boss/tests/group-message-dispatch-plan.test.ts

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 POST: (typeof import("../src/app/api/v1/projects/[projectId]/messages/route"))["POST"];
let createAuthSession: (typeof import("../src/lib/boss-data"))["createAuthSession"];
let createIndependentGroupChat: (typeof import("../src/lib/boss-data"))["createIndependentGroupChat"];
let readState: (typeof import("../src/lib/boss-data"))["readState"];
let writeState: (typeof import("../src/lib/boss-data"))["writeState"];
let AUTH_SESSION_COOKIE: string;
let baseState: Awaited<ReturnType<typeof import("../src/lib/boss-data")["readState"]>>;

async function setup() {
  if (runtimeRoot) {
    return;
  }

  runtimeRoot = await mkdtemp(path.join(os.tmpdir(), "boss-task3-"));
  process.env.BOSS_RUNTIME_ROOT = runtimeRoot;
  process.env.BOSS_STATE_FILE = path.join(runtimeRoot, "boss-state.json");

  const [{ POST: routePost }, data, auth] = await Promise.all([
    import("../src/app/api/v1/projects/[projectId]/messages/route.ts"),
    import("../src/lib/boss-data.ts"),
    import("../src/lib/boss-auth.ts"),
  ]);

  POST = routePost;
  createAuthSession = data.createAuthSession;
  createIndependentGroupChat = data.createIndependentGroupChat;
  readState = data.readState;
  writeState = data.writeState;
  baseState = structuredClone(await readState());
  AUTH_SESSION_COOKIE = auth.AUTH_SESSION_COOKIE;
}

test.after(async () => {
  if (runtimeRoot) {
    await rm(runtimeRoot, { recursive: true, force: true });
  }
});

test.beforeEach(async () => {
  await setup();
  await writeState(structuredClone(baseState));
});

async function createAuthedRequest(projectId: string, body: { body: string; kind?: string }) {
  const session = await createAuthSession({
    account: "17600003315",
    role: "highest_admin",
    displayName: "Boss 超级管理员",
    loginMethod: "password",
  });

  return new NextRequest(`http://127.0.0.1:3000/api/v1/projects/${projectId}/messages`, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      cookie: `${AUTH_SESSION_COOKIE}=${session.sessionToken}`,
    },
    body: JSON.stringify(body),
  });
}

async function ensureTwoSingleThreadProjects() {
  const state = await readState();
  const seed = state.projects.find((project) => project.id !== "master-agent" && !project.isGroup);
  assert.ok(seed, "expected at least one seeded single-thread project");

  const primaryProject = {
    ...seed,
    id: "dispatch-thread-a",
    name: "Boss 移动控制台主线程",
    deviceIds: ["mac-studio"],
    updatedAt: "2026-03-30T10:00:00+08:00",
    lastMessageAt: "2026-03-30T10:00:00+08:00",
    preview: "主线程正在等待汇总今天的联调阻塞点。",
    threadMeta: {
      ...seed.threadMeta,
      projectId: "dispatch-thread-a",
      threadId: "thread-dispatch-a",
      threadDisplayName: "北区试产线回归",
      folderName: "阻塞梳理",
      updatedAt: "2026-03-30T10:00:00+08:00",
      codexThreadRef: "thread-dispatch-a",
      codexFolderRef: "/Users/kris/code/boss",
    },
    groupMembers: [],
    messages: [
      {
        id: "msg-dispatch-a",
        sender: "device" as const,
        senderLabel: "Mac Studio / Codex",
        body: "主线程还在等待主 Agent 汇总阻塞点。",
        sentAt: "2026-03-30T10:00:00+08:00",
        kind: "text" as const,
      },
    ],
    goals: [],
    versions: [],
  };

  const secondaryProject = {
    ...seed,
    id: "dispatch-thread-b",
    name: "Boss 移动控制台副线程",
    deviceIds: ["mac-studio"],
    updatedAt: "2026-03-30T10:00:00+08:00",
    lastMessageAt: "2026-03-30T10:00:00+08:00",
    preview: "副线程等待主 Agent 汇总阻塞点。",
    threadMeta: {
      ...seed.threadMeta,
      projectId: "dispatch-thread-b",
      threadId: "thread-dispatch-b",
      threadDisplayName: "南区试产线回归",
      folderName: "阻塞梳理",
      updatedAt: "2026-03-30T10:00:00+08:00",
      codexThreadRef: "thread-dispatch-b",
      codexFolderRef: "/Users/kris/code/boss",
    },
    groupMembers: [],
    messages: [
      {
        id: "msg-dispatch-b",
        sender: "device" as const,
        senderLabel: "Mac Studio / Codex",
        body: "副线程还在等待视觉链路复核。",
        sentAt: "2026-03-30T10:00:00+08:00",
        kind: "text" as const,
      },
    ],
    goals: [],
    versions: [],
  };

  await writeState({
    ...state,
    projects: state.projects
      .filter((project) => !["dispatch-thread-a", "dispatch-thread-b"].includes(project.id))
      .concat(primaryProject, secondaryProject),
  });

  return [primaryProject, secondaryProject];
}

