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 { act, fireEvent, renderHook, waitFor } from "@testing-library/react";
import { beforeEach, describe, expect, test, vi } from "vitest";
const { apiMock, writeMock } = vi.hoisted(() => {
const baseSession = {
id: "s1",
title: "会话一",
projectId: "p1",
model: "m1",
effort: "",
updatedAt: "2026-01-01T00:00:00Z",
messages: [{ role: "user", content: "原消息" }],
};
const apiMock = vi.fn(async (path, options) => {
if (options?.method === "DELETE") return {};
if (path === "/mcp")
return { result: { structuredContent: { data: { id: "saved" } } } };
if (path === "/api/auth/current") return { user: { id: 1, loginName: "tester", codeBuddyApiKeyConfigured: true } };
if (path === "/api/projects") return [{ id: "p1", name: "项目一", ownerId: 1, members: [1] }];
if (path === "/api/assistant/models?executor=codex") return { default: "default", models: [{ id: "default", name: "CLI default", family: "gpt" }, { id: "gpt-5", name: "GPT-5", family: "gpt", efforts: ["high", "xhigh"] }] };
if (path === "/api/assistant/models") return { default: "m1", sponsoredModel: "m1", models: [{ id: "m1", name: "模型一", effort: true }] };
if (path === "/api/users") return [{ id: 1, loginName: "tester", codeBuddyApiKeyConfigured: true }];
if (path === "/api/assistant/sessions") return [baseSession];
if (path.includes("/generation")) return { id: "g1", status: "completed", events: [] };
if (path.startsWith("/api/assistant/sessions/")) return structuredClone(baseSession);
return [];
});
const writeMock = vi.fn(async (path, body) => {
if (path === "/api/assistant/generations")
return { id: "g1", status: "running", events: [] };
if (path.endsWith("/fork") || path.endsWith("/edit"))
return { ...baseSession, id: path.endsWith("/fork") ? "s2" : "s1", messages: [{ role: "user", content: body.content }] };
if (path.includes("/issue")) return { ...baseSession, issueId: body.issueId };
return { ...baseSession, ...body, id: body?.id || baseSession.id };
});
return { apiMock, writeMock };
});
vi.mock("../src/api.js", async (original) => ({
...(await original()),
api: apiMock,
write: writeMock,
newId: () => "new-session",
}));
import { EXECUTORS, useChat } from "../src/useChat.js";
import { writeComposerPreference } from "../src/composer-preferences.js";
import {
isLocalConversation,
useLocalConversations,
} from "../src/useLocalConversations.js";
import { usePanelPresence } from "../src/usePanelPresence.js";
import { useArtifactPanelLayout } from "../src/useArtifactPanelLayout.js";
import { useConversationRuns } from "../src/runs.js";
describe("conversation hooks", () => {
test("refreshes environments after returning from sandbox creation", async () => {
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.ready).toBe(true));
const original = apiMock.getMockImplementation();
apiMock.mockImplementation((path, options) => path === "/api/sandboxes"
? Promise.resolve([{id:"created-from-chat",driver:"docker",projectId:"p1"}])
: original(path, options));
try {
act(() => window.dispatchEvent(new MessageEvent("message", {
origin: location.origin, source: window.parent,
data: {type:"agentflow-environments-changed"},
})));
await waitFor(() => expect(result.current.sandboxes).toEqual([expect.objectContaining({id:"created-from-chat"})]));
} finally { apiMock.mockImplementation(original); }
});
beforeEach(() => {
vi.clearAllMocks();
history.replaceState({}, "", "/");
});
test("switches Main Bot to another CLI and sends its executor", async () => {
localStorage.removeItem("loopforge.assistant.executor");
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.ready).toBe(true));
expect(result.current.executor).toBe("codebuddy");
expect(result.current.executors.map((item) => item.id)).toEqual(EXECUTORS.map((item) => item.id));
act(() => result.current.setExecutor("codex"));
await waitFor(() => expect(result.current.models.map((m) => m.id)).toEqual(["gpt-5"]));
expect(result.current.model).toBe("gpt-5");
expect(result.current.effort).toBe("");
expect(result.current.sponsored).toBe(false);
act(() => result.current.setExecutor("unknown"));
expect(result.current.executor).toBe("codex");
await act(() => result.current.send({ text: "你好" }));
expect(writeMock).toHaveBeenCalledWith(
"/api/assistant/generations",
expect.objectContaining({ executor: "codex", model: "gpt-5", effort: "" }),
);
act(() => result.current.setExecutor("codebuddy"));
expect(result.current.model).toBe("m1");
localStorage.removeItem("loopforge.assistant.executor");
});
test("restores the CLI and model saved by an earlier version", async () => {
localStorage.setItem("loopforge.assistant.executor", "codex");
localStorage.setItem("loopforge.assistant.model.codex", "gpt-5");
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.ready).toBe(true));
expect(result.current.executor).toBe("codex");
await waitFor(() => expect(result.current.model).toBe("gpt-5"));
});
test("does not create a chat without a concrete model on Pi", async () => {
const view = renderHook(() => useChat());
try {
await waitFor(() => expect(view.result.current.ready).toBe(true));
act(() => view.result.current.setExecutor("pi"));
await waitFor(() => expect(apiMock).toHaveBeenCalledWith("/api/assistant/models?executor=pi"));
expect(view.result.current.models).toEqual([]);
await act(async () => expect(await view.result.current.send({ text: "开始" })).toBe(false));
expect(writeMock).not.toHaveBeenCalled();
} finally {
view.unmount();
localStorage.removeItem("loopforge.assistant.executor");
}
});
test("reads Antigravity model families and restores a previous variant as an effort", async () => {
const originalAPI = apiMock.getMockImplementation();
const originalWrite = writeMock.getMockImplementation();
apiMock.mockImplementation((path, options) => {
if (path === "/api/runners?mine=1") return Promise.resolve([
{ id: "mac", name: "Mac", status: "online", ownerUserId: 1,
runtimes: [{ provider: "agy", authMode: "local" }] },
]);
if (path === "/api/runners/default") return Promise.resolve({ runnerId: "mac" });
return originalAPI(path, options);
});
writeMock.mockImplementation((path, body) => path === "/api/runners/mac/models/probe"
? Promise.resolve({ models: [
{
id: "claude-sonnet-5-5-medium", name: "Claude Sonnet 5.5",
efforts: {
low: "claude-sonnet-5-5-low", medium: "claude-sonnet-5-5-medium", high: "claude-sonnet-5-5-high",
},
discoveredReasoningEfforts: ["low", "medium", "high"],
},
{ id: "claude-opus-5-5-medium", name: "Claude Opus 5.5" },
] })
: originalWrite(path, body));
writeComposerPreference("model.agy", "agy:claude-sonnet-5-5-high");
const view = renderHook(() => useChat());
try {
await waitFor(() => expect(view.result.current.defaultRunnerId).toBe("mac"));
act(() => view.result.current.setExecutor("agy"));
await waitFor(() => expect(view.result.current.models.map((m) => m.id)).toEqual([
"agy:claude-sonnet-5-5-medium", "agy:claude-opus-5-5-medium",
]));
expect(writeMock).toHaveBeenCalledWith("/api/runners/mac/models/probe", { provider: "agy", useSaved: true });
expect(view.result.current.model).toBe("agy:claude-sonnet-5-5-medium");
expect(view.result.current.modelDetails.efforts).toEqual(["low", "medium", "high"]);
expect(view.result.current.effort).toBe("high");
act(() => view.result.current.setEffort(""));
expect(view.result.current.effort).toBe("");
act(() => view.result.current.setEffort("low"));
await act(() => view.result.current.send({ text: "使用低思考强度" }));
expect(writeMock).toHaveBeenCalledWith("/api/assistant/generations", expect.objectContaining({
model: "agy:claude-sonnet-5-5-medium", effort: "low", executionTarget: { pool: "runner", runnerId: "mac" },
}));
} finally {
view.unmount();
apiMock.mockImplementation(originalAPI);
writeMock.mockImplementation(originalWrite);
localStorage.removeItem("loopforge.assistant.executor");
localStorage.removeItem("loopforge.assistant.model.agy");
localStorage.removeItem("loopforge.assistant.effort.agy.claude-sonnet-5-5-medium");
history.replaceState({}, "", "/");
}
});
test("asks for a new model before continuing on a retired Antigravity variant", async () => {
const originalAPI = apiMock.getMockImplementation();
const originalWrite = writeMock.getMockImplementation();
const session = {
id: "legacy-agy", executor: "agy", model: "agy:gemini-3.8-flash-high", effort: "",
executionTarget: { pool: "runner", runnerId: "mac" },
messages: [{ role: "user", content: "原消息" }, { role: "assistant", content: "原回复", model: "agy:gemini-3.8-flash-high" }],
};
apiMock.mockImplementation(async (path, options) => {
if (path === "/api/runners?mine=1") return [
{ id: "mac", status: "online", ownerUserId: 1, runtimes: [{ provider: "agy", authMode: "local" }] },
];
if (path === "/api/assistant/sessions/legacy-agy") return structuredClone(session);
return originalAPI(path, options);
});
writeMock.mockImplementation(async (path, body) => path === "/api/runners/mac/models/probe"
? { models: [{
id: "gemini-3.8-flash-low", name: "Gemini 3.8 Flash", discoveredReasoningEfforts: ["low", "medium"],
efforts: { low: "gemini-3.8-flash-low", medium: "gemini-3.8-flash-medium" },
}] }
: originalWrite(path, body));
const view = renderHook(() => useChat());
try {
await waitFor(() => expect(view.result.current.ready).toBe(true));
act(() => view.result.current.open(session.id));
await waitFor(() => expect(view.result.current.models.map(model => model.id)).toEqual(["agy:gemini-3.8-flash-low"]));
await act(async () => expect(await view.result.current.send({ text: "继续" })).toBe(false));
expect(view.result.current.error).toContain("请重新选择模型");
expect(writeMock).not.toHaveBeenCalledWith("/api/assistant/generations", expect.anything());
act(() => view.result.current.setModel("agy:gemini-3.8-flash-low"));
await act(async () => expect(await view.result.current.send({ text: "继续" })).toBe(true));
expect(writeMock).toHaveBeenCalledWith("/api/assistant/generations", expect.objectContaining({
sessionId: session.id, model: "agy:gemini-3.8-flash-low", effort: "",
}));
} finally {
view.unmount();
apiMock.mockImplementation(originalAPI);
writeMock.mockImplementation(originalWrite);
localStorage.removeItem("loopforge.assistant.executor");
localStorage.removeItem("loopforge.assistant.model.agy");
localStorage.removeItem("loopforge.assistant.effort.agy.gemini-3.8-flash-low");
}
});
test.each(["after saving a key", "during the first open"])("refreshes a pending Cursor catalog %s", async (scenario) => {
const original = apiMock.getMockImplementation();
let configured = scenario === "during the first open";
let discovered = false;
let pendingReads = 0;
const fallback = { id: "widget", name: "Widget" };
writeComposerPreference("executor", "cursor");
apiMock.mockImplementation(async (path, options) => {
if (path === "/api/assistant/models?executor=cursor") return { models: [fallback] };
if (path === "/api/assistant/models" && configured) {
if (!discovered) pendingReads++;
return {
default: "m1",
cursorModelsPending: !discovered,
models: [{ ...fallback, id: "cursor:widget", engine: "cursor", efforts: discovered ? ["low", "xhigh"] : [] }],
};
}
return original(path, options);
});
try {
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.modelDetails?.name).toBe("Widget"));
await waitFor(() => expect(result.current.ready).toBe(true));
expect(result.current.modelDetails.efforts || []).toEqual([]);
act(() => { result.current.setModel(result.current.model); });
if (!configured) {
configured = true;
act(() => window.dispatchEvent(new MessageEvent("message", {
origin: location.origin,
source: window.parent,
data: { type: "agentflow-credentials-changed" },
})));
}
await waitFor(() => expect(pendingReads).toBeGreaterThan(0));
discovered = true;
await waitFor(() => expect(result.current.modelDetails.efforts).toEqual(["low", "xhigh"]), { timeout: 3500 });
act(() => result.current.setEffort("xhigh"));
expect(result.current.effort).toBe("xhigh");
await act(() => result.current.send({ text: "验证强度" }));
expect(writeMock).toHaveBeenCalledWith(
"/api/assistant/generations", expect.objectContaining({ executor: "cursor", model: "cursor:widget", effort: "xhigh" }),
);
} finally {
apiMock.mockImplementation(original);
}
});
test("without an own key chat is limited to the administrator's shared models", async () => {
localStorage.removeItem("loopforge.assistant.executor");
const original = apiMock.getMockImplementation();
apiMock.mockImplementation(async (path, options) => {
if (path === "/api/auth/current") return { user: { id: 1, loginName: "tester", codeBuddyApiKeyConfigured: false } };
if (path === "/api/users") return [{ id: 1, loginName: "tester", codeBuddyApiKeyConfigured: false }];
if (path === "/api/assistant/models")
return { default: "glm-5.1", sponsoredModel: "glm-5.1", sponsoredModels: ["glm-5.1", "kimi-k2.6"], models: [{ id: "glm-5.1", name: "GLM" }, { id: "kimi-k2.6", name: "Kimi" }] };
return original(path, options);
});
try {
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.ready).toBe(true));
expect(result.current.sponsored).toBe(true);
expect(result.current.sponsoredModels).toEqual(["glm-5.1", "kimi-k2.6"]);
expect(result.current.model).toBe("glm-5.1");
let accepted;
act(() => { accepted = result.current.setModel("kimi-k2.6"); });
expect(accepted).toBe(true);
expect(result.current.model).toBe("kimi-k2.6");
act(() => { accepted = result.current.setModel("claude-opus-5"); });
expect(accepted).toBe(false);
expect(result.current.model).toBe("kimi-k2.6");
expect(result.current.error).toContain("glm-5.1、kimi-k2.6");
} finally {
apiMock.mockImplementation(original);
}
});
test("restores model and effort choices in fresh chats and across catalog sources", async () => {
localStorage.setItem("loopforge.assistant.model.codebuddy", "default");
const original = apiMock.getMockImplementation();
let personalCodexCatalog = false;
apiMock.mockImplementation(async (path, options) => {
if (path === "/api/assistant/models") {
const models = [
{ id: "default", name: "CLI 默认模型" },
{ id: "m1", name: "模型一", efforts: ["low"] },
{ id: "claude-opus-5.5", name: "Opus", efforts: ["max"] },
];
if (personalCodexCatalog)
models.push({ id: "codex:gpt-5", engine: "codex", name: "GPT-5", efforts: ["high"] });
return { default: "default", defaultEfforts: ["low"], models };
}
return original(path, options);
});
try {
const first = renderHook(() => useChat());
await waitFor(() => expect(first.result.current.ready).toBe(true));
expect(first.result.current.models.map((m) => m.id)).toEqual(["m1", "claude-opus-5.5"]);
expect(first.result.current.model).toBe("m1");
act(() => first.result.current.setEffort("low"));
await act(() => first.result.current.send({ text: "运行第一个可用模型" }));
expect(writeMock).toHaveBeenCalledWith(
"/api/assistant/generations",
expect.objectContaining({ model: "m1", effort: "low" }),
);
act(() => first.result.current.newChat());
act(() => { first.result.current.setModel("claude-opus-5.5"); });
act(() => first.result.current.setEffort("max"));
act(() => first.result.current.open("s1"));
await waitFor(() => expect(first.result.current.session?.id).toBe("s1"));
expect(first.result.current.model).toBe("m1");
expect(first.result.current.effort).toBe("");
act(() => first.result.current.newChat());
expect(first.result.current.model).toBe("claude-opus-5.5");
expect(first.result.current.effort).toBe("max");
await act(() => first.result.current.send({ text: "你好" }));
expect(writeMock).toHaveBeenCalledWith(
"/api/assistant/generations",
expect.objectContaining({ model: "claude-opus-5.5", effort: "max" }),
);
act(() => first.result.current.newChat());
act(() => first.result.current.setExecutor("codex"));
await waitFor(() => expect(first.result.current.models.map((m) => m.id)).toEqual(["gpt-5"]));
act(() => { first.result.current.setModel("gpt-5"); });
act(() => first.result.current.setEffort("high"));
act(() => first.result.current.setExecutor("codebuddy"));
expect(first.result.current.model).toBe("claude-opus-5.5");
expect(first.result.current.effort).toBe("max");
act(() => first.result.current.setExecutor("codex"));
act(() => first.result.current.newChat());
expect(first.result.current.model).toBe("gpt-5");
expect(first.result.current.effort).toBe("high");
first.unmount();
personalCodexCatalog = true;
history.replaceState({}, "", "/");
const reloaded = renderHook(() => useChat());
await waitFor(() => expect(reloaded.result.current.ready).toBe(true));
expect(reloaded.result.current.executor).toBe("codex");
expect(reloaded.result.current.model).toBe("codex:gpt-5");
expect(reloaded.result.current.effort).toBe("high");
act(() => reloaded.result.current.setExecutor("codebuddy"));
expect(reloaded.result.current.model).toBe("claude-opus-5.5");
expect(reloaded.result.current.effort).toBe("max");
act(() => reloaded.result.current.setModel("m1"));
expect(reloaded.result.current.effort).toBe("low");
act(() => reloaded.result.current.setModel("claude-opus-5.5"));
expect(reloaded.result.current.effort).toBe("max");
act(() => reloaded.result.current.setEffort(""));
// A remembered model that is no longer offered falls back to the list.
writeComposerPreference("model.codebuddy", "retired-model");
act(() => reloaded.result.current.newChat());
expect(reloaded.result.current.model).toBe("m1");
expect(reloaded.result.current.effort).toBe("low");
act(() => reloaded.result.current.setModel("claude-opus-5.5"));
expect(reloaded.result.current.effort).toBe("");
} finally {
apiMock.mockImplementation(original);
}
});
test("regenerating after an edit follows the composer's approval mode", async () => {
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.ready).toBe(true));
const stored = { id: "s1", projectId: "p1", model: "m1", messages: [{ role: "user", content: "修改" }] };
await act(() => result.current.regenerate(stored, "assisted"));
expect(writeMock).toHaveBeenLastCalledWith("/api/assistant/generations", expect.objectContaining({ approvalMode: "assisted" }));
await act(() => result.current.regenerate(stored, "bogus"));
expect(writeMock).toHaveBeenLastCalledWith("/api/assistant/generations", expect.objectContaining({ approvalMode: "confirm" }));
});
test("an open conversation on a CLI without a key keeps its model", async () => {
localStorage.removeItem("loopforge.assistant.executor");
const original = apiMock.getMockImplementation();
const codexSession = {
id: "s9", title: "Codex 会话", projectId: "p1", executor: "codex", model: "codex:gpt-5.6-sol", effort: "",
updatedAt: "2026-01-01T00:00:00Z",
messages: [{ role: "user", content: "hi" }, { role: "assistant", content: "ok", model: "codex:gpt-5.6-sol" }],
};
apiMock.mockImplementation(async (path, options) =>
path === "/api/assistant/sessions/s9" ? structuredClone(codexSession) : original(path, options));
try {
history.replaceState({}, "", "/?session=s9");
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.session?.id).toBe("s9"));
await waitFor(() => expect(apiMock).toHaveBeenCalledWith("/api/assistant/models?executor=codex"));
await act(async () => {});
expect(result.current.executor).toBe("codex");
expect(result.current.model).toBe("codex:gpt-5.6-sol");
} finally {
apiMock.mockImplementation(original);
localStorage.removeItem("loopforge.assistant.executor");
}
});
test("persists the draft sandbox selection when creating a conversation", async () => {
history.replaceState({}, "", "/?projectId=p1");
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.ready).toBe(true));
await act(() => result.current.selectSandbox("business-docker"));
expect(result.current.sandboxProfileId).toBe("business-docker");
await act(() => result.current.send({ text: "改代码" }));
expect(writeMock).toHaveBeenCalledWith("/api/assistant/sessions/new-session", expect.objectContaining({ sandboxProfileId: "business-docker" }), "PUT");
});
test("keeps machine choices local and binds the final choice on the first send", async () => {
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.machinesReady).toBe(true));
await act(() => result.current.selectMachine(""));
await act(() => result.current.selectMachine("mac"));
await act(() => result.current.refreshMachines());
expect(result.current.defaultRunnerId).toBe("mac");
expect(result.current.session).toBeNull();
expect(result.current.activeId).toBeNull();
expect(location.search).not.toContain("session=");
expect(writeMock).not.toHaveBeenCalled();
await act(() => result.current.send({text:"开始"}));
expect(writeMock).toHaveBeenCalledWith("/api/assistant/generations",expect.objectContaining({executionTarget:{pool:"runner",runnerId:"mac"}}));
await act(async () => expect(await result.current.selectMachine("")).toBe(false));
});
test("waits for the personal machine default before allowing the first send", async () => {
const original=apiMock.getMockImplementation();
let release;
const delayed=new Promise(resolve=>{release=resolve;});
apiMock.mockImplementation((path,opts)=>path==="/api/runners/default"?delayed:original(path,opts));
try {
const {result}=renderHook(()=>useChat());
await waitFor(()=>expect(result.current.ready).toBe(true));
await act(async()=>expect(await result.current.send({text:"开始"})).toBe(false));
expect(result.current.error).toBe("执行机器仍在加载,请稍后发送。");
expect(writeMock).not.toHaveBeenCalled();
await act(async()=>{release({runnerId:"mac"});});
await waitFor(()=>expect(result.current.defaultRunnerId).toBe("mac"));
} finally {apiMock.mockImplementation(original);release({runnerId:"mac"});}
});
test("loads chat and exercises conversation commands", async () => {
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.ready).toBe(true));
expect(result.current.sessions).toHaveLength(1);
await act(() => result.current.send({ text: "新问题" }));
expect(writeMock).toHaveBeenCalledWith(
"/api/assistant/generations",
expect.objectContaining({ messages: expect.any(Array) }),
);
act(() => result.current.setModel("m1"));
await act(() => result.current.selectProject("p1"));
await act(() => result.current.rename("s1", "新标题"));
await act(() => result.current.archive("s1", true));
await act(() => result.current.remove("s1"));
await act(() => result.current.linkIssue("ISSUE-1"));
await act(() => result.current.refresh());
});
test("opens, edits, regenerates, stops and starts a known session", async () => {
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.ready).toBe(true));
act(() => result.current.open("s1"));
await waitFor(() => expect(result.current.session?.id).toBe("s1"));
await act(() => result.current.edit(0, "修改", true));
await act(() => result.current.regenerate({
id: "s1", projectId: "p1", model: "m1", messages: [{ role: "user", content: "修改" }],
}));
await act(() => result.current.stop());
apiMock.mockResolvedValueOnce({
id: "s1",
projectId: "p1",
messages: [{
role: "assistant",
content: JSON.stringify({ message: "确认", drafts: [{ tool: "issues_save", body: { title: "需求" } }] }),
}],
});
await act(() => result.current.applyDraft(0, 0, { approved: true }));
const mcp = apiMock.mock.calls.find(([path]) => path === "/mcp");
expect(mcp[1].headers).toEqual({ "x-agentflow-chat-session": "s1" });
expect(JSON.parse(mcp[1].body).params).toMatchObject({ name: "issues_save", arguments: { body: { title: "需求" } } });
act(() => result.current.newChat());
expect(result.current.activeId).toBeNull();
});
test("a confirmed project change refreshes both project pickers and new questions carry a time", async () => {
const parent = { postMessage: vi.fn() };
const original = Object.getOwnPropertyDescriptor(window, "parent");
Object.defineProperty(window, "parent", { configurable: true, get: () => parent });
try {
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.ready).toBe(true));
act(() => result.current.open("s1"));
await waitFor(() => expect(result.current.session?.id).toBe("s1"));
apiMock.mockResolvedValueOnce({
id: "s1",
projectId: "p1",
messages: [{
role: "assistant",
content: JSON.stringify({ message: "确认", drafts: [{ tool: "projects_save", body: { id: "okr", name: "OKR系统" } }] }),
}],
});
const projectLoads = () => apiMock.mock.calls.filter(([path]) => path === "/api/projects").length;
const before = projectLoads();
await act(() => result.current.applyDraft(0, 0, { approved: true }));
await waitFor(() => expect(projectLoads()).toBe(before + 1));
expect(parent.postMessage).toHaveBeenCalledWith({ type: "agentflow-projects-changed" }, location.origin);
const generation = writeMock.mock.calls.filter(([path]) => path === "/api/assistant/generations").at(-1);
expect(generation[1].messages.at(-1)).toMatchObject({ role: "user", createdAt: expect.stringMatching(/^\d{4}-\d{2}-\d{2}T/) });
} finally {
if (original) Object.defineProperty(window, "parent", original);
else delete window.parent;
}
});
test("a proposal card accepts before it runs, and a timed-out one never runs", async () => {
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.ready).toBe(true));
act(() => result.current.open("s1"));
await waitFor(() => expect(result.current.session?.id).toBe("s1"));
const draft = { tool: "issues_dispatch", path: { id: "i1" }, proposal: { reason: "走 SOP", timing: "start" } };
const withDraft = (extra = {}) => ({
id: "s1",
projectId: "p1",
messages: [{ role: "assistant", content: JSON.stringify({ message: "建议", drafts: [{ ...draft, ...extra }] }) }],
});
const original = writeMock.getMockImplementation();
const mcpCalls = () => apiMock.mock.calls.filter(([path]) => path === "/mcp");
try {
writeMock.mockImplementation((path, body, method) =>
path.endsWith("/proposals")
? Promise.reject(Object.assign(Error("这条建议已经处理过"), { status: 409 }))
: original(path, body, method),
);
apiMock.mockResolvedValueOnce(withDraft());
await act(() => expect(result.current.applyDraft(0, 0, { approved: true })).rejects.toThrow("已经处理过"));
expect(mcpCalls()).toHaveLength(0);
writeMock.mockImplementation((path, body, method) =>
path.endsWith("/proposals")
? Promise.resolve({ session: withDraft({ decision: "accepted" }), followUp: null })
: original(path, body, method),
);
apiMock.mockResolvedValueOnce(withDraft());
await act(() => result.current.applyDraft(0, 0, { approved: true }));
const accept = writeMock.mock.calls.findIndex(([path]) => path.endsWith("/proposals"));
const mcp = apiMock.mock.calls.findIndex(([path]) => path === "/mcp");
expect(writeMock.mock.invocationCallOrder[accept]).toBeLessThan(apiMock.mock.invocationCallOrder[mcp]);
const saved = writeMock.mock.calls.find(([path, , method]) => path === "/api/assistant/sessions/s1" && method === "PUT");
expect(JSON.parse(saved[1].messages[0].content).drafts[0]).toMatchObject({ decision: "accepted", saved: true });
} finally {
writeMock.mockImplementation(original);
}
});
test.each(["declined", "muted", "expired"])("a %s proposal decision refreshes a stale card without writing", async (decision) => {
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.ready).toBe(true));
act(() => result.current.open("s1"));
await waitFor(() => expect(result.current.session?.id).toBe("s1"));
const draft = { tool: "issues_dispatch", path: { id: "i1" }, proposal: { reason: "走 SOP", timing: "start" } };
const withDraft = (value) => ({
...result.current.session,
messages: [{ role: "assistant", content: JSON.stringify({ message: "建议", drafts: [value] }) }],
});
act(() => result.current.setSession(withDraft(draft)));
const latest = withDraft({ ...draft, decision });
apiMock.mockResolvedValueOnce(latest);
await act(() => expect(result.current.applyDraft(0, 0, { approved: true })).rejects.toThrow("这条建议已经处理过"));
expect(apiMock).not.toHaveBeenCalledWith("/mcp", expect.anything());
expect(writeMock).not.toHaveBeenCalled();
expect(result.current.session).toEqual(latest);
});
test("provides local fixture conversations and completes a local reply", async () => {
history.replaceState({}, "", "/?localPreview=1");
vi.useFakeTimers();
const real = {
user: { id: 1, loginName: "tester", chineseName: "测试" },
ready: true, activeId: null, sessions: [], projectId: "", model: "m1",
open: vi.fn(), newChat: vi.fn(), setError: vi.fn(), setModel: vi.fn(),
setSession: vi.fn(), send: vi.fn(), stop: vi.fn(), rename: vi.fn(),
archive: vi.fn(), remove: vi.fn(), edit: vi.fn(), regenerate: vi.fn(),
selectProject: vi.fn(), linkIssue: vi.fn(), applyDraft: vi.fn(), refresh: vi.fn(),
};
const { result } = renderHook(() => useLocalConversations(real));
await act(async () => {});
const local = result.current.sessions[0];
expect(isLocalConversation(local.id)).toBe(true);
act(() => result.current.open(local.id));
expect(result.current.local).toBe(true);
await act(() => result.current.send({ text: "请总结", attachments: [], references: [] }));
await act(() => vi.advanceTimersByTimeAsync(700));
expect(result.current.session.messages.at(-1).role).toBe("assistant");
await act(() => result.current.rename(local.id, "重命名"));
await act(() => result.current.linkIssue("ISSUE-2"));
await act(() => result.current.edit(0, "修改本地消息", false));
let forked;
await act(async () => { forked = await result.current.edit(0, "创建分支", true); });
await act(() => result.current.regenerate(forked));
await act(() => result.current.stop());
await act(() => result.current.selectProject("p1"));
await act(() => result.current.archive(forked.id, true));
await act(() => result.current.remove(local.id));
vi.useRealTimers();
history.replaceState({}, "", "/");
});
test("a new account has no fixture conversations unless explicitly previewing", async () => {
history.replaceState({}, "", "/");
const real = { user: { id: 99 }, ready: true, activeId: null, sessions: [], model: "m1" };
const { result } = renderHook(() => useLocalConversations(real));
await act(async () => {});
expect(result.current.sessions).toEqual([]);
expect(result.current.localSessions).toBe(false);
});
test("tracks opening and closing presence", () => {
const { result, rerender } = renderHook(
({ open }) => usePanelPresence(open, 0),
{ initialProps: { open: false } },
);
rerender({ open: true });
expect(result.current.mounted).toBe(true);
rerender({ open: false });
expect(result.current.phase).toBe("closing");
});
test("resizes and keyboard-controls the artifact panel layout", () => {
const close = vi.fn();
const host = document.createElement("div");
host.className = "chat-shell";
host.innerHTML = '<header class="conversation-header"></header><main class="conversation-main"></main><aside class="artifact-panel"><button>inside</button></aside>';
document.body.append(host);
const panel = host.querySelector(".artifact-panel");
host.querySelector(".conversation-header").getBoundingClientRect = () => ({ width: 1000, top: 0, bottom: 40, left: 0, right: 1000 });
panel.setPointerCapture = vi.fn();
const root = { current: panel };
const { result, rerender, unmount } = renderHook(
({ nodeId, open }) => useArtifactPanelLayout(root, close, nodeId, open),
{ initialProps: { nodeId: null, open: true } },
);
act(() => result.current.startResize({ button: 0, clientX: 600, pointerId: 1, currentTarget: panel, preventDefault: vi.fn() }));
act(() => result.current.resize({ clientX: 550 }));
act(() => result.current.finishResize());
act(() => result.current.resizeByKey({ key: "End", preventDefault: vi.fn() }));
act(() => result.current.resizeByKey({ key: "Enter", preventDefault: vi.fn() }));
rerender({ nodeId: "n1", open: true });
rerender({ nodeId: null, open: false });
fireEvent.keyDown(document, { key: "Escape" });
unmount();
host.remove();
expect(panel.setPointerCapture).toHaveBeenCalled();
});
test("loads conversation runs from session run references", async () => {
apiMock
.mockResolvedValueOnce({ id: "run-one", status: "failed" })
.mockResolvedValueOnce({ id: "run-two", status: "succeeded" });
const { result } = renderHook(() =>
useConversationRuns({
id: "s1",
runId: "run-one",
messages: [{ role: "assistant", runIds: ["run-two"] }],
}),
);
await waitFor(() => expect(result.current).toHaveLength(2));
});
test("surfaces command failures without throwing from chat actions", async () => {
const { result } = renderHook(() => useChat());
await waitFor(() => expect(result.current.ready).toBe(true));
apiMock.mockRejectedValueOnce(new Error("读取失败"));
await act(() => result.current.rename("s1", "失败"));
writeMock.mockRejectedValueOnce(new Error("保存失败"));
await act(() => result.current.archive("s1", true));
apiMock.mockRejectedValueOnce(new Error("删除失败"));
await act(() => result.current.remove("s1"));
expect(result.current.ready).toBe(true);
});
test("consumes generation updates from EventSource", async () => {
const sources = [];
class FakeEventSource {
constructor(url) {
this.url = url;
sources.push(this);
}
addEventListener(type, listener) {
if (type === "generation") this.generation = listener;
}
close = vi.fn();
}
globalThis.EventSource = FakeEventSource;
apiMock.mockImplementation(async (path) => {
if (path === "/api/auth/current")
return { user: { id: 1, loginName: "tester", codeBuddyApiKeyConfigured: true } };
if (path === "/api/projects")
return [{ id: "p1", name: "项目一", ownerId: 1, members: [1] }];
if (path === "/api/assistant/models")
return { default: "m1", sponsoredModel: "m1", models: [{ id: "m1", name: "模型一" }] };
if (path === "/api/users")
return [{ id: 1, loginName: "tester", codeBuddyApiKeyConfigured: true }];
if (path === "/api/assistant/sessions") return [];
if (path.includes("/generation"))
return {
id: "g-stream",
status: "running",
events: [{ sequence: 1, data: { kind: "answer", text: "部分" } }],
};
if (path.startsWith("/api/assistant/sessions/"))
return {
id: "s1", title: "流式会话", projectId: "p1", model: "m1",
messages: [{ role: "user", content: "开始" }],
};
return [];
});
const { result, unmount } = renderHook(() => useChat());
await waitFor(() => expect(result.current.ready).toBe(true));
act(() => result.current.open("s1"));
await waitFor(() => expect(sources).toHaveLength(1));
await act(async () => {
sources[0].generation({
data: JSON.stringify({
id: "g-stream",
status: "completed",
events: [{ sequence: 2, full: true, data: { kind: "answer", text: "完成" } }],
}),
});
});
await waitFor(() => expect(result.current.generation?.status).toBe("completed"));
expect(result.current.live.answer).toBe("部分完成");
unmount();
delete globalThis.EventSource;
});
test("replaces a new prompt title with the background summary without touching messages", async () => {
const prompt = "请帮我把积分商城的需求、缺口和验收标准整理出来";
const original = apiMock.getMockImplementation();
let summarized = false;
apiMock.mockImplementation(async (path, options) => {
if (path === "/api/assistant/sessions/s1") {
const messages = [{ role: "user", content: prompt }];
if (!summarized) return { id: "s1", title: prompt.slice(0, 36), projectId: "p1", model: "m1", messages };
return { id: "s1", title: "积分商城梳理", titleGenerated: true, messages: [] };
}
return original(path, options);
});
try {
history.replaceState({}, "", "/?session=s1");
const { result, unmount } = renderHook(() => useChat());
await waitFor(() => expect(result.current.session?.title).toBe(prompt.slice(0, 36)));
summarized = true;
await waitFor(() => expect(result.current.session?.title).toBe("积分商城梳理"), { timeout: 5000 });
expect(result.current.session.titleGenerated).toBe(true);
expect(result.current.session.messages).toEqual([{ role: "user", content: prompt }]);
unmount();
} finally {
apiMock.mockImplementation(original);
}
});
});