@sleep2agi/commhub-server 0.9.0-preview.155 → 0.9.0-preview.156

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.155",
+  "version": "0.9.0-preview.156",
   "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and MCP tools (17 collaboration-core + node/provider ops tools; authoritative list: docs-site/docs/api/mcp-tools.md).",
   "type": "module",
   "main": "src/index.ts",

package/src/requirement-tag-ops-http.test.ts

@@ -264,3 +264,120 @@ describe("改名 / 合并 / 删除 / 颜色", () => {
     expect(cardTags("net2")).toEqual(["UI", "交互"]);
   });
 });
+
+// ── 改父级(reparent) ──
+// 客户端(0.297+)的「管理标签」里要能改父级;Hub 侧此前只缺这一个 op。
+// 这里只验树:reparent 不给标签改名、不动任何卡片的 tags 数组。
+describe("改父级 reparent", () => {
+  const createTag = (token: string, name: string, parent: string | null = null) =>
+    send(token, "POST", `/api/requirements/tags/create?network_id=${NET}`, { name, parent_id: parent });
+  const nodesOf = async (token: string) =>
+    (await send(token, "GET", `/api/requirements/tags?network_id=${NET}`)).body.nodes as Array<{ name: string; parent_id: string | null; depth: number; registered: boolean }>;
+  const nodeOf = async (token: string, name: string) => (await nodesOf(token)).find(node => node.name === name)!;
+
+  test("搬到另一个标签下面,再搬回顶层:父与深度都跟着变,卡片一张都不动", async () => {
+    expect((await createTag(admin.token, "RP根")).status).toBe(201);
+    expect((await createTag(admin.token, "RP枝")).status).toBe(201);
+    expect((await createTag(admin.token, "RP叶", "RP枝")).status).toBe(201);
+    const before = db.get("SELECT COUNT(*) AS n FROM requirements WHERE network_id = ?1", NET).n;
+
+    const moved = await op(admin.token, { op: "reparent", tag: "RP叶", parent: "RP根" });
+    expect(moved.status).toBe(200);
+    expect(moved.body).toMatchObject({ ok: true, op: "reparent", affected: 0, reparented: 1 });
+    expect(await nodeOf(admin.token, "RP叶")).toMatchObject({ parent_id: "RP根", depth: 2 });
+    // 原来是 RP枝 的子孙,搬走之后 RP枝 下面没有它了
+    expect((await nodesOf(admin.token)).filter(node => node.parent_id === "RP枝")).toEqual([]);
+
+    const back = await op(admin.token, { op: "reparent", tag: "RP叶", parent: null });
+    expect(back.status).toBe(200);
+    expect(await nodeOf(admin.token, "RP叶")).toMatchObject({ parent_id: null, depth: 1 });
+    // 只动树:卡片数与卡的标签都没变
+    expect(db.get("SELECT COUNT(*) AS n FROM requirements WHERE network_id = ?1", NET).n).toBe(before);
+  });
+
+  test("父是自己的子孙 = 环,拒绝(400 tag_parent_cycle),树一个字都不改", async () => {
+    expect((await createTag(admin.token, "RP环甲")).status).toBe(201);
+    expect((await createTag(admin.token, "RP环乙", "RP环甲")).status).toBe(201);
+    const r = await op(admin.token, { op: "reparent", tag: "RP环甲", parent: "RP环乙" });
+    expect(r.status).toBe(400);
+    expect(r.body.error).toBe("tag_parent_cycle");
+    expect(await nodeOf(admin.token, "RP环甲")).toMatchObject({ parent_id: null });
+  });
+
+  test("自己当自己的父:解析阶段就拒(400 tag_parent_cycle)", async () => {
+    const r = await op(admin.token, { op: "reparent", tag: "RP根", parent: "RP根" });
+    expect(r.status).toBe(400);
+    expect(r.body.error).toBe("tag_parent_cycle");
+  });
+
+  test("连子树一起搬:新父深度 + 子树高度 > 4 就拒(400 tag_depth_exceeded)", async () => {
+    expect((await createTag(admin.token, "RPD1")).status).toBe(201);
+    expect((await createTag(admin.token, "RPD2", "RPD1")).status).toBe(201);
+    expect((await createTag(admin.token, "RPD3", "RPD2")).status).toBe(201);     // 3 层:1>2>3
+    expect((await createTag(admin.token, "RPX")).status).toBe(201);
+    expect((await createTag(admin.token, "RPY", "RPX")).status).toBe(201);       // 2 层子树
+    // 把 2 层的 RPX(含 RPY)挂到第 3 层下面 → 最深 5 层 > 4
+    const r = await op(admin.token, { op: "reparent", tag: "RPX", parent: "RPD3" });
+    expect(r.status).toBe(400);
+    expect(r.body.error).toBe("tag_depth_exceeded");
+    expect(await nodeOf(admin.token, "RPX")).toMatchObject({ parent_id: null });
+    // 只搬叶子(高度 1)就正好 4 层,允许
+    const ok = await op(admin.token, { op: "reparent", tag: "RPY", parent: "RPD3" });
+    expect(ok.status).toBe(200);
+    expect(await nodeOf(admin.token, "RPY")).toMatchObject({ parent_id: "RPD3", depth: 4 });
+  });
+
+  test("父不存在 = 404,不静默升到根", async () => {
+    const r = await op(admin.token, { op: "reparent", tag: "RP根", parent: "不存在的父" });
+    expect(r.status).toBe(404);
+    expect(r.body.error).toBe("tag_parent_not_found");
+    expect(await nodeOf(admin.token, "RP根")).toMatchObject({ parent_id: null });
+  });
+
+  test("缺 parent 键 = 400(不能用「没传」把标签静默升到根);parent 为空串 = 顶层", async () => {
+    const missing = await op(admin.token, { op: "reparent", tag: "RP根" });
+    expect(missing.status).toBe(400);
+    expect(missing.body.error).toBe("invalid_tag_parent_id");
+    expect(await nodeOf(admin.token, "RP根")).toMatchObject({ parent_id: null });
+
+    expect((await op(admin.token, { op: "reparent", tag: "RP根", parent: "RPD1" })).status).toBe(200);
+    const root = await op(admin.token, { op: "reparent", tag: "RP根", parent: "" });
+    expect(root.status).toBe(200);
+    expect(await nodeOf(admin.token, "RP根")).toMatchObject({ parent_id: null });
+  });
+
+  test("只在卡片上出现过的老标签也能改父级:先登记成节点,再挂到父下面", async () => {
+    const inUse = (await nodesOf(admin.token)).find(node => node.registered === false);
+    if (!inUse) return;                       // 该网络里没有"未登记但在用"的标签时,这条不适用
+    const r = await op(admin.token, { op: "reparent", tag: inUse.name, parent: "RPD1" });
+    expect(r.status).toBe(200);
+    const after = await nodeOf(admin.token, inUse.name);
+    expect(after).toMatchObject({ parent_id: "RPD1", depth: 2, registered: true });
+    // 卡片上的标签字符串不变(改父级不是改名)
+    const stillUsed = db.all<{ tags_json: string }>("SELECT tags_json FROM requirements WHERE network_id = ?1 AND tags_json LIKE ?2", NET, `%${inUse.name}%`);
+    expect(stillUsed.length).toBeGreaterThan(0);
+  });
+
+  test("reparent 走同一把标签管理锁:节点令牌与 viewer 都拒(403),树不变", async () => {
+    const byNode = await op(nodeToken, { op: "reparent", tag: "RP根", parent: "RPD1" });
+    expect(byNode.status).toBe(403);
+    const byViewer = await op(vic.token, { op: "reparent", tag: "RP根", parent: "RPD1" });
+    expect(byViewer.status).toBe(403);
+    expect(await nodeOf(admin.token, "RP根")).toMatchObject({ parent_id: null });
+  });
+});
+
+describe("改父级 reparent —— 被拒绝时不留副作用", () => {
+  const nodes = async () => (await send(admin.token, "GET", `/api/requirements/tags?network_id=${NET}`)).body.nodes as Array<{ name: string; parent_id: string | null; registered: boolean }>;
+  test("只在卡片上用过的标签,reparent 到不存在的父:404 且**不会**被登记进树", async () => {
+    const before = (await nodes()).filter(node => !node.registered).map(node => node.name);
+    if (!before.length) return;                 // 该网络里没有"未登记但在用"的标签时,这条不适用
+    const name = before[0];
+    const r = await op(admin.token, { op: "reparent", tag: name, parent: "根本没有这个父" });
+    expect(r.status).toBe(404);
+    expect(r.body.error).toBe("tag_parent_not_found");
+    // 关键:事务返回错误码是**提交**语义,若先 INSERT 登记再报错,这里就会看到 registered=true
+    const after = (await nodes()).find(node => node.name === name);
+    expect(after?.registered ?? false).toBe(false);
+  });
+});

