boss/tests/thread-archive-route.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 postRoute: (typeof import("../src/app/api/v1/projects/[projectId]/thread-archive/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 AUTH_SESSION_COOKIE = "";

async function setup() {
  if (runtimeRoot) return;
  runtimeRoot = await mkdtemp(path.join(os.tmpdir(), "boss-thread-archive-"));
  process.env.BOSS_RUNTIME_ROOT = runtimeRoot;
  process.env.BOSS_STATE_FILE = path.join(runtimeRoot, "boss-state.json");

  const [route, data, auth] = await Promise.all([
    import("../src/app/api/v1/projects/[projectId]/thread-archive/route.ts"),
    import("../src/lib/boss-data.ts"),
    import("../src/lib/boss-auth.ts"),
  ]);
  postRoute = route.POST;
  createAuthSession = data.createAuthSession;
  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 });
  }
});

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

async function createAuthedRequest(projectId: string, body: unknown) {
  const session = await createAuthSession({
    account: "krisolo",
    role: "highest_admin",
    displayName: "Boss 超级管理员",
    loginMethod: "password",
  });
  return new NextRequest(`http://127.0.0.1:3000/api/v1/projects/${projectId}/thread-archive`, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      cookie: `${AUTH_SESSION_COOKIE}=${session.sessionToken}`,
    },
    body: JSON.stringify(body),
  });
}

function buildThreadProject() {
  return {
    id: "archive-project",
    name: "可归档线程",
    pinned: false,
    systemPinned: false,
    deviceIds: ["mac-studio"],
    preview: "",
    updatedAt: "2026-06-03T11:00:00+08:00",
    lastMessageAt: "2026-06-03T11:00:00+08:00",
    isGroup: false,
    threadMeta: {
      projectId: "archive-project",
      threadId: "archive-thread",
      threadDisplayName: "可归档线程",
      folderName: "boss",
      codexFolderRef: "/Users/kris/code/boss",
      codexThreadRef: "codex-archive-thread",
      updatedAt: "2026-06-03T11:00:00+08:00",
    },
    groupMembers: [],
    createdByAgent: false,
    collaborationMode: "development" as const,
    approvalState: "not_required" as const,
    unreadCount: 0,
    riskLevel: "low" as const,
    messages: [],
    goals: [],
    versions: [],
  };
}

test("POST /thread-archive queues a controlled Codex thread archive task", async () => {
  const state = await readState();
  const project = buildThreadProject();
  state.projects = [
    ...state.projects.filter((item) => item.id === "master-agent"),
    project,
  ];
  await writeState(state);

  const response = await postRoute(
    await createAuthedRequest(project.id, {
      action: "archive",
      reason: "项目已阶段性结束，归档线程。",
    }),
    { params: Promise.resolve({ projectId: project.id }) },
  );
  const payload = await response.json();

  assert.equal(response.status, 200);
  assert.equal(payload.ok, true);
  assert.equal(payload.task.intentCategory, "thread_archive");
  assert.equal(payload.task.threadLifecycleAction, "archive");
  assert.equal(payload.task.threadLifecycleReason, "项目已阶段性结束，归档线程。");
  assert.equal(payload.task.targetProjectId, project.id);
  assert.equal(payload.task.targetCodexThreadRef, "codex-archive-thread");

  const persisted = (await readState()).masterAgentTasks.find(
    (task) => task.taskId === payload.task.taskId,
  );
  assert.equal(persisted?.status, "queued");
  assert.equal(persisted?.intentCategory, "thread_archive");
  assert.equal(persisted?.threadLifecycleAction, "archive");
});

test("POST /thread-archive queues a controlled Codex thread unarchive task", async () => {
  const state = await readState();
  const project = buildThreadProject();
  state.projects = [
    ...state.projects.filter((item) => item.id === "master-agent"),
    project,
  ];
  await writeState(state);

  const response = await postRoute(
    await createAuthedRequest(project.id, {
      action: "unarchive",
      reason: "恢复线程继续开发。",
    }),
    { params: Promise.resolve({ projectId: project.id }) },
  );
  const payload = await response.json();

  assert.equal(response.status, 200);
  assert.equal(payload.ok, true);
  assert.equal(payload.task.intentCategory, "thread_unarchive");
  assert.equal(payload.task.threadLifecycleAction, "unarchive");
  assert.equal(payload.task.threadLifecycleReason, "恢复线程继续开发。");

  const persisted = (await readState()).masterAgentTasks.find(
    (task) => task.taskId === payload.task.taskId,
  );
  assert.equal(persisted?.status, "queued");
  assert.equal(persisted?.intentCategory, "thread_unarchive");
  assert.equal(persisted?.threadLifecycleAction, "unarchive");
});

test("POST /thread-archive rejects unsupported lifecycle actions", async () => {
  const state = await readState();
  const project = buildThreadProject();
  state.projects = [
    ...state.projects.filter((item) => item.id === "master-agent"),
    project,
  ];
  await writeState(state);

  const response = await postRoute(
    await createAuthedRequest(project.id, { action: "delete" }),
    { params: Promise.resolve({ projectId: project.id }) },
  );
  const payload = await response.json();

  assert.equal(response.status, 400);
  assert.equal(payload.ok, false);
  assert.equal(payload.message, "THREAD_LIFECYCLE_ACTION_UNSUPPORTED");
});