@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 267 lines 9.74 KB
Raw
1 import {
2 DEFAULT_SERVER_SETTINGS,
3 ProjectId,
4 ProviderDriverKind,
5 ProviderInstanceId,
6 SecretProviderId,
7 SecretProviderKind,
8 type ServerSettings,
9 } from "@t3tools/contracts";
10 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
11 import * as NodeServices from "@effect/platform-node/NodeServices";
12 import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
13 import { it as effectIt } from "@effect/vitest";
14 import * as Effect from "effect/Effect";
15 import * as Layer from "effect/Layer";
16 import * as Queue from "effect/Queue";
17 import * as Stream from "effect/Stream";
18 import { describe, expect, it } from "vite-plus/test";
19
20 import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
21 import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
22 import * as ServerConfig from "../config.ts";
23 import * as PortScanner from "../preview/PortScanner.ts";
24 import { ServerSettingsService } from "../serverSettings.ts";
25 import {
26 DEV_REPLAY_INSTANCE_ID,
27 deriveProviderInstanceConfigMap,
28 layerSettingsWatcher,
29 providerHostLayer,
30 seedDevReplayInstance,
31 } from "./ProviderInstanceRegistryHydration.ts";
32 import * as ProviderHostLive from "./ProviderHostLive.ts";
33 import { ProviderInstanceRegistryMutator } from "./ProviderInstanceRegistryMutator.ts";
34
35 const projectId = ProjectId.make("project-a");
36 const instanceId = ProviderInstanceId.make("codex_work");
37
38 function settingsWith(overrides: Partial<ServerSettings>): ServerSettings {
39 return { ...DEFAULT_SERVER_SETTINGS, ...overrides };
40 }
41
42 describe("deriveProviderInstanceConfigMap", () => {
43 it("turns a machine-disabled instance on when a project enables it", () => {
44 const settings = settingsWith({
45 providerInstances: {
46 [instanceId]: { driver: ProviderDriverKind.make("codex"), enabled: false },
47 },
48 projectSettingsOverrides: {
49 [projectId]: { providerInstances: { [instanceId]: { enabled: true } } },
50 },
51 });
52
53 const merged = deriveProviderInstanceConfigMap(settings);
54
55 expect(merged[instanceId]).toEqual({ driver: ProviderDriverKind.make("codex"), enabled: true });
56 });
57
58 it("clears a nested config.enabled:false flag when a project enables the instance", () => {
59 const settings = settingsWith({
60 providerInstances: {
61 [instanceId]: {
62 driver: ProviderDriverKind.make("codex"),
63 config: { enabled: false },
64 },
65 },
66 projectSettingsOverrides: {
67 [projectId]: { providerInstances: { [instanceId]: { enabled: true } } },
68 },
69 });
70
71 const merged = deriveProviderInstanceConfigMap(settings);
72
73 expect(merged[instanceId]).toEqual({
74 driver: ProviderDriverKind.make("codex"),
75 enabled: true,
76 config: { enabled: true },
77 });
78 });
79
80 it("does not revive an instance a project override references but settings no longer configure", () => {
81 const settings = settingsWith({
82 providerInstances: {},
83 projectSettingsOverrides: {
84 [projectId]: { providerInstances: { [instanceId]: { enabled: true } } },
85 },
86 });
87
88 const merged = deriveProviderInstanceConfigMap(settings);
89
90 expect(merged[instanceId]).toBeUndefined();
91 });
92
93 it("ignores a project override that disables an instance, leaving the machine's config in charge", () => {
94 const settings = settingsWith({
95 providerInstances: {
96 [instanceId]: { driver: ProviderDriverKind.make("codex"), enabled: true },
97 },
98 projectSettingsOverrides: {
99 [projectId]: { providerInstances: { [instanceId]: { enabled: false } } },
100 },
101 });
102
103 const merged = deriveProviderInstanceConfigMap(settings);
104
105 expect(merged[instanceId]).toBe(settings.providerInstances[instanceId]);
106 });
107 });
108
109 describe("seedDevReplayInstance", () => {
110 const seed = (devUrl: URL | undefined) =>
111 Effect.gen(function* () {
112 const config = yield* ServerConfig.ServerConfig;
113 yield* seedDevReplayInstance().pipe(
114 Effect.provideService(ServerConfig.ServerConfig, { ...config, devUrl }),
115 );
116 const settings = yield* ServerSettingsService;
117 return (yield* settings.getSettings).providerInstances[DEV_REPLAY_INSTANCE_ID];
118 }).pipe(
119 Effect.provide(
120 Layer.mergeAll(
121 ServerConfig.layerTest(process.cwd(), { prefix: "t3-dev-replay-seed-" }),
122 ServerSettingsService.layerTest({
123 providerInstances: {
124 [DEV_REPLAY_INSTANCE_ID]: {
125 driver: ProviderDriverKind.make("acpRegistry"),
126 displayName: "My replay",
127 enabled: false,
128 config: { source: "local", commandPath: "/old/node" },
129 },
130 },
131 }),
132 ).pipe(Layer.provideMerge(NodeServices.layer)),
133 ),
134 );
135
136 effectIt.effect("leaves settings alone outside dev", () =>
137 seed(undefined).pipe(
138 Effect.map((instance) =>
139 expect(instance?.config).toEqual({ source: "local", commandPath: "/old/node" }),
140 ),
141 ),
142 );
143
144 effectIt.effect("points a dev server at the replay agent and keeps user edits", () =>
145 seed(new URL("http://localhost:5733")).pipe(
146 Effect.map((instance) => {
147 expect(instance?.displayName).toBe("My replay");
148 expect(instance?.enabled).toBe(false);
149 expect(instance?.config).toMatchObject({
150 source: "local",
151 commandArgs: [expect.stringMatching(/scripts[/\\]dev-replay-agent\.ts$/)],
152 });
153 }),
154 ),
155 );
156 });
157
158 describe("layerSettingsWatcher", () => {
159 const provider = (label: string) => ({
160 [SecretProviderId.make("personal")]: {
161 kind: SecretProviderKind.make("one_password"),
162 label,
163 config: { account: "my" },
164 },
165 });
166
167 const watch = (initial: ServerSettings | undefined) =>
168 Effect.gen(function* () {
169 const changes = yield* Queue.unbounded<ServerSettings>();
170 const reconciled = yield* Queue.unbounded<void>();
171 let reloads = 0;
172 const mutator = Layer.succeed(ProviderInstanceRegistryMutator, {
173 reconcile: () => Queue.offer(reconciled, undefined),
174 reloadSecrets: () => Effect.sync(() => void reloads++),
175 rebuild: () => Effect.void,
176 applySecret: () => Effect.succeed([]),
177 });
178 yield* Layer.build(
179 layerSettingsWatcher(Stream.fromQueue(changes), initial).pipe(Layer.provide(mutator)),
180 );
181 return {
182 reloads: () => reloads,
183 // Changes run one at a time, so the repeat's reconcile means the first one's reload decision is done.
184 change: (settings: ServerSettings) =>
185 Queue.offerAll(changes, [settings, settings]).pipe(
186 Effect.andThen(Queue.take(reconciled)),
187 Effect.andThen(Queue.take(reconciled)),
188 ),
189 };
190 });
191
192 effectIt.effect(
193 "retries unreadable secrets when a secret provider changes, not when it is renamed",
194 () =>
195 Effect.gen(function* () {
196 const settings = yield* ServerSettingsService;
197 const { reloads, change } = yield* watch(yield* settings.getSettings);
198
199 yield* change(yield* settings.updateSettings({ secretProviders: provider("Personal") }));
200 expect(reloads()).toBe(1);
201
202 // A label is not read by any vault, so renaming a provider retries nothing.
203 yield* change(yield* settings.updateSettings({ secretProviders: provider("Renamed") }));
204 expect(reloads()).toBe(1);
205 }).pipe(Effect.scoped, Effect.provide(ServerSettingsService.layerTest())),
206 );
207
208 effectIt.effect(
209 "compares a change queued during startup with the settings the registry started from",
210 () =>
211 Effect.gen(function* () {
212 const settings = yield* ServerSettingsService;
213 const started = yield* settings.getSettings;
214 const saved = yield* settings.updateSettings({ secretProviders: provider("Personal") });
215 const { reloads, change } = yield* watch(started);
216
217 yield* change(saved);
218
219 expect(reloads()).toBe(1);
220 }).pipe(Effect.scoped, Effect.provide(ServerSettingsService.layerTest())),
221 );
222 });
223
224 describe("providerHostLayer", () => {
225 const layerHostDeps = ServerConfig.layerTest(process.cwd(), {
226 prefix: "provider-host-hydration-test",
227 }).pipe(
228 Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
229 Layer.provideMerge(Layer.mock(ServerSecretStore.ServerSecretStore)({})),
230 Layer.provideMerge(Layer.mock(BackgroundPolicy.BackgroundPolicy)({})),
231 Layer.provideMerge(ServerSettingsService.layerTest()),
232 );
233
234 effectIt.effect(
235 "gives drivers trackAgent when a host without PortDiscovery was built first",
236 () =>
237 Effect.gen(function* () {
238 const seen = new Map<string, ProviderHost.ProviderHost["Service"]>();
239 const capture = (label: string) =>
240 Layer.effectDiscard(
241 Effect.map(ProviderHost.ProviderHost, (host) => {
242 seen.set(label, host);
243 }),
244 );
245 // Like server.ts: the ACP registry builds ProviderHostLive.layer before PortDiscovery exists.
246 const early = capture("early").pipe(
247 Layer.provide(ProviderHostLive.layer),
248 Layer.provide(layerHostDeps),
249 );
250 const hydrated = capture("hydrated").pipe(
251 Layer.provide(providerHostLayer),
252 Layer.provide(
253 Layer.mock(PortScanner.PortDiscovery)({ trackAgent: () => () => undefined }),
254 ),
255 Layer.provide(layerHostDeps),
256 );
257 // Build in order on one memo map, so a reused early host would fail the hydrated check.
258 const memoMap = yield* Layer.makeMemoMap;
259 const scope = yield* Effect.scope;
260 yield* Layer.buildWithMemoMap(early, memoMap, scope);
261 yield* Layer.buildWithMemoMap(hydrated, memoMap, scope);
262 expect(seen.size).toBe(2);
263 expect(seen.get("early")?.trackAgent).toBeUndefined();
264 expect(seen.get("hydrated")?.trackAgent).toBeTypeOf("function");
265 }),
266 );
267 });