diff --git a/packages/cli/src/acp/agent.ts b/packages/cli/src/acp/agent.ts index fba6525a451f..40ab20747e6c 100644 --- a/packages/cli/src/acp/agent.ts +++ b/packages/cli/src/acp/agent.ts @@ -1,52 +1,113 @@ -import { agent, RequestError, type Stream } from "@agentclientprotocol/sdk" -import type { OpenCodeClient } from "@opencode/client/promise" +import { + agent, + RequestError, + type AgentHandlerContext, + type AgentNotificationHandlersByMethod, + type AgentNotificationMethod, + type AgentRequestHandlersByMethod, + type AgentRequestMethod, + type Stream, +} from "@agentclientprotocol/sdk" +import { ClientError, type OpenCodeClient } from "@opencode/client/promise" +import { Cause, Effect } from "effect" import { ACPConnection } from "./connection" import { ACPError } from "./error" import { ACPService } from "./service" -export function connect(client: OpenCodeClient, stream: Stream) { - const connection = agent({ name: "opencode" }) - .onRequest("initialize", (ctx) => run(service.initialize(ctx.params))) - .onRequest("authenticate", (ctx) => run(service.authenticate(ctx.params))) - .onRequest("session/new", (ctx) => run(service.newSession(ctx.params))) - .onRequest("session/load", (ctx) => run(service.loadSession(ctx.params))) - .onRequest("session/list", (ctx) => run(service.listSessions(ctx.params))) - .onRequest("session/delete", (ctx) => run(service.deleteSession(ctx.params))) - .onRequest("session/resume", (ctx) => run(service.resumeSession(ctx.params))) - .onRequest("session/close", (ctx) => run(service.closeSession(ctx.params))) - .onRequest("session/fork", (ctx) => run(service.forkSession(ctx.params))) - .onRequest("session/set_config_option", (ctx) => run(service.setSessionConfigOption(ctx.params))) - .onRequest("session/set_mode", (ctx) => run(service.setSessionMode(ctx.params))) - .onRequest("session/prompt", (ctx) => run(service.prompt(ctx.params, ctx.signal))) - .onNotification("session/cancel", (ctx) => run(service.cancel(ctx.params))) - .connect(stream) +// Untraced so request spans parent to the caller's span instead of a setup span that has already ended. +export const connect = Effect.fnUntraced(function* (client: OpenCodeClient, stream: Stream) { + const run = Effect.runPromiseWith(yield* Effect.context()) + const handle = + (call: (ctx: AgentHandlerContext) => Effect.Effect) => + (name: string) => { + const handler = Effect.fn(name)( + call, + Effect.mapError((error) => (error instanceof RequestError ? error : ACPError.toRequestError(error))), + Effect.tapCauseIf(Cause.hasDies, (cause) => Effect.logError("ACP request failed", cause)), + Effect.catchDefect((defect) => Effect.fail(ACPError.toRequestError(ACPError.fromUnknown(defect)))), + ) + return (ctx: AgentHandlerContext) => run(handler(ctx)) + } + const app = agent({ name: "opencode" }) + const request = ( + method: Method, + make: (name: string) => AgentRequestHandlersByMethod[Method], + ) => app.onRequest(method, make(spanName(method))) + const notification = ( + method: Method, + make: (name: string) => AgentNotificationHandlersByMethod[Method], + ) => app.onNotification(method, make(spanName(method))) + + request( + "initialize", + handle((ctx) => promise(() => service.initialize(ctx.params))), + ) + request( + "authenticate", + handle((ctx) => promise(() => service.authenticate(ctx.params))), + ) + request( + "session/new", + handle((ctx) => promise(() => service.newSession(ctx.params))), + ) + request( + "session/load", + handle((ctx) => promise(() => service.loadSession(ctx.params))), + ) + request( + "session/list", + handle((ctx) => promise(() => service.listSessions(ctx.params))), + ) + request( + "session/delete", + handle((ctx) => promise(() => service.deleteSession(ctx.params))), + ) + request( + "session/resume", + handle((ctx) => promise(() => service.resumeSession(ctx.params))), + ) + request( + "session/close", + handle((ctx) => promise(() => service.closeSession(ctx.params))), + ) + request( + "session/fork", + handle((ctx) => promise(() => service.forkSession(ctx.params))), + ) + request( + "session/set_config_option", + handle((ctx) => promise(() => service.setSessionConfigOption(ctx.params))), + ) + request( + "session/set_mode", + handle((ctx) => promise(() => service.setSessionMode(ctx.params))), + ) + // The SDK signal is passed through rather than interrupting the fiber: a cancelled turn still resolves with + // `stopReason: "cancelled"`. + request( + "session/prompt", + handle((ctx) => promise(() => service.prompt(ctx.params, ctx.signal))), + ) + notification( + "session/cancel", + handle((ctx) => promise(() => service.cancel(ctx.params))), + ) + const connection = app.connect(stream) // Inbound dispatch starts after the stream's async read loop yields, so handlers never observe this before assignment. const service = ACPService.make({ client, connection: ACPConnection.make(connection) }) return connection -} +}) -async function run(promise: Promise) { - try { - return await promise - } catch (error) { - if (error instanceof RequestError) throw error - if (isACPError(error)) throw ACPError.toRequestError(error) - throw ACPError.toRequestError(ACPError.fromUnknown(error)) - } -} +const spanName = (method: string) => `cli.acp.${method.replaceAll("/", ".")}` -function isACPError(error: unknown): error is ACPError.Error { - return ( - error instanceof ACPError.SessionNotFoundError || - error instanceof ACPError.SessionDirectoryMismatchError || - error instanceof ACPError.InvalidConfigOptionError || - error instanceof ACPError.InvalidModelError || - error instanceof ACPError.InvalidEffortError || - error instanceof ACPError.InvalidModeError || - error instanceof ACPError.AuthRequiredError || - error instanceof ACPError.UnknownAuthMethodError || - error instanceof ACPError.ServiceFailureError +const promise = (evaluate: () => Promise) => + Effect.tryPromise({ try: evaluate, catch: (cause) => cause }).pipe( + Effect.catch((cause) => { + if (cause instanceof RequestError || ACPError.is(cause)) return Effect.fail(cause) + if (cause instanceof ClientError && cause.reason === "Transport") + return Effect.fail(new ACPError.ServerUnavailableError()) + return Effect.die(cause) + }), ) -} export * as ACP from "./agent" diff --git a/packages/cli/src/acp/error.ts b/packages/cli/src/acp/error.ts index 6256ae92b444..6ffc0c887434 100644 --- a/packages/cli/src/acp/error.ts +++ b/packages/cli/src/acp/error.ts @@ -40,16 +40,27 @@ export class ServiceFailureError extends Schema.TaggedError errorName: Schema.optional(Schema.String), }) {} -export type Error = - | SessionNotFoundError - | SessionDirectoryMismatchError - | InvalidConfigOptionError - | InvalidModelError - | InvalidEffortError - | InvalidModeError - | AuthRequiredError - | UnknownAuthMethodError - | ServiceFailureError +export class ServerUnavailableError extends Schema.TaggedError()( + "ACPServerUnavailableError", + {}, +) {} + +const Errors = Schema.Union([ + SessionNotFoundError, + SessionDirectoryMismatchError, + InvalidConfigOptionError, + InvalidModelError, + InvalidEffortError, + InvalidModeError, + AuthRequiredError, + UnknownAuthMethodError, + ServiceFailureError, + ServerUnavailableError, +]) + +export type Error = typeof Errors.Type + +export const is = Schema.is(Errors) export function toRequestError(error: Error): RequestError { switch (error._tag) { @@ -83,6 +94,8 @@ export function toRequestError(error: Error): RequestError { }, error.safeMessage, ) + case "ACPServerUnavailableError": + return RequestError.internalError({ errorName: "ServerUnavailable" }, "OpenCode server is unavailable") } const exhaustive: never = error return exhaustive diff --git a/packages/cli/src/commands/handlers/acp.ts b/packages/cli/src/commands/handlers/acp.ts index e170f05bc065..56ece4f82cf1 100644 --- a/packages/cli/src/commands/handlers/acp.ts +++ b/packages/cli/src/commands/handlers/acp.ts @@ -1,7 +1,9 @@ import { ndJsonStream } from "@agentclientprotocol/sdk" import { OpenCode } from "@opencode/client/promise" import { Service } from "@opencode/client/effect/service" +import { CrossSpawnSpawner } from "@opencode/util/cross-spawn-spawner" import { Effect } from "effect" +import { Writable } from "node:stream" import { ACP } from "../../acp/agent" import { Commands } from "../commands" import { Runtime } from "../../framework/runtime" @@ -13,23 +15,26 @@ export default Runtime.handler( process.env.OPENCODE_CLIENT = "acp" const endpoint = yield* Standalone.start() const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) }) - const input = new WritableStream({ - write: (chunk) => - new Promise((resolve, reject) => { - process.stdout.write(chunk, (error) => (error ? reject(error) : resolve())) + const connection = yield* ACP.connect(client, ndJsonStream(Writable.toWeb(process.stdout), Bun.stdin.stream())) + const code = yield* Effect.raceFirst( + Effect.promise(() => connection.closed).pipe(Effect.as(0)), + endpoint.exited.pipe( + Effect.match({ + onSuccess: (code) => `code ${code}`, + onFailure: (error) => + error.cause instanceof CrossSpawnSpawner.KilledBySignal ? `signal ${error.cause.signal}` : error.message, }), - }) - const output = new ReadableStream({ - start(controller) { - process.stdin.on("data", (chunk: Buffer) => controller.enqueue(new Uint8Array(chunk))) - process.stdin.on("end", () => controller.close()) - process.stdin.on("error", (error) => controller.error(error)) - }, - }) - const connection = ACP.connect(client, ndJsonStream(input, output)) - process.stdin.resume() - yield* Effect.promise(() => connection.closed) - // EOF owns this stdio process; exiting also closes the private server's lease pipe. - yield* Effect.sync(() => process.exit(0)) + // stdout carries ACP, so the diagnostic goes to stderr. + Effect.flatMap((reason) => + Effect.sync(() => { + process.stderr.write(`opencode acp: server exited unexpectedly (${reason})\n`) + return 1 + }), + ), + ), + ) + // Closing the handler scope would wait for the private server's graceful shutdown; its lease pipe already + // ends the server once this process exits. + yield* Effect.sync(() => process.exit(code)) }), ) diff --git a/packages/cli/src/services/standalone.ts b/packages/cli/src/services/standalone.ts index 9ec70ac8431f..b69e13ea3ea8 100644 --- a/packages/cli/src/services/standalone.ts +++ b/packages/cli/src/services/standalone.ts @@ -1,4 +1,4 @@ -import { Service, type Endpoint } from "@opencode/client/effect/service" +import { Service } from "@opencode/client/effect/service" import { CrossSpawnSpawner } from "@opencode/util/cross-spawn-spawner" import { LayerNode } from "@opencode/util/effect/layer-node" import { Deferred, Effect, Schema, Stream } from "effect" @@ -53,7 +53,8 @@ const makeEndpoint = Effect.fn("cli.standalone.endpoint")( url: ready.url, auth: { type: "basic" as const, username: "opencode", password }, pid: proc.pid, - } satisfies Endpoint & { readonly pid: number } + exited: proc.exitCode, + } }, Effect.provide(LayerNode.compile(CrossSpawnSpawner.node)), ) diff --git a/packages/cli/test/acp/error.test.ts b/packages/cli/test/acp/error.test.ts index 421364d0feb7..b17176764d5d 100644 --- a/packages/cli/test/acp/error.test.ts +++ b/packages/cli/test/acp/error.test.ts @@ -1,6 +1,8 @@ import { describe, expect, test } from "bun:test" import { RequestError } from "@agentclientprotocol/sdk" +import { Cause } from "effect" import { ACPError } from "../../src/acp/error" +import { rpcError, startSession, startWire } from "./wire-fixture" describe("acp errors", () => { test("maps validation failures to invalid params", () => { @@ -58,3 +60,34 @@ describe("acp errors", () => { expect(serialized).not.toContain("stack") }) }) + +describe("acp error boundary over the wire", () => { + test("maps unexpected server failures to the generic internal error", async () => { + await using acp = await startWire({ + fetch: (request) => + request.method === "POST" && request.path === "/api/session" ? new Response(null, { status: 500 }) : undefined, + }) + await acp.initialize() + + expect(await rpcError(acp.newSession())).toEqual({ + code: -32603, + message: "Internal error: Internal service failure", + data: { errorName: "ClientError" }, + }) + expect(acp.logs.map((log) => ({ message: log.message, cause: Cause.squash(log.cause) }))).toMatchObject([ + { message: ["ACP request failed"], cause: { name: "ClientError", reason: "UnexpectedStatus" } }, + ]) + }) + + test("reports an unavailable server once the server stops", async () => { + await using acp = await startSession() + await acp.server.stop() + + expect(await rpcError(acp.request("session/list", {}))).toEqual({ + code: -32603, + message: "Internal error: OpenCode server is unavailable", + data: { errorName: "ServerUnavailable" }, + }) + expect(acp.logs).toEqual([]) + }) +}) diff --git a/packages/cli/test/acp/lifecycle.subprocess.test.ts b/packages/cli/test/acp/lifecycle.subprocess.test.ts index 72d2a2103004..0e5c2f2886f5 100644 --- a/packages/cli/test/acp/lifecycle.subprocess.test.ts +++ b/packages/cli/test/acp/lifecycle.subprocess.test.ts @@ -101,8 +101,8 @@ describe("acp lifecycle subprocess", () => { }, 60_000) // The private server is found with `pgrep`, which Windows lacks. - const todoOutsideWindows = process.platform === "win32" ? test.skip : test.todo - todoOutsideWindows( + const testOutsideWindows = process.platform === "win32" ? test.skip : test + testOutsideWindows( "exits when the private server process dies (https://github.com/anomalyco/opencode/issues/51716)", async () => { await using fixture = await createAcpFixture() @@ -121,7 +121,9 @@ describe("acp lifecycle subprocess", () => { const timeout = Promise.withResolvers<"running">() const timer = setTimeout(() => timeout.resolve("running"), 10_000) const exited = await Promise.race([acp.exited, timeout.promise]).finally(() => clearTimeout(timer)) - expect(exited).not.toBe("running") + expect(exited).toBe(1) + await acp[Symbol.asyncDispose]() + expect(acp.stderr()).toContain("opencode acp: server exited unexpectedly (signal SIGKILL)") }, 60_000, ) diff --git a/packages/cli/test/acp/wire-fixture.ts b/packages/cli/test/acp/wire-fixture.ts index 01e3da975c7c..fbe5cff56273 100644 --- a/packages/cli/test/acp/wire-fixture.ts +++ b/packages/cli/test/acp/wire-fixture.ts @@ -28,7 +28,7 @@ import { type TokenUsageInfo, } from "@opencode/client/promise" import type { BunRequest } from "bun" -import { Option, Schema } from "effect" +import { Effect, Logger, Option, Schema } from "effect" import { ACP } from "../../src/acp/agent" type DurableEvent = Extract @@ -377,9 +377,12 @@ export async function startWire(options: WireOptions = {}) { const clientToAgent = new TransformStream() const agentToClient = new TransformStream() - const agentConnection = ACP.connect( - OpenCode.make({ baseUrl: server.url }), - ndJsonStream(agentToClient.writable, clientToAgent.readable), + const logs: Array, "message" | "cause">> = [] + const agentConnection = await Effect.runPromise( + ACP.connect( + OpenCode.make({ baseUrl: server.url }), + ndJsonStream(agentToClient.writable, clientToAgent.readable), + ).pipe(Effect.provide(Logger.layer([Logger.make((log) => logs.push({ message: log.message, cause: log.cause }))]))), ) const clientStream = ndJsonStream(clientToAgent.writable, agentToClient.readable) const connection = client({ name: "test" }) @@ -456,6 +459,7 @@ export async function startWire(options: WireOptions = {}) { return { server, + logs, received, updates, permissions,