diff --git a/packages/provider-opencode/src/server/driver.test.ts b/packages/provider-opencode/src/server/driver.test.ts index d19068dedc1f9..2456ccdc21169 100644 --- a/packages/provider-opencode/src/server/driver.test.ts +++ b/packages/provider-opencode/src/server/driver.test.ts @@ -37,7 +37,11 @@ import * as ProviderMaintenance from "@t3tools/provider-core/server/maintenanceR import * as OpenCodeRuntime from "./OpenCodeRuntime.ts"; import { OpenCodeDriver, isLocalOpenCodeServerUrl, openCodeUpdateFor } from "./driver.ts"; import * as OpenCodeServerLedger from "./OpenCodeServerLedger.ts"; -import { OPENCODE_2_RESPONSES, replayOpenCodeServer } from "./probeResponses.fixture.ts"; +import { + OPENCODE_2_RESPONSES, + OPENCODE_2_WORKSPACE_RESPONSES, + replayOpenCodeServer, +} from "./probeResponses.fixture.ts"; import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost"; it("only probes a locally configured OpenCode server's installed CLI", () => { @@ -413,6 +417,45 @@ it.layer(layer)("OpenCodeDriver runtime selection", (it) => { }).pipe(Effect.scoped, Effect.provide(TestClock.layer())), ); + it.effect.each(["/api/debug/location", "/api/event"])( + "lists workspace skills from an external OpenCode 2 server whose %s never answers", + (stalled) => + Effect.gen(function* () { + const answers: Record = { + "/api/info": OPENCODE_2_RESPONSES["/api/info"].body, + "/api/debug/location": "[]", + "/api/command": OPENCODE_2_WORKSPACE_RESPONSES["/api/command"].body, + "/api/skill": OPENCODE_2_WORKSPACE_RESPONSES["/api/skill"].body, + }; + const http = HttpClient.make((request) => { + const path = new URL(request.url).pathname; + if (path === stalled) return Effect.never; + if (path === "/api/event") + return Effect.succeed( + HttpClientResponse.fromWeb( + request, + new Response(new ReadableStream(), { + headers: { "content-type": "text/event-stream" }, + }), + ), + ); + const body = answers[path]; + return body === undefined + ? Effect.die(`Unexpected request: ${path}`) + : Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(JSON.parse(body)))); + }); + const instance = yield* create({ serverUrl: "http://127.0.0.1:4096" }, http); + + const snapshot = yield* instance.snapshotForCwd!("/work").pipe(Effect.forkChild); + yield* TestClock.adjust("30 seconds"); + const { skills } = yield* Fiber.join(snapshot); + assert.include( + skills.map((skill) => skill.name), + "plum", + ); + }).pipe(Effect.scoped, Effect.provide(TestClock.layer())), + ); + it.effect.each(["probe", "error", "empty"] as const)( "recovers discovery without a manual refresh after %s", (initialCatalog) => diff --git a/packages/provider-opencode/src/server/driver.ts b/packages/provider-opencode/src/server/driver.ts index 694d50b1f4df3..11691eece3108 100644 --- a/packages/provider-opencode/src/server/driver.ts +++ b/packages/provider-opencode/src/server/driver.ts @@ -379,7 +379,9 @@ export const OpenCodeDriver: ProviderDriver< const listOpenCode2Workspace = (cwd: string) => openCode2Server.withConnection(({ client, events }) => Effect.gen(function* () { - const location = { directory: cwd }; + // OpenCode names a location by its resolved path (no trailing slash or `..`). + const directory = pathService.resolve(cwd); + const location = { directory }; const scanned = yield* Deferred.make(); const pending = new Set(["command.updated", "skill.updated"]); const stream = yield* events.pipe(Effect.option); @@ -387,7 +389,7 @@ export const OpenCodeDriver: ProviderDriver< yield* stream.value.pipe( Stream.runForEach((event) => "location" in event && - event.location?.directory === cwd && + event.location?.directory === directory && pending.delete(event.type) && pending.size === 0 ? Deferred.succeed(scanned, undefined) @@ -406,6 +408,14 @@ export const OpenCodeDriver: ProviderDriver< { concurrency: "unbounded" }, ), Deferred.await(scanned), + // Without events no scan can be awaited, so trust the first read as before. + stream._tag === "None" + ? Effect.succeed(true) + : client.debug.location.list().pipe( + Effect.map((loaded) => loaded.some((entry) => entry.directory === directory)), + Effect.timeout("2 seconds"), + Effect.orElseSucceed(() => true), + ), ); }).pipe(Effect.scoped), ); diff --git a/packages/provider-opencode/src/server/status.test.ts b/packages/provider-opencode/src/server/status.test.ts index c8d324f06012b..f691337257a34 100644 --- a/packages/provider-opencode/src/server/status.test.ts +++ b/packages/provider-opencode/src/server/status.test.ts @@ -1113,17 +1113,50 @@ const scanned: OpenCode2Workspace = { ], }; -it.effect("reads a fresh OpenCode 2 directory again once its scan has ended", () => +it.effect( + "reads a loaded OpenCode 2 directory listing no commands again once its scan has ended", + () => + Effect.gen(function* () { + const reads: Array = [{ commands: [], skills: [] }, scanned]; + const scanEnded = yield* Deferred.make(); + const load = yield* loadOpenCode2Workspace( + Effect.sync(() => reads.shift()!), + Deferred.await(scanEnded), + Effect.succeed(true), + ).pipe(Effect.forkChild); + yield* Effect.yieldNow; + NodeAssert.equal(reads.length, 1); + yield* Deferred.succeed(scanEnded, undefined); + NodeAssert.deepEqual(yield* Fiber.join(load), scanned); + }), +); + +it.effect("waits for the scan of a cold OpenCode 2 directory that first lists only built-ins", () => Effect.gen(function* () { - const reads: Array = [{ commands: [], skills: [] }, scanned]; - const scanEnded = yield* Deferred.make(); - const load = yield* loadOpenCode2Workspace( - Effect.sync(() => reads.shift()!), - Deferred.await(scanEnded), - ).pipe(Effect.forkChild); - yield* Effect.yieldNow; - NodeAssert.equal(reads.length, 1); - yield* Deferred.succeed(scanEnded, undefined); - NodeAssert.deepEqual(yield* Fiber.join(load), scanned); + const calls: Array = []; + const reads: Array = [ + { commands: builtinCommands, skills: builtinSkills }, + scanned, + ]; + const workspace = yield* loadOpenCode2Workspace( + Effect.sync(() => (calls.push("read"), reads.shift()!)), + Effect.sync(() => void calls.push("scanned")), + Effect.sync(() => (calls.push("loaded"), false)), + ); + NodeAssert.deepEqual(workspace, scanned); + NodeAssert.deepEqual(calls, ["loaded", "read", "scanned", "read"]); + }), +); + +it.effect("reads an already loaded OpenCode 2 directory once without waiting for a scan", () => + Effect.gen(function* () { + const calls: Array = []; + const workspace = yield* loadOpenCode2Workspace( + Effect.sync(() => (calls.push("read"), scanned)), + Effect.sync(() => void calls.push("scanned")), + Effect.succeed(true), + ); + NodeAssert.deepEqual(workspace, scanned); + NodeAssert.deepEqual(calls, ["read"]); }), ); diff --git a/packages/provider-opencode/src/server/status.ts b/packages/provider-opencode/src/server/status.ts index 0ba2f84ceb896..c1d873073b9ca 100644 --- a/packages/provider-opencode/src/server/status.ts +++ b/packages/provider-opencode/src/server/status.ts @@ -527,15 +527,20 @@ export interface OpenCode2Workspace { } /** - * A server scans a directory it has not served yet in the background: its first read lists - * no commands at all (not even the built-ins), and `command.updated` plus `skill.updated` - * for the directory end the scan. `scanned` must be listening before `read` runs, since - * the read is what starts the scan. + * Reading a location the server has not loaded boots its scan, and only reads after the scan's + * `command.updated` plus `skill.updated` are complete; `scanned` must listen before `read`. A + * loaded location listing no commands is still scanning. OpenCode exposes no readiness signal, + * so one another caller booted moments earlier can still read partial. */ export const loadOpenCode2Workspace = Effect.fn("OpencodeProviderStatus.loadOpenCode2Workspace")( - function* (read: Effect.Effect, scanned: Effect.Effect) { + function* ( + read: Effect.Effect, + scanned: Effect.Effect, + loaded: Effect.Effect, + ) { + const wasLoaded = yield* loaded; const first = yield* read; - if (first.commands.length > 0) return first; + if (wasLoaded && first.commands.length > 0) return first; yield* scanned.pipe(Effect.timeoutOption("10 seconds")); return yield* read; },