mini: move frontend into tui package (#37754)
This commit is contained in:
Simon Klee
GitHub
parent
3f5ad8441f
commit
c50554d907
80 changed files with 2365 additions and 1488 deletions
131
packages/tui/test/mini/catalog.shared.test.ts
Normal file
131
packages/tui/test/mini/catalog.shared.test.ts
Normal file
|
|
@ -0,0 +1,131 @@
|
|||
import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
|
||||
import { OpenCode } from "@opencode-ai/client/promise"
|
||||
import { loadRunReferences, runProviders, waitForDefaultModel } from "../../src/mini/catalog.shared"
|
||||
|
||||
afterEach(() => {
|
||||
mock.restore()
|
||||
})
|
||||
|
||||
describe("run catalog shared", () => {
|
||||
test("resolves the catalog-selected model for the footer", async () => {
|
||||
const client = OpenCode.make({ baseUrl: "https://opencode.test" })
|
||||
const selected = spyOn(client.model, "default").mockImplementation(
|
||||
() =>
|
||||
Promise.resolve({
|
||||
location: { directory: "/tmp", project: { id: "proj_1", directory: "/tmp" } },
|
||||
data: { id: "gpt-5", providerID: "openai" },
|
||||
}) as never,
|
||||
)
|
||||
|
||||
await expect(waitForDefaultModel({ sdk: client, directory: "/tmp" })).resolves.toEqual({
|
||||
providerID: "openai",
|
||||
modelID: "gpt-5",
|
||||
})
|
||||
expect(selected).toHaveBeenCalledWith({ location: { directory: "/tmp" } })
|
||||
})
|
||||
|
||||
test("loads visible project references from the current reference catalog", async () => {
|
||||
const client = OpenCode.make({ baseUrl: "https://opencode.test" })
|
||||
const list = spyOn(client.reference, "list").mockImplementation(
|
||||
() =>
|
||||
Promise.resolve({
|
||||
location: { directory: "/tmp", project: { id: "proj_1", directory: "/tmp" } },
|
||||
data: [
|
||||
{
|
||||
name: "effect",
|
||||
path: "/repos/effect",
|
||||
description: "Effect v4 sources",
|
||||
source: { type: "local", path: "/repos/effect" },
|
||||
},
|
||||
{
|
||||
name: "secret",
|
||||
path: "/repos/secret",
|
||||
hidden: true,
|
||||
source: { type: "local", path: "/repos/secret" },
|
||||
},
|
||||
],
|
||||
}) as never,
|
||||
)
|
||||
|
||||
const references = await loadRunReferences(client, "/tmp")
|
||||
|
||||
expect(list).toHaveBeenCalledWith({ location: { directory: "/tmp" } })
|
||||
expect(references).toMatchObject([{ name: "effect", path: "/repos/effect", description: "Effect v4 sources" }])
|
||||
})
|
||||
|
||||
test("merges current providers and models into the footer catalog shape", () => {
|
||||
const providers = runProviders(
|
||||
[
|
||||
{
|
||||
id: "openai",
|
||||
name: "OpenAI",
|
||||
package: "",
|
||||
},
|
||||
],
|
||||
[
|
||||
{
|
||||
id: "gpt-5",
|
||||
modelID: "openai",
|
||||
providerID: "openai",
|
||||
name: "Little Frank",
|
||||
capabilities: {
|
||||
tools: true,
|
||||
input: ["text"],
|
||||
output: ["text"],
|
||||
},
|
||||
variants: [{ id: "high" }],
|
||||
time: {
|
||||
released: 1,
|
||||
},
|
||||
cost: [
|
||||
{
|
||||
input: 0,
|
||||
output: 0,
|
||||
cache: {
|
||||
read: 0,
|
||||
write: 0,
|
||||
},
|
||||
},
|
||||
],
|
||||
status: "active",
|
||||
enabled: true,
|
||||
limit: {
|
||||
context: 128000,
|
||||
output: 8192,
|
||||
},
|
||||
},
|
||||
],
|
||||
)
|
||||
|
||||
expect(providers).toEqual([
|
||||
{
|
||||
id: "openai",
|
||||
name: "OpenAI",
|
||||
models: {
|
||||
"gpt-5": {
|
||||
id: "gpt-5",
|
||||
providerID: "openai",
|
||||
name: "Little Frank",
|
||||
capabilities: expect.objectContaining({ tools: true }),
|
||||
cost: {
|
||||
input: 0,
|
||||
output: 0,
|
||||
cache: {
|
||||
read: 0,
|
||||
write: 0,
|
||||
},
|
||||
},
|
||||
limit: {
|
||||
context: 128000,
|
||||
output: 8192,
|
||||
},
|
||||
status: "active",
|
||||
variants: {
|
||||
high: {},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
])
|
||||
})
|
||||
})
|
||||
563
packages/tui/test/mini/entry.body.test.ts
Normal file
563
packages/tui/test/mini/entry.body.test.ts
Normal file
|
|
@ -0,0 +1,563 @@
|
|||
import { describe, expect, test } from "bun:test"
|
||||
import { entryBody, entryCanStream, entryDone } from "../../src/mini/entry.body"
|
||||
import type { MiniToolPart, StreamCommit, ToolSnapshot } from "../../src/mini/types"
|
||||
|
||||
function commit(input: Partial<StreamCommit> & Pick<StreamCommit, "kind" | "text" | "phase" | "source">): StreamCommit {
|
||||
return input
|
||||
}
|
||||
|
||||
function toolPart(
|
||||
tool: string,
|
||||
state: MiniToolPart["state"],
|
||||
id = `${tool}-1`,
|
||||
messageID = `msg-${tool}`,
|
||||
): MiniToolPart {
|
||||
return {
|
||||
id,
|
||||
sessionID: "session-1",
|
||||
messageID,
|
||||
type: "tool",
|
||||
callID: `call-${id}`,
|
||||
tool,
|
||||
state,
|
||||
} as MiniToolPart
|
||||
}
|
||||
|
||||
function toolCommit(input: {
|
||||
tool: string
|
||||
state: MiniToolPart["state"]
|
||||
phase?: StreamCommit["phase"]
|
||||
toolState?: StreamCommit["toolState"]
|
||||
text?: string
|
||||
id?: string
|
||||
messageID?: string
|
||||
}) {
|
||||
return commit({
|
||||
kind: "tool",
|
||||
text: input.text ?? "",
|
||||
phase: input.phase ?? "final",
|
||||
source: "tool",
|
||||
tool: input.tool,
|
||||
toolState: input.toolState ?? "completed",
|
||||
part: toolPart(input.tool, input.state, input.id, input.messageID),
|
||||
})
|
||||
}
|
||||
|
||||
function structured(next: StreamCommit) {
|
||||
const body = entryBody(next)
|
||||
expect(body.type).toBe("structured")
|
||||
if (body.type !== "structured") {
|
||||
throw new Error("expected structured body")
|
||||
}
|
||||
|
||||
return body.snapshot
|
||||
}
|
||||
|
||||
describe("run entry body", () => {
|
||||
test("renders a failed direct shell as an error instead of completed success", () => {
|
||||
expect(
|
||||
entryBody(
|
||||
commit({
|
||||
kind: "tool",
|
||||
text: "Shell exited with code 7",
|
||||
phase: "final",
|
||||
source: "tool",
|
||||
tool: "bash",
|
||||
toolState: "error",
|
||||
toolError: "Shell exited with code 7",
|
||||
shell: { callID: "sh_failed", command: "false" },
|
||||
}),
|
||||
),
|
||||
).toEqual({ type: "text", content: "✖ bash failed: Shell exited with code 7" })
|
||||
})
|
||||
|
||||
test("renders assistant, reasoning, and user entries in their display formats", () => {
|
||||
expect(
|
||||
entryBody(
|
||||
commit({
|
||||
kind: "assistant",
|
||||
text: "# Title\n\nHello **world**",
|
||||
phase: "progress",
|
||||
source: "assistant",
|
||||
partID: "part-1",
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
type: "markdown",
|
||||
content: "# Title\n\nHello **world**",
|
||||
})
|
||||
|
||||
const reasoning = entryBody(
|
||||
commit({
|
||||
kind: "reasoning",
|
||||
text: "Thinking: plan next steps",
|
||||
phase: "progress",
|
||||
source: "reasoning",
|
||||
partID: "reason-1",
|
||||
}),
|
||||
)
|
||||
expect(reasoning).toEqual({
|
||||
type: "code",
|
||||
filetype: "markdown",
|
||||
content: "_Thinking:_ plan next steps",
|
||||
})
|
||||
expect(
|
||||
entryCanStream(
|
||||
commit({
|
||||
kind: "reasoning",
|
||||
text: "Thinking: plan next steps",
|
||||
phase: "progress",
|
||||
source: "reasoning",
|
||||
}),
|
||||
reasoning,
|
||||
),
|
||||
).toBe(true)
|
||||
|
||||
expect(
|
||||
entryBody(
|
||||
commit({
|
||||
kind: "user",
|
||||
text: "Inspect footer tabs",
|
||||
phase: "start",
|
||||
source: "system",
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
type: "text",
|
||||
content: "› Inspect footer tabs",
|
||||
})
|
||||
})
|
||||
|
||||
for (const item of [
|
||||
{
|
||||
name: "keeps completed write tool finals structured",
|
||||
commit: toolCommit({
|
||||
tool: "write",
|
||||
state: {
|
||||
status: "completed",
|
||||
input: {
|
||||
filePath: "src/a.ts",
|
||||
content: "const x = 1\n",
|
||||
},
|
||||
output: "",
|
||||
title: "",
|
||||
metadata: {},
|
||||
time: { start: 1, end: 2 },
|
||||
},
|
||||
}),
|
||||
snapshot: {
|
||||
kind: "code",
|
||||
title: "# Wrote src/a.ts",
|
||||
content: "const x = 1\n",
|
||||
file: "src/a.ts",
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "keeps completed edit tool finals structured",
|
||||
commit: toolCommit({
|
||||
tool: "edit",
|
||||
state: {
|
||||
status: "completed",
|
||||
input: {
|
||||
filePath: "src/a.ts",
|
||||
},
|
||||
output: "",
|
||||
title: "",
|
||||
metadata: {
|
||||
diff: "@@ -1 +1 @@\n-old\n+new\n",
|
||||
},
|
||||
time: { start: 1, end: 2 },
|
||||
},
|
||||
}),
|
||||
snapshot: {
|
||||
kind: "diff",
|
||||
items: [
|
||||
{
|
||||
title: "# Edited src/a.ts",
|
||||
diff: "@@ -1 +1 @@\n-old\n+new\n",
|
||||
file: "src/a.ts",
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "keeps completed apply_patch tool finals structured",
|
||||
commit: toolCommit({
|
||||
tool: "apply_patch",
|
||||
state: {
|
||||
status: "completed",
|
||||
input: {},
|
||||
output: "",
|
||||
title: "",
|
||||
metadata: {
|
||||
files: [
|
||||
{
|
||||
type: "update",
|
||||
filePath: "src/a.ts",
|
||||
relativePath: "src/a.ts",
|
||||
patch: "@@ -1 +1 @@\n-old\n+new\n",
|
||||
},
|
||||
],
|
||||
},
|
||||
time: { start: 1, end: 2 },
|
||||
},
|
||||
}),
|
||||
snapshot: {
|
||||
kind: "diff",
|
||||
items: [
|
||||
{
|
||||
title: "# Patched src/a.ts",
|
||||
diff: "@@ -1 +1 @@\n-old\n+new\n",
|
||||
file: "src/a.ts",
|
||||
deletions: 0,
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
] satisfies Array<{ name: string; commit: StreamCommit; snapshot: ToolSnapshot }>) {
|
||||
if (item.name === "keeps completed apply_patch tool finals structured") {
|
||||
test.skip(item.name, () => {
|
||||
expect(structured(item.commit)).toEqual(item.snapshot)
|
||||
})
|
||||
continue
|
||||
}
|
||||
test(item.name, () => {
|
||||
expect(structured(item.commit)).toEqual(item.snapshot)
|
||||
})
|
||||
}
|
||||
|
||||
test("keeps running task tool state out of scrollback", () => {
|
||||
expect(
|
||||
entryBody(
|
||||
toolCommit({
|
||||
tool: "task",
|
||||
phase: "start",
|
||||
toolState: "running",
|
||||
text: "running inspect reducer",
|
||||
state: {
|
||||
status: "running",
|
||||
input: {
|
||||
description: "Inspect reducer",
|
||||
subagent_type: "explore",
|
||||
},
|
||||
time: { start: 1 },
|
||||
},
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
type: "none",
|
||||
})
|
||||
})
|
||||
|
||||
test("promotes task results to markdown and falls back to structured task summaries", () => {
|
||||
expect(
|
||||
entryBody(
|
||||
toolCommit({
|
||||
tool: "task",
|
||||
state: {
|
||||
status: "completed",
|
||||
input: {
|
||||
description: "Inspect reducer",
|
||||
subagent_type: "explore",
|
||||
},
|
||||
title: "",
|
||||
output: [
|
||||
'<task id="child-1" state="completed">',
|
||||
"<task_result>",
|
||||
"# Findings\n\n- Footer stays live",
|
||||
"</task_result>",
|
||||
"</task>",
|
||||
].join("\n"),
|
||||
metadata: {
|
||||
sessionId: "child-1",
|
||||
},
|
||||
time: { start: 1, end: 2 },
|
||||
},
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
type: "markdown",
|
||||
content: "# Findings\n\n- Footer stays live",
|
||||
})
|
||||
|
||||
expect(
|
||||
structured(
|
||||
toolCommit({
|
||||
tool: "task",
|
||||
state: {
|
||||
status: "completed",
|
||||
input: {
|
||||
description: "Inspect reducer",
|
||||
subagent_type: "explore",
|
||||
},
|
||||
title: "",
|
||||
output: ['<task id="child-1" state="completed">', "<task_result>", "", "</task_result>", "</task>"].join(
|
||||
"\n",
|
||||
),
|
||||
metadata: {
|
||||
sessionId: "child-1",
|
||||
},
|
||||
time: { start: 1, end: 2 },
|
||||
},
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
kind: "task",
|
||||
title: "# Explore Task",
|
||||
rows: ["Inspect reducer"],
|
||||
tail: "",
|
||||
})
|
||||
})
|
||||
|
||||
test("streams tool progress text and treats completed progress as done", () => {
|
||||
const body = entryBody(
|
||||
commit({
|
||||
kind: "tool",
|
||||
text: "partial output",
|
||||
phase: "progress",
|
||||
source: "tool",
|
||||
tool: "bash",
|
||||
partID: "tool-2",
|
||||
}),
|
||||
)
|
||||
|
||||
expect(body).toEqual({
|
||||
type: "text",
|
||||
content: "partial output",
|
||||
})
|
||||
expect(
|
||||
entryCanStream(
|
||||
commit({
|
||||
kind: "tool",
|
||||
text: "partial output",
|
||||
phase: "progress",
|
||||
source: "tool",
|
||||
tool: "bash",
|
||||
}),
|
||||
body,
|
||||
),
|
||||
).toBe(true)
|
||||
expect(
|
||||
entryDone(
|
||||
commit({
|
||||
kind: "tool",
|
||||
text: "output",
|
||||
phase: "progress",
|
||||
source: "tool",
|
||||
tool: "bash",
|
||||
toolState: "completed",
|
||||
}),
|
||||
),
|
||||
).toBe(true)
|
||||
})
|
||||
|
||||
test.skip("formats completed bash output with a blank line after the command and no trailing blank row", () => {
|
||||
expect(
|
||||
entryBody(
|
||||
toolCommit({
|
||||
tool: "bash",
|
||||
phase: "progress",
|
||||
toolState: "completed",
|
||||
text: ["/tmp/demo", "git status", "On branch demo", "nothing to commit, working tree clean", ""].join("\n"),
|
||||
state: {
|
||||
status: "completed",
|
||||
input: {
|
||||
command: "git status",
|
||||
workdir: "/tmp/demo",
|
||||
},
|
||||
output: ["/tmp/demo", "git status", "On branch demo", "nothing to commit, working tree clean", ""].join(
|
||||
"\n",
|
||||
),
|
||||
title: "git status",
|
||||
metadata: {
|
||||
exitCode: 0,
|
||||
},
|
||||
time: { start: 1, end: 2 },
|
||||
},
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
type: "text",
|
||||
content: "\nOn branch demo\nnothing to commit, working tree clean",
|
||||
})
|
||||
})
|
||||
|
||||
test.skip("renders command-only bash starts without the shell header", () => {
|
||||
expect(
|
||||
entryBody(
|
||||
toolCommit({
|
||||
tool: "bash",
|
||||
phase: "start",
|
||||
toolState: "running",
|
||||
text: "running shell",
|
||||
state: {
|
||||
status: "running",
|
||||
input: {
|
||||
command: "ls",
|
||||
},
|
||||
time: { start: 1 },
|
||||
},
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
type: "text",
|
||||
content: "$ ls",
|
||||
})
|
||||
})
|
||||
|
||||
test("renders direct shell commits without a synthetic shell header", () => {
|
||||
expect(
|
||||
entryBody(
|
||||
commit({
|
||||
kind: "tool",
|
||||
text: "running shell",
|
||||
phase: "start",
|
||||
source: "tool",
|
||||
tool: "bash",
|
||||
partID: "shell:call-1",
|
||||
toolState: "running",
|
||||
shell: {
|
||||
callID: "call-1",
|
||||
command: "pwd",
|
||||
},
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
type: "text",
|
||||
content: "$ pwd",
|
||||
})
|
||||
|
||||
expect(
|
||||
entryBody(
|
||||
commit({
|
||||
kind: "tool",
|
||||
text: "/tmp/demo\n",
|
||||
phase: "progress",
|
||||
source: "tool",
|
||||
tool: "bash",
|
||||
partID: "shell:call-1",
|
||||
toolState: "completed",
|
||||
shell: {
|
||||
callID: "call-1",
|
||||
command: "pwd",
|
||||
},
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
type: "text",
|
||||
content: "\n/tmp/demo",
|
||||
})
|
||||
})
|
||||
|
||||
test.skip("falls back to patch summary when apply_patch has no visible diff items", () => {
|
||||
expect(
|
||||
entryBody(
|
||||
toolCommit({
|
||||
tool: "apply_patch",
|
||||
state: {
|
||||
status: "completed",
|
||||
input: {
|
||||
patchText: "*** Begin Patch\n*** End Patch",
|
||||
},
|
||||
output: "",
|
||||
title: "",
|
||||
metadata: {
|
||||
files: [
|
||||
{
|
||||
type: "update",
|
||||
filePath: "src/a.ts",
|
||||
relativePath: "src/a.ts",
|
||||
diff: "@@ -1 +1 @@\n-old\n+new\n",
|
||||
},
|
||||
],
|
||||
},
|
||||
time: { start: 1, end: 2 },
|
||||
},
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
type: "text",
|
||||
content: "~ Patched src/a.ts",
|
||||
})
|
||||
})
|
||||
|
||||
test.skip("suppresses redundant patched rows when apply_patch also created a file", () => {
|
||||
expect(
|
||||
entryBody(
|
||||
toolCommit({
|
||||
tool: "apply_patch",
|
||||
state: {
|
||||
status: "completed",
|
||||
input: {
|
||||
patchText: "*** Begin Patch\n*** End Patch",
|
||||
},
|
||||
output: "",
|
||||
title: "",
|
||||
metadata: {
|
||||
files: [
|
||||
{
|
||||
type: "update",
|
||||
filePath: "src/a.ts",
|
||||
relativePath: "src/a.ts",
|
||||
diff: "@@ -1 +1 @@\n-old\n+new\n",
|
||||
},
|
||||
{
|
||||
type: "add",
|
||||
filePath: "README-demo.md",
|
||||
relativePath: "README-demo.md",
|
||||
},
|
||||
],
|
||||
},
|
||||
time: { start: 1, end: 2 },
|
||||
},
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
type: "text",
|
||||
content: "+ Created README-demo.md",
|
||||
})
|
||||
})
|
||||
|
||||
test("renders glob failures as the raw error under the existing header", () => {
|
||||
expect(
|
||||
entryBody(
|
||||
toolCommit({
|
||||
tool: "glob",
|
||||
phase: "final",
|
||||
toolState: "error",
|
||||
state: {
|
||||
status: "error",
|
||||
input: {
|
||||
pattern: "**/*tool*",
|
||||
path: "/tmp/demo/run",
|
||||
},
|
||||
error: "No such file or directory: '/tmp/demo/run'",
|
||||
metadata: {},
|
||||
time: { start: 1, end: 2 },
|
||||
},
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
type: "text",
|
||||
content: "No such file or directory: '/tmp/demo/run'",
|
||||
})
|
||||
})
|
||||
|
||||
test("renders interrupted assistant finals as text", () => {
|
||||
expect(
|
||||
entryBody(
|
||||
commit({
|
||||
kind: "assistant",
|
||||
text: "",
|
||||
phase: "final",
|
||||
source: "assistant",
|
||||
interrupted: true,
|
||||
partID: "part-1",
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
type: "text",
|
||||
content: "assistant interrupted",
|
||||
})
|
||||
})
|
||||
})
|
||||
12
packages/tui/test/mini/fixture/tui-runtime.ts
Normal file
12
packages/tui/test/mini/fixture/tui-runtime.ts
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
import { resolve, type Info, type Resolved } from "../../../src/config/v1"
|
||||
import { TuiKeybind } from "../../../src/config/v1/keybind"
|
||||
|
||||
type ResolvedInput = Omit<Info, "attention" | "keybinds" | "leader_timeout"> & {
|
||||
attention?: Partial<Resolved["attention"]>
|
||||
keybinds?: Partial<TuiKeybind.Keybinds>
|
||||
leader_timeout?: number
|
||||
}
|
||||
|
||||
export function createTuiResolvedConfig(input: ResolvedInput = {}) {
|
||||
return resolve(input, { terminalSuspend: process.platform !== "win32" })
|
||||
}
|
||||
95
packages/tui/test/mini/footer-keymap.test.tsx
Normal file
95
packages/tui/test/mini/footer-keymap.test.tsx
Normal file
|
|
@ -0,0 +1,95 @@
|
|||
/** @jsxImportSource @opentui/solid */
|
||||
import { testRender } from "@opentui/solid"
|
||||
import { Keymap } from "../../src/context/keymap"
|
||||
import { resolve } from "../../src/config/v1"
|
||||
import { expect, test } from "bun:test"
|
||||
import { createSignal } from "solid-js"
|
||||
import { RunFooterView } from "../../src/mini/footer.view"
|
||||
import { RUN_THEME_FALLBACK } from "../../src/mini/theme"
|
||||
import type { FooterState, FooterSubagentState, FooterView } from "../../src/mini/types"
|
||||
|
||||
test("down opens subagents from an empty prompt", async () => {
|
||||
const [state] = createSignal<FooterState>({
|
||||
phase: "idle",
|
||||
status: "",
|
||||
queue: 0,
|
||||
model: "gpt-5",
|
||||
duration: "",
|
||||
usage: "",
|
||||
first: false,
|
||||
interrupt: 0,
|
||||
exit: 0,
|
||||
})
|
||||
const [view] = createSignal<FooterView>({ type: "prompt" })
|
||||
const [subagents] = createSignal<FooterSubagentState>({
|
||||
tabs: [
|
||||
{
|
||||
sessionID: "subagent-1",
|
||||
partID: "part-1",
|
||||
callID: "call-1",
|
||||
label: "Explore",
|
||||
description: "Inspect the keymap",
|
||||
status: "running",
|
||||
lastUpdatedAt: 1,
|
||||
},
|
||||
],
|
||||
details: {},
|
||||
permissions: [],
|
||||
questions: [],
|
||||
})
|
||||
const config = resolve(
|
||||
{ keybinds: { editor_open: "none", session_queued_prompts: "none" } },
|
||||
{ terminalSuspend: true },
|
||||
)
|
||||
function Harness() {
|
||||
return (
|
||||
<Keymap.Provider config={config}>
|
||||
<RunFooterView
|
||||
directory="/tmp"
|
||||
findFiles={async () => []}
|
||||
agents={() => []}
|
||||
references={() => []}
|
||||
commands={() => []}
|
||||
providers={() => undefined}
|
||||
currentModel={() => undefined}
|
||||
variants={() => []}
|
||||
currentVariant={() => undefined}
|
||||
state={state}
|
||||
view={view}
|
||||
subagent={subagents}
|
||||
theme={() => RUN_THEME_FALLBACK}
|
||||
tuiConfig={config}
|
||||
agent="opencode"
|
||||
onSubmit={() => true}
|
||||
onPermissionReply={() => {}}
|
||||
onQuestionReply={() => {}}
|
||||
onQuestionReject={() => {}}
|
||||
onCycle={() => {}}
|
||||
onInterrupt={() => false}
|
||||
onEditorOpen={async () => undefined}
|
||||
onInputClear={() => {}}
|
||||
onExit={() => {}}
|
||||
onModelSelect={() => {}}
|
||||
onVariantSelect={() => {}}
|
||||
onRows={() => {}}
|
||||
onLayout={() => {}}
|
||||
onStatus={() => {}}
|
||||
onQueuedRemove={async () => true}
|
||||
/>
|
||||
</Keymap.Provider>
|
||||
)
|
||||
}
|
||||
|
||||
const app = await testRender(() => <Harness />, { width: 100, height: 8, kittyKeyboard: true })
|
||||
try {
|
||||
await app.renderOnce()
|
||||
expect(app.renderer.currentFocusedEditor?.plainText).toBe("")
|
||||
app.mockInput.pressArrow("down")
|
||||
await app.renderOnce()
|
||||
expect(app.captureCharFrame()).toContain("Select subagent")
|
||||
} finally {
|
||||
app.renderer.currentFocusedRenderable?.blur()
|
||||
app.renderer.currentFocusedEditor?.blur()
|
||||
app.renderer.destroy()
|
||||
}
|
||||
})
|
||||
43
packages/tui/test/mini/footer.menu.test.ts
Normal file
43
packages/tui/test/mini/footer.menu.test.ts
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
import { expect, test } from "bun:test"
|
||||
import { createRoot } from "solid-js"
|
||||
import { FOOTER_MENU_ROWS, createFooterMenuState } from "../../src/mini/footer.menu"
|
||||
|
||||
function mount(count: number, limit = FOOTER_MENU_ROWS) {
|
||||
let dispose!: () => void
|
||||
let menu!: ReturnType<typeof createFooterMenuState>
|
||||
|
||||
createRoot((nextDispose) => {
|
||||
dispose = nextDispose
|
||||
menu = createFooterMenuState({ count: () => count, limit })
|
||||
return null
|
||||
})
|
||||
|
||||
return { menu, dispose }
|
||||
}
|
||||
|
||||
test("footer menu scrolls before the selected row hits the bottom edge", () => {
|
||||
const state = mount(20)
|
||||
|
||||
try {
|
||||
Array.from({ length: 6 }).forEach(() => state.menu.move(1))
|
||||
|
||||
expect(state.menu.selected()).toBe(6)
|
||||
expect(state.menu.offset()).toBe(1)
|
||||
} finally {
|
||||
state.dispose()
|
||||
}
|
||||
})
|
||||
|
||||
test("footer menu scrolls before the selected row hits the top edge", () => {
|
||||
const state = mount(20)
|
||||
|
||||
try {
|
||||
Array.from({ length: 13 }).forEach(() => state.menu.move(1))
|
||||
Array.from({ length: 4 }).forEach(() => state.menu.move(-1))
|
||||
|
||||
expect(state.menu.selected()).toBe(9)
|
||||
expect(state.menu.offset()).toBe(7)
|
||||
} finally {
|
||||
state.dispose()
|
||||
}
|
||||
})
|
||||
1424
packages/tui/test/mini/footer.view.test.tsx
Normal file
1424
packages/tui/test/mini/footer.view.test.tsx
Normal file
File diff suppressed because it is too large
Load diff
35
packages/tui/test/mini/footer.width.test.ts
Normal file
35
packages/tui/test/mini/footer.width.test.ts
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
import { describe, expect, test } from "bun:test"
|
||||
import { footerWidthPolicy } from "../../src/mini/footer.width"
|
||||
|
||||
describe("run footer width", () => {
|
||||
test("preserves shared dialog and statusline breakpoints", () => {
|
||||
const narrow = footerWidthPolicy(79)
|
||||
expect(narrow.dialog.narrow).toBe(true)
|
||||
expect(narrow.statusline.showActivityMeta).toBe(false)
|
||||
expect(narrow.statusline.showCommandHint).toBe(true)
|
||||
expect(narrow.statusline.showContextHints).toBe(false)
|
||||
expect(narrow.statusline.contextHintLimit).toBe(0)
|
||||
expect(narrow.statusline.showModel).toBe(false)
|
||||
|
||||
const command = footerWidthPolicy(65)
|
||||
expect(command.statusline.showCommandHint).toBe(false)
|
||||
|
||||
const commandHint = footerWidthPolicy(66)
|
||||
expect(commandHint.statusline.showCommandHint).toBe(true)
|
||||
|
||||
const compact = footerWidthPolicy(80)
|
||||
expect(compact.dialog.narrow).toBe(false)
|
||||
expect(compact.statusline.showActivityMeta).toBe(true)
|
||||
expect(compact.statusline.showContextHints).toBe(true)
|
||||
expect(compact.statusline.contextHintLimit).toBe(1)
|
||||
expect(compact.statusline.showModel).toBe(false)
|
||||
|
||||
const model = footerWidthPolicy(120)
|
||||
expect(model.statusline.contextHintLimit).toBe(2)
|
||||
expect(model.statusline.showModel).toBe(true)
|
||||
|
||||
const spacious = footerWidthPolicy(150)
|
||||
expect(spacious.statusline.contextHintLimit).toBeUndefined()
|
||||
expect(spacious.statusline.showModel).toBe(true)
|
||||
})
|
||||
})
|
||||
144
packages/tui/test/mini/permission.shared.test.ts
Normal file
144
packages/tui/test/mini/permission.shared.test.ts
Normal file
|
|
@ -0,0 +1,144 @@
|
|||
import { describe, expect, test } from "bun:test"
|
||||
import type { PermissionV2Request } from "@opencode-ai/client/promise"
|
||||
import {
|
||||
createPermissionBodyState,
|
||||
permissionAlwaysLines,
|
||||
permissionCancel,
|
||||
permissionEscape,
|
||||
permissionInfo,
|
||||
permissionReject,
|
||||
permissionRun,
|
||||
} from "../../src/mini/permission.shared"
|
||||
|
||||
function req(input: Partial<PermissionV2Request> = {}): PermissionV2Request {
|
||||
return {
|
||||
id: "perm-1",
|
||||
sessionID: "session-1",
|
||||
action: "read",
|
||||
resources: [],
|
||||
metadata: {},
|
||||
save: [],
|
||||
...input,
|
||||
}
|
||||
}
|
||||
|
||||
describe("run permission shared", () => {
|
||||
test("replies immediately for allow once", () => {
|
||||
const out = permissionRun(createPermissionBodyState("perm-1"), "perm-1", "once")
|
||||
|
||||
expect(out.reply).toEqual({
|
||||
requestID: "perm-1",
|
||||
reply: "once",
|
||||
})
|
||||
})
|
||||
|
||||
test("requires confirmation for allow always", () => {
|
||||
const next = permissionRun(createPermissionBodyState("perm-1"), "perm-1", "always")
|
||||
expect(next.state.stage).toBe("always")
|
||||
expect(next.state.selected).toBe("confirm")
|
||||
expect(next.reply).toBeUndefined()
|
||||
|
||||
expect(permissionRun(next.state, "perm-1", "confirm").reply).toEqual({
|
||||
requestID: "perm-1",
|
||||
reply: "always",
|
||||
})
|
||||
|
||||
expect(permissionRun(next.state, "perm-1", "cancel").state).toMatchObject({
|
||||
stage: "permission",
|
||||
selected: "always",
|
||||
})
|
||||
})
|
||||
|
||||
test("builds trimmed reject replies and stage transitions", () => {
|
||||
const next = permissionRun(createPermissionBodyState("perm-1"), "perm-1", "reject")
|
||||
expect(next.state.stage).toBe("reject")
|
||||
|
||||
const out = permissionReject({ ...next.state, message: " use rg " }, "perm-1")
|
||||
expect(out).toEqual({
|
||||
requestID: "perm-1",
|
||||
reply: "reject",
|
||||
message: "use rg",
|
||||
})
|
||||
|
||||
expect(permissionCancel(next.state)).toMatchObject({
|
||||
stage: "permission",
|
||||
selected: "reject",
|
||||
})
|
||||
|
||||
expect(permissionEscape(createPermissionBodyState("perm-1"))).toMatchObject({
|
||||
stage: "reject",
|
||||
selected: "reject",
|
||||
})
|
||||
|
||||
expect(permissionEscape({ ...next.state, stage: "always", selected: "confirm" })).toMatchObject({
|
||||
stage: "permission",
|
||||
selected: "always",
|
||||
})
|
||||
})
|
||||
|
||||
test.skip("maps supported permission types into display info", () => {
|
||||
expect(
|
||||
permissionInfo(
|
||||
req({
|
||||
action: "bash",
|
||||
metadata: {
|
||||
input: {
|
||||
command: "git status --short",
|
||||
},
|
||||
},
|
||||
}),
|
||||
),
|
||||
).toMatchObject({
|
||||
title: "Shell command",
|
||||
lines: ["$ git status --short"],
|
||||
})
|
||||
|
||||
expect(
|
||||
permissionInfo(
|
||||
req({
|
||||
action: "task",
|
||||
metadata: {
|
||||
description: "investigate stream",
|
||||
subagent_type: "general",
|
||||
},
|
||||
}),
|
||||
),
|
||||
).toMatchObject({
|
||||
title: "General Task",
|
||||
lines: ["◉ investigate stream"],
|
||||
})
|
||||
|
||||
expect(
|
||||
permissionInfo(
|
||||
req({
|
||||
action: "external_directory",
|
||||
resources: ["/tmp/work/**/*.ts", "/tmp/work/**/*.tsx"],
|
||||
}),
|
||||
),
|
||||
).toMatchObject({
|
||||
title: "Access external directory /tmp/work",
|
||||
lines: ["- /tmp/work/**/*.ts", "- /tmp/work/**/*.tsx"],
|
||||
})
|
||||
|
||||
expect(permissionInfo(req({ action: "doom_loop" }))).toMatchObject({
|
||||
title: "Continue after repeated failures",
|
||||
})
|
||||
|
||||
expect(permissionInfo(req({ action: "custom_tool" }))).toMatchObject({
|
||||
title: "Call tool custom_tool",
|
||||
lines: ["Tool: custom_tool"],
|
||||
})
|
||||
})
|
||||
|
||||
test("formats always-allow copy for wildcard and explicit patterns", () => {
|
||||
expect(permissionAlwaysLines(req({ action: "bash", save: ["*"] }))).toEqual([
|
||||
"This will allow bash until OpenCode is restarted.",
|
||||
])
|
||||
|
||||
expect(permissionAlwaysLines(req({ save: ["src/**/*.ts", "src/**/*.tsx"] }))).toEqual([
|
||||
"This will allow the following patterns until OpenCode is restarted.",
|
||||
"- src/**/*.ts",
|
||||
"- src/**/*.tsx",
|
||||
])
|
||||
})
|
||||
})
|
||||
101
packages/tui/test/mini/prompt.editor.test.ts
Normal file
101
packages/tui/test/mini/prompt.editor.test.ts
Normal file
|
|
@ -0,0 +1,101 @@
|
|||
import { describe, expect, test } from "bun:test"
|
||||
import { realignEditorPromptParts, resolveEditorSlashValue } from "../../src/mini/prompt.editor"
|
||||
import type { RunPromptPart } from "../../src/mini/types"
|
||||
|
||||
describe("run prompt editor helpers", () => {
|
||||
test("strips the local /editor command from the initial editor text", () => {
|
||||
expect(resolveEditorSlashValue("/editor")).toBe("")
|
||||
expect(resolveEditorSlashValue("/editor draft message")).toBe("draft message")
|
||||
expect(resolveEditorSlashValue("/editor first line\nsecond line")).toBe("first line\nsecond line")
|
||||
})
|
||||
|
||||
test("realigns file and agent parts after external editing", () => {
|
||||
const filePart = {
|
||||
type: "file",
|
||||
mime: "text/plain",
|
||||
filename: "src/app.ts",
|
||||
url: "file:///src/app.ts",
|
||||
source: {
|
||||
type: "file",
|
||||
path: "src/app.ts",
|
||||
text: {
|
||||
start: 0,
|
||||
end: 11,
|
||||
value: "@src/app.ts",
|
||||
},
|
||||
},
|
||||
} satisfies RunPromptPart
|
||||
const agentPart = {
|
||||
type: "agent",
|
||||
name: "helper",
|
||||
source: {
|
||||
start: 12,
|
||||
end: 19,
|
||||
value: "@helper",
|
||||
},
|
||||
} satisfies RunPromptPart
|
||||
const parts = [filePart, agentPart]
|
||||
|
||||
expect(realignEditorPromptParts("Please check @helper before @src/app.ts", parts)).toEqual([
|
||||
{
|
||||
...filePart,
|
||||
source: {
|
||||
...filePart.source,
|
||||
text: {
|
||||
...filePart.source.text,
|
||||
start: 28,
|
||||
end: 39,
|
||||
value: "@src/app.ts",
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
...agentPart,
|
||||
source: {
|
||||
start: 13,
|
||||
end: 20,
|
||||
value: "@helper",
|
||||
},
|
||||
},
|
||||
])
|
||||
})
|
||||
|
||||
test("drops parts whose virtual text was deleted", () => {
|
||||
const filePart = {
|
||||
type: "file",
|
||||
mime: "text/plain",
|
||||
filename: "src/app.ts",
|
||||
url: "file:///src/app.ts",
|
||||
source: {
|
||||
type: "file",
|
||||
path: "src/app.ts",
|
||||
text: {
|
||||
start: 0,
|
||||
end: 11,
|
||||
value: "@src/app.ts",
|
||||
},
|
||||
},
|
||||
} satisfies RunPromptPart
|
||||
const agentPart = {
|
||||
type: "agent",
|
||||
name: "helper",
|
||||
source: {
|
||||
start: 12,
|
||||
end: 19,
|
||||
value: "@helper",
|
||||
},
|
||||
} satisfies RunPromptPart
|
||||
const parts = [filePart, agentPart]
|
||||
|
||||
expect(realignEditorPromptParts("Only @helper remains", parts)).toEqual([
|
||||
{
|
||||
...agentPart,
|
||||
source: {
|
||||
start: 5,
|
||||
end: 12,
|
||||
value: "@helper",
|
||||
},
|
||||
},
|
||||
])
|
||||
})
|
||||
})
|
||||
101
packages/tui/test/mini/prompt.shared.test.ts
Normal file
101
packages/tui/test/mini/prompt.shared.test.ts
Normal file
|
|
@ -0,0 +1,101 @@
|
|||
import { describe, expect, test } from "bun:test"
|
||||
import {
|
||||
createPromptHistory,
|
||||
isExitCommand,
|
||||
isNewCommand,
|
||||
movePromptHistory,
|
||||
pushPromptHistory,
|
||||
} from "../../src/mini/prompt.shared"
|
||||
import type { RunPrompt } from "../../src/mini/types"
|
||||
|
||||
function prompt(text: string, parts: RunPrompt["parts"] = []): RunPrompt {
|
||||
return { text, parts }
|
||||
}
|
||||
|
||||
describe("run prompt shared", () => {
|
||||
test("filters blank prompts and dedupes consecutive history", () => {
|
||||
const out = createPromptHistory([prompt(" "), prompt("one"), prompt("one"), prompt("two"), prompt("one")])
|
||||
|
||||
expect(out.items.map((item) => item.text)).toEqual(["one", "two", "one"])
|
||||
expect(out.index).toBeNull()
|
||||
expect(out.draft).toBe("")
|
||||
})
|
||||
|
||||
test("push ignores blanks and dedupes only the latest item", () => {
|
||||
const base = createPromptHistory([prompt("one")])
|
||||
|
||||
expect(pushPromptHistory(base, prompt(" ")).items.map((item) => item.text)).toEqual(["one"])
|
||||
expect(pushPromptHistory(base, prompt("one")).items.map((item) => item.text)).toEqual(["one"])
|
||||
expect(pushPromptHistory(base, prompt("two")).items.map((item) => item.text)).toEqual(["one", "two"])
|
||||
})
|
||||
|
||||
test("moves through history only at input boundaries and restores draft", () => {
|
||||
const base = createPromptHistory([prompt("one"), prompt("two")])
|
||||
|
||||
expect(movePromptHistory(base, -1, "draft", 1)).toEqual({
|
||||
state: base,
|
||||
apply: false,
|
||||
})
|
||||
|
||||
const up = movePromptHistory(base, -1, "draft", 0)
|
||||
expect(up.apply).toBe(true)
|
||||
expect(up.text).toBe("two")
|
||||
expect(up.cursor).toBe(0)
|
||||
expect(up.state.index).toBe(1)
|
||||
expect(up.state.draft).toBe("draft")
|
||||
|
||||
const older = movePromptHistory(up.state, -1, "two", 0)
|
||||
expect(older.apply).toBe(true)
|
||||
expect(older.text).toBe("one")
|
||||
expect(older.cursor).toBe(0)
|
||||
expect(older.state.index).toBe(0)
|
||||
|
||||
const newer = movePromptHistory(older.state, 1, "one", 3)
|
||||
expect(newer.apply).toBe(true)
|
||||
expect(newer.text).toBe("two")
|
||||
expect(newer.cursor).toBe(3)
|
||||
expect(newer.state.index).toBe(1)
|
||||
|
||||
const draft = movePromptHistory(newer.state, 1, "two", 3)
|
||||
expect(draft.apply).toBe(true)
|
||||
expect(draft.text).toBe("draft")
|
||||
expect(draft.cursor).toBe(5)
|
||||
expect(draft.state.index).toBeNull()
|
||||
})
|
||||
|
||||
test("uses display-width cursors for history restoration", () => {
|
||||
const base = createPromptHistory([prompt("one"), prompt("中文")])
|
||||
|
||||
const latest = movePromptHistory(base, -1, "草稿", 0)
|
||||
expect(latest.apply).toBe(true)
|
||||
expect(latest.text).toBe("中文")
|
||||
expect(latest.cursor).toBe(0)
|
||||
|
||||
const older = movePromptHistory(latest.state, -1, "中文", 0)
|
||||
expect(older.apply).toBe(true)
|
||||
expect(older.text).toBe("one")
|
||||
expect(older.cursor).toBe(0)
|
||||
|
||||
const newer = movePromptHistory(older.state, 1, "one", Bun.stringWidth("one"))
|
||||
expect(newer.apply).toBe(true)
|
||||
expect(newer.text).toBe("中文")
|
||||
expect(newer.cursor).toBe(Bun.stringWidth("中文"))
|
||||
|
||||
const draft = movePromptHistory(newer.state, 1, "中文", Bun.stringWidth("中文"))
|
||||
expect(draft.apply).toBe(true)
|
||||
expect(draft.text).toBe("草稿")
|
||||
expect(draft.cursor).toBe(Bun.stringWidth("草稿"))
|
||||
})
|
||||
|
||||
test("recognizes exit commands", () => {
|
||||
expect(isExitCommand("/exit")).toBe(true)
|
||||
expect(isExitCommand(" /Quit ")).toBe(true)
|
||||
expect(isExitCommand("/quit now")).toBe(false)
|
||||
})
|
||||
|
||||
test("recognizes the new-session command", () => {
|
||||
expect(isNewCommand("/new")).toBe(true)
|
||||
expect(isNewCommand(" /NEW ")).toBe(true)
|
||||
expect(isNewCommand("/new now")).toBe(false)
|
||||
})
|
||||
})
|
||||
115
packages/tui/test/mini/question.shared.test.ts
Normal file
115
packages/tui/test/mini/question.shared.test.ts
Normal file
|
|
@ -0,0 +1,115 @@
|
|||
import { describe, expect, test } from "bun:test"
|
||||
import type { QuestionV2Request } from "@opencode-ai/client/promise"
|
||||
import {
|
||||
createQuestionBodyState,
|
||||
questionConfirm,
|
||||
questionReject,
|
||||
questionSave,
|
||||
questionSelect,
|
||||
questionSetSelected,
|
||||
questionStoreCustom,
|
||||
questionSubmit,
|
||||
questionSync,
|
||||
} from "../../src/mini/question.shared"
|
||||
|
||||
function req(input: Partial<QuestionV2Request> = {}): QuestionV2Request {
|
||||
return {
|
||||
id: "question-1",
|
||||
sessionID: "session-1",
|
||||
questions: [
|
||||
{
|
||||
question: "Mode?",
|
||||
header: "Mode",
|
||||
options: [{ label: "chunked", description: "Incremental output" }],
|
||||
multiple: false,
|
||||
},
|
||||
],
|
||||
...input,
|
||||
}
|
||||
}
|
||||
|
||||
describe("run question shared", () => {
|
||||
test("replies immediately for a single-select question", () => {
|
||||
const out = questionSelect(createQuestionBodyState("question-1"), req())
|
||||
|
||||
expect(out.reply).toEqual({
|
||||
requestID: "question-1",
|
||||
answers: [["chunked"]],
|
||||
})
|
||||
})
|
||||
|
||||
test("advances multi-question flows and submits from confirm", () => {
|
||||
const ask = req({
|
||||
questions: [
|
||||
{
|
||||
question: "Mode?",
|
||||
header: "Mode",
|
||||
options: [{ label: "chunked", description: "Incremental output" }],
|
||||
multiple: false,
|
||||
},
|
||||
{
|
||||
question: "Output?",
|
||||
header: "Output",
|
||||
options: [
|
||||
{ label: "yes", description: "Show tool output" },
|
||||
{ label: "no", description: "Hide tool output" },
|
||||
],
|
||||
multiple: false,
|
||||
},
|
||||
],
|
||||
})
|
||||
|
||||
let state = questionSelect(createQuestionBodyState("question-1"), ask).state
|
||||
expect(state.tab).toBe(1)
|
||||
|
||||
state = questionSetSelected(state, 1)
|
||||
state = questionSelect(state, ask).state
|
||||
expect(questionConfirm(ask, state)).toBe(true)
|
||||
expect(questionSubmit(ask, state)).toEqual({
|
||||
requestID: "question-1",
|
||||
answers: [["chunked"], ["no"]],
|
||||
})
|
||||
})
|
||||
|
||||
test("toggles answers for multiple-choice questions", () => {
|
||||
const ask = req({
|
||||
questions: [
|
||||
{
|
||||
question: "Tags?",
|
||||
header: "Tags",
|
||||
options: [{ label: "bug", description: "Bug fix" }],
|
||||
multiple: true,
|
||||
},
|
||||
],
|
||||
})
|
||||
|
||||
let state = questionSelect(createQuestionBodyState("question-1"), ask).state
|
||||
expect(state.answers).toEqual([["bug"]])
|
||||
|
||||
state = questionSelect(state, ask).state
|
||||
expect(state.answers).toEqual([[]])
|
||||
})
|
||||
|
||||
test("stores and submits custom answers", () => {
|
||||
let state = questionSetSelected(createQuestionBodyState("question-1"), 1)
|
||||
let next = questionSelect(state, req())
|
||||
expect(next.state.editing).toBe(true)
|
||||
|
||||
state = questionStoreCustom(next.state, 0, " custom mode ")
|
||||
next = questionSave(state, req())
|
||||
expect(next.reply).toEqual({
|
||||
requestID: "question-1",
|
||||
answers: [["custom mode"]],
|
||||
})
|
||||
})
|
||||
|
||||
test("resets state when the request id changes and builds reject payloads", () => {
|
||||
const state = questionSetSelected(createQuestionBodyState("question-1"), 1)
|
||||
|
||||
expect(questionSync(state, "question-1")).toBe(state)
|
||||
expect(questionSync(state, "question-2")).toEqual(createQuestionBodyState("question-2"))
|
||||
expect(questionReject(req())).toEqual({
|
||||
requestID: "question-1",
|
||||
})
|
||||
})
|
||||
})
|
||||
256
packages/tui/test/mini/runtime.boot.test.ts
Normal file
256
packages/tui/test/mini/runtime.boot.test.ts
Normal file
|
|
@ -0,0 +1,256 @@
|
|||
import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
|
||||
import { OpenCode } from "@opencode-ai/client/promise"
|
||||
import type { Resolved } from "../../src/config/v1"
|
||||
import { resolveDiffStyle, resolveModelInfo, resolveRunTuiConfig } from "../../src/mini/runtime.boot"
|
||||
import { createTuiResolvedConfig } from "./fixture/tui-runtime"
|
||||
|
||||
function ok<T>(data: T) {
|
||||
return Promise.resolve(data)
|
||||
}
|
||||
|
||||
function provider(id: string, name: string) {
|
||||
return {
|
||||
id,
|
||||
name,
|
||||
api: { type: "native" as const, settings: {} },
|
||||
request: { headers: {}, body: {} },
|
||||
}
|
||||
}
|
||||
|
||||
function model(id: string, providerID: string, context: number, variants: string[] = []) {
|
||||
return {
|
||||
id,
|
||||
providerID,
|
||||
api: {
|
||||
id: providerID,
|
||||
type: "native" as const,
|
||||
settings: {},
|
||||
},
|
||||
name: id,
|
||||
capabilities: {
|
||||
tools: true,
|
||||
input: ["text"],
|
||||
output: ["text"],
|
||||
},
|
||||
request: {
|
||||
headers: {},
|
||||
body: {},
|
||||
},
|
||||
variants: variants.map((variant) => ({
|
||||
id: variant,
|
||||
headers: {},
|
||||
body: {},
|
||||
})),
|
||||
time: {
|
||||
released: 1,
|
||||
},
|
||||
cost: [
|
||||
{
|
||||
input: 0,
|
||||
output: 0,
|
||||
cache: {
|
||||
read: 0,
|
||||
write: 0,
|
||||
},
|
||||
},
|
||||
],
|
||||
limit: {
|
||||
context,
|
||||
output: 8192,
|
||||
},
|
||||
status: "active" as const,
|
||||
enabled: true,
|
||||
}
|
||||
}
|
||||
|
||||
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 () => {
|
||||
const input = 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(input)
|
||||
|
||||
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 () => {
|
||||
const result = await resolveRunTuiConfig(Promise.reject(new Error("boom")))
|
||||
|
||||
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 () => {
|
||||
const result = await resolveRunTuiConfig(config({ leader: "none" }))
|
||||
|
||||
expect(result.keybinds.get("leader")).toEqual([])
|
||||
})
|
||||
|
||||
test("reads diff style and falls back to auto", async () => {
|
||||
await expect(resolveDiffStyle(config({ diff_style: "stacked" }))).resolves.toBe("stacked")
|
||||
|
||||
await expect(resolveDiffStyle(Promise.reject(new Error("boom")))).resolves.toBe("auto")
|
||||
})
|
||||
|
||||
test("loads v2 providers and models for model selector data", async () => {
|
||||
const sdk = OpenCode.make({ baseUrl: "https://opencode.test" })
|
||||
const providers = [provider("openai", "OpenAI")]
|
||||
const models = [model("gpt-5", "openai", 128000, ["high", "minimal"])]
|
||||
const providerList = spyOn(sdk.provider, "list").mockImplementation(() => ok({ data: providers }) as never)
|
||||
spyOn(sdk.model, "list").mockImplementation(() => ok({ data: models }) as never)
|
||||
|
||||
await expect(resolveModelInfo(sdk, "/workspace", { providerID: "openai", modelID: "gpt-5" })).resolves.toEqual({
|
||||
providers: [
|
||||
{
|
||||
id: "openai",
|
||||
name: "OpenAI",
|
||||
models: {
|
||||
"gpt-5": {
|
||||
id: "gpt-5",
|
||||
providerID: "openai",
|
||||
name: "gpt-5",
|
||||
capabilities: {
|
||||
tools: true,
|
||||
input: ["text"],
|
||||
output: ["text"],
|
||||
},
|
||||
cost: {
|
||||
input: 0,
|
||||
output: 0,
|
||||
cache: {
|
||||
read: 0,
|
||||
write: 0,
|
||||
},
|
||||
},
|
||||
limit: {
|
||||
context: 128000,
|
||||
output: 8192,
|
||||
},
|
||||
status: "active",
|
||||
variants: {
|
||||
high: {},
|
||||
minimal: {},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
],
|
||||
variants: ["high", "minimal"],
|
||||
limits: {
|
||||
"openai/gpt-5": 128000,
|
||||
},
|
||||
})
|
||||
expect(providerList).toHaveBeenCalledWith(
|
||||
{
|
||||
location: {
|
||||
directory: "/workspace",
|
||||
},
|
||||
},
|
||||
)
|
||||
})
|
||||
|
||||
test("loads context limits across v2 providers", async () => {
|
||||
const sdk = OpenCode.make({ baseUrl: "https://opencode.test" })
|
||||
const providers = [provider("openai", "OpenAI"), provider("anthropic", "Anthropic")]
|
||||
const models = [model("gpt-5", "openai", 128000, ["high", "minimal"]), model("sonnet", "anthropic", 200000)]
|
||||
spyOn(sdk.provider, "list").mockImplementation(() => ok({ data: providers }) as never)
|
||||
spyOn(sdk.model, "list").mockImplementation(() => ok({ data: models }) as never)
|
||||
|
||||
await expect(resolveModelInfo(sdk, "/workspace", { providerID: "openai", modelID: "gpt-5" })).resolves.toEqual({
|
||||
providers: [
|
||||
expect.objectContaining({
|
||||
id: "openai",
|
||||
name: "OpenAI",
|
||||
models: expect.objectContaining({
|
||||
"gpt-5": expect.objectContaining({
|
||||
variants: {
|
||||
high: {},
|
||||
minimal: {},
|
||||
},
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
expect.objectContaining({
|
||||
id: "anthropic",
|
||||
name: "Anthropic",
|
||||
models: expect.objectContaining({
|
||||
sonnet: expect.objectContaining({
|
||||
variants: {},
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
],
|
||||
variants: ["high", "minimal"],
|
||||
limits: {
|
||||
"openai/gpt-5": 128000,
|
||||
"anthropic/sonnet": 200000,
|
||||
},
|
||||
})
|
||||
})
|
||||
})
|
||||
481
packages/tui/test/mini/runtime.queue.test.ts
Normal file
481
packages/tui/test/mini/runtime.queue.test.ts
Normal file
|
|
@ -0,0 +1,481 @@
|
|||
import { describe, expect, test } from "bun:test"
|
||||
import { runPromptQueue } from "../../src/mini/runtime.queue"
|
||||
import type { FooterApi, FooterEvent, RunPrompt, StreamCommit } from "../../src/mini/types"
|
||||
|
||||
function footer() {
|
||||
const prompts = new Set<(input: RunPrompt) => void>()
|
||||
const queuedRemoves = new Set<(messageID: string) => void>()
|
||||
const closes = new Set<() => void>()
|
||||
const events: FooterEvent[] = []
|
||||
const commits: StreamCommit[] = []
|
||||
let closed = false
|
||||
|
||||
const api: FooterApi = {
|
||||
get isClosed() {
|
||||
return closed
|
||||
},
|
||||
onPrompt(fn) {
|
||||
prompts.add(fn)
|
||||
return () => {
|
||||
prompts.delete(fn)
|
||||
}
|
||||
},
|
||||
onQueuedRemove(fn) {
|
||||
queuedRemoves.add(fn)
|
||||
return () => {
|
||||
queuedRemoves.delete(fn)
|
||||
}
|
||||
},
|
||||
onClose(fn) {
|
||||
if (closed) {
|
||||
fn()
|
||||
return () => {}
|
||||
}
|
||||
|
||||
closes.add(fn)
|
||||
return () => {
|
||||
closes.delete(fn)
|
||||
}
|
||||
},
|
||||
event(next) {
|
||||
events.push(next)
|
||||
},
|
||||
append(next) {
|
||||
commits.push(next)
|
||||
},
|
||||
idle() {
|
||||
return Promise.resolve()
|
||||
},
|
||||
close() {
|
||||
if (closed) {
|
||||
return
|
||||
}
|
||||
|
||||
closed = true
|
||||
for (const fn of [...closes]) {
|
||||
fn()
|
||||
}
|
||||
},
|
||||
destroy() {
|
||||
api.close()
|
||||
prompts.clear()
|
||||
closes.clear()
|
||||
},
|
||||
}
|
||||
|
||||
return {
|
||||
api,
|
||||
events,
|
||||
commits,
|
||||
submit(text: string, mode?: RunPrompt["mode"]) {
|
||||
const next = mode ? { text, parts: [] as RunPrompt["parts"], mode } : { text, parts: [] as RunPrompt["parts"] }
|
||||
for (const fn of [...prompts]) {
|
||||
fn(next)
|
||||
}
|
||||
},
|
||||
removeQueued(messageID: string) {
|
||||
for (const fn of [...queuedRemoves]) fn(messageID)
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
describe("run runtime queue", () => {
|
||||
test("ignores empty prompts", async () => {
|
||||
const ui = footer()
|
||||
let calls = 0
|
||||
|
||||
const task = runPromptQueue({
|
||||
footer: ui.api,
|
||||
run: async () => {
|
||||
calls += 1
|
||||
},
|
||||
})
|
||||
|
||||
ui.submit(" ")
|
||||
ui.api.close()
|
||||
await task
|
||||
|
||||
expect(calls).toBe(0)
|
||||
})
|
||||
|
||||
test("treats /exit as a close command", async () => {
|
||||
const ui = footer()
|
||||
let calls = 0
|
||||
|
||||
const task = runPromptQueue({
|
||||
footer: ui.api,
|
||||
run: async () => {
|
||||
calls += 1
|
||||
},
|
||||
})
|
||||
|
||||
ui.submit("/exit")
|
||||
await task
|
||||
|
||||
expect(calls).toBe(0)
|
||||
})
|
||||
|
||||
test("treats /new as a local session command", async () => {
|
||||
const ui = footer()
|
||||
const seen: string[] = []
|
||||
let created = 0
|
||||
|
||||
const task = runPromptQueue({
|
||||
footer: ui.api,
|
||||
onNewSession: async () => {
|
||||
created += 1
|
||||
},
|
||||
run: async (input) => {
|
||||
seen.push(input.text)
|
||||
ui.api.close()
|
||||
},
|
||||
})
|
||||
|
||||
ui.submit("/new")
|
||||
ui.submit("hello")
|
||||
await task
|
||||
|
||||
expect(created).toBe(1)
|
||||
expect(seen).toEqual(["hello"])
|
||||
expect(ui.commits).toEqual([
|
||||
{
|
||||
kind: "user",
|
||||
text: "hello",
|
||||
phase: "start",
|
||||
source: "system",
|
||||
messageID: expect.any(String),
|
||||
},
|
||||
])
|
||||
})
|
||||
|
||||
test("shell mode submits /exit as a shell command", async () => {
|
||||
const ui = footer()
|
||||
const seen: RunPrompt[] = []
|
||||
|
||||
const task = runPromptQueue({
|
||||
footer: ui.api,
|
||||
run: async (input) => {
|
||||
seen.push(input)
|
||||
ui.api.close()
|
||||
},
|
||||
})
|
||||
|
||||
ui.submit("/exit", "shell")
|
||||
await task
|
||||
|
||||
expect(seen).toEqual([{ text: "/exit", parts: [], mode: "shell" }])
|
||||
expect(ui.commits).toEqual([])
|
||||
})
|
||||
|
||||
test("shell mode submits /new instead of creating a session", async () => {
|
||||
const ui = footer()
|
||||
const seen: RunPrompt[] = []
|
||||
let created = 0
|
||||
|
||||
const task = runPromptQueue({
|
||||
footer: ui.api,
|
||||
onNewSession: async () => {
|
||||
created += 1
|
||||
},
|
||||
run: async (input) => {
|
||||
seen.push(input)
|
||||
ui.api.close()
|
||||
},
|
||||
})
|
||||
|
||||
ui.submit("/new", "shell")
|
||||
await task
|
||||
|
||||
expect(created).toBe(0)
|
||||
expect(seen).toEqual([{ text: "/new", parts: [], mode: "shell" }])
|
||||
expect(ui.commits).toEqual([])
|
||||
})
|
||||
|
||||
test("shell mode does not append a synthetic user row", async () => {
|
||||
const ui = footer()
|
||||
|
||||
const task = runPromptQueue({
|
||||
footer: ui.api,
|
||||
run: async () => {
|
||||
expect(ui.commits).toEqual([])
|
||||
ui.api.close()
|
||||
},
|
||||
})
|
||||
|
||||
ui.submit("ls", "shell")
|
||||
await task
|
||||
})
|
||||
|
||||
test("shell mode does not emit a turn duration summary", async () => {
|
||||
const ui = footer()
|
||||
|
||||
const task = runPromptQueue({
|
||||
footer: ui.api,
|
||||
run: async () => {
|
||||
ui.api.close()
|
||||
},
|
||||
})
|
||||
|
||||
ui.submit("ls", "shell")
|
||||
await task
|
||||
|
||||
expect(ui.events.some((event) => event.type === "turn.duration")).toBe(false)
|
||||
})
|
||||
|
||||
test("preserves whitespace for initial input", async () => {
|
||||
const ui = footer()
|
||||
const seen: string[] = []
|
||||
|
||||
await runPromptQueue({
|
||||
footer: ui.api,
|
||||
initialInput: " hello ",
|
||||
run: async (input) => {
|
||||
seen.push(input.text)
|
||||
ui.api.close()
|
||||
},
|
||||
})
|
||||
|
||||
expect(seen).toEqual([" hello "])
|
||||
expect(ui.commits).toEqual([
|
||||
{
|
||||
kind: "user",
|
||||
text: " hello ",
|
||||
phase: "start",
|
||||
source: "system",
|
||||
messageID: expect.any(String),
|
||||
},
|
||||
])
|
||||
})
|
||||
|
||||
test("passes prompts to onSend", async () => {
|
||||
const ui = footer()
|
||||
const seen: string[] = []
|
||||
|
||||
await runPromptQueue({
|
||||
footer: ui.api,
|
||||
initialInput: " hello ",
|
||||
onSend: (input) => {
|
||||
seen.push(input.text)
|
||||
},
|
||||
run: async () => {
|
||||
ui.api.close()
|
||||
},
|
||||
})
|
||||
|
||||
expect(seen).toEqual([" hello "])
|
||||
})
|
||||
|
||||
test("appends the user row before the turn starts", async () => {
|
||||
const ui = footer()
|
||||
|
||||
await runPromptQueue({
|
||||
footer: ui.api,
|
||||
initialInput: "/fmt bash",
|
||||
run: async () => {
|
||||
expect(ui.commits).toEqual([
|
||||
{
|
||||
kind: "user",
|
||||
text: "/fmt bash",
|
||||
phase: "start",
|
||||
source: "system",
|
||||
messageID: expect.any(String),
|
||||
},
|
||||
])
|
||||
ui.api.close()
|
||||
},
|
||||
})
|
||||
})
|
||||
|
||||
test("runs queued prompts in order", async () => {
|
||||
const ui = footer()
|
||||
const seen: string[] = []
|
||||
let wake: (() => void) | undefined
|
||||
const gate = new Promise<void>((resolve) => {
|
||||
wake = resolve
|
||||
})
|
||||
|
||||
const task = runPromptQueue({
|
||||
footer: ui.api,
|
||||
run: async (input) => {
|
||||
seen.push(input.text)
|
||||
if (seen.length === 1) {
|
||||
await gate
|
||||
return
|
||||
}
|
||||
|
||||
ui.api.close()
|
||||
},
|
||||
})
|
||||
|
||||
ui.submit("one")
|
||||
ui.submit("two")
|
||||
await Promise.resolve()
|
||||
expect(seen).toEqual(["one"])
|
||||
|
||||
wake?.()
|
||||
await task
|
||||
|
||||
expect(seen).toEqual(["one", "two"])
|
||||
})
|
||||
|
||||
test("exposes ordinary in-flight prompts for removal before sending", async () => {
|
||||
const ui = footer()
|
||||
const turns: RunPrompt[] = []
|
||||
let wake: (() => void) | undefined
|
||||
const gate = new Promise<void>((resolve) => {
|
||||
wake = resolve
|
||||
})
|
||||
|
||||
const task = runPromptQueue({
|
||||
footer: ui.api,
|
||||
run: async (input) => {
|
||||
turns.push(input)
|
||||
await gate
|
||||
},
|
||||
})
|
||||
|
||||
ui.submit("one")
|
||||
ui.submit("two")
|
||||
await Promise.resolve()
|
||||
await Promise.resolve()
|
||||
|
||||
expect(turns.map((item) => item.text)).toEqual(["one"])
|
||||
expect(turns[0]?.messageID).toEqual(expect.any(String))
|
||||
expect(ui.commits.map((item) => item.text)).toEqual(["one"])
|
||||
const first = ui.events.find((item) => item.type === "queued.prompts")
|
||||
const event = ui.events.findLast((item) => item.type === "queued.prompts")
|
||||
expect(first?.type === "queued.prompts" ? first.prompts : []).toEqual([])
|
||||
expect(
|
||||
first?.type === "queued.prompts" && event?.type === "queued.prompts" ? first.prompts === event.prompts : true,
|
||||
).toBe(false)
|
||||
expect(ui.events.findLast((item) => item.type === "queue")).toEqual({ type: "queue", queue: 1 })
|
||||
expect(event?.type === "queued.prompts" ? event.prompts.map((item) => item.prompt.text) : []).toEqual(["two"])
|
||||
if (event?.type === "queued.prompts") ui.removeQueued(event.prompts[0]!.messageID)
|
||||
await Promise.resolve()
|
||||
|
||||
wake?.()
|
||||
ui.api.close()
|
||||
await task
|
||||
expect(turns.map((item) => item.text)).toEqual(["one"])
|
||||
})
|
||||
|
||||
test("removing one managed queued prompt preserves the others", async () => {
|
||||
const ui = footer()
|
||||
const turns: string[] = []
|
||||
let wake: (() => void) | undefined
|
||||
const gate = new Promise<void>((resolve) => {
|
||||
wake = resolve
|
||||
})
|
||||
|
||||
const task = runPromptQueue({
|
||||
footer: ui.api,
|
||||
run: async (input) => {
|
||||
turns.push(input.text)
|
||||
if (input.text === "active") await gate
|
||||
if (input.text === "queued three") ui.api.close()
|
||||
},
|
||||
})
|
||||
|
||||
ui.submit("active")
|
||||
ui.submit("queued one")
|
||||
ui.submit("queued two")
|
||||
ui.submit("queued three")
|
||||
await Promise.resolve()
|
||||
await Promise.resolve()
|
||||
|
||||
const event = ui.events.findLast((item) => item.type === "queued.prompts")
|
||||
if (event?.type === "queued.prompts") {
|
||||
const second = event.prompts.find((item) => item.prompt.text === "queued two")
|
||||
if (second) ui.removeQueued(second.messageID)
|
||||
}
|
||||
|
||||
wake?.()
|
||||
await task
|
||||
expect(turns).toEqual(["active", "queued one", "queued three"])
|
||||
})
|
||||
|
||||
test("drains a prompt queued during an in-flight turn", async () => {
|
||||
const ui = footer()
|
||||
const seen: string[] = []
|
||||
let wake: (() => void) | undefined
|
||||
const gate = new Promise<void>((resolve) => {
|
||||
wake = resolve
|
||||
})
|
||||
|
||||
const task = runPromptQueue({
|
||||
footer: ui.api,
|
||||
run: async (input) => {
|
||||
seen.push(input.text)
|
||||
if (seen.length === 1) {
|
||||
await gate
|
||||
return
|
||||
}
|
||||
|
||||
ui.api.close()
|
||||
},
|
||||
})
|
||||
|
||||
ui.submit("one")
|
||||
await Promise.resolve()
|
||||
expect(seen).toEqual(["one"])
|
||||
|
||||
wake?.()
|
||||
await Promise.resolve()
|
||||
ui.submit("two")
|
||||
await task
|
||||
|
||||
expect(seen).toEqual(["one", "two"])
|
||||
})
|
||||
|
||||
test("close aborts the active run and drops pending queued work", async () => {
|
||||
const ui = footer()
|
||||
const seen: string[] = []
|
||||
let hit = false
|
||||
|
||||
const task = runPromptQueue({
|
||||
footer: ui.api,
|
||||
run: async (input, signal) => {
|
||||
seen.push(input.text)
|
||||
await new Promise<void>((resolve) => {
|
||||
if (signal.aborted) {
|
||||
hit = true
|
||||
resolve()
|
||||
return
|
||||
}
|
||||
|
||||
signal.addEventListener(
|
||||
"abort",
|
||||
() => {
|
||||
hit = true
|
||||
resolve()
|
||||
},
|
||||
{ once: true },
|
||||
)
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
ui.submit("one")
|
||||
await Promise.resolve()
|
||||
ui.submit("two")
|
||||
ui.api.close()
|
||||
await task
|
||||
|
||||
expect(hit).toBe(true)
|
||||
expect(seen).toEqual(["one"])
|
||||
})
|
||||
|
||||
test("propagates run errors", async () => {
|
||||
const ui = footer()
|
||||
|
||||
const task = runPromptQueue({
|
||||
footer: ui.api,
|
||||
run: async () => {
|
||||
throw new Error("boom")
|
||||
},
|
||||
})
|
||||
|
||||
ui.submit("one")
|
||||
await expect(task).rejects.toThrow("boom")
|
||||
})
|
||||
})
|
||||
850
packages/tui/test/mini/runtime.test.ts
Normal file
850
packages/tui/test/mini/runtime.test.ts
Normal file
|
|
@ -0,0 +1,850 @@
|
|||
import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
|
||||
import { OpenCode } from "@opencode-ai/client/promise"
|
||||
import { runMiniFrontend } from "../../src/mini"
|
||||
import { runInteractiveDeferredMode, runInteractiveMode } from "../../src/mini/runtime"
|
||||
import type { FooterApi, FooterEvent, MiniHost, RunProvider } from "../../src/mini/types"
|
||||
|
||||
const provider: RunProvider = {
|
||||
id: "openai",
|
||||
name: "OpenAI",
|
||||
models: {
|
||||
"gpt-5": {
|
||||
id: "gpt-5",
|
||||
providerID: "openai",
|
||||
name: "Little Frank",
|
||||
capabilities: {
|
||||
tools: true,
|
||||
input: ["text"],
|
||||
output: ["text"],
|
||||
},
|
||||
cost: {
|
||||
input: 0,
|
||||
output: 0,
|
||||
cache: {
|
||||
read: 0,
|
||||
write: 0,
|
||||
},
|
||||
},
|
||||
limit: {
|
||||
context: 128000,
|
||||
output: 8192,
|
||||
},
|
||||
status: "active",
|
||||
variants: {},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
const transportProviders: RunProvider[][] = []
|
||||
|
||||
function defer<T>() {
|
||||
let resolve!: (value: T | PromiseLike<T>) => void
|
||||
const promise = new Promise<T>((done) => {
|
||||
resolve = done
|
||||
})
|
||||
return { promise, resolve }
|
||||
}
|
||||
|
||||
function ok<T>(data: T) {
|
||||
return Promise.resolve(data)
|
||||
}
|
||||
|
||||
function host(): MiniHost {
|
||||
return {
|
||||
terminal: { stdin: process.stdin, cleanup() {} },
|
||||
platform: "linux",
|
||||
stdout: { write() {} },
|
||||
files: { readText: async () => "" },
|
||||
editor: { open: async () => undefined },
|
||||
paths: { home: "/home/test", state: "/tmp/state", log: "/tmp/log" },
|
||||
signals: {
|
||||
sigint: { subscribe: () => () => {} },
|
||||
sigusr2: { subscribe: () => () => {} },
|
||||
},
|
||||
startup: { showTiming: false, now: () => 0 },
|
||||
diagnostics: { pid: 1, cwd: "/tmp", argv: [] },
|
||||
preferences: {
|
||||
resolveVariant: async () => undefined,
|
||||
saveVariant: async () => {},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
function footer(events: FooterEvent[] = []): FooterApi {
|
||||
let closed = false
|
||||
const closes = new Set<() => void>()
|
||||
|
||||
const notify = () => {
|
||||
for (const fn of closes) fn()
|
||||
}
|
||||
|
||||
return {
|
||||
get isClosed() {
|
||||
return closed
|
||||
},
|
||||
onPrompt: () => () => {},
|
||||
onQueuedRemove: () => () => {},
|
||||
onClose(fn) {
|
||||
if (closed) {
|
||||
fn()
|
||||
return () => {}
|
||||
}
|
||||
|
||||
closes.add(fn)
|
||||
return () => {
|
||||
closes.delete(fn)
|
||||
}
|
||||
},
|
||||
event(value) {
|
||||
events.push(value)
|
||||
},
|
||||
append() {},
|
||||
idle() {
|
||||
return Promise.resolve()
|
||||
},
|
||||
close() {
|
||||
if (closed) {
|
||||
return
|
||||
}
|
||||
|
||||
closed = true
|
||||
notify()
|
||||
},
|
||||
destroy() {
|
||||
if (closed) {
|
||||
return
|
||||
}
|
||||
|
||||
closed = true
|
||||
notify()
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
afterEach(() => {
|
||||
mock.restore()
|
||||
transportProviders.length = 0
|
||||
})
|
||||
|
||||
describe("run interactive runtime", () => {
|
||||
test("leaves host terminal cleanup to the caller when startup fails before renderer creation", async () => {
|
||||
const sdk = OpenCode.make({ baseUrl: "https://opencode.test" })
|
||||
const inputHost = host()
|
||||
let cleaned = 0
|
||||
inputHost.terminal.cleanup = () => {
|
||||
cleaned++
|
||||
}
|
||||
inputHost.preferences.resolveVariant = async () => {
|
||||
throw new Error("preference failed")
|
||||
}
|
||||
|
||||
await expect(
|
||||
runMiniFrontend({
|
||||
host: inputHost,
|
||||
sdk,
|
||||
directory: "/tmp",
|
||||
resolveAgent: async () => "build",
|
||||
session: async () => ({ id: "ses-never" }),
|
||||
agent: "build",
|
||||
model: undefined,
|
||||
variant: undefined,
|
||||
files: [],
|
||||
thinking: false,
|
||||
}),
|
||||
).rejects.toThrow("preference failed")
|
||||
expect(cleaned).toBe(0)
|
||||
})
|
||||
|
||||
test("resolves the deferred session only after first paint", async () => {
|
||||
const sdk = OpenCode.make({ baseUrl: "https://opencode.test" })
|
||||
const lifecycleStarted = defer<void>()
|
||||
const painted = defer<void>()
|
||||
const api = footer()
|
||||
let resolved = 0
|
||||
api.idle = () => painted.promise
|
||||
spyOn(sdk.provider, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.model, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.agent, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.reference, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.command, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.skill, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
|
||||
const task = runInteractiveDeferredMode(
|
||||
{
|
||||
host: host(),
|
||||
sdk,
|
||||
directory: "/tmp",
|
||||
resolveAgent: async () => "build",
|
||||
session: async () => {
|
||||
resolved++
|
||||
api.close()
|
||||
return { id: "ses-deferred", title: "Deferred" }
|
||||
},
|
||||
agent: "build",
|
||||
model: { providerID: "openai", modelID: "gpt-5" },
|
||||
variant: undefined,
|
||||
files: [],
|
||||
thinking: false,
|
||||
},
|
||||
{
|
||||
createRuntimeLifecycle: async () => {
|
||||
lifecycleStarted.resolve()
|
||||
return {
|
||||
footer: api,
|
||||
onResize: () => () => {},
|
||||
refreshTheme: () => {},
|
||||
resetForReplay: () => Promise.resolve(),
|
||||
close: () => Promise.resolve(),
|
||||
}
|
||||
},
|
||||
},
|
||||
)
|
||||
|
||||
await lifecycleStarted.promise
|
||||
expect(resolved).toBe(0)
|
||||
painted.resolve()
|
||||
await task
|
||||
expect(resolved).toBe(1)
|
||||
})
|
||||
|
||||
test("restores deferred session history and model after first paint", async () => {
|
||||
const sdk = OpenCode.make({ baseUrl: "https://opencode.test" })
|
||||
const lifecycleStarted = defer<void>()
|
||||
const painted = defer<void>()
|
||||
const events: FooterEvent[] = []
|
||||
const api = footer(events)
|
||||
api.idle = () => painted.promise
|
||||
const event = api.event
|
||||
api.event = (value) => {
|
||||
event(value)
|
||||
if (value.type === "model") api.close()
|
||||
}
|
||||
spyOn(sdk.session, "get").mockImplementation(
|
||||
() =>
|
||||
ok({
|
||||
id: "ses-resume",
|
||||
projectID: "pro-1",
|
||||
title: "Resume",
|
||||
cost: 0,
|
||||
tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
|
||||
time: { created: 1, updated: 1 },
|
||||
location: { directory: "/tmp" },
|
||||
model: { providerID: "openai", id: "gpt-5", variant: "high" },
|
||||
}) as never,
|
||||
)
|
||||
spyOn(sdk.message, "list").mockImplementation(
|
||||
() =>
|
||||
ok({
|
||||
data: [{ id: "msg-user", type: "user", text: "previous prompt", time: { created: 1 } }],
|
||||
cursor: {},
|
||||
}) as never,
|
||||
)
|
||||
spyOn(sdk.provider, "list").mockImplementation(
|
||||
() =>
|
||||
ok({
|
||||
location: { directory: "/tmp" },
|
||||
data: [{ id: "openai", name: "OpenAI", request: { headers: {}, body: {} } }],
|
||||
}) as never,
|
||||
)
|
||||
spyOn(sdk.model, "list").mockImplementation(
|
||||
() =>
|
||||
ok({
|
||||
location: { directory: "/tmp" },
|
||||
data: [
|
||||
{
|
||||
id: "gpt-5",
|
||||
providerID: "openai",
|
||||
name: "Little Frank",
|
||||
capabilities: { tools: true, input: ["text"], output: ["text"] },
|
||||
request: { headers: {}, body: {} },
|
||||
variants: [{ id: "high", settings: {}, headers: {}, body: {} }],
|
||||
time: { released: 1 },
|
||||
cost: [{ input: 0, output: 0, cache: { read: 0, write: 0 } }],
|
||||
status: "active",
|
||||
enabled: true,
|
||||
limit: { context: 128000, output: 8192 },
|
||||
},
|
||||
],
|
||||
}) as never,
|
||||
)
|
||||
spyOn(sdk.agent, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.reference, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.command, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.skill, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
|
||||
const task = runInteractiveDeferredMode(
|
||||
{
|
||||
host: host(),
|
||||
sdk,
|
||||
directory: "/tmp",
|
||||
resolveAgent: async () => "build",
|
||||
session: async () => ({ id: "ses-resume", title: "Resume", resume: true }),
|
||||
agent: "build",
|
||||
model: undefined,
|
||||
variant: undefined,
|
||||
files: [],
|
||||
thinking: false,
|
||||
},
|
||||
{
|
||||
createRuntimeLifecycle: async () => {
|
||||
lifecycleStarted.resolve()
|
||||
return {
|
||||
footer: api,
|
||||
onResize: () => () => {},
|
||||
refreshTheme: () => {},
|
||||
resetForReplay: () => Promise.resolve(),
|
||||
close: () => Promise.resolve(),
|
||||
}
|
||||
},
|
||||
},
|
||||
)
|
||||
|
||||
await lifecycleStarted.promise
|
||||
expect(sdk.session.get).not.toHaveBeenCalled()
|
||||
painted.resolve()
|
||||
await task
|
||||
|
||||
expect(events).toContainEqual({
|
||||
type: "history",
|
||||
history: [{ text: "previous prompt", parts: [] }],
|
||||
})
|
||||
expect(events).toContainEqual({
|
||||
type: "model",
|
||||
model: "Little Frank · OpenAI · high",
|
||||
selection: { providerID: "openai", modelID: "gpt-5" },
|
||||
})
|
||||
})
|
||||
|
||||
test("waits for provider metadata before eager replay transport bootstrap", async () => {
|
||||
const providersStarted = defer<void>()
|
||||
const providers = defer<void>()
|
||||
const lifecycleModels: unknown[] = []
|
||||
|
||||
const sdk = OpenCode.make({ baseUrl: "https://opencode.test" })
|
||||
spyOn(sdk.provider, "list").mockImplementation(async () => {
|
||||
providersStarted.resolve()
|
||||
await providers.promise
|
||||
return ok({
|
||||
location: {
|
||||
directory: "/tmp",
|
||||
},
|
||||
data: [
|
||||
{
|
||||
id: "openai",
|
||||
name: "OpenAI",
|
||||
api: {
|
||||
type: "native",
|
||||
settings: {},
|
||||
},
|
||||
request: {
|
||||
headers: {},
|
||||
body: {},
|
||||
},
|
||||
},
|
||||
],
|
||||
}) as never
|
||||
})
|
||||
spyOn(sdk.model, "list").mockImplementation(
|
||||
() =>
|
||||
ok({
|
||||
location: {
|
||||
directory: "/tmp",
|
||||
},
|
||||
data: [
|
||||
{
|
||||
id: "gpt-5",
|
||||
providerID: "openai",
|
||||
name: "Little Frank",
|
||||
api: {
|
||||
id: "openai",
|
||||
type: "native",
|
||||
settings: {},
|
||||
},
|
||||
capabilities: {
|
||||
tools: true,
|
||||
input: ["text"],
|
||||
output: ["text"],
|
||||
},
|
||||
request: {
|
||||
headers: {},
|
||||
body: {},
|
||||
},
|
||||
variants: [],
|
||||
time: {
|
||||
released: 1,
|
||||
},
|
||||
cost: [
|
||||
{
|
||||
input: 0,
|
||||
output: 0,
|
||||
cache: {
|
||||
read: 0,
|
||||
write: 0,
|
||||
},
|
||||
},
|
||||
],
|
||||
status: "active",
|
||||
enabled: true,
|
||||
limit: {
|
||||
context: 128000,
|
||||
output: 8192,
|
||||
},
|
||||
},
|
||||
],
|
||||
}) as never,
|
||||
)
|
||||
spyOn(sdk.message, "list").mockImplementation(() =>
|
||||
ok({
|
||||
data: [
|
||||
{
|
||||
id: "msg-user-1",
|
||||
type: "user",
|
||||
text: "hello",
|
||||
time: {
|
||||
created: 1,
|
||||
},
|
||||
},
|
||||
],
|
||||
cursor: {},
|
||||
}),
|
||||
)
|
||||
spyOn(sdk.session, "get").mockImplementation(
|
||||
() =>
|
||||
ok({
|
||||
id: "ses-1",
|
||||
projectID: "pro-1",
|
||||
title: "Session",
|
||||
cost: 0,
|
||||
tokens: {
|
||||
input: 0,
|
||||
output: 0,
|
||||
reasoning: 0,
|
||||
cache: {
|
||||
read: 0,
|
||||
write: 0,
|
||||
},
|
||||
},
|
||||
time: {
|
||||
created: 1,
|
||||
updated: 1,
|
||||
},
|
||||
location: {
|
||||
directory: "/tmp",
|
||||
},
|
||||
model: {
|
||||
providerID: "openai",
|
||||
id: "gpt-5",
|
||||
},
|
||||
}) as never,
|
||||
)
|
||||
spyOn(sdk.agent, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.reference, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.command, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.skill, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
|
||||
const task = runInteractiveMode(
|
||||
{
|
||||
host: host(),
|
||||
sdk,
|
||||
directory: "/tmp",
|
||||
sessionID: "ses-1",
|
||||
sessionTitle: "Session",
|
||||
resume: true,
|
||||
replay: true,
|
||||
replayLimit: 100,
|
||||
agent: "build",
|
||||
model: undefined,
|
||||
variant: undefined,
|
||||
files: [],
|
||||
thinking: true,
|
||||
},
|
||||
{
|
||||
createRuntimeLifecycle: async (input) => {
|
||||
lifecycleModels.push(input.model)
|
||||
return {
|
||||
footer: footer(),
|
||||
onResize: () => () => {},
|
||||
refreshTheme: () => {},
|
||||
resetForReplay: () => Promise.resolve(),
|
||||
close: () => Promise.resolve(),
|
||||
}
|
||||
},
|
||||
streamTransport: Promise.resolve({
|
||||
createSessionTransport: async (input: { providers?: () => RunProvider[]; footer: FooterApi }) => {
|
||||
transportProviders.push(input.providers?.() ?? [])
|
||||
setTimeout(() => {
|
||||
input.footer.close()
|
||||
}, 0)
|
||||
return {
|
||||
runPromptTurn: async () => {},
|
||||
interruptActiveTurn: async () => {},
|
||||
selectSubagent: () => {},
|
||||
replayOnResize: async () => false,
|
||||
close: async () => {},
|
||||
}
|
||||
},
|
||||
formatUnknownError: (error: unknown) => (error instanceof Error ? error.message : String(error)),
|
||||
}),
|
||||
},
|
||||
)
|
||||
|
||||
await providersStarted.promise
|
||||
|
||||
expect(transportProviders).toEqual([])
|
||||
|
||||
providers.resolve()
|
||||
|
||||
await task
|
||||
|
||||
expect(lifecycleModels).toEqual([{ providerID: "openai", modelID: "gpt-5" }])
|
||||
expect(transportProviders).toEqual([[provider]])
|
||||
})
|
||||
|
||||
test("defers catalog-selected model resolution until after first paint", async () => {
|
||||
const sdk = OpenCode.make({ baseUrl: "https://opencode.test" })
|
||||
const defaultStarted = defer<void>()
|
||||
const releaseDefault = defer<void>()
|
||||
const lifecycleStarted = defer<void>()
|
||||
const painted = defer<void>()
|
||||
const modelShown = defer<void>()
|
||||
let defaultRequested = false
|
||||
const events: FooterEvent[] = []
|
||||
const api = footer(events)
|
||||
api.idle = () => painted.promise
|
||||
const event = api.event
|
||||
api.event = (value) => {
|
||||
event(value)
|
||||
if (value.type !== "model") return
|
||||
modelShown.resolve()
|
||||
api.close()
|
||||
}
|
||||
|
||||
spyOn(sdk.model, "default").mockImplementation(async () => {
|
||||
defaultRequested = true
|
||||
defaultStarted.resolve()
|
||||
await releaseDefault.promise
|
||||
return ok({
|
||||
location: { directory: "/tmp" },
|
||||
data: { id: "catalog-default-test-model", providerID: "openai" },
|
||||
}) as never
|
||||
})
|
||||
spyOn(sdk.provider, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.model, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.agent, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.reference, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.command, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
spyOn(sdk.skill, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
|
||||
const task = runInteractiveMode(
|
||||
{
|
||||
host: host(),
|
||||
sdk,
|
||||
directory: "/tmp",
|
||||
sessionID: "ses-fresh",
|
||||
resume: false,
|
||||
agent: "build",
|
||||
model: undefined,
|
||||
variant: undefined,
|
||||
files: [],
|
||||
thinking: false,
|
||||
},
|
||||
{
|
||||
createRuntimeLifecycle: async (input) => {
|
||||
expect(input.model).toBeUndefined()
|
||||
lifecycleStarted.resolve()
|
||||
return {
|
||||
footer: api,
|
||||
onResize: () => () => {},
|
||||
refreshTheme: () => {},
|
||||
resetForReplay: () => Promise.resolve(),
|
||||
close: () => Promise.resolve(),
|
||||
}
|
||||
},
|
||||
streamTransport: Promise.resolve({
|
||||
createSessionTransport: async () => ({
|
||||
runPromptTurn: async () => {},
|
||||
interruptActiveTurn: async () => {},
|
||||
selectSubagent: () => {},
|
||||
replayOnResize: async () => false,
|
||||
close: async () => {},
|
||||
}),
|
||||
formatUnknownError: (error: unknown) => (error instanceof Error ? error.message : String(error)),
|
||||
}),
|
||||
},
|
||||
)
|
||||
|
||||
await lifecycleStarted.promise
|
||||
expect(defaultRequested).toBe(false)
|
||||
painted.resolve()
|
||||
await defaultStarted.promise
|
||||
releaseDefault.resolve()
|
||||
await modelShown.promise
|
||||
await task
|
||||
|
||||
expect(events.find((event) => event.type === "model")).toEqual({
|
||||
type: "model",
|
||||
model: "catalog-default-test-model · openai",
|
||||
selection: { providerID: "openai", modelID: "catalog-default-test-model" },
|
||||
})
|
||||
})
|
||||
|
||||
test("does not start deferred work after the footer closes", async () => {
|
||||
const sdk = OpenCode.make({ baseUrl: "https://opencode.test" })
|
||||
const lifecycleStarted = defer<void>()
|
||||
const painted = defer<void>()
|
||||
const api = footer()
|
||||
api.idle = () => painted.promise
|
||||
const defaultModel = spyOn(sdk.model, "default")
|
||||
|
||||
const task = runInteractiveMode(
|
||||
{
|
||||
host: host(),
|
||||
sdk,
|
||||
directory: "/tmp",
|
||||
sessionID: "ses-closed",
|
||||
resume: false,
|
||||
agent: "build",
|
||||
model: undefined,
|
||||
variant: undefined,
|
||||
files: [],
|
||||
thinking: false,
|
||||
},
|
||||
{
|
||||
createRuntimeLifecycle: async () => {
|
||||
lifecycleStarted.resolve()
|
||||
return {
|
||||
footer: api,
|
||||
onResize: () => () => {},
|
||||
refreshTheme: () => {},
|
||||
resetForReplay: () => Promise.resolve(),
|
||||
close: () => Promise.resolve(),
|
||||
}
|
||||
},
|
||||
},
|
||||
)
|
||||
|
||||
await lifecycleStarted.promise
|
||||
api.close()
|
||||
painted.resolve()
|
||||
await task
|
||||
|
||||
expect(defaultModel).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
test("searches files through the V2 file API", async () => {
|
||||
const sdk = OpenCode.make({ baseUrl: "https://opencode.test" })
|
||||
const api = footer()
|
||||
const find = spyOn(sdk.file, "find").mockImplementation(
|
||||
() =>
|
||||
ok({
|
||||
location: { directory: "/tmp", project: { id: "proj_1", directory: "/tmp" } },
|
||||
data: [{ path: "src/index.ts", type: "file" }],
|
||||
}) as never,
|
||||
)
|
||||
|
||||
await runInteractiveMode(
|
||||
{
|
||||
host: host(),
|
||||
sdk,
|
||||
directory: "/tmp",
|
||||
sessionID: "ses-files",
|
||||
resume: false,
|
||||
agent: "build",
|
||||
model: undefined,
|
||||
variant: undefined,
|
||||
files: [],
|
||||
thinking: false,
|
||||
},
|
||||
{
|
||||
createRuntimeLifecycle: async (input) => {
|
||||
await expect(input.findFiles("index")).resolves.toEqual(["src/index.ts"])
|
||||
api.close()
|
||||
return {
|
||||
footer: api,
|
||||
onResize: () => () => {},
|
||||
refreshTheme: () => {},
|
||||
resetForReplay: () => Promise.resolve(),
|
||||
close: () => Promise.resolve(),
|
||||
}
|
||||
},
|
||||
},
|
||||
)
|
||||
|
||||
expect(find).toHaveBeenCalledWith({ query: "index", type: "file", location: { directory: "/tmp" } })
|
||||
})
|
||||
|
||||
test.skip("retains last-known-good state across failed coalesced refreshes and retries later", async () => {
|
||||
const sdk = OpenCode.make({ baseUrl: "https://opencode.test" })
|
||||
const refreshGate = defer<void>()
|
||||
let providerCalls = 0
|
||||
let modelCalls = 0
|
||||
let agentCalls = 0
|
||||
let referenceCalls = 0
|
||||
const events: FooterEvent[] = []
|
||||
const api = footer(events)
|
||||
spyOn(sdk.provider, "list").mockImplementation(async () => {
|
||||
providerCalls++
|
||||
if (providerCalls === 2) {
|
||||
await refreshGate.promise
|
||||
throw new Error("provider refresh failed")
|
||||
}
|
||||
return ok({
|
||||
location: { directory: "/tmp" },
|
||||
data: [
|
||||
{
|
||||
id: "openai",
|
||||
name: providerCalls >= 3 ? "OpenAI refreshed" : "OpenAI",
|
||||
api: { type: "native", settings: {} },
|
||||
request: { headers: {}, body: {} },
|
||||
},
|
||||
],
|
||||
}) as never
|
||||
})
|
||||
spyOn(sdk.model, "list").mockImplementation(() => {
|
||||
modelCalls++
|
||||
return ok({
|
||||
location: { directory: "/tmp" },
|
||||
data: [
|
||||
{
|
||||
id: "gpt-5",
|
||||
providerID: "openai",
|
||||
name: "Little Frank",
|
||||
api: { id: "openai", type: "native", settings: {} },
|
||||
capabilities: { tools: true, input: ["text"], output: ["text"] },
|
||||
request: { headers: {}, body: {} },
|
||||
variants:
|
||||
modelCalls >= 4 ? [] : [{ id: modelCalls >= 3 ? "high" : "low", settings: {}, headers: {}, body: {} }],
|
||||
time: { released: 1 },
|
||||
cost: [{ input: 0, output: 0, cache: { read: 0, write: 0 } }],
|
||||
status: "active",
|
||||
enabled: true,
|
||||
limit: { context: modelCalls >= 3 ? 256000 : 128000, output: 8192 },
|
||||
},
|
||||
],
|
||||
}) as never
|
||||
})
|
||||
spyOn(sdk.agent, "list").mockImplementation(async () => {
|
||||
agentCalls++
|
||||
if (agentCalls === 2) throw new Error("agent refresh failed")
|
||||
return ok({
|
||||
location: { directory: "/tmp" },
|
||||
data: [{ id: "build", description: agentCalls >= 3 ? "Refreshed agent" : "Agent", mode: "primary" }],
|
||||
}) as never
|
||||
})
|
||||
spyOn(sdk.reference, "list").mockImplementation(() => {
|
||||
referenceCalls++
|
||||
return ok({
|
||||
location: { directory: "/tmp" },
|
||||
data: [
|
||||
{ name: "effect", path: "/effect", description: referenceCalls >= 3 ? "Refreshed reference" : "Reference" },
|
||||
],
|
||||
}) as never
|
||||
})
|
||||
spyOn(sdk.command, "list").mockImplementation(
|
||||
() => ok({ location: { directory: "/tmp" }, data: [{ name: "check", description: "Check" }] }) as never,
|
||||
)
|
||||
spyOn(sdk.skill, "list").mockImplementation(() => ok({ location: { directory: "/tmp" }, data: [] }) as never)
|
||||
let finalProviders: RunProvider[] = []
|
||||
let finalLimits: Record<string, number> = {}
|
||||
let retainedProviders: RunProvider[] = []
|
||||
let retainedLimits: Record<string, number> = {}
|
||||
let retainedCatalog: FooterEvent | undefined
|
||||
let selectedDefault: unknown
|
||||
let selectDefault: (() => unknown) | undefined
|
||||
let selectVariant: ((variant: string | undefined) => unknown) | undefined
|
||||
let defaultRefreshVariants: FooterEvent | undefined
|
||||
|
||||
await runInteractiveMode(
|
||||
{
|
||||
host: host(),
|
||||
sdk,
|
||||
directory: "/tmp",
|
||||
sessionID: "ses-1",
|
||||
sessionTitle: "Session",
|
||||
resume: false,
|
||||
agent: "build",
|
||||
model: { providerID: "openai", modelID: "gpt-5" },
|
||||
variant: "low",
|
||||
files: [],
|
||||
thinking: false,
|
||||
},
|
||||
{
|
||||
createRuntimeLifecycle: async (input) => {
|
||||
selectDefault = () => input.onVariantSelect?.(undefined)
|
||||
selectVariant = (variant) => input.onVariantSelect?.(variant)
|
||||
return {
|
||||
footer: api,
|
||||
onResize: () => () => {},
|
||||
refreshTheme: () => {},
|
||||
resetForReplay: () => Promise.resolve(),
|
||||
close: () => Promise.resolve(),
|
||||
}
|
||||
},
|
||||
streamTransport: Promise.resolve({
|
||||
createSessionTransport: async (input) => {
|
||||
while (
|
||||
!events.some(
|
||||
(event) => event.type === "variants" && event.variants.includes("low") && event.current === "low",
|
||||
)
|
||||
)
|
||||
await Bun.sleep(0)
|
||||
selectedDefault = await Promise.resolve(selectDefault?.())
|
||||
input.onCatalogRefresh?.()
|
||||
input.onCatalogRefresh?.()
|
||||
input.onCatalogRefresh?.()
|
||||
while (providerCalls < 2) await Bun.sleep(0)
|
||||
refreshGate.resolve()
|
||||
await new Promise((resolve) => setTimeout(resolve, 0))
|
||||
retainedProviders = input.providers?.() ?? []
|
||||
retainedLimits = input.limits()
|
||||
retainedCatalog = events.filter((event) => event.type === "catalog").at(-1)
|
||||
input.onCatalogRefresh?.()
|
||||
input.onCatalogRefresh?.()
|
||||
while (providerCalls < 3 || modelCalls < 3 || agentCalls < 3) await Bun.sleep(0)
|
||||
await new Promise((resolve) => setTimeout(resolve, 0))
|
||||
defaultRefreshVariants = events.filter((event) => event.type === "variants").at(-1)
|
||||
await Promise.resolve(selectVariant?.("high"))
|
||||
input.onCatalogRefresh?.()
|
||||
while (providerCalls < 4 || modelCalls < 4) await Bun.sleep(0)
|
||||
await new Promise((resolve) => setTimeout(resolve, 0))
|
||||
finalProviders = input.providers?.() ?? []
|
||||
finalLimits = input.limits()
|
||||
setTimeout(() => input.footer.close(), 0)
|
||||
return {
|
||||
runPromptTurn: async () => {},
|
||||
interruptActiveTurn: async () => {},
|
||||
selectSubagent: () => {},
|
||||
replayOnResize: async () => false,
|
||||
close: async () => {},
|
||||
}
|
||||
},
|
||||
formatUnknownError: (error: unknown) => (error instanceof Error ? error.message : String(error)),
|
||||
}),
|
||||
},
|
||||
)
|
||||
|
||||
expect(providerCalls).toBe(4)
|
||||
expect(modelCalls).toBe(4)
|
||||
expect(retainedProviders[0]?.name).toBe("OpenAI")
|
||||
expect(retainedProviders[0]?.models["gpt-5"]?.variants).toEqual({ low: {} })
|
||||
expect(retainedLimits["openai/gpt-5"]).toBe(128000)
|
||||
expect(retainedCatalog).toMatchObject({
|
||||
agents: [{ name: "build", description: "Agent" }],
|
||||
references: [{ name: "effect", description: "Reference" }],
|
||||
})
|
||||
expect(selectedDefault).toMatchObject({ variant: undefined })
|
||||
expect(defaultRefreshVariants).toMatchObject({ variants: ["high"], current: undefined })
|
||||
expect(finalProviders[0]?.name).toBe("OpenAI refreshed")
|
||||
expect(finalProviders[0]?.models["gpt-5"]?.variants).toEqual({})
|
||||
expect(finalLimits["openai/gpt-5"]).toBe(256000)
|
||||
expect(events.filter((event) => event.type === "variants").at(-1)).toMatchObject({
|
||||
variants: [],
|
||||
current: undefined,
|
||||
})
|
||||
expect(events.filter((event) => event.type === "catalog").at(-1)).toMatchObject({
|
||||
agents: [{ name: "build", description: "Refreshed agent" }],
|
||||
references: [{ name: "effect", description: "Refreshed reference" }],
|
||||
commands: [{ name: "check", description: "Check" }],
|
||||
})
|
||||
})
|
||||
})
|
||||
1049
packages/tui/test/mini/scrollback.surface.test.ts
Normal file
1049
packages/tui/test/mini/scrollback.surface.test.ts
Normal file
File diff suppressed because it is too large
Load diff
217
packages/tui/test/mini/session.shared.test.ts
Normal file
217
packages/tui/test/mini/session.shared.test.ts
Normal file
|
|
@ -0,0 +1,217 @@
|
|||
import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
|
||||
import { OpenCode, type SessionMessageUser } from "@opencode-ai/client/promise"
|
||||
import {
|
||||
createSession,
|
||||
resolveCurrentSession,
|
||||
sessionHistory,
|
||||
sessionVariant,
|
||||
type RunSession,
|
||||
type SessionMessages,
|
||||
} from "../../src/mini/session.shared"
|
||||
|
||||
const model = {
|
||||
providerID: "openai",
|
||||
modelID: "gpt-5",
|
||||
}
|
||||
|
||||
afterEach(() => {
|
||||
mock.restore()
|
||||
})
|
||||
|
||||
function userMessage(id: string, text: string, input: Partial<SessionMessageUser> = {}): SessionMessageUser {
|
||||
return {
|
||||
id,
|
||||
type: "user",
|
||||
text,
|
||||
time: { created: 1 },
|
||||
...input,
|
||||
}
|
||||
}
|
||||
|
||||
describe("run session shared", () => {
|
||||
test("builds user prompts from projected text and attachments", () => {
|
||||
const msgs: SessionMessages = [
|
||||
userMessage("msg-user-1", "look @scan @note.ts", {
|
||||
agents: [{ name: "scan", mention: { start: 5, end: 10, text: "@scan" } }],
|
||||
files: [
|
||||
{
|
||||
data: "",
|
||||
mime: "text/plain",
|
||||
source: { type: "uri", uri: "file:///tmp/note.ts" },
|
||||
mention: { start: 11, end: 19, text: "@note.ts" },
|
||||
},
|
||||
],
|
||||
}),
|
||||
]
|
||||
|
||||
const out = createSession(msgs)
|
||||
expect(out.first).toBe(false)
|
||||
expect(out.turns).toHaveLength(1)
|
||||
expect(out.turns[0]?.prompt.text).toBe("look @scan @note.ts")
|
||||
expect(out.turns[0]?.prompt.parts).toEqual([
|
||||
{
|
||||
type: "file",
|
||||
mime: "text/plain",
|
||||
filename: undefined,
|
||||
url: "file:///tmp/note.ts",
|
||||
source: {
|
||||
type: "file",
|
||||
path: "file:///tmp/note.ts",
|
||||
text: {
|
||||
start: 11,
|
||||
end: 19,
|
||||
value: "@note.ts",
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
type: "agent",
|
||||
name: "scan",
|
||||
source: {
|
||||
start: 5,
|
||||
end: 10,
|
||||
value: "@scan",
|
||||
},
|
||||
},
|
||||
])
|
||||
})
|
||||
|
||||
test("leaves attachment sources undefined when projected mentions are absent", () => {
|
||||
const out = createSession([
|
||||
userMessage("msg-user-1", "look @scan @note.ts", {
|
||||
agents: [{ name: "scan" }],
|
||||
files: [{ data: "", mime: "text/plain", source: { type: "uri", uri: "file:///tmp/note.ts" } }],
|
||||
}),
|
||||
])
|
||||
|
||||
expect(out.turns[0]?.prompt).toEqual({
|
||||
text: "look @scan @note.ts",
|
||||
parts: [
|
||||
{
|
||||
type: "file",
|
||||
mime: "text/plain",
|
||||
filename: undefined,
|
||||
url: "file:///tmp/note.ts",
|
||||
source: undefined,
|
||||
},
|
||||
{
|
||||
type: "agent",
|
||||
name: "scan",
|
||||
source: undefined,
|
||||
},
|
||||
],
|
||||
})
|
||||
})
|
||||
|
||||
test("dedupes consecutive history entries, drops blanks, and copies prompt parts", () => {
|
||||
const parts = [
|
||||
{
|
||||
type: "agent" as const,
|
||||
name: "scan",
|
||||
source: {
|
||||
start: 0,
|
||||
end: 5,
|
||||
value: "@scan",
|
||||
},
|
||||
},
|
||||
]
|
||||
const session: RunSession = {
|
||||
first: false,
|
||||
turns: [
|
||||
{ prompt: { text: "one", parts }, provider: "openai", model: "gpt-5", variant: "high" },
|
||||
{ prompt: { text: "one", parts: structuredClone(parts) }, provider: "openai", model: "gpt-5", variant: "high" },
|
||||
{ prompt: { text: " ", parts: [] }, provider: "openai", model: "gpt-5", variant: "high" },
|
||||
{ prompt: { text: "two", parts: [] }, provider: "openai", model: "gpt-5", variant: undefined },
|
||||
],
|
||||
}
|
||||
|
||||
const out = sessionHistory(session)
|
||||
|
||||
expect(out.map((item) => item.text)).toEqual(["one", "two"])
|
||||
expect(out[0]?.parts).toEqual(parts)
|
||||
expect(out[0]?.parts).not.toBe(parts)
|
||||
expect(out[0]?.parts[0]).not.toBe(parts[0])
|
||||
})
|
||||
|
||||
test("returns the latest matching variant for the active model", () => {
|
||||
const session: RunSession = {
|
||||
first: false,
|
||||
turns: [
|
||||
{ prompt: { text: "one", parts: [] }, provider: "openai", model: "gpt-5", variant: "high" },
|
||||
{ prompt: { text: "two", parts: [] }, provider: "anthropic", model: "sonnet", variant: "max" },
|
||||
{ prompt: { text: "three", parts: [] }, provider: "openai", model: "gpt-5", variant: undefined },
|
||||
],
|
||||
}
|
||||
|
||||
expect(sessionVariant(session, model)).toBeUndefined()
|
||||
|
||||
session.turns.push({
|
||||
prompt: { text: "four", parts: [] },
|
||||
provider: "openai",
|
||||
model: "gpt-5",
|
||||
variant: "minimal",
|
||||
})
|
||||
|
||||
expect(sessionVariant(session, model)).toBe("minimal")
|
||||
})
|
||||
|
||||
test("restores current prompt history from stored text and file references", async () => {
|
||||
const client = OpenCode.make({ baseUrl: "https://opencode.test" })
|
||||
spyOn(client.message, "list").mockImplementation(() =>
|
||||
Promise.resolve({
|
||||
data: [
|
||||
{
|
||||
id: "msg_prompt",
|
||||
type: "user",
|
||||
text: "Review @note.ts",
|
||||
files: [
|
||||
{
|
||||
data: "",
|
||||
mime: "text/plain",
|
||||
name: "note.ts",
|
||||
source: { type: "uri", uri: "file:///tmp/note.ts" },
|
||||
mention: { start: 7, end: 15, text: "@note.ts" },
|
||||
},
|
||||
],
|
||||
agents: [],
|
||||
time: { created: 1 },
|
||||
},
|
||||
],
|
||||
cursor: {},
|
||||
}),
|
||||
)
|
||||
spyOn(client.session, "get").mockImplementation(() =>
|
||||
Promise.resolve({
|
||||
id: "ses_1",
|
||||
title: "Session",
|
||||
projectID: "proj_1",
|
||||
location: { directory: "/tmp" },
|
||||
time: { created: 1, updated: 1 },
|
||||
cost: 0,
|
||||
tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
|
||||
model: { providerID: "openai", id: "gpt-5", variant: "high" },
|
||||
}),
|
||||
)
|
||||
|
||||
const out = await resolveCurrentSession(client, "ses_1")
|
||||
|
||||
expect(out.model).toEqual({ providerID: "openai", modelID: "gpt-5" })
|
||||
expect(out.variant).toBe("high")
|
||||
expect(out.turns[0]?.prompt).toEqual({
|
||||
text: "Review @note.ts",
|
||||
parts: [
|
||||
{
|
||||
type: "file",
|
||||
url: "file:///tmp/note.ts",
|
||||
mime: "text/plain",
|
||||
filename: "note.ts",
|
||||
source: {
|
||||
type: "file",
|
||||
path: "note.ts",
|
||||
text: { start: 7, end: 15, value: "@note.ts" },
|
||||
},
|
||||
},
|
||||
],
|
||||
})
|
||||
})
|
||||
})
|
||||
2805
packages/tui/test/mini/stream-v2.transport.test.ts
Normal file
2805
packages/tui/test/mini/stream-v2.transport.test.ts
Normal file
File diff suppressed because it is too large
Load diff
56
packages/tui/test/mini/stream.test.ts
Normal file
56
packages/tui/test/mini/stream.test.ts
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
import { describe, expect, test } from "bun:test"
|
||||
import { writeSessionOutput } from "../../src/mini/stream"
|
||||
import type { FooterApi, FooterEvent, StreamCommit } from "../../src/mini/types"
|
||||
|
||||
function footer() {
|
||||
const events: FooterEvent[] = []
|
||||
const commits: StreamCommit[] = []
|
||||
|
||||
const api: FooterApi = {
|
||||
isClosed: false,
|
||||
onPrompt: () => () => {},
|
||||
onQueuedRemove: () => () => {},
|
||||
onClose: () => () => {},
|
||||
event: (next) => {
|
||||
events.push(next)
|
||||
},
|
||||
append: (next) => {
|
||||
commits.push(next)
|
||||
},
|
||||
idle: () => Promise.resolve(),
|
||||
close: () => {},
|
||||
destroy: () => {},
|
||||
}
|
||||
|
||||
return { api, events, commits }
|
||||
}
|
||||
|
||||
describe("run stream bridge", () => {
|
||||
test("defaults status patches to running phase", () => {
|
||||
const out = footer()
|
||||
|
||||
writeSessionOutput(
|
||||
{
|
||||
footer: out.api,
|
||||
},
|
||||
{
|
||||
commits: [],
|
||||
footer: {
|
||||
patch: {
|
||||
status: "assistant responding",
|
||||
},
|
||||
},
|
||||
},
|
||||
)
|
||||
|
||||
expect(out.events).toEqual([
|
||||
{
|
||||
type: "stream.patch",
|
||||
patch: {
|
||||
phase: "running",
|
||||
status: "assistant responding",
|
||||
},
|
||||
},
|
||||
])
|
||||
})
|
||||
})
|
||||
169
packages/tui/test/mini/theme.test.ts
Normal file
169
packages/tui/test/mini/theme.test.ts
Normal file
|
|
@ -0,0 +1,169 @@
|
|||
import { expect, test } from "bun:test"
|
||||
import { RGBA, type CliRenderer, type TerminalColors } from "@opentui/core"
|
||||
import { RUN_THEME_FALLBACK, generateSystem, resolveRunTheme, resolveTheme } from "../../src/mini/theme"
|
||||
|
||||
const palette = ["#15161e", "#f7768e", "#9ece6a", "#e0af68", "#7aa2f7", "#bb9af7", "#7dcfff", "#c0caf5"] as const
|
||||
|
||||
function terminalColors(input: Partial<TerminalColors> = {}): TerminalColors {
|
||||
return {
|
||||
palette: Array.from({ length: 256 }, (_, index) => input.palette?.[index] ?? palette[index % palette.length]!),
|
||||
defaultBackground: input.defaultBackground ?? "#1a1b26",
|
||||
defaultForeground: input.defaultForeground ?? "#c0caf5",
|
||||
cursorColor: input.cursorColor ?? "#ff9e64",
|
||||
mouseForeground: input.mouseForeground ?? null,
|
||||
mouseBackground: input.mouseBackground ?? null,
|
||||
tekForeground: input.tekForeground ?? null,
|
||||
tekBackground: input.tekBackground ?? null,
|
||||
highlightBackground: input.highlightBackground ?? "#33467c",
|
||||
highlightForeground: input.highlightForeground ?? "#c0caf5",
|
||||
}
|
||||
}
|
||||
|
||||
function renderer(
|
||||
input: {
|
||||
themeMode?: "dark" | "light"
|
||||
colors?: TerminalColors
|
||||
fail?: boolean
|
||||
} = {},
|
||||
) {
|
||||
return {
|
||||
themeMode: input.themeMode,
|
||||
getPalette: async () => {
|
||||
if (input.fail) {
|
||||
throw new Error("boom")
|
||||
}
|
||||
|
||||
return input.colors ?? terminalColors()
|
||||
},
|
||||
} as CliRenderer
|
||||
}
|
||||
|
||||
function expectRgba(color: unknown) {
|
||||
expect(color).toBeInstanceOf(RGBA)
|
||||
if (!(color instanceof RGBA)) {
|
||||
throw new Error("expected RGBA")
|
||||
}
|
||||
|
||||
return color
|
||||
}
|
||||
|
||||
function expectIndexed(color: unknown) {
|
||||
const rgba = expectRgba(color)
|
||||
expect(rgba.intent).toBe("indexed")
|
||||
expect(rgba.slot).toBeLessThan(256)
|
||||
}
|
||||
|
||||
function spread(color: RGBA) {
|
||||
const [r, g, b] = color.toInts()
|
||||
return Math.max(r, g, b) - Math.min(r, g, b)
|
||||
}
|
||||
|
||||
test("falls back when palette lookup fails", async () => {
|
||||
expect(await resolveRunTheme(renderer({ fail: true }))).toBe(RUN_THEME_FALLBACK)
|
||||
})
|
||||
|
||||
test("returns syntax styles and indexed splash colors", async () => {
|
||||
const theme = await resolveRunTheme(renderer({ themeMode: "dark" }))
|
||||
|
||||
try {
|
||||
expect(theme.block.syntax).toBeDefined()
|
||||
expect([...theme.block.syntax!.getAllStyles()].length).toBeGreaterThan(0)
|
||||
expectIndexed(theme.splash.left)
|
||||
expectIndexed(theme.splash.right)
|
||||
expectIndexed(theme.splash.leftShadow)
|
||||
expectIndexed(theme.splash.rightShadow)
|
||||
expectIndexed(theme.block.highlight)
|
||||
expectIndexed(theme.block.warning)
|
||||
expectRgba(theme.footer.highlight)
|
||||
expectRgba(theme.footer.statusAccent)
|
||||
expectRgba(theme.footer.surface)
|
||||
expect(expectRgba(theme.footer.statusAccent).toInts()).not.toEqual(expectRgba(theme.footer.status).toInts())
|
||||
} finally {
|
||||
theme.block.syntax?.destroy()
|
||||
}
|
||||
})
|
||||
|
||||
test("keeps footer surfaces exact while scrollback stays palette matched", async () => {
|
||||
const colors = terminalColors({
|
||||
defaultBackground: "#0f172a",
|
||||
defaultForeground: "#e2e8f0",
|
||||
})
|
||||
const theme = await resolveRunTheme(renderer({ themeMode: "dark", colors }))
|
||||
const exact = resolveTheme(generateSystem(colors, "dark"), "dark")
|
||||
|
||||
try {
|
||||
expect(expectRgba(theme.footer.selected).toInts()).toEqual(expectRgba(exact.backgroundElement).toInts())
|
||||
expect(expectRgba(theme.footer.border).toInts()).toEqual(expectRgba(exact.border).toInts())
|
||||
expect(expectRgba(theme.footer.pane).toInts()).toEqual(expectRgba(exact.backgroundMenu).toInts())
|
||||
expect(expectRgba(theme.footer.selected).intent).toBe("rgb")
|
||||
expectIndexed(theme.block.highlight)
|
||||
expectIndexed(theme.block.warning)
|
||||
} finally {
|
||||
theme.block.syntax?.destroy()
|
||||
}
|
||||
})
|
||||
|
||||
test("uses refreshed background brightness when cached renderer mode is stale", async () => {
|
||||
const colors = terminalColors({
|
||||
defaultBackground: "#fbf1c7",
|
||||
defaultForeground: "#3c3836",
|
||||
})
|
||||
const stale = await resolveRunTheme(renderer({ themeMode: "dark", colors }))
|
||||
const light = await resolveRunTheme(renderer({ themeMode: "light", colors }))
|
||||
|
||||
try {
|
||||
expect(expectRgba(stale.footer.surface).toInts()).toEqual(expectRgba(light.footer.surface).toInts())
|
||||
} finally {
|
||||
stale.block.syntax?.destroy()
|
||||
light.block.syntax?.destroy()
|
||||
}
|
||||
})
|
||||
|
||||
test("keeps renderer mode when refreshed default background is unavailable", async () => {
|
||||
const colors = {
|
||||
...terminalColors(),
|
||||
defaultBackground: null,
|
||||
palette: ["#000000", ...terminalColors().palette.slice(1)],
|
||||
}
|
||||
const light = await resolveRunTheme(renderer({ themeMode: "light", colors }))
|
||||
const dark = await resolveRunTheme(renderer({ themeMode: "dark", colors }))
|
||||
|
||||
try {
|
||||
expect(expectRgba(light.footer.surface).toInts()).not.toEqual(expectRgba(dark.footer.surface).toInts())
|
||||
} finally {
|
||||
light.block.syntax?.destroy()
|
||||
dark.block.syntax?.destroy()
|
||||
}
|
||||
})
|
||||
|
||||
test("keeps dark surfaces neutral on saturated backgrounds", () => {
|
||||
const theme = resolveTheme(
|
||||
generateSystem(
|
||||
terminalColors({
|
||||
defaultBackground: "#0000ff",
|
||||
defaultForeground: "#ffffff",
|
||||
}),
|
||||
"dark",
|
||||
),
|
||||
"dark",
|
||||
)
|
||||
|
||||
expect(spread(theme.backgroundPanel)).toBeLessThan(10)
|
||||
expect(spread(theme.backgroundElement)).toBeLessThan(10)
|
||||
})
|
||||
|
||||
test("keeps light surfaces close to neutral on warm backgrounds", () => {
|
||||
const theme = resolveTheme(
|
||||
generateSystem(
|
||||
terminalColors({
|
||||
defaultBackground: "#fbf1c7",
|
||||
defaultForeground: "#3c3836",
|
||||
}),
|
||||
"light",
|
||||
),
|
||||
"light",
|
||||
)
|
||||
|
||||
expect(spread(theme.backgroundPanel)).toBeLessThan(60)
|
||||
expect(spread(theme.backgroundElement)).toBeLessThan(60)
|
||||
})
|
||||
39
packages/tui/test/mini/tool.test.ts
Normal file
39
packages/tui/test/mini/tool.test.ts
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
import { describe, expect, test } from "bun:test"
|
||||
import { toolInlineInfo, toolOutputText, toolView } from "../../src/mini/tool"
|
||||
|
||||
describe("Mini tool presentation", () => {
|
||||
test("renders the renamed shell tool with the shell rule", () => {
|
||||
const part = {
|
||||
id: "part-shell",
|
||||
sessionID: "session-shell",
|
||||
messageID: "message-shell",
|
||||
callID: "call-shell",
|
||||
tool: "shell",
|
||||
state: {
|
||||
status: "pending" as const,
|
||||
input: { command: "pwd" },
|
||||
},
|
||||
} as const
|
||||
|
||||
expect(toolView(part.tool)).toEqual({ output: true, final: false })
|
||||
expect(toolInlineInfo(part)).toMatchObject({ icon: "$", title: "pwd", mode: "block" })
|
||||
})
|
||||
|
||||
test("uses non-empty V2 shell output without the model-facing status", () => {
|
||||
expect(
|
||||
toolOutputText("shell", [
|
||||
{ type: "text", text: "mini-output\n" },
|
||||
{ type: "text", text: "Command exited with code 0." },
|
||||
]),
|
||||
).toBe("mini-output\n")
|
||||
})
|
||||
|
||||
test("keeps empty V2 shell output empty", () => {
|
||||
expect(
|
||||
toolOutputText("shell", [
|
||||
{ type: "text", text: "" },
|
||||
{ type: "text", text: "Command exited with code 0." },
|
||||
]),
|
||||
).toBe("")
|
||||
})
|
||||
})
|
||||
104
packages/tui/test/mini/variant.shared.test.ts
Normal file
104
packages/tui/test/mini/variant.shared.test.ts
Normal file
|
|
@ -0,0 +1,104 @@
|
|||
import { describe, expect, test } from "bun:test"
|
||||
import { cycleVariant, formatModelLabel, pickVariant, resolveVariant } from "../../src/mini/variant.shared"
|
||||
import type { RunSession } from "../../src/mini/session.shared"
|
||||
import type { RunProvider } from "../../src/mini/types"
|
||||
|
||||
const model = {
|
||||
providerID: "openai",
|
||||
modelID: "gpt-5",
|
||||
}
|
||||
|
||||
const providers: RunProvider[] = [
|
||||
{
|
||||
id: "openai",
|
||||
name: "OpenAI",
|
||||
source: "api",
|
||||
env: [],
|
||||
options: {},
|
||||
models: {
|
||||
"gpt-5": {
|
||||
id: "gpt-5",
|
||||
providerID: "openai",
|
||||
api: {
|
||||
id: "gpt-5",
|
||||
url: "https://openai.test",
|
||||
npm: "@ai-sdk/openai",
|
||||
},
|
||||
name: "GPT-5",
|
||||
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: 128000,
|
||||
output: 8192,
|
||||
},
|
||||
status: "active",
|
||||
options: {},
|
||||
headers: {},
|
||||
release_date: "2026-01-01",
|
||||
},
|
||||
},
|
||||
},
|
||||
]
|
||||
|
||||
describe("run variant shared", () => {
|
||||
test("prefers cli then session then saved variants", () => {
|
||||
expect(resolveVariant("max", "high", "low", ["low", "high"])).toBe("max")
|
||||
expect(resolveVariant(undefined, "high", "low", ["low", "high"])).toBe("high")
|
||||
expect(resolveVariant(undefined, "missing", "low", ["low", "high"])).toBe("low")
|
||||
})
|
||||
|
||||
test("cycles through variants and back to default", () => {
|
||||
expect(cycleVariant(undefined, ["low", "high"])).toBe("low")
|
||||
expect(cycleVariant("low", ["low", "high"])).toBe("high")
|
||||
expect(cycleVariant("high", ["low", "high"])).toBeUndefined()
|
||||
expect(cycleVariant(undefined, [])).toBeUndefined()
|
||||
})
|
||||
|
||||
test("formats model labels", () => {
|
||||
expect(formatModelLabel(model, undefined)).toBe("gpt-5 · openai")
|
||||
expect(formatModelLabel(model, "high")).toBe("gpt-5 · openai · high")
|
||||
expect(formatModelLabel(model, undefined, providers)).toBe("GPT-5 · OpenAI")
|
||||
expect(formatModelLabel(model, "high", providers)).toBe("GPT-5 · OpenAI · high")
|
||||
})
|
||||
|
||||
test("picks the latest matching variant from session history", () => {
|
||||
const session: RunSession = {
|
||||
first: false,
|
||||
turns: [
|
||||
{ prompt: { text: "one", parts: [] }, provider: "openai", model: "gpt-5", variant: "high" },
|
||||
{ prompt: { text: "two", parts: [] }, provider: "anthropic", model: "sonnet", variant: "max" },
|
||||
{ prompt: { text: "three", parts: [] }, provider: "openai", model: "gpt-5", variant: "minimal" },
|
||||
],
|
||||
}
|
||||
|
||||
expect(pickVariant(model, session)).toBe("minimal")
|
||||
})
|
||||
|
||||
})
|
||||
Loading…
Add table
Add a link
Reference in a new issue