package/src/requirement-tag-tree.ts

@@ -95,3 +95,33 @@ export function buildTagNodes(registered: TagNodeRow[], inUse: string[]): TagNod
   }
   return nodes.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
 }
+
+/**
+ * name 这棵子树有几层(叶子 = 1)。改父级时用它算「搬过去之后最深到几层」:
+ * 只检查新父的深度是不够的 —— 一个 3 层的子树挂到第 3 层下,最深会到 5 层。
+ * 历史脏数据里有环时用 visited 兜住,不要为脏数据死循环。
+ */
+export function tagSubtreeHeight(name: string, parentOf: Map<string, string | null>): number {
+  const childrenOf = new Map<string, string[]>();
+  for (const [child, parent] of parentOf) {
+    if (!parent) continue;
+    const list = childrenOf.get(parent);
+    if (list) list.push(child); else childrenOf.set(parent, [child]);
+  }
+  let height = 1;
+  let frontier = [name];
+  const seen = new Set<string>([name]);
+  for (;;) {
+    const next: string[] = [];
+    for (const node of frontier) {
+      for (const child of childrenOf.get(node) ?? []) {
+        if (seen.has(child)) continue;
+        seen.add(child);
+        next.push(child);
+      }
+    }
+    if (!next.length) return height;
+    height++;
+    frontier = next;
+  }
+}