test("POST /api/v1/projects/[projectId]/messages returns a dispatch plan for group text messages", async () => {
  await setup();
  const memberProjects = await ensureTwoSingleThreadProjects();
  assert.ok(memberProjects.length >= 2, "expected seeded single-thread projects");

  const groupProject = await createIndependentGroupChat({
    memberProjectIds: [memberProjects[0].id, memberProjects[1].id],
    createdBy: "17600003315",
  });

  const response = await POST(await createAuthedRequest(groupProject.id, { body: "请大家汇总今天的阻塞点" }), {
    params: Promise.resolve({ projectId: groupProject.id }),
  });
  assert.equal(response.status, 200);

  const payload = (await response.json()) as {
    ok: boolean;
    message: { id: string; body: string };
    dispatchPlan: null | {
      groupProjectId: string;
      requestMessageId: string;
      status: string;
      targets: Array<{ projectId: string }>;
      summary: string;
    };
    collaborationGate: { isGroup: boolean };
  };

  assert.equal(payload.ok, true);
  assert.equal(payload.message.body, "请大家汇总今天的阻塞点");
  assert.ok(payload.dispatchPlan, "expected dispatch plan in response");
  assert.equal(payload.dispatchPlan?.groupProjectId, groupProject.id);
  assert.equal(payload.dispatchPlan?.requestMessageId, payload.message.id);
  assert.equal(payload.dispatchPlan?.status, "pending_user_confirmation");
  assert.equal(payload.dispatchPlan?.targets.length, groupProject.groupMembers.length);
  assert.match(payload.dispatchPlan?.summary ?? "", /阻塞点/);
  assert.equal(payload.collaborationGate.isGroup, true);

  const nextState = await readState();
  const queuedGroupDispatchTasks = nextState.masterAgentTasks.filter(
    (task) =>
      task.projectId === groupProject.id &&
      task.requestMessageId === payload.message.id &&
      task.taskType === "group_dispatch_plan",
  );
  assert.equal(
    queuedGroupDispatchTasks.length,
    1,
    "expected group messages to enqueue a master-agent dispatch recommendation task",
  );
});

test("POST /api/v1/projects/[projectId]/messages keeps dispatchPlan null for single-thread projects", async () => {
  await setup();
  const state = await readState();
  const singleProject = state.projects.find(
    (project) => project.id !== "master-agent" && !project.isGroup,
  );
  assert.ok(singleProject, "expected a seeded single-thread project");

  const response = await POST(await createAuthedRequest(singleProject.id, { body: "单线程消息" }), {
    params: Promise.resolve({ projectId: singleProject.id }),
  });
  assert.equal(response.status, 200);

  const payload = (await response.json()) as {
    ok: boolean;
    message: { body: string };
    dispatchPlan: null;
    collaborationGate: { isGroup: boolean };
  };

  assert.equal(payload.ok, true);
  assert.equal(payload.message.body, "单线程消息");
  assert.equal(payload.dispatchPlan, null);
  assert.equal(payload.collaborationGate.isGroup, false);
});

