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

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
}