The best way to control Claude Code, Codex and more from any computer or phone

main
ts 151 lines 5.96 KB
Raw
1 import {
2 AVAILABLE_CONNECTION_STATE,
3 connectionProjectionPhase,
4 } from "@t3tools/client-runtime/connection";
5 import {
6 createEnvironmentShellAtoms,
7 createEnvironmentSnapshotAtom,
8 createShellEnvironmentAtoms,
9 type EnvironmentShellState,
10 type EnvironmentShellStatus,
11 } from "@t3tools/client-runtime/state/shell";
12 import {
13 type EnvironmentCatalogState,
14 enabledEnvironmentIds,
15 } from "@t3tools/client-runtime/state/connections";
16 import type { EnvironmentId } from "@t3tools/contracts";
17 import { useAtomValue } from "@effect/atom-react";
18 import * as Option from "effect/Option";
19 import { AsyncResult, Atom } from "effect/reactivity";
20
21 import { environmentCatalog } from "../connection/catalog";
22 import { connectionAtomRuntime } from "../connection/runtime";
23 import { isHostedStaticApp } from "../hostedPairing";
24 import { isLocalEnvironmentDisabled } from "../localEnvironment";
25
26 export const shellEnvironment = createShellEnvironmentAtoms(connectionAtomRuntime);
27 export const environmentShell = createEnvironmentShellAtoms(connectionAtomRuntime);
28 export const environmentSnapshotAtom = createEnvironmentSnapshotAtom(environmentShell.stateAtom);
29
30 const NO_SHELL_STATUS_ATOM = Atom.make<EnvironmentShellStatus | null>(null).pipe(
31 Atom.withLabel("web-environment-shell-status:none"),
32 );
33 const NO_SHELL_SNAPSHOT_ATOM = Atom.make(false).pipe(
34 Atom.withLabel("web-environment-shell-has-snapshot:none"),
35 );
36
37 export function useEnvironmentShellStatus(
38 environmentId: EnvironmentId | null,
39 ): EnvironmentShellStatus | null {
40 return useAtomValue(
41 environmentId === null ? NO_SHELL_STATUS_ATOM : environmentShell.statusAtom(environmentId),
42 );
43 }
44
45 export function useEnvironmentShellHasSnapshot(environmentId: EnvironmentId | null): boolean {
46 return useAtomValue(
47 environmentId === null
48 ? NO_SHELL_SNAPSHOT_ATOM
49 : environmentShell.hasSnapshotAtom(environmentId),
50 );
51 }
52
53 let previousLiveEnvironmentIds: ReadonlySet<EnvironmentId> = new Set();
54 /** Environments whose threads reflect the server now, not a cache or a resync in flight. */
55 export const liveShellEnvironmentIdsAtom = Atom.make((get) => {
56 const next = new Set<EnvironmentId>();
57 for (const environmentId of enabledEnvironmentIds(get(environmentCatalog.catalogValueAtom))) {
58 if (get(environmentShell.statusAtom(environmentId)) === "live") next.add(environmentId);
59 }
60 if (
61 next.size === previousLiveEnvironmentIds.size &&
62 [...next].every((environmentId) => previousLiveEnvironmentIds.has(environmentId))
63 ) {
64 return previousLiveEnvironmentIds;
65 }
66 previousLiveEnvironmentIds = next;
67 return next;
68 }).pipe(Atom.withLabel("web-live-shell-environment-ids"));
69
70 export const allEnvironmentShellsBootstrappedAtom = Atom.make((get) => {
71 const catalog = AsyncResult.value(get(environmentCatalog.catalogAtom));
72 if (Option.isNone(catalog)) {
73 return false;
74 }
75 for (const environmentId of enabledEnvironmentIds(catalog.value)) {
76 if (Option.isSome(get(environmentShell.stateValueAtom(environmentId)).snapshot)) {
77 continue;
78 }
79 const connection = AsyncResult.getOrElse(
80 get(environmentCatalog.stateAtom(environmentId)),
81 () => AVAILABLE_CONNECTION_STATE,
82 );
83 if (connectionProjectionPhase(connection) !== "disconnected") {
84 return false;
85 }
86 if (connection.phase === "backoff" && connection.desired && connection.attempt <= 2) {
87 return false;
88 }
89 }
90 return true;
91 }).pipe(Atom.withLabel("web-all-environment-shells-bootstrapped"));
92
93 // Catalog can precede primary discovery; an empty or incomplete catalog cannot prove absence.
94 function catalogIsComplete(
95 catalog: EnvironmentCatalogState,
96 requiresPrimaryEnvironment: boolean,
97 ): boolean {
98 if (!catalog.isReady || catalog.entries.size === 0) return false;
99 return (
100 !requiresPrimaryEnvironment ||
101 Array.from(catalog.entries.values()).some(
102 (entry) => entry.target._tag === "PrimaryConnectionTarget",
103 )
104 );
105 }
106
107 export function createAllEnvironmentProjectSnapshotsReadyAtom(input: {
108 readonly catalogValueAtom: Atom.Atom<EnvironmentCatalogState>;
109 readonly shellStateValueAtom: (environmentId: EnvironmentId) => Atom.Atom<EnvironmentShellState>;
110 readonly requiresPrimaryEnvironment: boolean;
111 }) {
112 return Atom.make((get) => {
113 const catalog = get(input.catalogValueAtom);
114 if (!catalogIsComplete(catalog, input.requiresPrimaryEnvironment)) return false;
115 for (const environmentId of enabledEnvironmentIds(catalog)) {
116 const shell = get(input.shellStateValueAtom(environmentId));
117 if (shell.status !== "live" || Option.isNone(shell.snapshot)) return false;
118 }
119 return true;
120 }).pipe(Atom.withLabel("web-all-environment-project-snapshots-ready"));
121 }
122
123 export const allEnvironmentProjectSnapshotsReadyAtom =
124 createAllEnvironmentProjectSnapshotsReadyAtom({
125 catalogValueAtom: environmentCatalog.catalogValueAtom,
126 shellStateValueAtom: environmentShell.stateValueAtom,
127 requiresPrimaryEnvironment: expectsPrimaryEnvironment(),
128 });
129
130 /** Hosted clients and desktops with the local environment disabled never discover a primary. */
131 export function expectsPrimaryEnvironment(): boolean {
132 return !isHostedStaticApp() && !isLocalEnvironmentDisabled();
133 }
134
135 export const allReachableShellsLiveAtom = Atom.make((get) => {
136 const catalog = get(environmentCatalog.catalogValueAtom);
137 if (!catalogIsComplete(catalog, expectsPrimaryEnvironment())) return false;
138 for (const environmentId of enabledEnvironmentIds(catalog)) {
139 const shell = get(environmentShell.stateValueAtom(environmentId));
140 if (shell.status === "live" && Option.isSome(shell.snapshot)) continue;
141 const state = AsyncResult.value(get(environmentCatalog.stateAtom(environmentId)));
142 if (Option.isNone(state)) return false;
143 const connection = state.value;
144 const settledOffline =
145 connection.phase === "offline" ||
146 connection.phase === "blocked" ||
147 (connection.phase === "backoff" && connection.attempt > 2);
148 if (!settledOffline) return false;
149 }
150 return true;
151 }).pipe(Atom.withLabel("web-all-reachable-shells-live"));