@toolkit-cli/toolkode 1.3.8 → 1.3.10

package/test/cli/tui/plugin-toggle.test.ts

@@ -1,157 +0,0 @@
-import { expect, spyOn, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { pathToFileURL } from "url"
-import { tmpdir } from "../../fixture/fixture"
-import { createTuiPluginApi } from "../../fixture/tui-plugin"
-import { TuiConfig } from "../../../src/config/tui"
-
-const { TuiPluginRuntime } = await import("../../../src/cli/cmd/tui/plugin/runtime")
-
-test("toggles plugin runtime state by exported id", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      const file = path.join(dir, "toggle-plugin.ts")
-      const spec = pathToFileURL(file).href
-      const marker = path.join(dir, "toggle.txt")
-
-      await Bun.write(
-        file,
-        `export default {
-  id: "demo.toggle",
-  tui: async (api, options) => {
-    const text = await Bun.file(options.marker).text().catch(() => "")
-    await Bun.write(options.marker, text + "start\\n")
-    api.lifecycle.onDispose(async () => {
-      const next = await Bun.file(options.marker).text().catch(() => "")
-      await Bun.write(options.marker, next + "stop\\n")
-    })
-  },
-}
-`,
-      )
-
-      return {
-        spec,
-        marker,
-      }
-    },
-  })
-
-  process.env.OPENCODE_PLUGIN_META_FILE = path.join(tmp.path, "plugin-meta.json")
-  const get = spyOn(TuiConfig, "get").mockResolvedValue({
-    plugin: [[tmp.extra.spec, { marker: tmp.extra.marker }]],
-    plugin_enabled: {
-      "demo.toggle": false,
-    },
-    plugin_meta: {
-      [tmp.extra.spec]: {
-        scope: "local",
-        source: path.join(tmp.path, "tui.json"),
-      },
-    },
-  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
-  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
-  const api = createTuiPluginApi()
-
-  try {
-    await TuiPluginRuntime.init(api)
-
-    await expect(fs.readFile(tmp.extra.marker, "utf8")).rejects.toThrow()
-    expect(TuiPluginRuntime.list().find((item) => item.id === "demo.toggle")).toEqual({
-      id: "demo.toggle",
-      source: "file",
-      spec: tmp.extra.spec,
-      target: tmp.extra.spec,
-      enabled: false,
-      active: false,
-    })
-
-    await expect(TuiPluginRuntime.activatePlugin("demo.toggle")).resolves.toBe(true)
-    await expect(fs.readFile(tmp.extra.marker, "utf8")).resolves.toBe("start\n")
-    expect(api.kv.get("plugin_enabled", {})).toEqual({
-      "demo.toggle": true,
-    })
-
-    await expect(TuiPluginRuntime.deactivatePlugin("demo.toggle")).resolves.toBe(true)
-    await expect(fs.readFile(tmp.extra.marker, "utf8")).resolves.toBe("start\nstop\n")
-    expect(api.kv.get("plugin_enabled", {})).toEqual({
-      "demo.toggle": false,
-    })
-
-    await expect(TuiPluginRuntime.activatePlugin("missing.id")).resolves.toBe(false)
-  } finally {
-    await TuiPluginRuntime.dispose()
-    cwd.mockRestore()
-    get.mockRestore()
-    wait.mockRestore()
-    delete process.env.OPENCODE_PLUGIN_META_FILE
-  }
-})
-
-test("kv plugin_enabled overrides tui config on startup", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      const file = path.join(dir, "startup-plugin.ts")
-      const spec = pathToFileURL(file).href
-      const marker = path.join(dir, "startup.txt")
-
-      await Bun.write(
-        file,
-        `export default {
-  id: "demo.startup",
-  tui: async (_api, options) => {
-    await Bun.write(options.marker, "on")
-  },
-}
-`,
-      )
-
-      return {
-        spec,
-        marker,
-      }
-    },
-  })
-
-  process.env.OPENCODE_PLUGIN_META_FILE = path.join(tmp.path, "plugin-meta.json")
-  const get = spyOn(TuiConfig, "get").mockResolvedValue({
-    plugin: [[tmp.extra.spec, { marker: tmp.extra.marker }]],
-    plugin_enabled: {
-      "demo.startup": false,
-    },
-    plugin_meta: {
-      [tmp.extra.spec]: {
-        scope: "local",
-        source: path.join(tmp.path, "tui.json"),
-      },
-    },
-  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
-  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
-  const api = createTuiPluginApi()
-  api.kv.set("plugin_enabled", {
-    "demo.startup": true,
-  })
-
-  try {
-    await TuiPluginRuntime.init(api)
-
-    await expect(fs.readFile(tmp.extra.marker, "utf8")).resolves.toBe("on")
-    expect(TuiPluginRuntime.list().find((item) => item.id === "demo.startup")).toEqual({
-      id: "demo.startup",
-      source: "file",
-      spec: tmp.extra.spec,
-      target: tmp.extra.spec,
-      enabled: true,
-      active: true,
-    })
-  } finally {
-    await TuiPluginRuntime.dispose()
-    cwd.mockRestore()
-    get.mockRestore()
-    wait.mockRestore()
-    delete process.env.OPENCODE_PLUGIN_META_FILE
-  }
-})

