artificial-code 1.17.13 → 1.17.15

package/test/cli/run/run-process.test.ts

@@ -1,331 +0,0 @@
-// Subprocess integration tests for `opencode run` (non-interactive mode).
-// These exercise the real CLI binary against a TestLLMServer running in the
-// same process. See `test/lib/cli-process.ts` for the harness — each test uses
-// `opencode.run(message, opts?)` to spawn `bun src/index.ts run ...` with
-// `AC_CONFIG_CONTENT` providing the test provider config inline.
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { reply } from "../../lib/llm-server"
-import { cliIt } from "../../lib/cli-process"
-
-describe("opencode run (non-interactive subprocess)", () => {
-  // Happy path: prompt completes, output reaches stdout, process exits 0.
-  // If this fails, all the others likely will too — debug here first.
-  cliIt.concurrent(
-    "exits 0 and writes the response to stdout on a successful prompt",
-    ({ llm, opencode }) =>
-      Effect.gen(function* () {
-        yield* llm.text("hello from the test llm")
-        const result = yield* opencode.run("say hi")
-        opencode.expectExit(result, 0)
-        expect(result.stdout).toBe("hello from the test llm\n")
-      }),
-    60_000,
-  )
-
-  cliIt.concurrent(
-    "prints each completed text part in order around a tool continuation",
-    ({ llm, opencode }) =>
-      Effect.gen(function* () {
-        yield* llm.push(
-          reply().text("  before tool  ").tool("bash", {
-            command: "printf tool-output",
-            description: "Print deterministic output",
-          }),
-        )
-        yield* llm.text("  after tool  ")
-
-        const result = yield* opencode.run("use a tool", {
-          extraArgs: ["--dangerously-skip-permissions"],
-        })
-
-        opencode.expectExit(result, 0)
-        expect(result.stdout).toBe("before tool\nafter tool\n")
-      }),
-    60_000,
-  )
-
-  cliIt.concurrent(
-    "prints reasoning before text only with --thinking",
-    ({ llm, opencode }) =>
-      Effect.gen(function* () {
-        yield* llm.reason("  considering  ", { text: "  answer  " })
-        const thinking = yield* opencode.run("think", { extraArgs: ["--thinking"] })
-        opencode.expectExit(thinking, 0)
-        expect(thinking.stdout).toBe("Thinking: considering\nanswer\n")
-
-        yield* llm.reason("hidden", { text: "visible" })
-        const plain = yield* opencode.run("think again")
-        opencode.expectExit(plain, 0)
-        expect(plain.stdout).toBe("visible\n")
-      }),
-    60_000,
-  )
-
-  // Regression for #27371: an unknown model used to hang the process forever
-  // waiting on a session.status === idle event that never arrived. The fix
-  // makes the SDK call surface an error promptly so the process exits nonzero.
-  // We assert nonzero exit AND wall-clock under the harness timeout — a hang
-  // would expire the timeout and produce a different (signal-killed) failure.
-  cliIt.concurrent(
-    "exits nonzero promptly when the model is unknown (regression for #27371)",
-    ({ opencode }) =>
-      Effect.gen(function* () {
-        const result = yield* opencode.run("say hi", {
-          model: "test/nonexistent-model",
-          timeoutMs: 15_000,
-        })
-        expect(result.exitCode).not.toBe(0)
-        expect(result.durationMs).toBeLessThan(15_000)
-      }),
-    30_000,
-  )
-
-  // The test provider's SSE error item is interpreted by the SDK as an unknown
-  // finish, not a fatal provider/session error. Lock that distinction in so it
-  // is not accidentally used as the failure compatibility oracle.
-  cliIt.concurrent(
-    "unknown stream finish preserves partial output and exits 0",
-    ({ llm, opencode }) =>
-      Effect.gen(function* () {
-        yield* llm.push(
-          reply().text("partial response").tool("bash", {
-            command: "printf tool",
-            description: "Print deterministic output",
-          }),
-        )
-        yield* llm.fail("upstream provider exploded mid-stream")
-        const result = yield* opencode.run("trigger midstream error", { timeoutMs: 30_000 })
-        expect(result.exitCode).toBe(0)
-        expect(result.stdout).toBe("partial response\n")
-        expect(result.stderr).not.toContain("upstream provider exploded mid-stream")
-      }),
-    60_000,
-  )
-
-  // --format json puts one JSON object per line on stdout for each emitted
-  // event. Consumers (CI scripts, tooling) parse this stream. Asserts the
-  // shape so a future event-emit change has to update this expectation.
-  cliIt.concurrent(
-    "--format json emits parseable line-delimited JSON to stdout",
-    ({ llm, opencode }) =>
-      Effect.gen(function* () {
-        yield* llm.text("structured output")
-        const result = yield* opencode.run("say hi", { format: "json" })
-        opencode.expectExit(result, 0)
-
-        const events = opencode.parseJsonEvents(result.stdout)
-        expect(events.length).toBeGreaterThan(0)
-        for (const evt of events) {
-          expect(typeof evt.type).toBe("string")
-          expect(typeof evt.sessionID).toBe("string")
-        }
-        expect(events.map((event) => event.type)).toEqual(["step_start", "text", "step_finish"])
-        expect(events.map(({ timestamp: _, sessionID: __, ...event }) => event)).toEqual([
-          { type: "step_start", part: expect.objectContaining({ type: "step-start" }) },
-          {
-            type: "text",
-            part: expect.objectContaining({ type: "text", text: "structured output" }),
-          },
-          { type: "step_finish", part: expect.objectContaining({ type: "step-finish" }) },
-        ])
-        expect(result.stdout.endsWith("\n")).toBe(true)
-        expect(
-          result.stdout
-            .split("\n")
-            .slice(0, -1)
-            .every((line) => line.length > 0),
-        ).toBe(true)
-      }),
-    60_000,
-  )
-
-  cliIt.concurrent(
-    "--format json emits a pure error record for a rejected prompt request",
-    ({ opencode }) =>
-      Effect.gen(function* () {
-        const result = yield* opencode.run("use an unknown model", {
-          model: "test/nonexistent-model",
-          format: "json",
-        })
-
-        expect(result.exitCode).not.toBe(0)
-        const events = opencode.parseJsonEvents(result.stdout)
-        expect(events.map((event) => event.type)).toEqual(["error"])
-        expect(events[0]).toEqual({
-          type: "error",
-          timestamp: expect.any(Number),
-          sessionID: expect.any(String),
-          error: expect.any(Object),
-        })
-        expect(result.stdout.split("\n").filter(Boolean)).toHaveLength(1)
-      }),
-    30_000,
-  )
-
-  cliIt.concurrent(
-    "--format json preserves reasoning, tool, and continuation ordering",
-    ({ llm, opencode }) =>
-      Effect.gen(function* () {
-        yield* llm.push(
-          reply().reason("reasoning").text("before").tool("bash", {
-            command: "printf tool",
-            description: "Print deterministic output",
-          }),
-        )
-        yield* llm.text("after")
-
-        const result = yield* opencode.run("exercise json records", {
-          format: "json",
-          extraArgs: ["--thinking", "--dangerously-skip-permissions"],
-        })
-
-        expect(result.exitCode).toBe(0)
-        const events = opencode.parseJsonEvents(result.stdout)
-        expect(events.map((event) => event.type)).toEqual([
-          "step_start",
-          "reasoning",
-          "text",
-          "tool_use",
-          "step_finish",
-          "step_start",
-          "text",
-          "step_finish",
-        ])
-        expect(events.find((event) => event.type === "reasoning")?.part).toEqual(
-          expect.objectContaining({ type: "reasoning", text: "reasoning" }),
-        )
-        expect(events.find((event) => event.type === "tool_use")?.part).toEqual(
-          expect.objectContaining({
-            type: "tool",
-            tool: "bash",
-            state: expect.objectContaining({ status: "completed" }),
-          }),
-        )
-        expect(
-          result.stdout
-            .split("\n")
-            .slice(0, -1)
-            .every((line) => line.startsWith("{")),
-        ).toBe(true)
-      }),
-    60_000,
-  )
-
-  cliIt.concurrent(
-    "--format json records partial output for an unknown stream finish",
-    ({ llm, opencode }) =>
-      Effect.gen(function* () {
-        yield* llm.push(
-          reply().text("partial json").tool("bash", {
-            command: "printf tool",
-            description: "Print deterministic output",
-          }),
-        )
-        yield* llm.fail("provider failed")
-        const result = yield* opencode.run("fail after output", { format: "json" })
-
-        const events = opencode.parseJsonEvents(result.stdout)
-        expect(result.exitCode).toBe(0)
-        expect(events.map((event) => event.type)).toEqual([
-          "step_start",
-          "text",
-          "tool_use",
-          "step_finish",
-          "step_start",
-          "step_finish",
-        ])
-        expect(events[1]?.part).toEqual(expect.objectContaining({ type: "text", text: "partial json" }))
-        expect(events.at(-1)?.part).toEqual(expect.objectContaining({ type: "step-finish", reason: "unknown" }))
-      }),
-    60_000,
-  )
-
-  cliIt.concurrent(
-    "rejects requested permissions by default and allows them with the dangerous flag",
-    ({ home, llm, opencode }) =>
-      Effect.gen(function* () {
-        yield* llm.tool("bash", { command: "rm -f denied-file", description: "Remove a test file" })
-        yield* llm.text("continued after rejection")
-        const denied = yield* opencode.run("request permission", { permission: { bash: "ask" } })
-        opencode.expectExit(denied, 0)
-        expect(denied.stderr).toContain("permission requested: bash")
-        expect(denied.stdout).toBe("")
-
-        yield* llm.reset
-        yield* llm.tool("bash", { command: "rm -f allowed-file", description: "Remove a test file" })
-        yield* llm.text("continued after approval")
-        const allowed = yield* opencode.run("request permission", {
-          permission: { bash: "ask" },
-          extraArgs: ["--dangerously-skip-permissions"],
-        })
-        opencode.expectExit(allowed, 0)
-        expect(allowed.stderr).not.toContain("permission requested: bash")
-        expect(allowed.stdout).toContain("continued after approval")
-
-        yield* llm.reset
-        yield* llm.tool("bash", { command: "touch explicitly-denied", description: "Create a denied marker" })
-        yield* llm.text("continued after explicit denial")
-        const explicitlyDenied = yield* opencode.run("request denied permission", {
-          permission: { bash: "deny" },
-          extraArgs: ["--dangerously-skip-permissions"],
-        })
-        opencode.expectExit(explicitlyDenied, 0)
-        expect(explicitlyDenied.stdout).toContain("continued after explicit denial")
-        expect(yield* Effect.promise(() => Bun.file(`${home}/explicitly-denied`).exists())).toBe(false)
-      }),
-    60_000,
-  )
-
-  cliIt.live(
-    "attach mode sends client-local file contents without a shared path",
-    ({ home, llm, opencode }) =>
-      Effect.gen(function* () {
-        const source = `${home}/client-only.txt`
-        const sentinel = "client-only attachment sentinel"
-        yield* Effect.promise(() => Bun.write(source, sentinel))
-        yield* llm.text("attachment received")
-        const server = yield* opencode.serve()
-
-        const result = yield* opencode.run("read the attachment", {
-          extraArgs: ["--attach", server.url, `--file=${source}`, "--"],
-        })
-
-        opencode.expectExit(result, 0)
-        const input = JSON.stringify(yield* llm.inputs)
-        expect(input).toContain(sentinel)
-        expect(input).not.toContain(`file://${source}`)
-      }),
-    60_000,
-  )
-
-  cliIt.concurrent(
-    "attach mode rejects local directories before prompt admission",
-    ({ home, opencode }) =>
-      Effect.gen(function* () {
-        const result = yield* opencode.run("read the directory", {
-          extraArgs: ["--attach", "http://127.0.0.1:1", `--file=${home}`, "--"],
-        })
-
-        expect(result.exitCode).not.toBe(0)
-        expect(result.stderr).toContain("Cannot attach local directory without a shared filesystem")
-      }),
-    30_000,
-  )
-
-  cliIt.live(
-    "SIGINT interrupts an active non-interactive run without leaking the process",
-    ({ llm, opencode }) =>
-      Effect.gen(function* () {
-        yield* llm.hang
-        const run = yield* opencode.startRun("wait forever")
-        yield* llm.wait(1)
-        run.interrupt()
-        const result = yield* run.result
-
-        expect(result.exitCode).not.toBe(0)
-        expect(result.durationMs).toBeLessThan(30_000)
-      }),
-    30_000,
-  )
-})

