feat(acp): add initial acp-next skeleton behind runtime flag (#29226)

packages/opencode/test/cli/acp-next/acp-next-process.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect } from "bun:test"
+import type { AuthenticateResponse, InitializeResponse } from "@agentclientprotocol/sdk"
+import { Effect } from "effect"
+import { cliIt } from "../../lib/cli-process"
+import { createAcpClient, expectOk } from "../acp/acp-test-client"
+
+describe("opencode acp-next (subprocess)", () => {
+  cliIt.live(
+    "responds to initialize behind OPENCODE_ACP_NEXT",
+    ({ opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(yield* opencode.acp({ env: { OPENCODE_ACP_NEXT: "1" } }))
+        const initialized = expectOk(
+          yield* acp.request<InitializeResponse>("initialize", {
+            protocolVersion: 1,
+            clientCapabilities: { _meta: { "terminal-auth": true } },
+          }),
+        )
+
+        expect(initialized.protocolVersion).toBe(1)
+        expect(initialized.agentCapabilities?.promptCapabilities?.embeddedContext).toBe(true)
+        expect(initialized.agentCapabilities?.promptCapabilities?.image).toBe(true)
+        expect(initialized.agentCapabilities?.mcpCapabilities?.http).toBe(true)
+        expect(initialized.agentCapabilities?.mcpCapabilities?.sse).toBe(true)
+        expect(initialized.agentCapabilities?.sessionCapabilities).toBeUndefined()
+        expect(initialized.agentInfo?.name).toBe("OpenCode")
+        expect(initialized.authMethods?.[0]?.id).toBe("opencode-login")
+        expect(initialized.authMethods?.[0]?._meta?.["terminal-auth"]).toBeDefined()
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "authenticate succeeds for the advertised auth method and rejects unknown methods safely",
+    ({ opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(yield* opencode.acp({ env: { OPENCODE_ACP_NEXT: "1" } }))
+        const initialized = expectOk(yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 }))
+        const methodId = initialized.authMethods?.[0]?.id
+        expect(methodId).toBe("opencode-login")
+
+        expectOk(yield* acp.request<AuthenticateResponse>("authenticate", { methodId }))
+
+        const rejected = yield* acp.request<AuthenticateResponse>("authenticate", { methodId: "missing-auth-method" })
+        expect(errorCode(rejected.error)).toBe(-32602)
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "SDK-required session stubs fail with safe unsupported errors",
+    ({ home, opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(yield* opencode.acp({ env: { OPENCODE_ACP_NEXT: "1" } }))
+        yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 })
+
+        const newSession = yield* acp.request("session/new", { cwd: home, mcpServers: [] })
+        expect(errorCode(newSession.error)).toBe(-32601)
+
+        const prompt = yield* acp.request("session/prompt", {
+          sessionId: "ses_missing",
+          prompt: [{ type: "text", text: "hello" }],
+        })
+        expect(errorCode(prompt.error)).toBe(-32601)
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "exits cleanly when flagged stdin is closed",
+    ({ opencode }) =>
+      Effect.gen(function* () {
+        const exitedPromise = yield* Effect.scoped(
+          Effect.gen(function* () {
+            const acp = yield* opencode.acp({ env: { OPENCODE_ACP_NEXT: "1" } })
+            return acp.exited
+          }),
+        )
+
+        const code = yield* Effect.promise(() => exitedPromise)
+        expect(typeof code === "number" || code === null).toBe(true)
+      }),
+    60_000,
+  )
+
+  cliIt.live(
+    "default unflagged path still uses production ACP",
+    ({ opencode }) =>
+      Effect.gen(function* () {
+        const acp = createAcpClient(yield* opencode.acp())
+        const initialized = expectOk(yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 }))
+
+        expect(initialized.agentCapabilities?.sessionCapabilities?.close).toEqual({})
+        expect(initialized.agentCapabilities?.sessionCapabilities?.resume).toEqual({})
+      }),
+    60_000,
+  )
+})
+
+function errorCode(error: unknown) {
+  if (!error || typeof error !== "object") return undefined
+  if (!("code" in error)) return undefined
+  return typeof error.code === "number" ? error.code : undefined
+}