@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 1,033 lines 42.4 KB
Raw
1 import { describe, it, assert } from "@effect/vitest";
2 import {
3 DEFAULT_SERVER_SETTINGS,
4 ProviderDriverKind,
5 ProviderInstanceId,
6 ServerSettingsError,
7 type ServerProvider,
8 } from "@t3tools/contracts";
9 import { createModelCapabilities } from "@t3tools/shared/model";
10 import * as Cache from "effect/Cache";
11 import * as Deferred from "effect/Deferred";
12 import * as Effect from "effect/Effect";
13 import * as Fiber from "effect/Fiber";
14 import * as Layer from "effect/Layer";
15 import * as PubSub from "effect/PubSub";
16 import * as Ref from "effect/Ref";
17 import * as Stream from "effect/Stream";
18 import * as TestClock from "effect/testing/TestClock";
19
20 import * as ProviderHost from "./ProviderHost.ts";
21 import { makeManagedServerProvider } from "./managedProvider.ts";
22
23 const emptyCapabilities = createModelCapabilities({ optionDescriptors: [] });
24 const fastModeCapabilities = createModelCapabilities({
25 optionDescriptors: [
26 {
27 id: "fastMode",
28 label: "Fast Mode",
29 type: "boolean",
30 },
31 ],
32 });
33
34 interface TestSettings {
35 readonly enabled: boolean;
36 }
37
38 const maintenanceCapabilities = {
39 provider: ProviderDriverKind.make("codex"),
40 packageName: "@openai/codex",
41 update: {
42 command: "npm install -g @openai/codex@latest",
43
44 executable: "npm",
45
46 args: ["install", "-g", "@openai/codex@latest"],
47
48 lockKey: "npm-global",
49 },
50 } as const;
51
52 const initialSnapshot: ServerProvider = {
53 instanceId: ProviderInstanceId.make("codex"),
54 driver: ProviderDriverKind.make("codex"),
55 enabled: true,
56 installed: true,
57 version: null,
58 status: "warning",
59 auth: { status: "unknown" },
60 checkedAt: "2026-04-10T00:00:00.000Z",
61 message: "Checking provider availability...",
62 models: [],
63 slashCommands: [],
64 skills: [],
65 };
66
67 const refreshedSnapshot: ServerProvider = {
68 instanceId: ProviderInstanceId.make("codex"),
69 driver: ProviderDriverKind.make("codex"),
70 enabled: true,
71 installed: true,
72 version: "1.0.0",
73 status: "ready",
74 auth: { status: "authenticated" },
75 checkedAt: "2026-04-10T00:00:01.000Z",
76 models: [],
77 slashCommands: [],
78 skills: [],
79 };
80
81 const enrichedSnapshot: ServerProvider = {
82 ...refreshedSnapshot,
83 checkedAt: "2026-04-10T00:00:02.000Z",
84 models: [
85 {
86 slug: "composer-2",
87 name: "Composer 2",
88 isCustom: false,
89 capabilities: fastModeCapabilities,
90 },
91 ],
92 };
93
94 const refreshedSnapshotSecond: ServerProvider = {
95 ...refreshedSnapshot,
96 checkedAt: "2026-04-10T00:00:03.000Z",
97 message: "Refreshed provider availability again.",
98 };
99
100 function layerProviderHost(input: {
101 readonly runBackgroundWork: boolean;
102 readonly settings?: Pick<ProviderHost.ProviderHost["Service"], "settings">["settings"];
103 readonly awaitServerReady?: Effect.Effect<void>;
104 }) {
105 return Layer.succeed(
106 ProviderHost.ProviderHost,
107 ProviderHost.ProviderHost.of({
108 compatibility: () => Effect.undefined,
109 paths: {
110 cwd: process.cwd(),
111 baseDir: "/t3",
112 stateDir: "/t3/userdata",
113 providerStatusCacheDir: "/t3/caches",
114 attachmentsDir: "/t3/userdata/attachments",
115 },
116 settings: input.settings ?? {
117 get: Effect.succeed(DEFAULT_SERVER_SETTINGS),
118 withSnapshot: (use) => use(DEFAULT_SERVER_SETTINGS),
119 changes: Stream.empty,
120 subscribe: Effect.succeed(Stream.empty),
121 },
122 shouldRunBackgroundWork: () => Effect.succeed(input.runBackgroundWork),
123 ...(input.awaitServerReady ? { awaitServerReady: input.awaitServerReady } : {}),
124 resolveAttachmentPath: () => null,
125 credentials: () => Effect.die("unused"),
126 }),
127 );
128 }
129
130 const layerAlwaysRunTest = layerProviderHost({ runBackgroundWork: true });
131
132 const enrichedSnapshotSecond: ServerProvider = {
133 ...refreshedSnapshotSecond,
134 checkedAt: "2026-04-10T00:00:04.000Z",
135 models: [
136 {
137 slug: "gpt-5.4",
138 name: "GPT-5.4",
139 isCustom: false,
140 capabilities: emptyCapabilities,
141 },
142 ],
143 };
144
145 describe("makeManagedServerProvider", () => {
146 it.effect("invalidates cached usage and queues one refresh behind an in-flight refresh", () =>
147 Effect.scoped(
148 Effect.gen(function* () {
149 const calls = yield* Ref.make(0);
150 const probeStarted = yield* Deferred.make<void>();
151 const releaseProbe = yield* Deferred.make<void>();
152 const cache = yield* Cache.makeWith(
153 () =>
154 Effect.gen(function* () {
155 const count = yield* Ref.updateAndGet(calls, (count) => count + 1);
156 if (count === 2) {
157 yield* Deferred.succeed(probeStarted, undefined);
158 yield* Deferred.await(releaseProbe);
159 }
160 return {
161 ...refreshedSnapshot,
162 usageLimits: {
163 checkedAt: refreshedSnapshot.checkedAt,
164 windows: [
165 {
166 id: "five_hour",
167 kind: "session",
168 label: "Session",
169 usedPercent: count === 1 ? 20 : 100,
170 },
171 ],
172 },
173 } satisfies ServerProvider;
174 }),
175 { capacity: 1, timeToLive: () => "5 minutes" },
176 );
177 const warmed = yield* Cache.get(cache, "claude");
178 const provider = yield* makeManagedServerProvider<TestSettings>({
179 resolveMaintenance: () => Effect.die("usage refresh must not resolve maintenance"),
180 getSettings: Effect.succeed({ enabled: true }),
181 streamSettings: Stream.empty,
182 haveSettingsChanged: () => false,
183 initialSnapshot: () => Effect.succeed(warmed),
184 checkProvider: Cache.get(cache, "claude"),
185 invalidateUsageCache: Cache.invalidateAll(cache),
186 refreshOnInterval: false,
187 });
188 yield* provider.streamChanges.pipe(Stream.take(1), Stream.runDrain);
189 assert.strictEqual(yield* Ref.get(calls), 1);
190 const refresh = yield* provider.refreshUsage!.pipe(Effect.forkChild);
191 yield* Deferred.await(probeStarted);
192 const queued = yield* provider.refreshUsage!.pipe(
193 Effect.forkChild({ startImmediately: true }),
194 );
195 yield* provider.refreshUsage!;
196 assert.strictEqual(yield* Ref.get(calls), 2);
197 assert.strictEqual((yield* provider.getSnapshot).usageLimits?.windows[0]?.usedPercent, 20);
198 yield* Deferred.succeed(releaseProbe, undefined);
199 yield* Fiber.join(refresh);
200 yield* Fiber.join(queued);
201 assert.strictEqual(yield* Ref.get(calls), 3);
202 assert.strictEqual((yield* provider.getSnapshot).usageLimits?.windows[0]?.usedPercent, 100);
203 }),
204 ).pipe(Effect.provide(layerAlwaysRunTest)),
205 );
206 it.effect("keeps the waiting usage refresh's claim when the running one is interrupted", () =>
207 Effect.scoped(
208 Effect.gen(function* () {
209 const calls = yield* Ref.make(0);
210 const usageProbeStarted = yield* Deferred.make<void>();
211 const statusProbeStarted = yield* Deferred.make<void>();
212 const releaseStatusProbe = yield* Deferred.make<void>();
213 const provider = yield* makeManagedServerProvider<TestSettings>({
214 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
215 getSettings: Effect.succeed({ enabled: true }),
216 streamSettings: Stream.empty,
217 haveSettingsChanged: () => false,
218 initialSnapshot: () => Effect.succeed(initialSnapshot),
219 checkProvider: Effect.gen(function* () {
220 const count = yield* Ref.updateAndGet(calls, (count) => count + 1);
221 if (count === 2) {
222 yield* Deferred.succeed(usageProbeStarted, undefined);
223 return yield* Effect.never;
224 }
225 if (count === 3) {
226 yield* Deferred.succeed(statusProbeStarted, undefined);
227 yield* Deferred.await(releaseStatusProbe);
228 }
229 return {
230 ...refreshedSnapshot,
231 usageLimits: { checkedAt: refreshedSnapshot.checkedAt, windows: [] },
232 } satisfies ServerProvider;
233 }),
234 refreshOnInterval: false,
235 });
236 yield* provider.streamChanges.pipe(Stream.take(1), Stream.runDrain);
237 const running = yield* provider.refreshUsage!.pipe(Effect.forkChild);
238 yield* Deferred.await(usageProbeStarted);
239 const status = yield* provider.refresh.pipe(Effect.forkChild({ startImmediately: true }));
240 const waiting = yield* provider.refreshUsage!.pipe(
241 Effect.forkChild({ startImmediately: true }),
242 );
243 yield* Fiber.interrupt(running);
244 yield* Deferred.await(statusProbeStarted);
245 const extra = yield* provider.refreshUsage!.pipe(
246 Effect.forkChild({ startImmediately: true }),
247 );
248 yield* Deferred.succeed(releaseStatusProbe, undefined);
249 yield* Fiber.join(status);
250 yield* Fiber.join(waiting);
251 yield* Fiber.join(extra);
252 assert.strictEqual(yield* Ref.get(calls), 4);
253 }),
254 ).pipe(Effect.provide(layerAlwaysRunTest)),
255 );
256 it.effect(
257 "runs the initial provider check in the background and streams the refreshed snapshot",
258 () =>
259 Effect.scoped(
260 Effect.gen(function* () {
261 const checkCalls = yield* Ref.make(0);
262 const releaseCheck = yield* Deferred.make<void>();
263 const provider = yield* makeManagedServerProvider<TestSettings>({
264 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
265 getSettings: Effect.succeed({ enabled: true }),
266 streamSettings: Stream.empty,
267 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
268 initialSnapshot: () => Effect.succeed(initialSnapshot),
269 checkProvider: Ref.update(checkCalls, (count) => count + 1).pipe(
270 Effect.flatMap(() => Deferred.await(releaseCheck)),
271 Effect.as(refreshedSnapshot),
272 ),
273 refreshInterval: "1 hour",
274 });
275
276 const initial = yield* provider.getSnapshot;
277 assert.deepStrictEqual(initial, initialSnapshot);
278 assert.strictEqual(yield* provider.isAwaitingFirstCheck!, true);
279
280 const updatesFiber = yield* Stream.take(provider.streamChanges, 1).pipe(
281 Stream.runCollect,
282 Effect.forkChild,
283 );
284 yield* Effect.yieldNow;
285 assert.strictEqual(yield* Ref.get(checkCalls), 1);
286
287 yield* Deferred.succeed(releaseCheck, undefined);
288
289 const updates = Array.from(yield* Fiber.join(updatesFiber));
290 const latest = yield* provider.getSnapshot;
291
292 assert.deepStrictEqual(updates, [refreshedSnapshot]);
293 assert.deepStrictEqual(latest, refreshedSnapshot);
294 assert.strictEqual(yield* provider.isAwaitingFirstCheck!, false);
295 assert.strictEqual(yield* Ref.get(checkCalls), 1);
296 }),
297 ).pipe(Effect.provide(layerAlwaysRunTest)),
298 );
299
300 it.effect("holds the first provider check until server startup finishes", () =>
301 Effect.gen(function* () {
302 const serverReady = yield* Deferred.make<void>();
303 const checkStarted = yield* Deferred.make<void>();
304 const checkCalls = yield* Ref.make(0);
305 yield* Effect.scoped(
306 Effect.gen(function* () {
307 const provider = yield* makeManagedServerProvider<TestSettings>({
308 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
309 getSettings: Effect.succeed({ enabled: true }),
310 streamSettings: Stream.empty,
311 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
312 initialSnapshot: () => Effect.succeed(initialSnapshot),
313 checkProvider: Ref.update(checkCalls, (count) => count + 1).pipe(
314 Effect.andThen(Deferred.succeed(checkStarted, undefined)),
315 Effect.as(refreshedSnapshot),
316 ),
317 refreshInterval: "1 hour",
318 });
319
320 yield* TestClock.adjust("10 seconds");
321 assert.strictEqual(yield* Ref.get(checkCalls), 0);
322 assert.deepStrictEqual(yield* provider.getSnapshot, initialSnapshot);
323 assert.isTrue(yield* provider.isAwaitingFirstCheck!);
324
325 yield* Deferred.succeed(serverReady, undefined);
326 yield* Deferred.await(checkStarted);
327 assert.strictEqual(yield* Ref.get(checkCalls), 1);
328 }),
329 ).pipe(
330 Effect.provide(
331 Layer.mergeAll(
332 layerProviderHost({
333 runBackgroundWork: false,
334 awaitServerReady: Deferred.await(serverReady),
335 }),
336 TestClock.layer(),
337 ),
338 ),
339 );
340 }),
341 );
342
343 it.effect("skips periodic provider refreshes without foreground provider-status demand", () =>
344 Effect.scoped(
345 Effect.gen(function* () {
346 const checkCalls = yield* Ref.make(0);
347 const initialCheckDone = yield* Deferred.make<void>();
348 yield* makeManagedServerProvider<TestSettings>({
349 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
350 getSettings: Effect.succeed({ enabled: true }),
351 streamSettings: Stream.empty,
352 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
353 refreshOnInterval: () => true,
354 initialSnapshot: () => Effect.succeed(initialSnapshot),
355 checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
356 Effect.tap((count) =>
357 count === 1
358 ? Deferred.succeed(initialCheckDone, undefined).pipe(Effect.ignore)
359 : Effect.void,
360 ),
361 Effect.as(refreshedSnapshot),
362 ),
363 refreshInterval: "1 second",
364 });
365
366 yield* Deferred.await(initialCheckDone);
367 yield* TestClock.adjust("1 second");
368 yield* Effect.yieldNow;
369
370 assert.strictEqual(yield* Ref.get(checkCalls), 1);
371 }),
372 ).pipe(
373 Effect.provide(
374 Layer.mergeAll(layerProviderHost({ runBackgroundWork: false }), TestClock.layer()),
375 ),
376 ),
377 );
378
379 it.effect("stops periodic recovery checks once the snapshot is ready", () =>
380 Effect.scoped(
381 Effect.gen(function* () {
382 const checkCalls = yield* Ref.make(0);
383 const releaseInitialCheck = yield* Deferred.make<void>();
384 const failedSnapshot = { ...refreshedSnapshot, status: "error" as const };
385 const provider = yield* makeManagedServerProvider<TestSettings>({
386 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
387 getSettings: Effect.succeed({ enabled: true }),
388 streamSettings: Stream.empty,
389 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
390 refreshOnInterval: (snapshot) => snapshot.status === "error",
391 initialSnapshot: () => Effect.succeed(initialSnapshot),
392 checkProvider: Deferred.await(releaseInitialCheck).pipe(
393 Effect.andThen(Ref.updateAndGet(checkCalls, (count) => count + 1)),
394 Effect.map((count) => (count === 1 ? failedSnapshot : refreshedSnapshot)),
395 ),
396 refreshInterval: "1 second",
397 });
398 const updates = yield* provider.streamChanges.pipe(
399 Stream.take(2),
400 Stream.runCollect,
401 Effect.forkChild,
402 );
403 yield* Effect.yieldNow;
404 yield* Deferred.succeed(releaseInitialCheck, undefined);
405 yield* TestClock.adjust("1 second");
406
407 assert.deepStrictEqual(Array.from(yield* Fiber.join(updates)), [
408 failedSnapshot,
409 refreshedSnapshot,
410 ]);
411 yield* TestClock.adjust("3 seconds");
412 assert.strictEqual(yield* Ref.get(checkCalls), 2);
413 }),
414 ).pipe(Effect.provide(Layer.mergeAll(layerAlwaysRunTest, TestClock.layer()))),
415 );
416
417 it.effect("rechecks a ready provider after one failed periodic check before publishing it", () =>
418 Effect.scoped(
419 Effect.gen(function* () {
420 const checkCalls = yield* Ref.make(0);
421 const initialCheckDone = yield* Deferred.make<void>();
422 const failedSnapshot: ServerProvider = {
423 ...refreshedSnapshot,
424 status: "error",
425 auth: { status: "unknown" },
426 message: "Codex app-server provider probe failed: workspace routing discovery timed out.",
427 };
428 const provider = yield* makeManagedServerProvider<TestSettings>({
429 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
430 getSettings: Effect.succeed({ enabled: true }),
431 streamSettings: Stream.empty,
432 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
433 initialSnapshot: () => Effect.succeed(initialSnapshot),
434 checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
435 Effect.tap((count) =>
436 count === 1
437 ? Deferred.succeed(initialCheckDone, undefined).pipe(Effect.ignore)
438 : Effect.void,
439 ),
440 Effect.map((count) => (count === 2 ? failedSnapshot : refreshedSnapshot)),
441 ),
442 refreshInterval: "5 minutes",
443 });
444 yield* Deferred.await(initialCheckDone);
445 const published = yield* Ref.make<ReadonlyArray<ServerProvider>>([]);
446 yield* provider.streamChanges.pipe(
447 Stream.runForEach((snapshot) => Ref.update(published, (all) => [...all, snapshot])),
448 Effect.forkChild,
449 );
450 yield* Effect.yieldNow;
451
452 yield* TestClock.adjust("5 minutes");
453 yield* TestClock.adjust("1 minute");
454
455 assert.strictEqual((yield* provider.getSnapshot).status, "ready");
456 assert.deepStrictEqual(
457 (yield* Ref.get(published)).filter((snapshot) => snapshot.status === "error"),
458 [],
459 );
460 }),
461 ).pipe(Effect.provide(Layer.mergeAll(layerAlwaysRunTest, TestClock.layer()))),
462 );
463
464 it.effect("reruns the provider check when streamed settings change", () =>
465 Effect.scoped(
466 Effect.gen(function* () {
467 const settingsRef = yield* Ref.make<TestSettings>({ enabled: true });
468 const settingsChanges = yield* PubSub.unbounded<TestSettings>();
469 const checkCalls = yield* Ref.make(0);
470 const releaseInitialCheck = yield* Deferred.make<void>();
471 const releaseSettingsCheck = yield* Deferred.make<void>();
472 const provider = yield* makeManagedServerProvider<TestSettings>({
473 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
474 getSettings: Ref.get(settingsRef),
475 streamSettings: Stream.fromPubSub(settingsChanges),
476 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
477 initialSnapshot: () => Effect.succeed(initialSnapshot),
478 checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
479 Effect.flatMap((count) =>
480 count === 1
481 ? Deferred.await(releaseInitialCheck).pipe(Effect.as(refreshedSnapshot))
482 : Deferred.await(releaseSettingsCheck).pipe(Effect.as(refreshedSnapshotSecond)),
483 ),
484 ),
485 refreshInterval: "1 hour",
486 });
487
488 const updatesFiber = yield* Stream.take(provider.streamChanges, 2).pipe(
489 Stream.runCollect,
490 Effect.forkChild,
491 );
492 yield* Effect.yieldNow;
493
494 yield* Deferred.succeed(releaseInitialCheck, undefined);
495 yield* Ref.set(settingsRef, { enabled: false });
496 yield* PubSub.publish(settingsChanges, { enabled: false });
497 yield* Deferred.succeed(releaseSettingsCheck, undefined);
498
499 const updates = Array.from(yield* Fiber.join(updatesFiber));
500 const latest = yield* provider.getSnapshot;
501
502 assert.deepStrictEqual(updates, [refreshedSnapshot, refreshedSnapshotSecond]);
503 assert.deepStrictEqual(latest, refreshedSnapshotSecond);
504 assert.strictEqual(yield* Ref.get(checkCalls), 2);
505 }),
506 ).pipe(Effect.provide(layerAlwaysRunTest)),
507 );
508
509 it.effect("keeps consuming settings changes after a provider check fails", () =>
510 Effect.scoped(
511 Effect.gen(function* () {
512 const settingsChanges = yield* PubSub.unbounded<TestSettings>();
513 const checkCalls = yield* Ref.make(0);
514 const releaseInitialCheck = yield* Deferred.make<void>();
515 const thirdCheckStarted = yield* Deferred.make<void>();
516 const releaseRecoveredCheck = yield* Deferred.make<void>();
517 const provider = yield* makeManagedServerProvider<TestSettings>({
518 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
519 getSettings: Effect.succeed({ enabled: true }),
520 streamSettings: Stream.fromPubSub(settingsChanges),
521 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
522 initialSnapshot: () => Effect.succeed(initialSnapshot),
523 checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
524 Effect.flatMap((count) =>
525 count === 1
526 ? Deferred.await(releaseInitialCheck).pipe(Effect.as(refreshedSnapshot))
527 : count === 2
528 ? Effect.fail(
529 new ServerSettingsError({
530 settingsPath: "/t3/userdata/settings.json",
531 operation: "read-file",
532 }),
533 )
534 : Deferred.succeed(thirdCheckStarted, undefined).pipe(
535 Effect.andThen(Deferred.await(releaseRecoveredCheck)),
536 Effect.as(refreshedSnapshotSecond),
537 ),
538 ),
539 ),
540 refreshInterval: "1 hour",
541 });
542
543 const updatesFiber = yield* Stream.take(provider.streamChanges, 2).pipe(
544 Stream.runCollect,
545 Effect.forkChild,
546 );
547 yield* Effect.yieldNow;
548 yield* Deferred.succeed(releaseInitialCheck, undefined);
549
550 // The first change fails its provider check; the failed application never
551 // advances the stored settings, so the same change still differs next time.
552 yield* PubSub.publish(settingsChanges, { enabled: false });
553 yield* Effect.yieldNow;
554 assert.strictEqual(yield* Ref.get(checkCalls), 2);
555
556 // The subscription must survive that failure and retry on the next change;
557 // on main the dead consumer never starts the third check and this times out.
558 yield* PubSub.publish(settingsChanges, { enabled: false });
559 yield* Deferred.await(thirdCheckStarted);
560 assert.strictEqual(yield* Ref.get(checkCalls), 3);
561 yield* Deferred.succeed(releaseRecoveredCheck, undefined);
562
563 const updates = Array.from(yield* Fiber.join(updatesFiber));
564 assert.deepStrictEqual(updates, [refreshedSnapshot, refreshedSnapshotSecond]);
565 assert.deepStrictEqual(yield* provider.getSnapshot, refreshedSnapshotSecond);
566 }),
567 ).pipe(Effect.provide(layerAlwaysRunTest)),
568 );
569
570 it.effect(
571 "rechecks an auth failure when settings are applied, even if this provider's did not change",
572 () =>
573 Effect.scoped(
574 Effect.gen(function* () {
575 const settingsChanges = yield* PubSub.unbounded<
576 TestSettings & { readonly revision: number }
577 >();
578 const checkCalls = yield* Ref.make(0);
579 const seenRevisions: Array<number> = [];
580 const releaseInitialCheck = yield* Deferred.make<void>();
581 const markerApplied = yield* Deferred.make<void>();
582 const unauthenticatedSnapshot: ServerProvider = {
583 ...refreshedSnapshot,
584 status: "error",
585 auth: { status: "unauthenticated" },
586 message: "Codex CLI is not authenticated. Run `codex login` and try again.",
587 };
588 const provider = yield* makeManagedServerProvider<
589 TestSettings & { readonly revision: number }
590 >({
591 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
592 getSettings: Effect.succeed({ enabled: true, revision: 0 }),
593 streamSettings: Stream.fromPubSub(settingsChanges),
594 haveSettingsChanged: (previous, next) => {
595 seenRevisions.push(next.revision);
596 if (next.revision === 2) Deferred.doneUnsafe(markerApplied, Effect.void);
597 return previous.enabled !== next.enabled;
598 },
599 initialSnapshot: () => Effect.succeed(initialSnapshot),
600 // The credential is fixed (e.g. `codex login`) after the first, failed probe.
601 checkProvider: Deferred.await(releaseInitialCheck).pipe(
602 Effect.andThen(Ref.updateAndGet(checkCalls, (count) => count + 1)),
603 Effect.map((count) => (count === 1 ? unauthenticatedSnapshot : refreshedSnapshot)),
604 ),
605 refreshInterval: "1 hour",
606 });
607 const initialProbe = yield* provider.streamChanges.pipe(
608 Stream.take(1),
609 Stream.runDrain,
610 Effect.forkChild,
611 );
612 yield* Effect.yieldNow;
613 yield* Deferred.succeed(releaseInitialCheck, undefined);
614 yield* Fiber.join(initialProbe);
615 assert.deepStrictEqual(yield* provider.getSnapshot, unauthenticatedSnapshot);
616
617 // A settings apply that does not touch this provider's settings, then a marker:
618 // the consumer is sequential, so the first apply has finished once the marker is seen.
619 yield* PubSub.publish(settingsChanges, { enabled: true, revision: 1 });
620 yield* PubSub.publish(settingsChanges, { enabled: true, revision: 2 });
621 yield* Deferred.await(markerApplied);
622
623 assert.deepStrictEqual(seenRevisions, [1, 2]);
624 assert.isAtLeast(yield* Ref.get(checkCalls), 2);
625 assert.deepStrictEqual((yield* provider.getSnapshot).auth, refreshedSnapshot.auth);
626 }),
627 ).pipe(Effect.provide(layerAlwaysRunTest)),
628 );
629
630 it.effect("streams supplemental snapshot updates after the base provider check completes", () =>
631 Effect.scoped(
632 Effect.gen(function* () {
633 const releaseEnrichment = yield* Deferred.make<void>();
634 const releaseCheck = yield* Deferred.make<void>();
635 const provider = yield* makeManagedServerProvider<TestSettings>({
636 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
637 getSettings: Effect.succeed({ enabled: true }),
638 streamSettings: Stream.empty,
639 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
640 initialSnapshot: () => Effect.succeed(initialSnapshot),
641 checkProvider: Deferred.await(releaseCheck).pipe(Effect.as(refreshedSnapshot)),
642 enrichSnapshot: ({ publishSnapshot }) =>
643 Deferred.await(releaseEnrichment).pipe(
644 Effect.flatMap(() => publishSnapshot(enrichedSnapshot)),
645 ),
646 refreshInterval: "1 hour",
647 });
648
649 const updatesFiber = yield* Stream.take(provider.streamChanges, 2).pipe(
650 Stream.runCollect,
651 Effect.forkChild,
652 );
653 yield* Effect.yieldNow;
654
655 yield* Deferred.succeed(releaseCheck, undefined);
656
657 yield* Deferred.succeed(releaseEnrichment, undefined);
658
659 const updates = Array.from(yield* Fiber.join(updatesFiber));
660 const latest = yield* provider.getSnapshot;
661
662 assert.deepStrictEqual(updates, [refreshedSnapshot, enrichedSnapshot]);
663 assert.deepStrictEqual(latest, enrichedSnapshot);
664 }),
665 ).pipe(Effect.provide(layerAlwaysRunTest)),
666 );
667
668 it.effect("ignores stale enrichment callbacks after a newer refresh advances generation", () =>
669 Effect.scoped(
670 Effect.gen(function* () {
671 const publishCallbacks: Array<(snapshot: ServerProvider) => Effect.Effect<void>> = [];
672 const refreshCount = yield* Ref.make(0);
673 const firstCallbackReady = yield* Deferred.make<void>();
674 const secondCallbackReady = yield* Deferred.make<void>();
675 const allowFirstRefresh = yield* Deferred.make<void>();
676 const provider = yield* makeManagedServerProvider<TestSettings>({
677 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
678 getSettings: Effect.succeed({ enabled: true }),
679 streamSettings: Stream.empty,
680 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
681 initialSnapshot: () => Effect.succeed(initialSnapshot),
682 checkProvider: Ref.updateAndGet(refreshCount, (count) => count + 1).pipe(
683 Effect.flatMap((count) =>
684 count === 1
685 ? Deferred.await(allowFirstRefresh).pipe(Effect.as(refreshedSnapshot))
686 : Effect.succeed(refreshedSnapshotSecond),
687 ),
688 ),
689 enrichSnapshot: ({ publishSnapshot }) =>
690 Effect.gen(function* () {
691 publishCallbacks.push(publishSnapshot);
692 if (publishCallbacks.length === 1) {
693 yield* Deferred.succeed(firstCallbackReady, undefined).pipe(Effect.ignore);
694 } else if (publishCallbacks.length === 2) {
695 yield* Deferred.succeed(secondCallbackReady, undefined).pipe(Effect.ignore);
696 }
697 }),
698 refreshInterval: "1 hour",
699 });
700
701 const updatesFiber = yield* Stream.take(provider.streamChanges, 3).pipe(
702 Stream.runCollect,
703 Effect.forkChild,
704 );
705 yield* Effect.yieldNow;
706
707 yield* Deferred.succeed(allowFirstRefresh, undefined);
708 yield* Deferred.await(firstCallbackReady);
709
710 yield* provider.refresh;
711 yield* Deferred.await(secondCallbackReady);
712
713 yield* publishCallbacks[0]!(enrichedSnapshot);
714 yield* publishCallbacks[1]!(enrichedSnapshotSecond);
715
716 const updates = Array.from(yield* Fiber.join(updatesFiber));
717 const latest = yield* provider.getSnapshot;
718
719 assert.deepStrictEqual(updates, [
720 refreshedSnapshot,
721 refreshedSnapshotSecond,
722 enrichedSnapshotSecond,
723 ]);
724 assert.deepStrictEqual(latest, enrichedSnapshotSecond);
725 }),
726 ).pipe(Effect.provide(layerAlwaysRunTest)),
727 );
728
729 it.effect("applies runtime usage updates onto the published snapshot", () =>
730 Effect.scoped(
731 Effect.gen(function* () {
732 const provider = yield* makeManagedServerProvider<TestSettings>({
733 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
734 getSettings: Effect.succeed({ enabled: true }),
735 streamSettings: Stream.empty,
736 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
737 initialSnapshot: () => Effect.succeed(initialSnapshot),
738 checkProvider: Effect.succeed({
739 ...refreshedSnapshot,
740 usageLimits: {
741 checkedAt: "2026-04-10T00:00:01.000Z",
742 windows: [
743 { id: "five_hour", kind: "session", label: "Session", usedPercent: 10 },
744 {
745 id: "seven_day",
746 kind: "weekly",
747 label: "Weekly",
748 usedPercent: 20,
749 resetsAt: "2026-04-17T00:00:00.000Z",
750 },
751 ],
752 },
753 } satisfies ServerProvider),
754 refreshInterval: "1 hour",
755 });
756 yield* Stream.take(provider.streamChanges, 1).pipe(Stream.runDrain);
757
758 const updatesFiber = yield* Stream.take(provider.streamChanges, 1).pipe(
759 Stream.runCollect,
760 Effect.forkChild,
761 );
762 yield* Effect.yieldNow;
763
764 yield* provider.applyUsageLimits({
765 checkedAt: "2026-04-10T00:05:00.000Z",
766 windows: [{ id: "seven_day", kind: "weekly", label: "Weekly", usedPercent: 25 }],
767 authLabel: "tier-1",
768 });
769 yield* provider.applyUsageLimits({
770 checkedAt: "2026-04-10T00:06:00.000Z",
771 windows: [],
772 authLabel: "tier-2",
773 });
774
775 const [update] = Array.from(yield* Fiber.join(updatesFiber));
776 assert.strictEqual(update?.auth.label, "tier-1");
777 assert.deepStrictEqual(update?.usageLimits, {
778 checkedAt: "2026-04-10T00:05:00.000Z",
779 windows: [
780 { id: "five_hour", kind: "session", label: "Session", usedPercent: 10 },
781 {
782 id: "seven_day",
783 kind: "weekly",
784 label: "Weekly",
785 usedPercent: 25,
786 resetsAt: "2026-04-17T00:00:00.000Z",
787 },
788 ],
789 });
790 assert.deepStrictEqual(yield* provider.getSnapshot, update);
791 }),
792 ).pipe(Effect.provide(layerAlwaysRunTest)),
793 );
794
795 it.effect.each([
796 { name: "a live plan", clearPlan: false },
797 { name: "a cleared plan", clearPlan: true },
798 ])("keeps $name and usage across a failed probe and stale enrichment", ({ clearPlan }) =>
799 Effect.scoped(
800 Effect.gen(function* () {
801 const releaseEnrichment = yield* Deferred.make<void>();
802 const refreshCount = yield* Ref.make(0);
803 const probedLimits = {
804 checkedAt: "2026-04-10T00:00:01.000Z",
805 windows: [{ id: "primary", kind: "session", label: "Session", usedPercent: 10 }],
806 } as const;
807 const provider = yield* makeManagedServerProvider<TestSettings>({
808 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
809 getSettings: Effect.succeed({ enabled: true }),
810 streamSettings: Stream.empty,
811 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
812 initialSnapshot: () => Effect.succeed(initialSnapshot),
813 checkProvider: Ref.updateAndGet(refreshCount, (count) => count + 1).pipe(
814 Effect.map((count) =>
815 count === 1
816 ? {
817 ...refreshedSnapshot,
818 auth: { ...refreshedSnapshot.auth, workspaceId: "ws-a", label: "tier-1" },
819 usageLimits: probedLimits,
820 }
821 : {
822 ...refreshedSnapshotSecond,
823 ...(count === 3
824 ? { auth: { ...refreshedSnapshotSecond.auth, workspaceId: "ws-b" } }
825 : {}),
826 usageLimits: {
827 checkedAt: "2026-04-10T00:00:03.000Z",
828 windows: [],
829 unavailable: { reason: "probeFailed" },
830 },
831 },
832 ),
833 ),
834 enrichSnapshot: ({ snapshot, publishSnapshot }) =>
835 Deferred.await(releaseEnrichment).pipe(
836 Effect.flatMap(() =>
837 publishSnapshot({
838 ...enrichedSnapshot,
839 ...snapshot,
840 models: enrichedSnapshot.models,
841 }),
842 ),
843 ),
844 refreshInterval: "1 hour",
845 });
846 yield* Stream.take(provider.streamChanges, 1).pipe(Stream.runDrain);
847
848 const liveWindow = {
849 id: "primary",
850 kind: "session",
851 label: "Session",
852 usedPercent: 60,
853 } as const;
854 yield* provider.applyUsageLimits({
855 checkedAt: "2026-04-10T00:00:02.000Z",
856 authLabel: "tier-2",
857 windows: [liveWindow],
858 });
859
860 if (clearPlan) {
861 yield* provider.applyUsageLimits({
862 checkedAt: "2026-04-10T00:00:02.000Z",
863 complete: true,
864 windows: [liveWindow],
865 });
866 }
867
868 yield* Deferred.succeed(releaseEnrichment, undefined);
869 const enriched = yield* Stream.take(provider.streamChanges, 1).pipe(
870 Stream.runCollect,
871 Effect.map((chunk) => Array.from(chunk)[0]!),
872 );
873 assert.deepStrictEqual(enriched.models, enrichedSnapshot.models);
874 assert.deepStrictEqual(enriched.usageLimits?.windows, [liveWindow]);
875 assert.strictEqual(enriched.auth.label, clearPlan ? undefined : "tier-2");
876
877 const refreshed = yield* provider.refresh;
878 assert.strictEqual(refreshed.message, refreshedSnapshotSecond.message);
879 assert.deepStrictEqual(refreshed.usageLimits?.windows, [liveWindow]);
880 assert.strictEqual(refreshed.auth.workspaceId, "ws-a");
881 assert.strictEqual(refreshed.auth.label, clearPlan ? undefined : "tier-2");
882
883 const switched = yield* provider.refresh;
884 assert.strictEqual(switched.auth.workspaceId, "ws-b");
885 assert.strictEqual(switched.usageLimits?.unavailable?.reason, "probeFailed");
886 }),
887 ).pipe(Effect.provide(layerAlwaysRunTest)),
888 );
889
890 it.effect.each([
891 { name: "an empty reading", hasUsage: true, clearPlan: false },
892 { name: "no reading", hasUsage: false, clearPlan: false },
893 { name: "an empty reading after clearing the plan", hasUsage: true, clearPlan: true },
894 { name: "no reading after clearing the plan", hasUsage: false, clearPlan: true },
895 ])("keeps the live plan and limits after $name", ({ hasUsage, clearPlan }) =>
896 Effect.scoped(
897 Effect.gen(function* () {
898 const started = yield* Deferred.make<void>();
899 const release = yield* Deferred.make<void>();
900 const count = yield* Ref.make(0);
901 const provider = yield* makeManagedServerProvider<TestSettings>({
902 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
903 getSettings: Effect.succeed({ enabled: true }),
904 streamSettings: Stream.empty,
905 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
906 initialSnapshot: () => Effect.succeed(initialSnapshot),
907 checkProvider: Effect.gen(function* () {
908 if ((yield* Ref.updateAndGet(count, (n) => n + 1)) > 1) {
909 yield* Deferred.succeed(started, undefined);
910 yield* Deferred.await(release);
911 }
912 return {
913 ...refreshedSnapshot,
914 auth: { status: "authenticated", label: "tier-1" },
915 ...(hasUsage
916 ? { usageLimits: { checkedAt: refreshedSnapshot.checkedAt, windows: [] } }
917 : {}),
918 } satisfies ServerProvider;
919 }),
920 });
921 yield* Stream.take(provider.streamChanges, 1).pipe(Stream.runDrain);
922 const refresh = yield* provider.refresh.pipe(Effect.forkChild);
923 yield* Deferred.await(started);
924 yield* provider.applyUsageLimits({
925 checkedAt: "2026-04-10T00:00:04.000Z",
926 authLabel: "tier-2",
927 complete: true,
928 windows: [{ id: "session", kind: "session", label: "Session", usedPercent: 70 }],
929 });
930 if (clearPlan) {
931 yield* provider.applyUsageLimits({
932 checkedAt: "2026-04-10T00:00:04.000Z",
933 complete: true,
934 windows: [{ id: "session", kind: "session", label: "Session", usedPercent: 70 }],
935 });
936 }
937 yield* Deferred.succeed(release, undefined);
938 const refreshed = yield* Fiber.join(refresh);
939 assert.strictEqual(refreshed.auth.label, clearPlan ? undefined : "tier-2");
940 assert.strictEqual(refreshed.usageLimits?.windows[0]?.usedPercent, 70);
941 assert.strictEqual(refreshed.usageLimits?.unavailable, undefined);
942 }),
943 ).pipe(Effect.provide(layerAlwaysRunTest)),
944 );
945
946 it.effect("drops an earlier plan override after a complete reading without a label", () =>
947 Effect.scoped(
948 Effect.gen(function* () {
949 const usageLimits = {
950 checkedAt: "2026-04-10T00:00:04.000Z",
951 windows: [{ id: "session", kind: "session", label: "Session", usedPercent: 70 }],
952 } as const;
953 const provider = yield* makeManagedServerProvider<TestSettings>({
954 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
955 getSettings: Effect.succeed({ enabled: true }),
956 streamSettings: Stream.empty,
957 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
958 initialSnapshot: () => Effect.succeed(initialSnapshot),
959 checkProvider: Effect.succeed({ ...refreshedSnapshot, usageLimits }),
960 refreshOnInterval: false,
961 });
962 yield* Stream.take(provider.streamChanges, 1).pipe(Stream.runDrain);
963 yield* provider.applyUsageLimits({ ...usageLimits, complete: true, authLabel: "tier-2" });
964 assert.strictEqual((yield* provider.refresh).auth.label, "tier-2");
965
966 yield* provider.applyUsageLimits({ ...usageLimits, complete: true });
967 assert.strictEqual((yield* provider.getSnapshot).auth.label, undefined);
968 const refreshed = yield* provider.refresh;
969 assert.strictEqual(refreshed.auth.label, undefined);
970 assert.deepStrictEqual(refreshed.usageLimits, usageLimits);
971 }),
972 ).pipe(Effect.provide(layerAlwaysRunTest)),
973 );
974
975 it.effect("keeps sparse usage unavailable after probe failure until a full probe recovers", () =>
976 Effect.scoped(
977 Effect.gen(function* () {
978 const failedLimits = {
979 checkedAt: "2026-04-10T00:00:01.000Z",
980 windows: [],
981 unavailable: { reason: "probeFailed", message: "Usage probe timed out." },
982 } as const;
983 const probeSnapshot = yield* Ref.make<ServerProvider>({
984 ...refreshedSnapshot,
985 usageLimits: failedLimits,
986 });
987 const provider = yield* makeManagedServerProvider<TestSettings>({
988 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
989 getSettings: Effect.succeed({ enabled: true }),
990 streamSettings: Stream.empty,
991 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
992 initialSnapshot: () => Effect.succeed(initialSnapshot),
993 checkProvider: Ref.get(probeSnapshot),
994 refreshOnInterval: false,
995 });
996 yield* Stream.take(provider.streamChanges, 1).pipe(Stream.runDrain);
997
998 const weekly = {
999 id: "seven_day",
1000 kind: "weekly",
1001 label: "Weekly",
1002 usedPercent: 20,
1003 } as const;
1004 yield* provider.applyUsageLimits({
1005 checkedAt: "2026-04-10T00:00:02.000Z",
1006 windows: [weekly],
1007 });
1008 const partial = yield* provider.getSnapshot;
1009 assert.deepStrictEqual(partial.usageLimits, {
1010 checkedAt: "2026-04-10T00:00:02.000Z",
1011 windows: [weekly],
1012 unavailable: failedLimits.unavailable,
1013 });
1014 yield* provider.applyUsageLimits({
1015 checkedAt: "2026-04-10T00:00:03.000Z",
1016 windows: [{ ...weekly }],
1017 });
1018 assert.strictEqual(yield* provider.getSnapshot, partial);
1019 assert.deepStrictEqual((yield* provider.refresh).usageLimits, failedLimits);
1020
1021 const completeLimits = {
1022 checkedAt: "2026-04-10T00:00:04.000Z",
1023 windows: [
1024 { id: "five_hour", kind: "session", label: "Session", usedPercent: 10 },
1025 { ...weekly, usedPercent: 25 },
1026 ],
1027 } as const;
1028 yield* Ref.set(probeSnapshot, { ...refreshedSnapshot, usageLimits: completeLimits });
1029 assert.deepStrictEqual((yield* provider.refresh).usageLimits, completeLimits);
1030 }),
1031 ).pipe(Effect.provide(layerAlwaysRunTest)),
1032 );
1033 });