package/test/cli/tui/theme-store.test.ts

@@ -1,51 +0,0 @@
-import { expect, test } from "bun:test"
-
-const { DEFAULT_THEMES, allThemes, addTheme, hasTheme, resolveTheme } = await import(
-  "../../../src/cli/cmd/tui/context/theme"
-)
-
-test("addTheme writes into module theme store", () => {
-  const name = `plugin-theme-${Date.now()}`
-  expect(addTheme(name, DEFAULT_THEMES.opencode)).toBe(true)
-
-  expect(allThemes()[name]).toBeDefined()
-})
-
-test("addTheme keeps first theme for duplicate names", () => {
-  const name = `plugin-theme-keep-${Date.now()}`
-  const one = structuredClone(DEFAULT_THEMES.opencode)
-  const two = structuredClone(DEFAULT_THEMES.opencode)
-  one.theme.primary = "#101010"
-  two.theme.primary = "#fefefe"
-
-  expect(addTheme(name, one)).toBe(true)
-  expect(addTheme(name, two)).toBe(false)
-
-  expect(allThemes()[name]).toBeDefined()
-  expect(allThemes()[name]!.theme.primary).toBe("#101010")
-})
-
-test("addTheme ignores entries without a theme object", () => {
-  const name = `plugin-theme-invalid-${Date.now()}`
-  expect(addTheme(name, { defs: { a: "#ffffff" } })).toBe(false)
-  expect(allThemes()[name]).toBeUndefined()
-})
-
-test("hasTheme checks theme presence", () => {
-  const name = `plugin-theme-has-${Date.now()}`
-  expect(hasTheme(name)).toBe(false)
-  expect(addTheme(name, DEFAULT_THEMES.opencode)).toBe(true)
-  expect(hasTheme(name)).toBe(true)
-})
-
-test("resolveTheme rejects circular color refs", () => {
-  const item = structuredClone(DEFAULT_THEMES.opencode)
-  item.defs = {
-    ...(item.defs ?? {}),
-    one: "two",
-    two: "one",
-  }
-  item.theme.primary = "one"
-
-  expect(() => resolveTheme(item, "dark")).toThrow("Circular color reference")
-})

package/test/cli/tui/thread.test.ts

