Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

driver.test.ts

1,302 lines52.5 KB

1// @effect-diagnostics nodeBuiltinImport:off
2import * as NodeFS from "node:fs";
3import * as NodeOS from "node:os";
4import * as NodePath from "node:path";
5​
6import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
7import * as NodeServices from "@effect/platform-node/NodeServices";
8import { assert, it } from "@effect/vitest";
9import {
10 DEFAULT_SERVER_SETTINGS,
11 ProviderInstanceId,
12 ProviderSessionId,
13 ThreadId,
14} from "@t3tools/contracts";
15import type { OpenCodeSettings } from "../settings.ts";
16import * as HostProcess from "@t3tools/shared/HostProcess";
17import * as Deferred from "effect/Deferred";
18import * as Effect from "effect/Effect";
19import * as Duration from "effect/Duration";
20import * as Fiber from "effect/Fiber";
21import * as FileSystem from "effect/FileSystem";
22import * as Layer from "effect/Layer";
23import * as Logger from "effect/Logger";
24import * as Option from "effect/Option";
25import * as References from "effect/References";
26import * as Stream from "effect/Stream";
27import * as TestClock from "effect/testing/TestClock";
28import * as HttpClient from "effect/http/HttpClient";
29import * as HttpClientResponse from "effect/http/HttpClientResponse";
30import * as FetchHttpClient from "effect/http/FetchHttpClient";
31import * as UrlParams from "effect/http/UrlParams";
32import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
33​
34import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
35import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
36import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
37import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers";
38import * as ProviderMaintenance from "@t3tools/provider-core/server/maintenanceResolver";
39import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
40import { OpenCodeDriver, isLocalOpenCodeServerUrl, openCodeUpdateFor } from "./driver.ts";
41import * as OpenCodeServerLedger from "./OpenCodeServerLedger.ts";
42import {
43 OPENCODE_2_RESPONSES,
44 OPENCODE_2_WORKSPACE_RESPONSES,
45 replayOpenCodeServer,
46} from "./probeResponses.fixture.ts";
47import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
48​
49it("only probes a locally configured OpenCode server's installed CLI", () => {
50 assert.isTrue(isLocalOpenCodeServerUrl("http://127.0.0.1:35768"));
51 assert.isTrue(isLocalOpenCodeServerUrl("http://127.255.255.254:4096"));
52 assert.isFalse(isLocalOpenCodeServerUrl("http://127.example.com:4096"));
53 assert.isFalse(isLocalOpenCodeServerUrl("http://128.0.0.1:4096"));
54 assert.isTrue(isLocalOpenCodeServerUrl("http://localhost:4096"));
55 assert.isTrue(isLocalOpenCodeServerUrl("http://[::1]:4096"));
56 assert.isFalse(isLocalOpenCodeServerUrl("https://remote.example.com:4096"));
57 assert.isFalse(isLocalOpenCodeServerUrl(""));
58 assert.isFalse(isLocalOpenCodeServerUrl("file:///tmp/opencode"));
59});
60​
61const serverStarts: Array<string> = [];
62const reachedServer = (operation: string) =>
63 Effect.sync(() => serverStarts.push(operation)).pipe(
64 Effect.andThen(
65 Effect.fail(
66 new OpenCodeRuntime.OpenCodeRuntimeError({
67 operation,
68 detail: "reached a 1.x server path",
69 }),
70 ),
71 ),
72 );
73const openCode2Runtime = {
74 runOpenCodeCommand: () => Effect.succeed({ stdout: "opencode v2.0.18\n", stderr: "", code: 0 }),
75 startOpenCodeServerProcess: () => reachedServer("start"),
76 connectToOpenCodeServer: () => reachedServer("connect"),
77} as unknown as OpenCodeRuntime.OpenCodeRuntime["Service"];
78​
79const layer = Layer.mergeAll(
80 IdAllocator.layer,
81 McpProviderSessions.layer,
82 ProviderLatestVersions.layer,
83 TestProviderHost.layer(),
84 Layer.succeed(
85 ProviderEventLoggers.ProviderEventLoggers,
86 ProviderEventLoggers.NoOpProviderEventLoggers,
87 ),
88 Layer.succeed(OpenCodeRuntime.OpenCodeRuntime, openCode2Runtime),
89).pipe(Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
90​
91const create = (config: Partial<OpenCodeSettings>, http: HttpClient.HttpClient, enabled = true) =>
92 OpenCodeDriver.create({
93 instanceId: ProviderInstanceId.make("opencode-test"),
94 displayName: undefined,
95 environment: [],
96 enabled,
97 config: { ...OpenCodeDriver.defaultConfig(), ...config },
98 }).pipe(Effect.provideService(HttpClient.HttpClient, http));
99​
100const noHttp = HttpClient.make(() => Effect.die("A local binary must not be probed over HTTP"));
101​
102const openCode2Project = "/work/project-with-config";
103const openCode2Model = (providerID: string, id: string, name: string) => ({
104 id,
105 modelID: id,
106 providerID,
107 name,
108 package: "@opencode/ai/providers/openai-compatible",
109 settings: {},
110 compatibility: {},
111 capabilities: { tools: true, input: ["text"], output: ["text"] },
112 variants: [],
113 time: { released: 1789516800000 },
114 cost: [{ input: 0, output: 0, cache: { read: 0, write: 0 } }],
115 status: "active",
116 enabled: true,
117 limit: { context: 1000000, output: 65536 },
118});
119// Serves one machine catalog everywhere plus extra models for the project directory.
120const makeOpenCode2ProjectInstance = (
121 projectCatalog: "listed" | "models-unavailable" | "providers-unavailable",
122) =>
123 Effect.gen(function* () {
124 const machineModels = [openCode2Model("opencode", "big-pickle", "Big Pickle")];
125 const projectModels = [
126 ...machineModels,
127 openCode2Model("uni", "medium-gpt", "Medium GPT"),
128 openCode2Model("uni", "large-gpt", "Large GPT"),
129 ];
130 const replay = replayOpenCodeServer(
131 { ...OPENCODE_2_RESPONSES, ...OPENCODE_2_WORKSPACE_RESPONSES },
132 "secret",
133 );
134 const server = HttpClient.make((request) => {
135 const pathname = new URL(request.url).pathname;
136 if (pathname !== "/api/model" && pathname !== "/api/provider") {
137 return replay.execute(request);
138 }
139 const directory = Option.getOrUndefined(
140 UrlParams.getFirst(request.urlParams, "location[directory]"),
141 );
142 const isProject = directory === openCode2Project;
143 const data = pathname === "/api/provider" ? [] : isProject ? projectModels : machineModels;
144 const unavailable =
145 isProject &&
146 ((pathname === "/api/model" && projectCatalog === "models-unavailable") ||
147 (pathname === "/api/provider" && projectCatalog === "providers-unavailable"));
148 return Effect.succeed(
149 HttpClientResponse.fromWeb(
150 request,
151 new Response(JSON.stringify({ location: { directory }, data }), {
152 status: unavailable ? 503 : 200,
153 headers: { "content-type": "application/json" },
154 }),
155 ),
156 );
157 });
158 const instance = yield* create(
159 { serverUrl: "http://127.0.0.1:4096", serverPassword: "secret" },
160 server,
161 );
162 const ready = yield* instance.snapshot.streamChanges.pipe(
163 Stream.filter((snapshot) => snapshot.status === "ready"),
164 Stream.take(1),
165 Stream.runCollect,
166 Effect.forkChild,
167 );
168 yield* TestClock.adjust("5 seconds");
169 yield* Fiber.join(ready);
170 // Catalog reads repeat until two agree, so let them settle on the test clock.
171 return (cwd: string) =>
172 Effect.gen(function* () {
173 const read = yield* Effect.forkChild(instance.snapshotForCwd!(cwd));
174 yield* TestClock.adjust("5 seconds");
175 return yield* Fiber.join(read);
176 });
177 });
178​
179it.live("discovers models through a home-relative OpenCode wrapper", () =>
180 Effect.gen(function* () {
181 const fs = yield* FileSystem.FileSystem;
182 const home = yield* fs.makeTempDirectoryScoped({ prefix: "t3-opencode-home with spaces-" });
183 const binaryPath = NodePath.join(home, "opencode");
184 const scriptPath = NodePath.join(home, "opencode.cjs");
185 yield* fs.writeFileString(
186 scriptPath,
187 `if (process.argv.includes('--version')) {
188 console.log('1.18.32');
189 } else {
190 const server = require('node:http').createServer((req, res) => {
191 const route = new URL(req.url, 'http://localhost').pathname;
192 res.setHeader('content-type', 'application/json');
193 res.end(JSON.stringify(route === '/global/health'
194 ? { healthy: true, version: '1.18.32' }
195 : route === '/provider'
196 ? { connected: ['opencode'], default: {}, all: [{
197 id: 'opencode', name: 'OpenCode', models: {
198 'big-pickle': { id: 'big-pickle', name: 'Big Pickle' }
199 }
200 }] }
201 : []));
202 });
203 server.listen(0, '127.0.0.1', () => {
204 console.log('opencode server listening on http://127.0.0.1:' + server.address().port);
205 });
206 }`,
207 );
208 const windows = (yield* HostProcess.Platform) === "win32";
209 const wrapperPath = windows ? `${binaryPath}.cmd` : binaryPath;
210 const node = yield* HostProcess.ExecutablePath;
211 yield* fs.writeFileString(
212 wrapperPath,
213 windows
214 ? `@echo off\r\n"${node}" "${scriptPath}" %*\r\n`
215 : `#!/bin/sh\nexec "${node}" "${scriptPath}" "$@"\n`,
216 );
217 if (!windows) yield* fs.chmod(wrapperPath, 0o755);
218​
219 const instance = yield* OpenCodeDriver.create({
220 instanceId: ProviderInstanceId.make("opencode-home"),
221 displayName: undefined,
222 environment: [],
223 enabled: true,
224 config: {
225 ...OpenCodeDriver.defaultConfig(),
226 binaryPath: windows ? "~/opencode.cmd" : "~/opencode",
227 },
228 }).pipe(Effect.provideService(HostProcess.HomeDirectory, home));
229 const snapshot = yield* instance.snapshot.refresh;
230 assert.strictEqual(snapshot.status, "ready");
231 assert.strictEqual(snapshot.version, "1.18.32");
232 assert.isTrue(snapshot.models.some((model) => model.slug === "opencode/big-pickle"));
233 }).pipe(
234 Effect.scoped,
235 Effect.provide(
236 Layer.mergeAll(
237 IdAllocator.layer,
238 McpProviderSessions.layer,
239 ProviderLatestVersions.layer,
240 TestProviderHost.layer({ runBackgroundWork: false }),
241 Layer.succeed(
242 ProviderEventLoggers.ProviderEventLoggers,
243 ProviderEventLoggers.NoOpProviderEventLoggers,
244 ),
245 OpenCodeRuntime.layer.pipe(Layer.provide(OpenCodeServerLedger.layerTest)),
246 ).pipe(
247 Layer.provideMerge(
248 Layer.mergeAll(NodeServices.layer, NodeCrypto.layer, FetchHttpClient.layer),
249 ),
250 ),
251 ),
252 ),
253);
254​
255// Under MISE_OFFLINE the shim cannot install OpenCode; a normal run installs 2.x first.
256const lazyMiseShim = {
257 ...openCode2Runtime,
258 runOpenCodeCommand: ({ environment }: { readonly environment?: NodeJS.ProcessEnv }) =>
259 environment?.MISE_OFFLINE === "1"
260 ? Effect.fail(
261 new OpenCodeRuntime.OpenCodeRuntimeError({
262 operation: "runOpenCodeCommand",
263 detail: "mise ERROR Failed to install opencode@latest",
264 }),
265 )
266 : Effect.succeed({ stdout: "opencode v2.0.18\n", stderr: "", code: 0 }),
267} as unknown as OpenCodeRuntime.OpenCodeRuntime["Service"];
268​
269it.layer(layer)("OpenCodeDriver runtime selection", (it) => {
270 it.effect("never starts a 1.x server for an OpenCode 2 instance", () =>
271 Effect.gen(function* () {
272 serverStarts.length = 0;
273 const instance = yield* create({}, noHttp);
274 yield* Effect.flip(
275 instance.textGeneration.generateThreadTitle({
276 cwd: process.cwd(),
277 message: "hello",
278 modelSelection: { instanceId: instance.instanceId, model: "opencode/big-pickle" },
279 }),
280 );
281 assert.deepStrictEqual(serverStarts, ["start"]);
282 }).pipe(Effect.scoped),
283 );
284​
285 it.effect.each(["2.1.2", null])(
286 "reports the installed CLI version independently of the loopback server (%s)",
287 (installedVersion) =>
288 Effect.gen(function* () {
289 const probeOffline: Array<string | undefined> = [];
290 const runtime = {
291 ...openCode2Runtime,
292 runOpenCodeCommand: (input) =>
293 Effect.sync(() => {
294 probeOffline.push(input.environment?.MISE_OFFLINE);
295 return {
296 stdout:
297 installedVersion === null ? "unrecognized" : `opencode v${installedVersion}\n`,
298 stderr: "",
299 code: 0,
300 };
301 }),
302 } as OpenCodeRuntime.OpenCodeRuntime["Service"];
303 const instance = yield* create(
304 { serverUrl: "http://127.0.0.1:4096" },
305 replayOpenCodeServer(OPENCODE_2_RESPONSES, ""),
306 ).pipe(Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, runtime));
307​
308 const snapshot = yield* instance.snapshot.refresh;
309 assert.strictEqual(snapshot.version, "2.0.18");
310 assert.strictEqual(snapshot.installedVersion, installedVersion ?? undefined);
311 const maintenance = yield* instance.snapshot.resolveMaintenance({ fresh: true });
312 assert.strictEqual(maintenance.packageName, "@opencode/cli");
313 assert.isNotEmpty(probeOffline);
314 assert.isTrue(probeOffline.every((offline) => offline === "1"));
315 }).pipe(Effect.scoped),
316 );
317​
318 it.effect("skips the installed CLI probe when a localhost provider is disabled", () =>
319 Effect.gen(function* () {
320 const probed: string[] = [];
321 const runtime = {
322 ...openCode2Runtime,
323 runOpenCodeCommand: () =>
324 Effect.sync(() => {
325 probed.push("--version");
326 return { stdout: "opencode v2.1.2\n", stderr: "", code: 0 };
327 }),
328 } as OpenCodeRuntime.OpenCodeRuntime["Service"];
329 const instance = yield* create({ serverUrl: "http://127.0.0.1:4096" }, noHttp, false).pipe(
330 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, runtime),
331 );
332​
333 const snapshot = yield* instance.snapshot.refresh;
334 assert.isFalse(snapshot.enabled);
335 assert.deepStrictEqual(probed, []);
336 }).pipe(Effect.scoped),
337 );
338​
339 it.effect("opens a session through OpenCode 2 that a lazy mise shim installs on first use", () =>
340 Effect.gen(function* () {
341 serverStarts.length = 0;
342 const instance = yield* create({}, noHttp).pipe(
343 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, lazyMiseShim),
344 // The background status check probes offline, which this shim always fails.
345 Effect.provide(TestProviderHost.layer({ runBackgroundWork: false })),
346 );
347​
348 yield* instance.orchestrationAdapter
349 .openSession({
350 threadId: ThreadId.make("thread-lazy-mise"),
351 providerSessionId: ProviderSessionId.make("session-lazy-mise"),
352 modelSelection: { instanceId: instance.instanceId, model: "opencode/big-pickle" },
353 runtimePolicy: { runtimeMode: "full-access", interactionMode: "default", cwd: null },
354 })
355 .pipe(Effect.scoped, Effect.flip);
356 assert.deepStrictEqual(serverStarts, ["start"], "the OpenCode 2 adapter starts its server");
357 const capabilities = yield* instance.orchestrationAdapter.getCapabilities();
358 assert.isTrue(capabilities.sessions.supportsRuntimeModeSwitchInSession);
359 }).pipe(Effect.scoped),
360 );
361​
362 it.effect("does not scan a workspace through a 1.x server it could not probe offline", () =>
363 Effect.gen(function* () {
364 serverStarts.length = 0;
365 const instance = yield* create({}, noHttp).pipe(
366 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, lazyMiseShim),
367 );
368​
369 yield* Effect.flip(instance.snapshotForCwd!(process.cwd()));
370 assert.deepStrictEqual(serverStarts, []);
371 }).pipe(Effect.scoped),
372 );
373​
374 it.effect.each([
375 "1.18.32",
376 "opencode v2.0.18",
377 "opencode v2.2.4",
378 "opencode v2.2.5",
379 "opencode v2.2.6",
380 ])("advertises native goal support only for supported OpenCode versions: %s", (version) =>
381 Effect.gen(function* () {
382 const fs = yield* FileSystem.FileSystem;
383 const root = yield* fs.makeTempDirectoryScoped({ prefix: "opencode-goal-capability-" });
384 const binaryPath = NodePath.join(
385 root,
386 "lib",
387 "node_modules",
388 "@opencode",
389 "cli",
390 "bin",
391 "opencode",
392 );
393 yield* fs.makeDirectory(NodePath.dirname(binaryPath), { recursive: true });
394 yield* fs.writeFileString(binaryPath, "");
395 const instance = yield* create({ binaryPath }, noHttp).pipe(
396 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, {
397 ...openCode2Runtime,
398 runOpenCodeCommand: () => Effect.succeed({ stdout: version, stderr: "", code: 0 }),
399 }),
400 );
401 yield* instance.snapshot.resolveMaintenance({ fresh: true });
402 const capabilities = yield* instance.orchestrationAdapter.getCapabilities();
403 assert.equal(
404 capabilities.turns.supportsNativeGoals === true,
405 version.endsWith("2.2.5") || version.endsWith("2.2.6"),
406 );
407 }).pipe(Effect.scoped),
408 );
409​
410 it.effect("uses the connected OpenCode version for goal support after an upgrade", () =>
411 Effect.gen(function* () {
412 const fs = yield* FileSystem.FileSystem;
413 const root = yield* fs.makeTempDirectoryScoped({ prefix: "opencode-upgraded-goals-" });
414 const binaryPath = NodePath.join(
415 root,
416 "lib",
417 "node_modules",
418 "@opencode",
419 "cli",
420 "bin",
421 "opencode",
422 );
423 yield* fs.makeDirectory(NodePath.dirname(binaryPath), { recursive: true });
424 yield* fs.writeFileString(binaryPath, "");
425 const http = HttpClient.make((request) => {
426 const path = new URL(request.url).pathname;
427 if (path === "/api/info")
428 return Effect.succeed(
429 HttpClientResponse.fromWeb(
430 request,
431 Response.json({
432 ...JSON.parse(OPENCODE_2_RESPONSES["/api/info"].body),
433 version: "2.2.5",
434 }),
435 ),
436 );
437 if (path === "/api/model")
438 return Effect.succeed(
439 HttpClientResponse.fromWeb(
440 request,
441 Response.json({ location: { directory: "/work" }, data: [] }),
442 ),
443 );
444 if (path === "/api/event")
445 return Effect.succeed(
446 HttpClientResponse.fromWeb(
447 request,
448 new Response(new ReadableStream(), {
449 headers: { "content-type": "text/event-stream" },
450 }),
451 ),
452 );
453 return Effect.die(`Unexpected request: ${path}`);
454 });
455 const instance = yield* create({ binaryPath }, http).pipe(
456 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, {
457 ...openCode2Runtime,
458 runOpenCodeCommand: () =>
459 Effect.succeed({ stdout: "opencode v2.2.4", stderr: "", code: 0 }),
460 startOpenCodeServerProcess: ({ verify }) =>
461 Effect.gen(function* () {
462 const url = "http://127.0.0.1:4096";
463 const version = verify ? yield* verify(url) : "2.2.5";
464 return { url, version, isRunning: Effect.succeed(true), exitCode: Effect.never };
465 }),
466 }),
467 );
468 yield* instance.snapshot.resolveMaintenance({ fresh: true });
469 assert.isFalse(
470 (yield* instance.orchestrationAdapter.getCapabilities()).turns.supportsNativeGoals,
471 );
472 const session = yield* instance.orchestrationAdapter.openSession({
473 threadId: ThreadId.make("upgraded-goal"),
474 providerSessionId: ProviderSessionId.make("upgraded-goal"),
475 modelSelection: { instanceId: instance.instanceId, model: "opencode/big-pickle" },
476 runtimePolicy: { runtimeMode: "full-access", interactionMode: "default", cwd: null },
477 });
478 assert.isTrue(session.providerSession.capabilities.turns.supportsNativeGoals);
479 assert.isTrue(
480 (yield* instance.orchestrationAdapter.getCapabilities()).turns.supportsNativeGoals,
481 );
482 }).pipe(Effect.scoped),
483 );
484​
485 it.effect("answers capability reads without waiting on an unreachable server", () =>
486 Effect.gen(function* () {
487 const hang = HttpClient.make(() => Effect.never);
488 const instance = yield* create({ serverUrl: "http://127.0.0.1:9" }, hang);
489​
490 const capabilities = yield* instance.orchestrationAdapter
491 .getCapabilities()
492 .pipe(Effect.forkChild);
493 yield* Effect.yieldNow;
494 assert.isDefined(capabilities.pollUnsafe());
495 yield* Fiber.join(capabilities);
496 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
497 );
498​
499 it.effect.each(["/api/debug/location", "/api/event"])(
500 "lists workspace skills from an external OpenCode 2 server whose %s never answers",
501 (stalled) =>
502 Effect.gen(function* () {
503 const answers: Record<string, string> = {
504 "/api/info": OPENCODE_2_RESPONSES["/api/info"].body,
505 "/api/debug/location": "[]",
506 "/api/model": '{"location":{"directory":"/work"},"data":[]}',
507 "/api/provider": '{"location":{"directory":"/work"},"data":[]}',
508 "/api/command": OPENCODE_2_WORKSPACE_RESPONSES["/api/command"].body,
509 "/api/skill": OPENCODE_2_WORKSPACE_RESPONSES["/api/skill"].body,
510 };
511 const http = HttpClient.make((request) => {
512 const path = new URL(request.url).pathname;
513 if (path === stalled) return Effect.never;
514 if (path === "/api/event")
515 return Effect.succeed(
516 HttpClientResponse.fromWeb(
517 request,
518 new Response(new ReadableStream(), {
519 headers: { "content-type": "text/event-stream" },
520 }),
521 ),
522 );
523 const body = answers[path];
524 return body === undefined
525 ? Effect.die(`Unexpected request: ${path}`)
526 : Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(JSON.parse(body))));
527 });
528 const instance = yield* create({ serverUrl: "http://127.0.0.1:4096" }, http);
529​
530 const snapshot = yield* instance.snapshotForCwd!("/work").pipe(Effect.forkChild);
531 yield* TestClock.adjust("30 seconds");
532 const { skills } = yield* Fiber.join(snapshot);
533 assert.include(
534 skills.map((skill) => skill.name),
535 "plum",
536 );
537 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
538 );
539​
540 it.effect("caches a cold OpenCode 2 directory's skills only after its scan ends", () =>
541 Effect.gen(function* () {
542 // OpenCode 2.2.7: touching a location lists it as loaded with built-in commands and skills
543 // at once, while provider.list waits for the scan that adds the project's skills.
544 const scanEnded = yield* Deferred.make<void>();
545 const builtinSkills = JSON.stringify({
546 location: { directory: "/work" },
547 data: (
548 JSON.parse(OPENCODE_2_WORKSPACE_RESPONSES["/api/skill"].body).data as Array<{
549 id: string;
550 }>
551 ).filter((skill) => skill.id !== "plum"),
552 });
553 const http = HttpClient.make((request) => {
554 const path = new URL(request.url).pathname;
555 const json = (body: string) =>
556 Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(JSON.parse(body))));
557 const afterScan = (body: string) =>
558 Deferred.await(scanEnded).pipe(Effect.andThen(json(body)));
559 switch (path) {
560 case "/api/info":
561 return json(
562 JSON.stringify({
563 ...JSON.parse(OPENCODE_2_RESPONSES["/api/info"].body),
564 version: "2.2.7",
565 }),
566 );
567 case "/api/event":
568 return Effect.succeed(
569 HttpClientResponse.fromWeb(
570 request,
571 new Response(new ReadableStream(), {
572 headers: { "content-type": "text/event-stream" },
573 }),
574 ),
575 );
576 case "/api/debug/location":
577 return json('[{"directory":"/work"}]');
578 case "/api/provider":
579 case "/api/model":
580 return afterScan('{"location":{"directory":"/work"},"data":[]}');
581 case "/api/command":
582 return json(OPENCODE_2_WORKSPACE_RESPONSES["/api/command"].body);
583 case "/api/skill":
584 return Deferred.isDone(scanEnded).pipe(
585 Effect.flatMap((done) =>
586 json(done ? OPENCODE_2_WORKSPACE_RESPONSES["/api/skill"].body : builtinSkills),
587 ),
588 );
589 default:
590 return Effect.die(`Unexpected request: ${path}`);
591 }
592 });
593 const instance = yield* create({ serverUrl: "http://127.0.0.1:4096" }, http);
594​
595 const snapshot = yield* instance.snapshotForCwd!("/work").pipe(Effect.forkChild);
596 yield* TestClock.adjust("1 second");
597 yield* Deferred.succeed(scanEnded, undefined);
598 yield* TestClock.adjust("30 seconds");
599 const { skills } = yield* Fiber.join(snapshot);
600 assert.include(
601 skills.map((skill) => skill.name),
602 "plum",
603 );
604 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
605 );
606​
607 it.effect.each(["probe", "error", "empty"] as const)(
608 "recovers discovery without a manual refresh after %s",
609 (initialCatalog) =>
610 Effect.gen(function* () {
611 const releaseCatalog = yield* Deferred.make<void>();
612 const discoveryLogs: Array<Record<string, unknown>> = [];
613 const logger = Logger.make(({ message, fiber }) => {
614 if (Array.isArray(message) && message.includes("OpenCode discovery failed")) {
615 discoveryLogs.push({ ...fiber.getRef(References.CurrentLogAnnotations) });
616 }
617 });
618 let catalogAvailable = false;
619 let modelReads = 0;
620 const replies = {
621 ...OPENCODE_2_RESPONSES,
622 "/api/provider": {
623 status: 200,
624 contentType: "application/json",
625 body: '{"location":{"directory":"/work"},"data":[]}',
626 },
627 "/api/model": {
628 status: 200,
629 contentType: "application/json",
630 body: JSON.stringify({
631 location: { directory: "/work" },
632 data: [
633 {
634 id: "big-pickle",
635 modelID: "big-pickle",
636 providerID: "opencode",
637 name: "Big Pickle",
638 package: "@opencode/ai/providers/openai-compatible",
639 settings: {},
640 compatibility: {},
641 capabilities: { tools: true, input: ["text"], output: ["text"] },
642 variants: [],
643 time: { released: 1789516800000 },
644 cost: [{ input: 0, output: 0, cache: { read: 0, write: 0 } }],
645 status: "active",
646 enabled: true,
647 limit: { context: 1000000, output: 65536 },
648 },
649 ],
650 }),
651 },
652 };
653 const replay = replayOpenCodeServer(replies, "secret");
654 const server = HttpClient.make((request) =>
655 Effect.gen(function* () {
656 if (initialCatalog === "probe" && !catalogAvailable) {
657 yield* Deferred.await(releaseCatalog);
658 return HttpClientResponse.fromWeb(
659 request,
660 new Response('{"_tag":"InternalServerError","message":"server starting"}', {
661 status: 503,
662 headers: { "content-type": "application/json" },
663 }),
664 );
665 }
666 if (new URL(request.url).pathname === "/api/model") {
667 modelReads += 1;
668 yield* Deferred.await(releaseCatalog);
669 if (!catalogAvailable) {
670 return HttpClientResponse.fromWeb(
671 request,
672 new Response(
673 initialCatalog === "error"
674 ? '{"_tag":"InternalServerError","message":"catalog unavailable"}'
675 : '{"location":{"directory":"/work"},"data":[]}',
676 {
677 status: initialCatalog === "error" ? 500 : 200,
678 headers: { "content-type": "application/json" },
679 },
680 ),
681 );
682 }
683 }
684 return yield* replay.execute(request);
685 }),
686 );
687 const instance = yield* create(
688 { serverUrl: "http://127.0.0.1:4096", serverPassword: "secret" },
689 server,
690 ).pipe(Effect.provide(Logger.layer([logger], { mergeWithExisting: false })));
691 const initial = yield* instance.snapshot.streamChanges.pipe(
692 Stream.filter(
693 (snapshot) =>
694 snapshot.installed &&
695 snapshot.status === (initialCatalog === "empty" ? "warning" : "error"),
696 ),
697 Stream.take(1),
698 Stream.runCollect,
699 Effect.forkChild,
700 );
701 yield* Effect.yieldNow;
702 yield* Deferred.succeed(releaseCatalog, undefined);
703 yield* TestClock.adjust("5 seconds");
704 const [failed] = Array.from(yield* Fiber.join(initial));
705 assert.strictEqual(failed?.auth.status, "unknown");
706 assert.deepStrictEqual(failed?.models, []);
707 if (initialCatalog === "probe") assert.strictEqual(failed?.version, null);
708 assert.strictEqual(discoveryLogs.length, 1);
709 assert.strictEqual(discoveryLogs[0]?.providerInstanceId, "opencode-test");
710 assert.strictEqual(discoveryLogs[0]?.serverMode, "external");
711 assert.strictEqual(
712 discoveryLogs[0]?.phase,
713 initialCatalog === "probe" ? "version" : "models",
714 );
715​
716 catalogAvailable = true;
717 const recovered = yield* instance.snapshot.streamChanges.pipe(
718 Stream.filter((snapshot) => snapshot.status === "ready"),
719 Stream.take(1),
720 Stream.runCollect,
721 Effect.forkChild,
722 );
723 yield* TestClock.adjust("5 minutes");
724 assert.strictEqual((yield* instance.snapshot.getSnapshot).status, "ready");
725 const [ready] = Array.from(yield* Fiber.join(recovered));
726 assert.strictEqual(ready?.auth.status, "authenticated");
727 assert.deepStrictEqual(
728 ready?.models.map((model) => model.slug),
729 ["opencode/big-pickle"],
730 );
731​
732 const readsAfterRecovery = modelReads;
733 yield* TestClock.adjust("15 minutes");
734 assert.strictEqual(modelReads, readsAfterRecovery);
735 assert.strictEqual(discoveryLogs.length, 1);
736 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
737 );
738​
739 it.effect("lists a project's own opencode.jsonc models in that project's snapshot", () =>
740 Effect.gen(function* () {
741 const snapshotFor = yield* makeOpenCode2ProjectInstance("listed");
742​
743 const projectSnapshot = yield* snapshotFor(openCode2Project);
744 assert.deepStrictEqual(projectSnapshot.models.map((entry) => entry.slug).toSorted(), [
745 "opencode/big-pickle",
746 "uni/large-gpt",
747 "uni/medium-gpt",
748 ]);
749 const otherSnapshot = yield* snapshotFor("/work/other-project");
750 assert.deepStrictEqual(
751 otherSnapshot.models.map((entry) => entry.slug),
752 ["opencode/big-pickle"],
753 );
754 assert.strictEqual(otherSnapshot.workspaceModels, undefined);
755 assert.strictEqual(otherSnapshot.workspaceModelsPending, undefined);
756 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
757 );
758​
759 it.effect.each(["models-unavailable", "providers-unavailable"] as const)(
760 "reports a project's catalog unknown when its read fails (%s)",
761 (projectCatalog) =>
762 Effect.gen(function* () {
763 const snapshotFor = yield* makeOpenCode2ProjectInstance(projectCatalog);
764​
765 const projectSnapshot = yield* snapshotFor(openCode2Project);
766 assert.deepStrictEqual(
767 projectSnapshot.models.map((entry) => entry.slug),
768 ["opencode/big-pickle"],
769 );
770 assert.strictEqual(projectSnapshot.workspaceModels, undefined);
771 assert.strictEqual(projectSnapshot.workspaceModelsPending, true);
772 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
773 );
774​
775 it.effect("does not retry a rejected server password in the background", () =>
776 Effect.gen(function* () {
777 const releaseResponse = yield* Deferred.make<void>();
778 const requested: Array<string> = [];
779 const server = replayOpenCodeServer(OPENCODE_2_RESPONSES, "secret", requested);
780 const instance = yield* create(
781 { serverUrl: "http://127.0.0.1:4096", serverPassword: "wrong" },
782 HttpClient.make((request) =>
783 Deferred.await(releaseResponse).pipe(Effect.andThen(server.execute(request))),
784 ),
785 );
786 // Wait for startup and its maintenance enrichment, both of which probe.
787 const rejected = yield* instance.snapshot.streamChanges.pipe(
788 Stream.filter(
789 (snapshot) => snapshot.status === "error" && snapshot.versionAdvisory !== undefined,
790 ),
791 Stream.take(1),
792 Stream.runCollect,
793 Effect.forkChild,
794 );
795 yield* Effect.yieldNow;
796 yield* Deferred.succeed(releaseResponse, undefined);
797 const [snapshot] = Array.from(yield* Fiber.join(rejected));
798 assert.strictEqual(snapshot?.version, null);
799 assert.strictEqual(snapshot?.auth.status, "unauthenticated");
800 const readsAfterRejection = requested.length;
801​
802 yield* TestClock.adjust("15 minutes");
803 assert.strictEqual(requested.length, readsAfterRejection);
804 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
805 );
806​
807 it.effect.each([
808 { status: 200, data: null, reason: "unsupported" },
809 { status: 404, data: null, reason: "unsupported" },
810 { status: 503, data: null, reason: "probeFailed" },
811 {
812 status: 200,
813 data: {
814 workspace: {
815 id: "remote-workspace",
816 name: "Remote workspace",
817 usageURL: "https://opencode.ai/console/remote-workspace",
818 },
819 budgets: [
820 {
821 id: "all",
822 limit: 20,
823 spent: 15,
824 scope: "combined",
825 per: "set",
826 coverage: "all",
827 models: [],
828 shared: true,
829 resetsAt: 1793491200000,
830 },
831 ],
832 },
833 reason: undefined,
834 },
835 ])(
836 "reads external workspace usage without local credentials, HTTP $status, $reason",
837 (scenario) =>
838 Effect.gen(function* () {
839 const requested: string[] = [];
840 const replay = replayOpenCodeServer(OPENCODE_2_RESPONSES, "secret", requested);
841 const server = HttpClient.make((request) => {
842 assert.notInclude(request.url, "opencode.ai/zen");
843 if (request.url.endsWith("/api/experimental/usage/limits")) {
844 assert.strictEqual(request.headers.authorization, "Basic b3BlbmNvZGU6c2VjcmV0");
845 return Effect.succeed(
846 HttpClientResponse.fromWeb(
847 request,
848 Response.json(
849 {
850 location: { directory: "/work" },
851 data: scenario.data,
852 },
853 { status: scenario.status },
854 ),
855 ),
856 );
857 }
858 return replay.execute(request);
859 });
860 const instance = yield* create(
861 { serverUrl: "https://remote.example", serverPassword: "secret" },
862 server,
863 );
864 const [snapshot] = Array.from(
865 yield* instance.snapshot.streamChanges.pipe(
866 Stream.filter((snapshot) => snapshot.usageLimits !== undefined),
867 Stream.take(1),
868 Stream.runCollect,
869 ),
870 );
871 assert.strictEqual(snapshot?.usageLimits?.unavailable?.reason, scenario.reason);
872 if (scenario.reason === undefined) {
873 assert.strictEqual(snapshot?.usageLimits?.windows[0]?.usedPercent, 75);
874 assert.strictEqual(snapshot?.usageLimits?.externalUsage?.label, "Remote workspace");
875 assert.deepStrictEqual(snapshot?.usageLimits?.windows[0]?.providerIds, []);
876 } else {
877 assert.deepStrictEqual(snapshot?.usageLimits?.windows, []);
878 }
879 }).pipe(Effect.scoped),
880 );
881​
882 it.effect.each(
883 [
884 { name: "recovers" },
885 { name: "skips without demand", demand: false },
886 { name: "respects a disabled interval", intervalOff: true },
887 { name: "skips disabled instances", enabled: false },
888 { name: "skips unsupported usage", unsupported: true },
889 ].map((scenario) => ({
890 enabled: true,
891 demand: true,
892 intervalOff: false,
893 unsupported: false,
894 ...scenario,
895 })),
896 )("Go usage recovery $name without restarting a ready catalog", (scenario) =>
897 Effect.gen(function* () {
898 const usageStarted = yield* Deferred.make<void>();
899 let usageReads = 0;
900 let serverStarts = 0;
901 let modelReads = 0;
902 const server = HttpClient.make((request) => {
903 if (request.url === "https://opencode.ai/zen/go/v1/usage") {
904 usageReads += 1;
905 assert.strictEqual(request.headers.authorization, "Bearer test-go-key");
906 if (scenario.unsupported)
907 return Effect.succeed(
908 HttpClientResponse.fromWeb(request, new Response(null, { status: 403 })),
909 );
910 if (usageReads === 1)
911 return Deferred.succeed(usageStarted, undefined).pipe(Effect.andThen(Effect.never));
912 const window = { percent: 10, resetsAt: "2026-11-01T00:00:00.000Z" };
913 return Effect.succeed(
914 HttpClientResponse.fromWeb(
915 request,
916 Response.json({ usage: { rolling: window, weekly: window, monthly: window } }),
917 ),
918 );
919 }
920 const path = new URL(request.url).pathname;
921 if (path === "/api/experimental/usage/limits")
922 return Effect.succeed(
923 HttpClientResponse.fromWeb(request, new Response(null, { status: 404 })),
924 );
925 if (path === "/api/model") modelReads += 1;
926 const body =
927 path === "/api/info"
928 ? JSON.parse(OPENCODE_2_RESPONSES["/api/info"].body)
929 : {
930 location: { directory: "/work" },
931 data:
932 path === "/api/model"
933 ? [
934 {
935 id: "big-pickle",
936 modelID: "big-pickle",
937 providerID: "opencode",
938 name: "Big Pickle",
939 package: "@opencode/ai/providers/openai-compatible",
940 settings: {},
941 compatibility: {},
942 capabilities: { tools: true, input: ["text"], output: ["text"] },
943 variants: [],
944 time: { released: 1789516800000 },
945 cost: [],
946 status: "active",
947 enabled: true,
948 limit: { context: 1000000, output: 65536 },
949 },
950 ]
951 : [],
952 };
953 return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(body)));
954 });
955 const runtime = {
956 ...openCode2Runtime,
957 startOpenCodeServerProcess: ({
958 verify,
959 }: Parameters<
960 OpenCodeRuntime.OpenCodeRuntime["Service"]["startOpenCodeServerProcess"]
961 >[0]) =>
962 Effect.gen(function* () {
963 serverStarts += 1;
964 const url = "http://127.0.0.1:4096";
965 const version = verify ? yield* verify(url) : "2.0.18";
966 return { url, version, isRunning: Effect.succeed(true), exitCode: Effect.never };
967 }),
968 };
969 const instance = yield* OpenCodeDriver.create({
970 instanceId: ProviderInstanceId.make("opencode-usage-recovery"),
971 displayName: undefined,
972 environment: [
973 {
974 name: "OPENCODE_AUTH_CONTENT",
975 sensitive: true,
976 value: JSON.stringify({
977 "opencode-go": { type: "api", key: "test-go-key" },
978 }),
979 },
980 ],
981 enabled: scenario.enabled,
982 config: OpenCodeDriver.defaultConfig(),
983 }).pipe(
984 Effect.provide(
985 TestProviderHost.layer({
986 runBackgroundWork: scenario.demand,
987 settings: scenario.intervalOff
988 ? {
989 ...DEFAULT_SERVER_SETTINGS,
990 backgroundActivity: {
991 ...DEFAULT_SERVER_SETTINGS.backgroundActivity,
992 profile: "custom",
993 overrides: { providerHealthRefreshInterval: Duration.zero },
994 },
995 }
996 : DEFAULT_SERVER_SETTINGS,
997 }),
998 ),
999 Effect.provideService(HttpClient.HttpClient, server),
1000 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, runtime),
1001 );
1002 const initial = scenario.enabled
1003 ? yield* instance.snapshot.streamChanges.pipe(
1004 Stream.filter((snapshot) => snapshot.usageLimits !== undefined),
1005 Stream.take(1),
1006 Stream.runCollect,
1007 Effect.forkChild,
1009 : undefined;
1010 if (scenario.enabled && !scenario.unsupported) yield* Deferred.await(usageStarted);
1011 yield* TestClock.adjust("5 seconds");
1012 const failed = initial
1013 ? Array.from(yield* Fiber.join(initial))[0]
1014 : yield* instance.snapshot.getSnapshot;
1015 if (scenario.enabled) {
1016 assert.strictEqual(failed?.status, "ready");
1017 assert.strictEqual(failed?.auth.status, "authenticated");
1019 const initialReason =
1020 scenario.enabled && !scenario.unsupported ? "probeFailed" : "unsupported";
1021 assert.strictEqual(failed?.usageLimits?.unavailable?.reason, initialReason);
1022 const catalogReads = modelReads;
1023 const starts = serverStarts;
1024​
1025 const shouldRecover =
1026 scenario.enabled && scenario.demand && !scenario.intervalOff && !scenario.unsupported;
1027 const recovery = shouldRecover
1028 ? yield* instance.snapshot.streamChanges.pipe(
1029 Stream.filter((snapshot) => snapshot.usageLimits?.windows.length === 3),
1030 Stream.take(1),
1031 Stream.runCollect,
1032 Effect.forkChild,
1034 : undefined;
1035 yield* TestClock.adjust("5 minutes");
1036 const recovered = yield* instance.snapshot.getSnapshot;
1037 const expectedReads = !scenario.enabled ? 0 : shouldRecover ? 2 : 1;
1038 assert.strictEqual(usageReads, expectedReads);
1039 if (recovery) assert.deepStrictEqual(Array.from(yield* Fiber.join(recovery)), [recovered]);
1040 assert.strictEqual(
1041 recovered.usageLimits?.unavailable?.reason,
1042 shouldRecover ? undefined : initialReason,
1043 );
1044 assert.deepStrictEqual(
1045 recovered.usageLimits?.windows.map((window) => window.kind),
1046 shouldRecover ? ["session", "weekly", "monthly"] : [],
1047 );
1048 assert.strictEqual(modelReads, catalogReads);
1049 assert.strictEqual(serverStarts, starts);
1050 yield* TestClock.adjust("15 minutes");
1051 assert.strictEqual(usageReads, expectedReads);
1052 assert.strictEqual(modelReads, catalogReads);
1053 assert.strictEqual(serverStarts, starts);
1054 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
1055 );
1056});
1057​
1058// npm links into opencode-ai for 1.x and @opencode/cli for 2.x.
1059const npmGlobalInstall = (prefix: string, packagePath: ReadonlyArray<string>, bin: string) => {
1060 const target = NodePath.join(prefix, "lib", "node_modules", ...packagePath, "bin", bin);
1061 NodeFS.mkdirSync(NodePath.dirname(target), { recursive: true });
1062 NodeFS.writeFileSync(target, "#!/bin/sh\n");
1063 NodeFS.chmodSync(target, 0o755);
1064 const link = NodePath.join(prefix, "bin", "opencode");
1065 NodeFS.mkdirSync(NodePath.dirname(link), { recursive: true });
1066 NodeFS.symlinkSync(target, link);
1067 return link;
1069const resolveUpdate = (generation: "v1" | "v2", binaryPath: string) =>
1070 ProviderMaintenance.resolveProviderMaintenanceCapabilitiesEffect(openCodeUpdateFor(generation), {
1071 binaryPath,
1072 env: { PATH: "" },
1073 }).pipe(
1074 Effect.provideService(
1075 ChildProcessSpawner.ChildProcessSpawner,
1076 ChildProcessSpawner.make(() => Effect.die("resolving an update must not spawn")),
1077 ),
1078 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
1079 );
1080​
1081it.effect.skipIf(HostProcess.Platform.defaultValue() === "win32")(
1082 "updates npm-global OpenCode by generation and runs upgrade only for its own installer's path",
1083 () =>
1084 Effect.gen(function* () {
1085 const root = NodeFS.realpathSync(
1086 NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-opencode-update-")),
1087 );
1088 const v2Prefix = NodePath.join(root, "v2");
1089 const v1Prefix = NodePath.join(root, "v1");
1090 const v2 = yield* resolveUpdate(
1091 "v2",
1092 npmGlobalInstall(v2Prefix, ["@opencode", "cli"], "opencode.exe"),
1093 );
1094 assert.deepStrictEqual(v2.update?.args, [
1095 "install",
1096 "-g",
1097 "--prefix",
1098 v2Prefix,
1099 "--allow-scripts=@opencode/cli",
1100 "@opencode/cli@latest",
1101 ]);
1102 const v1 = yield* resolveUpdate(
1103 "v1",
1104 npmGlobalInstall(v1Prefix, ["opencode-ai"], "opencode"),
1105 );
1106 assert.strictEqual(v1.update?.args.at(-1), "opencode-ai@latest");
1107 assert.isNull(
1108 (yield* resolveUpdate("v2", NodePath.join(v1Prefix, "bin", "opencode"))).update,
1109 );
1110 assert.isNull(
1111 (yield* resolveUpdate("v1", NodePath.join(v2Prefix, "bin", "opencode"))).update,
1112 );
1113 const executable = (...segments: ReadonlyArray<string>) => {
1114 const path = NodePath.join(root, ...segments);
1115 NodeFS.mkdirSync(NodePath.dirname(path), { recursive: true });
1116 NodeFS.writeFileSync(path, "#!/bin/sh\n");
1117 NodeFS.chmodSync(path, 0o755);
1118 return path;
1119 };
1120 const launcher = executable("launcher", "opencode");
1121 const native = executable(".opencode", "bin", "opencode");
1122 for (const generation of ["v1", "v2"] as const) {
1123 assert.isNull((yield* resolveUpdate(generation, launcher)).update);
1124 const update = (yield* resolveUpdate(generation, native)).update;
1125 assert.deepStrictEqual(update?.args, ["upgrade", "--method", "curl"]);
1126 assert.strictEqual(update?.env?.HOME, root);
1128 }),
1130​
1131const versionOutput: { current: string | undefined } = { current: undefined };
1132const versionProbes: Array<string> = [];
1133const changingRuntime = {
1134 runOpenCodeCommand: ({ binaryPath }: { readonly binaryPath: string }) =>
1135 Effect.sync(() => versionProbes.push(binaryPath)).pipe(
1136 Effect.andThen(
1137 versionOutput.current === undefined
1138 ? Effect.fail(
1139 new OpenCodeRuntime.OpenCodeRuntimeError({
1140 operation: "version",
1141 detail: "no version",
1142 }),
1144 : Effect.succeed({ stdout: versionOutput.current, stderr: "", code: 0 }),
1145 ),
1146 ),
1147 startOpenCodeServerProcess: () => reachedServer("start"),
1148 connectToOpenCodeServer: () => reachedServer("connect"),
1149} as unknown as OpenCodeRuntime.OpenCodeRuntime["Service"];
1150const layerUpdate = Layer.mergeAll(
1151 IdAllocator.layer,
1152 McpProviderSessions.layer,
1153 ProviderLatestVersions.layer,
1154 TestProviderHost.layer(),
1155 Layer.succeed(
1156 ProviderEventLoggers.ProviderEventLoggers,
1157 ProviderEventLoggers.NoOpProviderEventLoggers,
1158 ),
1159 Layer.succeed(OpenCodeRuntime.OpenCodeRuntime, changingRuntime),
1160).pipe(Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
1161​
1162const openCode1Provider = (id: string, models: ReadonlyArray<string>) => ({
1163 id,
1164 name: id,
1165 models: Object.fromEntries(
1166 models.map((model) => [model, { id: model, name: model, release_date: "2026-01-01" }]),
1167 ),
1168});
1169const openCode1Project = "/work/project-with-config";
1170const openCode1UnreadableProject = "/work/unreadable-project";
1171const openCode1Providers = (directory: string) => {
1172 const all = [
1173 openCode1Provider("opencode", ["big-pickle"]),
1174 ...(directory === openCode1Project ? [openCode1Provider("uni", ["medium-gpt"])] : []),
1175 ];
1176 return { all, connected: all.map((provider) => provider.id), default: {} };
1178const openCode1Runtime = {
1179 runOpenCodeCommand: () => Effect.succeed({ stdout: "1.18.18\n", stderr: "", code: 0 }),
1180 startOpenCodeServerProcess: () =>
1181 Effect.succeed({
1182 url: "http://127.0.0.1:4096",
1183 version: "1.18.18",
1184 isRunning: Effect.succeed(true),
1185 exitCode: Effect.never,
1186 }),
1187 createOpenCodeSdkClient: ({ directory }: { readonly directory: string }) => ({
1188 provider: {
1189 list: () =>
1190 directory === openCode1UnreadableProject
1191 ? Promise.reject(new Error("provider list failed"))
1192 : Promise.resolve({ data: openCode1Providers(directory) }),
1193 },
1194 app: { agents: () => Promise.resolve({ data: [] }) },
1195 command: { list: () => Promise.resolve({ data: [] }) },
1196 }),
1197 loadOpenCodeInventory: () =>
1198 Effect.succeed({ providerList: openCode1Providers("/machine"), agents: [], skills: [] }),
1199 loadOpenCodeSkills: () => Effect.succeed([]),
1200} as unknown as OpenCodeRuntime.OpenCodeRuntime["Service"];
1201​
1202it.layer(Layer.mergeAll(layer, Layer.succeed(OpenCodeRuntime.OpenCodeRuntime, openCode1Runtime)))(
1203 "OpenCodeDriver on OpenCode 1",
1204 (it) => {
1205 it.effect("lists a project's own opencode.jsonc models in that project's snapshot", () =>
1206 Effect.gen(function* () {
1207 const instance = yield* create({}, noHttp);
1208 const ready = yield* instance.snapshot.streamChanges.pipe(
1209 Stream.filter((snapshot) => snapshot.status === "ready"),
1210 Stream.take(1),
1211 Stream.runCollect,
1212 Effect.forkChild,
1213 );
1214 yield* Fiber.join(ready);
1215 const slugsOf = (snapshot: { readonly models: ReadonlyArray<{ readonly slug: string }> }) =>
1216 snapshot.models.map((model) => model.slug).toSorted();
1217​
1218 assert.deepStrictEqual(slugsOf(yield* instance.snapshotForCwd!(openCode1Project)), [
1219 "opencode/big-pickle",
1220 "uni/medium-gpt",
1221 ]);
1222 const otherSnapshot = yield* instance.snapshotForCwd!("/work/other-project");
1223 assert.deepStrictEqual(slugsOf(otherSnapshot), ["opencode/big-pickle"]);
1224 assert.strictEqual(otherSnapshot.workspaceModels, undefined);
1225 assert.strictEqual(otherSnapshot.workspaceModelsPending, undefined);
1226 const unreadable = yield* instance.snapshotForCwd!(openCode1UnreadableProject);
1227 assert.deepStrictEqual(slugsOf(unreadable), ["opencode/big-pickle"]);
1228 assert.strictEqual(unreadable.workspaceModels, undefined);
1229 assert.strictEqual(unreadable.workspaceModelsPending, true);
1230 }).pipe(Effect.scoped),
1231 );
1232 },
1234​
1235it.layer(layerUpdate)("OpenCodeDriver updates", (it) => {
1236 it.effect.skipIf(HostProcess.Platform.defaultValue() === "win32")(
1237 "offers no package update for an unknown version and follows a changed one on a fresh read",
1238 () =>
1239 Effect.gen(function* () {
1240 const root = NodeFS.realpathSync(
1241 NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-opencode-driver-update-")),
1242 );
1243 const binaryPath = npmGlobalInstall(NodePath.join(root, "v1"), ["opencode-ai"], "opencode");
1244 const instance = yield* OpenCodeDriver.create({
1245 instanceId: ProviderInstanceId.make("opencode-update"),
1246 displayName: undefined,
1247 environment: [],
1248 enabled: true,
1249 config: { ...OpenCodeDriver.defaultConfig(), binaryPath },
1250 }).pipe(Effect.provideService(HttpClient.HttpClient, noHttp));
1251​
1252 versionOutput.current = undefined;
1253 const unknown = yield* instance.snapshot.resolveMaintenance({ fresh: true });
1254 assert.isNull(unknown.update);
1255 assert.isNull(unknown.packageName);
1256​
1257 versionOutput.current = "1.18.32\n";
1258 const v1 = yield* instance.snapshot.resolveMaintenance({ fresh: true });
1259 assert.strictEqual(v1.packageName, "opencode-ai");
1260​
1261 versionOutput.current = "opencode v2.0.18\n";
1262 const v2 = yield* instance.snapshot.resolveMaintenance({ fresh: true });
1263 assert.strictEqual(v2.packageName, "@opencode/cli");
1264 assert.isNull(v2.update);
1265 }).pipe(Effect.scoped),
1266 );
1267​
1268 it.effect(
1269 "opens sessions through OpenCode 2 after the binary is upgraded in place from 1.x",
1270 () =>
1271 Effect.gen(function* () {
1272 versionOutput.current = "1.18.18\n";
1273 const instance = yield* create({}, noHttp);
1274 // Let the startup status check claim the refresh permit, then wait behind it so it
1275 // cannot probe after the upgrade below.
1276 yield* Effect.yieldNow;
1277 yield* instance.snapshot.refresh;
1278 serverStarts.length = 0;
1279 const openSession = instance.orchestrationAdapter
1280 .openSession({
1281 threadId: ThreadId.make("thread-upgraded"),
1282 providerSessionId: ProviderSessionId.make("session-upgraded"),
1283 modelSelection: { instanceId: instance.instanceId, model: "opencode/big-pickle" },
1284 runtimePolicy: { runtimeMode: "full-access", interactionMode: "default", cwd: null },
1285 })
1286 .pipe(Effect.scoped, Effect.flip);
1287​
1288 yield* openSession;
1289 assert.deepStrictEqual(serverStarts, ["connect"], "1.x opens through the 1.x adapter");
1290​
1291 versionOutput.current = "opencode v2.2.4\n";
1292 serverStarts.length = 0;
1293 yield* openSession;
1294 assert.notInclude(
1295 serverStarts,
1296 "connect",
1297 "after upgrading to 2.x, the next session must not open through the 1.x adapter",
1298 );
1299 assert.include(serverStarts, "start", "the OpenCode 2 adapter starts its server");
1300 }).pipe(Effect.scoped),
1301 );
1302});