package/test/cli/run/runtime.boot.test.ts

@@ -1,283 +0,0 @@
-import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
-import { OpencodeClient, type Provider } from "@ac/sdk/v2"
-import type { Resolved } from "@ac/tui/config"
-import { TuiConfig } from "@/config/tui"
-import { resolveDiffStyle, resolveModelInfo, resolveRunTuiConfig } from "@/cli/cmd/run/runtime.boot"
-import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
-
-function model(id: string, providerID: string, context: number, variants?: Record<string, Record<string, never>>) {
-  return {
-    id,
-    providerID,
-    api: {
-      id: providerID,
-      url: `https://${providerID}.test`,
-      npm: `@ai-sdk/${providerID}`,
-    },
-    name: id,
-    capabilities: {
-      temperature: true,
-      reasoning: true,
-      attachment: true,
-      toolcall: true,
-      input: {
-        text: true,
-        audio: false,
-        image: false,
-        video: false,
-        pdf: false,
-      },
-      output: {
-        text: true,
-        audio: false,
-        image: false,
-        video: false,
-        pdf: false,
-      },
-      interleaved: false,
-    },
-    cost: {
-      input: 0,
-      output: 0,
-      cache: {
-        read: 0,
-        write: 0,
-      },
-    },
-    limit: {
-      context,
-      output: 8192,
-    },
-    status: "active" as const,
-    options: {},
-    headers: {},
-    release_date: "2026-01-01",
-    variants,
-  }
-}
-
-function config(input?: {
-  leader?: string
-  leaderTimeout?: number
-  diff_style?: "auto" | "stacked"
-  bindings?: Partial<{
-    commandList: string[]
-    variantCycle: string[]
-    interrupt: string[]
-    historyPrevious: string[]
-    historyNext: string[]
-    inputClear: string[]
-    inputSubmit: string[]
-    inputNewline: string[]
-  }>
-}): Resolved {
-  const bind = input?.bindings
-  return createTuiResolvedConfig({
-    diff_style: input?.diff_style,
-    leader_timeout: input?.leaderTimeout,
-    keybinds: {
-      ...(input?.leader && { leader: input.leader }),
-      ...(bind?.commandList && { command_list: bind.commandList }),
-      ...(bind?.variantCycle && { variant_cycle: bind.variantCycle }),
-      ...(bind?.interrupt && { session_interrupt: bind.interrupt }),
-      ...(bind?.historyPrevious && { history_previous: bind.historyPrevious }),
-      ...(bind?.historyNext && { history_next: bind.historyNext }),
-      ...(bind?.inputClear && { input_clear: bind.inputClear }),
-      ...(bind?.inputSubmit && { input_submit: bind.inputSubmit }),
-      ...(bind?.inputNewline && { input_newline: bind.inputNewline }),
-    },
-  })
-}
-
-describe("run runtime boot", () => {
-  afterEach(() => {
-    mock.restore()
-  })
-
-  test("reads footer keybinds from resolved keybind config", async () => {
-    spyOn(TuiConfig, "get").mockResolvedValue(
-      config({
-        leader: "ctrl+g",
-        bindings: {
-          commandList: ["ctrl+p"],
-          variantCycle: ["ctrl+t", "alt+t"],
-          interrupt: ["ctrl+c"],
-          historyPrevious: ["k"],
-          historyNext: ["j"],
-          inputClear: ["ctrl+l"],
-          inputSubmit: ["ctrl+s"],
-          inputNewline: ["alt+return"],
-        },
-      }),
-    )
-
-    const result = await resolveRunTuiConfig()
-
-    expect(result.keybinds.get("leader")?.[0]?.key).toBe("ctrl+g")
-    expect(result.leader_timeout).toBe(2000)
-    expect(result.keybinds.get("command.palette.show")?.[0]?.key).toBe("ctrl+p")
-    expect(result.keybinds.get("variant.cycle").map((item) => item.key)).toEqual(["ctrl+t", "alt+t"])
-    expect(result.keybinds.get("session.interrupt")?.[0]?.key).toBe("ctrl+c")
-    expect(result.keybinds.get("prompt.history.previous")?.[0]?.key).toBe("k")
-    expect(result.keybinds.get("prompt.history.next")?.[0]?.key).toBe("j")
-    expect(result.keybinds.get("prompt.clear")?.[0]?.key).toBe("ctrl+l")
-    expect(result.keybinds.get("input.submit")?.[0]?.key).toBe("ctrl+s")
-    expect(result.keybinds.get("input.newline")?.[0]?.key).toBe("alt+return")
-  })
-
-  test("falls back to default tui keymap config when config load fails", async () => {
-    spyOn(TuiConfig, "get").mockRejectedValue(new Error("boom"))
-
-    const result = await resolveRunTuiConfig()
-
-    expect(result.keybinds.get("leader")?.[0]?.key).toBe("ctrl+x")
-    expect(result.leader_timeout).toBe(2000)
-    expect(result.diff_style).toBe("auto")
-    expect(result.keybinds.get("command.palette.show")?.[0]?.key).toBe("ctrl+p")
-    expect(result.keybinds.get("variant.cycle")?.[0]?.key).toBe("ctrl+t")
-    expect(result.keybinds.get("session.interrupt")?.[0]?.key).toBe("escape")
-    expect(result.keybinds.get("prompt.history.previous")?.[0]?.key).toBe("up")
-    expect(result.keybinds.get("prompt.history.next")?.[0]?.key).toBe("down")
-    expect(result.keybinds.get("prompt.clear")?.[0]?.key).toBe("ctrl+c")
-    expect(result.keybinds.get("input.submit")?.[0]?.key).toBe("return")
-    expect(result.keybinds.get("input.newline")?.[0]?.key).toBe("shift+return,ctrl+return,alt+return,ctrl+j")
-  })
-
-  test("preserves disabled leader from resolved tui config", async () => {
-    spyOn(TuiConfig, "get").mockResolvedValue(config({ leader: "none" }))
-
-    const result = await resolveRunTuiConfig()
-
-    expect(result.keybinds.get("leader")).toEqual([])
-  })
-
-  test("reads diff style and falls back to auto", async () => {
-    spyOn(TuiConfig, "get").mockResolvedValue(config({ diff_style: "stacked" }))
-    await expect(resolveDiffStyle()).resolves.toBe("stacked")
-
-    mock.restore()
-    spyOn(TuiConfig, "get").mockRejectedValue(new Error("boom"))
-    await expect(resolveDiffStyle()).resolves.toBe("auto")
-  })
-
-  test("prefers configured providers for model selector data", async () => {
-    const sdk = new OpencodeClient()
-    const data: {
-      all: Provider[]
-      default: Record<string, string>
-      connected: string[]
-    } = {
-      all: [
-        {
-          id: "openai",
-          name: "OpenAI",
-          source: "api",
-          env: [],
-          options: {},
-          models: {
-            "gpt-5": model("gpt-5", "openai", 128000, {
-              high: {},
-              minimal: {},
-            }),
-          },
-        },
-        {
-          id: "anthropic",
-          name: "Anthropic",
-          source: "api",
-          env: [],
-          options: {},
-          models: {
-            sonnet: model("sonnet", "anthropic", 200000),
-          },
-        },
-      ],
-      default: {},
-      connected: [],
-    }
-    const configured = {
-      providers: [data.all[0]!],
-      default: {},
-    }
-    const list = spyOn(sdk.provider, "list").mockImplementation(() =>
-      Promise.resolve({
-        data,
-        error: undefined,
-        request: new Request("https://opencode.test"),
-        response: new Response(),
-      }),
-    )
-    spyOn(sdk.config, "providers").mockImplementation(() =>
-      Promise.resolve({
-        data: configured,
-        error: undefined,
-        request: new Request("https://opencode.test"),
-        response: new Response(),
-      }),
-    )
-
-    await expect(resolveModelInfo(sdk, "/workspace", { providerID: "openai", modelID: "gpt-5" })).resolves.toEqual({
-      providers: configured.providers,
-      variants: ["high", "minimal"],
-      limits: {
-        "openai/gpt-5": 128000,
-      },
-    })
-    expect(list).not.toHaveBeenCalled()
-  })
-
-  test("falls back to provider list when configured providers are unavailable", async () => {
-    const sdk = new OpencodeClient()
-    const data: {
-      all: Provider[]
-      default: Record<string, string>
-      connected: string[]
-    } = {
-      all: [
-        {
-          id: "openai",
-          name: "OpenAI",
-          source: "api",
-          env: [],
-          options: {},
-          models: {
-            "gpt-5": model("gpt-5", "openai", 128000, {
-              high: {},
-              minimal: {},
-            }),
-          },
-        },
-        {
-          id: "anthropic",
-          name: "Anthropic",
-          source: "api",
-          env: [],
-          options: {},
-          models: {
-            sonnet: model("sonnet", "anthropic", 200000),
-          },
-        },
-      ],
-      default: {},
-      connected: [],
-    }
-    spyOn(sdk.config, "providers").mockRejectedValue(new Error("boom"))
-    spyOn(sdk.provider, "list").mockImplementation(() =>
-      Promise.resolve({
-        data,
-        error: undefined,
-        request: new Request("https://opencode.test"),
-        response: new Response(),
-      }),
-    )
-
-    await expect(resolveModelInfo(sdk, "/workspace", { providerID: "openai", modelID: "gpt-5" })).resolves.toEqual({
-      providers: data.all,
-      variants: ["high", "minimal"],
-      limits: {
-        "openai/gpt-5": 128000,
-        "anthropic/sonnet": 200000,
-      },
-    })
-  })
-})