@@ -1,128 +0,0 @@
-import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { tmpdir } from "../../fixture/fixture"
-import * as App from "../../../src/cli/cmd/tui/app"
-import { Rpc } from "../../../src/util/rpc"
-import { UI } from "../../../src/cli/ui"
-import * as Timeout from "../../../src/util/timeout"
-import * as Network from "../../../src/cli/network"
-import * as Win32 from "../../../src/cli/cmd/tui/win32"
-import { TuiConfig } from "../../../src/config/tui"
-import { Instance } from "../../../src/project/instance"
-
-const stop = new Error("stop")
-const seen = {
-  tui: [] as string[],
-  inst: [] as string[],
-}
-
-function setup() {
-  // Intentionally avoid mock.module() here: Bun keeps module overrides in cache
-  // and mock.restore() does not reset mock.module values. If this switches back
-  // to module mocks, later suites can see mocked @/config/tui and fail (e.g.
-  // plugin-loader tests expecting real TuiConfig.waitForDependencies). See:
-  // https://github.com/oven-sh/bun/issues/7823 and #12823.
-  spyOn(App, "tui").mockImplementation(async (input) => {
-    if (input.directory) seen.tui.push(input.directory)
-    throw stop
-  })
-  spyOn(Rpc, "client").mockImplementation(() => ({
-    call: async () => ({ url: "http://127.0.0.1" }) as never,
-    on: () => () => {},
-  }))
-  spyOn(UI, "error").mockImplementation(() => {})
-  spyOn(Timeout, "withTimeout").mockImplementation((input) => input)
-  spyOn(Network, "resolveNetworkOptions").mockResolvedValue({
-    mdns: false,
-    port: 0,
-    hostname: "127.0.0.1",
-    mdnsDomain: "opencode.local",
-    cors: [],
-  })
-  spyOn(Win32, "win32DisableProcessedInput").mockImplementation(() => {})
-  spyOn(Win32, "win32InstallCtrlCGuard").mockReturnValue(undefined)
-  spyOn(TuiConfig, "get").mockResolvedValue({})
-  spyOn(Instance, "provide").mockImplementation(async (input) => {
-    seen.inst.push(input.directory)
-    return input.fn()
-  })
-}
-
-describe("tui thread", () => {
-  afterEach(() => {
-    mock.restore()
-  })
-
-  async function call(project?: string) {
-    const { TuiThreadCommand } = await import("../../../src/cli/cmd/tui/thread")
-    const args: Parameters<NonNullable<typeof TuiThreadCommand.handler>>[0] = {
-      _: [],
-      $0: "opencode",
-      project,
-      prompt: "hi",
-      model: undefined,
-      agent: undefined,
-      session: undefined,
-      continue: false,
-      fork: false,
-      port: 0,
-      hostname: "127.0.0.1",
-      mdns: false,
-      "mdns-domain": "opencode.local",
-      mdnsDomain: "opencode.local",
-      cors: [],
-    }
-    return TuiThreadCommand.handler(args)
-  }
-
-  async function check(project?: string) {
-    setup()
-    await using tmp = await tmpdir({ git: true })
-    const cwd = process.cwd()
-    const pwd = process.env.PWD
-    const worker = globalThis.Worker
-    const tty = Object.getOwnPropertyDescriptor(process.stdin, "isTTY")
-    const link = path.join(path.dirname(tmp.path), path.basename(tmp.path) + "-link")
-    const type = process.platform === "win32" ? "junction" : "dir"
-    seen.tui.length = 0
-    seen.inst.length = 0
-    await fs.symlink(tmp.path, link, type)
-
-    Object.defineProperty(process.stdin, "isTTY", {
-      configurable: true,
-      value: true,
-    })
-    globalThis.Worker = class extends EventTarget {
-      onerror = null
-      onmessage = null
-      onmessageerror = null
-      postMessage() {}
-      terminate() {}
-    } as unknown as typeof Worker
-
-    try {
-      process.chdir(tmp.path)
-      process.env.PWD = link
-      await expect(call(project)).rejects.toBe(stop)
-      expect(seen.inst[0]).toBe(tmp.path)
-      expect(seen.tui[0]).toBe(tmp.path)
-    } finally {
-      process.chdir(cwd)
-      if (pwd === undefined) delete process.env.PWD
-      else process.env.PWD = pwd
-      if (tty) Object.defineProperty(process.stdin, "isTTY", tty)
-      else delete (process.stdin as { isTTY?: boolean }).isTTY
-      globalThis.Worker = worker
-      await fs.rm(link, { recursive: true, force: true }).catch(() => undefined)
-    }
-  }
-
-  test("uses the real cwd when PWD points at a symlink", async () => {
-    await check()
-  })
-
-  test("uses the real cwd after resolving a relative project from PWD", async () => {
-    await check(".")
-  })
-})

package/test/cli/tui/transcript.test.ts

