@sleep2agi/commhub-server 0.9.0-preview.65 → 0.9.0-preview.67

package/src/requirements-migrate.ts

@@ -0,0 +1,51 @@
+// 需求卡的启动迁移。requirements.ts 载入时调用一次(列由 db.ts 的加列循环加上)。
+import type { DbAdapter } from "./db-adapter";
+
+/**
+ * 负责人 = 人类(owner, kind user);负责 Agent = 节点(agent_owner, kind node)。
+ * 之前 owner 可以是节点:这些卡把节点挪到 agent_owner、owner 置空。只动 agent_owner 还空着的行,
+ * 所以重复执行不会再改任何东西;不删行,不碰别的列。在 JS 里判 kind(不依赖 SQLite 的 json_extract)。
+ */
+export function migrateRequirementAgentOwners(database: DbAdapter): { moved: number } {
+  const rows = database.all<{ requirement_id: string; owner_json: string | null }>(
+    "SELECT requirement_id, owner_json FROM requirements WHERE owner_json IS NOT NULL AND agent_owner_json IS NULL",
+  );
+  let moved = 0;
+  for (const row of rows) {
+    let owner: { kind?: unknown; id?: unknown } | null = null;
+    try { owner = JSON.parse(row.owner_json || "null"); } catch { continue; }
+    if (!owner || owner.kind !== "node" || typeof owner.id !== "string" || !owner.id) continue;
+    database.run(
+      "UPDATE requirements SET agent_owner_json = ?1, owner_json = NULL WHERE requirement_id = ?2 AND agent_owner_json IS NULL",
+      [JSON.stringify({ kind: "node", id: owner.id }), row.requirement_id],
+    );
+    moved += 1;
+  }
+  return { moved };
+}
+
+/**
+ * 项目表(需求卡的「项目」)。只建表、建索引,不塞任何项目 —— 军团项目 / TMAI 由 owner 在界面里建。
+ * CREATE ... IF NOT EXISTS:重复执行无副作用。放在这里而不是 db.ts,db.ts 的行号被文档钉着。
+ */
+export function ensureRequirementProjects(database: DbAdapter): void {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS requirement_projects (
+      project_id  TEXT PRIMARY KEY,
+      network_id  TEXT NOT NULL,
+      name        TEXT NOT NULL,
+      color       TEXT NOT NULL,
+      sort        INTEGER NOT NULL DEFAULT 0,
+      archived    INTEGER NOT NULL DEFAULT 0,
+      created_at  TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_requirement_projects_network ON requirement_projects(network_id, sort);
+  `);
+}
+
+/** external_ref 在同一网络里唯一(只管有值的行)。IF NOT EXISTS:重复执行无副作用。 */
+export function ensureRequirementIndexes(database: DbAdapter): void {
+  database.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_requirements_external_ref ON requirements(network_id, external_ref) WHERE external_ref IS NOT NULL");
+  database.exec("CREATE INDEX IF NOT EXISTS idx_requirements_network_updated ON requirements(network_id, updated_at)");
+  database.exec("CREATE INDEX IF NOT EXISTS idx_requirements_parent ON requirements(parent_id) WHERE parent_id IS NOT NULL");
+}

package/src/requirements-upgrade-e2e.test.ts

@@ -0,0 +1,126 @@
+// 负责人 / 负责 Agent 拆分:一次性 Hub 进程的升级端到端。
+// 真起两次 `bun run src/index.ts`(HOME=临时目录、随机端口、绝不是 9200、独立库):
+//   第一次:注册、建节点、建一张「旧式」卡(owner 是节点 —— 用 SQL 写进去,因为新 Hub 已不接受);
+//          再把 agent_owner_json 列删掉,库回到 #2065 时代的样子。
+//   第二次:同一个库启动 = 升级。启动迁移把节点挪到 agent_owner,HTTP 读回;然后走一遍新规则。
+import { afterAll, expect, test } from "bun:test";
+import { Database } from "bun:sqlite";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { spawn, type ChildProcess } from "node:child_process";
+
+const home = mkdtempSync(join(tmpdir(), "anet-req-agent-owner-e2e-"));
+const dbFile = join(home, "hub.db");
+const port = 20000 + Math.floor(Math.random() * 20000);
+if (port === 9200) throw new Error("9200 is the production hub port");
+const base = `http://127.0.0.1:${port}`;
+const serverDir = resolve(import.meta.dir, "..");
+let proc: ChildProcess | null = null;
+
+async function startHub() {
+  proc = spawn("bun", ["run", "src/index.ts"], {
+    cwd: serverDir,
+    env: { PATH: process.env.PATH || "", HOME: home, COMMHUB_DB: dbFile, COMMHUB_SERVER: "1", PORT: String(port), HOST: "127.0.0.1" },
+    stdio: ["ignore", "ignore", "pipe"],
+  });
+  let err = "";
+  proc.stderr?.on("data", d => { err += String(d); });
+  for (let i = 0; i < 100; i++) {
+    try { if ((await fetch(`${base}/health`)).ok) return; } catch {}
+    await new Promise(r => setTimeout(r, 150));
+  }
+  throw new Error(`hub did not start on ${port}: ${err.slice(-600)}`);
+}
+async function stopHub() {
+  if (!proc) return;
+  const p = proc;
+  proc = null;
+  await new Promise<void>(res => { p.once("exit", () => res()); p.kill("SIGTERM"); setTimeout(() => { p.kill("SIGKILL"); res(); }, 5000); });
+}
+afterAll(async () => { await stopHub(); try { rmSync(home, { recursive: true, force: true }); } catch {} });
+
+async function api(token: string, path: string, init?: RequestInit) {
+  const res = await fetch(`${base}${path}`, { ...init, headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" } });
+  return { status: res.status, body: await res.json() as any };
+}
+
+test("an upgraded hub moves node owners to agent_owner and then enforces human owner / agent executor", async () => {
+  await startHub();
+  const reg = await (await fetch(`${base}/api/auth/register`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ username: "e2e_owner", password: "E2eOwner123!pass" }) })).json() as any;
+  expect(reg.ok).toBe(true);
+  const token = reg.token as string, net = reg.network_id as string, uid = reg.user.user_id as string;
+  const human = { kind: "user", id: uid }, agent = { kind: "node", id: "node_e2e_exec" };
+  {
+    const db = new Database(dbFile);
+    db.run("INSERT INTO nodes (node_id,node_name,alias,network_id) VALUES (?1,'e2e-exec','e2e-exec',?2)", [agent.id, net]);
+    db.close();
+  }
+  const card = await api(token, "/api/requirements", { method: "POST", body: JSON.stringify({ name: "旧式卡", network_id: net, participants: [human] }) });
+  expect(card.status).toBe(201);
+  const keep = await api(token, "/api/requirements", { method: "POST", body: JSON.stringify({ name: "人类负责人卡", network_id: net, owner: human }) });
+  expect(keep.status).toBe(201);
+  await stopHub();
+  {
+    // 退回旧库:节点当负责人,且没有 agent_owner_json 列
+    const db = new Database(dbFile);
+    db.run("UPDATE requirements SET owner_json = ?1 WHERE requirement_id = ?2", [JSON.stringify(agent), card.body.requirement.id]);
+    db.exec("ALTER TABLE requirements DROP COLUMN agent_owner_json");
+    const cols = (db.query("PRAGMA table_info(requirements)").all() as { name: string }[]).map(c => c.name);
+    expect(cols.includes("agent_owner_json")).toBe(false);
+    db.close();
+  }
+  await startHub();
+  const listed = await api(token, `/api/requirements?network_id=${net}`);
+  expect(listed.status).toBe(200);
+  expect(listed.body.requirements.length).toBe(2);
+  const upgraded = listed.body.requirements.find((r: any) => r.id === card.body.requirement.id);
+  expect(upgraded.owner).toBeNull();
+  expect(upgraded.agent_owner).toEqual(agent);
+  expect(upgraded.participants).toEqual([human]);
+  expect(upgraded.name).toBe("旧式卡");
+  const untouched = listed.body.requirements.find((r: any) => r.id === keep.body.requirement.id);
+  expect(untouched.owner).toEqual(human);
+  expect(untouched.agent_owner).toBeNull();
+
+  const path = `/api/requirements/${upgraded.id}?network_id=${net}`;
+  const both = await api(token, path, { method: "PATCH", body: JSON.stringify({ owner: human }) });
+  expect(both.status).toBe(200);
+  expect(both.body.requirement.owner).toEqual(human);
+  expect(both.body.requirement.agent_owner).toEqual(agent);
+  expect((await api(token, path, { method: "PATCH", body: JSON.stringify({ owner: agent, agent_owner: agent }) })).body.error).toBe("owner_must_be_human");
+  expect((await api(token, path, { method: "PATCH", body: JSON.stringify({ agent_owner: human }) })).body.error).toBe("agent_owner_must_be_agent");
+
+  // 预计完成:旧卡的全天值(升级前写的)原样读回;改成带时刻的,存 UTC
+  const dated = await api(token, path, { method: "PATCH", body: JSON.stringify({ due: "2026-10-01" }) });
+  expect(dated.body.requirement.due).toBe("2026-10-01");
+  // 描述 / 子任务:升级后的旧卡可写,单项勾选只动那一项
+  expect(upgraded.description).toBe("");
+  expect(upgraded.checklist).toEqual([]);
+  const withList = await api(token, path, { method: "PATCH", body: JSON.stringify({ description: "# 验收\n- 能用", checklist: [{ id: "one", text: "第一步" }, { id: "two", text: "第二步" }] }) });
+  expect(withList.status).toBe(200);
+  const ticked = await api(token, `/api/requirements/${upgraded.id}/checklist/two?network_id=${net}`, { method: "PATCH", body: JSON.stringify({ done: true }) });
+  expect(ticked.body.requirement.checklist).toEqual([{ id: "one", text: "第一步", done: false }, { id: "two", text: "第二步", done: true }]);
+
+  // 项目:升级后没有任何项目(不预置),建一个、给旧卡挂上
+  expect((await api(token, `/api/requirements/projects?network_id=${net}`)).body.projects).toEqual([]);
+  const proj = await api(token, `/api/requirements/projects?network_id=${net}`, { method: "POST", body: JSON.stringify({ name: "军团项目" }) });
+  expect(proj.status).toBe(201);
+  expect((await api(token, path, { method: "PATCH", body: JSON.stringify({ project_id: proj.body.project.id }) })).body.requirement.project_id).toBe(proj.body.project.id);
+
+  // 第三次启动(同一个库):迁移不再改任何东西
+  await stopHub();
+  await startHub();
+  const again = (await api(token, `/api/requirements?network_id=${net}`)).body.requirements;
+  expect(again.length).toBe(2);
+  const same = again.find((r: any) => r.id === upgraded.id);
+  expect(same.owner).toEqual(human);
+  expect(same.agent_owner).toEqual(agent);
+  expect(same.description).toBe("# 验收\n- 能用");
+  expect(same.checklist.map((i: any) => i.done)).toEqual([false, true]);
+  expect(same.project_id).toBe(proj.body.project.id);
+  expect(same.due).toBe("2026-10-01");
+  const timed = await api(token, `/api/requirements/${upgraded.id}?network_id=${net}`, { method: "PATCH", body: JSON.stringify({ due: "2026-10-01T18:30:45+08:00" }) });
+  expect(timed.body.requirement.due).toBe("2026-10-01T10:30:45Z");
+  expect((await api(token, `/api/requirements/projects?network_id=${net}`)).body.projects.map((p: any) => p.name)).toEqual(["军团项目"]);
+}, 60_000);

package/src/requirements-upgrade-migration.test.ts

@@ -0,0 +1,85 @@
+// 负责人 / 负责 Agent 拆分的启动迁移:旧库里 owner 是节点的卡,节点挪到 agent_owner、owner 置空。
+// 用 #2065 时代的表结构(没有 agent_owner_json 列)先建库、塞行,再 import db.ts + requirements.ts(真实启动路径)。
+import { afterAll, expect, test } from "bun:test";
+import { Database } from "bun:sqlite";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const dir = mkdtempSync(join(tmpdir(), "anet-req-agent-owner-"));
+const file = join(dir, "hub.db");
+process.env.COMMHUB_DB = file;
+
+const legacy = new Database(file);
+legacy.exec(`CREATE TABLE requirements (
+  requirement_id TEXT PRIMARY KEY, network_id TEXT NOT NULL, title TEXT NOT NULL,
+  column_name TEXT NOT NULL DEFAULT 'pool', priority TEXT NOT NULL DEFAULT 'normal', due_on TEXT, assignee TEXT,
+  client_id TEXT, issues_json TEXT, created_by TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')), updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  owner_json TEXT, participants_json TEXT NOT NULL DEFAULT '[]')`);
+const rows: [string, string | null, string][] = [
+  ["r_node_owner", JSON.stringify({ kind: "node", id: "node_x" }), JSON.stringify([{ kind: "user", id: "u1" }])],
+  ["r_user_owner", JSON.stringify({ kind: "user", id: "u1" }), "[]"],
+  ["r_no_owner", null, "[]"],
+  ["r_bad_json", "{not json", "[]"],
+  ["r_node_no_id", JSON.stringify({ kind: "node" }), "[]"],
+  ["r_node_owner_2", JSON.stringify({ kind: "node", id: "node_y" }), "[]"],
+];
+for (const [id, owner, participants] of rows) {
+  legacy.run("INSERT INTO requirements (requirement_id, network_id, title, due_on, assignee, owner_json, participants_json) VALUES (?1, 'net', ?2, '2026-10-01', 'legacy', ?3, ?4)", [id, `卡 ${id}`, owner, participants]);
+}
+legacy.close();
+
+afterAll(() => { try { rmSync(dir, { recursive: true, force: true }); } catch {} });
+
+const snapshot = (db: any) => db.all("SELECT requirement_id, network_id, title, due_on, assignee, participants_json, owner_json, agent_owner_json, project_id FROM requirements ORDER BY requirement_id") as any[];
+
+test("startup migration moves node owners to agent_owner, keeps every row, and is idempotent", async () => {
+  const { db } = await import("./db.js");
+  await import("./requirements.js"); // 真实启动路径:server.ts 载入 requirements.ts 时迁移
+  const { migrateRequirementAgentOwners } = await import("./requirements-migrate.js");
+  const after = snapshot(db);
+  expect(after.length).toBe(rows.length);
+  const by = Object.fromEntries(after.map(r => [r.requirement_id, r]));
+  expect(by.r_node_owner.owner_json).toBeNull();
+  expect(JSON.parse(by.r_node_owner.agent_owner_json)).toEqual({ kind: "node", id: "node_x" });
+  expect(by.r_node_owner.participants_json).toBe(JSON.stringify([{ kind: "user", id: "u1" }]));
+  expect(JSON.parse(by.r_node_owner_2.agent_owner_json)).toEqual({ kind: "node", id: "node_y" });
+  expect(JSON.parse(by.r_user_owner.owner_json)).toEqual({ kind: "user", id: "u1" });
+  expect(by.r_user_owner.agent_owner_json).toBeNull();
+  expect(by.r_no_owner.owner_json).toBeNull();
+  // 读不懂的旧值原样留着,不猜、不删
+  expect(by.r_bad_json.owner_json).toBe("{not json");
+  expect(by.r_node_no_id.owner_json).toBe(JSON.stringify({ kind: "node" }));
+  for (const r of after) {
+    expect(r.title).toBe(`卡 ${r.requirement_id}`);
+    expect(r.network_id).toBe("net");
+    expect(r.due_on).toBe("2026-10-01");
+    expect(r.assignee).toBe("legacy");
+  }
+  // 加列只加不改:旧行的描述 / 子任务是空
+  const cols = (db.all("PRAGMA table_info(requirements)") as { name: string }[]).map(c => c.name);
+  expect(cols.includes("description") && cols.includes("checklist_json") && cols.includes("agent_owner_json")).toBe(true);
+  const extra = db.all("SELECT description, checklist_json FROM requirements") as any[];
+  expect(extra.every(r => r.description === null && r.checklist_json === null)).toBe(true);
+  // 项目表:建了、是空的(不预置),重复执行不报错;卡片的 project_id 列只加不改
+  expect(cols.includes("project_id")).toBe(true);
+  // PR B:外部引用 / 归档 / 谁做的 —— 只加不改;旧行 archived = 0、其余 NULL;external_ref 的部分唯一索引建了
+  for (const c of ["external_ref", "external_url", "archived", "created_by_json", "updated_by_json", "parent_id"]) expect(cols.includes(c)).toBe(true);
+  expect((db.all("SELECT parent_id FROM requirements WHERE parent_id IS NOT NULL") as any[]).length).toBe(0);
+  expect((db.all("PRAGMA index_list(requirements)") as { name: string }[]).some(i => i.name === "idx_requirements_parent")).toBe(true);
+  expect((db.all("SELECT archived, external_ref FROM requirements") as any[]).every(r => r.archived === 0 && r.external_ref === null)).toBe(true);
+  const idx = (db.all("PRAGMA index_list(requirements)") as { name: string; unique: number }[]).find(i => i.name === "idx_requirements_external_ref");
+  expect(idx?.unique).toBe(1);
+  const { ensureRequirementIndexes } = await import("./requirements-migrate.js");
+  ensureRequirementIndexes(db);
+  expect((db.all("SELECT project_id FROM requirements WHERE project_id IS NOT NULL") as any[]).length).toBe(0);
+  expect((db.get("SELECT COUNT(*) AS n FROM requirement_projects") as any).n).toBe(0);
+  const { ensureRequirementProjects } = await import("./requirements-migrate.js");
+  ensureRequirementProjects(db);
+  ensureRequirementProjects(db);
+  expect((db.get("SELECT COUNT(*) AS n FROM requirement_projects") as any).n).toBe(0);
+  // 再跑一次(= 下次启动):什么都不动
+  expect(migrateRequirementAgentOwners(db).moved).toBe(0);
+  expect(snapshot(db)).toEqual(after);
+});