@sleep2agi/commhub-server 0.9.0-preview.120 → 0.9.0-preview.122

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.120",
+  "version": "0.9.0-preview.122",
   "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/adoption-candidates-http.test.ts

@@ -0,0 +1,137 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const dir = mkdtempSync(join(tmpdir(), "adoption-candidates-"));
+process.env.COMMHUB_DB ||= join(dir, "hub.db");
+process.env.COMMHUB_AUTH_TOKEN ||= "adoption-candidates-master-fixture";
+const WORKDIR = "/home/example/adoption-candidate-workdir-654";
+const SECRET = "ntok_should_not_surface";
+let hub: { stop: (closeActiveConnections?: boolean) => void; port: number }, base: string;
+let db: any, owner: any, member: any, nodeOwner: any, other: any, daemonToken: string;
+const ids = { daemon: "n_cand_daemon", hand: "n_cand_hand", foreign: "n_cand_foreign" };
+
+const get = async (path: string, token = owner.token) => {
+  const res = await fetch(base + path, { headers: { Authorization: `Bearer ${token}` } });
+  return { status: res.status, body: await res.json() as any, text: "" };
+};
+const raw = async (path: string, token = owner.token) => {
+  const res = await fetch(base + path, { headers: { Authorization: `Bearer ${token}` } });
+  const text = await res.text();
+  return { status: res.status, text, body: JSON.parse(text) };
+};
+
+function snapshot(candidates: unknown, adopt = true) {
+  return JSON.stringify({
+    role: "host_supervisor",
+    daemon_capabilities: { adopt_capable: adopt, adoption_candidates: candidates },
+  });
+}
+
+beforeAll(async () => {
+  ({ db } = await import("./db.js"));
+  const { register } = await import("./auth.js");
+  const suffix = Date.now();
+  owner = register(`cand_owner_${suffix}`, "CandFixture-Strong1!");
+  member = register(`cand_member_${suffix}`, "CandFixture-Strong1!");
+  nodeOwner = register(`cand_node_owner_${suffix}`, "CandFixture-Strong1!");
+  other = register(`cand_other_${suffix}`, "CandFixture-Strong1!");
+  expect(owner.ok && member.ok && nodeOwner.ok && other.ok).toBe(true);
+  for (const user of [owner, member, nodeOwner, other]) db.run("UPDATE users SET role='user' WHERE user_id=?1", [user.user.user_id]);
+  db.run("INSERT INTO network_members(network_id,user_id,role) VALUES(?1,?2,'member')", [owner.network_id, member.user.user_id]);
+  db.run("INSERT INTO network_members(network_id,user_id,role) VALUES(?1,?2,'member')", [owner.network_id, nodeOwner.user.user_id]);
+  const candidate = { node_id: ids.hand, alias: "hand-node", workdir: WORKDIR, runtime: "claude-agent-sdk", launch_hint: "tmux", token: SECRET, env: { API_KEY: SECRET } };
+  db.run("INSERT INTO nodes(node_id,node_name,alias,network_id,owner_user_id,hostname,config_snapshot) VALUES(?1,?2,?2,?3,?4,'fixture-host',?5)",
+    [ids.daemon, "cand-daemon", owner.network_id, owner.user.user_id, snapshot([candidate, { node_id: "n_missing", alias: "nope", workdir: "/tmp/nope", launch_hint: "bare" }])]);
+  db.run("INSERT INTO nodes(node_id,node_name,alias,network_id,owner_user_id,hostname,config_snapshot) VALUES(?1,?2,?2,?3,?4,'fixture-host','{}')",
+    [ids.hand, "hand-node", owner.network_id, nodeOwner.user.user_id]);
+  db.run("INSERT INTO nodes(node_id,node_name,alias,network_id,owner_user_id,hostname) VALUES(?1,?2,?2,?3,?4,'other-host')",
+    [ids.foreign, "foreign-node", other.network_id, other.user.user_id]);
+  db.run("INSERT INTO sessions(resume_id,alias,node_id,network_id,status,last_seen_at) VALUES('cand-daemon-session','cand-daemon',?1,?2,'idle',datetime('now'))",
+    [ids.daemon, owner.network_id]);
+  const { generateNetworkToken, hashToken } = await import("./db.js");
+  daemonToken = generateNetworkToken();
+  db.run("INSERT INTO api_tokens(token_id,user_id,network_id,scope,name,token_hash) VALUES('cand-daemon-token',?1,?2,'network','node:cand-daemon',?3)",
+    [owner.user.user_id, owner.network_id, hashToken(daemonToken)]);
+  const { bootServer } = await import("./server.js");
+  hub = bootServer({ port: 0, hostname: "127.0.0.1" });
+  base = `http://127.0.0.1:${hub.port}`;
+}, 30_000);
+afterAll(() => hub?.stop(true));
+
+test("owner and node owner see the candidate; the report token stays out", async () => {
+  for (const token of [owner.token, nodeOwner.token]) {
+    const r = await raw(`/api/adoption-candidates?network_id=${owner.network_id}`, token);
+    expect(r.status).toBe(200);
+    expect(r.body.count).toBe(1);
+    expect(r.body.candidates).toEqual([{
+      node_id: ids.hand, alias: "hand-node", daemon_node_id: ids.daemon, daemon_alias: "cand-daemon",
+      hostname: "fixture-host", workdir: WORKDIR, runtime: "claude-agent-sdk", launch_hint: "tmux",
+    }]);
+    expect(r.text).not.toContain(SECRET);
+    expect(r.text).toContain(WORKDIR);
+  }
+  const supervisors = await raw(`/api/host-supervisors?network_id=${owner.network_id}`);
+  expect(supervisors.body.daemons.find((d: any) => d.daemon_node_id === ids.daemon).adoption_discovery).toBe(true);
+  expect(supervisors.text).not.toContain(WORKDIR);
+  expect(supervisors.text).not.toContain(SECRET);
+  const nodes = await raw(`/api/nodes?network_id=${owner.network_id}`);
+  expect(nodes.text).not.toContain("adoption_candidate");
+  expect(nodes.text).not.toContain(WORKDIR);
+});
+
+test("member, other network, daemon token, and query token do not receive the workdir", async () => {
+  const memberRes = await raw(`/api/adoption-candidates?network_id=${owner.network_id}`, member.token);
+  expect(memberRes.status).toBe(200);
+  expect(memberRes.body.candidates).toEqual([]);
+  expect(memberRes.text).not.toContain(WORKDIR);
+  const otherRes = await raw(`/api/adoption-candidates?network_id=${owner.network_id}`, other.token);
+  expect(otherRes.status).toBe(403);
+  expect(otherRes.text).not.toContain(WORKDIR);
+  expect((await get("/api/adoption-candidates", daemonToken)).status).toBe(403);
+  expect((await get("/api/adoption-candidates", process.env.COMMHUB_AUTH_TOKEN!)).status).toBe(403);
+  const queryOnly = await fetch(base + `/api/adoption-candidates?network_id=${owner.network_id}&token=${encodeURIComponent(owner.token)}`);
+  expect([401, 403]).toContain(queryOnly.status);
+});
+
+test("offline, hostname, alias, binding, and created-node filters drop the hint", async () => {
+  const path = `/api/adoption-candidates?network_id=${owner.network_id}`;
+  db.run("UPDATE sessions SET last_seen_at='2000-01-01 00:00:00' WHERE alias='cand-daemon'");
+  expect((await get(path)).body.candidates).toEqual([]);
+  db.run("UPDATE sessions SET last_seen_at=datetime('now') WHERE alias='cand-daemon'");
+  expect((await get(path)).body.count).toBe(1);
+
+  db.run("UPDATE nodes SET hostname='elsewhere' WHERE node_id=?1", [ids.hand]);
+  expect((await get(path)).body.candidates).toEqual([]);
+  db.run("UPDATE nodes SET hostname='fixture-host' WHERE node_id=?1", [ids.hand]);
+
+  db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id=?2", [snapshot([{ node_id: ids.hand, alias: "other-name", workdir: WORKDIR, launch_hint: "stopped" }]), ids.daemon]);
+  expect((await get(path)).body.candidates).toEqual([]);
+  db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id=?2", [snapshot([{ node_id: ids.hand, alias: "hand-node", workdir: WORKDIR, runtime: "claude-agent-sdk", launch_hint: "tmux", token: SECRET }]), ids.daemon]);
+  expect((await get(path)).body.count).toBe(1);
+
+  db.run(`INSERT INTO node_daemon_bindings(request_id,network_id,node_id,daemon_node_id,workdir,requested_by,status,created_at,updated_at)
+    VALUES('adopt_cand_pending',?1,?2,?3,?4,?5,'pending',1,1)`, [owner.network_id, ids.hand, ids.daemon, WORKDIR, owner.user.user_id]);
+  expect((await get(path)).body.candidates).toEqual([]);
+  db.run("UPDATE node_daemon_bindings SET status='revoked' WHERE request_id='adopt_cand_pending'");
+  expect((await get(path)).body.count).toBe(1);
+
+  db.run(`INSERT INTO node_create_requests(request_id,daemon_node_id,child_node_id,child_name,network_id,runtime,flags_json,env_keys,status,created_at,created_by_token)
+    VALUES('cr_cand_hand',?1,?2,'hand-node',?3,'claude-agent-sdk','{}','[]','succeeded',1,'private')`, [ids.daemon, ids.hand, owner.network_id]);
+  expect((await get(path)).body.candidates).toEqual([]);
+  db.run("DELETE FROM node_create_requests WHERE request_id='cr_cand_hand'");
+  expect((await get(path)).body.count).toBe(1);
+});
+
+test("discovery flag is absent unless the daemon actually reported a list", async () => {
+  const path = `/api/host-supervisors?network_id=${owner.network_id}`;
+  db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id=?2", [JSON.stringify({ role: "host_supervisor", daemon_capabilities: { adopt_capable: true } }), ids.daemon]);
+  expect((await get(path)).body.daemons[0].adoption_discovery).toBeUndefined();
+  expect((await get(path)).body.daemons[0].adopt_capable).toBe(true);
+  db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id=?2", [snapshot([], true), ids.daemon]);
+  expect((await get(path)).body.daemons[0].adoption_discovery).toBe(true);
+  expect((await get(`/api/adoption-candidates?network_id=${owner.network_id}`)).body.candidates).toEqual([]);
+  const limited = await get(path, member.token);
+  expect(limited.body.daemons.find((d: any) => d.daemon_node_id === ids.daemon).adoption_discovery).toBe(true);
+});

