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
| 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 | }); |