@@ -1,322 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-  formatAssistantHeader,
-  formatMessage,
-  formatPart,
-  formatTranscript,
-} from "../../../src/cli/cmd/tui/util/transcript"
-import type { AssistantMessage, Part, UserMessage } from "@toolkit-cli/sdk/v2"
-
-describe("transcript", () => {
-  describe("formatAssistantHeader", () => {
-    const baseMsg: AssistantMessage = {
-      id: "msg_123",
-      sessionID: "ses_123",
-      role: "assistant",
-      agent: "build",
-      modelID: "claude-sonnet-4-20250514",
-      providerID: "anthropic",
-      mode: "",
-      parentID: "msg_parent",
-      path: { cwd: "/test", root: "/test" },
-      cost: 0.001,
-      tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
-      time: { created: 1000000, completed: 1005400 },
-    }
-
-    test("includes metadata when enabled", () => {
-      const result = formatAssistantHeader(baseMsg, true)
-      expect(result).toBe("## Assistant (Build · claude-sonnet-4-20250514 · 5.4s)\n\n")
-    })
-
-    test("excludes metadata when disabled", () => {
-      const result = formatAssistantHeader(baseMsg, false)
-      expect(result).toBe("## Assistant\n\n")
-    })
-
-    test("handles missing completed time", () => {
-      const msg = { ...baseMsg, time: { created: 1000000 } }
-      const result = formatAssistantHeader(msg as AssistantMessage, true)
-      expect(result).toBe("## Assistant (Build · claude-sonnet-4-20250514)\n\n")
-    })
-
-    test("titlecases agent name", () => {
-      const msg = { ...baseMsg, agent: "plan" }
-      const result = formatAssistantHeader(msg, true)
-      expect(result).toContain("Plan")
-    })
-  })
-
-  describe("formatPart", () => {
-    const options = { thinking: true, toolDetails: true, assistantMetadata: true }
-
-    test("formats text part", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "text",
-        text: "Hello world",
-      }
-      const result = formatPart(part, options)
-      expect(result).toBe("Hello world\n\n")
-    })
-
-    test("skips synthetic text parts", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "text",
-        text: "Synthetic content",
-        synthetic: true,
-      }
-      const result = formatPart(part, options)
-      expect(result).toBe("")
-    })
-
-    test("formats reasoning when thinking enabled", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "reasoning",
-        text: "Let me think...",
-        time: { start: 1000 },
-      }
-      const result = formatPart(part, options)
-      expect(result).toBe("_Thinking:_\n\nLet me think...\n\n")
-    })
-
-    test("skips reasoning when thinking disabled", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "reasoning",
-        text: "Let me think...",
-        time: { start: 1000 },
-      }
-      const result = formatPart(part, { ...options, thinking: false })
-      expect(result).toBe("")
-    })
-
-    test("formats tool part with details", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "tool",
-        callID: "call_1",
-        tool: "bash",
-        state: {
-          status: "completed",
-          input: { command: "ls" },
-          output: "file1.txt\nfile2.txt",
-          title: "List files",
-          metadata: {},
-          time: { start: 1000, end: 1100 },
-        },
-      }
-      const result = formatPart(part, options)
-      expect(result).toContain("**Tool: bash**")
-      expect(result).toContain("**Input:**")
-      expect(result).toContain('"command": "ls"')
-      expect(result).toContain("**Output:**")
-      expect(result).toContain("file1.txt")
-    })
-
-    test("formats tool output containing triple backticks without breaking markdown", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "tool",
-        callID: "call_1",
-        tool: "bash",
-        state: {
-          status: "completed",
-          input: { command: "echo '```hello```'" },
-          output: "```hello```",
-          title: "Echo backticks",
-          metadata: {},
-          time: { start: 1000, end: 1100 },
-        },
-      }
-      const result = formatPart(part, options)
-      // The tool header should not be inside a code block
-      expect(result).toStartWith("**Tool: bash**\n")
-      // Input and output should each be in their own code blocks
-      expect(result).toContain("**Input:**\n```json")
-      expect(result).toContain("**Output:**\n```\n```hello```\n```")
-    })
-
-    test("formats tool part without details when disabled", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "tool",
-        callID: "call_1",
-        tool: "bash",
-        state: {
-          status: "completed",
-          input: { command: "ls" },
-          output: "file1.txt",
-          title: "List files",
-          metadata: {},
-          time: { start: 1000, end: 1100 },
-        },
-      }
-      const result = formatPart(part, { ...options, toolDetails: false })
-      expect(result).toContain("**Tool: bash**")
-      expect(result).not.toContain("**Input:**")
-      expect(result).not.toContain("**Output:**")
-    })
-
-    test("formats tool error", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "tool",
-        callID: "call_1",
-        tool: "bash",
-        state: {
-          status: "error",
-          input: { command: "invalid" },
-          error: "Command failed",
-          time: { start: 1000, end: 1100 },
-        },
-      }
-      const result = formatPart(part, options)
-      expect(result).toContain("**Error:**")
-      expect(result).toContain("Command failed")
-    })
-  })
-
-  describe("formatMessage", () => {
-    const options = { thinking: true, toolDetails: true, assistantMetadata: true }
-
-    test("formats user message", () => {
-      const msg: UserMessage = {
-        id: "msg_123",
-        sessionID: "ses_123",
-        role: "user",
-        agent: "build",
-        model: { providerID: "anthropic", modelID: "claude-sonnet-4-20250514" },
-        time: { created: 1000000 },
-      }
-      const parts: Part[] = [{ id: "p1", sessionID: "ses_123", messageID: "msg_123", type: "text", text: "Hello" }]
-      const result = formatMessage(msg, parts, options)
-      expect(result).toContain("## User")
-      expect(result).toContain("Hello")
-    })
-
-    test("formats assistant message with metadata", () => {
-      const msg: AssistantMessage = {
-        id: "msg_123",
-        sessionID: "ses_123",
-        role: "assistant",
-        agent: "build",
-        modelID: "claude-sonnet-4-20250514",
-        providerID: "anthropic",
-        mode: "",
-        parentID: "msg_parent",
-        path: { cwd: "/test", root: "/test" },
-        cost: 0.001,
-        tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
-        time: { created: 1000000, completed: 1005400 },
-      }
-      const parts: Part[] = [{ id: "p1", sessionID: "ses_123", messageID: "msg_123", type: "text", text: "Hi there" }]
-      const result = formatMessage(msg, parts, options)
-      expect(result).toContain("## Assistant (Build · claude-sonnet-4-20250514 · 5.4s)")
-      expect(result).toContain("Hi there")
-    })
-  })
-
-  describe("formatTranscript", () => {
-    test("formats complete transcript", () => {
-      const session = {
-        id: "ses_abc123",
-        title: "Test Session",
-        time: { created: 1000000000000, updated: 1000000001000 },
-      }
-      const messages = [
-        {
-          info: {
-            id: "msg_1",
-            sessionID: "ses_abc123",
-            role: "user" as const,
-            agent: "build",
-            model: { providerID: "anthropic", modelID: "claude-sonnet-4-20250514" },
-            time: { created: 1000000000000 },
-          },
-          parts: [{ id: "p1", sessionID: "ses_abc123", messageID: "msg_1", type: "text" as const, text: "Hello" }],
-        },
-        {
-          info: {
-            id: "msg_2",
-            sessionID: "ses_abc123",
-            role: "assistant" as const,
-            agent: "build",
-            modelID: "claude-sonnet-4-20250514",
-            providerID: "anthropic",
-            mode: "",
-            parentID: "msg_1",
-            path: { cwd: "/test", root: "/test" },
-            cost: 0.001,
-            tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
-            time: { created: 1000000000100, completed: 1000000000600 },
-          },
-          parts: [{ id: "p2", sessionID: "ses_abc123", messageID: "msg_2", type: "text" as const, text: "Hi!" }],
-        },
-      ]
-      const options = { thinking: false, toolDetails: false, assistantMetadata: true }
-
-      const result = formatTranscript(session, messages, options)
-
-      expect(result).toContain("# Test Session")
-      expect(result).toContain("**Session ID:** ses_abc123")
-      expect(result).toContain("## User")
-      expect(result).toContain("Hello")
-      expect(result).toContain("## Assistant (Build · claude-sonnet-4-20250514 · 0.5s)")
-      expect(result).toContain("Hi!")
-      expect(result).toContain("---")
-    })
-
-    test("formats transcript without assistant metadata", () => {
-      const session = {
-        id: "ses_abc123",
-        title: "Test Session",
-        time: { created: 1000000000000, updated: 1000000001000 },
-      }
-      const messages = [
-        {
-          info: {
-            id: "msg_1",
-            sessionID: "ses_abc123",
-            role: "assistant" as const,
-            agent: "build",
-            modelID: "claude-sonnet-4-20250514",
-            providerID: "anthropic",
-            mode: "",
-            parentID: "msg_0",
-            path: { cwd: "/test", root: "/test" },
-            cost: 0.001,
-            tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
-            time: { created: 1000000000100, completed: 1000000000600 },
-          },
-          parts: [{ id: "p1", sessionID: "ses_abc123", messageID: "msg_1", type: "text" as const, text: "Response" }],
-        },
-      ]
-      const options = { thinking: false, toolDetails: false, assistantMetadata: false }
-
-      const result = formatTranscript(session, messages, options)
-
-      expect(result).toContain("## Assistant\n\n")
-      expect(result).not.toContain("Build")
-      expect(result).not.toContain("claude-sonnet-4-20250514")
-    })
-  })
-})