@sleep2agi/commhub-server 0.9.0-preview.111 → 0.9.0-preview.112

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.111",
+  "version": "0.9.0-preview.112",
   "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/binding-generation-http.test.ts

@@ -0,0 +1,121 @@
+import { beforeAll, afterAll, expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { preflightCodexStart } from "../../agent-node/src/runtime/adopt-codex-start-preflight.js";
+
+process.env.COMMHUB_DB ||= `${mkdtempSync("/tmp/binding-http-")}/hub.db`;
+process.env.COMMHUB_AUTH_TOKEN ||= "binding-master-fixture";
+let db:any, hub:ReturnType<typeof Bun.serve>, base:string, owner:any, other:any;
+const daemon="n_binding_daemon", child="n_binding_child";
+let token:string, wrong:string, cross:string, ordinary:string, revoked:string;
+async function mcp(credential:string,name:string,args:Record<string,unknown>={}) {
+  const res=await fetch(`${base}/mcp`, {method:"POST",headers:{Authorization:`Bearer ${credential}`,
+    "Content-Type":"application/json",Accept:"application/json, text/event-stream","MCP-Protocol-Version":"2025-03-26"},
+    body:JSON.stringify({jsonrpc:"2.0",id:1,method:"tools/call",params:{name,arguments:args}})});
+  const raw=await res.text();
+  if(res.status!==200)return {ok:false,http_status:res.status};
+  const lines=raw.split("\n").filter(s=>s.startsWith("data:"));
+  const payload=JSON.parse(lines.length?lines.at(-1)!.slice(5):raw);
+  return payload.result?.content?.[0]?.text ? JSON.parse(payload.result.content[0].text) : {ok:false,error:payload.error};
+}
+const list=(t=token)=>mcp(t,"list_my_children");
+const request=()=>mcp(owner.token,"request_adopt_node",{node_id:child,daemon_node_id:daemon,workdir:"/fixture/project"});
+const ack=(id:string,status="adopted")=>mcp(token,"ack_adopt_request",{request_id:id,status});
+const unadopt=()=>mcp(owner.token,"unadopt_node",{node_id:child});
+async function activate(){const r=await request();expect(r.ok).toBe(true);expect((await ack(r.request_id)).status).toBe("active");return r.request_id;}
+beforeAll(async()=>{
+  ({db}=await import("./db.js"));
+  const {register}=await import("./auth.js");
+  owner=register("binding_owner","Fixture-Strong1!");other=register("binding_other","Fixture-Strong1!");
+  expect(owner.ok&&other.ok).toBe(true);
+  db.run("UPDATE users SET role='user' WHERE user_id=?1",[other.user.user_id]);
+  db.run("INSERT INTO network_members(network_id,user_id,role) VALUES(?1,?2,'member')",[owner.network_id,other.user.user_id]);
+  const {generateNetworkToken,hashToken}=await import("./db.js");
+  function node(id:string,network:string,user:string,supervisor=true){
+    db.run("INSERT INTO nodes(node_id,node_name,alias,network_id,owner_user_id,hostname,config_snapshot,lifecycle_state) VALUES(?1,?1,?1,?2,?3,'fixture-host',?4,'active')",
+      [id,network,user,JSON.stringify(supervisor?{role:"host_supervisor",daemon_capabilities:{adopt_capable:true}}:{})]);
+    db.run("INSERT INTO sessions(resume_id,alias,node_id,network_id,status,last_seen_at) VALUES(?1,?1,?1,?2,'idle',datetime('now'))",[id,network]);
+    const raw=generateNetworkToken();
+    db.run("INSERT INTO api_tokens(token_id,user_id,network_id,scope,name,token_hash) VALUES(?1,?2,?3,'network',?4,?5)",[id,user,network,`node:${id}`,hashToken(raw)]);
+    return raw;
+  }
+  token=node(daemon,owner.network_id,owner.user.user_id);
+  wrong=node("n_binding_other",owner.network_id,other.user.user_id);
+  cross=node("n_binding_cross",other.network_id,other.user.user_id);
+  node(child,owner.network_id,owner.user.user_id,false);
+  ordinary=generateNetworkToken();revoked=generateNetworkToken();
+  for(const [id,raw,name,dead] of [["ordinary",ordinary,"general",null],["revoked",revoked,`node:${daemon}`,"2020-01-01"]])
+    db.run("INSERT INTO api_tokens(token_id,user_id,network_id,scope,name,token_hash,revoked_at) VALUES(?1,?2,?3,'network',?4,?5,?6)",[id,owner.user.user_id,owner.network_id,name,hashToken(raw as string),dead]);
+  db.run("INSERT INTO nodes(node_id,node_name,alias,network_id,lifecycle_state) VALUES('node_binding_created','created','created',?1,'active')",[owner.network_id]);
+  db.run("INSERT INTO node_create_requests(request_id,daemon_node_id,child_name,network_id,runtime,flags_json,env_keys,status,created_at,created_by_token) VALUES('cr_binding_created',?1,'created',?2,'codex-sdk','{}','[]','succeeded',1,'fixture')",[daemon,owner.network_id]);
+  const {bootServer}=await import("./server.js");hub=bootServer({port:0,hostname:"127.0.0.1"});base=`http://127.0.0.1:${hub.port}`;
+},60000);
+afterAll(()=>hub?.stop(true));
+
+test("generation projection and unchanged created row",async()=>{
+  const id=await activate();
+  const r=await list();expect(r.ok).toBe(true);
+  expect((await mcp(token,"get_adopt_request",{request_id:id})).error).toBe("request_not_pending");
+  expect(r.children.find((n:any)=>n.child_node_id===child)).toEqual({child_node_id:child,alias:child,lifecycle_state:"active",managed:"adopted",binding_request_id:id});
+  expect(r.children.find((n:any)=>n.child_node_id==="node_binding_created")).toEqual({child_node_id:"node_binding_created",alias:"created",lifecycle_state:"active"});
+  // Old consumers continue reading exactly the same fields; additive only.
+  expect(r.children.map(({child_node_id,alias,lifecycle_state,managed}:any)=>({child_node_id,alias,lifecycle_state,managed}))).toContainEqual({child_node_id:child,alias:child,lifecycle_state:"active",managed:"adopted"});
+  expect((await unadopt()).ok).toBe(true);
+});
+test("token boundary denies humans general revoked and other owners",async()=>{
+  await activate();
+  for(const t of [owner.token,other.token,ordinary,revoked])expect((await list(t)).ok).toBe(false);
+  for(const t of [wrong,cross]){const r=await list(t);expect(r.ok).toBe(true);expect(r.children).toEqual([]);}
+  expect((await unadopt()).ok).toBe(true);
+});
+test("child node token sees an empty list, not its parent binding",async()=>{
+  const id=await activate();
+  try {
+    const issued=await fetch(`${base}/api/auth/node-token`,{method:"POST",
+      headers:{Authorization:`Bearer ${owner.token}`,"Content-Type":"application/json"},
+      body:JSON.stringify({network_id:owner.network_id,node_name:child,node_id:child})});
+    expect(issued.status).toBe(200);
+    const credential=await issued.json() as any;
+    expect(credential.ok).toBe(true);
+    expect(typeof credential.token).toBe("string");
+    // Same owner and network do not confer the parent's daemon identity.
+    expect((await list()).children.find((n:any)=>n.child_node_id===child).binding_request_id).toBe(id);
+    expect(await list(credential.token)).toEqual({ok:true,count:0,children:[]});
+  } finally {expect((await unadopt()).ok).toBe(true);}
+});
+test("network predicate rejects corrupted cross-network binding sentinel",async()=>{
+  const id=await activate();
+  // Deliberately inconsistent test DB: daemon stays in A, binding and child in B.
+  // This makes the network predicate independently load-bearing, HTTP still real.
+  try {
+    db.run("UPDATE node_daemon_bindings SET network_id=?1 WHERE request_id=?2",[other.network_id,id]);
+    db.run("UPDATE nodes SET network_id=?1 WHERE node_id=?2",[other.network_id,child]);
+    expect((await list()).children.some((n:any)=>n.child_node_id===child)).toBe(false);
+  } finally {
+    db.run("UPDATE node_daemon_bindings SET network_id=?1 WHERE request_id=?2",[owner.network_id,id]);
+    db.run("UPDATE nodes SET network_id=?1 WHERE node_id=?2",[owner.network_id,child]);await unadopt();
+  }
+});
+test("node join rejects mismatched node network sentinel",async()=>{
+  await activate();
+  try {db.run("UPDATE nodes SET network_id=?1 WHERE node_id=?2",[other.network_id,child]);expect((await list()).children.some((n:any)=>n.child_node_id===child)).toBe(false);}
+  finally {db.run("UPDATE nodes SET network_id=?1 WHERE node_id=?2",[owner.network_id,child]);await unadopt();}
+});
+test("non-active bindings never project generation",async()=>{
+  const r=await request();expect(r.ok).toBe(true);
+  expect((await list()).children.some((n:any)=>n.child_node_id===child)).toBe(false);
+  expect((await ack(r.request_id,"refused")).status).toBe("refused");
+  expect((await list()).children.some((n:any)=>n.child_node_id===child)).toBe(false);
+  await activate();await unadopt();expect((await list()).children.some((n:any)=>n.child_node_id===child)).toBe(false);
+});
+test("revocation rotates generation and old acknowledgements cannot revive",async()=>{
+  const r1=await activate();await unadopt();
+  expect((await ack(r1)).error).toBe("request_not_pending");
+  const r2=await request();expect(r2.ok).toBe(true);expect(r2.request_id).not.toBe(r1);
+  expect((await list()).children.some((n:any)=>n.child_node_id===child)).toBe(false);
+  expect((await ack(r2.request_id)).status).toBe("active");
+  const current=(await list()).children.find((n:any)=>n.child_node_id===child).binding_request_id;
+  expect(current).toBe(r2.request_id);expect(current).not.toBe(r1);
+  // Real HTTP authority feeds the existing daemon gate; later probes must not run.
+  for(const authority of [current,undefined])await expect(preflightCodexStart({request_id:r1} as any,{} as any,{} as any,authority,()=>true)).rejects.toThrow("adopt_codex_binding_generation_unproven");
+  await unadopt();
+});

package/src/create-node.ts

@@ -232,47 +232,91 @@ export type DaemonResolveResult =
   | { ok: true; daemonNodeId: string; daemonAlias: string; networkId: string }
   | { ok: false; error: string };
 
-export function resolveCallerDaemonTokenBound(opts: {
-  callerTokenIsNetwork: boolean;
-  callerTokenId: string | null | undefined;
-  enforceNetworkId: string | null | undefined;
-}): DaemonResolveResult {
-  if (!opts.callerTokenIsNetwork || !opts.callerTokenId) {
-    return { ok: false, error: "caller_not_a_daemon" };
-  }
-  if (!opts.enforceNetworkId) {
-    return { ok: false, error: "caller_not_a_daemon" };
-  }
+export type NodeCallerResolution =
+  | { ok: true; kind: "node"; nodeId: string; alias: string; networkId: string }
+  | { ok: true; kind: "unregistered"; alias: string; networkId: string }
+  | { ok: false; reason: "not_a_node_token" | "bound_node_missing" | "ambiguous" | "not_owner" };
+
+type NodeCallerRow = { node_id: string; alias: string; network_id: string; owner_user_id: string | null };
+
+// nodes has no unique (network, alias). An unbound token that hits several
+// rows is not rejected outright: the row owned by the token's issuer wins;
+// if that is still not unique, the node_id on the latest session for the
+// alias wins. Still not unique, then refuse.
+function disambiguateUnboundAlias(
+  rows: NodeCallerRow[],
+  userId: string | null,
+  alias: string,
+  networkId: string,
+): NodeCallerRow | undefined {
+  const owned = userId ? rows.filter((row) => row.owner_user_id === userId) : [];
+  if (owned.length === 1) return owned[0]; // board679-unbound-dup
+  const pool = owned.length > 1 ? owned : rows;
+  const recent = db.get<{ node_id: string | null }>(
+    `SELECT node_id FROM sessions WHERE alias = ?1 AND network_id = ?2 AND node_id IS NOT NULL ORDER BY updated_at DESC LIMIT 1`,
+    alias,
+    networkId,
+  );
+  const hit = recent?.node_id ? pool.filter((row) => row.node_id === recent.node_id) : [];
+  return hit.length === 1 ? hit[0] : undefined;
+}
+
+// One lookup for every caller-identity entry. The token name is a hint.
+// bound_node_id is the row: if that row is gone, refuse — do not look up by name.
+// An unbound token with no row in its network stays the token name. First
+// registration (report_status) still depends on that; sending and subscribing
+// do not get a second exception.
+export function resolveNodeCaller(tokenId: string | null | undefined): NodeCallerResolution {
+  if (!tokenId) return { ok: false, reason: "not_a_node_token" };
   const tokRow = db.get<{ name: string; network_id: string | null; user_id: string | null; bound_node_id: string | null; node_identity_epoch: number }>(
     `SELECT name, network_id, user_id, bound_node_id, node_identity_epoch FROM api_tokens WHERE token_id = ?1 AND revoked_at IS NULL`,
-    opts.callerTokenId,
+    tokenId,
   );
-  if (!tokRow || !tokRow.name || !tokRow.name.startsWith("node:")) {
-    return { ok: false, error: "caller_not_a_daemon" };
-  }
-  if (tokRow.network_id !== opts.enforceNetworkId) {
-    return { ok: false, error: "caller_not_a_daemon" };
+  if (!tokRow || !tokRow.name || !tokRow.name.startsWith("node:") || !tokRow.network_id) {
+    return { ok: false, reason: "not_a_node_token" };
   }
   const tokenAlias = tokRow.name.slice(5);
   type DaemonRow = { node_id: string; alias: string; network_id: string; owner_user_id: string | null };
   const rows = tokRow.bound_node_id
     ? db.all<DaemonRow>(`SELECT node_id, alias, network_id, owner_user_id FROM nodes WHERE node_id = ?1 AND network_id = ?2`, tokRow.bound_node_id, tokRow.network_id)
     : db.all<DaemonRow>(`SELECT node_id, alias, network_id, owner_user_id FROM nodes WHERE alias = ?1 AND network_id = ?2`, tokenAlias, tokRow.network_id);
-  const nodeRow = rows.length === 1 ? rows[0] : undefined;
-  if (!nodeRow) {
-    return { ok: false, error: "caller_not_a_daemon" };
+  const nodeRow = rows.length === 1
+    ? rows[0]
+    : (!tokRow.bound_node_id && rows.length > 1
+      ? disambiguateUnboundAlias(rows, tokRow.user_id, tokenAlias, tokRow.network_id)
+      : undefined);
+  // board679-bound-row-missing: a bound token with no row is refused. Do not look up by name.
+  if (tokRow.bound_node_id && !nodeRow) return { ok: false, reason: "bound_node_missing" };
+  if (!nodeRow && rows.length === 0) {
+    return { ok: true, kind: "unregistered", alias: tokenAlias, networkId: tokRow.network_id };
   }
-  // Legacy daemon tokens have no bound_node_id: retain their owner's authority.
-  // A token name is a lookup hint, never proof of authority over that node.
+  if (!nodeRow) return { ok: false, reason: "ambiguous" };
+  // Legacy unbound tokens keep their owner's authority. A token name is only a hint.
   const ownsNode = !!tokRow.user_id && tokRow.user_id === nodeRow.owner_user_id;
   const boundToNode = tokRow.bound_node_id === nodeRow.node_id;
   const legacyOwnerless = nodeRow.owner_user_id === null && tokRow.node_identity_epoch === 0;
-  if (!ownsNode && !boundToNode && !legacyOwnerless) return { ok: false, error: "caller_not_a_daemon" };
+  if (!ownsNode && !boundToNode && !legacyOwnerless) return { ok: false, reason: "not_owner" };
+  return { ok: true, kind: "node", nodeId: nodeRow.node_id, alias: nodeRow.alias, networkId: nodeRow.network_id };
+}
+
+export function resolveCallerDaemonTokenBound(opts: {
+  callerTokenIsNetwork: boolean;
+  callerTokenId: string | null | undefined;
+  enforceNetworkId: string | null | undefined;
+}): DaemonResolveResult {
+  if (!opts.callerTokenIsNetwork || !opts.callerTokenId || !opts.enforceNetworkId) {
+    return { ok: false, error: "caller_not_a_daemon" };
+  }
+  const resolved = resolveNodeCaller(opts.callerTokenId);
+  // No row yet is not a daemon. First registration stays on report_status.
+  if (!resolved.ok || resolved.kind !== "node" || resolved.networkId !== opts.enforceNetworkId) {
+    return { ok: false, error: "caller_not_a_daemon" };
+  }
   return {
     ok: true,
-    daemonNodeId: nodeRow.node_id,
-    daemonAlias: nodeRow.alias,
-    networkId: nodeRow.network_id,
+    daemonNodeId: resolved.nodeId,
+    daemonAlias: resolved.alias,
+    networkId: resolved.networkId,
   };
 }
 

package/src/daemon-token-owner-http.test.ts

@@ -116,7 +116,7 @@ test("legacy owner and exact bound identity remain supported", async () => {
   const denied = await fetch(`${base}/mcp`, { method: "POST", headers: { Authorization: `Bearer ${revoked}` } });
   expect(denied.status).toBe(401);
   expect(await call(legacy, "ack_adopt_request", { request_id: requestId, status: "adopted" })).toMatchObject({ ok: true, status: "active" });
-  expect((await call(legacy, "list_my_children")).children).toContainEqual({ child_node_id: child, alias: child, lifecycle_state: "active", managed: "adopted" });
+  expect((await call(legacy, "list_my_children")).children).toContainEqual({ child_node_id: child, alias: child, lifecycle_state: "active", managed: "adopted", binding_request_id: requestId });
   const stop = await call(owner.token, "stop_node", { node_id: child, network_id: owner.network_id });
   expect(stop.ok).toBe(true);
   expect((await call(legacy, "get_stop_request", { request_id: stop.request_id })).ok).toBe(true);
@@ -169,9 +169,10 @@ test("fresh ID cannot mint another node alias", async () => {
   expect((await call(legacy, "list_my_children")).ok).toBe(true);
 });
 
-test("duplicate legacy aliases use bound IDs and unbound ambiguity fails closed", async () => {
+test("duplicate legacy aliases use bound IDs and an unbound token follows its owner", async () => {
   // Historical duplicate rows: the member's row was inserted first. Neither
-  // lookup order nor alias can redirect the later owner's exact-bound token.
+  // lookup order nor alias can redirect an exact-bound token. An unbound
+  // token resolves to the row its issuer owns.
   const { hashToken, generateNetworkToken } = await import("./db.js");
   const tokens: string[] = [];
   for (const [id, user] of [["n_duplicate_first", member.user.user_id], ["n_duplicate_owner", owner.user.user_id]]) {
@@ -188,9 +189,13 @@ test("duplicate legacy aliases use bound IDs and unbound ambiguity fails closed"
     expect((await call(tokens[i], "get_adopt_request", { request_id: i === 0 ? "n_duplicate_owner" : "n_duplicate_first" })).ok).toBe(false);
   }
   db.run("UPDATE api_tokens SET bound_node_id=NULL WHERE token_id='n_duplicate_owner'");
-  expect(await call(tokens[1], "list_my_children")).toMatchObject({ ok: false, error: "caller_not_a_daemon" });
+  expect((await call(tokens[1], "list_my_children")).ok).toBe(true);
+  expect((await call(tokens[1], "get_adopt_request", { request_id: "n_duplicate_owner" })).ok).toBe(true);
+  expect((await call(tokens[1], "get_adopt_request", { request_id: "n_duplicate_first" })).ok).toBe(false);
   db.run("UPDATE api_tokens SET bound_node_id=NULL WHERE token_id='n_duplicate_first'");
-  expect(await call(tokens[0], "list_my_children")).toMatchObject({ ok: false, error: "caller_not_a_daemon" });
+  expect((await call(tokens[0], "list_my_children")).ok).toBe(true);
+  expect((await call(tokens[0], "get_adopt_request", { request_id: "n_duplicate_first" })).ok).toBe(true);
+  expect((await call(tokens[0], "get_adopt_request", { request_id: "n_duplicate_owner" })).ok).toBe(false);
   expect((await mint(owner.token, owner.network_id, "duplicate_fixture", "n_third_duplicate")).status).toBe(400);
 });