test("POST /api/v1/projects/master-agent/messages returns a dispatch plan for thread-operation requests", async () => {
  await setup();
  const memberProjects = await ensureTwoSingleThreadProjects();
  assert.ok(memberProjects.length >= 2, "expected seeded single-thread projects");

  const response = await POST(
    await createAuthedRequest("master-agent", {
      body: "请操作真实线程，先让北区试产线回归只回复：主Agent线程操作正常",
    }),
    { params: Promise.resolve({ projectId: "master-agent" }) },
  );
  assert.equal(response.status, 200);

  const payload = (await response.json()) as {
    ok: boolean;
    message: { id: string; body: string };
    dispatchPlan: null | {
      groupProjectId: string;
      requestMessageId: string;
      status: string;
      targets: Array<{ projectId: string }>;
      summary: string;
    };
    masterReply?: { ok: boolean; taskId?: string };
    collaborationGate: { isGroup: boolean };
  };

  assert.equal(payload.ok, true);
  assert.equal(payload.message.body, "请操作真实线程，先让北区试产线回归只回复：主Agent线程操作正常");
  assert.ok(payload.dispatchPlan, "expected dispatch plan in master-agent response");
  assert.equal(payload.dispatchPlan?.groupProjectId, "master-agent");
  assert.equal(payload.dispatchPlan?.requestMessageId, payload.message.id);
  assert.equal(payload.dispatchPlan?.status, "pending_user_confirmation");
  assert.ok(
    (payload.dispatchPlan?.targets ?? []).some((target) => target.projectId === "dispatch-thread-a"),
    "expected dispatch plan to include the matching real thread target",
  );
  assert.match(payload.dispatchPlan?.summary ?? "", /北区试产线回归|主 Agent/);
  assert.equal(payload.collaborationGate.isGroup, false);
  assert.equal(payload.masterReply?.ok, true);

  const nextState = await readState();
  const queuedDispatchTask = nextState.masterAgentTasks.find(
    (task) =>
      task.projectId === "master-agent" &&
      task.requestMessageId === payload.message.id &&
      task.taskType === "group_dispatch_plan",
  );
  assert.ok(queuedDispatchTask, "expected master-agent thread-op request to enqueue a dispatch recommendation task");
});

test("POST /api/v1/projects/[projectId]/messages marks approval_required groups as pending user approval", async () => {
  await setup();
  const memberProjects = await ensureTwoSingleThreadProjects();
  assert.ok(memberProjects.length >= 2, "expected seeded single-thread projects");

  const groupProject = await createIndependentGroupChat({
    memberProjectIds: [memberProjects[0].id, memberProjects[1].id],
    createdBy: "17600003315",
  });

  const state = await readState();
  await writeState({
    ...state,
    projects: state.projects.map((project) =>
      project.id === groupProject.id
        ? {
            ...project,
            collaborationMode: "approval_required" as const,
            approvalState: "not_required" as const,
          }
        : project,
    ),
  });

  const response = await POST(await createAuthedRequest(groupProject.id, { body: "请协调两个线程确认上线方案" }), {
    params: Promise.resolve({ projectId: groupProject.id }),
  });
  assert.equal(response.status, 200);

  const payload = (await response.json()) as {
    ok: boolean;
    dispatchPlan: { planId: string } | null;
    collaborationGate: {
      isGroup: boolean;
      collaborationMode: "development" | "approval_required";
      requiresMasterAgentApproval: boolean;
      approvalState: "not_required" | "pending_agent" | "pending_user" | "approved" | "rejected";
    };
  };

  assert.equal(payload.ok, true);
  assert.ok(payload.dispatchPlan, "expected dispatch plan");
  assert.equal(payload.collaborationGate.isGroup, true);
  assert.equal(payload.collaborationGate.collaborationMode, "approval_required");
  assert.equal(payload.collaborationGate.requiresMasterAgentApproval, true);
  assert.equal(payload.collaborationGate.approvalState, "pending_user");

  const nextState = await readState();
  const persistedGroup = nextState.projects.find((project) => project.id === groupProject.id);
  assert.ok(persistedGroup, "expected group project to persist");
  assert.equal(persistedGroup?.approvalState, "pending_user");
  const pendingNotice = persistedGroup?.messages.find(
    (message) =>
      message.sender === "master" &&
      message.kind === "system_notice" &&
      message.body.includes("等待你确认"),
  );
  assert.ok(pendingNotice, "expected an approval notice to be persisted in the group ledger");
  assert.match(pendingNotice?.body ?? "", /等待你确认|待审批|待确认/);
});