package/src/requirement-tags.ts

@@ -23,7 +23,9 @@ export type TagOp =
   | { op: "rename"; from: string; to: string }
   | { op: "merge"; from: string[]; to: string }
   | { op: "delete"; tag: string }
-  | { op: "color"; tag: string; color: string | null };
+  | { op: "color"; tag: string; color: string | null }
+  // 改父级(标签树自己的层级,与卡片无关):parent=null = 升为顶层。
+  | { op: "reparent"; tag: string; parent: string | null };
 
 /** 单个标签名,规则同 normalizeTags。不合法 = null。 */
 export function tagName(value: unknown): string | null {
@@ -66,6 +68,17 @@ export function parseTagOp(body: Record<string, unknown>): TagOp | { error: stri
       if (body.color !== null && (typeof body.color !== "string" || !TAG_COLOR.test(body.color))) return { error: "invalid_tag_color" };
       return { op: "color", tag, color: body.color === null ? null : (body.color as string).toLowerCase() };
     }
+    case "reparent": {
+      const tag = tagName(body.tag);
+      if (!tag) return { error: "invalid_tag" };
+      // 与 create 同一套读法:缺省 key 算错(不能靠"没传"把标签静默升到根),显式 null = 根。
+      if (!("parent" in body)) return { error: "invalid_tag_parent_id" };
+      if (body.parent === null || body.parent === "") return { op: "reparent", tag, parent: null };
+      const parent = tagName(body.parent);
+      if (!parent) return { error: "invalid_tag_parent_id" };
+      if (parent === tag) return { error: "tag_parent_cycle" };
+      return { op: "reparent", tag, parent };
+    }
     default:
       return { error: "invalid_tag_op" };
   }

