fix: harden dispatch and device import flows

This commit is contained in:
kris
2026-03-30 12:03:43 +08:00
parent 745b47e812
commit 038c2bd088
13 changed files with 872 additions and 108 deletions

View File

@@ -53,9 +53,19 @@ test.after(async () => {
});
async function createAuthedRequest(url: string, method: "GET" | "POST", body?: unknown) {
return createAuthedRequestFor("17600003315", "highest_admin", url, method, body);
}
async function createAuthedRequestFor(
account: string,
role: "member" | "admin" | "highest_admin",
url: string,
method: "GET" | "POST",
body?: unknown,
) {
const session = await createAuthSession({
account: "17600003315",
role: "highest_admin",
account,
role,
displayName: "Boss 超级管理员",
loginMethod: "password",
});
@@ -177,6 +187,15 @@ test("device import draft flow scans candidates, selects imports, resolves sugge
["create_thread_conversation"],
);
const reviewedState = await readState();
const resolutionTask = reviewedState.masterAgentTasks.find(
(task) =>
task.taskType === "device_import_resolution" &&
task.deviceImportDraftId &&
task.status === "completed",
);
assert.ok(resolutionTask, "expected import review to leave a master-agent task trace");
const applyResponse = await applyImportDraftRoute(
await createAuthedRequest(
`http://127.0.0.1:3000/api/v1/devices/${enrollmentPayload.device.id}/import-draft/apply`,
@@ -207,3 +226,262 @@ test("device import draft flow scans candidates, selects imports, resolves sugge
assert.equal(appliedDraft?.status, "applied");
assert.equal(appliedResolution?.status, "applied");
});
test("heartbeat candidates no longer auto-create chat windows from legacy projects when import draft is present", async () => {
await setup();
const enrollmentResponse = await createEnrollmentRoute(
await createAuthedRequest("http://127.0.0.1:3000/api/v1/devices/enrollments", "POST", {
name: "ThinkPad",
avatar: "T",
account: "17600003315",
endpoint: "pc://thinkpad.local",
note: "legacy projects should not auto import",
}),
);
assert.equal(enrollmentResponse.status, 200);
const enrollmentPayload = (await enrollmentResponse.json()) as {
enrollment: { pairingCode: string };
device: { id: string };
};
const beforeState = await readState();
const beforeCount = beforeState.projects.filter((project) => project.name === "Legacy Folder").length;
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: "ThinkPad",
avatar: "T",
account: "17600003315",
status: "online",
quota5h: 60,
quota7d: 75,
projects: ["Legacy Folder"],
endpoint: "pc://thinkpad.local",
projectCandidates: [
{
folderName: "Legacy Folder",
folderRef: "legacy-folder",
threadId: "thread-legacy-1",
threadDisplayName: "Legacy 线程",
codexFolderRef: "legacy-folder",
codexThreadRef: "thread-legacy-1",
lastActiveAt: "2026-03-30T10:30:00+08:00",
suggestedImport: true,
},
],
}),
}),
);
assert.equal(heartbeatResponse.status, 200);
const nextState = await readState();
const afterCount = nextState.projects.filter((project) => project.name === "Legacy Folder").length;
assert.equal(afterCount, beforeCount, "legacy project folders should wait for import apply");
const draft = nextState.deviceImportDrafts.find((item) => item.deviceId === enrollmentPayload.device.id);
assert.ok(draft, "expected import draft to be created");
});
test("device import apply is idempotent and heartbeat preserves applied status", async () => {
await setup();
const enrollmentResponse = await createEnrollmentRoute(
await createAuthedRequest("http://127.0.0.1:3000/api/v1/devices/enrollments", "POST", {
name: "Studio Mac",
avatar: "S",
account: "17600003315",
endpoint: "mac://studio.local",
note: "idempotent import apply",
}),
);
assert.equal(enrollmentResponse.status, 200);
const enrollmentPayload = (await enrollmentResponse.json()) as {
enrollment: { pairingCode: string };
device: { id: string };
};
const heartbeatPayload = {
deviceId: enrollmentPayload.device.id,
pairingCode: enrollmentPayload.enrollment.pairingCode,
name: "Studio Mac",
avatar: "S",
account: "17600003315",
status: "online" as const,
quota5h: 68,
quota7d: 82,
projects: [],
endpoint: "mac://studio.local",
projectCandidates: [
{
folderName: "导入目录",
folderRef: "import-folder",
threadId: "thread-import-1",
threadDisplayName: "导入线程一",
codexFolderRef: "import-folder",
codexThreadRef: "thread-import-1",
lastActiveAt: "2026-03-30T10:40:00+08:00",
suggestedImport: true,
},
],
};
assert.equal(
(
await deviceHeartbeatRoute(
new NextRequest("http://127.0.0.1:3000/api/device-heartbeat", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify(heartbeatPayload),
}),
)
).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 }) },
);
const draftPayload = (await draftResponse.json()) as {
draft: { candidates: Array<{ candidateId: string }> };
};
const selectedCandidateIds = draftPayload.draft.candidates.map((candidate) => candidate.candidateId);
assert.equal(
(
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 }) },
)
).status,
200,
);
assert.equal(
(
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 }) },
)
).status,
200,
);
const applyUrl = `http://127.0.0.1:3000/api/v1/devices/${enrollmentPayload.device.id}/import-draft/apply`;
const firstApply = await applyImportDraftRoute(
await createAuthedRequest(applyUrl, "POST", {}),
{ params: Promise.resolve({ deviceId: enrollmentPayload.device.id }) },
);
assert.equal(firstApply.status, 200);
const secondApply = await applyImportDraftRoute(
await createAuthedRequest(applyUrl, "POST", {}),
{ params: Promise.resolve({ deviceId: enrollmentPayload.device.id }) },
);
assert.equal(secondApply.status, 200);
let nextState = await readState();
const importedProjects = nextState.projects.filter(
(project) => project.threadMeta.codexThreadRef === "thread-import-1",
);
assert.equal(importedProjects.length, 1, "replaying apply should not duplicate imported thread windows");
assert.equal(
(
await deviceHeartbeatRoute(
new NextRequest("http://127.0.0.1:3000/api/device-heartbeat", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify(heartbeatPayload),
}),
)
).status,
200,
);
nextState = await readState();
const appliedDraft = nextState.deviceImportDrafts.find((item) => item.deviceId === enrollmentPayload.device.id);
assert.equal(appliedDraft?.status, "applied", "later heartbeats should not regress applied drafts");
});
test("device import routes reject unrelated logged-in members", async () => {
await setup();
const enrollmentResponse = await createEnrollmentRoute(
await createAuthedRequest("http://127.0.0.1:3000/api/v1/devices/enrollments", "POST", {
name: "Build Mac",
avatar: "B",
account: "17600003315",
endpoint: "mac://build.local",
note: "route auth test",
}),
);
assert.equal(enrollmentResponse.status, 200);
const enrollmentPayload = (await enrollmentResponse.json()) as {
enrollment: { pairingCode: string };
device: { id: string };
};
assert.equal(
(
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: "Build Mac",
avatar: "B",
account: "17600003315",
status: "online",
quota5h: 71,
quota7d: 80,
projects: [],
endpoint: "mac://build.local",
projectCandidates: [
{
folderName: "受控目录",
folderRef: "secured-folder",
threadId: "thread-secured",
threadDisplayName: "受控线程",
codexFolderRef: "secured-folder",
codexThreadRef: "thread-secured",
lastActiveAt: "2026-03-30T10:50:00+08:00",
suggestedImport: true,
},
],
}),
}),
)
).status,
200,
);
const outsiderRequest = await createAuthedRequestFor(
"15500001111",
"member",
`http://127.0.0.1:3000/api/v1/devices/${enrollmentPayload.device.id}/import-draft`,
"GET",
);
const getResponse = await getImportDraftRoute(outsiderRequest, {
params: Promise.resolve({ deviceId: enrollmentPayload.device.id }),
});
assert.equal(getResponse.status, 403);
});