@sleep2agi/commhub-server 0.9.0-preview.132 → 0.9.0-preview.133

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.132",
+  "version": "0.9.0-preview.133",
   "description": "CommHub Server \u2014 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/node-caller-identity-http.test.ts

@@ -288,6 +288,115 @@ const report = (tok: Tok, alias: string, nodeId: string, networkId: string, extr
     ...extra,
   });
 
+function lifecycleFixture(key: string) {
+  const daemonId = `node_life_daemon_${key}_${stamp}`, daemonAlias = `life-daemon-${key}-${stamp}`;
+  const childId = `node_life_${key}_${stamp}`, childAlias = `life-child-${key}-${stamp}`;
+  seedNode(daemonId, daemonAlias, NET, ownerId); seedNode(childId, childAlias, NET, ownerId);
+  seedSession(daemonId, daemonAlias, NET);
+  db.run("UPDATE nodes SET hostname='lifecycle-host',config_snapshot=?1 WHERE node_id=?2",
+    [JSON.stringify({ role: "host_supervisor", daemon_capabilities: { adopt_capable: true } }), daemonId]);
+  db.run("UPDATE nodes SET hostname='lifecycle-host',config_snapshot='{}' WHERE node_id=?1", [childId]);
+  db.run("UPDATE sessions SET last_seen_at=datetime('now') WHERE node_id=?1", [daemonId]);
+  return { daemonId, daemonAlias, childId, childAlias };
+}
+
+test("token lifecycle: adoption rejects a different node's same-name credential", async () => {
+  const f = lifecycleFixture("adopt-denied");
+  const otherNode = `n_life_other_${stamp}`;
+  seedNode(otherNode, `life-other-${stamp}`, NET, outsiderId);
+  mint(outsiderId, NET, f.daemonAlias, 2, otherNode);
+  mint(outsiderId, NET, f.daemonAlias, 0, null);
+  const result = await tool(ownerToken, "request_adopt_node", { node_id: f.childId, daemon_node_id: f.daemonId, workdir: "/workspace/fixture" });
+  expect(result.error).toBe("daemon_offline");
+  expect(db.get("SELECT request_id FROM node_daemon_bindings WHERE node_id=?1", f.childId)).toBeNull();
+});
+
+for (const shape of ["bound", "unbound"] as const) {
+  test(`token lifecycle: adoption accepts verified ${shape} credentials`, async () => {
+    const f = lifecycleFixture(`adopt-${shape}`);
+    mint(ownerId, NET, shape === "bound" ? victimAlias : f.daemonAlias, shape === "bound" ? 2 : 0, shape === "bound" ? f.daemonId : null);
+    const result = await tool(ownerToken, "request_adopt_node", { node_id: f.childId, daemon_node_id: f.daemonId, workdir: "/workspace/fixture" });
+    expect(result.ok).toBe(true);
+  });
+}
+
+test("token lifecycle: another node's heartbeat cannot make the daemon ready", async () => {
+  const f=lifecycleFixture("heartbeat-denied");
+  mint(ownerId,NET,f.daemonAlias,2,f.daemonId);
+  const other=`node_life_heartbeat_other_${stamp}`;
+  seedNode(other,f.daemonAlias,NET,outsiderId);
+  db.run("DELETE FROM sessions WHERE node_id=?1",[f.daemonId]);
+  seedSession(other,f.daemonAlias,NET);
+  db.run("UPDATE sessions SET last_seen_at=datetime('now') WHERE node_id=?1",[other]);
+  const result=await tool(ownerToken,"request_adopt_node",{node_id:f.childId,daemon_node_id:f.daemonId,workdir:"/workspace/fixture"});
+  expect(result.error).toBe("daemon_offline");
+});
+
+test("token lifecycle: a unique legacy null-ID heartbeat remains supported", async () => {
+  const f=lifecycleFixture("heartbeat-legacy");
+  mint(ownerId,NET,f.daemonAlias,0,null);
+  db.run("UPDATE sessions SET node_id=NULL WHERE node_id=?1",[f.daemonId]);
+  expect((await tool(ownerToken,"request_adopt_node",{node_id:f.childId,daemon_node_id:f.daemonId,workdir:"/workspace/fixture"})).ok).toBe(true);
+});
+
+for (const shape of ["frozen", "legacy null", "wrong frozen", "same alias rebuild"] as const) {
+  test(`token lifecycle: delete ${shape} revokes only the target credential`, async () => {
+    const key = shape.replaceAll(" ", "-"); const f = lifecycleFixture(key);
+    const daemonTok = mint(ownerId, NET, f.daemonAlias, 2, f.daemonId);
+    const wrong = mint(outsiderId, NET, f.childAlias, 0, null);
+    const childTok = mint(ownerId, NET, shape === "frozen" ? victimAlias : f.childAlias, 2, f.childId);
+    db.run(`INSERT INTO node_create_requests(request_id,daemon_node_id,child_name,child_node_id,network_id,runtime,flags_json,env_keys,status,child_token_id,created_at,created_by_token)
+            VALUES(?1,?2,?3,?4,?5,'fixture','{}','[]','started',?6,?7,'fixture')`,
+      [`cr_${f.childId.slice(5)}`, f.daemonId, f.childAlias, f.childId, NET, childTok.tokenId, Date.now()]);
+    const dispatched = await tool(ownerToken, "delete_node", { child_node_id: f.childId, daemon_node_id: f.daemonId, network_id: NET, confirm_alias: f.childAlias });
+    expect(dispatched.ok).toBe(true);
+    expect(db.get<{ child_token_id: string }>("SELECT child_token_id FROM node_stop_requests WHERE request_id=?1", dispatched.request_id)?.child_token_id).toBe(childTok.tokenId);
+    if (shape === "legacy null" || shape === "wrong frozen") db.run("UPDATE node_stop_requests SET child_token_id=?1 WHERE request_id=?2", [shape === "wrong frozen" ? wrong.tokenId : null, dispatched.request_id]);
+    let rebuilt: Tok | null = null;
+    if (shape === "same alias rebuild") {
+      db.run("DELETE FROM nodes WHERE node_id=?1", [f.childId]);
+      const newId = `n_life_rebuilt_${stamp}`;seedNode(newId, f.childAlias, NET, ownerId);
+      rebuilt = mint(ownerId, NET, f.childAlias, 2, newId);
+    }
+    const ack = await tool(daemonTok.token, "ack_stop_request", { request_id: dispatched.request_id, status: "stopped" });
+    expect(ack.ok).toBe(true);
+    const revoked = (id: string) => db.get<{ revoked_at: string | null }>("SELECT revoked_at FROM api_tokens WHERE token_id=?1", id)?.revoked_at;
+    expect(revoked(childTok.tokenId)).not.toBeNull();
+    expect(revoked(wrong.tokenId)).toBeNull();
+    if (rebuilt) expect(revoked(rebuilt.tokenId)).toBeNull();
+    expect(db.get("SELECT node_id FROM nodes WHERE node_id=?1", f.childId)).toBeNull();
+  });
+}
+
+test("token lifecycle: rename updates verified labels and preserves unrelated credentials", async () => {
+  const alias = `life-rename-${stamp}`, nodeId = `n_life_rename_${stamp}`, target = `life-renamed-${stamp}`;
+  seedNode(nodeId, alias, NET, ownerId);seedSession(nodeId, alias, NET);
+  const unrelated = mint(outsiderId, NET, alias, 0, null);
+  const bound = mint(ownerId, NET, victimAlias, 2, nodeId);
+  const legacy = mint(ownerId, NET, alias, 0, null);
+  const foreign = mint(outsiderId, NET2, alias, 0, null);
+  const before = [unrelated,foreign].map(t => tokenName(t.tokenId));
+  const prepare = await api(ownerToken, "POST", "/api/node-rename/prepare", { network_id: NET, old_alias: alias, new_alias: target });
+  expect(prepare.body.ok).toBe(true);
+  expect((await api(ownerToken, "POST", "/api/node-rename/commit", { txn_id: prepare.body.txn_id })).body.ok).toBe(true);
+  expect(tokenName(bound.tokenId)).toBe(`node:${target}`);
+  expect(tokenName(legacy.tokenId)).toBe(`node:${target}`);
+  expect([unrelated,foreign].map(t => tokenName(t.tokenId))).toEqual(before);
+});
+
+test("token lifecycle: rename refuses ambiguous node rows before and after prepare", async () => {
+  const alias=`life-dup-rename-${stamp}`, nodeId=`n_life_dupr_${stamp}`, target=`life-dup-target-${stamp}`;
+  seedNode(nodeId,alias,NET,ownerId);seedSession(nodeId,alias,NET);
+  const mine=mint(ownerId,NET,alias,2,nodeId);
+  const prepared=await api(ownerToken,"POST","/api/node-rename/prepare",{network_id:NET,old_alias:alias,new_alias:target});expect(prepared.body.ok).toBe(true);
+  seedNode(`n_life_dupo_${stamp}`,alias,NET,outsiderId);
+  expect((await api(ownerToken,"POST","/api/node-rename/commit",{txn_id:prepared.body.txn_id})).body.error).toBe("node_alias_ambiguous");
+  expect((await api(ownerToken,"POST","/api/node-rename/prepare",{network_id:NET,old_alias:alias,new_alias:target})).body.error).toBe("node_alias_ambiguous");
+  expect(tokenName(mine.tokenId)).toBe(`node:${alias}`);
+  expect(db.get("SELECT status FROM rename_txn WHERE txn_id=?1",prepared.body.txn_id)).toEqual({status:"prepared"});
+  await api(ownerToken,"POST","/api/node-rename/abort",{txn_id:prepared.body.txn_id});
+});
+
 beforeAll(async () => {
   process.env.COMMHUB_UPLOADS_DIR = join(dir, "uploads");
   process.env.HOST = "127.0.0.1";

package/src/node-daemon-bindings.ts

@@ -3,6 +3,7 @@ import { getUserNetworkRole } from "./auth.js";
 import { pushEvent } from "./push.js";
 import { canRestWriteNetwork } from "./network-scope.js";
 import { parseDbTimestampMs } from "./db-timestamp.js";
+import { activeNodeTokenIds } from "./node-token-identity.js";
 
 type Node = { node_id: string; alias: string; network_id: string; owner_user_id: string | null; hostname: string | null; config_snapshot: string | null };
 type Binding = { request_id: string; network_id: string; node_id: string; daemon_node_id: string; workdir: string; requested_by: string; status: string; error: string | null };
@@ -41,11 +42,15 @@ function daemonReady(daemon: Node | null, node: Node): string | null {
   const snap = snapshot(daemon);
   if (snap.role !== "host_supervisor" || snap.daemon_capabilities?.adopt_capable !== true) return "daemon_not_adopt_capable";
   if (!node.hostname || daemon.hostname !== node.hostname) return "hostname_mismatch";
-  const session = db.get<{ last_seen_at: string }>(`SELECT last_seen_at FROM sessions WHERE alias=?1 AND network_id=?2`, daemon.alias, daemon.network_id);
+  const session = db.get<{ last_seen_at: string }>(
+    `SELECT last_seen_at FROM sessions WHERE alias=?1 AND network_id=?2
+       AND (node_id=?3 OR (node_id IS NULL AND NOT EXISTS (
+         SELECT 1 FROM nodes n WHERE n.network_id=?2 AND n.alias=?1 AND n.node_id!=?3)))`,
+    daemon.alias, daemon.network_id, daemon.node_id,
+  );
   const seen = parseDbTimestampMs(session?.last_seen_at ?? "");
   if (!Number.isFinite(seen) || Date.now() - seen > 300_000) return "daemon_offline";
-  const token = db.get(`SELECT token_id FROM api_tokens WHERE name=?1 AND network_id=?2 AND revoked_at IS NULL`, `node:${daemon.alias}`, daemon.network_id);
-  return token ? null : "daemon_offline";
+  return activeNodeTokenIds(daemon.node_id, daemon.network_id).length ? null : "daemon_offline";
 }
 
 export function requestAdopt(ctx: Human, args: { node_id: string; daemon_node_id: string; workdir: string }) {

package/src/node-token-identity.ts

@@ -0,0 +1,35 @@
+import { db } from "./db.js";
+import { resolveNodeCaller } from "./create-node.js";
+
+/** Active credentials belonging to an immutable node, including verified legacy unbound tokens. */
+export function activeNodeTokenIds(nodeId: string, networkId: string): string[] {
+  const node = db.get<{ alias: string }>("SELECT alias FROM nodes WHERE node_id=?1 AND network_id=?2", nodeId, networkId);
+  if (!node) return [];
+  const tokens = db.all<{ token_id: string }>(
+    `SELECT token_id FROM api_tokens WHERE network_id=?1 AND scope='network' AND revoked_at IS NULL
+       AND (bound_node_id=?2 OR (bound_node_id IS NULL AND name=?3)) ORDER BY token_id`,
+    networkId, nodeId, `node:${node.alias}`,
+  );
+  return tokens.filter(token => {
+    const caller = resolveNodeCaller(token.token_id);
+    return caller.ok && caller.kind === "node" && caller.nodeId === nodeId && caller.networkId === networkId;
+  }).map(token => token.token_id);
+}
+
+/** Preserve the dispatch-time freeze; old requests without it use verified node identity. */
+export function revokeNodeTokens(nodeId: string, networkId: string, frozenTokenId: string | null): void {
+  let ids: string[];
+  if (frozenTokenId) {
+    const token = db.get<{ bound_node_id: string | null }>(
+      "SELECT bound_node_id FROM api_tokens WHERE token_id=?1 AND network_id=?2 AND scope='network' AND revoked_at IS NULL",
+      frozenTokenId, networkId,
+    );
+    // An immutable binding remains sufficient for revocation even after its node row was removed.
+    const caller = token && !token.bound_node_id ? resolveNodeCaller(frozenTokenId) : null;
+    ids = token?.bound_node_id === nodeId || (caller?.ok && caller.kind === "node" && caller.nodeId === nodeId && caller.networkId === networkId)
+      ? [frozenTokenId] : activeNodeTokenIds(nodeId, networkId);
+  } else {
+    ids = activeNodeTokenIds(nodeId, networkId);
+  }
+  for (const id of ids) db.run("UPDATE api_tokens SET revoked_at=datetime('now') WHERE token_id=?1 AND network_id=?2 AND revoked_at IS NULL", [id, networkId]);
+}

package/src/rename.ts

@@ -19,6 +19,7 @@ import { canSeeAgent, isAgentRestricted } from "./agent-access";
 import { pushEvent } from "./push";
 import { eventBus } from "./event_bus";
 import { aliasControlCharacter, describeAliasControlCharacter } from "./node-alias-control";
+import { activeNodeTokenIds } from "./node-token-identity.js";
 
 export interface RenameResult {
   ok: boolean;
@@ -127,6 +128,9 @@ export function prepareRename(
     };
   }
   if (oldAlias === newAlias) return { ok: false, error: "old and new alias are identical" };
+  if (db.all("SELECT node_id FROM nodes WHERE network_id=?1 AND alias=?2", networkId, oldAlias).length > 1) {
+    return { ok: false, error: "node_alias_ambiguous" };
+  }
 
   // old-alias must exist as a session in this network
   const oldSession = db.get<any>(
@@ -167,6 +171,10 @@ export function commitRename(userId: string, txnId: string): RenameResult {
   if (txn.status === "committed") return { ok: true, txn_id: txnId }; // idempotent
   if (txn.status === "aborted") return { ok: false, error: "rename transaction was aborted" };
   if (!hasWriteAccess(userId, txn.network_id)) return { ok: false, error: "no write access to this network" };
+  const nodes = db.all<{ node_id: string }>("SELECT node_id FROM nodes WHERE network_id=?1 AND alias=?2", txn.network_id, txn.old_alias);
+  if (nodes.length > 1) return { ok: false, error: "node_alias_ambiguous" };
+  // Resolve labels before changing the node alias, so legacy unbound ownership remains verifiable.
+  const tokenIds = nodes[0] ? activeNodeTokenIds(nodes[0].node_id, txn.network_id) : [];
 
   // Defense-in-depth: new-alias still free in both registries (prepare already CAS'd,
   // but a parallel direct registration could have raced in).
@@ -182,9 +190,9 @@ export function commitRename(userId: string, txnId: string): RenameResult {
     db.run(
       "UPDATE nodes SET alias = ?1, updated_at = datetime('now') WHERE network_id = ?2 AND alias = ?3",
       [txn.new_alias, txn.network_id, txn.old_alias]);
-    db.run(
-      "UPDATE api_tokens SET name = ?1 WHERE network_id = ?2 AND name = ?3",
-      [`node:${txn.new_alias}`, txn.network_id, `node:${txn.old_alias}`]);
+    for (const tokenId of tokenIds) db.run(
+      "UPDATE api_tokens SET name = ?1 WHERE token_id = ?2 AND network_id = ?3",
+      [`node:${txn.new_alias}`, tokenId, txn.network_id]);
     db.run(
       "UPDATE rename_txn SET status = 'committed', committed_at = datetime('now') WHERE txn_id = ?1",
       [txnId]);

package/src/stop-delete-node.test.ts

@@ -742,7 +742,6 @@ describe("inbox-enqueue lifecycle_state guard (RFC-027 §2.3 race-free)", () =>
     const r = await call(tools.send_task, {
       alias: CHILD_A_ALIAS,
       task: "racey post-SIGTERM task",
-      from_session: "sender-x",
       network_id: NET_A,
     });
     expect(r.ok).toBe(false);

package/src/tools.ts

@@ -15,6 +15,7 @@ import { assertNodeHealthy } from "./node-health-guard.js";
 import { noteModelAuthHealth } from "./model-auth-notify.js";
 import { numberedAliasInClause, parseAliasFilter } from "./alias-filter.js";
 import { createHash } from "node:crypto";
+import { activeNodeTokenIds, revokeNodeTokens } from "./node-token-identity.js";
 import { db, uuidv4, logTaskEvent, chainReplyToParent, hashToken, generateId, generateNetworkToken, syncScheduledRunForTask } from "./db.js";
 import { sessionTaskOnDispatch } from "./session-task-on-dispatch.js";
 import { TASK_CONTENT_MAX, sessionTaskPreview } from "./shared/task-content-limit.js";
@@ -5400,12 +5401,8 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
     // #1448 finding-5 — 记下该 child **当前活着的** ntok 的 token_id,让 ack 精确按
     // token_id 撤销,而非按 name='node:<alias>' 广撤。后者会在「同 alias 节点在这次
     // delete 未收敛的窗口内被重建(拿到同名新 token)」时,把新 token 一并误撤。这里
-    // 在派发时刻定住身份;若此刻没有活 token(异常),存 null,ack 退回按 name 撤(旧语义)。
-    const childTokenRow = db.get<{ token_id: string }>(
-      `SELECT token_id FROM api_tokens WHERE network_id = ?1 AND name = ?2 AND revoked_at IS NULL`,
-      node.network_id, `node:${node.alias}`,
-    );
-    const childTokenId = childTokenRow?.token_id ?? null;
+    // 在派发时刻定住经解析器验证的节点身份；旧请求也不按名字广撤。
+    const childTokenId = activeNodeTokenIds(node.node_id, node.network_id)[0] ?? null;
 
     // §4.5 D8 — lifecycle UPDATE + audit INSERTs + request INSERT atomic.
     // PR1.1: use db.transaction() (SQLiteAdapter wraps better-sqlite3's
@@ -5643,24 +5640,9 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
             });
           } else if (status === "stopped" && row.action === "delete") {
             // Revoke the child's ntok, then DELETE the nodes row.
-            // #1448 finding-5 — 精确按派发时定住的 child_token_id 撤(镜像
-            // ack_create_request 的 token_id 精撤)。旧行(升级前派发,child_token_id
-            // 为 NULL)fallback 回按 name='node:<alias>' 撤——旧语义,不引入回归。
-            // 按 token_id 撤避免了「同 alias 在本次 delete 窗口内被重建、拿到同名新
-            // token」时把新 token 一并误撤。
-            if (row.child_token_id) {
-              db.run(
-                `UPDATE api_tokens SET revoked_at = datetime('now')
-                   WHERE token_id = ?1 AND revoked_at IS NULL`,
-                [row.child_token_id],
-              );
-            } else {
-              db.run(
-                `UPDATE api_tokens SET revoked_at = datetime('now')
-                   WHERE network_id = ?1 AND name = ?2 AND revoked_at IS NULL`,
-                [row.network_id, `node:${row.child_alias}`],
-              );
-            }
+            // Validate the frozen token's immutable identity; legacy requests
+            // resolve only credentials belonging to this node before deleting it.
+            revokeNodeTokens(row.child_node_id, row.network_id, row.child_token_id);
             db.run(`DELETE FROM nodes WHERE node_id = ?1`, [row.child_node_id]);
             // Same as REST DELETE /api/nodes/:id: without this the sessions row
             // stays "offline" and /api/status lists the deleted node forever.