test("POST /api/v1/projects/[projectId]/messages blocks new approval_required requests while a plan is still pending", async () => {
  await setup();
  const memberProjects = await ensureTwoSingleThreadProjects();
  assert.ok(memberProjects.length >= 2, "expected seeded single-thread projects");

  const groupProject = await createIndependentGroupChat({
    memberProjectIds: [memberProjects[0].id, memberProjects[1].id],
    createdBy: "17600003315",
  });

  const state = await readState();
  await writeState({
    ...state,
    projects: state.projects.map((project) =>
      project.id === groupProject.id
        ? {
            ...project,
            collaborationMode: "approval_required" as const,
            approvalState: "not_required" as const,
          }
        : project,
    ),
  });

  const firstResponse = await POST(await createAuthedRequest(groupProject.id, { body: "请协调两个线程确认上线方案" }), {
    params: Promise.resolve({ projectId: groupProject.id }),
  });
  assert.equal(firstResponse.status, 200);
  const firstPayload = (await firstResponse.json()) as {
    dispatchPlan: { planId: string } | null;
  };
  assert.ok(firstPayload.dispatchPlan, "expected first message to create a dispatch plan");

  const blockedResponse = await POST(await createAuthedRequest(groupProject.id, { body: "再补充一个新的下发要求" }), {
    params: Promise.resolve({ projectId: groupProject.id }),
  });
  assert.equal(blockedResponse.status, 409);

  const blockedPayload = (await blockedResponse.json()) as {
    ok: boolean;
    message: string;
    pendingPlan: { planId: string } | null;
    collaborationGate: {
      approvalState: "not_required" | "pending_agent" | "pending_user" | "approved" | "rejected";
      requiresMasterAgentApproval: boolean;
    };
  };

  assert.equal(blockedPayload.ok, false);
  assert.match(blockedPayload.message, /先确认|拒绝|待确认/);
  assert.equal(blockedPayload.pendingPlan?.planId, firstPayload.dispatchPlan?.planId);
  assert.equal(blockedPayload.collaborationGate.approvalState, "pending_user");
  assert.equal(blockedPayload.collaborationGate.requiresMasterAgentApproval, true);

  const nextState = await readState();
  const groupState = nextState.projects.find((project) => project.id === groupProject.id);
  assert.ok(groupState, "expected group project to exist");
  assert.equal(groupState?.approvalState, "pending_user");
  assert.equal(
    nextState.dispatchPlans.filter((plan) => plan.groupProjectId === groupProject.id && plan.status === "pending_user_confirmation").length,
    1,
    "expected only the original pending dispatch plan to remain",
  );
  assert.equal(
    groupState?.messages.some((message) => message.body === "再补充一个新的下发要求"),
    false,
    "expected blocked request not to append a new user message",
  );
});

