2056 lines
83 KiB
TypeScript
2056 lines
83 KiB
TypeScript
import test from "node:test";
|
||
import assert from "node:assert/strict";
|
||
import os from "node:os";
|
||
import path from "node:path";
|
||
import { mkdtemp, rm } from "node:fs/promises";
|
||
import { NextRequest } from "next/server";
|
||
|
||
let runtimeRoot = "";
|
||
let postMessageRoute: (typeof import("../src/app/api/v1/projects/[projectId]/messages/route"))["POST"];
|
||
let completeMasterTaskRoute: (typeof import("../src/app/api/v1/master-agent/tasks/[taskId]/complete/route"))["POST"];
|
||
let createAuthSession: (typeof import("../src/lib/boss-data"))["createAuthSession"];
|
||
let readState: (typeof import("../src/lib/boss-data"))["readState"];
|
||
let writeState: (typeof import("../src/lib/boss-data"))["writeState"];
|
||
let queueMasterAgentTask: (typeof import("../src/lib/boss-data"))["queueMasterAgentTask"];
|
||
let upsertDeviceHeartbeat: (typeof import("../src/lib/boss-data"))["upsertDeviceHeartbeat"];
|
||
let AUTH_SESSION_COOKIE = "";
|
||
const TEST_ACCOUNT = "krisolo";
|
||
type MasterAgentTask = Awaited<ReturnType<typeof readState>>["masterAgentTasks"][number];
|
||
|
||
async function setup() {
|
||
if (runtimeRoot) {
|
||
return;
|
||
}
|
||
|
||
runtimeRoot = await mkdtemp(path.join(os.tmpdir(), "boss-single-thread-message-"));
|
||
process.env.BOSS_RUNTIME_ROOT = runtimeRoot;
|
||
process.env.BOSS_STATE_FILE = path.join(runtimeRoot, "boss-state.json");
|
||
|
||
const [messageModule, completeModule, data, auth] = await Promise.all([
|
||
import("../src/app/api/v1/projects/[projectId]/messages/route.ts"),
|
||
import("../src/app/api/v1/master-agent/tasks/[taskId]/complete/route.ts"),
|
||
import("../src/lib/boss-data.ts"),
|
||
import("../src/lib/boss-auth.ts"),
|
||
]);
|
||
|
||
postMessageRoute = messageModule.POST;
|
||
completeMasterTaskRoute = completeModule.POST;
|
||
createAuthSession = data.createAuthSession;
|
||
readState = data.readState;
|
||
writeState = data.writeState;
|
||
queueMasterAgentTask = data.queueMasterAgentTask;
|
||
upsertDeviceHeartbeat = data.upsertDeviceHeartbeat;
|
||
AUTH_SESSION_COOKIE = auth.AUTH_SESSION_COOKIE;
|
||
}
|
||
|
||
test.after(async () => {
|
||
if (runtimeRoot) {
|
||
await rm(runtimeRoot, { recursive: true, force: true });
|
||
}
|
||
});
|
||
|
||
async function createAuthedRequest(url: string, method: "POST", body: unknown) {
|
||
const session = await createAuthSession({
|
||
account: TEST_ACCOUNT,
|
||
role: "highest_admin",
|
||
displayName: "Boss 超级管理员",
|
||
loginMethod: "password",
|
||
});
|
||
|
||
return new NextRequest(url, {
|
||
method,
|
||
headers: {
|
||
"content-type": "application/json",
|
||
cookie: `${AUTH_SESSION_COOKIE}=${session.sessionToken}`,
|
||
},
|
||
body: JSON.stringify(body),
|
||
});
|
||
}
|
||
|
||
function findSingleThreadProject(
|
||
state: Awaited<ReturnType<typeof readState>>,
|
||
) {
|
||
return state.projects.find((project) => project.id !== "master-agent" && !project.isGroup);
|
||
}
|
||
|
||
function buildSingleThreadProject(projectId: string) {
|
||
return {
|
||
id: projectId,
|
||
name: "测试线程",
|
||
pinned: false,
|
||
systemPinned: false,
|
||
deviceIds: ["mac-studio"],
|
||
preview: "测试线程等待继续处理。",
|
||
updatedAt: "2026-04-04T11:30:00+08:00",
|
||
lastMessageAt: "2026-04-04T11:30:00+08:00",
|
||
isGroup: false,
|
||
threadMeta: {
|
||
projectId,
|
||
threadId: `${projectId}-thread`,
|
||
threadDisplayName: "测试线程",
|
||
folderName: "测试项目",
|
||
activityIconCount: 0,
|
||
updatedAt: "2026-04-04T11:30:00+08:00",
|
||
codexThreadRef: `${projectId}-thread`,
|
||
codexFolderRef: `/Users/kris/code/${projectId}`,
|
||
},
|
||
groupMembers: [],
|
||
createdByAgent: true,
|
||
collaborationMode: "development" as const,
|
||
approvalState: "not_required" as const,
|
||
unreadCount: 0,
|
||
riskLevel: "low" as const,
|
||
messages: [],
|
||
goals: [],
|
||
versions: [],
|
||
};
|
||
}
|
||
|
||
function buildProjectFolderKey(project: ReturnType<typeof buildSingleThreadProject>) {
|
||
const folderRef = (project.threadMeta.codexFolderRef?.trim() || project.threadMeta.folderName.trim()).toLowerCase();
|
||
return `${project.deviceIds[0]}:${folderRef}`;
|
||
}
|
||
|
||
async function ensureSingleThreadProject() {
|
||
const state = await readState();
|
||
const existing = findSingleThreadProject(state);
|
||
if (existing) {
|
||
return existing;
|
||
}
|
||
const project = buildSingleThreadProject("single-thread-test");
|
||
await writeState({
|
||
...state,
|
||
projects: state.projects.concat(project),
|
||
});
|
||
const nextState = await readState();
|
||
return findSingleThreadProject(nextState);
|
||
}
|
||
|
||
async function setProjectTakeover(projectId: string, enabled: boolean) {
|
||
const state = await readState();
|
||
state.userProjectAgentControls = state.userProjectAgentControls.filter(
|
||
(item) => !(item.projectId === projectId && item.account === TEST_ACCOUNT),
|
||
);
|
||
state.userProjectAgentControls.unshift({
|
||
account: TEST_ACCOUNT,
|
||
projectId,
|
||
controls: {
|
||
takeoverEnabled: enabled,
|
||
updatedAt: enabled ? "2026-04-17T10:00:00.000Z" : "2026-04-17T10:10:00.000Z",
|
||
},
|
||
});
|
||
await writeState(state);
|
||
}
|
||
|
||
async function resetThreadExecutionState(projectId: string) {
|
||
const state = await readState();
|
||
const project = state.projects.find((item) => item.id === projectId);
|
||
const targetDevice = project ? state.devices.find((device) => device.id === project.deviceIds[0]) : null;
|
||
if (targetDevice) {
|
||
targetDevice.preferredExecutionMode = "cli";
|
||
}
|
||
state.projectExecutionPolicies = state.projectExecutionPolicies.filter((policy) => policy.projectId !== projectId);
|
||
state.userProjectAgentControls = state.userProjectAgentControls.filter(
|
||
(item) => !(item.projectId === projectId && item.account === TEST_ACCOUNT),
|
||
);
|
||
await writeState(state);
|
||
}
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages enqueues a conversation task for single-thread projects", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "请同步一下当前阻塞情况" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
message: { id: string; body: string; sentAt: string };
|
||
task?: { taskId: string; taskType: string; status: string } | null;
|
||
dispatchPlan: null;
|
||
};
|
||
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.message.body, "请同步一下当前阻塞情况");
|
||
assert.equal(payload.dispatchPlan, null);
|
||
assert.ok(payload.task, "expected single-thread message to return a queued task");
|
||
assert.equal(payload.task?.taskType, "conversation_reply");
|
||
assert.equal(payload.task?.status, "queued");
|
||
|
||
const nextState = await readState();
|
||
const task = nextState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.taskType === "conversation_reply" &&
|
||
item.projectId === singleProject.id &&
|
||
item.requestText === "请同步一下当前阻塞情况",
|
||
);
|
||
assert.ok(task, "expected a queued conversation_reply task for the single-thread project");
|
||
assert.equal(task?.targetProjectId, singleProject.id);
|
||
assert.equal(task?.targetThreadId, singleProject.threadMeta.threadId);
|
||
assert.equal(task?.targetCodexThreadRef, singleProject.threadMeta.codexThreadRef);
|
||
assert.equal(task?.targetCodexFolderRef, singleProject.threadMeta.codexFolderRef);
|
||
assert.equal(task?.sourceMessageId, payload.message.id);
|
||
assert.equal(task?.sourceMessageBody, "请同步一下当前阻塞情况");
|
||
assert.equal(task?.sourceMessageSentAt, payload.message.sentAt);
|
||
assert.equal(task?.mirrorBossUserMessageToCodexDesktop, true);
|
||
assert.ok(!task?.executionPrompt?.includes("threadProjectId:"), "thread prompt should not include project id labels");
|
||
assert.ok(!task?.executionPrompt?.includes("folderName:"), "thread prompt should not include folder labels");
|
||
assert.ok(!task?.executionPrompt?.includes("deviceIds:"), "thread prompt should not include device id labels");
|
||
assert.equal(task?.relayViaMasterAgent, undefined);
|
||
assert.equal(task?.executionPrompt, "请同步一下当前阻塞情况");
|
||
|
||
const progressMessage = nextState.projects
|
||
.find((project) => project.id === singleProject.id)
|
||
?.messages.find((message) => message.executionProgress?.taskId === task.taskId);
|
||
assert.ok(progressMessage, "expected a structured execution progress card for the queued thread task");
|
||
assert.equal(progressMessage?.kind, "execution_progress");
|
||
assert.equal(progressMessage?.executionProgress?.status, "queued");
|
||
assert.equal(progressMessage?.executionProgress?.steps[0]?.text, "接收对话任务");
|
||
assert.equal(progressMessage?.executionProgress?.steps.at(-1)?.text, "回写 Boss 对话窗口");
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages routes takeover mode through the target Codex thread", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, true);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "请继续同步当前线程进展" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyPresenter?: "thread" | "master";
|
||
task?: { taskId: string; taskType: string; status: string } | null;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.equal(payload.task?.taskType, "conversation_reply");
|
||
|
||
const nextState = await readState();
|
||
const task = nextState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.taskType === "conversation_reply" &&
|
||
item.projectId === singleProject.id &&
|
||
item.requestText === "请继续同步当前线程进展",
|
||
);
|
||
assert.ok(task, "expected a queued conversation_reply task for takeover mode");
|
||
assert.equal(task?.relayViaMasterAgent, true);
|
||
assert.equal(task?.targetProjectId, singleProject.id);
|
||
assert.equal(task?.targetThreadId, singleProject.threadMeta.threadId);
|
||
assert.equal(task?.targetCodexThreadRef, singleProject.threadMeta.codexThreadRef);
|
||
assert.equal(task?.targetCodexFolderRef, singleProject.threadMeta.codexFolderRef);
|
||
assert.equal(task?.mirrorBossUserMessageToCodexDesktop, true);
|
||
assert.equal(task?.sourceMessageId, task?.requestMessageId);
|
||
assert.equal(task?.sourceMessageBody, "请继续同步当前线程进展");
|
||
assert.ok(task?.executionPrompt?.includes("Boss APP 发来一条托管消息"));
|
||
assert.ok(task?.executionPrompt?.includes("请继续同步当前线程进展"));
|
||
assert.ok(!task?.executionPrompt?.includes("目标线程名称："));
|
||
assert.ok(!task?.executionPrompt?.includes("不要自称主 Agent"));
|
||
|
||
const progressMessage = nextState.projects
|
||
.find((project) => project.id === singleProject.id)
|
||
?.messages.find((message) => message.executionProgress?.taskId === task.taskId);
|
||
assert.ok(progressMessage, "expected takeover mode to show the same thread execution progress card");
|
||
assert.equal(progressMessage?.sender, "master");
|
||
assert.equal(progressMessage?.kind, "execution_progress");
|
||
assert.equal(progressMessage?.executionProgress?.status, "queued");
|
||
});
|
||
|
||
test("POST /api/v1/master-agent/tasks/[taskId]/complete updates the existing execution progress card", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
|
||
const task = await queueMasterAgentTask({
|
||
projectId: singleProject.id,
|
||
taskType: "conversation_reply",
|
||
requestMessageId: "msg-progress-complete",
|
||
requestText: "继续开发并回写进度",
|
||
executionPrompt: "继续开发并回写进度",
|
||
requestedBy: "Boss 超级管理员",
|
||
requestedByAccount: TEST_ACCOUNT,
|
||
deviceId: "mac-studio",
|
||
targetProjectId: singleProject.id,
|
||
targetThreadId: singleProject.threadMeta.threadId,
|
||
targetThreadDisplayName: singleProject.threadMeta.threadDisplayName,
|
||
targetCodexThreadRef: singleProject.threadMeta.codexThreadRef,
|
||
targetCodexFolderRef: singleProject.threadMeta.codexFolderRef,
|
||
mirrorBossUserMessageToCodexDesktop: true,
|
||
});
|
||
|
||
const response = await completeMasterTaskRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/master-agent/tasks/${task.taskId}/complete`,
|
||
"POST",
|
||
{
|
||
deviceId: task.deviceId,
|
||
status: "completed",
|
||
targetProjectId: singleProject.id,
|
||
targetThreadId: singleProject.threadMeta.threadId,
|
||
replyBody: "已完成本轮开发，并更新了验证记录。",
|
||
executionProgress: {
|
||
branch: {
|
||
additions: 42,
|
||
deletions: 3,
|
||
gitStatus: "有未提交变更",
|
||
githubCliStatus: "unavailable",
|
||
},
|
||
artifacts: [
|
||
{ label: "development_version_log_20260508.md", kind: "file" },
|
||
{ label: "已生成图像 1", kind: "image" },
|
||
],
|
||
agents: [
|
||
{ name: "Mendel", role: "explorer" },
|
||
],
|
||
},
|
||
},
|
||
),
|
||
{ params: Promise.resolve({ taskId: task.taskId }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const nextState = await readState();
|
||
const progressMessages = nextState.projects
|
||
.find((project) => project.id === singleProject.id)
|
||
?.messages.filter((message) => message.executionProgress?.taskId === task.taskId);
|
||
assert.equal(progressMessages?.length, 1, "progress updates should mutate the existing card");
|
||
const progress = progressMessages?.[0]?.executionProgress;
|
||
assert.equal(progress?.status, "completed");
|
||
assert.equal(progress?.branch?.additions, 42);
|
||
assert.equal(progress?.branch?.deletions, 3);
|
||
assert.equal(progress?.artifacts?.[0]?.label, "development_version_log_20260508.md");
|
||
assert.equal(progress?.agents?.[0]?.name, "Mendel");
|
||
assert.ok(progress?.steps.every((step) => step.status === "done"));
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages routes master-agent mentions in the message body only to master agent", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
const state = await readState();
|
||
const targetDevice = state.devices.find((device) => device.id === singleProject.deviceIds[0]);
|
||
assert.ok(targetDevice, "expected a seeded target device");
|
||
targetDevice.preferredExecutionMode = "gui";
|
||
await writeState(state);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "先别发给子线程，麻烦 @主Agent 帮我判断这个线程下一步怎么推进" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyPresenter?: "thread" | "master";
|
||
task?: { taskId: string; taskType: string; status: string } | null;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.equal(payload.task?.taskType, "conversation_reply");
|
||
|
||
const nextState = await readState();
|
||
const task = nextState.masterAgentTasks.find((item) => item.taskId === payload.task?.taskId);
|
||
assert.ok(task, "expected the mention to queue a master-agent reply task in this conversation");
|
||
assert.equal(task?.projectId, singleProject.id);
|
||
assert.equal(task?.requestText, "先别发给子线程，麻烦 帮我判断这个线程下一步怎么推进");
|
||
assert.equal(task?.relayViaMasterAgent, undefined);
|
||
assert.equal(task?.targetProjectId, undefined);
|
||
assert.equal(task?.targetThreadId, undefined);
|
||
|
||
const childThreadTask = nextState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.taskType === "conversation_reply" &&
|
||
item.projectId === singleProject.id &&
|
||
item.requestText === "先别发给子线程，麻烦 @主Agent 帮我判断这个线程下一步怎么推进" &&
|
||
item.targetProjectId === singleProject.id,
|
||
);
|
||
assert.equal(childThreadTask, undefined, "at-mention messages must not be sent to the child thread");
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages lets @主Agent create browser control tasks inside a thread conversation", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "@主Agent 打开 Chrome 去后台看一下订单页" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyPresenter?: "thread" | "master";
|
||
task?: { taskId: string; taskType: string; status: string } | null;
|
||
executionMode?: string;
|
||
riskLevel?: string;
|
||
requiresConfirmation?: boolean;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.equal(payload.task?.taskType, "browser_control");
|
||
assert.equal(payload.executionMode, "browser");
|
||
assert.equal(payload.riskLevel, "medium");
|
||
assert.equal(payload.requiresConfirmation, false);
|
||
|
||
const nextState = await readState();
|
||
const task = nextState.masterAgentTasks.find((item) => item.taskId === payload.task?.taskId);
|
||
assert.equal(task?.projectId, singleProject.id);
|
||
assert.equal(task?.taskType, "browser_control");
|
||
assert.equal(task?.intentCategory, "browser_control");
|
||
assert.equal(task?.runtimeKind, "browser-automation-runtime");
|
||
assert.equal(task?.requiresUserConfirmation, undefined);
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages routes direct GUI browser commands to browser control", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
const state = await readState();
|
||
const targetDevice = state.devices.find((device) => device.id === singleProject.deviceIds[0]);
|
||
assert.ok(targetDevice, "expected a seeded target device");
|
||
targetDevice.preferredExecutionMode = "gui";
|
||
targetDevice.capabilities = {
|
||
...(targetDevice.capabilities ?? {}),
|
||
browserAutomation: {
|
||
...(targetDevice.capabilities?.browserAutomation ?? {}),
|
||
connected: true,
|
||
},
|
||
};
|
||
await writeState(state);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "打开浏览器，用浏览器打开 YouTube，找一个 MV 播放" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyPresenter?: "thread" | "master";
|
||
task?: { taskId: string; taskType: string; status: string } | null;
|
||
executionMode?: string;
|
||
riskLevel?: string;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.equal(payload.task?.taskType, "browser_control");
|
||
assert.equal(payload.task?.status, "queued");
|
||
assert.equal(payload.executionMode, "browser");
|
||
assert.equal(payload.riskLevel, "medium");
|
||
|
||
const nextState = await readState();
|
||
const task = nextState.masterAgentTasks.find((item) => item.taskId === payload.task?.taskId);
|
||
assert.ok(task, "expected a queued browser_control task");
|
||
assert.equal(task?.projectId, singleProject.id);
|
||
assert.equal(task?.deviceId, singleProject.deviceIds[0]);
|
||
assert.equal(task?.taskType, "browser_control");
|
||
assert.equal(task?.intentCategory, "browser_control");
|
||
assert.equal(task?.runtimeKind, "browser-automation-runtime");
|
||
|
||
const staleConversationTask = nextState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.projectId === singleProject.id &&
|
||
item.taskType === "conversation_reply" &&
|
||
item.requestText === "打开浏览器，用浏览器打开 YouTube，找一个 MV 播放",
|
||
);
|
||
assert.equal(staleConversationTask, undefined, "direct GUI control should not queue an unclaimable thread task");
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages creates native remote progress for direct GUI control", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
const state = await readState();
|
||
const targetDevice = state.devices.find((device) => device.id === singleProject.deviceIds[0]);
|
||
assert.ok(targetDevice, "expected a seeded target device");
|
||
targetDevice.preferredExecutionMode = "gui";
|
||
targetDevice.capabilities = {
|
||
...(targetDevice.capabilities ?? {}),
|
||
browserAutomation: {
|
||
...(targetDevice.capabilities?.browserAutomation ?? {}),
|
||
connected: true,
|
||
},
|
||
};
|
||
await writeState(state);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "打开浏览器，用浏览器打开 YouTube，找一个 MV 播放" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
const payload = (await response.json()) as { task?: { taskId: string } | null };
|
||
|
||
const nextState = await readState();
|
||
const progressMessage = nextState.projects
|
||
.find((project) => project.id === singleProject.id)
|
||
?.messages.find((message) => message.executionProgress?.taskId === payload.task?.taskId);
|
||
const progress = progressMessage?.executionProgress as
|
||
| (NonNullable<typeof progressMessage>["executionProgress"] & {
|
||
controlMode?: string;
|
||
runtimeKind?: string;
|
||
controlPlatform?: string;
|
||
computerUseProvider?: string;
|
||
})
|
||
| undefined;
|
||
|
||
assert.ok(progressMessage, "expected native control task to render its own progress card");
|
||
assert.equal(progress?.title, "远程控制进度");
|
||
assert.equal(progress?.controlMode, "native_remote_control");
|
||
assert.equal(progress?.runtimeKind, "browser-automation-runtime");
|
||
assert.equal(progress?.controlPlatform, "macos");
|
||
assert.equal(progress?.computerUseProvider, "openai-computer-use");
|
||
assert.ok(progress?.steps.some((step) => step.text.includes("连接目标电脑")));
|
||
assert.ok(!progress?.steps.some((step) => /Codex|Git|线程记录/.test(step.text)));
|
||
assert.equal(progress?.branch, undefined);
|
||
assert.equal(progress?.agents, undefined);
|
||
});
|
||
|
||
test("POST /api/v1/master-agent/tasks/[taskId]/complete appends a visible master summary after control tasks", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
|
||
const task = await queueMasterAgentTask({
|
||
projectId: singleProject.id,
|
||
taskType: "browser_control",
|
||
requestMessageId: "msg-browser-summary",
|
||
requestText: "打开浏览器，用浏览器打开 YouTube，找一个周杰伦 MV 播放",
|
||
executionPrompt: "打开浏览器并搜索周杰伦 MV",
|
||
requestedBy: "Boss 超级管理员",
|
||
requestedByAccount: TEST_ACCOUNT,
|
||
deviceId: "mac-studio",
|
||
accountLabel: "主 GPT",
|
||
intentCategory: "browser_control",
|
||
runtimeKind: "browser-automation-runtime",
|
||
riskLevel: "medium",
|
||
});
|
||
|
||
const response = await completeMasterTaskRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/master-agent/tasks/${task.taskId}/complete`,
|
||
"POST",
|
||
{
|
||
deviceId: task.deviceId,
|
||
status: "completed",
|
||
replyBody: "浏览器控制已完成：打开浏览器，用浏览器打开 YouTube，找一个周杰伦 MV 播放",
|
||
targetUrl: "https://www.youtube.com/results?search_query=%E5%91%A8%E6%9D%B0%E4%BC%A6%20MV",
|
||
},
|
||
),
|
||
{ params: Promise.resolve({ taskId: task.taskId }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const nextState = await readState();
|
||
const updatedProject = nextState.projects.find((project) => project.id === singleProject.id);
|
||
const controlSummary = updatedProject?.messages.find(
|
||
(message) => message.kind === "control_summary" && message.executionProgress?.taskId !== task.taskId,
|
||
);
|
||
const visibleSummary = updatedProject?.messages.at(-1);
|
||
|
||
assert.equal(controlSummary?.body, "浏览器控制已完成：打开浏览器，用浏览器打开 YouTube，找一个周杰伦 MV 播放");
|
||
assert.equal(visibleSummary?.sender, "master");
|
||
assert.equal(visibleSummary?.senderLabel, "主 Agent · 主 GPT");
|
||
assert.equal(visibleSummary?.kind, "text");
|
||
assert.match(visibleSummary?.body ?? "", /任务小结：浏览器控制已完成/);
|
||
assert.match(visibleSummary?.body ?? "", /周杰伦 MV/);
|
||
assert.ok(visibleSummary?.body.includes("youtube.com/results"));
|
||
assert.ok(!visibleSummary?.body.includes("\n"));
|
||
assert.equal(updatedProject?.preview, visibleSummary?.body);
|
||
assert.equal(updatedProject?.unreadCount, 1);
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages lets @主Agent trigger project summary sync that writes back to top entries", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
let state = await readState();
|
||
const seededProject = state.projects.find((project) => project.id === singleProject.id);
|
||
assert.ok(seededProject, "expected seeded single-thread project in state");
|
||
seededProject!.projectUnderstanding = undefined;
|
||
seededProject!.versions = [];
|
||
await writeState(state);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "@主Agent 请同步一下当前线程的项目目标和版本记录，同步完成记得告诉我" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyPresenter?: "thread" | "master";
|
||
replyMessage?: { body?: string };
|
||
task?: { taskId: string; taskType: string; status: string } | null;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.match(payload.replyMessage?.body ?? "", /项目目标.*版本记录/);
|
||
assert.match(payload.replyMessage?.body ?? "", /完成后.*告诉你|回你|回执/);
|
||
|
||
state = await readState();
|
||
const syncTask = state.masterAgentTasks.find((item) => item.taskId === payload.task?.taskId);
|
||
assert.ok(syncTask, "expected a hidden project understanding sync task for @主Agent summary sync");
|
||
assert.equal(syncTask?.projectId, "master-agent");
|
||
assert.equal(syncTask?.projectUnderstandingTargetProjectId, singleProject.id);
|
||
assert.equal(syncTask?.projectUnderstandingReplyProjectId, singleProject.id);
|
||
assert.equal(syncTask?.projectUnderstandingNotifyOnCompletion, true);
|
||
|
||
const completeResponse = await completeMasterTaskRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/master-agent/tasks/${syncTask!.taskId}/complete`,
|
||
"POST",
|
||
{
|
||
deviceId: syncTask!.deviceId,
|
||
status: "completed",
|
||
replyBody: JSON.stringify({
|
||
projectGoal: "把 @主Agent 触发的项目摘要同步也写回顶部入口",
|
||
currentProgress: "已经补上线程内 @主Agent 触发摘要同步的写回链路",
|
||
technicalArchitecture: "消息路由创建隐藏同步任务，状态账本持久化项目理解与版本记录",
|
||
currentBlockers: "",
|
||
recommendedNextStep: "继续做 Android 顶部入口真机回归",
|
||
versionRecord: "新增线程内 @主Agent 同步项目摘要后自动回写顶部入口。",
|
||
}),
|
||
},
|
||
),
|
||
{ params: Promise.resolve({ taskId: syncTask!.taskId }) },
|
||
);
|
||
assert.equal(completeResponse.status, 200);
|
||
|
||
state = await readState();
|
||
const updatedProject = state.projects.find((project) => project.id === singleProject.id);
|
||
assert.equal(updatedProject?.projectUnderstanding?.projectGoal, "把 @主Agent 触发的项目摘要同步也写回顶部入口");
|
||
assert.equal(updatedProject?.versions[0]?.summary, "新增线程内 @主Agent 同步项目摘要后自动回写顶部入口。");
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages lets takeover mode create browser control tasks with execution metadata", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, true);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "打开 Chrome 去后台看一下订单页" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyPresenter?: "thread" | "master";
|
||
task?: { taskId: string; taskType: string; status: string } | null;
|
||
executionMode?: string;
|
||
riskLevel?: string;
|
||
requiresConfirmation?: boolean;
|
||
};
|
||
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.equal(payload.task?.taskType, "browser_control");
|
||
assert.equal(payload.executionMode, "browser");
|
||
assert.equal(payload.riskLevel, "medium");
|
||
assert.equal(payload.requiresConfirmation, false);
|
||
|
||
const nextState = await readState();
|
||
const task = nextState.masterAgentTasks.find((item) => item.taskId === payload.task?.taskId);
|
||
assert.equal(task?.projectId, singleProject.id);
|
||
assert.equal(task?.taskType, "browser_control");
|
||
assert.equal(task?.intentCategory, "browser_control");
|
||
assert.equal(task?.runtimeKind, "browser-automation-runtime");
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages accepts punctuated master-agent mention variants", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "@ 主a'gent 帮我看下这个线程为什么不回消息" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyPresenter?: "thread" | "master";
|
||
task?: { taskId: string; taskType: string; status: string } | null;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.equal(payload.task?.taskType, "conversation_reply");
|
||
|
||
const nextState = await readState();
|
||
const task = nextState.masterAgentTasks.find((item) => item.taskId === payload.task?.taskId);
|
||
assert.ok(task, "expected the punctuated mention to queue a master-agent reply task");
|
||
assert.equal(task?.requestText, "帮我看下这个线程为什么不回消息");
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages lets a master mention enable current conversation takeover", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "@主Agent 帮我开启当前线程托管" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyPresenter?: "thread" | "master";
|
||
replyMessage?: { body: string };
|
||
task?: { taskId: string } | null;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.equal(payload.task, null);
|
||
assert.match(payload.replyMessage?.body ?? "", /已.*开启.*主 Agent 协同接管|已.*开启.*托管/);
|
||
|
||
const nextState = await readState();
|
||
const scopedControls = nextState.userProjectAgentControls.find(
|
||
(item) => item.projectId === singleProject.id && item.account === TEST_ACCOUNT,
|
||
);
|
||
assert.equal(scopedControls?.controls.takeoverEnabled, true);
|
||
|
||
const childThreadTask = nextState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.taskType === "conversation_reply" &&
|
||
item.projectId === singleProject.id &&
|
||
item.requestText === "@主Agent 帮我开启当前线程托管" &&
|
||
item.targetProjectId === singleProject.id,
|
||
);
|
||
assert.equal(childThreadTask, undefined, "takeover command should not be sent to the child thread");
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages lets a master mention disable current conversation takeover", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, true);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "@主Agent 退出当前的接管模式" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyPresenter?: "thread" | "master";
|
||
replyMessage?: { body: string };
|
||
task?: { taskId: string } | null;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.equal(payload.task, null);
|
||
assert.match(payload.replyMessage?.body ?? "", /已.*关闭.*主 Agent 协同接管|已.*退出.*接管/);
|
||
|
||
const nextState = await readState();
|
||
const scopedControls = nextState.userProjectAgentControls.find(
|
||
(item) => item.projectId === singleProject.id && item.account === TEST_ACCOUNT,
|
||
);
|
||
assert.equal(scopedControls?.controls.takeoverEnabled, false);
|
||
});
|
||
|
||
test("takeover mode can exit current conversation takeover directly from chat", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, true);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "退出当前的接管模式" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyPresenter?: "thread" | "master";
|
||
replyMessage?: { body: string };
|
||
task?: { taskId: string } | null;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.equal(payload.task, null);
|
||
assert.match(payload.replyMessage?.body ?? "", /已.*关闭.*主 Agent 协同接管|已.*退出.*接管/);
|
||
|
||
const nextState = await readState();
|
||
const scopedControls = nextState.userProjectAgentControls.find(
|
||
(item) => item.projectId === singleProject.id && item.account === TEST_ACCOUNT,
|
||
);
|
||
assert.equal(scopedControls?.controls.takeoverEnabled, false);
|
||
|
||
const genericTakeoverTask = nextState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.taskType === "conversation_reply" &&
|
||
item.projectId === singleProject.id &&
|
||
item.requestText === "退出当前的接管模式" &&
|
||
item.relayViaMasterAgent === true,
|
||
);
|
||
assert.equal(genericTakeoverTask, undefined, "exit takeover command should not enqueue a generic takeover reply");
|
||
});
|
||
|
||
test("master-agent conversation can enable takeover for a specified thread", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
"http://127.0.0.1:3000/api/v1/projects/master-agent/messages",
|
||
"POST",
|
||
{ body: `帮我开启${singleProject.threadMeta.threadDisplayName}的接管模式` },
|
||
),
|
||
{ params: Promise.resolve({ projectId: "master-agent" }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyPresenter?: "thread" | "master";
|
||
replyMessage?: { body: string };
|
||
task?: { taskId: string } | null;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.equal(payload.task, null);
|
||
assert.match(payload.replyMessage?.body ?? "", /已.*开启.*主 Agent 协同接管|已.*开启.*接管/);
|
||
assert.match(payload.replyMessage?.body ?? "", new RegExp(singleProject.threadMeta.threadDisplayName));
|
||
|
||
const nextState = await readState();
|
||
const scopedControls = nextState.userProjectAgentControls.find(
|
||
(item) => item.projectId === singleProject.id && item.account === TEST_ACCOUNT,
|
||
);
|
||
assert.equal(scopedControls?.controls.takeoverEnabled, true);
|
||
});
|
||
|
||
test("master-agent conversation can disable takeover for a specified thread", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, true);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
"http://127.0.0.1:3000/api/v1/projects/master-agent/messages",
|
||
"POST",
|
||
{ body: `帮我关闭${singleProject.threadMeta.threadDisplayName}的接管模式` },
|
||
),
|
||
{ params: Promise.resolve({ projectId: "master-agent" }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyPresenter?: "thread" | "master";
|
||
replyMessage?: { body: string };
|
||
task?: { taskId: string } | null;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.equal(payload.task, null);
|
||
assert.match(payload.replyMessage?.body ?? "", /已.*关闭.*主 Agent 协同接管|已.*退出.*接管/);
|
||
assert.match(payload.replyMessage?.body ?? "", new RegExp(singleProject.threadMeta.threadDisplayName));
|
||
|
||
const nextState = await readState();
|
||
const scopedControls = nextState.userProjectAgentControls.find(
|
||
(item) => item.projectId === singleProject.id && item.account === TEST_ACCOUNT,
|
||
);
|
||
assert.equal(scopedControls?.controls.takeoverEnabled, false);
|
||
});
|
||
|
||
test("takeover summary sync only queues verified project understanding and returns a concise ack", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, true);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "核对一下项目目标和版本记录，确认后同步到顶部入口" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyMessage?: { body: string };
|
||
replyPresenter?: "thread" | "master";
|
||
task?: { taskId: string; taskType: string; status: string } | null;
|
||
dispatchPlan: null;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.equal(payload.dispatchPlan, null);
|
||
assert.equal(payload.task?.taskType, "conversation_reply");
|
||
assert.ok(payload.replyMessage?.body.includes(singleProject.threadMeta.threadDisplayName));
|
||
assert.ok(payload.replyMessage?.body.includes("项目目标"));
|
||
assert.ok(payload.replyMessage?.body.includes("版本记录"));
|
||
assert.ok(!/OTA|在线设备|APP 日志|运行时|heartbeat|心跳/.test(payload.replyMessage?.body ?? ""));
|
||
|
||
const nextState = await readState();
|
||
const task = nextState.masterAgentTasks.find((item) => item.taskId === payload.task?.taskId);
|
||
assert.ok(task, "expected queued project understanding sync task");
|
||
assert.equal(task?.projectId, "master-agent");
|
||
assert.equal(task?.projectUnderstandingTargetProjectId, singleProject.id);
|
||
assert.equal(task?.relayViaMasterAgent, undefined);
|
||
assert.match(task!.executionPrompt, /只输出 JSON/);
|
||
assert.match(task!.executionPrompt, /不要把全局 OTA 可用状态/);
|
||
|
||
const understandingTask = nextState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.projectId === "master-agent" &&
|
||
item.projectUnderstandingTargetProjectId === singleProject.id &&
|
||
item.status === "queued",
|
||
);
|
||
assert.ok(understandingTask, "expected a hidden project understanding sync task");
|
||
assert.match(understandingTask!.executionPrompt, /先基于当前项目本地可见的开发文档和实际代码进行汇总/);
|
||
|
||
const genericTakeoverTask = nextState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.taskType === "conversation_reply" &&
|
||
item.projectId === singleProject.id &&
|
||
item.requestText === "核对一下项目目标和版本记录，确认后同步到顶部入口" &&
|
||
item.relayViaMasterAgent === true,
|
||
);
|
||
assert.equal(genericTakeoverTask, undefined, "summary sync should not also queue a generic master reply");
|
||
});
|
||
|
||
test("takeover summary wording also queues verified project understanding instead of a generic master reply", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, true);
|
||
|
||
const requestText = "帮我总结一下当前项目目标和版本记录";
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: requestText },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyMessage?: { body: string };
|
||
replyPresenter?: "thread" | "master";
|
||
task?: { taskId: string; taskType: string; status: string } | null;
|
||
dispatchPlan: null;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.equal(payload.dispatchPlan, null);
|
||
assert.ok(payload.replyMessage?.body.includes("项目目标"));
|
||
assert.ok(payload.replyMessage?.body.includes("版本记录"));
|
||
assert.ok(!/OTA|在线设备|APP 日志|运行时|heartbeat|心跳/.test(payload.replyMessage?.body ?? ""));
|
||
|
||
const nextState = await readState();
|
||
const understandingTask = nextState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.projectId === "master-agent" &&
|
||
item.projectUnderstandingTargetProjectId === singleProject.id &&
|
||
item.status === "queued",
|
||
);
|
||
assert.ok(understandingTask, "expected summary wording to queue a hidden project understanding sync task");
|
||
assert.equal(understandingTask!.requestText, `请同步项目《${singleProject.name}》当前目标与进度`);
|
||
|
||
const genericTakeoverTask = nextState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.taskType === "conversation_reply" &&
|
||
item.projectId === singleProject.id &&
|
||
item.requestText === requestText &&
|
||
item.relayViaMasterAgent === true,
|
||
);
|
||
assert.equal(genericTakeoverTask, undefined, "summary wording should not queue a generic master reply");
|
||
});
|
||
|
||
test("takeover summary sync remembers completion notice preference and replies after sync completes", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, true);
|
||
|
||
const requestText = "核对一下项目目标和版本记录，同步完成记得和我说，以后也是这样";
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: requestText },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyMessage?: { body: string };
|
||
task?: { taskId: string; taskType: string; status: string } | null;
|
||
};
|
||
|
||
assert.equal(payload.ok, true);
|
||
assert.match(payload.replyMessage?.body ?? "", /完成后.*回你|回执|告诉你/);
|
||
|
||
let state = await readState();
|
||
const rememberedRule = state.masterAgentMemories.find(
|
||
(memory) =>
|
||
memory.account === TEST_ACCOUNT &&
|
||
memory.scope === "global" &&
|
||
memory.memoryType === "workflow_rule" &&
|
||
/同步.*项目目标.*版本记录.*完成后.*提醒|项目摘要同步完成/.test(memory.title + memory.content),
|
||
);
|
||
assert.ok(rememberedRule, "expected the master agent to persist the completion notice preference");
|
||
|
||
const syncTask = state.masterAgentTasks.find((item) => item.taskId === payload.task?.taskId);
|
||
assert.ok(syncTask, "expected a hidden project understanding sync task");
|
||
assert.equal(syncTask.projectUnderstandingNotifyOnCompletion, true);
|
||
assert.equal(syncTask.projectUnderstandingReplyProjectId, singleProject.id);
|
||
|
||
const completeResponse = await completeMasterTaskRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/master-agent/tasks/${syncTask!.taskId}/complete`,
|
||
"POST",
|
||
{
|
||
deviceId: syncTask!.deviceId,
|
||
status: "completed",
|
||
replyBody: JSON.stringify({
|
||
projectGoal: "稳定 AI 眼镜线程的项目目标和版本记录同步",
|
||
currentProgress: "主 Agent 已基于本地文档重新汇总当前状态",
|
||
technicalArchitecture: "Boss 通过文件账本保存项目理解并由 Android 顶部入口读取",
|
||
currentBlockers: "",
|
||
recommendedNextStep: "继续用真机验证同步回执",
|
||
versionRecord: "新增项目目标和版本记录同步完成后的主动回执。",
|
||
}),
|
||
},
|
||
),
|
||
{ params: Promise.resolve({ taskId: syncTask!.taskId }) },
|
||
);
|
||
assert.equal(completeResponse.status, 200);
|
||
|
||
state = await readState();
|
||
const updatedProject = state.projects.find((project) => project.id === singleProject.id);
|
||
assert.equal(updatedProject?.projectUnderstanding?.projectGoal, "稳定 AI 眼镜线程的项目目标和版本记录同步");
|
||
assert.ok(
|
||
updatedProject?.messages.some((message) =>
|
||
/项目目标和版本记录已同步完成|同步完成/.test(message.body) &&
|
||
/顶部入口/.test(message.body),
|
||
),
|
||
"expected a completion notice in the conversation that requested the sync",
|
||
);
|
||
|
||
const followupResponse = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "再同步一下项目目标和版本记录" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(followupResponse.status, 200);
|
||
const followupPayload = (await followupResponse.json()) as {
|
||
replyMessage?: { body: string };
|
||
task?: { taskId: string } | null;
|
||
};
|
||
assert.match(followupPayload.replyMessage?.body ?? "", /完成后.*回你|回执|告诉你/);
|
||
|
||
state = await readState();
|
||
const followupTask: MasterAgentTask | undefined = state.masterAgentTasks.find(
|
||
(item) => item.taskId === followupPayload.task?.taskId,
|
||
);
|
||
assert.equal(followupTask?.projectUnderstandingNotifyOnCompletion, true);
|
||
assert.equal(followupTask?.projectUnderstandingReplyProjectId, singleProject.id);
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages still lets takeover mode talk to master agent during gui conflict", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, true);
|
||
|
||
const state = await readState();
|
||
const targetDevice = state.devices.find((device) => device.id === singleProject.deviceIds[0]);
|
||
assert.ok(targetDevice, "expected a seeded target device");
|
||
targetDevice.preferredExecutionMode = "gui";
|
||
await writeState(state);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "我先和你确认一下接下来怎么推进" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
replyPresenter?: "thread" | "master";
|
||
task?: { taskId: string; taskType: string; status: string } | null;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.replyPresenter, "master");
|
||
assert.equal(payload.task?.taskType, "conversation_reply");
|
||
|
||
const nextState = await readState();
|
||
const task = nextState.masterAgentTasks.find((item) => item.taskId === payload.task?.taskId);
|
||
assert.ok(task, "expected takeover mode to queue a master-agent task");
|
||
assert.equal(task?.relayViaMasterAgent, true);
|
||
assert.equal(task?.targetProjectId, undefined);
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages blocks single-thread sends when the target device prefers gui mode", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
const state = await readState();
|
||
const targetDevice = state.devices.find((device) => device.id === singleProject.deviceIds[0]);
|
||
assert.ok(targetDevice, "expected a seeded target device");
|
||
targetDevice.preferredExecutionMode = "gui";
|
||
await writeState(state);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "继续推进当前线程" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 409);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
code?: string;
|
||
message?: string;
|
||
executionConflict?: {
|
||
projectId: string;
|
||
deviceId: string;
|
||
preferredExecutionMode: "gui" | "cli";
|
||
allowPolicy: "forbid" | "allow_once" | "allow_always";
|
||
conflictState: "none" | "warning" | "blocked";
|
||
reason: string;
|
||
actions: string[];
|
||
};
|
||
};
|
||
|
||
assert.equal(payload.ok, false);
|
||
assert.equal(payload.code, "THREAD_EXECUTION_CONFLICT");
|
||
assert.equal(payload.executionConflict?.projectId, singleProject.id);
|
||
assert.equal(payload.executionConflict?.deviceId, singleProject.deviceIds[0]);
|
||
assert.equal(payload.executionConflict?.preferredExecutionMode, "gui");
|
||
assert.equal(payload.executionConflict?.allowPolicy, "forbid");
|
||
assert.equal(payload.executionConflict?.conflictState, "blocked");
|
||
assert.equal(payload.executionConflict?.reason, "preferred_gui_mode");
|
||
assert.deepEqual(payload.executionConflict?.actions, ["forbid", "allow_once", "allow_always"]);
|
||
|
||
const nextState = await readState();
|
||
const updatedProject = nextState.projects.find((project) => project.id === singleProject.id);
|
||
const blockedMessage = updatedProject?.messages.find((message) => message.body.includes("继续推进当前线程"));
|
||
assert.equal(blockedMessage, undefined, "blocked send should not append a local chat message");
|
||
const queuedTask = nextState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.taskType === "conversation_reply" &&
|
||
item.projectId === singleProject.id &&
|
||
item.requestText === "继续推进当前线程",
|
||
);
|
||
assert.equal(queuedTask, undefined, "blocked send should not enqueue a conversation task");
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages blocks single-thread sends when the current project folder is forbidden", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
const state = await readState();
|
||
const targetDevice = state.devices.find((device) => device.id === singleProject.deviceIds[0]);
|
||
assert.ok(targetDevice, "expected a seeded target device");
|
||
targetDevice.preferredExecutionMode = "cli";
|
||
state.projectExecutionPolicies = [
|
||
{
|
||
deviceId: singleProject.deviceIds[0],
|
||
folderKey: buildProjectFolderKey(singleProject),
|
||
projectId: singleProject.id,
|
||
allowPolicy: "forbid",
|
||
conflictState: "blocked",
|
||
updatedAt: "2026-04-06T13:20:00.000Z",
|
||
},
|
||
];
|
||
await writeState(state);
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "继续同步项目进度" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 409);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
code?: string;
|
||
executionConflict?: {
|
||
projectId: string;
|
||
folderKey?: string;
|
||
preferredExecutionMode: "gui" | "cli";
|
||
allowPolicy: "forbid" | "allow_once" | "allow_always";
|
||
conflictState: "none" | "warning" | "blocked";
|
||
reason: string;
|
||
};
|
||
};
|
||
|
||
assert.equal(payload.ok, false);
|
||
assert.equal(payload.code, "THREAD_EXECUTION_CONFLICT");
|
||
assert.equal(payload.executionConflict?.projectId, singleProject.id);
|
||
assert.equal(payload.executionConflict?.folderKey, buildProjectFolderKey(singleProject));
|
||
assert.equal(payload.executionConflict?.preferredExecutionMode, "cli");
|
||
assert.equal(payload.executionConflict?.allowPolicy, "forbid");
|
||
assert.equal(payload.executionConflict?.conflictState, "blocked");
|
||
assert.equal(payload.executionConflict?.reason, "project_conflict_forbid");
|
||
|
||
const nextState = await readState();
|
||
const updatedProject = nextState.projects.find((project) => project.id === singleProject.id);
|
||
const blockedMessage = updatedProject?.messages.find((message) => message.body.includes("继续同步项目进度"));
|
||
assert.equal(blockedMessage, undefined, "blocked send should not append a local chat message");
|
||
const queuedTask = nextState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.taskType === "conversation_reply" &&
|
||
item.projectId === singleProject.id &&
|
||
item.requestText === "继续同步项目进度",
|
||
);
|
||
assert.equal(queuedTask, undefined, "blocked send should not enqueue a conversation task");
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages blocks before queueing when recent codex activity exists without a stored policy", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
const recentExternalActivityAt = new Date(Date.now() - 60_000).toISOString();
|
||
const state = await readState();
|
||
await writeState({
|
||
...state,
|
||
projects: state.projects.map((project) =>
|
||
project.id === singleProject.id
|
||
? {
|
||
...project,
|
||
threadMeta: {
|
||
...project.threadMeta,
|
||
lastObservedCodexActivityAt: recentExternalActivityAt,
|
||
},
|
||
}
|
||
: project,
|
||
),
|
||
projectExecutionPolicies: state.projectExecutionPolicies.filter(
|
||
(policy) => policy.projectId !== singleProject.id,
|
||
),
|
||
});
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "请看一下这个项目现在卡在哪里" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 409);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
code?: string;
|
||
executionConflict?: {
|
||
projectId: string;
|
||
preferredExecutionMode: "gui" | "cli";
|
||
allowPolicy: "forbid" | "allow_once" | "allow_always";
|
||
conflictState: "none" | "warning" | "blocked";
|
||
reason: string;
|
||
};
|
||
};
|
||
assert.equal(payload.ok, false);
|
||
assert.equal(payload.code, "THREAD_EXECUTION_CONFLICT");
|
||
assert.equal(payload.executionConflict?.projectId, singleProject.id);
|
||
assert.equal(payload.executionConflict?.preferredExecutionMode, "cli");
|
||
assert.equal(payload.executionConflict?.allowPolicy, "forbid");
|
||
assert.equal(payload.executionConflict?.conflictState, "blocked");
|
||
assert.equal(payload.executionConflict?.reason, "project_conflict_forbid");
|
||
|
||
const nextState = await readState();
|
||
const updatedProject = nextState.projects.find((project) => project.id === singleProject.id);
|
||
const blockedMessage = updatedProject?.messages.find((message) =>
|
||
message.body.includes("请看一下这个项目现在卡在哪里"),
|
||
);
|
||
assert.equal(blockedMessage, undefined, "blocked send should not append a local chat message");
|
||
const queuedTask = nextState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.taskType === "conversation_reply" &&
|
||
item.projectId === singleProject.id &&
|
||
item.requestText === "请看一下这个项目现在卡在哪里",
|
||
);
|
||
assert.equal(queuedTask, undefined, "blocked send should not enqueue a conversation task");
|
||
});
|
||
|
||
test("POST /api/v1/projects/[projectId]/messages ignores stale scoped conflict policies", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
|
||
const staleExternalActivityAt = new Date(Date.now() - 30 * 60_000).toISOString();
|
||
const state = await readState();
|
||
await writeState({
|
||
...state,
|
||
projects: state.projects.map((project) =>
|
||
project.id === singleProject.id
|
||
? {
|
||
...project,
|
||
threadMeta: {
|
||
...project.threadMeta,
|
||
lastObservedCodexActivityAt: staleExternalActivityAt,
|
||
},
|
||
}
|
||
: project,
|
||
),
|
||
projectExecutionPolicies: [
|
||
...state.projectExecutionPolicies.filter((policy) => policy.projectId !== singleProject.id),
|
||
{
|
||
deviceId: singleProject.deviceIds[0],
|
||
folderKey: buildProjectFolderKey(singleProject),
|
||
projectId: singleProject.id,
|
||
allowPolicy: "forbid" as const,
|
||
conflictState: "blocked" as const,
|
||
recentExternalActivityAt: staleExternalActivityAt,
|
||
updatedAt: staleExternalActivityAt,
|
||
},
|
||
],
|
||
});
|
||
|
||
const response = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "继续同步这个线程" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const payload = (await response.json()) as {
|
||
ok: boolean;
|
||
task?: { taskId: string; taskType: string; status: string } | null;
|
||
};
|
||
assert.equal(payload.ok, true);
|
||
assert.equal(payload.task?.taskType, "conversation_reply");
|
||
assert.equal(payload.task?.status, "queued");
|
||
});
|
||
|
||
test("POST /api/v1/master-agent/tasks/[taskId]/complete writes the raw thread reply back to the single-thread project", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
const sendResponse = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "请同步一下当前阻塞情况" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
const sendPayload = (await sendResponse.json()) as {
|
||
task?: { taskId: string };
|
||
};
|
||
|
||
const queuedState = await readState();
|
||
const task = queuedState.masterAgentTasks.find(
|
||
(item) => item.taskId === sendPayload.task?.taskId,
|
||
);
|
||
assert.ok(task, "expected a queued conversation_reply task");
|
||
|
||
const response = await completeMasterTaskRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/master-agent/tasks/${task.taskId}/complete`,
|
||
"POST",
|
||
{
|
||
deviceId: task.deviceId,
|
||
status: "completed",
|
||
targetProjectId: singleProject.id,
|
||
targetThreadId: singleProject.threadMeta.threadId,
|
||
replyBody: "当前阻塞点已经同步：视觉验收待今晚回归。",
|
||
},
|
||
),
|
||
{ params: Promise.resolve({ taskId: task.taskId }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const nextState = await readState();
|
||
const updatedProject = nextState.projects.find((project) => project.id === singleProject.id);
|
||
const mirroredReply = updatedProject?.messages.find((message) =>
|
||
message.body.includes("当前阻塞点已经同步：视觉验收待今晚回归。"),
|
||
);
|
||
assert.ok(mirroredReply, "expected single-thread reply to be written back to the project");
|
||
assert.equal(mirroredReply?.sender, "device");
|
||
});
|
||
|
||
test("POST /api/v1/master-agent/tasks/[taskId]/complete folds thread commentary into thread_process and only counts final result unread", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "请继续推进当前线程" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
|
||
const queuedState = await readState();
|
||
const task = queuedState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.taskType === "conversation_reply" &&
|
||
item.projectId === singleProject.id &&
|
||
item.targetProjectId === singleProject.id,
|
||
);
|
||
assert.ok(task, "expected a queued conversation_reply task");
|
||
|
||
const processText = "我先检查聊天折叠链路，确认过程消息不会直接展开。";
|
||
const finalText = "这轮已经完成折叠修复，未读现在只会算最终结果。";
|
||
|
||
const processResponse = await completeMasterTaskRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/master-agent/tasks/${task.taskId}/complete`,
|
||
"POST",
|
||
{
|
||
deviceId: task.deviceId,
|
||
status: "completed",
|
||
targetProjectId: singleProject.id,
|
||
targetThreadId: singleProject.threadMeta.threadId,
|
||
replyBody: processText,
|
||
},
|
||
),
|
||
{ params: Promise.resolve({ taskId: task.taskId }) },
|
||
);
|
||
assert.equal(processResponse.status, 200);
|
||
|
||
let nextState = await readState();
|
||
let updatedProject = nextState.projects.find((project) => project.id === singleProject.id);
|
||
let processMessage = updatedProject?.messages.find((message) => message.body === processText);
|
||
|
||
assert.ok(processMessage, "expected process message to be written back");
|
||
assert.equal(processMessage?.kind, "thread_process");
|
||
assert.equal(updatedProject?.preview, "请继续推进当前线程");
|
||
assert.equal(updatedProject?.unreadCount, 0);
|
||
|
||
const finalTask = await queueMasterAgentTask({
|
||
projectId: singleProject.id,
|
||
taskType: "conversation_reply",
|
||
requestMessageId: "msg-final-round",
|
||
requestText: "继续推进当前线程",
|
||
executionPrompt: "请继续回复用户",
|
||
requestedBy: "Boss 超级管理员",
|
||
requestedByAccount: TEST_ACCOUNT,
|
||
deviceId: "mac-studio",
|
||
targetProjectId: singleProject.id,
|
||
targetThreadId: singleProject.threadMeta.threadId,
|
||
targetThreadDisplayName: singleProject.threadMeta.threadDisplayName,
|
||
targetCodexThreadRef: singleProject.threadMeta.codexThreadRef,
|
||
targetCodexFolderRef: singleProject.threadMeta.codexFolderRef,
|
||
});
|
||
|
||
const finalResponse = await completeMasterTaskRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/master-agent/tasks/${finalTask.taskId}/complete`,
|
||
"POST",
|
||
{
|
||
deviceId: finalTask.deviceId,
|
||
status: "completed",
|
||
targetProjectId: singleProject.id,
|
||
targetThreadId: singleProject.threadMeta.threadId,
|
||
replyBody: finalText,
|
||
},
|
||
),
|
||
{ params: Promise.resolve({ taskId: finalTask.taskId }) },
|
||
);
|
||
assert.equal(finalResponse.status, 200);
|
||
|
||
nextState = await readState();
|
||
updatedProject = nextState.projects.find((project) => project.id === singleProject.id);
|
||
processMessage = updatedProject?.messages.find((message) => message.body === processText);
|
||
const finalMessage = updatedProject?.messages.find((message) => message.body === finalText);
|
||
|
||
assert.equal(processMessage?.kind, "thread_process");
|
||
assert.equal(finalMessage?.kind, "text");
|
||
assert.equal(updatedProject?.preview, finalText);
|
||
assert.equal(updatedProject?.unreadCount, 1);
|
||
});
|
||
|
||
test("POST /api/v1/master-agent/tasks/[taskId]/complete keeps compact numbered progress updates folded", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "继续处理" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
|
||
const queuedState = await readState();
|
||
const task = queuedState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.taskType === "conversation_reply" &&
|
||
item.projectId === singleProject.id &&
|
||
item.targetProjectId === singleProject.id,
|
||
);
|
||
assert.ok(task, "expected a queued conversation_reply task");
|
||
|
||
const processText = [
|
||
"1. 先检查当前消息折叠链路。",
|
||
"2. 再确认 Android 端只把最终结果记成未读。",
|
||
"3. 处理完成后我会回你最终结果。"
|
||
].join("\n");
|
||
|
||
const processResponse = await completeMasterTaskRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/master-agent/tasks/${task.taskId}/complete`,
|
||
"POST",
|
||
{
|
||
deviceId: task.deviceId,
|
||
status: "completed",
|
||
targetProjectId: singleProject.id,
|
||
targetThreadId: singleProject.threadMeta.threadId,
|
||
replyBody: processText,
|
||
},
|
||
),
|
||
{ params: Promise.resolve({ taskId: task.taskId }) },
|
||
);
|
||
assert.equal(processResponse.status, 200);
|
||
|
||
const nextState = await readState();
|
||
const updatedProject = nextState.projects.find((project) => project.id === singleProject.id);
|
||
const processMessage = updatedProject?.messages.find((message) => message.body === processText);
|
||
|
||
assert.ok(processMessage, "expected compact process message to be written back");
|
||
assert.equal(processMessage?.kind, "thread_process");
|
||
assert.equal(updatedProject?.preview, "继续处理");
|
||
assert.equal(updatedProject?.unreadCount, 0);
|
||
});
|
||
|
||
test("device heartbeat keeps conversation preview on the latest non-process message", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
|
||
const state = await readState();
|
||
const project = state.projects.find((item) => item.id === singleProject.id);
|
||
if (!project) {
|
||
throw new Error("PROJECT_NOT_FOUND");
|
||
}
|
||
project.messages = [
|
||
{
|
||
id: "msg-final-existing",
|
||
sender: "device",
|
||
senderLabel: project.threadMeta.threadDisplayName,
|
||
body: "这是上一轮最终结果。",
|
||
sentAt: "2026-04-24T05:30:00.000Z",
|
||
kind: "text",
|
||
},
|
||
];
|
||
project.preview = "这是上一轮最终结果。";
|
||
project.lastMessageAt = "2026-04-24T05:30:00.000Z";
|
||
project.unreadCount = 0;
|
||
await writeState(state);
|
||
|
||
await upsertDeviceHeartbeat({
|
||
deviceId: "mac-studio",
|
||
token: (await readState()).devices.find((device) => device.id === "mac-studio")?.token,
|
||
name: "Mac Studio",
|
||
avatar: "M",
|
||
account: TEST_ACCOUNT,
|
||
status: "online",
|
||
quota5h: 90,
|
||
quota7d: 92,
|
||
projects: [],
|
||
endpoint: "mac://studio",
|
||
projectCandidates: [
|
||
{
|
||
folderName: singleProject.threadMeta.folderName,
|
||
folderRef: singleProject.threadMeta.codexFolderRef,
|
||
threadId: singleProject.threadMeta.threadId,
|
||
threadDisplayName: singleProject.threadMeta.threadDisplayName,
|
||
codexFolderRef: singleProject.threadMeta.codexFolderRef,
|
||
codexThreadRef: singleProject.threadMeta.codexThreadRef,
|
||
lastActiveAt: "2026-04-24T05:41:14.246Z",
|
||
suggestedImport: true,
|
||
recentAssistantMessages: [
|
||
{
|
||
messageId: "codex-thread:preview-keep:2026-04-24T05:41:14.246Z:p1",
|
||
body: "1. 先检查当前消息折叠链路。\n2. 再确认 Android 端只把最终结果记成未读。\n3. 处理完成后我会回你最终结果。",
|
||
sentAt: "2026-04-24T05:41:14.246Z",
|
||
phase: "commentary",
|
||
},
|
||
],
|
||
},
|
||
],
|
||
});
|
||
|
||
const nextState = await readState();
|
||
const updatedProject = nextState.projects.find((project) => project.id === singleProject.id);
|
||
const processMessage = updatedProject?.messages.find(
|
||
(message) => message.externalMessageId === "codex-thread:preview-keep:2026-04-24T05:41:14.246Z:p1",
|
||
);
|
||
|
||
assert.equal(processMessage?.kind, "thread_process");
|
||
assert.equal(updatedProject?.preview, "这是上一轮最终结果。");
|
||
assert.equal(updatedProject?.unreadCount, 0);
|
||
});
|
||
|
||
test("device heartbeat keeps conversation preview blank when only process messages are mirrored", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
|
||
const state = await readState();
|
||
const project = state.projects.find((item) => item.id === singleProject.id);
|
||
if (!project) {
|
||
throw new Error("PROJECT_NOT_FOUND");
|
||
}
|
||
project.messages = [];
|
||
project.preview = "历史遗留的过程预览";
|
||
project.lastMessageAt = "2026-04-24T05:30:00.000Z";
|
||
project.unreadCount = 0;
|
||
await writeState(state);
|
||
|
||
await upsertDeviceHeartbeat({
|
||
deviceId: "mac-studio",
|
||
token: (await readState()).devices.find((device) => device.id === "mac-studio")?.token,
|
||
name: "Mac Studio",
|
||
avatar: "M",
|
||
account: TEST_ACCOUNT,
|
||
status: "online",
|
||
quota5h: 90,
|
||
quota7d: 92,
|
||
projects: [],
|
||
endpoint: "mac://studio",
|
||
projectCandidates: [
|
||
{
|
||
folderName: singleProject.threadMeta.folderName,
|
||
folderRef: singleProject.threadMeta.codexFolderRef,
|
||
threadId: singleProject.threadMeta.threadId,
|
||
threadDisplayName: singleProject.threadMeta.threadDisplayName,
|
||
codexFolderRef: singleProject.threadMeta.codexFolderRef,
|
||
codexThreadRef: singleProject.threadMeta.codexThreadRef,
|
||
lastActiveAt: "2026-04-24T05:41:14.246Z",
|
||
suggestedImport: true,
|
||
recentAssistantMessages: [
|
||
{
|
||
messageId: "codex-thread:preview-empty:2026-04-24T05:41:14.246Z:p1",
|
||
body: "1. 先检查当前消息折叠链路。\n2. 再确认 Android 端只把最终结果记成未读。\n3. 处理完成后我会回你最终结果。",
|
||
sentAt: "2026-04-24T05:41:14.246Z",
|
||
phase: "commentary",
|
||
},
|
||
],
|
||
},
|
||
],
|
||
});
|
||
|
||
const nextState = await readState();
|
||
const updatedProject = nextState.projects.find((item) => item.id === singleProject.id);
|
||
const processMessage = updatedProject?.messages.find(
|
||
(message) => message.externalMessageId === "codex-thread:preview-empty:2026-04-24T05:41:14.246Z:p1",
|
||
);
|
||
|
||
assert.equal(processMessage?.kind, "thread_process");
|
||
assert.equal(updatedProject?.preview, "");
|
||
assert.equal(updatedProject?.unreadCount, 0);
|
||
});
|
||
|
||
test("legacy device process text is reclassified and no longer pollutes preview or unread", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
|
||
const state = await readState();
|
||
const project = state.projects.find((item) => item.id === singleProject.id);
|
||
if (!project) {
|
||
throw new Error("PROJECT_NOT_FOUND");
|
||
}
|
||
project.messages = [
|
||
{
|
||
id: "legacy-process",
|
||
sender: "device",
|
||
senderLabel: singleProject.threadMeta.threadDisplayName,
|
||
body: "我继续往下收，这一轮先检查折叠链路，再确认未读逻辑，随后回你结果。",
|
||
sentAt: "2026-04-24T05:45:00.000Z",
|
||
kind: "text",
|
||
},
|
||
{
|
||
id: "legacy-final",
|
||
sender: "device",
|
||
senderLabel: singleProject.threadMeta.threadDisplayName,
|
||
body: "这轮已经处理完成，最终结果已回写。",
|
||
sentAt: "2026-04-24T05:46:00.000Z",
|
||
kind: "text",
|
||
},
|
||
];
|
||
project.preview = "我继续往下收，这一轮先检查折叠链路，再确认未读逻辑，随后回你结果。";
|
||
project.lastMessageAt = "2026-04-24T05:46:00.000Z";
|
||
project.unreadCount = 2;
|
||
await writeState(state);
|
||
|
||
const nextState = await readState();
|
||
const updatedProject = nextState.projects.find((item) => item.id === singleProject.id);
|
||
const processMessage = updatedProject?.messages.find((message) => message.id === "legacy-process");
|
||
const finalMessage = updatedProject?.messages.find((message) => message.id === "legacy-final");
|
||
|
||
assert.equal(processMessage?.kind, "thread_process");
|
||
assert.equal(finalMessage?.kind, "text");
|
||
assert.equal(updatedProject?.preview, "这轮已经处理完成，最终结果已回写。");
|
||
assert.equal(updatedProject?.unreadCount, 1);
|
||
});
|
||
|
||
test("POST /api/v1/master-agent/tasks/[taskId]/complete writes takeover master replies to the current project", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, true);
|
||
|
||
const sendResponse = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "托管后请帮我问一下当前阻塞" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
const sendPayload = (await sendResponse.json()) as {
|
||
task?: { taskId: string };
|
||
};
|
||
|
||
const queuedState = await readState();
|
||
const task = queuedState.masterAgentTasks.find(
|
||
(item) => item.taskId === sendPayload.task?.taskId,
|
||
);
|
||
assert.ok(task, "expected a queued conversation_reply task");
|
||
assert.equal(task?.relayViaMasterAgent, true);
|
||
assert.equal(task?.targetProjectId, singleProject.id);
|
||
assert.equal(task?.targetThreadId, singleProject.threadMeta.threadId);
|
||
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
const response = await completeMasterTaskRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/master-agent/tasks/${task.taskId}/complete`,
|
||
"POST",
|
||
{
|
||
deviceId: task.deviceId,
|
||
status: "completed",
|
||
replyBody: "我先确认一下：你是希望我梳理当前阻塞后，再协调目标线程继续推进，对吗？",
|
||
},
|
||
),
|
||
{ params: Promise.resolve({ taskId: task.taskId }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const nextState = await readState();
|
||
const updatedProject = nextState.projects.find((project) => project.id === singleProject.id);
|
||
const relayedReply = updatedProject?.messages.find((message) =>
|
||
message.body.includes("我先确认一下：你是希望我梳理当前阻塞后，再协调目标线程继续推进，对吗？"),
|
||
);
|
||
assert.ok(relayedReply, "expected a master reply to be written back to the current project");
|
||
assert.equal(relayedReply?.sender, "master");
|
||
assert.match(relayedReply?.senderLabel ?? "", /主 Agent/);
|
||
});
|
||
|
||
test("POST /api/v1/master-agent/tasks/[taskId]/complete converts a mirrored takeover thread reply instead of duplicating it", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, true);
|
||
|
||
const sendResponse = await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "托管回归测试" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
const sendPayload = (await sendResponse.json()) as {
|
||
task?: { taskId: string };
|
||
};
|
||
const queuedState = await readState();
|
||
const task = queuedState.masterAgentTasks.find(
|
||
(item) => item.taskId === sendPayload.task?.taskId,
|
||
);
|
||
assert.ok(task, "expected a queued conversation_reply task");
|
||
assert.equal(task?.relayViaMasterAgent, true);
|
||
|
||
const replyBody = "主Agent托管链路已收到。";
|
||
const mirroredState = await readState();
|
||
const project = mirroredState.projects.find((item) => item.id === singleProject.id);
|
||
assert.ok(project);
|
||
project!.messages.push({
|
||
id: "msg-mirrored-before-complete",
|
||
sender: "device",
|
||
senderLabel: singleProject.threadMeta.threadDisplayName,
|
||
body: replyBody,
|
||
sentAt: new Date().toISOString(),
|
||
kind: "text",
|
||
externalMessageId: "codex-thread:takeover-dedupe:reply",
|
||
});
|
||
project!.preview = replyBody;
|
||
project!.unreadCount = 1;
|
||
await writeState(mirroredState);
|
||
|
||
const response = await completeMasterTaskRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/master-agent/tasks/${task.taskId}/complete`,
|
||
"POST",
|
||
{
|
||
deviceId: task.deviceId,
|
||
status: "completed",
|
||
replyBody,
|
||
},
|
||
),
|
||
{ params: Promise.resolve({ taskId: task.taskId }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const nextState = await readState();
|
||
const updatedProject = nextState.projects.find((item) => item.id === singleProject.id);
|
||
const replies = updatedProject?.messages.filter(
|
||
(message) => message.sender !== "user" && message.body === replyBody,
|
||
);
|
||
assert.equal(replies?.length, 1);
|
||
assert.equal(replies?.[0]?.sender, "master");
|
||
assert.match(replies?.[0]?.senderLabel ?? "", /主 Agent/);
|
||
assert.equal(replies?.[0]?.externalMessageId, "codex-thread:takeover-dedupe:reply");
|
||
assert.equal(updatedProject?.preview, replyBody);
|
||
assert.equal(updatedProject?.unreadCount, 1);
|
||
});
|
||
|
||
test("POST /api/v1/master-agent/tasks/[taskId]/complete blocks leaked thread environment diagnostics from the chat transcript", async () => {
|
||
await setup();
|
||
const singleProject = await ensureSingleThreadProject();
|
||
assert.ok(singleProject, "expected a seeded single-thread project");
|
||
await resetThreadExecutionState(singleProject.id);
|
||
await setProjectTakeover(singleProject.id, false);
|
||
|
||
await postMessageRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/projects/${singleProject.id}/messages`,
|
||
"POST",
|
||
{ body: "请继续推进当前线程" },
|
||
),
|
||
{ params: Promise.resolve({ projectId: singleProject.id }) },
|
||
);
|
||
|
||
const queuedState = await readState();
|
||
const task = queuedState.masterAgentTasks.find(
|
||
(item) =>
|
||
item.taskType === "conversation_reply" &&
|
||
item.projectId === singleProject.id &&
|
||
item.targetProjectId === singleProject.id,
|
||
);
|
||
assert.ok(task, "expected a queued conversation_reply task");
|
||
|
||
const response = await completeMasterTaskRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/master-agent/tasks/${task.taskId}/complete`,
|
||
"POST",
|
||
{
|
||
deviceId: task.deviceId,
|
||
status: "completed",
|
||
targetProjectId: singleProject.id,
|
||
targetThreadId: singleProject.threadMeta.threadId,
|
||
replyBody:
|
||
"我不能直接把当前会话环境从只读改回可写，也不能替你修改这层运行配置。cwd 我可以在命令里指向 /Users/kris/code/gptpluscontrol。",
|
||
},
|
||
),
|
||
{ params: Promise.resolve({ taskId: task.taskId }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const nextState = await readState();
|
||
const updatedProject = nextState.projects.find((project) => project.id === singleProject.id);
|
||
const leakedReply = updatedProject?.messages.find((message) =>
|
||
message.body.includes("当前会话环境从只读改回可写"),
|
||
);
|
||
assert.equal(leakedReply, undefined);
|
||
|
||
const opsNotice = updatedProject?.messages.find((message) =>
|
||
message.body.includes("线程环境异常，请重新绑定到正确项目或工作目录后再试。"),
|
||
);
|
||
assert.ok(opsNotice, "expected a user-facing system notice instead of raw environment diagnostics");
|
||
});
|
||
|
||
test("POST /api/v1/master-agent/tasks/[taskId]/complete hides leaked Codex CLI envelopes from master chat", async () => {
|
||
await setup();
|
||
const task = await queueMasterAgentTask({
|
||
projectId: "master-agent",
|
||
requestMessageId: "msg-master-cli-leak",
|
||
requestText: "同步完成记得要和我说，以后也是这样。",
|
||
executionPrompt: "请按主 Agent 规则回复用户。",
|
||
requestedBy: "Boss 超级管理员",
|
||
requestedByAccount: TEST_ACCOUNT,
|
||
deviceId: "mac-studio",
|
||
});
|
||
const leakedEnvelope = [
|
||
"OpenAI Codex v0.114.0 (research preview)",
|
||
"--------",
|
||
"workdir: /Users/kris/code/boss",
|
||
"model: gpt-5.4",
|
||
"provider: openai",
|
||
"approval: never",
|
||
"sandbox: workspace-write [workdir, /tmp, $TMPDIR, /Users/kris/.codex/memories]",
|
||
"session id: 019da4e5-9b1d-7dc1-8aa5-a74a74b6b021",
|
||
"--------",
|
||
"user",
|
||
"同步完成记得要和我说，以后也是这样。",
|
||
"mcp: chrome-devtools starting",
|
||
].join("\n");
|
||
|
||
const response = await completeMasterTaskRoute(
|
||
await createAuthedRequest(
|
||
`http://127.0.0.1:3000/api/v1/master-agent/tasks/${task.taskId}/complete`,
|
||
"POST",
|
||
{
|
||
deviceId: task.deviceId,
|
||
status: "failed",
|
||
errorMessage: leakedEnvelope,
|
||
},
|
||
),
|
||
{ params: Promise.resolve({ taskId: task.taskId }) },
|
||
);
|
||
assert.equal(response.status, 200);
|
||
|
||
const nextState = await readState();
|
||
const masterProject = nextState.projects.find((project) => project.id === "master-agent");
|
||
const leakedMessage = masterProject?.messages.find((message) =>
|
||
/OpenAI Codex|workdir:|sandbox:|session id:|mcp: chrome-devtools/.test(message.body),
|
||
);
|
||
assert.equal(leakedMessage, undefined);
|
||
assert.ok(
|
||
masterProject?.messages.some((message) =>
|
||
message.body.includes("主 Agent 执行节点返回了内部启动日志，已拦截"),
|
||
),
|
||
"expected a concise user-facing failure notice",
|
||
);
|
||
});
|