package/src/requirements.ts

@@ -8,7 +8,7 @@ import { db, logAudit } from "./db.js";
 import { resolveNodeCaller } from "./create-node.js";
 import { markGzipReusable } from "./http-gzip.js";
 import { applyTagOp, normalizeTags, parseTagOp, storedTags, type TagOp } from "./requirement-tags.js";
-import { buildTagNodes, MAX_TAG_DEPTH, parseCreateTag, TAG_TREE_CAPABILITY, tagDepth, type TagNodeRow } from "./requirement-tag-tree.js";
+import { buildTagNodes, isDescendant, MAX_TAG_DEPTH, parseCreateTag, TAG_TREE_CAPABILITY, tagDepth, tagSubtreeHeight, type TagNodeRow } from "./requirement-tag-tree.js";
 import { aggregateStats, parseStatsQuery, type StatsRow } from "./requirements-stats.js";
 import { addHumanNetworkScope, canRestWriteNetwork, canRestWriteNetworkAsHuman, resolveRestWriteNetworkId, type RestNetworkScope } from "./network-scope.js";
 import { isAgentRestricted, restrictedNetworkIds, visibleAgents } from "./agent-access.js";
@@ -547,13 +547,37 @@ async function handleTagOp(ctx: RequirementsRequestContext): Promise<Response> {
     const sources = op.op === "rename" ? [op.from] : op.op === "merge" ? op.from : [op.tag];
     // 「存在」= 有卡片在用 / 有颜色行 / 是登记过的树节点。最后一种让 0 任务的标签也能改名、合并、删除、上色。
     const nodeExists = (name: string) => !!db.get<{ x: number }>("SELECT 1 AS x FROM network_tag_nodes WHERE network_id = ?1 AND name = ?2", networkId, name);
-    const known = cards.some(card => storedTags(card.tags_json).some(tag => sources.includes(tag))) || sources.some(tag => colorOf(tag) !== null || nodeExists(tag));
+    // 「存在」的三种形态(卡片在用 / 有颜色行 / 登记过的树节点),reparent 判父存在时用的是同一个口径。
+    const tagExists = (name: string) => cards.some(card => storedTags(card.tags_json).includes(name)) || colorOf(name) !== null || nodeExists(name);
+    const known = sources.some(tagExists);
     if (!known) return null;
     if (op.op === "color") {
       if (op.color === null) db.run("DELETE FROM network_tags WHERE network_id = ?1 AND name = ?2", [networkId, op.tag]);
       else db.run("INSERT INTO network_tags (network_id, name, color, updated_at) VALUES (?1, ?2, ?3, ?4) ON CONFLICT (network_id, name) DO UPDATE SET color = excluded.color, updated_at = excluded.updated_at", [networkId, op.tag, op.color, now]);
       return { affected: 0 };
     }
+    // 改父级:只动标签树,不动任何卡片(标签仍然是卡片 tags_json 里的字符串)。
+    // 三条规则都明确拒绝而不是静默纠正:父必须存在、不许成环、搬完最深不超过 MAX_TAG_DEPTH。
+    if (op.op === "reparent") {
+      const nodes = db.all<TagNodeRow>("SELECT name, parent_name FROM network_tag_nodes WHERE network_id = ?1", networkId);
+      const parentOf = new Map(nodes.map(row => [row.name, row.parent_name ?? null]));
+      // 只在卡片上出现过的老标签没有行可改,要登记成顶层节点(这不是把它降级,它本来就没有父)。
+      // ⚠ 先**在虚拟树上**判环与深度,判过了再写:事务返回 {error} 是提交而不是回滚,
+      //   如果先 INSERT 登记再返回错误,调用方看到的是"被拒绝了",库里却多了一行 —— 树被静默改过。
+      const virtual = new Map(parentOf);
+      if (!virtual.has(op.tag)) virtual.set(op.tag, null);
+      if (op.parent) {
+        if (!tagExists(op.parent)) return { error: "tag_parent_not_found" };
+        if (!virtual.has(op.parent)) virtual.set(op.parent, null);
+        // 环:父是自己(parse 已挡)或自己的子孙(这里挡)。深度:新父的深度 + 自己这棵子树的高度。
+        if (isDescendant(op.parent, op.tag, virtual)) return { error: "tag_parent_cycle" };
+        if (tagDepth(op.parent, virtual) + tagSubtreeHeight(op.tag, virtual) > MAX_TAG_DEPTH) return { error: "tag_depth_exceeded" };
+      }
+      if (!parentOf.has(op.tag)) db.run("INSERT INTO network_tag_nodes (network_id, name, parent_name, created_at, updated_at, created_by_json) VALUES (?1, ?2, NULL, ?3, ?3, ?4)", [networkId, op.tag, now, actor]);
+      if (op.parent && !parentOf.has(op.parent)) db.run("INSERT INTO network_tag_nodes (network_id, name, parent_name, created_at, updated_at, created_by_json) VALUES (?1, ?2, NULL, ?3, ?3, ?4)", [networkId, op.parent, now, actor]);
+      db.run("UPDATE network_tag_nodes SET parent_name = ?1, updated_at = ?2 WHERE network_id = ?3 AND name = ?4", [op.parent, now, networkId, op.tag]);
+      return { affected: 0, reparented: 1 };
+    }
     let affected = 0;
     for (const card of cards) {
       const next = applyTagOp(storedTags(card.tags_json), op);
@@ -567,13 +591,14 @@ async function handleTagOp(ctx: RequirementsRequestContext): Promise<Response> {
     return { affected, reparented };
   });
   if (!result) return jsonError("tag_not_found", 404);
+  if ("error" in result) return jsonError(result.error, result.error === "tag_parent_not_found" ? 404 : 400);
   if (ctx.auth) logAudit(ctx.auth.userId, ctx.auth.username || null, `requirement_tag_${op.op}`, "requirement_tag", op.op === "rename" || op.op === "merge" ? op.to : op.tag, JSON.stringify({ ...op, affected: result.affected }).slice(0, 1000), undefined, networkId);
   return Response.json({ ok: true, op: op.op, affected: result.affected, reparented: result.reparented });
 }
 
 /** 改名 / 合并:目标没有颜色就继承第一个有颜色的来源;来源的颜色行删掉。删除:删颜色行。 */
 function moveTagColors(networkId: string, op: TagOp, colorOf: (name: string) => string | null, now: string): void {
-  if (op.op === "color") return;
+  if (op.op === "color" || op.op === "reparent") return;
   const sources = op.op === "rename" ? [op.from] : op.op === "merge" ? op.from : [op.tag];
   if (op.op !== "delete" && colorOf(op.to) === null) {
     const inherited = sources.map(colorOf).find(color => color !== null);
@@ -590,7 +615,7 @@ function moveTagColors(networkId: string, op: TagOp, colorOf: (name: string) =>
  * 返回被改挂的节点数(客户端能报「N 个子标签已上移」)。
  */
 function maintainTagTree(networkId: string, op: TagOp, now: string): number {
-  if (op.op === "color") return 0;
+  if (op.op === "color" || op.op === "reparent") return 0;
   const rows = db.all<TagNodeRow>("SELECT name, parent_name FROM network_tag_nodes WHERE network_id = ?1", networkId);
   if (!rows.length) return 0;
   const parentOf = new Map(rows.map(row => [row.name, row.parent_name ?? null]));