// @effect-diagnostics nodeBuiltinImport:off
import * as NodeFS from "node:fs";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, it } from "@effect/vitest";
import {
DEFAULT_SERVER_SETTINGS,
ProviderInstanceId,
ProviderSessionId,
ThreadId,
} from "@t3tools/contracts";
import type { OpenCodeSettings } from "../settings.ts";
import * as HostProcess from "@t3tools/shared/HostProcess";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Duration from "effect/Duration";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Logger from "effect/Logger";
import * as References from "effect/References";
import * as Stream from "effect/Stream";
import * as TestClock from "effect/testing/TestClock";
import * as HttpClient from "effect/http/HttpClient";
import * as HttpClientResponse from "effect/http/HttpClientResponse";
import * as FetchHttpClient from "effect/http/FetchHttpClient";
import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers";
import * as ProviderMaintenance from "@t3tools/provider-core/server/maintenanceResolver";
import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
import * as OpenCodeServerLedger from "./OpenCodeServerLedger.ts";
import { OPENCODE_2_RESPONSES, replayOpenCodeServer } from "./probeResponses.fixture.ts";
import { OpenCodeDriver, openCodeUpdateFor } from "./driver.ts";
import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
const serverStarts: Array<string> = [];
const reachedServer = (operation: string) =>
Effect.sync(() => serverStarts.push(operation)).pipe(
Effect.andThen(
Effect.fail(
new OpenCodeRuntime.OpenCodeRuntimeError({
operation,
detail: "reached a 1.x server path",
}),
),
),
);
const openCode2Runtime = {
runOpenCodeCommand: () => Effect.succeed({ stdout: "opencode v2.0.18\n", stderr: "", code: 0 }),
startOpenCodeServerProcess: () => reachedServer("start"),
connectToOpenCodeServer: () => reachedServer("connect"),
} as unknown as OpenCodeRuntime.OpenCodeRuntime["Service"];
const layer = Layer.mergeAll(
IdAllocator.layer,
McpProviderSessions.layer,
ProviderLatestVersions.layer,
TestProviderHost.layer(),
Layer.succeed(
ProviderEventLoggers.ProviderEventLoggers,
ProviderEventLoggers.NoOpProviderEventLoggers,
),
Layer.succeed(OpenCodeRuntime.OpenCodeRuntime, openCode2Runtime),
).pipe(Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
const create = (config: Partial<OpenCodeSettings>, http: HttpClient.HttpClient) =>
OpenCodeDriver.create({
instanceId: ProviderInstanceId.make("opencode-test"),
displayName: undefined,
environment: [],
enabled: true,
config: { ...OpenCodeDriver.defaultConfig(), ...config },
}).pipe(Effect.provideService(HttpClient.HttpClient, http));
const noHttp = HttpClient.make(() => Effect.die("A local binary must not be probed over HTTP"));
it.live("discovers models through a home-relative OpenCode wrapper", () =>
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const home = yield* fs.makeTempDirectoryScoped({ prefix: "t3-opencode-home with spaces-" });
const binaryPath = NodePath.join(home, "opencode");
const scriptPath = NodePath.join(home, "opencode.cjs");
yield* fs.writeFileString(
scriptPath,
`if (process.argv.includes('--version')) {
console.log('1.18.32');
} else {
const server = require('node:http').createServer((req, res) => {
const route = new URL(req.url, 'http://localhost').pathname;
res.setHeader('content-type', 'application/json');
res.end(JSON.stringify(route === '/global/health'
? { healthy: true, version: '1.18.32' }
: route === '/provider'
? { connected: ['opencode'], default: {}, all: [{
id: 'opencode', name: 'OpenCode', models: {
'big-pickle': { id: 'big-pickle', name: 'Big Pickle' }
}
}] }
: []));
});
server.listen(0, '127.0.0.1', () => {
console.log('opencode server listening on http://127.0.0.1:' + server.address().port);
});
}`,
);
const windows = (yield* HostProcess.Platform) === "win32";
const wrapperPath = windows ? `${binaryPath}.cmd` : binaryPath;
const node = yield* HostProcess.ExecutablePath;
yield* fs.writeFileString(
wrapperPath,
windows
? `@echo off\r\n"${node}" "${scriptPath}" %*\r\n`
: `#!/bin/sh\nexec "${node}" "${scriptPath}" "$@"\n`,
);
if (!windows) yield* fs.chmod(wrapperPath, 0o755);
const instance = yield* OpenCodeDriver.create({
instanceId: ProviderInstanceId.make("opencode-home"),
displayName: undefined,
environment: [],
enabled: true,
config: {
...OpenCodeDriver.defaultConfig(),
binaryPath: windows ? "~/opencode.cmd" : "~/opencode",
},
}).pipe(Effect.provideService(HostProcess.HomeDirectory, home));
const snapshot = yield* instance.snapshot.refresh;
assert.strictEqual(snapshot.status, "ready");
assert.strictEqual(snapshot.version, "1.18.32");
assert.isTrue(snapshot.models.some((model) => model.slug === "opencode/big-pickle"));
}).pipe(
Effect.scoped,
Effect.provide(
Layer.mergeAll(
IdAllocator.layer,
McpProviderSessions.layer,
ProviderLatestVersions.layer,
TestProviderHost.layer({ runBackgroundWork: false }),
Layer.succeed(
ProviderEventLoggers.ProviderEventLoggers,
ProviderEventLoggers.NoOpProviderEventLoggers,
),
OpenCodeRuntime.layer.pipe(Layer.provide(OpenCodeServerLedger.layerTest)),
).pipe(
Layer.provideMerge(
Layer.mergeAll(NodeServices.layer, NodeCrypto.layer, FetchHttpClient.layer),
),
),
),
),
);
it.layer(layer)("OpenCodeDriver runtime selection", (it) => {
it.effect("never starts a 1.x server for an OpenCode 2 instance", () =>
Effect.gen(function* () {
serverStarts.length = 0;
const instance = yield* create({}, noHttp);
yield* Effect.flip(
instance.textGeneration.generateThreadTitle({
cwd: process.cwd(),
message: "hello",
modelSelection: { instanceId: instance.instanceId, model: "opencode/big-pickle" },
}),
);
assert.deepStrictEqual(serverStarts, ["start"]);
}).pipe(Effect.scoped),
);
it.effect("answers capability reads without waiting on an unreachable server", () =>
Effect.gen(function* () {
const hang = HttpClient.make(() => Effect.never);
const instance = yield* create({ serverUrl: "http://127.0.0.1:9" }, hang);
const capabilities = yield* instance.orchestrationAdapter
.getCapabilities()
.pipe(Effect.forkChild);
yield* Effect.yieldNow;
assert.isDefined(capabilities.pollUnsafe());
yield* Fiber.join(capabilities);
}).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
);
it.effect.each(["probe", "error", "empty"] as const)(
"recovers discovery without a manual refresh after %s",
(initialCatalog) =>
Effect.gen(function* () {
const releaseCatalog = yield* Deferred.make<void>();
const discoveryLogs: Array<Record<string, unknown>> = [];
const logger = Logger.make(({ message, fiber }) => {
if (Array.isArray(message) && message.includes("OpenCode discovery failed")) {
discoveryLogs.push({ ...fiber.getRef(References.CurrentLogAnnotations) });
}
});
let catalogAvailable = false;
let modelReads = 0;
const replies = {
...OPENCODE_2_RESPONSES,
"/api/provider": {
status: 200,
contentType: "application/json",
body: '{"location":{"directory":"/work"},"data":[]}',
},
"/api/model": {
status: 200,
contentType: "application/json",
body: JSON.stringify({
location: { directory: "/work" },
data: [
{
id: "big-pickle",
modelID: "big-pickle",
providerID: "opencode",
name: "Big Pickle",
package: "@opencode/ai/providers/openai-compatible",
settings: {},
compatibility: {},
capabilities: { tools: true, input: ["text"], output: ["text"] },
variants: [],
time: { released: 1789516800000 },
cost: [{ input: 0, output: 0, cache: { read: 0, write: 0 } }],
status: "active",
enabled: true,
limit: { context: 1000000, output: 65536 },
},
],
}),
},
};
const replay = replayOpenCodeServer(replies, "secret");
const server = HttpClient.make((request) =>
Effect.gen(function* () {
if (initialCatalog === "probe" && !catalogAvailable) {
yield* Deferred.await(releaseCatalog);
return HttpClientResponse.fromWeb(
request,
new Response('{"_tag":"InternalServerError","message":"server starting"}', {
status: 503,
headers: { "content-type": "application/json" },
}),
);
}
if (new URL(request.url).pathname === "/api/model") {
modelReads += 1;
yield* Deferred.await(releaseCatalog);
if (!catalogAvailable) {
return HttpClientResponse.fromWeb(
request,
new Response(
initialCatalog === "error"
? '{"_tag":"InternalServerError","message":"catalog unavailable"}'
: '{"location":{"directory":"/work"},"data":[]}',
{
status: initialCatalog === "error" ? 500 : 200,
headers: { "content-type": "application/json" },
},
),
);
}
}
return yield* replay.execute(request);
}),
);
const instance = yield* create(
{ serverUrl: "http://127.0.0.1:4096", serverPassword: "secret" },
server,
).pipe(Effect.provide(Logger.layer([logger], { mergeWithExisting: false })));
const initial = yield* instance.snapshot.streamChanges.pipe(
Stream.filter(
(snapshot) =>
snapshot.installed &&
snapshot.status === (initialCatalog === "empty" ? "warning" : "error"),
),
Stream.take(1),
Stream.runCollect,
Effect.forkChild,
);
yield* Effect.yieldNow;
yield* Deferred.succeed(releaseCatalog, undefined);
yield* TestClock.adjust("5 seconds");
const [failed] = Array.from(yield* Fiber.join(initial));
assert.strictEqual(failed?.auth.status, "unknown");
assert.deepStrictEqual(failed?.models, []);
if (initialCatalog === "probe") assert.strictEqual(failed?.version, null);
assert.strictEqual(discoveryLogs.length, 1);
assert.strictEqual(discoveryLogs[0]?.providerInstanceId, "opencode-test");
assert.strictEqual(discoveryLogs[0]?.serverMode, "external");
assert.strictEqual(
discoveryLogs[0]?.phase,
initialCatalog === "probe" ? "version" : "models",
);
catalogAvailable = true;
const recovered = yield* instance.snapshot.streamChanges.pipe(
Stream.filter((snapshot) => snapshot.status === "ready"),
Stream.take(1),
Stream.runCollect,
Effect.forkChild,
);
yield* TestClock.adjust("5 minutes");
assert.strictEqual((yield* instance.snapshot.getSnapshot).status, "ready");
const [ready] = Array.from(yield* Fiber.join(recovered));
assert.strictEqual(ready?.auth.status, "authenticated");
assert.deepStrictEqual(
ready?.models.map((model) => model.slug),
["opencode/big-pickle"],
);
const readsAfterRecovery = modelReads;
yield* TestClock.adjust("15 minutes");
assert.strictEqual(modelReads, readsAfterRecovery);
assert.strictEqual(discoveryLogs.length, 1);
}).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
);
it.effect("does not retry a rejected server password in the background", () =>
Effect.gen(function* () {
const releaseResponse = yield* Deferred.make<void>();
const requested: Array<string> = [];
const server = replayOpenCodeServer(OPENCODE_2_RESPONSES, "secret", requested);
const instance = yield* create(
{ serverUrl: "http://127.0.0.1:4096", serverPassword: "wrong" },
HttpClient.make((request) =>
Deferred.await(releaseResponse).pipe(Effect.andThen(server.execute(request))),
),
);
// Wait for startup and its maintenance enrichment, both of which probe.
const rejected = yield* instance.snapshot.streamChanges.pipe(
Stream.filter(
(snapshot) => snapshot.status === "error" && snapshot.versionAdvisory !== undefined,
),
Stream.take(1),
Stream.runCollect,
Effect.forkChild,
);
yield* Effect.yieldNow;
yield* Deferred.succeed(releaseResponse, undefined);
const [snapshot] = Array.from(yield* Fiber.join(rejected));
assert.strictEqual(snapshot?.version, null);
assert.strictEqual(snapshot?.auth.status, "unauthenticated");
const readsAfterRejection = requested.length;
yield* TestClock.adjust("15 minutes");
assert.strictEqual(requested.length, readsAfterRejection);
}).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
);
it.effect.each(
[
{ name: "recovers" },
{ name: "skips without demand", demand: false },
{ name: "respects a disabled interval", intervalOff: true },
{ name: "skips disabled instances", enabled: false },
{ name: "skips unsupported usage", unsupported: true },
].map((scenario) => ({
enabled: true,
demand: true,
intervalOff: false,
unsupported: false,
...scenario,
})),
)("Go usage recovery $name without restarting a ready catalog", (scenario) =>
Effect.gen(function* () {
const usageStarted = yield* Deferred.make<void>();
let usageReads = 0;
let serverStarts = 0;
let modelReads = 0;
const server = HttpClient.make((request) => {
if (request.url === "https://opencode.ai/zen/go/v1/usage") {
usageReads += 1;
assert.strictEqual(request.headers.authorization, "Bearer test-go-key");
if (scenario.unsupported)
return Effect.succeed(
HttpClientResponse.fromWeb(request, new Response(null, { status: 403 })),
);
if (usageReads === 1)
return Deferred.succeed(usageStarted, undefined).pipe(Effect.andThen(Effect.never));
const window = { percent: 10, resetsAt: "2026-11-01T00:00:00.000Z" };
return Effect.succeed(
HttpClientResponse.fromWeb(
request,
Response.json({ usage: { rolling: window, weekly: window, monthly: window } }),
),
);
}
const path = new URL(request.url).pathname;
if (path === "/api/model") modelReads += 1;
const body =
path === "/api/info"
? JSON.parse(OPENCODE_2_RESPONSES["/api/info"].body)
: {
location: { directory: "/work" },
data:
path === "/api/model"
? [
{
id: "big-pickle",
modelID: "big-pickle",
providerID: "opencode",
name: "Big Pickle",
package: "@opencode/ai/providers/openai-compatible",
settings: {},
compatibility: {},
capabilities: { tools: true, input: ["text"], output: ["text"] },
variants: [],
time: { released: 1789516800000 },
cost: [],
status: "active",
enabled: true,
limit: { context: 1000000, output: 65536 },
},
]
: [],
};
return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(body)));
});
const runtime = {
...openCode2Runtime,
startOpenCodeServerProcess: ({
verify,
}: Parameters<
OpenCodeRuntime.OpenCodeRuntime["Service"]["startOpenCodeServerProcess"]
>[0]) =>
Effect.gen(function* () {
serverStarts += 1;
const url = "http://127.0.0.1:4096";
const version = verify ? yield* verify(url) : "2.0.18";
return { url, version, isRunning: Effect.succeed(true), exitCode: Effect.never };
}),
};
const instance = yield* OpenCodeDriver.create({
instanceId: ProviderInstanceId.make("opencode-usage-recovery"),
displayName: undefined,
environment: [
{
name: "OPENCODE_AUTH_CONTENT",
sensitive: true,
value: JSON.stringify({
"opencode-go": { type: "api", key: "test-go-key" },
}),
},
],
enabled: scenario.enabled,
config: OpenCodeDriver.defaultConfig(),
}).pipe(
Effect.provide(
TestProviderHost.layer({
runBackgroundWork: scenario.demand,
settings: scenario.intervalOff
? {
...DEFAULT_SERVER_SETTINGS,
backgroundActivity: {
...DEFAULT_SERVER_SETTINGS.backgroundActivity,
profile: "custom",
overrides: { providerHealthRefreshInterval: Duration.zero },
},
}
: DEFAULT_SERVER_SETTINGS,
}),
),
Effect.provideService(HttpClient.HttpClient, server),
Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, runtime),
);
const initial = scenario.enabled
? yield* instance.snapshot.streamChanges.pipe(
Stream.filter((snapshot) => snapshot.usageLimits !== undefined),
Stream.take(1),
Stream.runCollect,
Effect.forkChild,
)
: undefined;
if (scenario.enabled && !scenario.unsupported) yield* Deferred.await(usageStarted);
yield* TestClock.adjust("5 seconds");
const failed = initial
? Array.from(yield* Fiber.join(initial))[0]
: yield* instance.snapshot.getSnapshot;
if (scenario.enabled) {
assert.strictEqual(failed?.status, "ready");
assert.strictEqual(failed?.auth.status, "authenticated");
}
const initialReason =
scenario.enabled && !scenario.unsupported ? "probeFailed" : "unsupported";
assert.strictEqual(failed?.usageLimits?.unavailable?.reason, initialReason);
const catalogReads = modelReads;
const starts = serverStarts;
const shouldRecover =
scenario.enabled && scenario.demand && !scenario.intervalOff && !scenario.unsupported;
const recovery = shouldRecover
? yield* instance.snapshot.streamChanges.pipe(
Stream.filter((snapshot) => snapshot.usageLimits?.windows.length === 3),
Stream.take(1),
Stream.runCollect,
Effect.forkChild,
)
: undefined;
yield* TestClock.adjust("5 minutes");
const recovered = yield* instance.snapshot.getSnapshot;
const expectedReads = !scenario.enabled ? 0 : shouldRecover ? 2 : 1;
assert.strictEqual(usageReads, expectedReads);
if (recovery) assert.deepStrictEqual(Array.from(yield* Fiber.join(recovery)), [recovered]);
assert.strictEqual(
recovered.usageLimits?.unavailable?.reason,
shouldRecover ? undefined : initialReason,
);
assert.deepStrictEqual(
recovered.usageLimits?.windows.map((window) => window.kind),
shouldRecover ? ["session", "weekly", "monthly"] : [],
);
assert.strictEqual(modelReads, catalogReads);
assert.strictEqual(serverStarts, starts);
yield* TestClock.adjust("15 minutes");
assert.strictEqual(usageReads, expectedReads);
assert.strictEqual(modelReads, catalogReads);
assert.strictEqual(serverStarts, starts);
}).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
);
});
// npm links into opencode-ai for 1.x and @opencode/cli for 2.x.
const npmGlobalInstall = (prefix: string, packagePath: ReadonlyArray<string>, bin: string) => {
const target = NodePath.join(prefix, "lib", "node_modules", ...packagePath, "bin", bin);
NodeFS.mkdirSync(NodePath.dirname(target), { recursive: true });
NodeFS.writeFileSync(target, "#!/bin/sh\n");
NodeFS.chmodSync(target, 0o755);
const link = NodePath.join(prefix, "bin", "opencode");
NodeFS.mkdirSync(NodePath.dirname(link), { recursive: true });
NodeFS.symlinkSync(target, link);
return link;
};
const resolveUpdate = (generation: "v1" | "v2", binaryPath: string) =>
ProviderMaintenance.resolveProviderMaintenanceCapabilitiesEffect(openCodeUpdateFor(generation), {
binaryPath,
env: { PATH: "" },
}).pipe(
Effect.provideService(
ChildProcessSpawner.ChildProcessSpawner,
ChildProcessSpawner.make(() => Effect.die("resolving an update must not spawn")),
),
Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
);
it.effect.skipIf(HostProcess.Platform.defaultValue() === "win32")(
"updates npm-global OpenCode by generation and runs upgrade only for its own installer's path",
() =>
Effect.gen(function* () {
const root = NodeFS.realpathSync(
NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-opencode-update-")),
);
const v2Prefix = NodePath.join(root, "v2");
const v1Prefix = NodePath.join(root, "v1");
const v2 = yield* resolveUpdate(
"v2",
npmGlobalInstall(v2Prefix, ["@opencode", "cli"], "opencode.exe"),
);
assert.deepStrictEqual(v2.update?.args, [
"install",
"-g",
"--prefix",
v2Prefix,
"--allow-scripts=@opencode/cli",
"@opencode/cli@latest",
]);
const v1 = yield* resolveUpdate(
"v1",
npmGlobalInstall(v1Prefix, ["opencode-ai"], "opencode"),
);
assert.strictEqual(v1.update?.args.at(-1), "opencode-ai@latest");
assert.isNull(
(yield* resolveUpdate("v2", NodePath.join(v1Prefix, "bin", "opencode"))).update,
);
assert.isNull(
(yield* resolveUpdate("v1", NodePath.join(v2Prefix, "bin", "opencode"))).update,
);
const executable = (...segments: ReadonlyArray<string>) => {
const path = NodePath.join(root, ...segments);
NodeFS.mkdirSync(NodePath.dirname(path), { recursive: true });
NodeFS.writeFileSync(path, "#!/bin/sh\n");
NodeFS.chmodSync(path, 0o755);
return path;
};
const launcher = executable("launcher", "opencode");
const native = executable(".opencode", "bin", "opencode");
for (const generation of ["v1", "v2"] as const) {
assert.isNull((yield* resolveUpdate(generation, launcher)).update);
assert.deepStrictEqual((yield* resolveUpdate(generation, native)).update?.args, [
"upgrade",
]);
}
}),
);
const versionOutput: { current: string | undefined } = { current: undefined };
const versionProbes: Array<string> = [];
const changingRuntime = {
runOpenCodeCommand: ({ binaryPath }: { readonly binaryPath: string }) =>
Effect.sync(() => versionProbes.push(binaryPath)).pipe(
Effect.andThen(
versionOutput.current === undefined
? Effect.fail(
new OpenCodeRuntime.OpenCodeRuntimeError({
operation: "version",
detail: "no version",
}),
)
: Effect.succeed({ stdout: versionOutput.current, stderr: "", code: 0 }),
),
),
startOpenCodeServerProcess: () => reachedServer("start"),
connectToOpenCodeServer: () => reachedServer("connect"),
} as unknown as OpenCodeRuntime.OpenCodeRuntime["Service"];
const layerUpdate = Layer.mergeAll(
IdAllocator.layer,
McpProviderSessions.layer,
ProviderLatestVersions.layer,
TestProviderHost.layer(),
Layer.succeed(
ProviderEventLoggers.ProviderEventLoggers,
ProviderEventLoggers.NoOpProviderEventLoggers,
),
Layer.succeed(OpenCodeRuntime.OpenCodeRuntime, changingRuntime),
).pipe(Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
it.layer(layerUpdate)("OpenCodeDriver updates", (it) => {
it.effect.skipIf(HostProcess.Platform.defaultValue() === "win32")(
"offers no package update for an unknown version and follows a changed one on a fresh read",
() =>
Effect.gen(function* () {
const root = NodeFS.realpathSync(
NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-opencode-driver-update-")),
);
const binaryPath = npmGlobalInstall(NodePath.join(root, "v1"), ["opencode-ai"], "opencode");
const instance = yield* OpenCodeDriver.create({
instanceId: ProviderInstanceId.make("opencode-update"),
displayName: undefined,
environment: [],
enabled: true,
config: { ...OpenCodeDriver.defaultConfig(), binaryPath },
}).pipe(Effect.provideService(HttpClient.HttpClient, noHttp));
versionOutput.current = undefined;
const unknown = yield* instance.snapshot.resolveMaintenance({ fresh: true });
assert.isNull(unknown.update);
assert.isNull(unknown.packageName);
versionOutput.current = "1.18.32\n";
const v1 = yield* instance.snapshot.resolveMaintenance({ fresh: true });
assert.strictEqual(v1.packageName, "opencode-ai");
versionOutput.current = "opencode v2.0.18\n";
const v2 = yield* instance.snapshot.resolveMaintenance({ fresh: true });
assert.strictEqual(v2.packageName, "@opencode/cli");
assert.isNull(v2.update);
}).pipe(Effect.scoped),
);
it.effect(
"opens sessions through OpenCode 2 after the binary is upgraded in place from 1.x",
() =>
Effect.gen(function* () {
versionOutput.current = "1.18.18\n";
const instance = yield* create({}, noHttp);
// Let the startup status check claim the refresh permit, then wait behind it so it
// cannot probe after the upgrade below.
yield* Effect.yieldNow;
yield* instance.snapshot.refresh;
serverStarts.length = 0;
const openSession = instance.orchestrationAdapter
.openSession({
threadId: ThreadId.make("thread-upgraded"),
providerSessionId: ProviderSessionId.make("session-upgraded"),
modelSelection: { instanceId: instance.instanceId, model: "opencode/big-pickle" },
runtimePolicy: { runtimeMode: "full-access", interactionMode: "default", cwd: null },
})
.pipe(Effect.scoped, Effect.flip);
yield* openSession;
assert.deepStrictEqual(serverStarts, ["connect"], "1.x opens through the 1.x adapter");
versionOutput.current = "opencode v2.2.4\n";
serverStarts.length = 0;
yield* openSession;
assert.notInclude(
serverStarts,
"connect",
"after upgrading to 2.x, the next session must not open through the 1.x adapter",
);
assert.include(serverStarts, "start", "the OpenCode 2 adapter starts its server");
}).pipe(Effect.scoped),
);
});