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

main
tsx 134 lines 4.74 KB
Raw
1 import { type EnvironmentId, T3_PROJECT_FILE_NAME, type T3ProjectFile } from "@t3tools/contracts";
2 import { parseT3ProjectFile } from "@t3tools/shared/t3ProjectFile";
3 import { useAtomValue } from "@effect/atom-react";
4 import { AsyncResult, Atom } from "effect/reactivity";
5 import { useMessages } from "gt-react";
6 import { createContext, type ReactNode, useContext } from "react";
7
8 import { useEnvironments, usePrimaryEnvironmentId } from "../../state/environments";
9 import { getProjectFileQueryAtom, optimisticFileAtom } from "../files/projectFilesQueryState";
10 import { useSettingsProjectGroups } from "./useSettingsProjectGroups";
11 import {
12 applyPendingScopedWrites,
13 pendingScopedWritesAtom,
14 resolveScopedSettingsTargets,
15 selectScopedSettingsEnvironments,
16 } from "./scopedSettings";
17 import { resolveSettingsScope, type SettingsScopeSearch } from "./settingsScope";
18 import { selectSingleEnvironmentScope } from "./settingsScopeAxis";
19
20 type ProjectFileMember = readonly [
21 environmentId: EnvironmentId,
22 workspaceRoot: string,
23 physicalProjectKey: string,
24 ];
25
26 const memberProjectFilesAtom = Atom.family((membersKey: string) => {
27 const members = JSON.parse(membersKey) as ReadonlyArray<ProjectFileMember>;
28 return Atom.make((get) => {
29 const files = new Map<string, T3ProjectFile | null>();
30 for (const [environmentId, workspaceRoot, physicalProjectKey] of members) {
31 const result = get(
32 getProjectFileQueryAtom(environmentId, workspaceRoot, T3_PROJECT_FILE_NAME),
33 );
34 if (result.waiting) continue;
35 const data =
36 get(optimisticFileAtom(environmentId, workspaceRoot, T3_PROJECT_FILE_NAME))?.data ??
37 AsyncResult.getOrElse(result, () => null);
38 files.set(
39 physicalProjectKey,
40 data === null || data.exists === false || data.truncated
41 ? null
42 : parseT3ProjectFile(data.contents),
43 );
44 }
45 return files;
46 }).pipe(Atom.withLabel(`web-settings-member-project-files:${membersKey}`));
47 });
48
49 function useMemberProjectFiles(scope: ReturnType<typeof resolveSettingsScope>) {
50 const members = scope.kind === "project" || scope.kind === "checkout" ? scope.members : [];
51 return useAtomValue(
52 memberProjectFilesAtom(
53 JSON.stringify(
54 members.map((member): ProjectFileMember => [
55 member.environmentId,
56 member.workspaceRoot,
57 member.physicalProjectKey,
58 ]),
59 ),
60 ),
61 );
62 }
63
64 function useResolvedSettingsScope(rawSearch: SettingsScopeSearch, singleEnvironment: boolean) {
65 const groups = useSettingsProjectGroups();
66 const { environments: availableEnvironments } = useEnvironments();
67 const primaryEnvironmentId = usePrimaryEnvironmentId();
68 const m = useMessages();
69 const search = singleEnvironment
70 ? selectSingleEnvironmentScope(
71 rawSearch,
72 resolveSettingsScope(rawSearch, groups, availableEnvironments, m),
73 availableEnvironments,
74 primaryEnvironmentId,
75 )
76 : rawSearch;
77 const scope = resolveSettingsScope(search, groups, availableEnvironments, m);
78 const projectFiles = useMemberProjectFiles(scope);
79 const pendingWrites = useAtomValue(pendingScopedWritesAtom);
80 const selected = selectScopedSettingsEnvironments(
81 scope,
82 availableEnvironments,
83 primaryEnvironmentId,
84 );
85 const targets = resolveScopedSettingsTargets(
86 scope,
87 applyPendingScopedWrites(selected.connectedEnvironments, pendingWrites),
88 projectFiles,
89 );
90 const target =
91 targets.find((candidate) => candidate.environmentId === selected.environment?.environmentId) ??
92 targets[0] ??
93 null;
94 return { scope, groups, search, ...selected, targets, target };
95 }
96
97 const SettingsScopeContext = createContext<
98 | (ReturnType<typeof useResolvedSettingsScope> & {
99 singleEnvironment: boolean;
100 deviceOnly: boolean;
101 search: SettingsScopeSearch;
102 selectScope: (next: SettingsScopeSearch) => void;
103 })
104 | null
105 >(null);
106
107 export function SettingsScopeProvider({
108 search,
109 onChange,
110 children,
111 singleEnvironment = false,
112 deviceOnly = false,
113 }: {
114 singleEnvironment?: boolean;
115 /** The page hides the scope picker, so its client settings save for this device. */
116 deviceOnly?: boolean;
117 search: SettingsScopeSearch;
118 onChange: (next: SettingsScopeSearch) => void;
119 children: ReactNode;
120 }) {
121 const resolved = useResolvedSettingsScope(search, singleEnvironment);
122 const value = { ...resolved, singleEnvironment, deviceOnly, selectScope: onChange };
123 return <SettingsScopeContext value={value}>{children}</SettingsScopeContext>;
124 }
125
126 export function useOptionalSettingsScope() {
127 return useContext(SettingsScopeContext);
128 }
129
130 export function useSettingsScope() {
131 const scope = useOptionalSettingsScope();
132 if (scope === null) throw new Error("Settings scope must be read inside SettingsScopeProvider.");
133 return scope;
134 }