@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,578 lines 56 KB
Raw
1 import * as NodeServices from "@effect/platform-node/NodeServices";
2 import { describe, it, assert } from "@effect/vitest";
3 import {
4 ProviderDriverKind,
5 ProviderInstanceId,
6 type ServerProvider,
7 type ServerProviderUpdateState,
8 } from "@t3tools/contracts";
9 import { ServerProviderUpdateError } from "@t3tools/contracts";
10 import * as Cause from "effect/Cause";
11 import * as Deferred from "effect/Deferred";
12 import * as Effect from "effect/Effect";
13 import * as Exit from "effect/Exit";
14 import * as Fiber from "effect/Fiber";
15 import * as Layer from "effect/Layer";
16 import * as Ref from "effect/Ref";
17 import * as Schema from "effect/Schema";
18 import * as Sink from "effect/Sink";
19 import * as Stream from "effect/Stream";
20 import * as TestClock from "effect/testing/TestClock";
21 import { HttpClient, HttpClientResponse } from "effect/http";
22 import { ChildProcessSpawner } from "effect/process";
23 import * as HostProcess from "@t3tools/shared/HostProcess";
24 import { SpawnExecutableResolution } from "@t3tools/shared/shell";
25
26 import type { ProviderInstance } from "@t3tools/provider-core/server/driver";
27
28 import * as ServerSettings from "../serverSettings.ts";
29 import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
30 import * as TextGeneration from "../textGeneration/TextGeneration.ts";
31 import * as TextGenerators from "../textGeneration/TextGenerators.ts";
32 import * as ProviderInstallationGate from "./ProviderInstallationGate.ts";
33 import * as ProviderInstanceRegistry from "./ProviderInstanceRegistry.ts";
34 import * as ProviderRegistry from "./ProviderRegistry.ts";
35 import * as ModelManifest from "./ModelManifest.ts";
36 import * as ProviderMaintenanceRunner from "./providerMaintenanceRunner.ts";
37 import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
38 import {
39 enrichProviderSnapshotWithVersionAdvisory,
40 makeProviderMaintenanceCapabilities,
41 type ProviderMaintenanceCapabilities,
42 } from "@t3tools/provider-core/server/maintenanceResolver";
43 const isServerProviderUpdateError = Schema.is(ServerProviderUpdateError);
44
45 const CODEX_DRIVER = ProviderDriverKind.make("codex");
46 const NATIVE_CLI_DRIVER = ProviderDriverKind.make("nativeCli");
47 const OPENCODE_DRIVER = ProviderDriverKind.make("opencode");
48 const CODEX_INSTANCE_ID = ProviderInstanceId.make("codex");
49 const NATIVE_CLI_INSTANCE_ID = ProviderInstanceId.make("nativeCli");
50 const OPENCODE_INSTANCE_ID = ProviderInstanceId.make("opencode");
51 const encoder = new TextEncoder();
52
53 // Pin Linux so raw command/args assertions bypass Windows shim resolution.
54 const layerNonWindowsPlatform = Layer.succeed(HostProcess.Platform, "linux");
55
56 function lifecycleFor(provider: ProviderDriverKind): ProviderMaintenanceCapabilities {
57 if (provider === NATIVE_CLI_DRIVER) {
58 return makeProviderMaintenanceCapabilities({
59 provider,
60 packageName: null,
61 updateExecutable: "native-agent",
62 updateArgs: ["update"],
63 updateLockKey: "native-agent",
64 });
65 }
66 return makeProviderMaintenanceCapabilities({
67 provider,
68 packageName: provider === OPENCODE_DRIVER ? "opencode-ai" : "@openai/codex",
69 updateExecutable: "npm",
70 updateArgs:
71 provider === OPENCODE_DRIVER
72 ? ["install", "-g", "opencode-ai@latest"]
73 : ["install", "-g", "@openai/codex@latest"],
74 updateLockKey: "npm-global",
75 });
76 }
77
78 const baseProvider: ServerProvider = {
79 instanceId: CODEX_INSTANCE_ID,
80 driver: CODEX_DRIVER,
81 enabled: true,
82 installed: true,
83 version: "0.0.0",
84 status: "ready",
85 auth: { status: "authenticated" },
86 checkedAt: "2026-04-10T00:00:00.000Z",
87 models: [],
88 slashCommands: [],
89 skills: [],
90 };
91
92 const baseNativeCliProvider: ServerProvider = {
93 ...baseProvider,
94 instanceId: NATIVE_CLI_INSTANCE_ID,
95 driver: NATIVE_CLI_DRIVER,
96 };
97
98 const baseOpenCodeProvider: ServerProvider = {
99 ...baseProvider,
100 instanceId: OPENCODE_INSTANCE_ID,
101 driver: OPENCODE_DRIVER,
102 };
103
104 const layerLatestVersionHttpClient = (version: string) =>
105 Layer.succeed(
106 HttpClient.HttpClient,
107 HttpClient.make((request) =>
108 Effect.succeed(
109 HttpClientResponse.fromWeb(
110 request,
111 Response.json({ version }, { headers: { "content-type": "application/json" } }),
112 ),
113 ),
114 ),
115 );
116
117 function mockHandle(result: {
118 readonly stdout?: string;
119 readonly stderr?: string;
120 readonly code?: number;
121 readonly exitCode?: Effect.Effect<ChildProcessSpawner.ExitCode>;
122 }) {
123 return ChildProcessSpawner.makeHandle({
124 pid: ChildProcessSpawner.ProcessId(1),
125 exitCode: result.exitCode ?? Effect.succeed(ChildProcessSpawner.ExitCode(result.code ?? 0)),
126 isRunning: Effect.succeed(false),
127 kill: () => Effect.void,
128 unref: Effect.succeed(Effect.void),
129 stdin: Sink.drain,
130 stdout: Stream.make(encoder.encode(result.stdout ?? "")),
131 stderr: Stream.make(encoder.encode(result.stderr ?? "")),
132 all: Stream.empty,
133 getInputFd: () => Sink.drain,
134 getOutputFd: () => Stream.empty,
135 });
136 }
137
138 function layerMockSpawner(
139 handler: (
140 command: string,
141 args: ReadonlyArray<string>,
142 options: { readonly env?: NodeJS.ProcessEnv | undefined },
143 ) => {
144 readonly stdout?: string;
145 readonly stderr?: string;
146 readonly code?: number;
147 readonly exitCode?: Effect.Effect<ChildProcessSpawner.ExitCode>;
148 },
149 ) {
150 return Layer.succeed(
151 ChildProcessSpawner.ChildProcessSpawner,
152 ChildProcessSpawner.make((command) => {
153 const childProcess = command as unknown as {
154 readonly command: string;
155 readonly args: ReadonlyArray<string>;
156 readonly options: { readonly env?: NodeJS.ProcessEnv | undefined };
157 };
158 return Effect.succeed(
159 mockHandle(handler(childProcess.command, childProcess.args, childProcess.options)),
160 );
161 }),
162 );
163 }
164
165 function makeRegistry(
166 initialProviders: ServerProvider | ReadonlyArray<ServerProvider> = baseProvider,
167 options?: {
168 readonly installedVersionAfterUpdate?: string;
169 },
170 ) {
171 return Effect.gen(function* () {
172 const providersRef = yield* Ref.make<ReadonlyArray<ServerProvider>>(
173 Array.isArray(initialProviders) ? initialProviders : [initialProviders],
174 );
175 const updateStatesRef = yield* Ref.make<ReadonlyArray<ServerProviderUpdateState>>([]);
176
177 const setProviderMaintenanceActionState = Effect.fn(
178 "providerMaintenanceRunner.test.setProviderMaintenanceActionState",
179 )(function* (input: {
180 readonly instanceId: ProviderInstanceId;
181 readonly action: "update";
182 readonly state: ServerProviderUpdateState | null;
183 }) {
184 const updateState = input.state;
185 if (updateState) {
186 yield* Ref.update(updateStatesRef, (states) => [...states, updateState]);
187 }
188 return yield* Ref.updateAndGet(providersRef, (providers) =>
189 providers.map((candidate) => {
190 if (candidate.instanceId !== input.instanceId) {
191 return candidate;
192 }
193 if (!updateState) {
194 const { updateState: _updateState, ...providerWithoutUpdateState } = candidate;
195 return providerWithoutUpdateState;
196 }
197 return {
198 ...candidate,
199 updateState,
200 };
201 }),
202 );
203 });
204
205 const registry: ProviderRegistry.ProviderRegistry["Service"] = {
206 getProviders: Ref.get(providersRef),
207 refresh: () => Ref.get(providersRef),
208 refreshInstance: () => Ref.get(providersRef),
209 reloadSecretsAndRefresh: () => Ref.get(providersRef),
210 applySecretAndRefresh: () => Ref.get(providersRef),
211 refreshAfterUpdate: () => {
212 const version = options?.installedVersionAfterUpdate;
213 if (version === undefined) {
214 return Ref.get(providersRef);
215 }
216 return Ref.updateAndGet(providersRef, (providers) =>
217 providers.map((provider) => ({
218 ...provider,
219 version,
220 })),
221 );
222 },
223 refreshWorkspaceSnapshot: () => Ref.get(providersRef),
224 invalidateModelCaches: () => Effect.void,
225 refreshModelCatalog: Effect.void,
226 getProviderMaintenanceCapabilitiesForInstance: (_instanceId, provider) =>
227 Effect.succeed(lifecycleFor(provider)),
228 setProviderMaintenanceActionState,
229 streamChanges: Stream.empty,
230 };
231
232 return {
233 registry,
234 providersRef,
235 updateStatesRef,
236 };
237 });
238 }
239
240 const makeTestRunner = (
241 registry: ProviderRegistry.ProviderRegistry["Service"],
242 manifest: ModelManifest.ModelManifestData = {
243 version: 1,
244 currentModels: {},
245 compatibility: [CODEX_DRIVER, OPENCODE_DRIVER].map((driver) => ({
246 driver,
247 t3CodeRange: ">=0.0.42",
248 ranges: [],
249 })),
250 },
251 latestVersions: Layer.Layer<ProviderLatestVersions.ProviderLatestVersions> = ProviderLatestVersions.layer,
252 ) =>
253 Effect.service(ProviderMaintenanceRunner.ProviderMaintenanceRunner).pipe(
254 Effect.provide(
255 ProviderMaintenanceRunner.layer.pipe(
256 Layer.provide(
257 Layer.mergeAll(
258 Layer.succeed(ProviderRegistry.ProviderRegistry, registry),
259 Layer.succeed(ModelManifest.ModelManifest, {
260 current: Effect.succeed(manifest),
261 refresh: Effect.succeed(manifest),
262 forceRefresh: Effect.succeed(manifest),
263 refreshOnDemand: Effect.succeed(manifest),
264 refreshInBackground: Effect.void,
265 }),
266 latestVersions,
267 // Layers memoize by reference, so a test that provides the gate shares it.
268 ProviderInstallationGate.layer,
269 ),
270 ),
271 ),
272 ),
273 );
274
275 function layerFailingLatestLookupAfterFirst() {
276 let lookups = 0;
277 return Layer.succeed(ProviderLatestVersions.ProviderLatestVersions, {
278 cached: (_key, lookup) =>
279 Effect.gen(function* () {
280 lookups += 1;
281 if (lookups > 1) {
282 return yield* Effect.die("latest lookup failed");
283 }
284 return yield* lookup;
285 }),
286 invalidate: () => Effect.void,
287 invalidateAll: Effect.void,
288 });
289 }
290
291 describe("providerMaintenanceRunner", () => {
292 it.effect("runs the allowlisted provider update command and records success", () => {
293 const calls: Array<{ command: string; args: ReadonlyArray<string> }> = [];
294 return Effect.gen(function* () {
295 const { registry, updateStatesRef } = yield* makeRegistry(baseNativeCliProvider);
296 const updater = yield* makeTestRunner(registry);
297
298 const result = yield* updater.updateProvider(NATIVE_CLI_DRIVER);
299 assert.deepStrictEqual(calls, [
300 {
301 command: "native-agent",
302 args: ["update"],
303 },
304 ]);
305 assert.strictEqual(result.providers[0]?.updateState?.status, "succeeded");
306 assert.deepStrictEqual(
307 (yield* Ref.get(updateStatesRef)).map((state) => [state.status, state.message]),
308 [
309 ["queued", "Waiting for another provider update to finish."],
310 ["running", "Checking for the latest version"],
311 ["running", "Waiting for running provider work to finish."],
312 ["running", "Running native-agent update"],
313 ["running", "Verifying the installed version"],
314 ["succeeded", "Provider updated."],
315 ],
316 );
317 }).pipe(
318 Effect.provide(
319 Layer.mergeAll(
320 layerNonWindowsPlatform,
321 layerLatestVersionHttpClient("1.0.0"),
322 layerMockSpawner((command, args) => {
323 calls.push({ command, args });
324 return { stdout: "updated" };
325 }),
326 ),
327 ),
328 );
329 });
330
331 it.effect.each([
332 { name: "current", probe: {}, skip: true },
333 { name: "failed", probe: { status: "error" }, skip: false },
334 { name: "behind", probe: { version: "2.1.309" }, skip: false },
335 { name: "unknown", probe: { version: null }, skip: false },
336 {
337 name: "installed current",
338 probe: { version: "2.1.309", installedVersion: "2.1.310" },
339 skip: true,
340 },
341 { name: "installed behind", probe: { installedVersion: "2.1.309" }, skip: false },
342 { name: "installed unknown", probe: { installedVersion: null }, skip: false },
343 ] as const)("only skips a successful fresh current probe: $name", ({ probe, skip }) => {
344 const calls: Array<{ command: string; args: ReadonlyArray<string> }> = [];
345 const refreshedInstanceIds: Array<ProviderInstanceId> = [];
346 return Effect.gen(function* () {
347 const { registry, updateStatesRef, providersRef } = yield* makeRegistry({
348 ...baseProvider,
349 version: "2.1.309",
350 versionAdvisory: {
351 status: "behind_latest",
352 currentVersion: "2.1.309",
353 latestVersion: "2.1.310",
354 updateCommand: "claude update",
355 canUpdate: true,
356 checkedAt: "2026-04-10T00:00:00.000Z",
357 message: "Update available.",
358 },
359 });
360 const updater = yield* makeTestRunner({
361 ...registry,
362 refreshInstance: (instanceId) => {
363 refreshedInstanceIds.push(instanceId);
364 return Ref.updateAndGet(providersRef, (providers) =>
365 providers.map((provider) =>
366 provider.instanceId === instanceId
367 ? {
368 ...provider,
369 version: "2.1.310",
370 ...probe,
371 checkedAt: "2026-04-10T00:00:01.000Z",
372 }
373 : provider,
374 ),
375 );
376 },
377 getProviderMaintenanceCapabilitiesForInstance: () =>
378 Effect.succeed(
379 makeProviderMaintenanceCapabilities({
380 provider: CODEX_DRIVER,
381 packageName: "@anthropic-ai/claude-code",
382 updateExecutable: "claude",
383 updateArgs: ["update"],
384 updateLockKey: "claudeAgent-native",
385 }),
386 ),
387 });
388
389 const result = yield* updater.updateProvider(CODEX_DRIVER);
390 assert.deepStrictEqual(refreshedInstanceIds, [CODEX_INSTANCE_ID]);
391 assert.deepStrictEqual(calls, skip ? [] : [{ command: "claude", args: ["update"] }]);
392 if (!skip) return;
393 assert.strictEqual(result.providers[0]?.updateState?.status, "succeeded");
394 assert.strictEqual(result.providers[0]?.updateState?.message, "Already up to date.");
395 assert.deepStrictEqual(
396 (yield* Ref.get(updateStatesRef)).map((state) => [state.status, state.message]),
397 [
398 ["queued", "Waiting for another provider update to finish."],
399 ["running", "Checking for the latest version"],
400 ["succeeded", "Already up to date."],
401 ],
402 );
403 }).pipe(
404 Effect.provide(
405 Layer.mergeAll(
406 layerNonWindowsPlatform,
407 layerLatestVersionHttpClient("2.1.310"),
408 layerMockSpawner((command, args) => {
409 calls.push({ command, args });
410 return { stdout: "updated" };
411 }),
412 ),
413 ),
414 );
415 });
416
417 it.effect("still runs the installer when refreshInstance returns the cached snapshot", () => {
418 const calls: Array<{ command: string; args: ReadonlyArray<string> }> = [];
419 return Effect.gen(function* () {
420 const { registry } = yield* makeRegistry({
421 ...baseProvider,
422 version: "2.1.310",
423 });
424 const updater = yield* makeTestRunner({
425 ...registry,
426 getProviderMaintenanceCapabilitiesForInstance: () =>
427 Effect.succeed(
428 makeProviderMaintenanceCapabilities({
429 provider: CODEX_DRIVER,
430 packageName: "@anthropic-ai/claude-code",
431 updateExecutable: "claude",
432 updateArgs: ["update"],
433 updateLockKey: "claudeAgent-native",
434 }),
435 ),
436 });
437
438 const result = yield* updater.updateProvider(CODEX_DRIVER);
439 assert.deepStrictEqual(calls, [{ command: "claude", args: ["update"] }]);
440 assert.strictEqual(result.providers[0]?.updateState?.status, "succeeded");
441 }).pipe(
442 Effect.provide(
443 Layer.mergeAll(
444 layerNonWindowsPlatform,
445 layerLatestVersionHttpClient("2.1.310"),
446 layerMockSpawner((command, args) => {
447 calls.push({ command, args });
448 return { stdout: "updated" };
449 }),
450 ),
451 ),
452 );
453 });
454
455 it.effect("still runs the installer when precheck advisory enrichment fails", () => {
456 const calls: Array<{ command: string; args: ReadonlyArray<string> }> = [];
457 return Effect.gen(function* () {
458 const { registry, providersRef } = yield* makeRegistry({
459 ...baseProvider,
460 version: "2.1.310",
461 versionAdvisory: {
462 status: "current",
463 currentVersion: "2.1.310",
464 latestVersion: "2.1.310",
465 updateCommand: "claude update",
466 canUpdate: true,
467 checkedAt: "2026-04-10T00:00:00.000Z",
468 message: null,
469 },
470 });
471 const updater = yield* makeTestRunner(
472 {
473 ...registry,
474 refreshInstance: (instanceId) =>
475 Ref.updateAndGet(providersRef, (providers) =>
476 providers.map((provider) =>
477 provider.instanceId === instanceId
478 ? { ...provider, checkedAt: "2026-04-10T00:00:01.000Z" }
479 : provider,
480 ),
481 ),
482 getProviderMaintenanceCapabilitiesForInstance: () =>
483 Effect.succeed(
484 makeProviderMaintenanceCapabilities({
485 provider: CODEX_DRIVER,
486 packageName: "@anthropic-ai/claude-code",
487 updateExecutable: "claude",
488 updateArgs: ["update"],
489 updateLockKey: "claudeAgent-native",
490 }),
491 ),
492 },
493 undefined,
494 layerFailingLatestLookupAfterFirst(),
495 );
496
497 const result = yield* updater.updateProvider(CODEX_DRIVER);
498 assert.deepStrictEqual(calls, [{ command: "claude", args: ["update"] }]);
499 assert.strictEqual(result.providers[0]?.updateState?.status, "succeeded");
500 }).pipe(
501 Effect.provide(
502 Layer.mergeAll(
503 layerNonWindowsPlatform,
504 layerLatestVersionHttpClient("2.1.310"),
505 layerMockSpawner((command, args) => {
506 calls.push({ command, args });
507 return { stdout: "updated" };
508 }),
509 ),
510 ),
511 );
512 });
513
514 it.effect(
515 "keeps a successful update when the binary is present but its version is unreadable",
516 () => {
517 return Effect.gen(function* () {
518 const { registry, providersRef } = yield* makeRegistry(baseNativeCliProvider);
519 const updater = yield* makeTestRunner({
520 ...registry,
521 refreshAfterUpdate: () =>
522 Ref.updateAndGet(providersRef, (providers) =>
523 providers.map((provider) => ({ ...provider, installed: true, version: null })),
524 ),
525 });
526
527 const result = yield* updater.updateProvider(NATIVE_CLI_DRIVER);
528 assert.strictEqual(result.providers[0]?.updateState?.status, "succeeded");
529 }).pipe(
530 Effect.provide(
531 Layer.mergeAll(
532 layerNonWindowsPlatform,
533 layerLatestVersionHttpClient("1.0.0"),
534 layerMockSpawner(() => ({ stdout: "updated" })),
535 ),
536 ),
537 );
538 },
539 );
540
541 it.effect("spawns the updater with the environment its capabilities declare", () => {
542 const seen: Array<NodeJS.ProcessEnv | undefined> = [];
543 return Effect.gen(function* () {
544 const { registry } = yield* makeRegistry(baseProvider);
545 const updater = yield* makeTestRunner({
546 ...registry,
547 getProviderMaintenanceCapabilitiesForInstance: (_instanceId, provider) =>
548 Effect.succeed({
549 ...lifecycleFor(provider),
550 update: {
551 command: "codex update",
552 executable: "/work/codex-home/packages/standalone/bin/codex",
553 args: ["update"],
554 lockKey: "codex-native",
555 env: { CODEX_HOME: "/work/codex-home" },
556 },
557 }),
558 });
559
560 yield* updater.updateProvider(CODEX_DRIVER);
561 assert.deepStrictEqual(seen, [{ CODEX_HOME: "/work/codex-home" }]);
562 }).pipe(
563 Effect.provide(
564 Layer.mergeAll(
565 layerNonWindowsPlatform,
566 layerLatestVersionHttpClient("1.0.0"),
567 layerMockSpawner((_command, _args, options) => {
568 seen.push(options.env);
569 return { stdout: "updated" };
570 }),
571 ),
572 ),
573 );
574 });
575
576 it.effect.skipIf(HostProcess.Platform.defaultValue() === "win32")(
577 "runs the updater with no stdin, so a command that reads it cannot wait forever",
578 () =>
579 Effect.gen(function* () {
580 const { registry } = yield* makeRegistry(baseProvider);
581 const updater = yield* makeTestRunner({
582 ...registry,
583 getProviderMaintenanceCapabilitiesForInstance: (_instanceId, provider) =>
584 Effect.succeed({
585 ...lifecycleFor(provider),
586 update: {
587 command: "codex update",
588 executable: "/bin/sh",
589 // An open pipe here would block a CLI that reads stdin until the update times out.
590 args: ["-c", "[ -c /dev/stdin ] || { echo 'stdin is an open pipe' >&2; exit 1; }"],
591 lockKey: "codex-native",
592 },
593 }),
594 });
595
596 const result = yield* updater.updateProvider(CODEX_DRIVER);
597 // The registry reports no new version, so a command that exits 0 ends as "unchanged".
598 assert.strictEqual(
599 result.providers[0]?.updateState?.message,
600 "Update command completed, but T3 Code still detects an outdated provider version.",
601 );
602 }).pipe(
603 Effect.provide(
604 Layer.mergeAll(
605 NodeServices.layer,
606 layerNonWindowsPlatform,
607 layerLatestVersionHttpClient("1.0.0"),
608 ),
609 ),
610 ),
611 );
612
613 it.effect("re-resolves ownership before running and executes the fresh command", () => {
614 const calls: Array<{ command: string; args: ReadonlyArray<string> }> = [];
615 const fresh: Array<boolean> = [];
616 return Effect.gen(function* () {
617 const { registry } = yield* makeRegistry(baseProvider);
618 const updater = yield* makeTestRunner({
619 ...registry,
620 getProviderMaintenanceCapabilitiesForInstance: (_instanceId, provider, options) => {
621 fresh.push(options?.fresh === true);
622 return Effect.succeed(
623 makeProviderMaintenanceCapabilities({
624 provider,
625 packageName: "@openai/codex",
626 updateExecutable: options?.fresh ? "/opt/homebrew/bin/brew" : "brew",
627 updateArgs: ["upgrade", "--cask", "codex"],
628 updateLockKey: "homebrew",
629 }),
630 );
631 },
632 });
633
634 yield* updater.updateProvider(CODEX_DRIVER);
635 assert.deepStrictEqual(fresh, [false, true, true]);
636 assert.deepStrictEqual(calls, [
637 { command: "/opt/homebrew/bin/brew", args: ["upgrade", "--cask", "codex"] },
638 ]);
639 }).pipe(
640 Effect.provide(
641 Layer.mergeAll(
642 layerNonWindowsPlatform,
643 layerLatestVersionHttpClient("1.0.0"),
644 layerMockSpawner((command, args) => {
645 calls.push({ command, args });
646 return { stdout: "updated" };
647 }),
648 ),
649 ),
650 );
651 });
652
653 it("splits installer output into clean status lines", () => {
654 assert.deepStrictEqual(ProviderMaintenanceRunner.splitOutputLines("Down", "loading\r\n 5"), {
655 lines: ["Downloading"],
656 partialLine: " 5",
657 });
658 assert.strictEqual(
659 ProviderMaintenanceRunner.toProgressLine("\u001b[1m==>\u001b[0m Pouring"),
660 "==> Pouring",
661 );
662 assert.strictEqual(ProviderMaintenanceRunner.toProgressLine(" \t "), null);
663 assert.strictEqual(
664 ProviderMaintenanceRunner.splitOutputLines("x".repeat(5_000), "y").partialLine.length,
665 4_096,
666 );
667 assert.strictEqual(ProviderMaintenanceRunner.toProgressLine("x".repeat(300))?.length, 200);
668
669 for (const redraw of [
670 "\r",
671 "\u001b[G",
672 "\u001b[0G",
673 "\u001b[1G",
674 "\u001b[01G",
675 "\u001b[999D",
676 "\u001b[999D\u001b[J",
677 ]) {
678 const output = `first${redraw}second${redraw}last`;
679 for (let boundary = 0; boundary <= output.length; boundary++) {
680 let partialLine = "";
681 for (const chunk of [output.slice(0, boundary), output.slice(boundary)]) {
682 partialLine = ProviderMaintenanceRunner.splitOutputLines(partialLine, chunk).partialLine;
683 }
684 assert.strictEqual(ProviderMaintenanceRunner.toProgressLine(partialLine), "last");
685 }
686 }
687 for (const incomplete of ["\u001b", "\u001b[", "\u001b[0", "\u001b[01"]) {
688 assert.strictEqual(ProviderMaintenanceRunner.toProgressLine(`progress${incomplete}`), null);
689 }
690 });
691
692 it.effect("aborts without running when the installation changed since the advisory", () => {
693 const calls: Array<string> = [];
694 return Effect.gen(function* () {
695 const { registry, updateStatesRef } = yield* makeRegistry(baseProvider);
696 const updater = yield* makeTestRunner({
697 ...registry,
698 getProviderMaintenanceCapabilitiesForInstance: (_instanceId, provider, options) =>
699 Effect.succeed(
700 options?.fresh
701 ? makeProviderMaintenanceCapabilities({
702 provider,
703 packageName: "@openai/codex",
704 updateExecutable: null,
705 updateArgs: [],
706 updateLockKey: null,
707 })
708 : lifecycleFor(provider),
709 ),
710 });
711
712 const result = yield* updater.updateProvider(CODEX_DRIVER);
713 assert.deepStrictEqual(calls, []);
714 assert.strictEqual(result.providers[0]?.updateState?.status, "failed");
715 assert.strictEqual(
716 result.providers[0]?.updateState?.message,
717 "Provider installation changed. Refresh and try again.",
718 );
719 assert.deepStrictEqual(
720 (yield* Ref.get(updateStatesRef)).map((state) => state.status),
721 ["queued", "running", "failed"],
722 );
723 }).pipe(
724 Effect.provide(
725 Layer.mergeAll(
726 layerNonWindowsPlatform,
727 layerLatestVersionHttpClient("1.0.0"),
728 layerMockSpawner((command) => {
729 calls.push(command);
730 return { stdout: "updated" };
731 }),
732 ),
733 ),
734 );
735 });
736
737 it.effect("records command failure output in provider update state", () =>
738 Effect.gen(function* () {
739 const { registry } = yield* makeRegistry();
740 const updater = yield* makeTestRunner(registry);
741
742 const result = yield* updater.updateProvider(CODEX_DRIVER);
743 const updateState = result.providers[0]?.updateState;
744
745 assert.strictEqual(updateState?.status, "failed");
746 assert.strictEqual(
747 updateState?.message,
748 "Update command exited with code 1: Error: Could not detect the Codex installation method.",
749 );
750 assert.include(updateState?.output ?? "", "checking install");
751 }).pipe(
752 Effect.provide(
753 Layer.mergeAll(
754 layerNonWindowsPlatform,
755 layerLatestVersionHttpClient("1.0.0"),
756 layerMockSpawner(() => ({
757 stdout: "checking install\n",
758 stderr: "Error: Could not detect the Codex installation method.\n\n",
759 code: 1,
760 })),
761 ),
762 ),
763 ),
764 );
765
766 it.effect("reports the updater's error rather than a trailing hint after it", () =>
767 Effect.forEach(
768 [
769 {
770 stdout: "Current version: 2.1.310\nChecking for updates to latest version...\n",
771 stderr: [
772 "Error: Failed to install native update",
773 "TelemetrySafeError: Failed to fetch version from https://downloads.claude.ai/claude-code-releases/latest after 3 attempt(s): Request failed with status code 403",
774 'Try running "claude doctor" for diagnostics',
775 "",
776 ].join("\n"),
777 reason: "Request failed with status code 403",
778 hint: "claude doctor",
779 },
780 {
781 stdout: "",
782 stderr: [
783 "Failed to check for updates",
784 "Unable to fetch latest version from npm registry",
785 "",
786 "Possible causes:",
787 " • Network connectivity issues",
788 " • npm registry is unreachable",
789 " • Corporate proxy/firewall blocking npm",
790 "",
791 "Try:",
792 " • Check your internet connection",
793 " • Run with --debug flag for more details",
794 " • Manually check: npm view @anthropic-ai/claude-code version",
795 " • Check if you need to login: npm whoami",
796 "",
797 ].join("\n"),
798 reason: "Failed to check for updates",
799 hint: "npm whoami",
800 },
801 ],
802 ({ stdout, stderr, reason, hint }) =>
803 Effect.gen(function* () {
804 const { registry } = yield* makeRegistry(baseNativeCliProvider);
805 const updater = yield* makeTestRunner(registry);
806
807 const result = yield* updater.updateProvider(NATIVE_CLI_DRIVER);
808 const message = result.providers[0]?.updateState?.message ?? "";
809
810 assert.include(message, reason);
811 assert.notInclude(message, hint);
812 }).pipe(
813 Effect.provide(
814 Layer.mergeAll(
815 layerNonWindowsPlatform,
816 layerLatestVersionHttpClient("0.0.0"),
817 layerMockSpawner(() => ({ stdout, stderr, code: 1 })),
818 ),
819 ),
820 ),
821 { discard: true },
822 ),
823 );
824
825 it.effect("keeps the exit code message when a failed command prints nothing", () =>
826 Effect.gen(function* () {
827 const { registry } = yield* makeRegistry();
828 const updater = yield* makeTestRunner(registry);
829
830 const result = yield* updater.updateProvider(CODEX_DRIVER);
831
832 assert.strictEqual(
833 result.providers[0]?.updateState?.message,
834 "Update command exited with code 1.",
835 );
836 }).pipe(
837 Effect.provide(
838 Layer.mergeAll(
839 layerNonWindowsPlatform,
840 layerLatestVersionHttpClient("1.0.0"),
841 layerMockSpawner(() => ({ code: 1 })),
842 ),
843 ),
844 ),
845 );
846
847 it.effect(
848 "marks successful commands as unchanged when the refreshed provider is still outdated",
849 () =>
850 Effect.gen(function* () {
851 const { registry } = yield* makeRegistry({
852 ...baseProvider,
853 installed: true,
854 version: "0.1.0",
855 });
856 const updater = yield* makeTestRunner(registry);
857
858 const result = yield* updater.updateProvider(CODEX_DRIVER);
859
860 assert.strictEqual(result.providers[0]?.updateState?.status, "unchanged");
861 assert.include(result.providers[0]?.updateState?.message ?? "", "still detects");
862 }).pipe(
863 Effect.provide(
864 Layer.mergeAll(
865 layerNonWindowsPlatform,
866 layerLatestVersionHttpClient("9.9.9"),
867 layerMockSpawner(() => ({ stdout: "updated" })),
868 ),
869 ),
870 ),
871 );
872
873 // A native updater such as `claude update` downloads a ~300 MB binary and
874 // prints nothing while it does. Killed mid-download, it leaves a truncated
875 // binary behind that later updates mistake for an install.
876 it.effect.each([
877 { runFor: "6 minutes", status: "succeeded", message: "Provider updated." },
878 { runFor: "31 minutes", status: "failed", message: "Update timed out after 30 minutes." },
879 ] as const)("lets a slow installer run for $runFor", ({ runFor, status, message }) => {
880 const started = Deferred.makeUnsafe<void>();
881 return Effect.gen(function* () {
882 const { registry } = yield* makeRegistry(baseNativeCliProvider);
883 const updater = yield* makeTestRunner(registry);
884
885 const update = yield* updater.updateProvider(NATIVE_CLI_DRIVER).pipe(Effect.forkScoped);
886 yield* Deferred.await(started);
887 yield* TestClock.adjust(runFor);
888 const result = yield* Fiber.join(update);
889
890 assert.strictEqual(result.providers[0]?.updateState?.status, status);
891 assert.strictEqual(result.providers[0]?.updateState?.message, message);
892 }).pipe(
893 Effect.provide(
894 Layer.mergeAll(
895 layerNonWindowsPlatform,
896 layerLatestVersionHttpClient("1.0.0"),
897 layerMockSpawner(() => ({
898 exitCode: Deferred.succeed(started, undefined).pipe(
899 Effect.andThen(Effect.sleep(runFor)),
900 Effect.as(ChildProcessSpawner.ExitCode(0)),
901 ),
902 })),
903 ),
904 ),
905 );
906 });
907
908 it.effect("an interrupted update ends failed instead of running forever", () => {
909 const started = Deferred.makeUnsafe<void>();
910 return Effect.gen(function* () {
911 const { registry, updateStatesRef } = yield* makeRegistry(baseNativeCliProvider);
912 const updater = yield* makeTestRunner(registry);
913 const update = yield* updater.updateProvider(NATIVE_CLI_DRIVER).pipe(Effect.forkScoped);
914 yield* Deferred.await(started);
915 yield* Fiber.interrupt(update);
916 const last = (yield* Ref.get(updateStatesRef)).at(-1);
917 assert.deepStrictEqual(
918 [last?.status, last?.message],
919 ["failed", "Update stopped before it finished."],
920 );
921 }).pipe(
922 Effect.provide(
923 Layer.mergeAll(
924 layerNonWindowsPlatform,
925 layerLatestVersionHttpClient("1.0.0"),
926 layerMockSpawner(() => ({
927 exitCode: Deferred.succeed(started, undefined).pipe(Effect.andThen(Effect.never)),
928 })),
929 ),
930 ),
931 );
932 });
933
934 it.effect("a request dropped while the final state is written still records it", () => {
935 const writing = Deferred.makeUnsafe<void>();
936 const release = Deferred.makeUnsafe<void>();
937 return Effect.gen(function* () {
938 const { registry, updateStatesRef } = yield* makeRegistry(baseNativeCliProvider);
939 const updater = yield* makeTestRunner({
940 ...registry,
941 setProviderMaintenanceActionState: (input) =>
942 input.state?.status === "succeeded"
943 ? Deferred.succeed(writing, undefined).pipe(
944 Effect.andThen(Deferred.await(release)),
945 Effect.andThen(registry.setProviderMaintenanceActionState(input)),
946 )
947 : registry.setProviderMaintenanceActionState(input),
948 });
949
950 const update = yield* updater.updateProvider(NATIVE_CLI_DRIVER).pipe(Effect.forkScoped);
951 yield* Deferred.await(writing);
952 update.interruptUnsafe();
953 yield* Deferred.succeed(release, undefined);
954 yield* Fiber.await(update);
955
956 assert.strictEqual((yield* Ref.get(updateStatesRef)).at(-1)?.status, "succeeded");
957 }).pipe(
958 Effect.provide(
959 Layer.mergeAll(
960 layerNonWindowsPlatform,
961 layerLatestVersionHttpClient("1.0.0"),
962 layerMockSpawner(() => ({ stdout: "updated" })),
963 ),
964 ),
965 );
966 });
967
968 it.effect("prevents concurrent updates for the same provider", () => {
969 const startedLatch: { resolve: () => void } = { resolve: () => {} };
970 const releaseLatch: { resolve: () => void } = { resolve: () => {} };
971 const started = new Promise<void>((resolve) => {
972 startedLatch.resolve = resolve;
973 });
974 const release = new Promise<void>((resolve) => {
975 releaseLatch.resolve = resolve;
976 });
977 return Effect.gen(function* () {
978 const { registry } = yield* makeRegistry();
979 const updater = yield* makeTestRunner(registry);
980
981 const first = yield* updater.updateProvider(CODEX_DRIVER).pipe(Effect.forkScoped);
982 yield* Effect.promise(() => started);
983
984 const second = yield* updater.updateProvider(CODEX_DRIVER).pipe(Effect.exit);
985 assert.strictEqual(Exit.isFailure(second), true);
986 if (Exit.isFailure(second)) {
987 const error = Cause.squash(second.cause);
988 assert.strictEqual(isServerProviderUpdateError(error), true);
989 if (isServerProviderUpdateError(error)) {
990 assert.include(error.reason, "already running");
991 }
992 }
993
994 releaseLatch.resolve();
995 yield* Fiber.join(first);
996 }).pipe(
997 Effect.provide(
998 Layer.mergeAll(
999 layerNonWindowsPlatform,
1000 layerLatestVersionHttpClient("1.0.0"),
1001 layerMockSpawner(() => {
1002 startedLatch.resolve();
1003 return {
1004 stdout: "updated",
1005 exitCode: Effect.promise(() => release).pipe(
1006 Effect.as(ChildProcessSpawner.ExitCode(0)),
1007 ),
1008 };
1009 }),
1010 ),
1011 ),
1012 );
1013 });
1014
1015 it.effect("holds text generation for an instance until its update finishes", () => {
1016 const updateStarted = Deferred.makeUnsafe<void>();
1017 const log: Array<string> = [];
1018 return Effect.gen(function* () {
1019 const { registry } = yield* makeRegistry(baseProvider, {
1020 installedVersionAfterUpdate: "1.0.0",
1021 });
1022 const updater = yield* makeTestRunner(registry);
1023 const instance: ProviderInstance = {
1024 instanceId: CODEX_INSTANCE_ID,
1025 driverKind: CODEX_DRIVER,
1026 continuationIdentity: { driverKind: CODEX_DRIVER, continuationKey: CODEX_INSTANCE_ID },
1027 displayName: undefined,
1028 enabled: true,
1029 snapshot: { getSnapshot: Effect.succeed(baseProvider) } as ProviderInstance["snapshot"],
1030 orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
1031 textGeneration: TextGeneration.TextGeneration.of({
1032 generateCommitMessage: () => Effect.die("unused"),
1033 generatePrContent: () => Effect.die("unused"),
1034 generateBranchName: () => Effect.die("unused"),
1035 generateReviewGuide: () => Effect.die("unused"),
1036 generateTranscriptionPostProcessing: () => Effect.die("unused"),
1037 generateThreadTitle: () =>
1038 Effect.sync(() => {
1039 log.push("text generation spawned provider");
1040 return { title: "Generated title" };
1041 }),
1042 }),
1043 };
1044 const textGeneration = yield* TextGeneration.make.pipe(
1045 Effect.provide(
1046 Layer.mergeAll(
1047 Layer.mock(ProviderInstanceRegistry.ProviderInstanceRegistry)({
1048 listInstances: Effect.succeed([instance]),
1049 getInstance: (id) => Effect.succeed(id === CODEX_INSTANCE_ID ? instance : undefined),
1050 }),
1051 ServerSettings.layerTest(),
1052 Layer.mock(TextGenerators.TextGenerators)({ runner: () => Effect.undefined }),
1053 Layer.mock(SourceControlProviderRegistry.SourceControlProviderRegistry)({
1054 resolveLink: () => Effect.die("unused"),
1055 }),
1056 ),
1057 ),
1058 );
1059
1060 const update = yield* updater.updateProvider(CODEX_DRIVER).pipe(Effect.forkScoped);
1061 yield* Deferred.await(updateStarted);
1062 const generation = yield* textGeneration
1063 .generateThreadTitle({
1064 cwd: "/tmp",
1065 message: "hello",
1066 linkedContext: "",
1067 modelSelection: { instanceId: CODEX_INSTANCE_ID, model: "gpt-5" },
1068 })
1069 .pipe(Effect.forkScoped);
1070 yield* TestClock.adjust("1 minute");
1071 const result = yield* Fiber.join(update);
1072 yield* Fiber.join(generation);
1073
1074 assert.strictEqual(result.providers[0]?.updateState?.status, "succeeded");
1075 assert.deepStrictEqual(log, ["update command exited", "text generation spawned provider"]);
1076 }).pipe(
1077 Effect.provide(
1078 Layer.mergeAll(
1079 ProviderInstallationGate.layer,
1080 layerNonWindowsPlatform,
1081 layerLatestVersionHttpClient("1.0.0"),
1082 layerMockSpawner(() => ({
1083 exitCode: Deferred.succeed(updateStarted, undefined).pipe(
1084 Effect.andThen(Effect.sleep("1 minute")),
1085 Effect.andThen(Effect.sync(() => log.push("update command exited"))),
1086 Effect.as(ChildProcessSpawner.ExitCode(0)),
1087 ),
1088 })),
1089 ),
1090 ),
1091 );
1092 });
1093
1094 it.effect("holds every instance that shares the updated installation", () => {
1095 const CODEX_WORK_INSTANCE_ID = ProviderInstanceId.make("codex_work");
1096 const updateStarted = Deferred.makeUnsafe<void>();
1097 const log: Array<string> = [];
1098 return Effect.gen(function* () {
1099 const { registry } = yield* makeRegistry(
1100 [
1101 baseProvider,
1102 { ...baseProvider, instanceId: CODEX_WORK_INSTANCE_ID },
1103 baseOpenCodeProvider,
1104 ],
1105 { installedVersionAfterUpdate: "1.0.0" },
1106 );
1107 // OpenCode installs into the same npm prefix, so it shares the lock key but not the package.
1108 const updater = yield* makeTestRunner(registry);
1109 const gate = yield* ProviderInstallationGate.ProviderInstallationGate;
1110
1111 const update = yield* updater.updateProvider(CODEX_DRIVER).pipe(Effect.forkScoped);
1112 yield* Deferred.await(updateStarted);
1113 const shared = yield* gate
1114 .execute(
1115 CODEX_WORK_INSTANCE_ID,
1116 Effect.sync(() => log.push("shared installation ran")),
1117 )
1118 .pipe(Effect.forkScoped);
1119 const other = yield* gate
1120 .execute(
1121 OPENCODE_INSTANCE_ID,
1122 Effect.sync(() => log.push("other driver ran")),
1123 )
1124 .pipe(Effect.forkScoped);
1125 yield* TestClock.adjust("1 minute");
1126 yield* Fiber.join(update);
1127 yield* Fiber.join(shared);
1128 yield* Fiber.join(other);
1129
1130 assert.deepStrictEqual(log, [
1131 "other driver ran",
1132 "update command exited",
1133 "shared installation ran",
1134 ]);
1135 }).pipe(
1136 Effect.provide(
1137 Layer.mergeAll(
1138 ProviderInstallationGate.layer,
1139 layerNonWindowsPlatform,
1140 layerLatestVersionHttpClient("1.0.0"),
1141 layerMockSpawner(() => ({
1142 exitCode: Deferred.succeed(updateStarted, undefined).pipe(
1143 Effect.andThen(Effect.sleep("1 minute")),
1144 Effect.andThen(Effect.sync(() => log.push("update command exited"))),
1145 Effect.as(ChildProcessSpawner.ExitCode(0)),
1146 ),
1147 })),
1148 ),
1149 ),
1150 );
1151 });
1152
1153 it.effect(
1154 "releases the running-provider marker when interrupted after queuing but before the lock run starts",
1155 () =>
1156 Effect.gen(function* () {
1157 const { registry } = yield* makeRegistry(baseProvider, {
1158 installedVersionAfterUpdate: "1.0.0",
1159 });
1160 let blockQueuedState = true;
1161 const queuedStateWrittenLatch: { resolve: () => void } = { resolve: () => {} };
1162 const releaseQueuedStateLatch: { resolve: () => void } = { resolve: () => {} };
1163 const queuedStateWritten = new Promise<void>((resolve) => {
1164 queuedStateWrittenLatch.resolve = resolve;
1165 });
1166 const releaseQueuedState = new Promise<void>((resolve) => {
1167 releaseQueuedStateLatch.resolve = resolve;
1168 });
1169
1170 const updater = yield* makeTestRunner({
1171 ...registry,
1172 setProviderMaintenanceActionState: Effect.fn(
1173 "providerMaintenanceRunner.test.blockQueuedState",
1174 )(function* (input) {
1175 const providers = yield* registry.setProviderMaintenanceActionState(input);
1176 if (input.state?.status === "queued" && blockQueuedState) {
1177 queuedStateWrittenLatch.resolve();
1178 yield* Effect.promise(() => releaseQueuedState);
1179 }
1180 return providers;
1181 }),
1182 });
1183
1184 const first = yield* updater.updateProvider(CODEX_DRIVER).pipe(Effect.forkScoped);
1185 yield* Effect.promise(() => queuedStateWritten);
1186 blockQueuedState = false;
1187
1188 yield* Fiber.interrupt(first);
1189 releaseQueuedStateLatch.resolve();
1190
1191 const second = yield* updater.updateProvider(CODEX_DRIVER).pipe(Effect.exit);
1192 assert.strictEqual(Exit.isSuccess(second), true);
1193 if (Exit.isSuccess(second)) {
1194 assert.strictEqual(second.value.providers[0]?.updateState?.status, "succeeded");
1195 }
1196 }).pipe(
1197 Effect.provide(
1198 Layer.mergeAll(
1199 layerNonWindowsPlatform,
1200 layerLatestVersionHttpClient("1.0.0"),
1201 layerMockSpawner(() => ({ stdout: "updated" })),
1202 ),
1203 ),
1204 ),
1205 );
1206
1207 it.effect("resolves npm to a .cmd shim from the provider's PATH on win32", () => {
1208 const captured: Array<{
1209 readonly command: string;
1210 readonly args: ReadonlyArray<string>;
1211 readonly shell: boolean | string | undefined;
1212 readonly env: NodeJS.ProcessEnv | undefined;
1213 }> = [];
1214 return Effect.gen(function* () {
1215 const { registry } = yield* makeRegistry(baseProvider, {
1216 installedVersionAfterUpdate: "1.0.0",
1217 });
1218 const runner = yield* makeTestRunner({
1219 ...registry,
1220 getProviderMaintenanceCapabilitiesForInstance: () =>
1221 Effect.succeed(
1222 makeProviderMaintenanceCapabilities({
1223 provider: CODEX_DRIVER,
1224 packageName: "@openai/codex",
1225 updateExecutable: "npm",
1226 updateArgs: ["install", "-g", "@openai/codex@latest"],
1227 updateLockKey: "npm-global",
1228 env: { PATH: "C:\\fake\\npm" },
1229 }),
1230 ),
1231 });
1232
1233 const result = yield* runner.updateProvider(CODEX_DRIVER);
1234
1235 assert.strictEqual(captured.length, 1);
1236 const call = captured[0];
1237 assert.ok(call, "expected the spawner to be invoked once");
1238 assert.strictEqual(
1239 call.command,
1240 '^"C:\\fake\\npm\\npm.cmd^" ^"install^" ^"-g^" ^"@openai/codex@latest^"',
1241 );
1242 assert.deepEqual(call.args, []);
1243 assert.strictEqual(call.shell, true);
1244 assert.deepStrictEqual(call.env, { PATH: "C:\\fake\\npm" });
1245 assert.strictEqual(result.providers[0]?.updateState?.status, "succeeded");
1246 }).pipe(
1247 Effect.provide(
1248 Layer.mergeAll(
1249 Layer.succeed(HostProcess.Platform, "win32"),
1250 // Only the provider's PATH has npm.
1251 Layer.succeed(HostProcess.Environment, {
1252 PATH: "C:\\Windows\\System32",
1253 PATHEXT: ".COM;.EXE;.BAT;.CMD",
1254 }),
1255 Layer.succeed(SpawnExecutableResolution, (command, _platform, env) =>
1256 command === "npm" && env.PATH === "C:\\fake\\npm"
1257 ? "C:\\fake\\npm\\npm.cmd"
1258 : undefined,
1259 ),
1260 layerLatestVersionHttpClient("1.0.0"),
1261 Layer.succeed(
1262 ChildProcessSpawner.ChildProcessSpawner,
1263 ChildProcessSpawner.make((command) => {
1264 const childProcess = command as unknown as {
1265 readonly command: string;
1266 readonly args: ReadonlyArray<string>;
1267 readonly options: {
1268 readonly shell?: boolean | string | undefined;
1269 readonly env?: NodeJS.ProcessEnv | undefined;
1270 };
1271 };
1272 captured.push({
1273 command: childProcess.command,
1274 args: childProcess.args,
1275 shell: childProcess.options.shell,
1276 env: childProcess.options.env,
1277 });
1278 return Effect.succeed(mockHandle({ stdout: "updated" }));
1279 }),
1280 ),
1281 ),
1282 ),
1283 );
1284 });
1285 });
1286
1287 it.effect.each([
1288 {
1289 mode: "default-precurrent",
1290 version: "1.14.19",
1291 installation: { installedVersion: "1.14.20" },
1292 status: "succeeded",
1293 },
1294 {
1295 mode: "default",
1296 version: "1.14.19",
1297 installation: { installedVersion: "1.14.20" },
1298 status: "succeeded",
1299 },
1300 {
1301 mode: "targeted",
1302 version: "1.14.19",
1303 installation: { installedVersion: "1.14.20" },
1304 status: "succeeded",
1305 },
1306 {
1307 mode: "targeted-current",
1308 version: "1.14.20",
1309 installation: { installedVersion: "1.14.20" },
1310 status: "succeeded",
1311 },
1312 {
1313 mode: "unknown",
1314 version: "1.14.19",
1315 installation: { installedVersion: null },
1316 status: "unchanged",
1317 },
1318 { mode: "legacy", version: "1.14.20", installation: {}, status: "succeeded" },
1319 ] as const)(
1320 "verifies the $mode OpenCode update using the refreshed installation",
1321 ({ mode, version, installation, status }) => {
1322 const calls: string[] = [];
1323 const capabilities = lifecycleFor(OPENCODE_DRIVER);
1324 const pinnedCapabilities = {
1325 ...capabilities,
1326 update: { ...capabilities.update!, lockKey: "npm-global:/fixture" },
1327 };
1328 const manifest: ModelManifest.ModelManifestData = {
1329 version: 1,
1330 currentModels: {},
1331 compatibility: [
1332 {
1333 driver: OPENCODE_DRIVER,
1334 t3CodeRange: ">=0.0.42",
1335 recommendedVersion: "1.14.20",
1336 ranges: [{ range: "=1.14.20", status: "supported" }],
1337 },
1338 ],
1339 };
1340 return Effect.gen(function* () {
1341 const { registry, providersRef } = yield* makeRegistry({ ...baseOpenCodeProvider, version });
1342 const httpClient = yield* HttpClient.HttpClient;
1343 const latestVersions = yield* ProviderLatestVersions.ProviderLatestVersions;
1344 const updater = yield* makeTestRunner(
1345 {
1346 ...registry,
1347 refreshInstance: () =>
1348 Ref.updateAndGet(providersRef, (providers) =>
1349 providers.map((provider) => ({
1350 ...provider,
1351 ...(mode === "default-precurrent" ? installation : {}),
1352 checkedAt: "2026-04-10T00:00:01.000Z",
1353 })),
1354 ),
1355 getProviderMaintenanceCapabilitiesForInstance: () => Effect.succeed(pinnedCapabilities),
1356 refreshAfterUpdate: () =>
1357 Effect.gen(function* () {
1358 assert.strictEqual(calls.length, 1);
1359 const refreshed = yield* enrichProviderSnapshotWithVersionAdvisory(
1360 { ...baseOpenCodeProvider, version, ...installation },
1361 pinnedCapabilities,
1362 ).pipe(
1363 Effect.provideService(HttpClient.HttpClient, httpClient),
1364 Effect.provideService(
1365 ProviderLatestVersions.ProviderLatestVersions,
1366 latestVersions,
1367 ),
1368 );
1369 return yield* Ref.updateAndGet(providersRef, (providers) =>
1370 providers.map((provider) => ({ ...provider, ...refreshed })),
1371 );
1372 }),
1373 },
1374 manifest,
1375 );
1376
1377 const result = yield* updater.updateProvider({
1378 provider: OPENCODE_DRIVER,
1379 ...(mode.startsWith("default") ? {} : { targetVersion: "1.14.20" }),
1380 });
1381
1382 assert.deepStrictEqual(
1383 calls,
1384 mode === "default-precurrent"
1385 ? []
1386 : [`npm install -g opencode-ai@${mode.startsWith("default") ? "latest" : "1.14.20"}`],
1387 );
1388 const provider = result.providers[0];
1389 assert.ok(provider);
1390 assert.strictEqual(provider.updateState?.status, status);
1391 if (mode === "default" || mode === "default-precurrent" || mode === "targeted") {
1392 assert.strictEqual(
1393 provider.updateState?.message,
1394 "OpenCode CLI updated. Restart the configured local OpenCode server to use the new version.",
1395 );
1396 }
1397 assert.strictEqual(provider.version, version);
1398 assert.strictEqual("installedVersion" in provider, mode !== "legacy");
1399 if (mode === "default-precurrent") return;
1400 assert.strictEqual(
1401 provider.versionAdvisory?.status,
1402 mode === "unknown" ? "unknown" : "current",
1403 );
1404 assert.strictEqual(
1405 provider.versionAdvisory?.currentVersion,
1406 mode === "unknown" ? null : "1.14.20",
1407 );
1408 }).pipe(
1409 Effect.provide(
1410 Layer.mergeAll(
1411 layerNonWindowsPlatform,
1412 ProviderLatestVersions.layer,
1413 layerLatestVersionHttpClient("1.14.20"),
1414 layerMockSpawner((command, args) => {
1415 calls.push([command, ...args].join(" "));
1416 return { stdout: "installed" };
1417 }),
1418 ),
1419 ),
1420 );
1421 },
1422 );
1423
1424 it.effect(
1425 "uses fresh installer versions for post-update verification and compatibility checks",
1426 () => {
1427 const calls: string[] = [];
1428 let latest = "2.0.0";
1429 const manifest: ModelManifest.ModelManifestData = {
1430 version: 1,
1431 currentModels: {},
1432 compatibility: [
1433 {
1434 driver: "codex",
1435 t3CodeRange: ">=0.0.42",
1436 ranges: [
1437 { range: "<=2.0.0", status: "supported" },
1438 { range: ">2.0.0", status: "broken" },
1439 ],
1440 },
1441 ],
1442 };
1443 return Effect.gen(function* () {
1444 const { registry } = yield* makeRegistry({ ...baseProvider, version: "1.0.0" });
1445 const capabilities = makeProviderMaintenanceCapabilities({
1446 provider: CODEX_DRIVER,
1447 packageName: "@openai/codex",
1448 updateExecutable: "/opt/homebrew/bin/brew",
1449 updateArgs: ["upgrade", "--cask", "codex"],
1450 updateLockKey: "homebrew",
1451 latestVersion: null,
1452 lookupLatestVersion: Effect.sync(() => latest),
1453 });
1454 const updater = yield* makeTestRunner(
1455 {
1456 ...registry,
1457 getProviderMaintenanceCapabilitiesForInstance: () => Effect.succeed(capabilities),
1458 },
1459 manifest,
1460 );
1461
1462 const unchanged = yield* updater.updateProvider(CODEX_DRIVER);
1463 assert.strictEqual(unchanged.providers[0]?.updateState?.status, "unchanged");
1464 assert.match(unchanged.providers[0]?.updateState?.message ?? "", /outdated provider version/);
1465 assert.deepStrictEqual(calls, ["upgrade --cask codex"]);
1466
1467 latest = "3.0.0";
1468 const refused = yield* updater.updateProvider(CODEX_DRIVER);
1469 assert.strictEqual(refused.providers[0]?.updateState?.status, "failed");
1470 assert.match(refused.providers[0]?.updateState?.message ?? "", /incompatible/);
1471 assert.deepStrictEqual(calls, ["upgrade --cask codex"]);
1472 }).pipe(
1473 Effect.provide(
1474 Layer.mergeAll(
1475 layerNonWindowsPlatform,
1476 Layer.succeed(
1477 HttpClient.HttpClient,
1478 HttpClient.make(() => Effect.die("Homebrew's latest should not come from npm")),
1479 ),
1480 layerMockSpawner((_command, args) => {
1481 calls.push(args.join(" "));
1482 latest = "2.0.0";
1483 return { stdout: "upgraded" };
1484 }),
1485 ),
1486 ),
1487 );
1488 },
1489 );
1490
1491 it.effect("refuses incompatible latest versions and unapproved or unpinnable targets", () => {
1492 const calls: string[] = [];
1493 const manifest: ModelManifest.ModelManifestData = {
1494 version: 1,
1495 currentModels: {},
1496 compatibility: [
1497 {
1498 driver: "codex",
1499 t3CodeRange: ">=0.0.42",
1500 recommendedVersion: "2.0.0",
1501 ranges: [
1502 { range: "=2.0.0", status: "supported" },
1503 { range: ">2.0.0", status: "broken" },
1504 ],
1505 },
1506 ],
1507 };
1508 return Effect.gen(function* () {
1509 const { registry, providersRef } = yield* makeRegistry();
1510 const pinnedCapabilities = makeProviderMaintenanceCapabilities({
1511 provider: CODEX_DRIVER,
1512 packageName: "@openai/codex",
1513 updateExecutable: "npm",
1514 updateArgs: ["install", "-g", "@openai/codex@latest"],
1515 updateLockKey: "npm-global:/fixture",
1516 });
1517 const updater = yield* makeTestRunner(
1518 {
1519 ...registry,
1520 getProviderMaintenanceCapabilitiesForInstance: () => Effect.succeed(pinnedCapabilities),
1521 },
1522 manifest,
1523 );
1524 for (const targetVersion of [undefined, "", "1.0.0", "2.0.0; echo unsafe"]) {
1525 const result = yield* updater.updateProvider({
1526 provider: CODEX_DRIVER,
1527 ...(targetVersion !== undefined ? { targetVersion } : {}),
1528 });
1529 assert.strictEqual(result.providers[0]?.updateState?.status, "failed");
1530 }
1531 assert.deepStrictEqual(calls, []);
1532 yield* Ref.update(providersRef, (providers) =>
1533 providers.map((entry) => ({ ...entry, version: "2.0.0" })),
1534 );
1535 const installed = yield* updater.updateProvider({
1536 provider: CODEX_DRIVER,
1537 targetVersion: "2.0.0",
1538 });
1539 assert.deepStrictEqual(calls, ["install -g @openai/codex@2.0.0"]);
1540 assert.strictEqual(installed.providers[0]?.updateState?.status, "succeeded");
1541 yield* Ref.update(providersRef, (providers) =>
1542 providers.map((entry) => ({ ...entry, version: "1.0.0" })),
1543 );
1544 const unchanged = yield* updater.updateProvider({
1545 provider: CODEX_DRIVER,
1546 targetVersion: "2.0.0",
1547 });
1548 assert.strictEqual(unchanged.providers[0]?.updateState?.status, "unchanged");
1549 const nativeUpdater = yield* makeTestRunner(
1550 {
1551 ...registry,
1552 getProviderMaintenanceCapabilitiesForInstance: () =>
1553 Effect.succeed({
1554 ...pinnedCapabilities,
1555 update: { ...pinnedCapabilities.update!, lockKey: "codex-native" },
1556 }),
1557 },
1558 manifest,
1559 );
1560 const refused = yield* nativeUpdater.updateProvider({
1561 provider: CODEX_DRIVER,
1562 targetVersion: "2.0.0",
1563 });
1564 assert.strictEqual(refused.providers[0]?.updateState?.status, "failed");
1565 assert.strictEqual(calls.length, 2);
1566 }).pipe(
1567 Effect.provide(
1568 Layer.mergeAll(
1569 layerNonWindowsPlatform,
1570 layerLatestVersionHttpClient("3.0.0"),
1571 layerMockSpawner((_command, args) => {
1572 calls.push(args.join(" "));
1573 return { stdout: "installed" };
1574 }),
1575 ),
1576 ),
1577 );
1578 });