@sleep2agi/commhub-server 0.9.0-preview.13 → 0.9.0-preview.130

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

@@ -0,0 +1,267 @@
+// 多用户账号与 Agent 权限 —— slice 3:剩下的面向 Agent 的路径。
+//
+// slice 1(agent-acl-http.test.ts)把默认作用域做成 fail-closed,并对核心路径逐条放行。
+// 这里补:授权后 task_events 跟随授权 Agent 的时间线(#563)、messages 的「只看自己往来」、改名广播不外泄 alias、
+// 排程在建的人被收权后不再代派、用户名与后注册的 Agent alias 撞名、以及
+// rules / skills / files / logs 对受限成员(即使授权了)仍然拒绝 —— 这是一个明确的产品决定:
+// 授权 = 能看见、能对话;不等于能管理这个 Agent。
+
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { register, addNetworkMember } from "./auth.js";
+import { db } from "./db.js";
+import { replaceAgentGrants } from "./agent-access.js";
+import { dispatchScheduledOccurrence } from "./scheduled-tasks.js";
+
+const DIR = mkdtempSync(join(tmpdir(), "anet-agent-acl3-"));
+let BASE = "";
+let hub: any = null;
+const PW = "AclSlice3Passw0rd!";
+let adminToken = "", adminId = "", adminName = "", NET = "";
+let carolToken = "", carolId = "";
+
+const X = { alias: "acl3-agent-x", node: "node_acl3_x" };
+const Z = { alias: "acl3-agent-z", node: "node_acl3_z" };
+const auth = (t: string) => ({ Authorization: `Bearer ${t}` });
+
+async function get(token: string, path: string) {
+  const res = await fetch(`${BASE}${path}`, { headers: auth(token) });
+  return { status: res.status, body: await res.json().catch(() => null) as any };
+}
+async function send(token: string, method: string, path: string, payload?: unknown) {
+  const res = await fetch(`${BASE}${path}`, { method, headers: { ...auth(token), "Content-Type": "application/json" }, body: payload === undefined ? undefined : JSON.stringify(payload) });
+  return { status: res.status, body: await res.json().catch(() => null) as any };
+}
+async function tool(token: string, name: string, args: Record<string, unknown>) {
+  const res = await fetch(`${BASE}/mcp`, {
+    method: "POST",
+    headers: { ...auth(token), "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();
+  const data = raw.split("\n").filter(x => x.startsWith("data:"));
+  const payload = data.length ? JSON.parse(data.at(-1)!.slice(5).trim()) : JSON.parse(raw);
+  const text = payload.result.content[0].text;
+  // 参数没过 zod 的调用根本没进到处理函数(也就没进到权限判定),当成测试写错了而不是「被拒」。
+  if (!text.startsWith("{")) throw new Error(`${name}: ${text}`);
+  return JSON.parse(text);
+}
+function seedAgent(a: { alias: string; node: string }) {
+  db.run(`INSERT INTO nodes (node_id, node_name, alias, network_id, owner_user_id) VALUES (?1, ?2, ?2, ?3, ?4)`, [a.node, a.alias, NET, adminId]);
+  db.run(`INSERT INTO sessions (resume_id, alias, node_id, status, network_id, updated_at, last_seen_at) VALUES (?1, ?2, ?3, 'idle', ?4, datetime('now'), datetime('now'))`, [`r_${a.node}`, a.alias, a.node, NET]);
+}
+function seedTask(id: string, from: string, to: string, content: string) {
+  db.run(`INSERT INTO tasks (task_id, from_name, to_name, status, content, network_id) VALUES (?1, ?2, ?3, 'replied', ?4, ?5)`, [id, from, to, content, NET]);
+  db.run(`INSERT INTO inbox (id, task_id, session_name, type, priority, content, from_session, network_id) VALUES (?1, ?2, ?3, 'task', 'normal', ?4, ?5, ?6)`, [`ib_${id}`, id, to, content, from, NET]);
+  db.run(`INSERT INTO task_events (task_id, to_status, actor, network_id) VALUES (?1, 'replied', 'test', ?2)`, [id, NET]);
+}
+async function openStream(path: string, token: string) {
+  const ctrl = new AbortController();
+  const res = await fetch(`${BASE}${path}`, { headers: auth(token), signal: ctrl.signal });
+  const reader = res.body!.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  let pending: ReturnType<typeof reader.read> | null = null;
+  const readFor = async (ms: number) => {
+    const until = Date.now() + ms;
+    while (Date.now() < until) {
+      pending ??= reader.read();
+      const chunk = await Promise.race([pending, new Promise<null>(r => setTimeout(() => r(null), until - Date.now()))]);
+      if (!chunk) break;
+      pending = null;
+      if (chunk.done) break;
+      buf += decoder.decode(chunk.value);
+    }
+  };
+  return { status: res.status, readFor, events: () => buf.split("\n").filter(l => l.startsWith("data:")).map(l => JSON.parse(l.slice(5))), close: () => ctrl.abort() };
+}
+
+beforeAll(async () => {
+  process.env.COMMHUB_DB ||= join(DIR, "hub.db");
+  process.env.COMMHUB_UPLOADS_DIR = join(DIR, "uploads");
+  process.env.HOST = "127.0.0.1";
+  adminName = `acl3_admin_${Date.now()}`;
+  const admin = register(adminName, PW);
+  adminToken = admin.token!; adminId = admin.user!.user_id; NET = admin.network_id!;
+  db.run("UPDATE users SET role = 'admin' WHERE user_id = ?1", [adminId]);
+  seedAgent(X); seedAgent(Z);
+  const carol = register("acl3_carol", PW);
+  carolToken = carol.token!; carolId = carol.user!.user_id;
+  expect(addNetworkMember(NET, carolId, "member", adminId).ok).toBe(true);
+  expect(replaceAgentGrants({ networkId: NET, userId: carolId, grants: [{ node_id: X.node }], actorUserId: adminId }).ok).toBe(true);
+  seedTask("t3_admin_x", adminName, X.alias, "admin to X");
+  seedTask("t3_carol_x", "acl3_carol", X.alias, "carol to X");
+  seedTask("t3_x_carol", X.alias, "acl3_carol", "X to carol");
+  const mod: any = await import("./server.js");
+  hub = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  BASE = `http://127.0.0.1:${hub.port}`;
+}, 30_000);
+
+afterAll(() => {
+  try { hub?.stop?.(true); } catch {}
+  try { rmSync(DIR, { recursive: true, force: true }); } catch {}
+});
+
+describe("granted member: task_events follow X's timeline (#563); messages stay own traffic", () => {
+  test("task_events: every task on granted X's timeline is visible, including admin's (#563)", async () => {
+    const mine = await get(carolToken, `/api/task_events?task_id=t3_carol_x`);
+    expect(mine.body.events.length).toBe(1);
+    expect((await get(carolToken, `/api/task_events?task_id=t3_x_carol`)).body.events.length).toBe(1);
+    expect((await get(carolToken, `/api/task_events?task_id=t3_admin_x`)).body.events.length).toBe(1);
+    const all = await get(carolToken, `/api/task_events?network_id=${NET}`);
+    expect(all.body.events.map((e: any) => e.task_id).sort()).toEqual(["t3_admin_x", "t3_carol_x", "t3_x_carol"]);
+  });
+  test("messages (alias branch): own inbox rows with X only; admin's never", async () => {
+    const r = await get(carolToken, `/api/messages?network_id=${NET}&since=2000-01-01`);
+    expect(r.body.messages.map((m: any) => m.content).sort()).toEqual(["X to carol", "carol to X"].sort());
+    const x = await get(carolToken, `/api/messages?alias=${X.alias}&since=2000-01-01`);
+    expect(x.body.messages.map((m: any) => m.content)).toEqual(["carol to X"]);
+    expect(x.body.pending_count).toBe(1);
+  });
+});
+
+describe("decision: granted ≠ administer — rules / skills / files / logs / config stay refused", () => {
+  test("every read and write admin op on the GRANTED agent is refused", async () => {
+    for (const [name, args] of [
+      ["read_node_rules_file", { alias: X.alias, network_id: NET }],
+      ["write_node_rules_file", { alias: X.alias, content: "x", network_id: NET }],
+      ["list_node_skills", { alias: X.alias, network_id: NET }],
+      ["list_node_files", { alias: X.alias, network_id: NET }],
+      ["tail_node_logs", { alias: X.alias, network_id: NET }],
+      ["update_node_config", { node_id: X.node, base_revision: 0, patch: { model: "m" }, network_id: NET }],
+      ["restart_node", { node_id: X.node, network_id: NET }],
+    ] as const) {
+      expect((await tool(carolToken, name, args as any)).error).toBe("agent_access_restricted");
+    }
+    expect((await send(carolToken, "PUT", `/api/nodes/${X.node}/attrs?network_id=${NET}`, { display_name: "pwned" })).status).toBeGreaterThanOrEqual(403);
+    expect(db.get<{ display_name: string | null }>("SELECT display_name FROM nodes WHERE node_id = ?1", X.node)?.display_name ?? null).toBeNull();
+  });
+});
+
+describe("rename broadcast does not leak aliases to restricted members", () => {
+  test("renaming Z (not granted) sends nothing to carol; renaming X (granted) does", async () => {
+    const s = await openStream(`/events/acl3_carol?network_id=${NET}`, carolToken);
+    expect(s.status).toBe(200);
+    await s.readFor(100);
+    const renameTo = async (oldAlias: string, newAlias: string) => {
+      const p = await send(adminToken, "POST", "/api/node-rename/prepare", { network_id: NET, old_alias: oldAlias, new_alias: newAlias });
+      expect(p.body.ok).toBe(true);
+      expect((await send(adminToken, "POST", "/api/node-rename/commit", { txn_id: p.body.txn_id })).body.ok).toBe(true);
+    };
+    await renameTo(Z.alias, "acl3-agent-z2");
+    await renameTo(X.alias, "acl3-agent-x2");
+    await s.readFor(400);
+    s.close();
+    const renamed = s.events().filter(e => e.type === "node.renamed").map(e => e.data.new_alias);
+    expect(renamed).toEqual(["acl3-agent-x2"]);
+    // 改名后授权(按 node_id)仍然有效。
+    expect((await get(carolToken, `/api/status?network_id=${NET}`)).body.sessions.map((r: any) => r.alias)).toEqual(["acl3-agent-x2"]);
+    await renameTo("acl3-agent-z2", Z.alias);
+    await renameTo("acl3-agent-x2", X.alias);
+  });
+});
+
+describe("schedules created before a restriction stop dispatching", () => {
+  function schedule(createdBy: string, target: { alias: string; node: string }) {
+    const id = `sched_acl3_${createdBy}_${target.node}`;
+    db.run(
+      `INSERT INTO scheduled_tasks (schedule_id, network_id, created_by, name, target_node_id, target_alias, task_content, schedule_type, schedule_json, next_run_at)
+       VALUES (?1, ?2, ?3, 'n', ?4, ?5, 'scheduled work', 'interval', '{"type":"interval","minutes":60}', datetime('now'))`,
+      [id, NET, createdBy, target.node, target.alias],
+    );
+    return db.get<any>("SELECT * FROM scheduled_tasks WHERE schedule_id = ?1", id);
+  }
+  test("carol (restricted) → Z (not granted): run fails creator_access_revoked, no task created", () => {
+    const row = schedule(carolId, Z);
+    const r = dispatchScheduledOccurrence(row, new Date().toISOString(), false);
+    expect(r.status).toBe("failed");
+    expect(r.taskId).toBeUndefined();
+    expect(db.get<{ error_code: string }>("SELECT error_code FROM scheduled_task_runs WHERE run_id = ?1", r.runId)?.error_code).toBe("creator_access_revoked");
+  });
+  test("carol → X (granted, can_message): dispatches", () => {
+    const r = dispatchScheduledOccurrence(schedule(carolId, X), new Date(Date.now() + 1000).toISOString(), false);
+    expect(r.taskId).toBeTruthy();
+  });
+  test("owner-created schedules are unaffected", () => {
+    const r = dispatchScheduledOccurrence(schedule(adminId, Z), new Date(Date.now() + 2000).toISOString(), false);
+    expect(r.taskId).toBeTruthy();
+  });
+});
+
+describe("username collides with an agent alias registered later", () => {
+  test("carol's own channel and own traffic close for that network", async () => {
+    expect((await get(carolToken, `/api/tasks?network_id=${NET}`)).body.tasks.length).toBeGreaterThan(0);
+    db.run(`INSERT INTO sessions (resume_id, alias, status, network_id, updated_at, last_seen_at) VALUES ('r_collide', 'acl3_carol', 'idle', ?1, datetime('now'), datetime('now'))`, [NET]);
+    const s = await fetch(`${BASE}/events/acl3_carol?network_id=${NET}`, { headers: auth(carolToken) });
+    expect(s.status).toBe(403);
+    await s.body?.cancel();
+    expect((await get(carolToken, `/api/tasks?network_id=${NET}`)).body.tasks).toEqual([]);
+    expect((await get(carolToken, `/api/messages?network_id=${NET}&since=2000-01-01`)).body.messages).toEqual([]);
+    db.run("DELETE FROM sessions WHERE resume_id = 'r_collide'");
+    expect((await get(carolToken, `/api/tasks?network_id=${NET}`)).body.tasks.length).toBeGreaterThan(0);
+  });
+});
+
+describe("human ↔ human DM (/api/dm): restricted members can talk to people", () => {
+  let daveToken = "", daveId = "";
+  test("carol (restricted) DMs dave; dave sees it in thread + threads + user inbox and replies", async () => {
+    const dave = register("acl3_dave", PW);
+    daveToken = dave.token!; daveId = dave.user!.user_id;
+    expect(addNetworkMember(NET, daveId, "member", adminId).ok).toBe(true);
+    const sent = await send(carolToken, "POST", "/api/dm", { network_id: NET, to_user_id: daveId, message: "hi dave", client_request_id: "c1" });
+    expect(sent.status).toBe(200);
+    expect(sent.body.message.sender_user_id).toBe(carolId);
+    // 重试同一个气泡不产生第二条。
+    expect((await send(carolToken, "POST", "/api/dm", { network_id: NET, to_user_id: daveId, message: "hi dave", client_request_id: "c1" })).body.message.message_id).toBe(sent.body.message.message_id);
+    const threads = await get(daveToken, `/api/dm/threads?network_id=${NET}`);
+    expect(threads.body.threads).toEqual([expect.objectContaining({ other_user_id: carolId, unread: 1 })]);
+    expect((await get(daveToken, `/api/messages?scope=user&network_id=${NET}`)).body.messages.map((m: any) => m.content)).toContain("hi dave");
+    expect((await send(daveToken, "POST", "/api/dm", { network_id: NET, to_username: "acl3_carol", message: "hi carol" })).status).toBe(200);
+    const thread = await get(carolToken, `/api/dm?network_id=${NET}&with=${daveId}`);
+    expect(thread.body.messages.map((m: any) => [m.direction, m.content])).toEqual([["in", "hi carol"], ["out", "hi dave"]]);
+    // 私信不进按 Agent 的未读(发信人不是 Agent)。
+    const inbox = await get(daveToken, `/api/messages?scope=user&network_id=${NET}`);
+    expect(inbox.body.unread_by_agent["acl3_carol"]).toBeUndefined();
+    const daveThread = await get(daveToken, `/api/dm?network_id=${NET}&with=${carolId}`);
+    expect(daveThread.body.messages.map((m: any) => m.direction)).toEqual(["out", "in"]);
+  });
+  test("sender identity comes from the token, not from the body", async () => {
+    await send(carolToken, "POST", "/api/dm", { network_id: NET, to_user_id: daveId, message: "who am i", from: adminName, sender_user_id: adminId });
+    const row = db.get<{ sender_user_id: string; from_session: string }>("SELECT sender_user_id, from_session FROM user_inbox WHERE content = 'who am i'");
+    expect(row).toEqual({ sender_user_id: carolId, from_session: "acl3_carol" });
+  });
+  test("a third party cannot read someone else's thread", async () => {
+    const eve = register("acl3_eve", PW);
+    expect(addNetworkMember(NET, eve.user!.user_id, "member", adminId).ok).toBe(true);
+    // eve 查「她和 dave」的会话:空(carol↔dave 的不会出现)。
+    expect((await get(eve.token!, `/api/dm?network_id=${NET}&with=${daveId}`)).body.messages).toEqual([]);
+    expect((await get(eve.token!, `/api/dm/threads?network_id=${NET}`)).body.threads).toEqual([]);
+  });
+  test("non-members and outsiders are refused; unknown and outside users look the same", async () => {
+    const out = register("acl3_out", PW);
+    expect((await send(out.token!, "POST", "/api/dm", { network_id: NET, to_user_id: daveId, message: "x" })).status).toBe(403);
+    expect((await get(out.token!, `/api/dm/threads?network_id=${NET}`)).status).toBe(403);
+    const a = await send(carolToken, "POST", "/api/dm", { network_id: NET, to_user_id: out.user!.user_id, message: "x" });
+    const b = await send(carolToken, "POST", "/api/dm", { network_id: NET, to_user_id: "u_nobody", message: "x" });
+    expect(a).toEqual(b);
+    expect(a.status).toBe(404);
+  });
+  test("a restricted member cannot smuggle a file they cannot see into a DM", async () => {
+    const form = new FormData();
+    form.append("file", new Blob([new Uint8Array([1, 2, 3])]), "a.bin");
+    const up = await fetch(`${BASE}/api/upload?network_id=${NET}`, { method: "POST", body: form, headers: auth(adminToken) });
+    const fid = (await up.json()).file_id;
+    const r = await send(carolToken, "POST", "/api/dm", { network_id: NET, to_user_id: daveId, message: "f", attachments: [{ type: "file", file_id: fid }] });
+    expect(r.status).toBe(403);
+    expect(r.body.error).toBe("attachment_not_accessible");
+    // 管理员(不受限)可以附带本网络文件发给 carol;carol 因此能下载它。
+    expect((await send(adminToken, "POST", "/api/dm", { network_id: NET, to_user_id: carolId, message: "file for you", attachments: [{ type: "file", file_id: fid }] })).status).toBe(200);
+    expect((await fetch(`${BASE}/api/files/${fid}`, { headers: auth(carolToken) })).status).toBe(200);
+  });
+  test("node tokens cannot use the DM API", async () => {
+    const r = await fetch(`${BASE}/api/dm/threads?network_id=${NET}`, { headers: { Authorization: "Bearer ntok_x" } });
+    expect(r.status).toBeGreaterThanOrEqual(401);
+  });
+});

package/src/agent-groups-perf.test.ts

@@ -0,0 +1,223 @@
+// Agent 分组的性能守卫(RFC-038 §8):visibleAgents() 每个请求多做一次「组授权 → 组成员」展开,
+// 这里量它的额外开销,并用 EXPLAIN QUERY PLAN 钉住展开查询走索引(不是全表扫)。
+//
+// 场景:NET 里 300 个节点;50 个组,每组 6 个节点(合起来覆盖全部 300 个)。
+//   baseline —— bob 直接授权这 300 个节点(没有组);
+//   groups   —— alice 授权这 50 个组(没有直接授权),可见集合与 bob 完全相同。
+// 两人看到的 Agent 一样多,差值就是「按组展开」本身的代价。团队要求 ≈2 ms 以内(本机实测 −0.5~+1.9 ms);
+// 断言放宽到 max(5 ms, 基线的 15%)—— CI 容器比本机慢时两边一起变慢,绝对差也跟着放大。数字打印出来。
+// #517:差值怎么量见 lowDelta*() —— 交替且每轮翻转先后、样本 40 对、比两边的 p20(不是每轮差值的中位数)、
+// 一轮超标再重量最多 2 轮。界限本身(max(5 ms, 15%))没动。
+
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { register } from "./auth.js";
+import { db } from "./db.js";
+import { visibleAgents } from "./agent-access.js";
+
+const DIR = mkdtempSync(join(tmpdir(), "anet-agent-groups-perf-"));
+let BASE = "";
+let hub: any = null;
+const PW = "GroupPerfPassw0rd!x";
+let NET = "";
+let adminToken = "";
+let adminId = "";
+let alice = { token: "", id: "" };
+let bob = { token: "", id: "" };
+const NODES = 300;
+const GROUPS = 50;
+const PER_GROUP = NODES / GROUPS;
+const BOUND_MS = 5;
+const bound = (base: number) => Math.max(BOUND_MS, base * 0.15);
+// CI 容器里一次 visibleAgents() 约 65 ms(本机约 28 ms):原来 40 次 × 两边再加预热,顶破了 bun 默认的 5 s 单测超时(#2131 CI 实测)。
+// 性能用例另给显式超时(差值守卫最坏 3 轮 × 40 对,见 lowDelta)。
+const WARMUP = 3;
+const PERF_TIMEOUT_MS = 60_000;
+// #517 差值守卫:每轮 DELTA_PAIRS 对、比两边的 LOW_P 分位、超标再量最多 RETRIES 轮。
+const DELTA_PAIRS = 40, LOW_P = 0.2, RETRIES = 2;
+
+const json = (token: string) => ({ Authorization: `Bearer ${token}`, "Content-Type": "application/json" });
+async function send(token: string, method: string, path: string, payload?: unknown) {
+  const res = await fetch(`${BASE}${path}`, { method, headers: json(token), body: payload === undefined ? undefined : JSON.stringify(payload) });
+  return { status: res.status, body: await res.json().catch(() => null) as any };
+}
+const median = (xs: number[]) => { const s = [...xs].sort((a, b) => a - b); return s[Math.floor(s.length / 2)]; };
+/**
+ * 交替计时:每一轮先量 A 再量 B,取「B − A」的中位数(再附上两边各自的中位数给人看)。
+ * 不能 A 连量 N 次再 B 连量 N 次:test638 在同一台机器上并发跑两份 aggregate,负载随时间变,
+ * 两段分开量时差值被负载漂移主导(--cpus=1 实测差出 26–33 ms,真实差值 < 1 ms)。
+ */
+function pairedDelta(a: () => void, b: () => void, n: number): { a: number; b: number; delta: number } {
+  for (let i = 0; i < WARMUP; i++) { a(); b(); }
+  const as: number[] = [], bs: number[] = [], ds: number[] = [];
+  for (let i = 0; i < n; i++) {
+    let t = performance.now(); a(); const ta = performance.now() - t;
+    t = performance.now(); b(); const tb = performance.now() - t;
+    as.push(ta); bs.push(tb); ds.push(tb - ta);
+  }
+  return { a: median(as), b: median(bs), delta: median(ds) };
+}
+const pct = (xs: number[], p: number) => { const s = [...xs].sort((a, b) => a - b); return s[Math.min(s.length - 1, Math.floor(p * s.length))]; };
+type LowDelta = { a: number; b: number; delta: number; aP50: number; bP50: number; ok: boolean };
+/**
+ * #517 —— 「组授权比直接授权多出多少」的稳健量法。旧做法(15 对、每轮固定先 A 后 B、取每轮差值中位数)在 test638
+ * 两份 aggregate 并发时红过(本地 2 核 + 忙循环邻居实测 paired-delta 7.34 ms > 5 ms,同一轮两边中位数差出 10 ms)——
+ * 量的是负载,不是组展开。现在:
+ *   - 每轮翻转先后(偶数轮 A→B,奇数轮 B→A),「第二个总吃前一个的 GC / 调度」这类顺序偏差两边对半分;
+ *   - 每边 DELTA_PAIRS 个样本,比两边各自的 LOW_P 分位:调度噪声只会加时间,低尾最接近真实成本;
+ *   - 一轮超标就整轮重量,最多 RETRIES 次;真回归(组路径每节点多查一次,#2133 那种 N+1)每一轮都超。
+ */
+function lowDelta(a: () => void, b: () => void, bound: (base: number) => number): LowDelta {
+  let r: LowDelta | null = null;
+  for (let attempt = 0; attempt <= RETRIES; attempt++) {
+    for (let i = 0; i < WARMUP; i++) { a(); b(); }
+    const as: number[] = [], bs: number[] = [];
+    for (let i = 0; i < DELTA_PAIRS; i++) {
+      const time = (f: () => void) => { const t = performance.now(); f(); return performance.now() - t; };
+      if (i % 2 === 0) { as.push(time(a)); bs.push(time(b)); } else { bs.push(time(b)); as.push(time(a)); }
+    }
+    const lowA = pct(as, LOW_P), lowB = pct(bs, LOW_P);
+    r = { a: lowA, b: lowB, delta: lowB - lowA, aP50: pct(as, 0.5), bP50: pct(bs, 0.5), ok: lowB - lowA <= bound(lowA) };
+    if (r.ok) return r;
+  }
+  return r!;
+}
+async function lowDeltaAsync(a: () => Promise<void>, b: () => Promise<void>, bound: (base: number) => number, label: string): Promise<LowDelta> {
+  let r: LowDelta | null = null;
+  for (let attempt = 0; attempt <= RETRIES; attempt++) {
+    for (let i = 0; i < WARMUP; i++) { await a(); await b(); }
+    const as: number[] = [], bs: number[] = [];
+    const time = async (f: () => Promise<void>) => { const t = performance.now(); await f(); return performance.now() - t; };
+    for (let i = 0; i < DELTA_PAIRS; i++) {
+      if (i % 2 === 0) { as.push(await time(a)); bs.push(await time(b)); } else { bs.push(await time(b)); as.push(await time(a)); }
+    }
+    const lowA = pct(as, LOW_P), lowB = pct(bs, LOW_P);
+    r = { a: lowA, b: lowB, delta: lowB - lowA, aP50: pct(as, 0.5), bP50: pct(bs, 0.5), ok: lowB - lowA <= bound(lowA) };
+    console.log(`[perf] ${label} pass ${attempt + 1}: p${LOW_P * 100} direct-300=${lowA.toFixed(2)}ms groups-50x6=${lowB.toFixed(2)}ms delta=${r.delta.toFixed(2)}ms bound=${bound(lowA).toFixed(2)}ms (p50 ${r.aP50.toFixed(2)} / ${r.bP50.toFixed(2)}) ${r.ok ? "ok" : "OVER"}`);
+    if (r.ok) return r;
+  }
+  return r!;
+}
+
+beforeAll(async () => {
+  process.env.COMMHUB_DB ||= join(DIR, "hub.db");
+  process.env.COMMHUB_UPLOADS_DIR = join(DIR, "uploads");
+  process.env.HOST = "127.0.0.1";
+  const admin = register(`perf_admin_${Date.now()}`, PW, undefined, "Admin");
+  expect(admin.ok).toBe(true);
+  adminToken = admin.token!;
+  adminId = admin.user!.user_id;
+  NET = admin.network_id!;
+  db.run("UPDATE users SET role = 'admin' WHERE user_id = ?1", [adminId]);
+  db.transaction(() => {
+    for (let i = 0; i < NODES; i++) {
+      const node = `node_perf_${i}`;
+      const alias = `perf-agent-${i}`;
+      db.run(`INSERT INTO nodes (node_id, node_name, alias, network_id, owner_user_id, updated_at) VALUES (?1, ?2, ?2, ?3, ?4, datetime('now'))`, [node, alias, NET, adminId]);
+      db.run(`INSERT INTO sessions (resume_id, alias, node_id, status, network_id, updated_at, last_seen_at) VALUES (?1, ?2, ?3, 'idle', ?4, datetime('now'), datetime('now'))`, [`resume_${node}`, alias, node, NET]);
+    }
+  });
+  const mod: any = await import("./server.js");
+  hub = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  BASE = `http://127.0.0.1:${hub.port}`;
+
+  const mk = async (username: string) => {
+    const r = await send(adminToken, "POST", "/api/admin/users", { username, password: PW, network_id: NET, role: "member" });
+    expect(r.status).toBe(200);
+    const login = await send("", "POST", "/api/auth/login", { username, password: PW });
+    return { token: login.body.token as string, id: login.body.user.user_id as string };
+  };
+  alice = await mk(`perf_alice_${Date.now()}`);
+  bob = await mk(`perf_bob_${Date.now()}`);
+
+  const groupIds: string[] = [];
+  for (let g = 0; g < GROUPS; g++) {
+    const nodeIds = Array.from({ length: PER_GROUP }, (_, k) => `node_perf_${g * PER_GROUP + k}`);
+    const r = await send(adminToken, "POST", `/api/networks/${NET}/agent-groups`, { name: `perf-group-${g}`, node_ids: nodeIds });
+    expect(r.status).toBe(200);
+    groupIds.push(r.body.group.group_id);
+  }
+  expect((await send(adminToken, "PUT", `/api/networks/${NET}/members/${alice.id}/agent-grants`, { group_grants: groupIds })).status).toBe(200);
+  expect((await send(adminToken, "PUT", `/api/networks/${NET}/members/${bob.id}/agent-grants`, { grants: Array.from({ length: NODES }, (_, i) => `node_perf_${i}`) })).status).toBe(200);
+}, 60_000);
+
+afterAll(() => {
+  try { hub?.stop?.(true); } catch {}
+  try { rmSync(DIR, { recursive: true, force: true }); } catch {}
+});
+
+describe("Agent 分组:性能守卫(50 组 × 300 节点)", () => {
+  test("两人可见集合相同(比较才公平)", () => {
+    const a = visibleAgents(alice.id, NET);
+    const b = visibleAgents(bob.id, NET);
+    expect(a.nodeIds.length).toBe(NODES);
+    expect([...a.nodeIds].sort()).toEqual([...b.nodeIds].sort());
+  });
+
+  test(`visibleAgents():组展开的额外开销 ≤ max(${BOUND_MS} ms, 基线 15%)(目标 ≈2 ms)`, () => {
+    const r = lowDelta(() => { visibleAgents(bob.id, NET); }, () => { visibleAgents(alice.id, NET); }, bound);
+    console.log(`[perf] visibleAgents p${LOW_P * 100}: direct-300=${r.a.toFixed(2)}ms groups-50x6=${r.b.toFixed(2)}ms delta=${r.delta.toFixed(2)}ms bound=${bound(r.a).toFixed(2)}ms (p50 ${r.aP50.toFixed(2)} / ${r.bP50.toFixed(2)})`);
+    expect(r.delta).toBeLessThanOrEqual(bound(r.a));
+  }, PERF_TIMEOUT_MS);
+
+  // #2133:visibleAgents() 以前每个授权节点查一次 alias(300 条 ≈ 28–43 ms)。这两条钉住它不再回到 N+1:
+  // 查询条数(直接授权 1 + 组授权 1 + alias 1)是主判据,不受机器负载影响;绝对上限只兜底 ——
+  // 本机实测 ≈2.6–3.7 ms(负载 ~5),15 ms 给 test638 那种 --cpus=1 双份并发留足余量,仍远低于 N+1 的 28 ms。
+  const ABS_MS = 15;
+  test(`visibleAgents() at 300 grants stays under ${ABS_MS} ms (direct and via groups)`, () => {
+    const t = pairedDelta(() => { visibleAgents(bob.id, NET); }, () => { visibleAgents(alice.id, NET); }, 40);
+    console.log(`[perf] visibleAgents absolute: direct-300=${t.a.toFixed(2)}ms groups-50x6=${t.b.toFixed(2)}ms bound=${ABS_MS}ms`);
+    expect(t.a).toBeLessThan(ABS_MS);
+    expect(t.b).toBeLessThan(ABS_MS);
+  });
+
+  test("visibleAgents() makes a fixed number of queries, not one per granted node (#2133)", () => {
+    for (const who of [bob, alice]) {
+      let queries = 0;
+      const all = db.all.bind(db), get = db.get.bind(db);
+      (db as any).all = (...a: any[]) => { queries++; return (all as any)(...a); };
+      (db as any).get = (...a: any[]) => { queries++; return (get as any)(...a); };
+      try { visibleAgents(who.id, NET); } finally { (db as any).all = all; (db as any).get = get; }
+      console.log(`[perf] visibleAgents queries (${who === bob ? "direct-300" : "groups-50x6"}): ${queries}`);
+      expect(queries).toBeLessThanOrEqual(3);
+    }
+  });
+
+  test(`受限成员 GET /api/status:组授权比等量直接授权多出 ≤ max(${BOUND_MS} ms, 基线 15%)`, async () => {
+    const hit = async (token: string) => {
+      const r = await fetch(`${BASE}/api/status?network_id=${NET}`, { headers: json(token) });
+      const body = await r.json() as any;
+      if ((body.sessions ?? []).length !== NODES) throw new Error(`expected ${NODES} sessions, got ${(body.sessions ?? []).length}`);
+    };
+    const r = await lowDeltaAsync(() => hit(bob.token), () => hit(alice.token), bound, "GET /api/status");
+    expect(r.delta).toBeLessThanOrEqual(bound(r.a));
+  }, PERF_TIMEOUT_MS);
+
+  test("EXPLAIN QUERY PLAN:组展开走索引,不全表扫描", () => {
+    const plan = db.all<{ detail: string }>(
+      `EXPLAIN QUERY PLAN
+       SELECT m.node_id, g.can_message
+         FROM network_member_group_grants g
+         JOIN agent_groups ag ON ag.group_id = g.group_id AND ag.network_id = g.network_id
+         JOIN agent_group_members m ON m.group_id = g.group_id
+         JOIN nodes n ON n.node_id = m.node_id AND n.network_id = g.network_id
+        WHERE g.network_id = ?1 AND g.user_id = ?2`,
+      NET, alice.id,
+    ).map((r) => r.detail);
+    console.log(`[perf] plan:\n  ${plan.join("\n  ")}`);
+    // 四张表都是 SEARCH(按主键 / 索引定位),没有一张是 SCAN。
+    expect(plan.length).toBeGreaterThanOrEqual(4);
+    expect(plan.filter((d) => /^SCAN\b/.test(d))).toEqual([]);
+    expect(plan.every((d) => /^SEARCH\b/.test(d) && /(PRIMARY KEY|INDEX)/.test(d))).toBe(true);
+  });
+
+  test("EXPLAIN QUERY PLAN:按组找被授权成员(改组成员时断流用)走 group_id 索引", () => {
+    const plan = db.all<{ detail: string }>(
+      "EXPLAIN QUERY PLAN SELECT user_id FROM network_member_group_grants WHERE group_id = ?1", "x",
+    ).map((r) => r.detail);
+    console.log(`[perf] plan (usersGrantedGroup): ${plan.join(" | ")}`);
+    expect(plan.some((d) => /SEARCH .*idx_group_grants_group/.test(d))).toBe(true);
+  });
+});

package/src/agent-notice.ts

@@ -0,0 +1,48 @@
+// Hub 以某个节点的名义发给一个用户的一条通知(#462 登录失效、#464 定时任务卡住)。
+//
+// 走 user_inbox + /events/users/me 的 desktop_message —— 与 send_desktop_message 同一张表、同一条推送,
+// from_session = 节点别名,所以 App 把它显示在**与该节点的会话**里(主动消息)+ 未读角标 + 通知。不新增渠道。
+// 只发给一个人;他不在本网络了就不发。推送在写库之后:收到推送的 App 立刻回读得到这一行。
+
+import { db, uuidv4 } from "./db.js";
+import { getUserNetworkRole } from "./auth.js";
+import { pushUserEvent } from "./push.js";
+
+export type AgentNotice = {
+  networkId: string;
+  userId: string;
+  /** 节点别名:通知出现在与它的会话里。 */
+  fromAlias: string;
+  kind: string;
+  title: string;
+  text: string;
+  severity?: "info" | "warning" | "error";
+  meta: Record<string, unknown>;
+  /** 消息 id 前缀(`dm_` 开头,与 App 的去重键同一套)。 */
+  idPrefix: string;
+};
+
+/** 返回 message_id;没发(收件人不在本网络)→ null。 */
+export function sendAgentNotice(n: AgentNotice): string | null {
+  if (!getUserNetworkRole(n.userId, n.networkId)) return null;
+  const messageId = `${n.idPrefix}${uuidv4()}`;
+  const severity = n.severity ?? "warning";
+  db.run(
+    `INSERT INTO user_inbox (message_id, network_id, user_id, from_session, kind, title, content, severity, meta_json)
+     VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)
+     ON CONFLICT(message_id) DO NOTHING`,
+    [messageId, n.networkId, n.userId, n.fromAlias, n.kind, n.title, n.text, severity, JSON.stringify(n.meta)],
+  );
+  pushUserEvent(n.networkId, n.userId, {
+    type: "desktop_message",
+    message_id: messageId,
+    kind: n.kind,
+    from: n.fromAlias,
+    title: n.title,
+    message: n.text,
+    severity,
+    created_at: new Date().toISOString(),
+    meta: n.meta,
+  });
+  return messageId;
+}

package/src/agent-team-whoami-http.test.ts

@@ -0,0 +1,98 @@
+import { beforeAll, afterAll, expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+
+process.env.COMMHUB_DB ||= `${mkdtempSync('/tmp/team-whoami-')}/hub.db`;
+let db: any, hub: any, base: string, owner: any, outside: any;
+let selfToken: string, otherToken: string, outsideToken: string, unboundToken: string;
+const SELF = 'node_team_whoami_self', OTHER = 'node_team_whoami_other', FOREIGN = 'node_team_whoami_foreign';
+const TEAM = 'team_whoami_child', ROOT = 'team_whoami_root';
+
+async function rpc(token: string, method = 'tools/call', params: unknown = { name: 'org_whoami', arguments: {} }) {
+  const response = await fetch(`${base}/mcp`, { method: 'POST', headers: {
+    Authorization: `Bearer ${token}`, '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, params }) });
+  expect(response.status).toBe(200);
+  const text = await response.text();
+  const line = text.split('\n').filter(x => x.startsWith('data:')).at(-1);
+  const body = JSON.parse(line ? line.slice(5) : text);
+  expect(body.error).toBeUndefined();
+  return body.result;
+}
+async function who(token = selfToken, args: Record<string, unknown> = {}) {
+  const result = await rpc(token, 'tools/call', { name: 'org_whoami', arguments: args });
+  return JSON.parse(result.content[0].text);
+}
+
+beforeAll(async () => {
+  ({ db } = await import('./db.js'));
+  const { register, createNetworkTokenForNode } = await import('./auth.js');
+  owner = register('team_whoami_owner', 'Fixture-Passw0rd!xyz');
+  outside = register('team_whoami_outside', 'Fixture-Passw0rd!xyz');
+  db.run("UPDATE users SET display_name = 'Team owner' WHERE user_id = ?1", [owner.user.user_id]);
+  const mint = (u: any, alias: string, node?: string) => {
+    const r = createNetworkTokenForNode(u.user.user_id, u.network_id, alias, node);
+    expect(r.error ?? null).toBe(null); return r.token!;
+  };
+  selfToken = mint(owner, 'team-self', SELF);
+  otherToken = mint(owner, 'team-other', OTHER);
+  outsideToken = mint(outside, 'team-self', FOREIGN); // Same alias in a different network.
+  unboundToken = mint(owner, 'team-unregistered');
+  const { bootServer } = await import('./server.js');
+  hub = bootServer({ port: 0, hostname: '127.0.0.1' });
+  base = `http://127.0.0.1:${hub.port}`;
+  for (const [net, id, name, parent] of [
+    [owner.network_id, ROOT, 'Parent', null], [owner.network_id, TEAM, 'My team', ROOT],
+    [outside.network_id, TEAM, 'Foreign team', null],
+  ]) db.run('INSERT INTO network_agent_teams(network_id,team_id,name,parent_id) VALUES(?1,?2,?3,?4)', [net,id,name,parent]);
+  db.run('UPDATE network_agent_teams SET lead_node_id=?1,owner_user_id=?2 WHERE network_id=?3 AND team_id=?4', [SELF,owner.user.user_id,owner.network_id,TEAM]);
+  for (const [net, node] of [[owner.network_id, SELF], [outside.network_id, FOREIGN]]) {
+    db.run('INSERT INTO network_agent_team_members(network_id,node_id,team_id) VALUES(?1,?2,?3)', [net,node,TEAM]);
+  }
+  // Even a stale/corrupt membership must not project a node from another network.
+  db.run('INSERT INTO network_agent_team_members(network_id,node_id,team_id) VALUES(?1,?2,?3)', [owner.network_id,FOREIGN,TEAM]);
+}, 60_000);
+afterAll(() => hub?.stop(true));
+
+test('exact node team, nearest-first ancestors, Agent lead and private human display name', async () => {
+  const r = await who();
+  expect(r.ok).toBe(true); expect(r.source).toBe('node'); expect(r.node_id).toBe(SELF);
+  expect(r.team).toEqual({ id: TEAM, name: 'My team' });
+  expect(r.ancestors).toEqual([{ id: ROOT, name: 'Parent' }]);
+  expect(r.lead.node_id).toBe(SELF);
+  expect(r.owner).toEqual({ user_id: owner.user.user_id, display_name: 'Team owner' });
+  expect(r.agents.map((n: any) => n.node_id)).toEqual([SELF]);
+  expect(r.truncated).toBe(false);
+  expect(JSON.stringify(r)).not.toContain('team_whoami_owner');
+});
+test('same-id foreign team and foreign node cannot cross network; supplied identity is ignored', async () => {
+  const r = await who(selfToken, { network_id: outside.network_id, node_id: FOREIGN, alias: 'team-other' });
+  expect(r.node_id).toBe(SELF); expect(r.team.name).toBe('My team');
+  expect(JSON.stringify(r)).not.toContain(FOREIGN);
+  const b = await who(outsideToken);
+  expect(b.team.name).toBe('Foreign team'); expect(b.node_id).toBe(FOREIGN);
+  expect(b.ancestors).toEqual([]); expect(JSON.stringify(b)).not.toContain(SELF);
+});
+test('unassigned node does not inherit its owner or another node team', async () => {
+  expect(await who(otherToken)).toEqual({ ok: true, source: 'none', node_id: OTHER, team: null,
+    ancestors: [], lead: null, owner: null, agents: [], truncated: false });
+  expect((await who(unboundToken)).error).toBe('node_identity_unbound');
+});
+test('user credentials cannot list or call; node credentials can list', async () => {
+  expect((await rpc(owner.token, 'tools/list', {})).tools.some((t: any) => t.name === 'org_whoami')).toBe(false);
+  expect((await who(owner.token)).error).toBe('network_token_required');
+  expect((await rpc(selfToken, 'tools/list', {})).tools.some((t: any) => t.name === 'org_whoami')).toBe(true);
+});
+test('foreign lead and human owner references are not returned', async () => {
+  db.run('UPDATE network_agent_teams SET lead_node_id=?1,owner_user_id=?2 WHERE network_id=?3 AND team_id=?4', [FOREIGN,outside.user.user_id,owner.network_id,TEAM]);
+  try { const r = await who(); expect(r.lead).toBe(null); expect(r.owner).toBe(null); }
+  finally { db.run('UPDATE network_agent_teams SET lead_node_id=?1,owner_user_id=?2 WHERE network_id=?3 AND team_id=?4', [SELF,owner.user.user_id,owner.network_id,TEAM]); }
+});
+test('large teams are bounded to 50 and explicitly truncated', async () => {
+  for (let i = 0; i < 51; i++) {
+    const id = `node_team_whoami_cap_${i}`;
+    db.run('INSERT INTO nodes(node_id,node_name,alias,network_id) VALUES(?1,?1,?1,?2)', [id,owner.network_id]);
+    db.run('INSERT INTO network_agent_team_members(network_id,node_id,team_id) VALUES(?1,?2,?3)', [owner.network_id,id,TEAM]);
+  }
+  const r = await who(); expect(r.agents.length).toBe(50); expect(r.truncated).toBe(true);
+});