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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.131",
-  "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).",
+  "version": "0.9.0-preview.132",
+  "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",
   "bin": {

package/src/dashboard-slash-routing-http.test.ts

@@ -14,6 +14,7 @@ const TARGET_RESUME_ID = `resume_dashboard_slash_target_${process.pid}`;
 let server: any;
 let base = "";
 let userToken = "";
+let userName = "";
 let nodeToken = "";
 let networkId = "";
 let requestSequence = 0;
@@ -25,6 +26,7 @@ let requestSequence = 0;
 beforeAll(async () => {
   process.env.COMMHUB_DB = process.env.COMMHUB_DB || join(PRIVATE_DB_DIR, "hub.db");
   const username = `dashboard_slash_${Date.now()}`;
+  userName = username;
   const registered = register(username, "DashboardSlash123!", undefined, "seed");
   expect(registered.ok).toBe(true);
   userToken = registered.token!;
@@ -81,7 +83,7 @@ async function postAndRead(token: string, from: string, task: string) {
 describe("real Hub → authenticated Dashboard slash routing", () => {
   test("Dashboard /goal and /loop remain exact native payloads for every runtime", async () => {
     for (const command of ["/goal 更新一下文档", "/loop 5m native loop"] as const) {
-      const row = await postAndRead(userToken, "dashboard-user", command);
+      const row = await postAndRead(userToken, userName, command);
       expect(row.content).toBe(command);
       expect(isInteractiveDashboardTask(row)).toBe(true);
       for (const runtime of ["codex-app-server", "codex", "claude", "grok", "opencode"] as const) {
@@ -92,7 +94,7 @@ describe("real Hub → authenticated Dashboard slash routing", () => {
 
   test("Dashboard /agoal and /aloop use the Agent Network scheduler", async () => {
     for (const command of ["/agoal 5m update docs", "/aloop 5m update docs"] as const) {
-      const row = await postAndRead(userToken, "dashboard-user", command);
+      const row = await postAndRead(userToken, userName, command);
       expect(isInteractiveDashboardTask(row)).toBe(true);
       expect(shouldCreateScheduledGoal(row.content, "codex-app-server", true)).toBe(true);
     }

package/src/node-caller-identity-http.test.ts

@@ -75,6 +75,92 @@ let p10Owner: Tok;
 type Sub = { events: any[]; done: boolean; abort: () => void; ready: Promise<void> };
 const openSubs: Sub[] = [];
 
+for (const transport of ["mcp", "rest"] as const) {
+  for (const shape of ["bound duplicate", "unbound duplicate", "no session", "other network"] as const) {
+    test(`node attribution: ${transport} ${shape} retains the credential's node ID`, async () => {
+      const key = `${transport}-${shape.replaceAll(" ", "-")}-${stamp}`;
+      const alias = `idvsender-${key}`;
+      const mine = `n_idv_sender_${key}`;
+      const member = register(`idvmem-${key}`, "CallerMember123!", undefined, "seed");
+      if (!member.ok || !member.user) throw new Error("member fixture failed");
+      const memberId = member.user.user_id;
+      const joined = addNetworkMember(NET, memberId, "member", ownerId, { agentAccess: "all" });
+      if (!joined.ok) throw new Error(joined.error);
+      seedNode(mine, alias, NET, memberId);
+      if (shape.includes("duplicate")) {
+        const ownerNode = `n_idv_owner_${key}`;
+        seedNode(ownerNode, alias, NET, ownerId);
+        seedSession(ownerNode, alias, NET); // the active session belongs to a different row
+      }
+      if (shape === "other network") {
+        const foreignNode = `n_idv_foreign_${key}`;
+        seedNode(foreignNode, alias, NET2, outsiderId);
+        seedSession(foreignNode, alias, NET2);
+      }
+      const tok = mint(memberId, NET, shape === "bound duplicate" ? victimAlias : alias,
+        shape === "unbound duplicate" ? 0 : 2, shape === "unbound duplicate" ? null : mine);
+      const content = `sender identity ${key}`;
+      const sent = transport === "mcp"
+        ? await mcpSend(tok.token, content, undefined)
+        : (await api(tok.token, "POST", "/api/task", { alias: sinkAlias, task: content, network_id: NET })).body;
+      expect(sent.ok).toBe(true);
+      const row = db.get("SELECT from_name, from_node_id, network_id FROM tasks WHERE content = ?1", content);
+      expect(row).toEqual({ from_name: alias, from_node_id: mine, network_id: NET });
+    });
+  }
+}
+
+for (const owner of ["own", "another"] as const) {
+  test(`rename registry: prepare rejects ${owner} node without a session`, async () => {
+    const target = `idvreserved-${owner}-${stamp}`;
+    seedNode(`n_idv_reserved_${owner}_${stamp}`, target, NET, owner === "own" ? ownerId : outsiderId);
+    const before = db.get("SELECT COUNT(*) AS n FROM rename_txn");
+    const result = await api(ownerToken, "POST", "/api/node-rename/prepare", { network_id: NET, old_alias: victimAlias, new_alias: target });
+    expect(result.status).toBe(400);
+    expect(result.body.ok).toBe(false);
+    expect(db.get("SELECT COUNT(*) AS n FROM rename_txn")).toEqual(before);
+    expect(sessionSnap(victimAlias, NET)?.node_id).toBe(victimId);
+  });
+}
+
+test("rename registry: commit rejects a node created after prepare", async () => {
+  const target = `idvrace-${stamp}`;
+  const prepared = await api(ownerToken, "POST", "/api/node-rename/prepare", { network_id: NET, old_alias: victimAlias, new_alias: target });
+  expect(prepared.body.ok).toBe(true);
+  const nodeId = `n_idv_race_${stamp}`;
+  seedNode(nodeId, target, NET, outsiderId);
+  const result = await api(ownerToken, "POST", "/api/node-rename/commit", { txn_id: prepared.body.txn_id });
+  expect(result.status).toBe(400);
+  expect(result.body.ok).toBe(false);
+  expect(sessionSnap(victimAlias, NET)?.node_id).toBe(victimId);
+  expect(db.get("SELECT alias FROM nodes WHERE node_id = ?1", nodeId)).toEqual({ alias: target });
+  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 });
+});
+
+test("rename registry: another network's node does not reserve the local alias", async () => {
+  const target = `idvforeign-target-${stamp}`;
+  seedNode(`n_idv_foreign_target_${stamp}`, target, NET2, outsiderId);
+  const prepared = await api(ownerToken, "POST", "/api/node-rename/prepare", { network_id: NET, old_alias: victimAlias, new_alias: target });
+  expect(prepared.body.ok).toBe(true);
+  expect((await api(ownerToken, "POST", "/api/node-rename/abort", { txn_id: prepared.body.txn_id })).body.ok).toBe(true);
+});
+
+test("rename registry: a free alias commits and preserves node identity", async () => {
+  const alias = `idvrename-old-${stamp}`;
+  const target = `idvrename-new-${stamp}`;
+  const nodeId = `n_idv_rename_${stamp}`;
+  seedNode(nodeId, alias, NET, ownerId);
+  seedSession(nodeId, alias, NET);
+  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);
+  const committed = await api(ownerToken, "POST", "/api/node-rename/commit", { txn_id: prepared.body.txn_id });
+  expect(committed.body.ok).toBe(true);
+  expect(sessionSnap(target, NET)?.node_id).toBe(nodeId);
+  expect(sessionSnap(alias, NET)).toBeNull();
+  expect(db.get("SELECT alias FROM nodes WHERE node_id = ?1", nodeId)).toEqual({ alias: target });
+});
+
 function subscribe(path: string, token: string, headers: Record<string, string> = {}): Sub {
   const ctrl = new AbortController();
   const sub: Sub = { events: [], done: false, abort: () => ctrl.abort(), ready: Promise.resolve() };
@@ -165,6 +251,16 @@ function minted(userId: string, networkId: string, alias: string, nodeId: string
   return { token: row.token, tokenId: row.token_id };
 }
 
+function seedNode(nodeId: string, alias: string, networkId: string, userId: string) {
+  db.run(`INSERT INTO nodes (node_id, node_name, alias, network_id, owner_user_id)
+          VALUES (?1, ?2, ?2, ?3, ?4)`, [nodeId, alias, networkId, userId]);
+}
+
+function seedSession(nodeId: string, alias: string, networkId: string) {
+  db.run(`INSERT INTO sessions (resume_id, alias, node_id, network_id, status)
+          VALUES (?1, ?2, ?3, ?4, 'idle')`, [`sdk-${nodeId}`, alias, nodeId, networkId]);
+}
+
 function taskCount(content: string): number {
   return Number(db.get<{ n: number | string }>("SELECT COUNT(*) AS n FROM tasks WHERE content = ?1", content)?.n ?? 0);
 }

package/src/rename.ts

@@ -109,7 +109,7 @@ export function cleanupCommittedRenameSessions(networkIds: string[] | null = nul
 
 // PHASE 1 P3 — create a prepared rename_txn row reserving new_alias.
 // CAS guard (RFC §4 risk #3 TOCTOU): new_alias must be free both in the
-// sessions registry AND among in-flight prepared rename_txn rows.
+// sessions/nodes registries AND among in-flight prepared rename_txn rows.
 export function prepareRename(
   userId: string, networkId: string, oldAlias: string, newAlias: string,
 ): RenameResult {
@@ -140,9 +140,9 @@ export function prepareRename(
     };
   }
 
-  // new-alias must not be taken — in sessions OR reserved by another prepared txn
+  // A node can reserve its alias before it has ever reported a session.
   const newInSessions = db.get<any>(
-    "SELECT 1 FROM sessions WHERE network_id = ?1 AND alias = ?2", networkId, newAlias);
+    "SELECT 1 FROM sessions WHERE network_id = ?1 AND alias = ?2 UNION ALL SELECT 1 FROM nodes WHERE network_id = ?1 AND alias = ?2", networkId, newAlias);
   if (newInSessions) return { ok: false, error: `alias "${newAlias}" already in use` };
   const newPrepared = db.get<any>(
     "SELECT txn_id FROM rename_txn WHERE network_id = ?1 AND new_alias = ?2 AND status = 'prepared'",
@@ -168,10 +168,10 @@ export function commitRename(userId: string, txnId: string): RenameResult {
   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" };
 
-  // Defense-in-depth: new-alias still free in sessions (prepare already CAS'd,
+  // Defense-in-depth: new-alias still free in both registries (prepare already CAS'd,
   // but a parallel direct registration could have raced in).
   const conflict = db.get<any>(
-    "SELECT 1 FROM sessions WHERE network_id = ?1 AND alias = ?2", txn.network_id, txn.new_alias);
+    "SELECT 1 FROM sessions WHERE network_id = ?1 AND alias = ?2 UNION ALL SELECT 1 FROM nodes WHERE network_id = ?1 AND alias = ?2", txn.network_id, txn.new_alias);
   if (conflict) return { ok: false, error: `alias "${txn.new_alias}" was taken since prepare` };
 
   const renamedNode = db.transaction(() => {

package/src/rest-identity.ts

@@ -33,7 +33,7 @@ export interface RestIdentityInput {
 }
 
 export type RestIdentityResult =
-  | { ok: true; fromSession: string }
+  | { ok: true; fromSession: string; nodeId?: string | null }
   | {
       ok: false;
       error: "from_session_identity_mismatch";
@@ -69,10 +69,12 @@ export function resolveUserTaskFromSession(username: string | null | undefined,
 export function resolveRestFromSession(input: RestIdentityInput): RestIdentityResult {
   const requested = typeof input.requestedFrom === "string" ? input.requestedFrom.trim() : "";
   let alias: string | null;
+  let nodeId: string | null = null;
   if (input.token.startsWith("ntok_") && input.tokenId) {
     const resolved = resolveNodeCaller(input.tokenId);
     if (resolved.ok) {
       alias = resolved.alias;
+      nodeId = resolved.kind === "node" ? resolved.nodeId : null;
     } else if (resolved.reason === "not_a_node_token") { // board679-plain-ntok-rest
       // Name is not `node:` yet. Main signs that as api, and refuses a claim.
       // not_owner / bound_node_missing / ambiguous stay the hard reject.
@@ -135,5 +137,5 @@ export function resolveRestFromSession(input: RestIdentityInput): RestIdentityRe
   }
 
   // Node token, no claim or a matching one: bind to the token's own alias.
-  return { ok: true, fromSession: alias };
+  return { ok: true, fromSession: alias, ...(input.tokenId ? { nodeId } : {}) };
 }

package/src/server.ts

@@ -3695,7 +3695,9 @@ return Bun.serve({
       const ttlSeconds = (body as any).ttl_seconds || 3600;
       const fromNodeId = restAuth && !requestToken(req).startsWith("ntok_")
         ? null
-        : resolveRestNodeIdForAlias(fromSession, taskNetId);
+        : requestToken(req).startsWith("ntok_")
+          ? (identity.nodeId ?? null)
+          : resolveRestNodeIdForAlias(fromSession, taskNetId);
       const targetNodeId = target.session?.node_id ?? null;
       const actualTo = restActualTo(target, taskNetId);
       // #221 — fold top-level `attachments` into `meta.attachments` so

package/src/tools.ts

@@ -58,6 +58,7 @@ import {
   auditCreateNode,
   auditCreateNodeStrict,
   resolveCallerDaemonTokenBound as _resolveCallerDaemonTokenBound,
+  resolveNodeCaller,
 } from "./create-node.js";
 import { decideClone, factsFromRows, parseWorkdirPolicy } from "./clone-node.js";
 import {
@@ -2007,7 +2008,10 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
       }
 
       console.log(`[${ts()}] ${from_session} → send_task → ${targetAlias}: ${task.slice(0, 60)}${priority === "high" ? " [HIGH]" : ""}${canonical.renamed ? ` [renamed from ${alias}]` : ""}`);
-      const fromNodeId = humanSender ? null : resolveNodeIdForAlias(from_session, effectiveNetId);
+      const senderIdentity = callerTokenIsNetwork ? resolveNodeCaller(callerTokenId) : null;
+      const fromNodeId = humanSender ? null : callerTokenIsNetwork
+        ? (senderIdentity?.ok && senderIdentity.kind === "node" && senderIdentity.networkId === effectiveNetId ? senderIdentity.nodeId : null)
+        : resolveNodeIdForAlias(from_session, effectiveNetId);
       const targetNodeId = target.session?.node_id ?? null;
       const resolvedActualTo = actualTo(target, effectiveNetId);
       // #500 step 2 — what is already queued on the target, read BEFORE this task is written (advice only, never blocks).