krisolo/boss
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: wire dispatch execution and device import flows

Browse Source
This commit is contained in:
kris
2026-03-30 11:08:43 +08:00
parent 3b2bf59b65
commit 745b47e812
16 changed files with 1545 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

209
tests/device-import-draft.test.ts Normal file
View File

@@ -0,0 +1,209 @@
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 createEnrollmentRoute: (typeof import("../src/app/api/v1/devices/enrollments/route"))["POST"];
let deviceHeartbeatRoute: (typeof import("../src/app/api/device-heartbeat/route"))["POST"];
let getImportDraftRoute: (typeof import("../src/app/api/v1/devices/[deviceId]/import-draft/route"))["GET"];
let selectImportDraftRoute: (typeof import("../src/app/api/v1/devices/[deviceId]/import-draft/select/route"))["POST"];
let reviewImportDraftRoute: (typeof import("../src/app/api/v1/devices/[deviceId]/import-draft/review/route"))["POST"];
let applyImportDraftRoute: (typeof import("../src/app/api/v1/devices/[deviceId]/import-draft/apply/route"))["POST"];
let createAuthSession: (typeof import("../src/lib/boss-data"))["createAuthSession"];
let readState: (typeof import("../src/lib/boss-data"))["readState"];
let AUTH_SESSION_COOKIE = "";
async function setup() {
if (runtimeRoot) return;
runtimeRoot = await mkdtemp(path.join(os.tmpdir(), "boss-device-import-"));
process.env.BOSS_RUNTIME_ROOT = runtimeRoot;
process.env.BOSS_STATE_FILE = path.join(runtimeRoot, "boss-state.json");
const [enrollmentModule, heartbeatModule, importDraftModule, selectModule, reviewModule, applyModule, data, auth] =
await Promise.all([
import("../src/app/api/v1/devices/enrollments/route.ts"),
import("../src/app/api/device-heartbeat/route.ts"),
import("../src/app/api/v1/devices/[deviceId]/import-draft/route.ts"),
import("../src/app/api/v1/devices/[deviceId]/import-draft/select/route.ts"),
import("../src/app/api/v1/devices/[deviceId]/import-draft/review/route.ts"),
import("../src/app/api/v1/devices/[deviceId]/import-draft/apply/route.ts"),
import("../src/lib/boss-data.ts"),
import("../src/lib/boss-auth.ts"),
]);
createEnrollmentRoute = enrollmentModule.POST;
deviceHeartbeatRoute = heartbeatModule.POST;
getImportDraftRoute = importDraftModule.GET;
selectImportDraftRoute = selectModule.POST;
reviewImportDraftRoute = reviewModule.POST;
applyImportDraftRoute = applyModule.POST;
createAuthSession = data.createAuthSession;
readState = data.readState;
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: {
cookie: `${AUTH_SESSION_COOKIE}=${session.sessionToken}`,
...(body ? { "content-type": "application/json" } : {}),
},
body: body ? JSON.stringify(body) : undefined,
});
}
test("device import draft flow scans candidates, selects imports, resolves suggestions, and creates real chat windows", async () => {
await setup();
const enrollmentResponse = await createEnrollmentRoute(
await createAuthedRequest("http://127.0.0.1:3000/api/v1/devices/enrollments", "POST", {
name: "MacBook Pro",
avatar: "P",
account: "17600003315",
endpoint: "mac://mbp.local",
note: "待导入新设备",
}),
);
assert.equal(enrollmentResponse.status, 200);
const enrollmentPayload = (await enrollmentResponse.json()) as {
enrollment: { deviceId: string; pairingCode: string };
device: { id: string };
};
const heartbeatResponse = await deviceHeartbeatRoute(
new NextRequest("http://127.0.0.1:3000/api/device-heartbeat", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({
deviceId: enrollmentPayload.device.id,
pairingCode: enrollmentPayload.enrollment.pairingCode,
name: "MacBook Pro",
avatar: "P",
account: "17600003315",
status: "online",
quota5h: 72,
quota7d: 88,
projects: [],
endpoint: "mac://mbp.local",
projectCandidates: [
{
folderName: "北区试产线",
folderRef: "north-line",
threadId: "thread-north-regression",
threadDisplayName: "北区试产线回归",
codexFolderRef: "north-line",
codexThreadRef: "thread-north-regression",
lastActiveAt: "2026-03-30T10:18:00+08:00",
suggestedImport: true,
},
{
folderName: "北区试产线",
folderRef: "north-line",
threadId: "thread-north-audit",
threadDisplayName: "北区试产线审计",
codexFolderRef: "north-line",
codexThreadRef: "thread-north-audit",
lastActiveAt: "2026-03-30T10:20:00+08:00",
suggestedImport: true,
},
],
}),
}),
);
assert.equal(heartbeatResponse.status, 200);
const draftResponse = await getImportDraftRoute(
await createAuthedRequest(
`http://127.0.0.1:3000/api/v1/devices/${enrollmentPayload.device.id}/import-draft`,
"GET",
),
{ params: Promise.resolve({ deviceId: enrollmentPayload.device.id }) },
);
assert.equal(draftResponse.status, 200);
const draftPayload = (await draftResponse.json()) as {
draft: { draftId: string; candidates: Array<{ candidateId: string; threadDisplayName: string }> } | null;
};
assert.ok(draftPayload.draft, "expected an import draft after heartbeat candidates");
assert.equal(draftPayload.draft.candidates.length, 2);
const selectedCandidateIds = draftPayload.draft.candidates
.filter((candidate) => candidate.threadDisplayName === "北区试产线回归")
.map((candidate) => candidate.candidateId);
assert.equal(selectedCandidateIds.length, 1);
const selectResponse = await selectImportDraftRoute(
await createAuthedRequest(
`http://127.0.0.1:3000/api/v1/devices/${enrollmentPayload.device.id}/import-draft/select`,
"POST",
{ selectedCandidateIds },
),
{ params: Promise.resolve({ deviceId: enrollmentPayload.device.id }) },
);
assert.equal(selectResponse.status, 200);
const reviewResponse = await reviewImportDraftRoute(
await createAuthedRequest(
`http://127.0.0.1:3000/api/v1/devices/${enrollmentPayload.device.id}/import-draft/review`,
"POST",
{},
),
{ params: Promise.resolve({ deviceId: enrollmentPayload.device.id }) },
);
assert.equal(reviewResponse.status, 200);
const reviewPayload = (await reviewResponse.json()) as {
resolution: { summary: string; items: Array<{ action: string; threadDisplayName: string }> };
};
assert.match(reviewPayload.resolution.summary, /MacBook Pro 导入建议/);
assert.deepEqual(
reviewPayload.resolution.items.map((item) => item.action),
["create_thread_conversation"],
);
const applyResponse = await applyImportDraftRoute(
await createAuthedRequest(
`http://127.0.0.1:3000/api/v1/devices/${enrollmentPayload.device.id}/import-draft/apply`,
"POST",
{},
),
{ params: Promise.resolve({ deviceId: enrollmentPayload.device.id }) },
);
assert.equal(applyResponse.status, 200);
const nextState = await readState();
const importedProject = nextState.projects.find(
(project) => project.threadMeta.codexThreadRef === "thread-north-regression",
);
assert.ok(importedProject, "expected selected candidate to become a real chat window");
assert.equal(importedProject?.threadMeta.threadDisplayName, "北区试产线回归");
assert.equal(importedProject?.threadMeta.folderName, "北区试产线");
const device = nextState.devices.find((item) => item.id === enrollmentPayload.device.id);
assert.deepEqual(device?.projects, ["北区试产线"]);
const appliedDraft = nextState.deviceImportDrafts.find(
(draft) => draft.deviceId === enrollmentPayload.device.id,
);
const appliedResolution = nextState.deviceImportResolutions.find(
(resolution) => resolution.deviceId === enrollmentPayload.device.id,
);
assert.equal(appliedDraft?.status, "applied");
assert.equal(appliedResolution?.status, "applied");
});

