Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
import React from "react";
import { fireEvent, render, screen, waitFor, within } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { beforeEach, describe, expect, test, vi } from "vitest";
import { modelProviderFor } from "../src/ModelProviderIcon";
const chat = {
user: { id: "u1", loginName: "tester", chineseName: "测试用户" },
users: [{ id: "u1", loginName: "tester", chineseName: "测试用户" }],
projects: [
{ id: "p1", name: "示例项目", ownerId: "u1", members: ["u1"] },
{ id: "p2", name: "未加入项目", ownerId: "u2", members: [] },
],
models: [
{ id: "m1", name: "GPT-Test", provider: "openai", effort: true },
{ id: "m2", name: "Claude-Test", provider: "anthropic" },
],
sessions: [],
session: null,
activeId: null,
revealId: null,
projectId: "",
issueId: "",
model: "m1",
effort: "",
executor: "codebuddy",
executors: [
{ id: "codebuddy", icon: "sparkles", label: "CodeBuddy", detail: "CodeBuddy" },
{ id: "codex", icon: "terminal", label: "Codex", detail: "Codex" },
],
setExecutor: vi.fn(),
sponsoredModel: "m1",
generation: null,
live: { answer: "", thinking: "", tools: [], activity: [] },
error: "",
ready: true,
busy: false,
submitting: false,
readOnly: false,
open: vi.fn(),
newChat: vi.fn(),
setError: vi.fn(),
setModel: vi.fn(),
setEffort: vi.fn(),
setSession: vi.fn(),
send: vi.fn(async () => true),
stop: vi.fn(),
rename: vi.fn(),
archive: vi.fn(),
remove: vi.fn(),
edit: vi.fn(),
regenerate: vi.fn(),
selectProject: vi.fn(async () => true),
linkIssue: vi.fn(),
applyDraft: vi.fn(),
refresh: vi.fn(),
};
vi.mock("../src/useChat.js", () => ({ useChat: () => chat }));
vi.mock("../src/useLocalConversations.js", () => ({
useLocalConversations: (value) => value,
}));
vi.mock("../src/runs.js", async (original) => ({
...(await original()),
useConversationRuns: () => [],
}));
vi.mock("mermaid", () => ({
default: { initialize: vi.fn(), render: vi.fn(async () => ({ svg: "<svg />" })) },
}));
import App from "../src/App.jsx";
describe("App", () => {
test("pauses without showing an intermediate stopping state", () => {
const previous = { ...chat };
Object.assign(chat, { activeId: "stopping-chat", busy: true, stopping: true,
generation: { id: "g-stop", status: "running" },
session: { id: "stopping-chat", messages: [{ role: "user", content: "检查目录" }] } });
let view;
try {
view = render(<App />);
expect(screen.queryByText(/正在停止/)).not.toBeInTheDocument();
expect(screen.getByRole("button", { name: "停止生成" })).toBeDisabled();
expect(screen.queryByRole("button", { name: "发送消息" })).not.toBeInTheDocument();
Object.assign(chat, { busy: false, stopping: false, generation: { id: "g-stop", status: "cancelled" } });
view.rerender(<App />);
expect(screen.queryByText("正在停止…")).not.toBeInTheDocument();
expect(screen.getByRole("button", { name: "发送消息" })).toBeInTheDocument();
} finally {
view?.unmount();
for (const key of Object.keys(chat)) if (!(key in previous)) delete chat[key];
Object.assign(chat, previous);
}
});
test("keeps the picked approval mode after a reload", async () => {
const user = userEvent.setup();
const first = render(<App />);
await user.click(screen.getByRole("button", { name: "操作确认方式" }));
await user.click(screen.getByRole("menuitemradio", { name: "帮我批准" }));
expect(screen.getByRole("button", { name: "操作确认方式" })).toHaveTextContent("帮我批准");
first.unmount();
render(<App />);
expect(screen.getByRole("button", { name: "操作确认方式" })).toHaveTextContent("帮我批准");
await user.type(screen.getByRole("textbox", { name: /消息|输入/ }), "你好");
await user.click(screen.getByRole("button", { name: "发送消息" }));
expect(chat.send).toHaveBeenLastCalledWith(expect.objectContaining({ approvalMode: "assisted" }));
});
test("restores full permission after a reload and resets it for another account", async () => {
const user = userEvent.setup();
const first = render(<App />);
await user.click(screen.getByRole("button", { name: "操作确认方式" }));
await user.click(screen.getByRole("menuitemradio", { name: "完全权限" }));
first.unmount();
const reloaded = render(<App />);
fireEvent.keyDown(window, { key: "O", ctrlKey: true, shiftKey: true });
expect(chat.newChat).toHaveBeenCalled();
expect(screen.getByRole("button", { name: "操作确认方式" })).toHaveTextContent("完全权限");
await user.type(screen.getByRole("textbox", { name: /消息|输入/ }), "你好");
await user.click(screen.getByRole("button", { name: "发送消息" }));
expect(chat.send).toHaveBeenLastCalledWith(expect.objectContaining({ approvalMode: "auto" }));
const originalUser = chat.user;
try {
chat.user = { id: "u2", loginName: "another-user" };
reloaded.rerender(<App />);
expect(screen.getByRole("button", { name: "操作确认方式" })).toHaveTextContent("请求批准");
await user.type(screen.getByRole("textbox", { name: "消息" }), "新账号");
await user.click(screen.getByRole("button", { name: "发送消息" }));
expect(chat.send).toHaveBeenLastCalledWith(expect.objectContaining({ approvalMode: "confirm" }));
} finally {
chat.user = originalUser;
}
});
test("does not ask for per-command native approval in a working conversation", () => {
const previous = {...chat};
Object.assign(chat,{activeId:"workspace-chat",busy:true,session:{id:"workspace-chat",runtimeMode:"workspace",messages:[{role:"user",content:"检查目录"}]}});
let view;
try {
view=render(<App />);
expect(screen.queryByRole("region",{name:"待确认的原生操作"})).not.toBeInTheDocument();
} finally { view?.unmount(); Object.assign(chat,previous); }
});
test("offers execution machine selection on the home page and moves it into the conversation header", async () => {
const previous = { ...chat };
const selectMachine = vi.fn();
Object.assign(chat, {
machinesReady: true, defaultRunnerId: "mac", machines: [{ id: "mac", name: "开发 Mac", status: "online" }],
selectMachine, refreshMachines: vi.fn(),
});
const user = userEvent.setup();
let view;
try {
view = render(<App />);
let trigger = screen.getByRole("button", { name: "执行机器:开发 Mac" });
expect(trigger.closest(".composer-context")).not.toBeNull();
trigger.getBoundingClientRect = () => ({ top: 500, bottom: 528, left: 200, right: 400, width: 200, height: 28 });
await user.click(trigger);
await user.click(screen.getByRole("option", { name: /LoopForge 云端/ }));
expect(selectMachine).toHaveBeenCalledWith("");
Object.assign(chat, { activeId: "s1", session: { id: "s1", messages: [] } });
view.rerender(<App />);
expect(screen.getAllByRole("button", { name: "执行机器:开发 Mac" })).toHaveLength(1);
chat.session.messages = [{ role: "user", content: "检查项目" }];
chat.session.executionTarget = {pool:"runner",runnerId:"mac"};
view.rerender(<App />);
expect(screen.queryByRole("button", { name: "执行机器:开发 Mac" })).not.toBeInTheDocument();
expect(screen.getByText("开发 Mac").closest(".header-actions")).not.toBeNull();
} finally {
view?.unmount();
for (const key of Object.keys(chat)) if (!(key in previous)) delete chat[key];
Object.assign(chat, previous);
}
});
test("hides environments by default and remembers each user's advanced preference", async () => {
const previous = { ...chat };
const selectSandbox = vi.fn();
Object.assign(chat, { projectId: "p1", sandboxProfileId: "business", sandboxes: [], selectSandbox });
const user = userEvent.setup();
let view = render(<App />);
expect(screen.queryByRole("button", { name: /^运行环境/ })).not.toBeInTheDocument();
await user.click(screen.getByLabelText("添加"));
await user.click(screen.getByRole("menuitem", { name: "高级设置" }));
await user.click(screen.getByRole("button", { name: /^高级环境选项/ }));
await user.click(screen.getByRole("option", { name: "显示", exact: true }));
await user.click(screen.getByRole("button", { name: "完成", exact: true }));
const environment = screen.getByRole("button", { name: /^运行环境/ });
expect(environment.closest(".composer-context")).toContainElement(screen.getByLabelText("选择项目"));
expect(environment.closest(".composer-toolbar")).toBeNull();
view.unmount();
view = render(<App />);
expect(screen.getByRole("button", { name: /^运行环境/ })).toBeInTheDocument();
view.unmount();
Object.assign(chat, { user: { ...chat.user, id: "another-user" } });
view = render(<App />);
expect(screen.queryByRole("button", { name: /^运行环境/ })).not.toBeInTheDocument();
expect(selectSandbox).not.toHaveBeenCalled();
expect(chat.sandboxProfileId).toBe("business");
view.unmount();
Object.assign(chat, previous);
});
beforeEach(() => {
vi.clearAllMocks();
history.replaceState({}, "", "/");
});
test("a requirement handed over by the workbench opens @-mentioned in a new conversation", async () => {
const previous = { ...chat };
const originalFetch = globalThis.fetch;
const issues = {
i1: { id: "i1", title: "个人主页徽章", projectId: "p1" },
i2: { id: "i2", title: "导出报表", projectId: "p1" },
};
globalThis.fetch = vi.fn(async (path) => ({
ok: true,
status: 200,
json: async () => ({ issue: issues[decodeURIComponent(String(path).split("/").pop())] }),
}));
Object.assign(chat, { projectId: "p1", startProjectDraft: vi.fn() });
history.replaceState({}, "", "/?projectId=p1&mentionIssue=i1");
let view;
try {
view = render(<App />);
const box = screen.getByRole("textbox");
await waitFor(() => expect(box.value).toBe("@个人主页徽章 "));
expect(screen.getByLabelText("移除引用 个人主页徽章")).toBeInTheDocument();
expect(globalThis.fetch).toHaveBeenCalledWith("/api/issues/i1", expect.anything());
expect(new URLSearchParams(location.search).has("mentionIssue")).toBe(false);
window.dispatchEvent(new MessageEvent("message", {
data: { type: "agentflow-chat-mention-issue", issueId: "i2", projectId: "p1" },
origin: location.origin,
source: window.parent,
}));
expect(chat.startProjectDraft).toHaveBeenCalledWith("p1");
await waitFor(() => expect(box.value).toBe("@导出报表 "));
expect(screen.queryByLabelText("移除引用 个人主页徽章")).not.toBeInTheDocument();
expect(screen.getByLabelText("移除引用 导出报表")).toBeInTheDocument();
} finally {
view?.unmount();
globalThis.fetch = originalFetch;
Object.assign(chat, previous);
delete chat.startProjectDraft;
localStorage.clear();
}
});
test("a requirement handoff keeps the project's unsent new-conversation draft", async () => {
const previous = { ...chat };
const originalFetch = globalThis.fetch;
globalThis.fetch = vi.fn(async () => ({
ok: true,
status: 200,
json: async () => ({ issue: { id: "i3", title: "订单导出", projectId: "p1" } }),
}));
Object.assign(chat, { projectId: "p1", startProjectDraft: vi.fn() });
const owner = chat.user?.id || "guest";
const projectDraftKey = `agentflow.native-chat.draft.${owner}.new:p1`;
const projectDraft = JSON.stringify({
text: "写了一半的问题",
attachments: [{ id: "att-1", name: "spec.pdf", type: "application/pdf", size: 12 }],
references: [],
});
localStorage.setItem(projectDraftKey, projectDraft);
history.replaceState({}, "", "/?projectId=p1&mentionIssue=i3");
let view;
try {
view = render(<App />);
const box = screen.getByRole("textbox");
await waitFor(() => expect(box.value).toBe("@订单导出 "));
expect(screen.queryByText("spec.pdf")).not.toBeInTheDocument();
expect(localStorage.getItem(projectDraftKey)).toBe(projectDraft);
// The draft is saved by an effect that runs after the mention renders;
// on a slow runner the box can already show it while storage does not.
await waitFor(() => {
const issueDraft = JSON.parse(localStorage.getItem(`agentflow.native-chat.draft.${owner}.issue:i3`));
expect(issueDraft.references).toEqual([{ type: "issue", id: "i3", name: "订单导出", projectId: "p1" }]);
});
fireEvent.change(box, { target: { value: "@订单导出 先聊范围" } });
window.dispatchEvent(new MessageEvent("message", {
data: { type: "agentflow-chat-mention-issue", issueId: "i3", projectId: "p1" },
origin: location.origin,
source: window.parent,
}));
await waitFor(() => expect(globalThis.fetch).toHaveBeenCalledTimes(2));
expect(box.value).toBe("@订单导出 先聊范围");
} finally {
view?.unmount();
globalThis.fetch = originalFetch;
Object.assign(chat, previous);
delete chat.startProjectDraft;
localStorage.clear();
}
});
test("leaving a requirement handoff before its details load cancels the mention", async () => {
const previous = { ...chat };
const originalFetch = globalThis.fetch;
let resolveIssue;
globalThis.fetch = vi.fn(() => new Promise((resolve) => {
resolveIssue = () => resolve({
ok: true,
status: 200,
json: async () => ({ issue: { id: "i4", title: "慢需求", projectId: "p1" } }),
});
}));
Object.assign(chat, { projectId: "p1", startProjectDraft: vi.fn() });
const owner = chat.user?.id || "guest";
const projectDraftKey = `agentflow.native-chat.draft.${owner}.new:p1`;
const projectDraft = JSON.stringify({ text: "原来的草稿", attachments: [], references: [] });
localStorage.setItem(projectDraftKey, projectDraft);
history.replaceState({}, "", "/?projectId=p1&mentionIssue=i4");
let view;
try {
view = render(<App />);
await waitFor(() => expect(globalThis.fetch).toHaveBeenCalledTimes(1));
fireEvent.keyDown(window, { key: "O", ctrlKey: true, shiftKey: true });
expect(chat.newChat).toHaveBeenCalled();
const box = screen.getByRole("textbox");
await waitFor(() => expect(box.value).toBe("原来的草稿"));
resolveIssue();
await new Promise((resolve) => setTimeout(resolve, 50));
expect(box.value).toBe("原来的草稿");
expect(globalThis.fetch).toHaveBeenCalledTimes(1);
expect(localStorage.getItem(projectDraftKey)).toBe(projectDraft);
} finally {
view?.unmount();
globalThis.fetch = originalFetch;
Object.assign(chat, previous);
delete chat.startProjectDraft;
localStorage.clear();
}
});
test("renders the ready empty state and opens primary controls", async () => {
const user = userEvent.setup();
render(<App />);
expect(screen.getByText("快速接入")).toBeInTheDocument();
const settings = screen.queryByLabelText("设置");
if (settings) await user.click(settings);
fireEvent.keyDown(document, { key: "k", ctrlKey: true });
expect(screen.getByRole("dialog")).toBeInTheDocument();
fireEvent.keyDown(document, { key: "Escape" });
await user.click(screen.getByLabelText("选择项目"));
expect(screen.getByRole("listbox", { name: "项目" })).toBeInTheDocument();
fireEvent.keyDown(document, { key: "Escape" });
// With no project the picker is highlighted so newcomers notice it.
expect(screen.getByLabelText("选择项目")).toHaveClass("is-unset");
await user.click(screen.getByText("接入测试环境"));
expect(screen.getByRole("textbox").value).toMatch(/^带我一步步接入测试环境/);
await user.click(screen.getByText("选用 SOP 与角色"));
expect(screen.getByRole("textbox").value).toMatch(/产品、前端、后端交付 SOP/);
});
test("questions and replies show when they were sent, and the header switches project", async () => {
const user = userEvent.setup();
const previous = { ...chat };
const today = (h, m) => {
const d = new Date();
d.setHours(h, m, 0, 0);
return d.toISOString();
};
Object.assign(chat, {
sessions: [{ id: "s9", title: "带时间", projectId: "p1", updatedAt: today(9, 0), messages: [] }],
activeId: "s9",
session: {
id: "s9",
title: "带时间",
projectId: "p1",
model: "m1",
messages: [
// Saved before questions were stamped: falls back to the reply start.
{ role: "user", content: "旧问题", createdAt: "0001-01-01T00:00:00Z" },
{ role: "assistant", content: "旧回答", startedAt: today(8, 5), createdAt: today(8, 6), activity: [] },
{ role: "user", content: "新问题", createdAt: today(9, 1) },
{ role: "assistant", content: "新回答", startedAt: today(9, 1), createdAt: today(9, 2), activity: [] },
],
},
projectId: "p1",
});
const view = render(<App />);
const times = [...document.querySelectorAll("time.message-time")].map((t) => t.textContent);
expect(times).toEqual(["08:05", "08:06", "09:01", "09:02"]);
expect(document.querySelectorAll(".message-author time.message-time")).toHaveLength(2);
expect(document.querySelectorAll(".message-actions time.message-time")).toHaveLength(2);
const switcher = screen.getByRole("button", { name: "当前项目:示例项目,切换项目" });
// jsdom has no layout; give the anchor a box so the menu stays open.
switcher.getBoundingClientRect = () => ({ top: 10, bottom: 30, left: 600, right: 700, width: 100, height: 20 });
await user.click(switcher);
const list = screen.getByRole("listbox", { name: "切换项目" });
expect(list).toBeInTheDocument();
fireEvent.click(screen.getByRole("option", { name: /个人对话/ }));
expect(chat.selectProject).toHaveBeenCalledWith("");
view.unmount();
Object.assign(chat, previous);
});
test("renders a populated conversation and sends text", async () => {
const user = userEvent.setup();
const previous = { ...chat };
Object.assign(chat, {
sessions: [
{
id: "s1",
title: "已有会话",
projectId: "p1",
userId: "another-creator",
updatedAt: new Date().toISOString(),
messages: [],
},
],
activeId: "s1",
session: {
id: "s1",
title: "已有会话",
projectId: "p1",
userId: "another-creator",
model: "m1",
messages: [
{ role: "user", content: "你好", createdAt: new Date().toISOString() },
{
role: "assistant",
content: "回答内容",
createdAt: new Date().toISOString(),
activity: [],
},
],
},
projectId: "p1",
});
const view = render(<App />);
expect(screen.getAllByText("已有会话").length).toBeGreaterThan(0);
const textbox = screen.getByRole("textbox");
await user.type(textbox, "继续");
const send = screen.queryByLabelText(/发送/);
if (send) await user.click(send);
expect(chat.send).toHaveBeenCalled();
await user.click(screen.getByLabelText("编辑消息"));
const edit = screen.getByRole("dialog");
await user.clear(edit.querySelector("textarea"));
await user.type(edit.querySelector("textarea"), "修改后的消息");
chat.edit.mockResolvedValueOnce({ id: "s1", messages: [] });
await user.click(screen.getByText("保存并重新生成"));
expect(chat.edit).toHaveBeenCalled();
await user.click(screen.getByLabelText("重命名会话"));
const rename = screen.getByRole("dialog").querySelector("input");
await user.clear(rename);
await user.type(rename, "新会话名");
chat.rename.mockResolvedValueOnce(true);
await user.click(screen.getByText("保存"));
const showSidebar = screen.queryByLabelText("显示会话侧边栏");
if (showSidebar) await user.click(showSidebar);
// Pinning moves the row to another section; query the live row each time.
const openSessionMenu = async () => {
const sessionLink = document.querySelector(".session-link");
expect(sessionLink).toBeInTheDocument();
fireEvent.contextMenu(sessionLink, { clientX: 20, clientY: 20 });
return screen.findByRole("menu", { name: "会话操作" });
};
await user.click(within(await openSessionMenu()).getByRole("menuitem", { name: "置顶" }));
await user.click(within(await openSessionMenu()).getByRole("menuitem", { name: "归档" }));
expect(chat.archive).toHaveBeenCalled();
await waitFor(() => expect(screen.queryByRole("menu", { name: "会话操作" })).not.toBeInTheDocument());
await user.click(within(await openSessionMenu()).getByRole("menuitem", { name: "删除" }));
const deleteDialog = await screen.findByRole("dialog", { name: "删除会话" });
await user.click(within(deleteDialog).getByRole("button", { name: "删除" }));
expect(chat.remove).toHaveBeenCalled();
await user.click(await screen.findByLabelText("筛选会话"));
await user.click(screen.getByText("已归档"));
await user.click(screen.getByLabelText("搜索会话"));
await user.type(screen.getByLabelText("搜索会话名称"), "已有");
fireEvent.keyDown(document, { key: "Escape" });
fireEvent.keyDown(document, { key: ",", ctrlKey: true });
expect(screen.getByText("个人配置与模型凭据")).toBeInTheDocument();
view.unmount();
Object.assign(chat, previous);
});
test("renders live generation, errors, artifacts, and toolbar menus", async () => {
const user = userEvent.setup();
const previous = { ...chat };
Object.assign(chat, {
sessions: [
{ id: "s2", title: "运行会话", projectId: "p1", updatedAt: new Date().toISOString(), messages: [] },
],
activeId: "s2",
session: {
id: "s2",
title: "运行会话",
projectId: "p1",
model: "m1",
messages: [
{
role: "assistant",
content: JSON.stringify({
message: "生成了产物",
drafts: [{ tool: "workflows_save", body: { name: "交付 SOP", projectId: "p1" } }],
}),
attachments: [{ id: "img1", name: "result.png", mimeType: "image/png" }],
createdAt: new Date().toISOString(),
},
],
},
projectId: "p1",
generation: { id: "g1", status: "running", startedAt: new Date().toISOString(), updatedAt: new Date().toISOString() },
live: {
answer: "流式回答",
thinking: "思考中",
tools: [],
activity: [{ id: "live1", kind: "thinking", text: "分析", startedAt: new Date().toISOString() }],
},
error: "出现测试错误",
busy: true,
});
render(<App />);
expect(screen.getByText("流式回答")).toBeInTheDocument();
expect(screen.getByText("出现测试错误")).toBeInTheDocument();
await user.click(screen.getByLabelText("查看会话产物"));
expect(screen.getByLabelText("会话产物")).toBeInTheDocument();
const add = screen.queryByLabelText("添加");
if (add) await user.click(add);
const project = screen.queryByLabelText("选择项目");
if (project) await user.click(project);
const stop = screen.queryByLabelText("停止生成");
if (stop) await user.click(stop);
expect(chat.stop).toHaveBeenCalled();
Object.assign(chat, previous);
});
test("the composer switches CLI and keeps the effort picker", async () => {
const user = userEvent.setup();
const previous = { ...chat };
chat.setExecutor = vi.fn();
chat.executors = [
...previous.executors,
{ id: "pi", icon: "terminal", label: "Pi", detail: "Pi" },
{ id: "agy", icon: "sparkles", label: "Antigravity", detail: "Antigravity" },
{ id: "kimi", icon: "terminal", label: "Kimi Code", detail: "Kimi Code" },
];
const view = render(<App />);
await user.click(screen.getByRole("button", { name: "CLI" }));
const pi = await screen.findByRole("menuitemradio", { name: "Pi" });
expect(pi.querySelector('[data-model-provider="pi"] svg')).not.toBeNull();
const agy = screen.getByRole("menuitemradio", { name: "Antigravity" });
expect(agy.querySelector('[data-model-provider="antigravity"] svg')).not.toBeNull();
const kimi = screen.getByRole("menuitemradio", { name: "Kimi Code" });
expect(kimi.querySelector('[data-model-provider="kimi-code"] img')).not.toBeNull();
expect(modelProviderFor({ id: "agy:gemini-4-neon-high" })).toBe("gemini");
expect(modelProviderFor({ id: "agy:claude-opus-5-5-high" })).toBe("claude");
expect(modelProviderFor({ id: "claude-code:opus" })).toBe("claude");
expect(modelProviderFor({ id: "cursor:composer-2.5" })).toBe("cursor");
expect(modelProviderFor({ id: "cursor:cursor-grok-4.6" })).toBe("xai");
expect(modelProviderFor({ id: "cursor:muse-wonder-1.0" })).toBe("meta");
expect(modelProviderFor({ id: "auto", engine: "cursor" })).toBe("cursor");
expect(modelProviderFor({ id: "kimi:k3.1-pro-highspeed" })).toBe("kimi");
expect(modelProviderFor({ id: "kimi:deepseek-v4-pro" })).toBe("deepseek");
await user.click(await screen.findByRole("menuitemradio", { name: "Codex" }));
expect(chat.setExecutor).toHaveBeenCalledWith("codex");
expect(screen.getByRole("button", { name: "思考强度" })).toBeInTheDocument();
chat.executor = "codex";
view.rerender(<App />);
expect(screen.getByRole("button", { name: "思考强度" })).toBeInTheDocument();
// A saved reply locks the CLI: the switch leaves the composer and the
// title shows which CLI this conversation uses.
Object.assign(chat, {
session: {
id: "s1",
title: "已开始",
executor: "codex",
messages: [{ id: "a1", role: "assistant", model: "m1", content: "hi" }],
},
});
view.rerender(<App />);
expect(screen.queryByRole("button", { name: "CLI" })).not.toBeInTheDocument();
expect(document.querySelector(".conversation-engine")).toHaveTextContent("Codex");
// The first reply, still running, locks it the same way.
Object.assign(chat, {
busy: true,
executor: "codebuddy",
session: { id: "s2", title: "生成中", executor: "codebuddy", messages: [] },
});
view.rerender(<App />);
expect(screen.queryByRole("button", { name: "CLI" })).not.toBeInTheDocument();
expect(document.querySelector(".conversation-engine")).toHaveTextContent("CodeBuddy");
Object.assign(chat, previous);
});
test("covers credential, local upload, read-only, and interrupted states", async () => {
const previous = { ...chat };
Object.assign(chat, {
user: { id: "u1", loginName: "tester", codexApiKeyConfigured: true },
activeId: null,
session: null,
sessions: [],
projectId: "",
sponsoredModel: "",
local: false,
busy: false,
generation: null,
live: { answer: "", thinking: "", tools: [], activity: [] },
error: "",
});
const view = render(<App />);
expect(screen.getByText(/当前执行器 CodeBuddy 需要先配置 CodeBuddy API Key/)).toBeInTheDocument();
expect(screen.getByText(/也可以在输入框下方把执行器切换过去/)).toBeInTheDocument();
chat.executor = "codex";
view.rerender(<App />);
expect(screen.queryByText(/当前执行器 CodeBuddy/)).toBeNull();
chat.executor = "codebuddy";
chat.local = true;
view.rerender(<App />);
const fileInput = document.querySelector('input[type="file"]');
fireEvent.change(fileInput, {
target: { files: [new File(["hello"], "hello.txt", { type: "text/plain" })] },
});
expect(await screen.findByText("hello.txt")).toBeInTheDocument();
const originalFetch = globalThis.fetch;
globalThis.fetch = vi.fn(async () => ({
ok: true,
status: 200,
json: async () => ({ id: "remote-file", name: "remote.txt", mimeType: "text/plain", size: 6 }),
}));
chat.local = false;
view.rerender(<App />);
fireEvent.change(document.querySelector('input[type="file"]'), {
target: { files: [new File(["remote"], "remote.txt", { type: "text/plain" })] },
});
expect(await screen.findByText("remote.txt")).toBeInTheDocument();
globalThis.fetch = originalFetch;
Object.assign(chat, {
local: false,
activeId: "readonly",
session: {
id: "readonly", title: "共享会话", projectId: "p2", readOnly: true,
shared: true, messages: [{ role: "assistant", content: "只读内容", createdAt: new Date().toISOString() }],
},
projectId: "p2",
readOnly: true,
});
view.rerender(<App />);
expect(document.querySelector(".readonly-notice")?.textContent).toContain("只能查看这个会话");
Object.assign(chat, {
session: { ...chat.session, readOnly: false },
readOnly: false,
generation: { id: "g2", status: "failed", error: "中断原因" },
live: {
answer: "部分内容",
thinking: "",
tools: [],
activity: [{ id: "a", kind: "command", detail: "test", startedAt: new Date().toISOString() }],
},
});
view.rerender(<App />);
expect(screen.getByText("中断原因")).toBeInTheDocument();
Object.assign(chat, previous);
});
test("previews a pasted screenshot in the composer instead of only a filename", async () => {
const originalFetch = globalThis.fetch;
const originalCreate = globalThis.URL.createObjectURL;
const originalRevoke = globalThis.URL.revokeObjectURL;
globalThis.URL.createObjectURL = vi.fn(() => "blob:composer-preview");
globalThis.URL.revokeObjectURL = vi.fn();
globalThis.fetch = vi.fn(async () => ({
ok: true,
status: 200,
json: async () => ({ id: "shot-1", name: "shot.png", mimeType: "image/png", size: 2048 }),
}));
Object.assign(chat, {
local: false,
activeId: null,
session: null,
projectId: "p1",
readOnly: false,
});
const view = render(<App />);
fireEvent.paste(screen.getByLabelText("消息"), {
clipboardData: {
items: [
{
kind: "file",
getAsFile: () => new File(["png"], "shot.png", { type: "image/png" }),
},
],
},
});
const thumb = await screen.findByAltText("shot.png");
expect(thumb.getAttribute("src")).toBe("blob:composer-preview");
expect(thumb.closest(".composer-attachment-thumb")).toBeTruthy();
fireEvent.click(screen.getByLabelText("查看图片 shot.png"));
expect(screen.getByLabelText("查看大图 shot.png")).toBeInTheDocument();
view.unmount();
globalThis.fetch = originalFetch;
if (originalCreate) globalThis.URL.createObjectURL = originalCreate;
else delete globalThis.URL.createObjectURL;
if (originalRevoke) globalThis.URL.revokeObjectURL = originalRevoke;
else delete globalThis.URL.revokeObjectURL;
});
test("uploads a pasted screenshot over plain HTTP, where crypto.randomUUID is missing", async () => {
const originalFetch = globalThis.fetch;
const originalCreate = globalThis.URL.createObjectURL;
const originalRevoke = globalThis.URL.revokeObjectURL;
Object.defineProperty(globalThis.crypto, "randomUUID", {
configurable: true,
value: undefined,
});
globalThis.URL.createObjectURL = vi.fn(() => "blob:http-preview");
globalThis.URL.revokeObjectURL = vi.fn();
globalThis.fetch = vi.fn(async () => ({
ok: true,
status: 200,
json: async () => ({ id: "shot-2", name: "http.png", mimeType: "image/png", size: 10 }),
}));
Object.assign(chat, {
local: false,
activeId: null,
session: null,
projectId: "p1",
readOnly: false,
});
try {
const view = render(<App />);
fireEvent.paste(screen.getByLabelText("消息"), {
clipboardData: {
items: [
{
kind: "file",
getAsFile: () => new File(["png"], "http.png", { type: "image/png" }),
},
],
},
});
await screen.findByLabelText("查看图片 http.png");
expect(chat.setError).not.toHaveBeenCalledWith(
expect.stringContaining("randomUUID"),
);
view.unmount();
} finally {
delete globalThis.crypto.randomUUID;
globalThis.fetch = originalFetch;
if (originalCreate) globalThis.URL.createObjectURL = originalCreate;
else delete globalThis.URL.createObjectURL;
if (originalRevoke) globalThis.URL.revokeObjectURL = originalRevoke;
else delete globalThis.URL.revokeObjectURL;
}
});
const artifactSessions = (messages) => ({
id: "session-artifacts",
title: "产物会话",
projectId: "p1",
messages,
});
test("reveals the artifact drawer when a reply generates an artifact", async () => {
const previous = { ...chat };
Object.assign(chat, {
local: false,
projectId: "p1",
activeId: "session-artifacts",
readOnly: false,
sessions: [],
busy: false,
generation: null,
live: { answer: "", thinking: "", tools: [], activity: [] },
session: artifactSessions([
{ id: "msg-1", role: "assistant", content: "先看一下现状" },
]),
});
const view = render(<App />);
expect(document.getElementById("conversation-artifacts")).toBeNull();
Object.assign(chat, {
session: artifactSessions([
{ id: "msg-1", role: "assistant", content: "先看一下现状" },
{
id: "msg-2",
role: "assistant",
content: "脚本已经生成",
attachments: [
{ id: "att-1", name: "代码-1.bash", mimeType: "text/x-shellscript", size: 32 },
],
},
]),
});
view.rerender(<App />);
await waitFor(() =>
expect(document.getElementById("conversation-artifacts")).toBeTruthy(),
);
expect(
document.getElementById("conversation-artifacts").getAttribute("aria-hidden"),
).toBeNull();
view.unmount();
Object.assign(chat, previous);
});
test("keeps the artifact drawer closed for a restored conversation without new artifacts", async () => {
const previous = { ...chat };
Object.assign(chat, {
local: false,
projectId: "p1",
activeId: "session-artifacts",
readOnly: false,
sessions: [],
busy: false,
generation: null,
live: { answer: "", thinking: "", tools: [], activity: [] },
session: artifactSessions([
{
id: "msg-1",
role: "assistant",
content: "上次生成的脚本",
attachments: [
{ id: "att-1", name: "代码-1.bash", mimeType: "text/x-shellscript", size: 32 },
],
},
]),
});
const view = render(<App />);
expect(screen.getByLabelText("查看会话产物")).toBeInTheDocument();
await new Promise((resolve) => setTimeout(resolve, 320));
expect(document.getElementById("conversation-artifacts")).toBeNull();
view.unmount();
Object.assign(chat, previous);
});
test("keeps the artifact drawer closed when the user attaches a file", async () => {
const previous = { ...chat };
Object.assign(chat, {
local: false,
projectId: "p1",
activeId: "session-artifacts",
readOnly: false,
sessions: [],
busy: false,
generation: null,
live: { answer: "", thinking: "", tools: [], activity: [] },
session: artifactSessions([
{ id: "msg-1", role: "user", content: "看下这个文件" },
]),
});
const view = render(<App />);
Object.assign(chat, {
session: artifactSessions([
{
id: "msg-1",
role: "user",
content: "看下这个文件",
attachments: [
{ id: "att-upload", name: "截图.png", mimeType: "image/png", size: 64 },
],
},
]),
});
view.rerender(<App />);
await new Promise((resolve) => setTimeout(resolve, 320));
expect(document.getElementById("conversation-artifacts")).toBeNull();
view.unmount();
Object.assign(chat, previous);
});
});
describe("sidebar conversation filter", () => {
test("only lists conversations the reader took part in", async () => {
const user = userEvent.setup();
const previous = { ...chat };
const now = new Date().toISOString();
Object.assign(chat, {
activeId: null,
session: null,
projectId: "p1",
sessions: [
{
id: "mine",
title: "我参与的项目会话",
projectId: "p1",
shared: true,
participants: [
{ id: "u1", name: "tester" },
{ id: "u2", name: "同事" },
],
updatedAt: now,
messages: [],
},
{
id: "theirs",
title: "同事独自发起的会话",
projectId: "p1",
shared: true,
participants: [{ id: "u2", name: "同事" }],
updatedAt: now,
messages: [],
},
],
});
const view = render(<App />);
try {
const showSidebar = screen.queryByLabelText("显示会话侧边栏");
if (showSidebar) await user.click(showSidebar);
expect(screen.getAllByText("同事独自发起的会话").length).toBeGreaterThan(0);
await user.click(screen.getByLabelText("筛选会话"));
await user.click(screen.getByText("仅我参与的对话"));
expect(screen.queryByText("同事独自发起的会话")).not.toBeInTheDocument();
expect(screen.getAllByText("我参与的项目会话").length).toBeGreaterThan(0);
await user.click(screen.getByLabelText("筛选会话"));
expect(
screen.getByText("仅我参与的对话").closest("[role=menuitemradio]"),
).toHaveAttribute("aria-checked", "true");
await user.click(screen.getByText("最近的会话"));
expect(screen.getAllByText("同事独自发起的会话").length).toBeGreaterThan(0);
} finally {
view.unmount();
Object.assign(chat, previous);
}
});
});
describe("sidebar reply status", () => {
test("an unread completed reply shows a blue dot, a running one spins, a failed one warns", async () => {
const user = userEvent.setup();
const previous = { ...chat };
const originalFetch = globalThis.fetch;
globalThis.fetch = vi.fn(async () => ({ ok: true, status: 200, json: async () => ({ ok: true, recorded: true }) }));
const now = new Date().toISOString();
const row = (id, title, generationStatus, generationId, unread = false) => ({
id, title, projectId: "p1", userId: "u1", generationStatus, generationId, unread, updatedAt: now, messages: [],
});
Object.assign(chat, {
activeId: null,
session: null,
projectId: "p1",
sessions: [
row("unread", "完成未读", "completed", "g2", true),
row("read", "完成已读", "completed", "g3"),
row("busy", "正在生成", "running", "g4"),
row("broken", "生成出错", "failed", "g5"),
],
});
const view = render(<App />);
try {
const showSidebar = screen.queryByLabelText("显示会话侧边栏");
if (showSidebar) await user.click(showSidebar);
const status = (title) =>
screen.getAllByText(title)[0].closest(".session-link").querySelector(".session-status");
await waitFor(() => expect(status("完成未读")).toHaveAttribute("data-session-status", "unread"));
expect(status("完成未读")).toHaveAccessibleName("有新回复未读");
expect(status("完成未读").querySelector(".session-unread-dot")).not.toBeNull();
expect(status("完成已读")).toBeNull();
expect(status("正在生成").querySelector('[data-icon="arc-spinner"]')).not.toBeNull();
expect(status("生成出错").querySelector('[data-icon="alert"]')).not.toBeNull();
// Opening the conversation reports the reply read and clears its dot.
Object.assign(chat, { activeId: "unread" });
view.rerender(<App />);
await waitFor(() =>
expect(globalThis.fetch).toHaveBeenCalledWith(
"/api/assistant/sessions/unread/read",
expect.objectContaining({ method: "POST", body: JSON.stringify({ generationId: "g2" }) }),
),
);
Object.assign(chat, { activeId: null });
view.rerender(<App />);
await waitFor(() => expect(status("完成未读")).toBeNull());
} finally {
view.unmount();
globalThis.fetch = originalFetch;
Object.assign(chat, previous);
}
});
});