test("POST /api/v1/projects/[projectId]/messages keeps message success when group dispatch recommendation fails", async () => {
  await setup();
  const memberProjects = await ensureTwoSingleThreadProjects();
  assert.ok(memberProjects.length >= 2, "expected seeded single-thread projects");

  const groupProject = await createIndependentGroupChat({
    memberProjectIds: [memberProjects[0].id, memberProjects[1].id],
    createdBy: "17600003315",
  });

  const state = await readState();
  const brokenMember = state.projects
    .find((project) => project.id === groupProject.id)
    ?.groupMembers[0];
  assert.ok(brokenMember, "expected group chat to have a member we can corrupt");
  await writeState({
    ...state,
    projects: state.projects.map((project) =>
      project.id === groupProject.id
        ? {
            ...project,
            groupMembers: [
              {
                ...brokenMember,
                projectId: "missing-project-for-dispatch",
              },
            ],
          }
        : project,
    ),
  });

  const response = await POST(await createAuthedRequest(groupProject.id, { body: "请重新梳理下待确认项" }), {
    params: Promise.resolve({ projectId: groupProject.id }),
  });
  assert.equal(response.status, 200);

  const payload = (await response.json()) as {
    ok: boolean;
    message: { id: string; body: string };
    dispatchPlan: null;
    dispatchRecommendation: {
      ok: boolean;
      taskId?: string;
      status: string;
      error?: string;
    };
  };

  assert.equal(payload.ok, true);
  assert.equal(payload.message.body, "请重新梳理下待确认项");
  assert.equal(payload.dispatchPlan, null);
  assert.equal(payload.dispatchRecommendation.ok, false);
  assert.equal(payload.dispatchRecommendation.status, "failed");
  assert.match(payload.dispatchRecommendation.error ?? "", /DISPATCH_TARGET_PROJECT_NOT_FOUND/);

  const nextState = await readState();
  const savedMessage = nextState.projects
    .find((project) => project.id === groupProject.id)
    ?.messages.find((message) => message.id === payload.message.id);
  assert.ok(savedMessage, "expected user message to remain persisted even when dispatch recommendation fails");
  const persistedMessages =
    nextState.projects.find((project) => project.id === groupProject.id)?.messages ?? [];
  const savedMessageIndex = persistedMessages.findIndex((message) => message.id === payload.message.id);
  assert.notEqual(savedMessageIndex, -1, "expected the user message to remain in the project timeline");
  assert.ok(
    persistedMessages
      .slice(savedMessageIndex + 1)
      .some((message) => message.sender === "master"),
    "expected a user-visible failure notice to be appended for dispatch errors",
  );

  const failedTask = nextState.masterAgentTasks.find(
    (task) =>
      task.projectId === groupProject.id &&
      task.requestMessageId === payload.message.id &&
      task.taskType === "group_dispatch_plan",
  );
  assert.ok(failedTask, "expected failed dispatch recommendation task to be recorded");
  assert.equal(failedTask?.status, "failed");
});

test("POST /api/v1/projects/[projectId]/messages excludes master-agent from group dispatch targets", async () => {
  await setup();
  const memberProjects = await ensureTwoSingleThreadProjects();
  assert.ok(memberProjects.length >= 2, "expected seeded single-thread projects");

  const groupProject = await createIndependentGroupChat({
    memberProjectIds: [memberProjects[0].id, memberProjects[1].id],
    createdBy: "17600003315",
  });

  const state = await readState();
  await writeState({
    ...state,
    projects: state.projects.map((project) =>
      project.id === groupProject.id
        ? {
            ...project,
            groupMembers: [
              ...project.groupMembers,
              {
                projectId: "master-agent",
                deviceId: "mac-studio",
                threadId: "thread-master-agent",
                threadDisplayName: "主 Agent",
                folderName: "主控线程",
              },
            ],
          }
        : project,
    ),
  });

  const response = await POST(await createAuthedRequest(groupProject.id, { body: "请继续同步联调进展" }), {
    params: Promise.resolve({ projectId: groupProject.id }),
  });
  assert.equal(response.status, 200);

  const payload = (await response.json()) as {
    dispatchPlan: null | {
      targets: Array<{ projectId: string }>;
    };
  };

  assert.ok(payload.dispatchPlan, "expected dispatch plan");
  assert.deepEqual(
    payload.dispatchPlan?.targets.map((target) => target.projectId),
    groupProject.groupMembers.map((member) => member.projectId),
  );
  assert.equal(
    payload.dispatchPlan?.targets.some((target) => target.projectId === "master-agent"),
    false,
    "master-agent should never appear as a dispatch target",
  );
});

test("createIndependentGroupChat rejects non-thread members like master-agent", async () => {
  await setup();
  const state = await readState();
  const realThread = state.projects.find(
    (project) => project.id !== "master-agent" && !project.isGroup && Boolean(project.threadMeta.codexThreadRef),
  );
  assert.ok(realThread, "expected a real thread-backed project");

  await assert.rejects(
    () =>
      createIndependentGroupChat({
        memberProjectIds: ["master-agent", realThread.id],
        createdBy: "17600003315",
      }),
    /GROUP_CHAT_MEMBER_NOT_THREAD/,
  );
});