222
tests/dispatch-execution-result.test.ts Normal file
View File

@@ -0,0 +1,222 @@
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 confirmDispatchPlanRoute: (typeof import("../src/app/api/v1/projects/[projectId]/dispatch-plans/[planId]/confirm/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 createProjectGroupChat: (typeof import("../src/lib/boss-data"))["createProjectGroupChat"];
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-task5-"));
process.env.BOSS_RUNTIME_ROOT = runtimeRoot;
process.env.BOSS_STATE_FILE = path.join(runtimeRoot, "boss-state.json");
const [messageModule, confirmModule, completeModule, data, auth] = await Promise.all([
import("../src/app/api/v1/projects/[projectId]/messages/route.ts"),
import("../src/app/api/v1/projects/[projectId]/dispatch-plans/[planId]/confirm/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;
confirmDispatchPlanRoute = confirmModule.POST;
completeMasterTaskRoute = completeModule.POST;
createAuthSession = data.createAuthSession;
createProjectGroupChat = data.createProjectGroupChat;
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: "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: JSON.stringify(body),
});
}
async function ensureTwoSingleThreadProjects() {
const state = await readState();
const singles = state.projects.filter((project) => project.id !== "master-agent" && !project.isGroup);
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: ["win-gpu-01"],
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) => project.id !== "master-agent" && !project.isGroup);
}
async function createConfirmedDispatchExecution() {
await setup();
const memberProjects = await ensureTwoSingleThreadProjects();
const groupProject = await createProjectGroupChat({
sourceProjectId: memberProjects[0].id,
memberProjectIds: [memberProjects[1].id],
createdBy: "17600003315",
});
const messageResponse = 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(messageResponse.status, 200);
const messagePayload = (await messageResponse.json()) as {
dispatchPlan: { planId: string; targets: Array<{ projectId: string }> } | null;
};
assert.ok(messagePayload.dispatchPlan, "expected seeded dispatch plan");
const approvedTargetProjectId = messagePayload.dispatchPlan.targets[0]?.projectId;
assert.ok(approvedTargetProjectId, "expected approved target");
const confirmResponse = await confirmDispatchPlanRoute(
await createAuthedRequest(
`http://127.0.0.1:3000/api/v1/projects/${groupProject.id}/dispatch-plans/${messagePayload.dispatchPlan.planId}/confirm`,
"POST",
{ approvedTargetProjectIds: [approvedTargetProjectId] },
),
{
params: Promise.resolve({
projectId: groupProject.id,
planId: messagePayload.dispatchPlan.planId,
}),
},
);
assert.equal(confirmResponse.status, 200);
const state = await readState();
const execution = state.dispatchExecutions.find(
(item) =>
item.planId === messagePayload.dispatchPlan?.planId &&
item.targetProjectId === approvedTargetProjectId,
);
assert.ok(execution, "expected queued dispatch execution");
const executionTask = state.masterAgentTasks.find(
(task) =>
task.taskType === "dispatch_execution" &&
task.projectId === groupProject.id &&
task.requestMessageId === messagePayload.dispatchPlan?.planId,
);
assert.ok(executionTask, "expected a queued dispatch execution master-agent task");
return { groupProject, execution, executionTask };
}
test("POST /api/v1/master-agent/tasks/[taskId]/complete mirrors raw thread replies to the group chat and appends a master-agent summary", async () => {
const { groupProject, execution, executionTask } = await createConfirmedDispatchExecution();
const response = await completeMasterTaskRoute(
await createAuthedRequest(
`http://127.0.0.1:3000/api/v1/master-agent/tasks/${executionTask.taskId}/complete`,
"POST",
{
deviceId: execution.deviceId,
status: "completed",
dispatchExecutionId: execution.executionId,
targetProjectId: execution.targetProjectId,
targetThreadId: execution.targetThreadId,
rawThreadReply: "线程A已经完成阻塞点整理，待你确认最终回滚窗口。",
replyBody: "主 Agent 汇总：线程A已返回阻塞点整理，下一步建议安排回滚窗口确认。",
},
),
{ params: Promise.resolve({ taskId: executionTask.taskId }) },
);
assert.equal(response.status, 200);
const nextState = await readState();
const completedExecution = nextState.dispatchExecutions.find(
(item) => item.executionId === execution.executionId,
);
assert.equal(completedExecution?.status, "completed");
assert.ok(completedExecution?.resultMessageId, "expected raw result message id to be recorded");
const groupMessages = nextState.projects.find((project) => project.id === groupProject.id)?.messages ?? [];
const mirroredDeviceReply = groupMessages.find(
(message) =>
message.sender === "device" &&
message.body.includes("线程A已经完成阻塞点整理"),
);
assert.ok(mirroredDeviceReply, "expected raw thread reply to be mirrored back to the group chat");
const masterSummary = groupMessages.find(
(message) =>
message.sender === "master" &&
message.body.includes("主 Agent 汇总：线程A已返回阻塞点整理"),
);
assert.ok(masterSummary, "expected master-agent summary to be appended after the raw thread reply");
});