package/src/adoption-candidates.ts

@@ -0,0 +1,158 @@
+// Board #654 — project daemon-reported hand-started adoption candidates.
+//
+// The daemon report is a hint, not authority. This module does not adopt,
+// bind, signal, start, or stop. Co-presence / three-stage nodes are not
+// part of the report contract: discovery on the daemon excludes them.
+// `GET /api/nodes` managed/adoption and `/api/node-lifecycle-requests`
+// stay records of requests that already exist; they are not this list.
+import { z } from "zod/v4";
+import { db } from "./db.js";
+import { getUserNetworkRole } from "./auth.js";
+import { parseDbTimestampMs } from "./db-timestamp.js";
+import { addAgentNetworkScope, addHumanNetworkScope, type RestNetworkScope } from "./network-scope.js";
+
+const HINTS = new Set(["bare", "tmux", "stopped", "unverified"]);
+const ONLINE_MS = 5 * 60_000;
+const MAX_PUBLIC = 64;
+
+export interface AdoptionCandidateReport {
+  node_id: string;
+  alias: string;
+  workdir: string;
+  runtime: string | null;
+  launch_hint: "bare" | "tmux" | "stopped" | "unverified";
+}
+
+export function sanitizeAdoptionCandidate(raw: unknown): AdoptionCandidateReport | null {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const row = raw as Record<string, unknown>;
+  const { node_id, alias, workdir, launch_hint } = row;
+  if (typeof node_id !== "string" || node_id.length < 1 || node_id.length > 128 || /[\x00-\x1f\x7f]/.test(node_id)) return null;
+  if (typeof alias !== "string" || alias.length < 1 || alias.length > 128 || /[\x00-\x1f\x7f/\\]/.test(alias)
+      || alias === "." || alias === ".." || alias.startsWith("-")) return null;
+  if (typeof workdir !== "string" || !workdir.startsWith("/") || workdir.length > 1024 || /[\x00-\x1f]/.test(workdir)) return null;
+  if (typeof launch_hint !== "string" || !HINTS.has(launch_hint)) return null;
+  let runtime: string | null = null;
+  if (row.runtime != null) {
+    if (typeof row.runtime !== "string" || row.runtime.length < 1 || row.runtime.length > 64 || !/^[A-Za-z0-9._-]+$/.test(row.runtime)) return null;
+    runtime = row.runtime;
+  }
+  return { node_id, alias, workdir, runtime, launch_hint: launch_hint as AdoptionCandidateReport["launch_hint"] };
+}
+
+const adoptionCandidateItemSchema = z.object({
+  node_id: z.string().min(1).max(128),
+  alias: z.string().min(1).max(128),
+  workdir: z.string().regex(/^\/[^\u0000-\u001f]{0,1023}$/),
+  runtime: z.string().min(1).max(64).nullable().optional(),
+  launch_hint: z.enum(["bare", "tmux", "stopped", "unverified"]),
+}).strip().catch(null);
+
+/** Ingest path for report_status. One bad item becomes null; a bad list never fails the heartbeat.
+ * No transform: tools/list JSON Schema cannot represent one. Readers drop nulls. */
+export const adoptionCandidatesReportSchema = z.array(adoptionCandidateItemSchema).max(32).optional().catch(undefined);
+
+function snapshotValue(snapshot: unknown): Record<string, any> | null {
+  try {
+    const parsed = typeof snapshot === "string" ? JSON.parse(snapshot) : snapshot;
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch { return null; }
+}
+
+export function snapshotReportsAdoptionDiscovery(snapshot: unknown): boolean {
+  const caps = snapshotValue(snapshot)?.daemon_capabilities;
+  return caps?.adopt_capable === true && Array.isArray(caps.adoption_candidates);
+}
+
+function reportedCandidates(snapshot: unknown): AdoptionCandidateReport[] {
+  const raw = snapshotValue(snapshot)?.daemon_capabilities?.adoption_candidates;
+  if (!Array.isArray(raw)) return [];
+  const out: AdoptionCandidateReport[] = [];
+  for (const item of raw) {
+    const clean = sanitizeAdoptionCandidate(item);
+    if (clean) out.push(clean);
+    if (out.length >= 32) break;
+  }
+  return out;
+}
+
+type NodeRow = {
+  node_id: string; alias: string; hostname: string | null; network_id: string;
+  owner_user_id?: string | null; config_snapshot?: string | null; last_seen_at?: string | null;
+};
+
+export function listAdoptionCandidates(
+  scope: RestNetworkScope,
+  viewer: { userId: string; isAdmin: boolean },
+  nowMs = Date.now(),
+): { ok: true; candidates: Array<AdoptionCandidateReport & { daemon_node_id: string; daemon_alias: string; hostname: string }>; count: number } {
+  const daemonParams: any[] = [];
+  let daemonSql = `SELECT n.node_id, n.alias, n.hostname, n.network_id, n.config_snapshot, s.last_seen_at
+    FROM nodes n
+    LEFT JOIN sessions s ON s.alias = n.alias AND (s.network_id = n.network_id OR s.network_id IS NULL)
+    WHERE EXISTS (
+      SELECT 1 FROM api_tokens t
+      WHERE t.network_id = n.network_id AND t.name = 'node:' || n.alias AND t.revoked_at IS NULL
+    )`;
+  daemonSql = addHumanNetworkScope(daemonSql, daemonParams, scope, "n.network_id");
+  const daemonRows = db.all<NodeRow>(daemonSql, ...daemonParams);
+  const daemons = new Map<string, NodeRow>();
+  for (const row of daemonRows) {
+    const prev = daemons.get(row.node_id);
+    if (!prev || parseDbTimestampMs(row.last_seen_at ?? "") > parseDbTimestampMs(prev.last_seen_at ?? "")) daemons.set(row.node_id, row);
+  }
+
+  const nodeParams: any[] = [];
+  let nodeSql = "SELECT n.node_id, n.alias, n.hostname, n.network_id, n.owner_user_id, n.config_snapshot FROM nodes n WHERE 1=1";
+  nodeSql = addAgentNetworkScope(nodeSql, nodeParams, scope, { network: "n.network_id", alias: "n.alias", nodeId: "n.node_id" });
+  const visible = new Map(db.all<NodeRow>(nodeSql, ...nodeParams).map((n) => [n.node_id, n]));
+
+  const managed = new Set<string>();
+  const bindingParams: any[] = [];
+  let bindingSql = `SELECT b.node_id FROM node_daemon_bindings b
+    JOIN nodes n ON n.node_id = b.node_id AND n.network_id = b.network_id
+    WHERE b.status IN ('pending','active')`;
+  bindingSql = addHumanNetworkScope(bindingSql, bindingParams, scope, "b.network_id");
+  for (const row of db.all<{ node_id: string }>(bindingSql, ...bindingParams)) managed.add(row.node_id);
+  const createdParams: any[] = [];
+  let createdSql = `SELECT COALESCE(c.child_node_id, CASE WHEN substr(c.request_id,1,3)='cr_' THEN 'node_' || substr(c.request_id,4) END) AS node_id
+    FROM node_create_requests c WHERE 1=1`;
+  createdSql = addHumanNetworkScope(createdSql, createdParams, scope, "c.network_id");
+  for (const row of db.all<{ node_id: string | null }>(createdSql, ...createdParams)) if (row.node_id) managed.add(row.node_id);
+
+  const roles = new Map<string, string | null>();
+  const maySee = (node: NodeRow) => {
+    if (viewer.isAdmin) return true;
+    if (node.owner_user_id && node.owner_user_id === viewer.userId) return true;
+    if (!roles.has(node.network_id)) roles.set(node.network_id, getUserNetworkRole(viewer.userId, node.network_id));
+    const role = roles.get(node.network_id);
+    return role === "owner" || role === "admin";
+  };
+
+  const candidates: Array<AdoptionCandidateReport & { daemon_node_id: string; daemon_alias: string; hostname: string }> = [];
+  const seen = new Set<string>();
+  for (const daemon of daemons.values()) {
+    const snap = snapshotValue(daemon.config_snapshot);
+    if (snap?.role !== "host_supervisor" || snap.daemon_capabilities?.adopt_capable !== true) continue;
+    if (!daemon.hostname) continue;
+    const seenAt = parseDbTimestampMs(daemon.last_seen_at ?? "");
+    if (!Number.isFinite(seenAt) || nowMs - seenAt > ONLINE_MS) continue;
+    for (const reported of reportedCandidates(daemon.config_snapshot)) {
+      if (candidates.length >= MAX_PUBLIC) break;
+      const node = visible.get(reported.node_id);
+      if (!node || node.network_id !== daemon.network_id || node.alias !== reported.alias) continue;
+      if (!node.hostname || node.hostname !== daemon.hostname) continue;
+      if (snapshotValue(node.config_snapshot)?.role === "host_supervisor") continue;
+      if (managed.has(node.node_id) || !maySee(node)) continue;
+      const key = `${daemon.node_id}\0${node.node_id}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      candidates.push({
+        node_id: node.node_id, alias: node.alias, daemon_node_id: daemon.node_id, daemon_alias: daemon.alias,
+        hostname: daemon.hostname, workdir: reported.workdir, runtime: reported.runtime, launch_hint: reported.launch_hint,
+      });
+    }
+  }
+  candidates.sort((a, b) => a.alias.localeCompare(b.alias) || a.node_id.localeCompare(b.node_id) || a.daemon_node_id.localeCompare(b.daemon_node_id));
+  return { ok: true, candidates, count: candidates.length };
+}

package/src/agent-acl-http.test.ts

@@ -255,7 +255,8 @@ describe("humans: restricted members can still see and DM other humans", () => {
     const r = await get(aliceToken, `/api/networks/${NET}/humans`);
     expect(r.status).toBe(200);
     expect(r.body.humans.map((h: any) => h.user_id).sort()).toEqual([adminId, aliceId, bobId].sort());
-    expect(Object.keys(r.body.humans[0]).sort()).toEqual(["display_name", "last_seen_at", "online", "user_id", "username"]);
+    expect(Object.keys(r.body.humans[0]).sort()).toEqual(["avatar_url", "display_name", "last_seen_at", "online", "user_id", "username"]);
+    expect(r.body.humans.every((h: any) => h.avatar_url === null)).toBe(true);
     // 非成员拿不到。
     const outsider = register(`acl_out_${Date.now()}`, PW);
     expect((await get(outsider.token!, `/api/networks/${NET}/humans`)).status).toBe(403);

package/src/api-host-supervisors-runtime-readiness.test.ts

@@ -104,6 +104,19 @@ describe("#622 sanitizeRuntimeReadiness(读取侧)", () => {
     expect(s.a.network).toBeUndefined();
     expect(s.a.auth).toBe("present");
   });
+  test("generation and accepted stay only on opencode-cli", () => {
+    const s = sanitizeRuntimeReadiness({
+      "opencode-cli": { ...READY, state: "unknown", ok: false, generation: "v2", accepted: false },
+      "claude-code-cli": { ...READY, generation: "v2", accepted: true },
+    })!;
+    expect(s["opencode-cli"].generation).toBe("v2");
+    expect(s["opencode-cli"].accepted).toBe(false);
+    expect(s["claude-code-cli"].generation).toBeUndefined();
+    expect(s["claude-code-cli"].accepted).toBeUndefined();
+    const lone = sanitizeRuntimeReadiness({ "opencode-cli": { ...READY, accepted: true, generation: "nope" } })!;
+    expect(lone["opencode-cli"].generation).toBeUndefined();
+    expect(lone["opencode-cli"].accepted).toBeUndefined();
+  });
 });
 
 let BASE = "";

package/src/auth.ts

@@ -35,6 +35,7 @@ export interface AuthUser {
   user_id: string;
   username: string;
   display_name: string | null;
+  avatar_url?: string | null;
   email: string | null;
   role: string;
 }
@@ -161,7 +162,7 @@ export function register(username: string, password: string, email?: string, dis
 
 export function login(username: string, password: string, client: SessionClientInfo = {}): AuthResult {
   const user = db.get<any>(
-    "SELECT user_id, username, password_hash, display_name, email, role, must_change_password FROM users WHERE username = ?1",
+    "SELECT user_id, username, password_hash, display_name, avatar_url, email, role, must_change_password FROM users WHERE username = ?1",
     username);
 
   if (!user) {
@@ -232,7 +233,7 @@ export function login(username: string, password: string, client: SessionClientI
 
   return {
     ok: true,
-    user: { user_id: user.user_id, username: user.username, display_name: user.display_name, email: user.email, role: user.role },
+    user: { user_id: user.user_id, username: user.username, display_name: user.display_name, avatar_url: user.avatar_url, email: user.email, role: user.role },
     token,
     token_id: tokenId,
     network_id: networkId,
@@ -384,7 +385,7 @@ function lookupToken(token: string): { row: any; rejected?: undefined } | { row?
   const cutoff = idleCutoffOffset();
   const row = db.get<any>(
     `SELECT t.token_id, t.user_id, t.network_id, t.scope, t.name AS token_name,
-            u.username, u.display_name, u.email, u.role,
+            u.username, u.display_name, u.avatar_url, u.email, u.role,
             CASE WHEN t.network_id IS NULL THEN 1
                  WHEN EXISTS (SELECT 1 FROM network_members nm WHERE nm.network_id = t.network_id AND nm.user_id = t.user_id) THEN 1
                  ELSE 0 END AS is_member
@@ -433,7 +434,7 @@ export function resolveToken(token: string): { user: AuthUser; networkId: string
   );
 
   return {
-    user: { user_id: row.user_id, username: row.username, display_name: row.display_name, email: row.email, role: row.role },
+    user: { user_id: row.user_id, username: row.username, display_name: row.display_name, avatar_url: row.avatar_url, email: row.email, role: row.role },
     networkId: row.network_id,
     tokenId: row.token_id || null,
     // tokenName carries the binding identity. For node-scoped ntok_, it's
@@ -702,7 +703,7 @@ export function resetUserPassword(targetUsername: string, callerIsHubAdmin: bool
 
 export function getNetworkMembers(networkId: string) {
   return db.all<any>(
-    `SELECT nm.user_id, nm.role, nm.joined_at, nm.invited_by, u.username, u.display_name,
+    `SELECT nm.user_id, nm.role, nm.joined_at, nm.invited_by, u.username, u.display_name, u.avatar_url,
             CASE WHEN u.role = 'admin' OR nm.role IN ('owner', 'admin') OR nm.agent_access = 'all' THEN 'all' ELSE 'granted' END AS agent_access,
             (SELECT COUNT(*) FROM network_member_agent_grants g WHERE g.network_id = nm.network_id AND g.user_id = nm.user_id) AS agent_grant_count,
             CASE WHEN u.role = 'admin' OR nm.role IN ('owner', 'admin') OR nm.task_access = 'all' THEN 'all' ELSE 'scoped' END AS task_access,
@@ -716,8 +717,8 @@ export function getNetworkMembers(networkId: string) {
 
 /** 网络里的人类成员(给受限成员也能看的通讯录):只有身份字段,不含角色与授权。 */
 export function getNetworkHumans(networkId: string) {
-  return db.all<{ user_id: string; username: string; display_name: string | null }>(
-    `SELECT u.user_id, u.username, u.display_name
+  return db.all<{ user_id: string; username: string; display_name: string | null; avatar_url: string | null }>(
+    `SELECT u.user_id, u.username, u.display_name, u.avatar_url
        FROM network_members nm JOIN users u ON nm.user_id = u.user_id
       WHERE nm.network_id = ?1 ORDER BY COALESCE(NULLIF(u.display_name, ''), u.username), u.user_id`,
     networkId);

package/src/clone-node.test.ts

@@ -0,0 +1,248 @@
+// Hub #938 — clone_node on the same daemon: new token, rename collision,
+// cross-daemon refusal. Handler-level, same shape as stop-delete-node.test.ts.
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { db, hashToken } from "./db.js";
+import { peekPendingEnvBlob, stopBackgroundTimersForTest } from "./create-node.js";
+import { registerTools } from "./tools.js";
+import { sessionContractForRuntime } from "./clone-node.js";
+
+const NET = "net_clone_938";
+const USER = "u_clone_938";
+const DAEMON = "node_clone_daemon_a";
+const DAEMON_B = "node_clone_daemon_b";
+const DAEMON_ALIAS = "clone-daemon-a";
+const DAEMON_B_ALIAS = "clone-daemon-b";
+const DAEMON_TOK = "tok_clone_daemon_a";
+const SOURCE = "node_clone_source";
+const SOURCE_ALIAS = "src-child";
+const SOURCE_TOKEN = "ntok_source_SHOULD_NOT_COPY";
+const OTHER = "node_clone_other";
+const OTHER_ALIAS = "other-child";
+
+interface ToolHandler { (args: any, extra?: any): Promise<{ content: Array<{ type: "text"; text: string }> }>; }
+interface Reply { ok?: boolean; error?: string; [k: string]: unknown; }
+
+function cleanup() {
+  for (const n of [NET]) {
+    try { db.run("DELETE FROM node_create_requests WHERE network_id = ?1", [n]); } catch {}
+    try { db.run("DELETE FROM audit_log WHERE network_id = ?1", [n]); } catch {}
+    try { db.run("DELETE FROM nodes WHERE network_id = ?1", [n]); } catch {}
+    try { db.run("DELETE FROM api_tokens WHERE network_id = ?1", [n]); } catch {}
+    try { db.run("DELETE FROM network_members WHERE network_id = ?1", [n]); } catch {}
+    try { db.run("DELETE FROM networks WHERE network_id = ?1", [n]); } catch {}
+  }
+  try { db.run("DELETE FROM users WHERE user_id = ?1", [USER]); } catch {}
+  stopBackgroundTimersForTest();
+}
+
+beforeEach(cleanup);
+afterAll(cleanup);
+
+function seed() {
+  db.run(
+    `INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?2, 'x', 'user', datetime('now'))`,
+    [USER, USER],
+  );
+  db.run(
+    `INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?2, ?3, datetime('now'))`,
+    [NET, NET, USER],
+  );
+  db.run(
+    `INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'admin', datetime('now'))`,
+    [USER, NET],
+  );
+  const snap = JSON.stringify({
+    role: "member",
+    runtime: "claude-agent-sdk",
+    model: "claude-sonnet",
+    flags: { permissionMode: "acceptEdits", timeout: 60000, apiKey: "sk-do-not-copy" },
+    channels: ["server:commhub", "feishu:bot-secret"],
+  });
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, network_id, runtime, model, channels, config_snapshot, hostname, created_at, updated_at, lifecycle_state)
+     VALUES (?1, ?2, ?3, ?4, 'claude-agent-sdk', 'claude-sonnet', ?5, ?6, 'host-a', datetime('now'), datetime('now'), 'active')`,
+    [SOURCE, SOURCE_ALIAS, SOURCE_ALIAS, NET, JSON.stringify(["server:commhub", "feishu:bot-secret"]), snap],
+  );
+  db.run(
+    `INSERT INTO api_tokens (token_id, user_id, network_id, scope, name, token_hash, role) VALUES (?1, ?2, ?3, 'network', ?4, ?5, 'child')`,
+    ["tok_clone_source", USER, NET, `node:${SOURCE_ALIAS}`, hashToken(SOURCE_TOKEN)],
+  );
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, network_id, config_snapshot, hostname, created_at, updated_at, lifecycle_state)
+     VALUES (?1, ?2, ?2, ?3, ?4, 'host-a', datetime('now'), datetime('now'), 'active')`,
+    [DAEMON, DAEMON_ALIAS, NET, JSON.stringify({ role: "host_supervisor", daemon_capabilities: { can_create_nodes: true, runtimes_supported: ["claude-agent-sdk", "opencode-cli"] } })],
+  );
+  db.run(
+    `INSERT INTO api_tokens (token_id, user_id, network_id, scope, name, token_hash) VALUES (?1, ?2, ?3, 'network', ?4, ?5)`,
+    [DAEMON_TOK, USER, NET, `node:${DAEMON_ALIAS}`, `hash_${DAEMON_TOK}`],
+  );
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, network_id, config_snapshot, hostname, created_at, updated_at, lifecycle_state)
+     VALUES (?1, ?2, ?2, ?3, ?4, 'host-b', datetime('now'), datetime('now'), 'active')`,
+    [DAEMON_B, DAEMON_B_ALIAS, NET, JSON.stringify({ role: "host_supervisor" })],
+  );
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, network_id, config_snapshot, hostname, created_at, updated_at, lifecycle_state)
+     VALUES (?1, ?2, ?2, ?3, '{}', 'host-a', datetime('now'), datetime('now'), 'active')`,
+    [OTHER, OTHER_ALIAS, NET],
+  );
+  db.run(
+    `INSERT INTO node_create_requests(request_id,daemon_node_id,child_name,network_id,runtime,model,flags_json,env_keys,status,created_at,created_by_token,child_node_id)
+     VALUES('cr_clone_source', ?1, ?2, ?3, 'claude-agent-sdk', 'claude-sonnet', ?4, '[]', 'succeeded', 1, 't', ?5)`,
+    [DAEMON, SOURCE_ALIAS, NET, JSON.stringify({ permissionMode: "plan" }), SOURCE],
+  );
+}
+
+function handlers(daemonBound = false): Record<string, ToolHandler> {
+  const server = new McpServer({ name: "test", version: "0" }) as any;
+  const tools: Record<string, ToolHandler> = {};
+  const orig = server.tool.bind(server);
+  server.tool = (name: string, desc: string, schema: any, handler: ToolHandler) => {
+    tools[name] = handler;
+    return orig(name, desc, schema, handler);
+  };
+  registerTools(server, undefined, daemonBound ? NET : null, USER, null, daemonBound, daemonBound ? DAEMON_TOK : null);
+  return tools;
+}
+
+async function call(handler: ToolHandler, args: any): Promise<Reply> {
+  const r = await handler(args);
+  return JSON.parse(r.content[0].text) as Reply;
+}
+
+describe("clone_node — happy path (Hub #938)", () => {
+  test("mints a new token, keeps the source token, records clone directives", async () => {
+    seed();
+    const tools = handlers();
+    const r = await call(tools.clone_node, {
+      source_node_id: SOURCE,
+      name: "cloned-child",
+      network_id: NET,
+    });
+    expect(r.ok).toBe(true);
+    expect(r.daemon_node_id).toBe(DAEMON);
+    expect(r.child_name).toBe("cloned-child");
+    expect(r.copy_session).toBe(true);
+    expect(r.workdir_policy).toBe("new_empty");
+    expect(r.session_contract).toMatchObject({ mode: "transcript_when_present", runtime: "claude-agent-sdk" });
+    const contract = r.contract as { token: string; workdir: string; session: string };
+    expect(contract.token).toContain("new ntok_");
+    expect(contract.workdir).toContain("new empty directory");
+    expect(contract.session).toContain("jsonl");
+
+    const requestId = r.request_id as string;
+    const row = db.get<{ clone_json: string; runtime: string; flags_json: string; child_token_id: string; status: string }>(
+      `SELECT clone_json, runtime, flags_json, child_token_id, status FROM node_create_requests WHERE request_id = ?1`,
+      requestId,
+    );
+    expect(row?.status).toBe("pending");
+    expect(row?.runtime).toBe("claude-agent-sdk");
+    const flags = JSON.parse(row!.flags_json);
+    expect(flags.permissionMode).toBe("acceptEdits");
+    expect(flags.timeout).toBe(60000);
+    expect(JSON.stringify(flags)).not.toContain("sk-do-not-copy");
+    const meta = JSON.parse(row!.clone_json);
+    expect(meta).toMatchObject({
+      source_node_id: SOURCE,
+      source_alias: SOURCE_ALIAS,
+      copy_session: true,
+      workdir_policy: "new_empty",
+      channels: ["server:commhub"],
+    });
+    expect(JSON.stringify(meta.channels)).not.toContain("feishu");
+
+    const blob = peekPendingEnvBlob(requestId);
+    expect(blob?.env_blob).toEqual({});
+    expect(blob?.child_token.startsWith("ntok_")).toBe(true);
+    expect(blob?.child_token).not.toBe(SOURCE_TOKEN);
+    const minted = db.get<{ token_hash: string }>(
+      `SELECT token_hash FROM api_tokens WHERE token_id = ?1`, row!.child_token_id,
+    );
+    expect(minted?.token_hash).toBe(hashToken(blob!.child_token));
+    expect(minted?.token_hash).not.toBe(hashToken(SOURCE_TOKEN));
+    const sourceTok = db.get<{ revoked_at: string | null }>(
+      `SELECT revoked_at FROM api_tokens WHERE token_id = 'tok_clone_source'`,
+    );
+    expect(sourceTok?.revoked_at ?? null).toBeNull();
+
+    const daemonTools = handlers(true);
+    const listed = await call(daemonTools.list_my_pending_create_requests, {});
+    expect(listed.ok).toBe(true);
+    expect(listed.requests).toEqual([]);
+    expect(listed.clone_requests).toEqual([
+      expect.objectContaining({ request_id: requestId, child_name: "cloned-child" }),
+    ]);
+    const refused = await call(daemonTools.get_create_request, { request_id: requestId });
+    expect(refused).toMatchObject({ ok: false, error: "clone_request" });
+    expect(peekPendingEnvBlob(requestId)?.child_token).toBe(blob?.child_token);
+    const pulled = await call(daemonTools.get_create_request, { request_id: requestId, expect_clone: true });
+    expect(pulled.ok).toBe(true);
+    expect(pulled.child_token).toBe(blob?.child_token);
+    expect((pulled.clone as { source_alias: string }).source_alias).toBe(SOURCE_ALIAS);
+    expect(peekPendingEnvBlob(requestId)).toBeNull();
+  });
+});
+
+describe("clone_node — rename collision", () => {
+  test("refuses the source name, an existing alias, and an inflight create name", async () => {
+    seed();
+    db.run(
+      `INSERT INTO node_create_requests(request_id,daemon_node_id,child_name,network_id,runtime,model,flags_json,env_keys,status,created_at,created_by_token)
+       VALUES('cr_clone_inflight', ?1, 'pending-name', ?2, 'claude-agent-sdk', 'm', '{}', '[]', 'pending', ?3, 't')`,
+      [DAEMON, NET, Date.now()],
+    );
+    const tools = handlers();
+    const same = await call(tools.clone_node, { source_node_id: SOURCE, name: SOURCE_ALIAS, network_id: NET });
+    expect(same).toMatchObject({ ok: false, error: "node_name_conflict", reason: "same_as_source" });
+    const taken = await call(tools.clone_node, { source_node_id: SOURCE, name: OTHER_ALIAS, network_id: NET });
+    expect(taken).toMatchObject({ ok: false, error: "node_name_conflict", reason: "alias_taken" });
+    const inflight = await call(tools.clone_node, { source_node_id: SOURCE, name: "pending-name", network_id: NET });
+    expect(inflight).toMatchObject({ ok: false, error: "node_name_conflict", reason: "inflight_create" });
+    const n = db.get<{ n: number }>(
+      `SELECT COUNT(*) AS n FROM node_create_requests WHERE child_name = 'cloned-child'`,
+    );
+    expect(n?.n).toBe(0);
+  });
+});
+
+describe("clone_node — cross-daemon refused", () => {
+  test("a daemon_node_id other than the source's daemon is refused", async () => {
+    seed();
+    const tools = handlers();
+    const r = await call(tools.clone_node, {
+      source_node_id: SOURCE,
+      name: "cloned-child",
+      daemon_node_id: DAEMON_B,
+      network_id: NET,
+    });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("cross_daemon_refused");
+    expect(r.source_daemon_node_id).toBe(DAEMON);
+    expect(r.requested_daemon_node_id).toBe(DAEMON_B);
+    const n = db.get<{ n: number }>(
+      `SELECT COUNT(*) AS n FROM api_tokens WHERE name = 'node:cloned-child'`,
+    );
+    expect(n?.n ?? 0).toBe(0);
+  });
+
+  test("omitting daemon_node_id stays on the source daemon", async () => {
+    seed();
+    const tools = handlers();
+    const r = await call(tools.clone_node, { source_node_id: SOURCE, name: "cloned-child", network_id: NET });
+    expect(r.ok).toBe(true);
+    expect(r.daemon_node_id).toBe(DAEMON);
+  });
+});
+
+describe("session contract is honest per runtime", () => {
+  test("OpenCode is an aliased server session, not a transcript fork", () => {
+    const c = sessionContractForRuntime("opencode-cli");
+    expect(c.mode).toBe("id_aliased");
+    expect(c.detail).toContain("not a private deep copy");
+  });
+
+  test("an unknown runtime does not claim a session copy", () => {
+    expect(sessionContractForRuntime("not-a-runtime").mode).toBe("unsupported");
+  });
+});