385 lines
15 KiB
TypeScript
385 lines
15 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 getDispatchPlansRoute: (typeof import("../src/app/api/v1/projects/[projectId]/dispatch-plans/route"))["GET"];
|
|
let confirmDispatchPlanRoute: (typeof import("../src/app/api/v1/projects/[projectId]/dispatch-plans/[planId]/confirm/route"))["POST"];
|
|
let rejectDispatchPlanRoute: (typeof import("../src/app/api/v1/projects/[projectId]/dispatch-plans/[planId]/reject/route"))["POST"];
|
|
let retryDispatchPlanRoute: (typeof import("../src/app/api/v1/projects/[projectId]/dispatch-plans/[planId]/retry/route"))["POST"];
|
|
let createAuthSession: (typeof import("../src/lib/boss-data"))["createAuthSession"];
|
|
let createProjectGroupChat: (typeof import("../src/lib/boss-data"))["createProjectGroupChat"];
|
|
let isDispatchableThreadProject: (typeof import("../src/lib/boss-data"))["isDispatchableThreadProject"];
|
|
let readState: (typeof import("../src/lib/boss-data"))["readState"];
|
|
let writeState: (typeof import("../src/lib/boss-data"))["writeState"];
|
|
let AUTH_SESSION_COOKIE = "";
|
|
|
|
async function setup() {
|
|
if (runtimeRoot) {
|
|
return;
|
|
}
|
|
|
|
runtimeRoot = await mkdtemp(path.join(os.tmpdir(), "boss-task4-"));
|
|
process.env.BOSS_RUNTIME_ROOT = runtimeRoot;
|
|
process.env.BOSS_STATE_FILE = path.join(runtimeRoot, "boss-state.json");
|
|
|
|
const [messageModule, plansModule, confirmModule, rejectModule, retryModule, data, auth] = await Promise.all([
|
|
import("../src/app/api/v1/projects/[projectId]/messages/route.ts"),
|
|
import("../src/app/api/v1/projects/[projectId]/dispatch-plans/route.ts"),
|
|
import("../src/app/api/v1/projects/[projectId]/dispatch-plans/[planId]/confirm/route.ts"),
|
|
import("../src/app/api/v1/projects/[projectId]/dispatch-plans/[planId]/reject/route.ts"),
|
|
import("../src/app/api/v1/projects/[projectId]/dispatch-plans/[planId]/retry/route.ts"),
|
|
import("../src/lib/boss-data.ts"),
|
|
import("../src/lib/boss-auth.ts"),
|
|
]);
|
|
|
|
postMessageRoute = messageModule.POST;
|
|
getDispatchPlansRoute = plansModule.GET;
|
|
confirmDispatchPlanRoute = confirmModule.POST;
|
|
rejectDispatchPlanRoute = rejectModule.POST;
|
|
retryDispatchPlanRoute = retryModule.POST;
|
|
createAuthSession = data.createAuthSession;
|
|
createProjectGroupChat = data.createProjectGroupChat;
|
|
isDispatchableThreadProject = data.isDispatchableThreadProject;
|
|
readState = data.readState;
|
|
writeState = data.writeState;
|
|
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: "GET" | "POST", body?: unknown) {
|
|
const session = await createAuthSession({
|
|
account: "17600003315",
|
|
role: "highest_admin",
|
|
displayName: "Boss 超级管理员",
|
|
loginMethod: "password",
|
|
});
|
|
|
|
return new NextRequest(url, {
|
|
method,
|
|
headers: {
|
|
"content-type": "application/json",
|
|
cookie: `${AUTH_SESSION_COOKIE}=${session.sessionToken}`,
|
|
},
|
|
body: body ? JSON.stringify(body) : undefined,
|
|
});
|
|
}
|
|
|
|
async function ensureTwoSingleThreadProjects() {
|
|
const state = await readState();
|
|
const singles = state.projects.filter((project) => isDispatchableThreadProject(project));
|
|
if (singles.length >= 2) {
|
|
return singles;
|
|
}
|
|
|
|
assert.ok(singles[0], "expected at least one seeded single-thread project");
|
|
const seed = singles[0];
|
|
const clonedProject = {
|
|
...seed,
|
|
id: "boss-console-clone",
|
|
name: "Boss 移动控制台副线程",
|
|
deviceIds: [...seed.deviceIds],
|
|
updatedAt: "2026-03-30T10:00:00+08:00",
|
|
lastMessageAt: "2026-03-30T10:00:00+08:00",
|
|
preview: "副线程等待主 Agent 汇总阻塞点。",
|
|
threadMeta: {
|
|
...seed.threadMeta,
|
|
projectId: "boss-console-clone",
|
|
threadId: "thread-boss-ui-clone",
|
|
threadDisplayName: "南区试产线回归",
|
|
folderName: "阻塞梳理",
|
|
updatedAt: "2026-03-30T10:00:00+08:00",
|
|
codexThreadRef: "thread-boss-ui-clone",
|
|
codexFolderRef: "boss-console-clone",
|
|
},
|
|
groupMembers: [],
|
|
messages: [
|
|
{
|
|
id: "msg-boss-console-clone",
|
|
sender: "device" as const,
|
|
senderLabel: "Win GPU / Codex",
|
|
body: "这里还在等待视觉链路复核。",
|
|
sentAt: "2026-03-30T10:00:00+08:00",
|
|
kind: "text" as const,
|
|
},
|
|
],
|
|
goals: [],
|
|
versions: [],
|
|
};
|
|
|
|
await writeState({
|
|
...state,
|
|
projects: [...state.projects, clonedProject],
|
|
});
|
|
|
|
const nextState = await readState();
|
|
return nextState.projects.filter((project) => isDispatchableThreadProject(project));
|
|
}
|
|
|
|
async function createDispatchPlanForTest() {
|
|
await setup();
|
|
const memberProjects = await ensureTwoSingleThreadProjects();
|
|
const groupProject = await createProjectGroupChat({
|
|
sourceProjectId: memberProjects[0].id,
|
|
memberProjectIds: [memberProjects[1].id],
|
|
createdBy: "17600003315",
|
|
});
|
|
|
|
const response = await postMessageRoute(
|
|
await createAuthedRequest(
|
|
`http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/messages`,
|
|
"POST",
|
|
{ body: "请主 Agent 推荐要先同步的线程" },
|
|
),
|
|
{ params: Promise.resolve({ projectId: groupProject.id }) },
|
|
);
|
|
assert.equal(response.status, 200);
|
|
const payload = (await response.json()) as {
|
|
dispatchPlan: { planId: string; targets: Array<{ projectId: string }> } | null;
|
|
};
|
|
assert.ok(payload.dispatchPlan, "expected seeded dispatch plan");
|
|
return { groupProject, dispatchPlan: payload.dispatchPlan };
|
|
}
|
|
|
|
test("GET /api/v1/projects/[projectId]/dispatch-plans lists the latest group dispatch plans", async () => {
|
|
const { groupProject, dispatchPlan } = await createDispatchPlanForTest();
|
|
|
|
const response = await getDispatchPlansRoute(
|
|
await createAuthedRequest(
|
|
`http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans`,
|
|
"GET",
|
|
),
|
|
{ params: Promise.resolve({ projectId: groupProject.id }) },
|
|
);
|
|
assert.equal(response.status, 200);
|
|
|
|
const payload = (await response.json()) as {
|
|
ok: boolean;
|
|
plans: Array<{ planId: string; requestMessageId: string; status: string }>;
|
|
};
|
|
assert.equal(payload.ok, true);
|
|
assert.equal(payload.plans[0]?.planId, dispatchPlan.planId);
|
|
assert.equal(payload.plans[0]?.status, "pending_user_confirmation");
|
|
});
|
|
|
|
test("POST /api/v1/projects/[projectId]/dispatch-plans/[planId]/confirm confirms targets, creates executions, and writes a master-agent notice", async () => {
|
|
const { groupProject, dispatchPlan } = await createDispatchPlanForTest();
|
|
const approvedTargetProjectId = dispatchPlan.targets[0]?.projectId;
|
|
assert.ok(approvedTargetProjectId, "expected a recommended target project");
|
|
|
|
const response = await confirmDispatchPlanRoute(
|
|
await createAuthedRequest(
|
|
`http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans/${dispatchPlan.planId}/confirm`,
|
|
"POST",
|
|
{ approvedTargetProjectIds: [approvedTargetProjectId] },
|
|
),
|
|
{ params: Promise.resolve({ projectId: groupProject.id, planId: dispatchPlan.planId }) },
|
|
);
|
|
assert.equal(response.status, 200);
|
|
|
|
const payload = (await response.json()) as {
|
|
ok: boolean;
|
|
plan: { planId: string; status: string; confirmedTargetProjectIds: string[] };
|
|
executions: Array<{ planId: string; targetProjectId: string; status: string }>;
|
|
notice: { kind: string; body: string } | null;
|
|
collaborationGate: {
|
|
isGroup: boolean;
|
|
collaborationMode: string;
|
|
requiresMasterAgentApproval: boolean;
|
|
approvalState: string;
|
|
};
|
|
};
|
|
assert.equal(payload.ok, true);
|
|
assert.equal(payload.plan.planId, dispatchPlan.planId);
|
|
assert.equal(payload.plan.status, "dispatched");
|
|
assert.deepEqual(payload.plan.confirmedTargetProjectIds, [approvedTargetProjectId]);
|
|
assert.equal(payload.executions.length, 1);
|
|
assert.equal(payload.executions[0]?.planId, dispatchPlan.planId);
|
|
assert.equal(payload.executions[0]?.targetProjectId, approvedTargetProjectId);
|
|
assert.equal(payload.executions[0]?.status, "queued");
|
|
assert.ok(payload.notice, "expected a confirmation notice in the response");
|
|
assert.equal(payload.notice?.kind, "system_notice");
|
|
assert.equal(payload.notice?.body, "已确认下发到 1 个线程：《北区试产线回归》。");
|
|
assert.equal(payload.collaborationGate.isGroup, true);
|
|
assert.equal(payload.collaborationGate.collaborationMode, "development");
|
|
assert.equal(payload.collaborationGate.requiresMasterAgentApproval, false);
|
|
assert.equal(payload.collaborationGate.approvalState, "not_required");
|
|
|
|
const nextState = await readState();
|
|
const notice = nextState.projects
|
|
.find((project) => project.id === groupProject.id)
|
|
?.messages.find(
|
|
(message) =>
|
|
message.sender === "master" &&
|
|
message.kind === "system_notice" &&
|
|
message.body.includes("已确认下发到 1 个线程"),
|
|
);
|
|
assert.ok(notice, "expected a master-agent notice in the group chat after confirmation");
|
|
});
|
|
|
|
test("confirming a dispatch plan marks approval_required groups as approved", async () => {
|
|
const { groupProject, dispatchPlan } = await createDispatchPlanForTest();
|
|
const approvedTargetProjectId = dispatchPlan.targets[0]?.projectId;
|
|
assert.ok(approvedTargetProjectId, "expected a recommended target project");
|
|
|
|
const state = await readState();
|
|
await writeState({
|
|
...state,
|
|
projects: state.projects.map((project) =>
|
|
project.id === groupProject.id
|
|
? {
|
|
...project,
|
|
collaborationMode: "approval_required" as const,
|
|
approvalState: "pending_user" as const,
|
|
}
|
|
: project,
|
|
),
|
|
});
|
|
|
|
const response = await confirmDispatchPlanRoute(
|
|
await createAuthedRequest(
|
|
`http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans/${dispatchPlan.planId}/confirm`,
|
|
"POST",
|
|
{ approvedTargetProjectIds: [approvedTargetProjectId] },
|
|
),
|
|
{ params: Promise.resolve({ projectId: groupProject.id, planId: dispatchPlan.planId }) },
|
|
);
|
|
assert.equal(response.status, 200);
|
|
|
|
const nextState = await readState();
|
|
const nextGroupProject = nextState.projects.find((project) => project.id === groupProject.id);
|
|
assert.ok(nextGroupProject, "expected group project to remain present");
|
|
assert.equal(nextGroupProject?.approvalState, "approved");
|
|
});
|
|
|
|
test("rejecting a dispatch plan marks approval_required groups as rejected and writes a system notice", async () => {
|
|
const { groupProject, dispatchPlan } = await createDispatchPlanForTest();
|
|
|
|
const state = await readState();
|
|
await writeState({
|
|
...state,
|
|
projects: state.projects.map((project) =>
|
|
project.id === groupProject.id
|
|
? {
|
|
...project,
|
|
collaborationMode: "approval_required" as const,
|
|
approvalState: "pending_user" as const,
|
|
}
|
|
: project,
|
|
),
|
|
});
|
|
|
|
const response = await rejectDispatchPlanRoute(
|
|
await createAuthedRequest(
|
|
`http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans/${dispatchPlan.planId}/reject`,
|
|
"POST",
|
|
{},
|
|
),
|
|
{ params: Promise.resolve({ projectId: groupProject.id, planId: dispatchPlan.planId }) },
|
|
);
|
|
assert.equal(response.status, 200);
|
|
|
|
const payload = (await response.json()) as {
|
|
ok: boolean;
|
|
plan: { planId: string; status: string };
|
|
notice: { kind: string; body: string };
|
|
collaborationGate: {
|
|
isGroup: boolean;
|
|
collaborationMode: string;
|
|
requiresMasterAgentApproval: boolean;
|
|
approvalState: string;
|
|
};
|
|
};
|
|
assert.equal(payload.ok, true);
|
|
assert.equal(payload.plan.planId, dispatchPlan.planId);
|
|
assert.equal(payload.plan.status, "rejected");
|
|
assert.equal(payload.notice.kind, "system_notice");
|
|
assert.equal(payload.notice.body, "已拒绝主 Agent 推荐，本次不会下发到任何线程。");
|
|
assert.equal(payload.collaborationGate.isGroup, true);
|
|
assert.equal(payload.collaborationGate.collaborationMode, "approval_required");
|
|
assert.equal(payload.collaborationGate.requiresMasterAgentApproval, true);
|
|
assert.equal(payload.collaborationGate.approvalState, "rejected");
|
|
|
|
const nextState = await readState();
|
|
const nextGroupProject = nextState.projects.find((project) => project.id === groupProject.id);
|
|
assert.ok(nextGroupProject, "expected group project to remain present");
|
|
assert.equal(nextGroupProject?.approvalState, "rejected");
|
|
const notice = nextGroupProject?.messages.find(
|
|
(message) =>
|
|
message.kind === "system_notice" &&
|
|
message.body.includes("已拒绝主 Agent 推荐"),
|
|
);
|
|
assert.ok(notice, "expected rejection notice in group chat");
|
|
});
|
|
|
|
test("retrying a rejected dispatch plan creates a fresh pending recommendation and resets approval gate", async () => {
|
|
const { groupProject, dispatchPlan } = await createDispatchPlanForTest();
|
|
|
|
const state = await readState();
|
|
await writeState({
|
|
...state,
|
|
projects: state.projects.map((project) =>
|
|
project.id === groupProject.id
|
|
? {
|
|
...project,
|
|
collaborationMode: "approval_required" as const,
|
|
approvalState: "pending_user" as const,
|
|
}
|
|
: project,
|
|
),
|
|
});
|
|
|
|
const rejectResponse = await rejectDispatchPlanRoute(
|
|
await createAuthedRequest(
|
|
`http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans/${dispatchPlan.planId}/reject`,
|
|
"POST",
|
|
{},
|
|
),
|
|
{ params: Promise.resolve({ projectId: groupProject.id, planId: dispatchPlan.planId }) },
|
|
);
|
|
assert.equal(rejectResponse.status, 200);
|
|
|
|
const retryResponse = await retryDispatchPlanRoute(
|
|
await createAuthedRequest(
|
|
`http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans/${dispatchPlan.planId}/retry`,
|
|
"POST",
|
|
{},
|
|
),
|
|
{ params: Promise.resolve({ projectId: groupProject.id, planId: dispatchPlan.planId }) },
|
|
);
|
|
assert.equal(retryResponse.status, 200);
|
|
|
|
const retryPayload = (await retryResponse.json()) as {
|
|
ok: boolean;
|
|
dispatchPlan: { planId: string; status: string; requestMessageId: string } | null;
|
|
collaborationGate: {
|
|
approvalState: string;
|
|
requiresMasterAgentApproval: boolean;
|
|
collaborationMode: string;
|
|
};
|
|
};
|
|
assert.equal(retryPayload.ok, true);
|
|
assert.ok(retryPayload.dispatchPlan, "expected a fresh dispatch recommendation");
|
|
assert.notEqual(retryPayload.dispatchPlan?.planId, dispatchPlan.planId);
|
|
assert.equal(retryPayload.dispatchPlan?.status, "pending_user_confirmation");
|
|
assert.match(retryPayload.dispatchPlan?.requestMessageId ?? "", /:retry:/);
|
|
assert.equal(retryPayload.collaborationGate.collaborationMode, "approval_required");
|
|
assert.equal(retryPayload.collaborationGate.requiresMasterAgentApproval, true);
|
|
assert.equal(retryPayload.collaborationGate.approvalState, "pending_user");
|
|
|
|
const nextState = await readState();
|
|
const refreshedPlan = nextState.dispatchPlans.find((plan) => plan.planId === retryPayload.dispatchPlan?.planId);
|
|
assert.ok(refreshedPlan, "expected retried dispatch plan in state");
|
|
const nextGroupProject = nextState.projects.find((project) => project.id === groupProject.id);
|
|
assert.equal(nextGroupProject?.approvalState, "pending_user");
|
|
});
|