Open History to see the last commit
1import {
2 ProviderDriverKind,
3 settingsSecretLiteral,
4 type ServerProviderModel,
5} from "@t3tools/contracts";
6import { OpenCodeSettings } from "../settings.ts";
7import * as Digest from "effect/crypto/Digest";
8import * as SecureRandom from "effect/crypto/SecureRandom";
9import * as Deferred from "effect/Deferred";
10import * as Effect from "effect/Effect";
11import * as Equal from "effect/Equal";
12import * as Option from "effect/Option";
13import * as FileSystem from "effect/FileSystem";
14import * as Path from "effect/Path";
15import * as Schema from "effect/Schema";
16import * as Stream from "effect/Stream";
17import * as HttpClient from "effect/http/HttpClient";
18import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
19
20import * as OpenCode2TextGeneration from "./v2/textGeneration.ts";
21import { makeOpenCodeTextGeneration } from "./textGeneration.ts";
22import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
23import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
24import { expandHomePath } from "@t3tools/provider-core/server/pathExpansion";
25import * as HostProcess from "@t3tools/shared/HostProcess";
26import { compareSemverVersions } from "@t3tools/shared/semver";
27import * as OpenCodeAdapterV2 from "./adapter.ts";
28import * as OpenCode2AdapterV2 from "./v2/adapter.ts";
29import type * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
30import type { ProviderTextGeneration } from "@t3tools/provider-core/server/textGeneration";
31import { ProviderDriverError } from "@t3tools/provider-core/server/errors";
32import { openCodeUsageReader, type OpenCodeUsageReaderEnv } from "./usage.ts";
33import { readOpenCodeGoUsageLimits } from "./usageLimits.ts";
34import { loadOpenCode2Catalog, loadOpenCode2DirectoryCatalog } from "./openCode2Catalog.ts";
35import {
36 checkOpenCodeProviderStatus,
37 loadOpenCode2Workspace,
38 makeOpenCode2ModelLoader,
39 makePendingOpenCodeProvider,
40 openCode2CommandsToServerProviderSlashCommands,
41 openCode2ProviderModels,
42 openCode2SkillsToServerProviderSkills,
43 openCodeSkillsToServerProviderSkills,
44 openCodeCommandsToServerProviderSlashCommands,
45 openCodeProviderModels,
46 readSettledOpenCode2Catalog,
47} from "./status.ts";
48import { makeManagedServerProvider } from "@t3tools/provider-core/server/managedProvider";
49import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
50import {
51 makeOpenCodeRuntimeProbe,
52 probeOpenCodeRuntime,
53 probeOpenCodeBinary,
54 type ProbedOpenCode,
55} from "./versionProbe.ts";
56import * as OpenCodeServerOwner from "./OpenCodeServerOwner.ts";
57import * as OpenCode2Client from "./v2/OpenCode2Client.ts";
58import * as OpenCode2Server from "./v2/OpenCode2Server.ts";
59import {
60 defaultProviderContinuationIdentity,
61 type ProviderDriver,
62 type ProviderInstance,
63} from "@t3tools/provider-core/server/driver";
64import { withInstanceIdentity } from "@t3tools/provider-core/server/instanceIdentity";
65import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment";
66import { providerProbeEnvironment } from "@t3tools/provider-core/server/snapshotProbe";
67import {
68 enrichProviderSnapshotWithVersionAdvisory,
69 makeCachedProviderMaintenanceResolution,
70 makeManualOnlyProviderMaintenanceCapabilities,
71 makePackageManagedProviderMaintenanceResolver,
72 normalizeCommandPath,
73 resolveProviderMaintenanceCapabilitiesEffect,
74} from "@t3tools/provider-core/server/maintenanceResolver";
75import {
76 haveProviderSnapshotSettingsChanged,
77 makeProviderSnapshotSettingsSource,
78 type ProviderSnapshotSettings,
79} from "@t3tools/provider-core/server/snapshotSettings";
80const decodeOpenCodeSettings = Schema.decodeSync(OpenCodeSettings);
81
82const DRIVER_KIND = ProviderDriverKind.make("opencode");
83
84// A loopback server runs on this environment, but can outlive its CLI installation.
85// Its reported version may therefore differ from the installed executable after an update.
86export function isLocalOpenCodeServerUrl(serverUrl: string): boolean {
87 const url = URL.parse(serverUrl.trim());
88 if (url?.protocol !== "http:" && url?.protocol !== "https:") return false;
89 return (
90 url.hostname === "localhost" ||
91 url.hostname === "[::1]" ||
92 /^127\.(?:\d{1,3}\.){2}\d{1,3}$/.test(url.hostname)
93 );
94}
95
96function isOpenCodeNativeCommandPath(commandPath: string): boolean {
97 const normalized = normalizeCommandPath(commandPath);
98 return (
99 normalized.endsWith("/.opencode/bin/opencode") ||
100 normalized.endsWith("/.opencode/bin/opencode.exe")
101 );
102}
103
104function openCodeNativeHome(commandPath: string): string | null {
105 const slashed = commandPath.replaceAll("\\", "/");
106 const match = /\/\.opencode\/bin\/opencode(?:\.exe)?$/i.exec(slashed);
107 if (!match) return null;
108 return match.index === 0 ? "/" : slashed.slice(0, match.index);
109}
110
111/** Update only within the installed package generation; 2.x converts the shared database in place. */
112export const openCodeUpdateFor = (generation: ProbedOpenCode["generation"]) =>
113 makePackageManagedProviderMaintenanceResolver({
114 provider: DRIVER_KIND,
115 npmPackageName: generation === "v2" ? "@opencode/cli" : "opencode-ai",
116 nativeUpdate: {
117 // `isOpenCodeNativeCommandPath` is the curl installer's own binary. Name the
118 // method so OpenCode does not have to infer it from `process.execPath`, which
119 // fails when the binary is launched through a wrapper or shim.
120 args: ["upgrade", "--method", "curl"],
121 isCommandPath: isOpenCodeNativeCommandPath,
122 requiresCommandPath: true,
123 // The curl installer writes to `$HOME/.opencode/bin`, so point HOME at the install it replaces.
124 env: (context) => {
125 const home =
126 openCodeNativeHome(context.realCommandPath) ??
127 openCodeNativeHome(context.resolvedCommandPath);
128 return home ? { HOME: home } : {};
129 },
130 },
131 // mise's `opencode` follows releases into 2.x, so it would upgrade 1.x across that line.
132 mise: { tool: "opencode", upgrade: generation === "v2" },
133 });
134
135type OpenCodeRuntimeProbe = Effect.Success<
136 ReturnType<typeof makeOpenCodeRuntimeProbe<OpenCodeRuntime.OpenCodeRuntimeError>>
137>;
138
139function byOpenCodeRuntime<A, E, R, PE>(
140 probed: Effect.Effect<ProbedOpenCode | undefined, PE>,
141 paths: { readonly v1: Effect.Effect<A, E, R>; readonly v2: Effect.Effect<A, E, R> },
142): Effect.Effect<A, E, R> {
143 return probed.pipe(
144 Effect.orElseSucceed(() => undefined),
145 Effect.flatMap((result) => (result?.generation === "v2" ? paths.v2 : paths.v1)),
146 );
147}
148
149// An unread catalog keeps what the registry found before rather than the machine catalog.
150function workspaceModelsFor(
151 machineModels: ReadonlyArray<ServerProviderModel>,
152 cwdModels: Option.Option<ReadonlyArray<ServerProviderModel>>,
153) {
154 if (Option.isNone(cwdModels)) return { workspaceModelsPending: true };
155 return Equal.equals(cwdModels.value, machineModels)
156 ? {}
157 : { models: cwdModels.value, workspaceModels: cwdModels.value };
158}
159
160// Hot reads use the last successful probe; session opens await it to select the correct protocol.
161function selectOpenCodeRuntimeAdapter(input: {
162 readonly probe: OpenCodeRuntimeProbe;
163 readonly resolve: Effect.Effect<ProbedOpenCode, OpenCodeRuntime.OpenCodeRuntimeError>;
164 readonly v1: ProviderAdapter.ProviderAdapterV2["Service"];
165 readonly v2: ProviderAdapter.ProviderAdapterV2["Service"];
166}): ProviderAdapter.ProviderAdapterV2["Service"] {
167 const pick = <PE>(probed: Effect.Effect<ProbedOpenCode | undefined, PE>) =>
168 byOpenCodeRuntime(probed, { v1: Effect.succeed(input.v1), v2: Effect.succeed(input.v2) });
169 const hot = pick(Effect.map(input.probe.lastSuccess, Option.getOrUndefined));
170 return {
171 instanceId: input.v1.instanceId,
172 driver: DRIVER_KIND,
173 getCapabilities: Effect.fn("OpenCodeDriver.getCapabilities")(function* () {
174 const probed = Option.getOrUndefined(yield* input.probe.lastSuccess);
175 const adapter = yield* pick(Effect.succeed(probed));
176 const capabilities = yield* adapter.getCapabilities();
177 return {
178 ...capabilities,
179 turns: {
180 ...capabilities.turns,
181 supportsNativeGoals:
182 capabilities.turns.supportsNativeGoals ??
183 (probed?.generation === "v2" && compareSemverVersions(probed.version, "2.2.5") >= 0),
184 },
185 };
186 }),
187 planSelectionTransition: (transition) =>
188 Effect.flatMap(hot, (adapter) => adapter.planSelectionTransition(transition)),
189 openSession: (session) =>
190 Effect.flatMap(pick(input.resolve), (adapter) => adapter.openSession(session)),
191 };
192}
193
194function selectOpenCodeRuntimeTextGeneration(
195 resolve: Effect.Effect<ProbedOpenCode, OpenCodeRuntime.OpenCodeRuntimeError>,
196 v1: ProviderTextGeneration,
197 v2: ProviderTextGeneration,
198): ProviderTextGeneration {
199 return {
200 generateCommitMessage: (input) =>
201 byOpenCodeRuntime(resolve, {
202 v1: v1.generateCommitMessage(input),
203 v2: v2.generateCommitMessage(input),
204 }),
205 generatePrContent: (input) =>
206 byOpenCodeRuntime(resolve, {
207 v1: v1.generatePrContent(input),
208 v2: v2.generatePrContent(input),
209 }),
210 generateBranchName: (input) =>
211 byOpenCodeRuntime(resolve, {
212 v1: v1.generateBranchName(input),
213 v2: v2.generateBranchName(input),
214 }),
215 generateThreadTitle: (input) =>
216 byOpenCodeRuntime(resolve, {
217 v1: v1.generateThreadTitle(input),
218 v2: v2.generateThreadTitle(input),
219 }),
220 generateReviewGuide: (input) =>
221 byOpenCodeRuntime(resolve, {
222 v1: v1.generateReviewGuide(input),
223 v2: v2.generateReviewGuide(input),
224 }),
225 generateTranscriptionPostProcessing: (input) =>
226 byOpenCodeRuntime(resolve, {
227 v1: v1.generateTranscriptionPostProcessing(input),
228 v2: v2.generateTranscriptionPostProcessing(input),
229 }),
230 };
231}
232
233export type OpenCodeDriverEnv =
234 | OpenCodeAdapterV2.OpenCodeAdapterV2DriverEnv
235 | ProviderHost.ProviderHost
236 | ChildProcessSpawner.ChildProcessSpawner
237 | Digest.Digest
238 | SecureRandom.SecureRandom
239 | FileSystem.FileSystem
240 | HttpClient.HttpClient
241 | ProviderLatestVersions.ProviderLatestVersions
242 | OpenCodeRuntime.OpenCodeRuntime
243 | Path.Path;
244
245export const OpenCodeDriver: ProviderDriver<
246 OpenCodeSettings,
247 OpenCodeDriverEnv,
248 OpenCodeUsageReaderEnv
249> = {
250 driverKind: DRIVER_KIND,
251 metadata: {
252 displayName: "OpenCode",
253 supportsMultipleInstances: true,
254 },
255 configSchema: OpenCodeSettings,
256 defaultConfig: (): OpenCodeSettings => decodeOpenCodeSettings({}),
257 usage: openCodeUsageReader,
258 create: Effect.fn("OpencodeDriver.create")(function* ({
259 instanceId,
260 displayName,
261 accentColor,
262 environment,
263 enabled,
264 config,
265 }) {
266 const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
267 const fileSystem = yield* FileSystem.FileSystem;
268 const pathService = yield* Path.Path;
269 const openCodeRuntime = yield* OpenCodeRuntime.OpenCodeRuntime;
270 const httpClient = yield* HttpClient.HttpClient;
271 const latestVersions = yield* ProviderLatestVersions.ProviderLatestVersions;
272 const digest = yield* Digest.Digest;
273 const host = yield* ProviderHost.ProviderHost;
274 const processEnv = yield* mergeProviderInstanceEnvironment(environment);
275 const continuationIdentity = defaultProviderContinuationIdentity({
276 driverKind: DRIVER_KIND,
277 instanceId,
278 });
279 const stampIdentity = withInstanceIdentity({
280 instanceId,
281 driverKind: DRIVER_KIND,
282 displayName,
283 accentColor,
284 continuationGroupKey: continuationIdentity.continuationKey,
285 });
286 const effectiveConfig = {
287 ...config,
288 enabled,
289 binaryPath: expandHomePath(config.binaryPath, yield* HostProcess.HomeDirectory),
290 // The instance registry has already read a referenced password from its secret provider.
291 serverPassword: settingsSecretLiteral(config.serverPassword),
292 } satisfies OpenCodeSettings;
293 const probeRuntime = (probeEnv: NodeJS.ProcessEnv) =>
294 probeOpenCodeRuntime(effectiveConfig, probeEnv).pipe(
295 Effect.provideService(HttpClient.HttpClient, httpClient),
296 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, openCodeRuntime),
297 );
298 const runtimeProbe = yield* makeOpenCodeRuntimeProbe(
299 probeRuntime(providerProbeEnvironment(processEnv)),
300 );
301 // A mise shim cannot install OpenCode offline; a session or text generation the user started
302 // may, so without a cached result it probes once online and caches what mise installed.
303 const resolveRuntime =
304 effectiveConfig.serverUrl.trim().length > 0
305 ? runtimeProbe.get
306 : runtimeProbe.lastSuccess.pipe(
307 Effect.flatMap(
308 Option.match({
309 onSome: Effect.succeed,
310 onNone: () => probeRuntime(processEnv).pipe(Effect.tap(runtimeProbe.record)),
311 }),
312 ),
313 );
314 const noUpdate = makeManualOnlyProviderMaintenanceCapabilities({
315 provider: DRIVER_KIND,
316 packageName: null,
317 });
318 const maintenanceFor = (probed: typeof runtimeProbe.get) =>
319 probed.pipe(
320 Effect.map((result) => result.generation),
321 Effect.option,
322 Effect.flatMap((generation) =>
323 Option.isNone(generation)
324 ? Effect.succeed(noUpdate)
325 : resolveProviderMaintenanceCapabilitiesEffect(openCodeUpdateFor(generation.value), {
326 binaryPath: effectiveConfig.binaryPath,
327 env: processEnv,
328 }),
329 ),
330 Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
331 Effect.provideService(FileSystem.FileSystem, fileSystem),
332 Effect.provideService(Path.Path, pathService),
333 );
334 const cachedMaintenance = yield* makeCachedProviderMaintenanceResolution(
335 maintenanceFor(
336 isLocalOpenCodeServerUrl(effectiveConfig.serverUrl)
337 ? probeOpenCodeBinary(
338 effectiveConfig.binaryPath,
339 providerProbeEnvironment(processEnv),
340 ).pipe(
341 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, openCodeRuntime),
342 Effect.catch(() => runtimeProbe.get),
343 )
344 : runtimeProbe.get,
345 ),
346 );
347 const resolveMaintenance = (options?: { readonly fresh?: boolean }) =>
348 !effectiveConfig.enabled
349 ? Effect.succeed(noUpdate)
350 : options?.fresh === true
351 ? runtimeProbe.refresh.pipe(
352 Effect.ignore,
353 Effect.andThen(cachedMaintenance({ fresh: true })),
354 )
355 : cachedMaintenance();
356 const openCodeV1Adapter = yield* OpenCodeAdapterV2.OpenCodeAdapterV2Driver.create({
357 instanceId,
358 displayName,
359 accentColor,
360 environment,
361 enabled,
362 config: effectiveConfig,
363 }).pipe(
364 Effect.mapError(
365 (cause) =>
366 new ProviderDriverError({
367 driver: DRIVER_KIND,
368 instanceId,
369 detail: "Failed to build OpenCode orchestration adapter.",
370 cause,
371 }),
372 ),
373 );
374 const openCode2Server = yield* OpenCode2Server.make({
375 binaryPath: effectiveConfig.binaryPath,
376 serverUrl: effectiveConfig.serverUrl,
377 serverPassword: effectiveConfig.serverPassword,
378 directory: host.paths.cwd,
379 environment: processEnv,
380 }).pipe(
381 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, openCodeRuntime),
382 Effect.provideService(
383 OpenCode2Client.OpenCode2Client,
384 yield* OpenCode2Client.make.pipe(Effect.provideService(HttpClient.HttpClient, httpClient)),
385 ),
386 );
387 const orchestrationAdapter = selectOpenCodeRuntimeAdapter({
388 probe: runtimeProbe,
389 resolve: resolveRuntime,
390 v1: openCodeV1Adapter,
391 v2: yield* OpenCode2AdapterV2.make(instanceId).pipe(
392 Effect.provideService(OpenCode2Server.OpenCode2Server, openCode2Server),
393 ),
394 });
395 const loadOpenCode2Models = yield* makeOpenCode2ModelLoader(
396 openCode2Server.withConnection(({ client }) => loadOpenCode2Catalog(client, host.paths.cwd)),
397 );
398 const listOpenCode2Workspace = (cwd: string) =>
399 openCode2Server.withConnection(({ client, events }) =>
400 Effect.gen(function* () {
401 // OpenCode names a location by its resolved path (no trailing slash or `..`).
402 const directory = pathService.resolve(cwd);
403 const location = { directory };
404 const scanned = yield* Deferred.make<void>();
405 const pending = new Set(["command.updated", "skill.updated"]);
406 const stream = yield* events.pipe(Effect.option);
407 if (stream._tag === "Some") {
408 yield* stream.value.pipe(
409 Stream.runForEach((event) =>
410 "location" in event &&
411 event.location?.directory === directory &&
412 pending.delete(event.type) &&
413 pending.size === 0
414 ? Deferred.succeed(scanned, undefined)
415 : Effect.void,
416 ),
417 Effect.ignore,
418 Effect.forkScoped,
419 );
420 }
421 return yield* loadOpenCode2Workspace(
422 Effect.all(
423 {
424 skills: client.skill.list({ location }).pipe(Effect.map((list) => list.data)),
425 commands: client.command.list({ location }).pipe(Effect.map((list) => list.data)),
426 },
427 { concurrency: "unbounded" },
428 ),
429 Deferred.await(scanned),
430 // Without events no scan can be awaited, so trust the first read as before.
431 stream._tag === "None"
432 ? Effect.succeed(true)
433 : client.debug.location.list().pipe(
434 Effect.map((loaded) => loaded.some((entry) => entry.directory === directory)),
435 Effect.timeout("2 seconds"),
436 Effect.orElseSucceed(() => true),
437 ),
438 );
439 }).pipe(Effect.scoped),
440 );
441 const serverOwner = yield* OpenCodeServerOwner.make({
442 binaryPath: effectiveConfig.binaryPath,
443 directory: host.paths.cwd,
444 ...(effectiveConfig.serverPassword ? { serverPassword: effectiveConfig.serverPassword } : {}),
445 environment: processEnv,
446 });
447 const textGeneration = selectOpenCodeRuntimeTextGeneration(
448 resolveRuntime,
449 yield* makeOpenCodeTextGeneration(effectiveConfig).pipe(
450 Effect.provideService(OpenCodeServerOwner.OpenCodeServerOwner, serverOwner),
451 ),
452 yield* OpenCode2TextGeneration.make().pipe(
453 Effect.provideService(OpenCode2Server.OpenCode2Server, openCode2Server),
454 ),
455 );
456
457 const checkUsageLimits = readOpenCodeGoUsageLimits({
458 enabled: effectiveConfig.enabled,
459 serverUrl: effectiveConfig.serverUrl,
460 environment: processEnv,
461 }).pipe(
462 Effect.provideService(FileSystem.FileSystem, fileSystem),
463 Effect.provideService(Path.Path, pathService),
464 Effect.provideService(HttpClient.HttpClient, httpClient),
465 Effect.provideService(Digest.Digest, digest),
466 );
467 const checkProvider = Effect.all(
468 {
469 // A configured loopback server reports its running version. Probe the local
470 // CLI separately so a completed npm update is not mistaken for a failure
471 // while that independently managed server still runs the previous binary.
472 installedVersion:
473 effectiveConfig.enabled && isLocalOpenCodeServerUrl(effectiveConfig.serverUrl)
474 ? probeOpenCodeBinary(
475 effectiveConfig.binaryPath,
476 providerProbeEnvironment(processEnv),
477 ).pipe(
478 Effect.map((probed) => probed.version),
479 Effect.orElseSucceed(() => undefined),
480 )
481 : Effect.void,
482 provider: checkOpenCodeProviderStatus(
483 effectiveConfig,
484 host.paths.cwd,
485 runtimeProbe.refresh,
486 loadOpenCode2Models,
487 ).pipe(
488 Effect.annotateLogs({ providerInstanceId: instanceId }),
489 Effect.annotateSpans({ providerInstanceId: instanceId }),
490 ),
491 usageLimits: checkUsageLimits,
492 },
493 { concurrency: "unbounded" },
494 ).pipe(
495 Effect.map(({ provider, usageLimits, installedVersion }) => ({
496 ...provider,
497 usageLimits,
498 ...(installedVersion === undefined ? {} : { installedVersion }),
499 })),
500 Effect.map(stampIdentity),
501 Effect.provideService(OpenCodeServerOwner.OpenCodeServerOwner, serverOwner),
502 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, openCodeRuntime),
503 );
504 // The CLI writes its full JSON inventory to stdout, but the Bun-compiled binary does not
505 // flush more than one 64KB pipe buffer to a non-TTY stdout, so the piped output arrives
506 // truncated and unparseable — which degrades to an empty skill list and poisons the workspace
507 // snapshot the `$` picker reads.
508 const loadWorkspaceInventory = (
509 client: Parameters<typeof OpenCodeRuntime.loadOpenCodeCommands>[0],
510 ) =>
511 Effect.all(
512 {
513 skills: openCodeRuntime.loadOpenCodeSkills(client),
514 commandInventory: OpenCodeRuntime.loadOpenCodeCommands(client).pipe(
515 Effect.timeoutOption("10 seconds"),
516 Effect.map((commands) => ({
517 commands: Option.getOrElse(commands, () => []),
518 slashCommandsPending: Option.isNone(commands),
519 })),
520 // SDK errors leave command discovery to the provider's health.
521 Effect.orElseSucceed(() => ({
522 commands: [],
523 slashCommandsPending: undefined,
524 })),
525 ),
526 // A project's opencode.jsonc can define its own providers.
527 models: OpenCodeRuntime.loadOpenCodeProviderCatalog(client).pipe(
528 Effect.timeoutOption("10 seconds"),
529 Effect.map(
530 Option.flatMapNullishOr((catalog) =>
531 openCodeProviderModels(effectiveConfig, catalog),
532 ),
533 ),
534 Effect.orElseSucceed(() => Option.none<ReadonlyArray<ServerProviderModel>>()),
535 ),
536 },
537 { concurrency: "unbounded" },
538 ).pipe(
539 Effect.map(({ skills, commandInventory, models }) => ({
540 skills,
541 models,
542 ...commandInventory,
543 })),
544 );
545 const loadWorkspaceForCwd = (cwd: string) =>
546 effectiveConfig.serverUrl.trim().length > 0
547 ? Effect.scoped(
548 Effect.gen(function* () {
549 const server = yield* openCodeRuntime.connectToOpenCodeServer({
550 binaryPath: effectiveConfig.binaryPath,
551 directory: cwd,
552 serverUrl: effectiveConfig.serverUrl,
553 ...(effectiveConfig.serverPassword
554 ? { serverPassword: effectiveConfig.serverPassword }
555 : {}),
556 environment: processEnv,
557 });
558 const client = openCodeRuntime.createOpenCodeSdkClient({
559 baseUrl: server.url,
560 directory: cwd,
561 ...(effectiveConfig.serverPassword
562 ? { serverPassword: effectiveConfig.serverPassword }
563 : {}),
564 });
565 return yield* loadWorkspaceInventory(client);
566 }),
567 )
568 : serverOwner.withServer((server) =>
569 loadWorkspaceInventory(
570 openCodeRuntime.createOpenCodeSdkClient({
571 baseUrl: server.url,
572 directory: cwd,
573 ...(server.serverPassword !== undefined
574 ? { serverPassword: server.serverPassword }
575 : {}),
576 }),
577 ),
578 );
579
580 const snapshotSettings = yield* makeProviderSnapshotSettingsSource(effectiveConfig);
581 const snapshot = yield* makeManagedServerProvider<ProviderSnapshotSettings<OpenCodeSettings>>({
582 resolveMaintenance,
583 getSettings: snapshotSettings.getSettings,
584 streamSettings: snapshotSettings.streamSettings,
585 haveSettingsChanged: haveProviderSnapshotSettingsChanged,
586 checkProviderOnSettingsChange: () => false,
587 // A failed or still-loading catalog must recover without a manual
588 // refresh. Healthy instances need no recurring server starts.
589 refreshOnInterval: (snapshot) =>
590 snapshot.enabled &&
591 snapshot.installed &&
592 snapshot.status !== "ready" &&
593 snapshot.auth.status === "unknown",
594 initialSnapshot: (settings) =>
595 makePendingOpenCodeProvider(settings.provider).pipe(Effect.map(stampIdentity)),
596 checkProvider,
597 checkUsageLimits,
598 enrichSnapshot: ({ settings, snapshot, publishSnapshot }) =>
599 resolveMaintenance().pipe(
600 Effect.flatMap((maintenanceCapabilities) =>
601 enrichProviderSnapshotWithVersionAdvisory(snapshot, maintenanceCapabilities, {
602 enableProviderUpdateChecks: settings.enableProviderUpdateChecks,
603 }),
604 ),
605 Effect.provideService(HttpClient.HttpClient, httpClient),
606 Effect.provideService(ProviderLatestVersions.ProviderLatestVersions, latestVersions),
607 Effect.flatMap((enrichedSnapshot) => publishSnapshot(enrichedSnapshot)),
608 ),
609 }).pipe(
610 Effect.mapError(
611 (cause) =>
612 new ProviderDriverError({
613 driver: DRIVER_KIND,
614 instanceId,
615 detail: `Failed to build OpenCode snapshot: ${cause.message ?? String(cause)}`,
616 cause,
617 }),
618 ),
619 );
620
621 return {
622 instanceId,
623 driverKind: DRIVER_KIND,
624 continuationIdentity,
625 displayName,
626 accentColor,
627 enabled,
628 snapshot,
629 // A scan never installs OpenCode: without an offline probe result it fails and keeps the
630 // last inventory rather than guessing 1.x.
631 snapshotForCwd: (cwd) =>
632 !effectiveConfig.enabled
633 ? snapshot.getSnapshot
634 : runtimeProbe.get.pipe(
635 Effect.mapError(
636 (cause) =>
637 new ProviderDriverError({
638 driver: DRIVER_KIND,
639 instanceId,
640 detail: `Failed to probe OpenCode for '${cwd}'`,
641 cause,
642 }),
643 ),
644 Effect.flatMap((probed) =>
645 byOpenCodeRuntime(Effect.succeed(probed), {
646 v2: Effect.all(
647 [
648 snapshot.getSnapshot,
649 // A project's opencode.jsonc can define its own providers.
650 readSettledOpenCode2Catalog(
651 openCode2Server.withConnection(({ client }) =>
652 loadOpenCode2DirectoryCatalog(client, cwd),
653 ),
654 ).pipe(
655 Effect.map(
656 Option.map((catalog) =>
657 openCode2ProviderModels(effectiveConfig, catalog),
658 ),
659 ),
660 ),
661 listOpenCode2Workspace(cwd).pipe(
662 Effect.timeout("20 seconds"),
663 Effect.mapError(
664 (cause) =>
665 new ProviderDriverError({
666 driver: DRIVER_KIND,
667 instanceId,
668 detail: `Failed to list OpenCode commands and skills for '${cwd}'`,
669 cause,
670 }),
671 ),
672 ),
673 ],
674 { concurrency: "unbounded" },
675 ).pipe(
676 Effect.map(([machineSnapshot, cwdModels, { skills, commands }]) => ({
677 ...machineSnapshot,
678 ...workspaceModelsFor(machineSnapshot.models, cwdModels),
679 skills: openCode2SkillsToServerProviderSkills(skills),
680 slashCommands: openCode2CommandsToServerProviderSlashCommands(commands),
681 // A finished scan lists at least the built-ins. None means it
682 // timed out, so the registry decides from the provider's health.
683 slashCommandsPending: commands.length > 0 ? false : undefined,
684 })),
685 ),
686 v1: Effect.all([
687 snapshot.getSnapshot,
688 loadWorkspaceForCwd(cwd).pipe(Effect.timeout("20 seconds")),
689 ]).pipe(
690 Effect.map(
691 ([machineSnapshot, { skills, models, commands, slashCommandsPending }]) => ({
692 ...machineSnapshot,
693 ...workspaceModelsFor(machineSnapshot.models, models),
694 skills: openCodeSkillsToServerProviderSkills(skills),
695 slashCommands: openCodeCommandsToServerProviderSlashCommands(commands),
696 slashCommandsPending,
697 }),
698 ),
699 Effect.mapError(
700 (cause) =>
701 new ProviderDriverError({
702 driver: DRIVER_KIND,
703 instanceId,
704 detail: `Failed to probe OpenCode commands and skills for '${cwd}'`,
705 cause,
706 }),
707 ),
708 ),
709 }),
710 ),
711 ),
712 orchestrationAdapter,
713 textGeneration,
714 } satisfies ProviderInstance;
715 }),
716};