@sleep2agi/commhub-server 0.9.0-preview.71 → 0.9.0-preview.72

package/README.md

@@ -150,7 +150,7 @@ delivered/acked/running → reassign → delivered (new agent)
 
 ## PostgreSQL (community extension point — not on the maintained roadmap)
 
-> **PostgreSQL support is still in development and does not work yet** (PostgreSQL 支持尚在开发中，目前不可用). With `DATABASE_URL=postgres://…` the hub exits while creating its schema. Progress: [RFC-039](https://github.com/sleep2agi/agent-network/blob/main/docs/rfcs/RFC-039-hub-postgresql-backend.md).
+> **PostgreSQL support is still in development and does not work yet** (PostgreSQL 支持尚在开发中，目前不可用). With `DATABASE_URL=postgres://…` the hub builds its schema, but `startHub()` refuses to run on PostgreSQL unless you also set `COMMHUB_PG_EXPERIMENTAL=1` (experimental, for testing only: it switches on the scheduler, task runtime evidence and side-thread commands on PostgreSQL before their PostgreSQL tests exist; RFC-039 S4 removes the flag). Progress: [RFC-039](https://github.com/sleep2agi/agent-network/blob/main/docs/rfcs/RFC-039-hub-postgresql-backend.md).
 
 > v0.8+ product direction is **SQLite only** (see [docs/v3-postgresql-design.md banner](https://github.com/sleep2agi/agent-network/blob/main/docs/v3-postgresql-design.md)). The PostgreSQL adapter interface is preserved as a community extension point — no E2E coverage on the current stable line; **not recommended for mainline production**.
 
@@ -276,7 +276,7 @@ main 上 66 处写的是 `SOURCE_COMMIT`,另有若干写成 `TEST<编号>_SOURCE
 ## Not verified
 
 - `/api/license*` — experimental legacy trial/pro-license endpoints.
-- PostgreSQL backend — in development, does not work yet (hub exits while creating its schema; RFC-039).
+- PostgreSQL backend — in development, does not work yet (the hub refuses to start on it without the experimental opt-in; RFC-039).
 - Telegram / WeChat / Feishu channel endpoints — channel code exists, but only Telegram-oriented agent-node paths are actively exercised.
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.71",
+  "version": "0.9.0-preview.72",
   "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/admin-delete-network-http.test.ts

@@ -174,4 +174,55 @@ describe("DELETE /api/networks/:id — hub admin override for empty foreign netw
     expect(res.status).toBe(200);
     expect(await res.json()).toEqual({ ok: true });
   });
+
+  // #2144 —— Agent 分组(#2131)的三张表。
+  function addGroup(netId: string, tag: string): string {
+    const groupId = `grp-${tag}-${stamp}`;
+    db.run("INSERT INTO agent_groups (group_id, network_id, name) VALUES (?1, ?2, ?3)", [groupId, netId, `g-${tag}`]);
+    db.run("INSERT INTO agent_group_members (group_id, node_id) VALUES (?1, ?2)", [groupId, `node-${tag}-${stamp}`]);
+    db.run("INSERT INTO network_member_group_grants (network_id, user_id, group_id) VALUES (?1, ?2, ?3)", [netId, memberUserId, groupId]);
+    return groupId;
+  }
+  function groupRows(netId: string, groupId: string) {
+    return {
+      agent_groups: rowCount("agent_groups", netId),
+      agent_group_members: db.get<{ cnt: number }>("SELECT COUNT(*) AS cnt FROM agent_group_members WHERE group_id = ?1", groupId)!.cnt,
+      network_member_group_grants: rowCount("network_member_group_grants", netId),
+    };
+  }
+
+  test("#2144 admin is refused with 409 counts.agent_groups when the network has an agent group", async () => {
+    const netId = memberNetwork("grouped");
+    const groupId = addGroup(netId, "admin-blocked");
+    const res = await del(netId, adminToken);
+    const body = await res.json() as any;
+    expect(res.status).toBe(409);
+    expect(body.counts).toEqual({ agent_groups: 1 });
+    expect(db.get("SELECT 1 AS x FROM networks WHERE network_id = ?1", netId)).toBeTruthy();
+    expect(groupRows(netId, groupId)).toEqual({ agent_groups: 1, agent_group_members: 1, network_member_group_grants: 1 });
+  });
+
+  test("#2144 admin delete of an otherwise-empty network cleans orphan group grants", async () => {
+    const netId = memberNetwork("orphan-grant");
+    db.run("INSERT INTO network_member_group_grants (network_id, user_id, group_id) VALUES (?1, ?2, ?3)", [netId, memberUserId, `grp-gone-${stamp}`]);
+    const res = await del(netId, adminToken);
+    const body = await res.json() as any;
+    expect(res.status).toBe(200);
+    expect(body.cleaned.network_member_group_grants).toBe(1);
+    expect(rowCount("network_member_group_grants", netId)).toBe(0);
+  });
+
+  test("#2144 owner delete removes the network's groups, group members and group grants, and leaves other networks' groups", async () => {
+    const netId = memberNetwork("owner-grouped");
+    const groupId = addGroup(netId, "owner");
+    const otherNet = memberNetwork("owner-grouped-other");
+    const otherGroup = addGroup(otherNet, "other");
+
+    const res = await del(netId, memberToken);
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ ok: true });
+    expect(db.get("SELECT 1 AS x FROM networks WHERE network_id = ?1", netId)).toBeFalsy();
+    expect(groupRows(netId, groupId)).toEqual({ agent_groups: 0, agent_group_members: 0, network_member_group_grants: 0 });
+    expect(groupRows(otherNet, otherGroup)).toEqual({ agent_groups: 1, agent_group_members: 1, network_member_group_grants: 1 });
+  });
 });

package/src/agent-access-batch.test.ts

@@ -0,0 +1,210 @@
+// visibleAgents() batched into one query. The old implementation (kept here verbatim as the
+// reference) ran one nodes ∪ sessions lookup per node_id grant — ~300 queries per call for a
+// restricted member with 300 grants, on every restricted /api/status poll. The new one must return
+// IDENTICAL output (same members, same order) on randomized fixtures.
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const dir = mkdtempSync(join(tmpdir(), "anet-agent-access-batch-"));
+process.env.COMMHUB_DB = join(dir, "hub.db");
+
+let db: any;
+let visibleAgents: (userId: string, networkId: string) => any;
+let listAgentGrants: (networkId: string, userId: string) => any[];
+let CHUNK = 0;
+
+function visibleAgentsReference(userId: string, networkId: string) {
+  const aliases = new Set<string>();
+  const nodeIds = new Set<string>();
+  const messageAliases = new Set<string>();
+  const messageNodeIds = new Set<string>();
+  // Group grants (#2131) expanded exactly as agent-access.ts groupGrantNodes() does, appended after
+  // the direct grants — the order the old loop saw them in.
+  const groupNodes = db.all(
+    `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`,
+    networkId, userId,
+  ).map((row: any) => ({ node_id: row.node_id, alias: null, can_message: row.can_message === 1 }));
+  for (const grant of [...listAgentGrants(networkId, userId), ...groupNodes]) {
+    const grantAliases: string[] = [];
+    if (grant.node_id) {
+      nodeIds.add(grant.node_id);
+      if (grant.can_message) messageNodeIds.add(grant.node_id);
+      for (const row of db.all(
+        `SELECT alias FROM nodes WHERE node_id = ?1 AND network_id = ?2
+         UNION SELECT alias FROM sessions WHERE node_id = ?1 AND network_id = ?2`,
+        grant.node_id, networkId,
+      )) {
+        if (row.alias) grantAliases.push(row.alias);
+      }
+    } else if (grant.alias) {
+      grantAliases.push(grant.alias);
+    }
+    for (const alias of grantAliases) {
+      aliases.add(alias);
+      if (grant.can_message) messageAliases.add(alias);
+    }
+  }
+  return { aliases: [...aliases], nodeIds: [...nodeIds], messageAliases: [...messageAliases], messageNodeIds: [...messageNodeIds] };
+}
+
+// Deterministic PRNG so a failure is reproducible from the printed seed.
+function rng(seed: number) {
+  let s = seed >>> 0;
+  return () => { s = (s * 1664525 + 1013904223) >>> 0; return s / 2 ** 32; };
+}
+
+let seq = 0;
+function seedFixture(seed: number, opts: { nodes: number; grants: number; groups?: number }) {
+  const r = rng(seed);
+  const pick = <T,>(xs: T[]) => xs[Math.floor(r() * xs.length)];
+  const tag = `s${seed}_${seq++}`;
+  db.exec("BEGIN");
+  const net = `net_${tag}`, other = `net_${tag}_other`, user = `u_${tag}`;
+  db.run(`INSERT INTO users (user_id, username, password_hash) VALUES (?1, ?1, 'x')`, [user]);
+  const nodeIds: string[] = [];
+  const legacyAliases: string[] = [];
+  for (let i = 0; i < opts.nodes; i++) {
+    const nodeId = `node_${tag}_${i}`;
+    nodeIds.push(nodeId);
+    const alias = `agent-${tag}-${i}`;
+    const shape = r();
+    // nodes row (sometimes missing, sometimes NULL alias)
+    if (shape > 0.1) db.run(`INSERT INTO nodes (node_id, node_name, alias, network_id) VALUES (?1, ?2, ?3, ?4)`, [nodeId, alias, shape > 0.15 ? alias : null, net]);
+    // sessions rows: same alias, a renamed alias (rename window), several, or none
+    const sessions = r() < 0.2 ? 0 : 1 + Math.floor(r() * 3);
+    for (let k = 0; k < sessions; k++) {
+      const sAlias = k === 0 && r() < 0.6 ? alias : `${alias}-renamed-${k}`;
+      db.run(`INSERT INTO sessions (resume_id, alias, node_id, status, network_id) VALUES (?1, ?2, ?3, 'idle', ?4)`, [`r_${tag}_${i}_${k}`, sAlias, nodeId, net]);
+    }
+    // same node_id in another network must never leak in
+    if (r() < 0.3) db.run(`INSERT INTO sessions (resume_id, alias, node_id, status, network_id) VALUES (?1, ?2, ?3, 'idle', ?4)`, [`r_${tag}_${i}_x`, `${alias}-elsewhere`, nodeId, other]);
+  }
+  for (let i = 0; i < Math.ceil(opts.nodes / 5); i++) {
+    const alias = `legacy-${tag}-${i}`;
+    legacyAliases.push(alias);
+    db.run(`INSERT INTO sessions (resume_id, alias, status, network_id) VALUES (?1, ?2, 'idle', ?3)`, [`rl_${tag}_${i}`, alias, net]);
+  }
+  const usedAliases = new Set<string>();
+  // distinct nodes in a shuffled order (the grant table has one row per node per member)
+  const order = nodeIds.map(n => [r(), n] as const).sort((a, b) => a[0] - b[0]).map(([, n]) => n);
+  for (let i = 0; i < opts.grants; i++) {
+    const byNode = r() < 0.8;
+    const can = r() < 0.5 ? 1 : 0;
+    if (byNode) {
+      const nodeId = r() < 0.05 ? `node_${tag}_ghost_${i}` : order.pop();
+      if (!nodeId) continue;
+      db.run(`INSERT INTO network_member_agent_grants (network_id, user_id, node_id, alias, can_message) VALUES (?1, ?2, ?3, NULL, ?4)`, [net, user, nodeId, can]);
+    } else {
+      const alias = pick(legacyAliases);
+      if (usedAliases.has(alias)) continue;
+      usedAliases.add(alias);
+      db.run(`INSERT INTO network_member_agent_grants (network_id, user_id, node_id, alias, can_message) VALUES (?1, ?2, NULL, ?3, ?4)`, [net, user, alias, can]);
+    }
+  }
+  // Groups (#2131): some granted, some not; members include nodes also granted directly (with a
+  // different can_message), ghost nodes with no nodes row, and a node that lives in another network.
+  const groups = opts.groups ?? 0;
+  for (let gi = 0; gi < groups; gi++) {
+    const groupId = `grp_${tag}_${gi}`;
+    const groupNet = r() < 0.1 ? other : net;
+    db.run(`INSERT INTO agent_groups (group_id, network_id, name) VALUES (?1, ?2, ?3)`, [groupId, groupNet, `group ${tag} ${gi}`]);
+    const size = 1 + Math.floor(r() * 8);
+    const members = new Set<string>();
+    for (let k = 0; k < size; k++) members.add(r() < 0.05 ? `node_${tag}_ghostmember_${gi}_${k}` : pick(nodeIds));
+    if (r() < 0.2) {
+      const foreign = `node_${tag}_foreign_${gi}`;
+      db.run(`INSERT INTO nodes (node_id, node_name, alias, network_id) VALUES (?1, ?1, ?2, ?3)`, [foreign, `foreign-${tag}-${gi}`, other]);
+      members.add(foreign);
+    }
+    for (const m of members) db.run(`INSERT INTO agent_group_members (group_id, node_id) VALUES (?1, ?2)`, [groupId, m]);
+    if (r() < 0.7) db.run(`INSERT INTO network_member_group_grants (network_id, user_id, group_id, can_message) VALUES (?1, ?2, ?3, ?4)`, [net, user, groupId, r() < 0.5 ? 1 : 0]);
+  }
+  db.exec("COMMIT");
+  return { net, user };
+}
+
+beforeAll(async () => {
+  ({ db } = await import("./db.js"));
+  ({ visibleAgents, listAgentGrants, VISIBLE_AGENTS_CHUNK: CHUNK } = await import("./agent-access.js") as any);
+});
+
+afterAll(() => {
+  try { rmSync(dir, { recursive: true, force: true }); } catch {}
+});
+
+describe("visibleAgents batched = reference, on randomized fixtures", () => {
+  test("200 random fixtures: identical output (members and order)", () => {
+    for (let seed = 1; seed <= 200; seed++) {
+      const { net, user } = seedFixture(seed, { nodes: 5 + (seed % 40), grants: seed % 7 === 0 ? 0 : 3 + (seed % 50), groups: seed % 3 === 0 ? 0 : 1 + (seed % 12) });
+      const got = visibleAgents(user, net);
+      const want = visibleAgentsReference(user, net);
+      if (JSON.stringify(got) !== JSON.stringify(want)) {
+        throw new Error(`seed ${seed} differs:\nnew ${JSON.stringify(got)}\nold ${JSON.stringify(want)}`);
+      }
+    }
+  }, 120_000);
+
+  test("the fixtures exercise every shape (rename window, NULL alias, ghost node, legacy alias, other network, groups)", () => {
+    const { net, user } = seedFixture(4242, { nodes: 60, grants: 80, groups: 15 });
+    const groupNodes = db.get<{ n: number }>("SELECT COUNT(*) AS n FROM network_member_group_grants WHERE network_id = ?1 AND user_id = ?2", net, user)!.n;
+    expect(groupNodes).toBeGreaterThan(0);
+    const got = visibleAgents(user, net);
+    expect(got.aliases.some((a: string) => a.includes("-renamed-"))).toBe(true);
+    expect(got.aliases.some((a: string) => a.startsWith("legacy-"))).toBe(true);
+    expect(got.aliases.some((a: string) => a.endsWith("-elsewhere"))).toBe(false);
+    expect(got.messageAliases.length).toBeLessThan(got.aliases.length);
+    expect(JSON.stringify(got)).toBe(JSON.stringify(visibleAgentsReference(user, net)));
+  });
+
+  test("groups only (no direct grants): identical output, group nodes visible", () => {
+    const { net, user } = seedFixture(9090, { nodes: 80, grants: 0, groups: 25 });
+    const got = visibleAgents(user, net);
+    expect(got.nodeIds.length).toBeGreaterThan(0);
+    expect(JSON.stringify(got)).toBe(JSON.stringify(visibleAgentsReference(user, net)));
+  });
+
+  test("no grants → all empty; unknown user → all empty", () => {
+    const { net } = seedFixture(7, { nodes: 10, grants: 0 });
+    expect(visibleAgents("nobody", net)).toEqual({ aliases: [], nodeIds: [], messageAliases: [], messageNodeIds: [] });
+  });
+
+  test("query-count guard: a fixed number of queries per call, not one per grant (#2133)", () => {
+    const { net, user } = seedFixture(301, { nodes: 400, grants: 420, groups: 30 });
+    const grants = listAgentGrants(net, user).length;
+    expect(grants).toBeGreaterThanOrEqual(300);
+    const calls = { all: 0, get: 0 };
+    const all = db.all.bind(db), get = db.get.bind(db);
+    db.all = (...a: any[]) => { calls.all++; return all(...a); };
+    db.get = (...a: any[]) => { calls.get++; return get(...a); };
+    try { visibleAgents(user, net); } finally { db.all = all; db.get = get; }
+    // direct grants + group grants + ceil(nodes / chunk) alias reads
+    expect(calls.all + calls.get).toBeLessThanOrEqual(2 + Math.ceil(grants / CHUNK));
+    expect(calls.all + calls.get).toBeLessThanOrEqual(3);
+  }, 60_000);
+
+  test("more granted nodes than one chunk: same output across the chunk boundary", () => {
+    const { net, user } = seedFixture(777, { nodes: CHUNK + 120, grants: CHUNK + 200 });
+    expect(listAgentGrants(net, user).filter((g: any) => g.node_id).length).toBeGreaterThan(CHUNK);
+    expect(JSON.stringify(visibleAgents(user, net))).toBe(JSON.stringify(visibleAgentsReference(user, net)));
+  }, 120_000);
+
+  test("timing at 300 grants (printed; new must be faster)", () => {
+    const { net, user } = seedFixture(300, { nodes: 400, grants: 420 });
+    const grants = listAgentGrants(net, user).length;
+    expect(grants).toBeGreaterThanOrEqual(300);
+    const time = (fn: () => unknown, n = 50) => { fn(); const t0 = performance.now(); for (let i = 0; i < n; i++) fn(); return (performance.now() - t0) / n; };
+    const oldMs = time(() => visibleAgentsReference(user, net));
+    const newMs = time(() => visibleAgents(user, net));
+    console.log(`visibleAgents @ ${grants} grants: old ${oldMs.toFixed(2)} ms/call, new ${newMs.toFixed(2)} ms/call (${(oldMs / newMs).toFixed(1)}x)`);
+    expect(JSON.stringify(visibleAgents(user, net))).toBe(JSON.stringify(visibleAgentsReference(user, net)));
+    expect(newMs).toBeLessThan(oldMs);
+  }, 120_000);
+});

package/src/agent-access.ts

@@ -88,6 +88,9 @@ export function listAgentGrants(networkId: string, userId: string): AgentGrant[]
  * node_id 授权同时带出:nodes 表里这个节点的 alias、sessions 表里同 node_id 的会话 alias
  * (改名后 sessions 先于 nodes 更新的窗口里两者可能不同,两个都算)。都限定在同一网络。
  */
+/** visibleAgents 一次查询里最多放多少个节点 id(绑定参数上限;1000 个授权节点 = 2 次查询)。 */
+export const VISIBLE_AGENTS_CHUNK = 500;
+
 export function visibleAgents(userId: string, networkId: string): VisibleAgents {
   const aliases = new Set<string>();
   const nodeIds = new Set<string>();
@@ -96,20 +99,34 @@ export function visibleAgents(userId: string, networkId: string): VisibleAgents
   // RFC-038 §8:组授权展开成「该组此刻的成员节点」—— 每次现算,组里新加的节点下一次请求就可见。
   // 只并同网络、且 nodes 表里还在的节点;可对话取并集(直接授权或任一组给了就算)。
   const grants: AgentGrant[] = [...listAgentGrants(networkId, userId), ...groupGrantNodes(networkId, userId)];
+  // #2133:所有授权节点的 alias 一次查完(原来每个节点单独查一次 nodes ∪ sessions:300 条授权 ≈ 300 次查询,
+  // 而受限成员的每次 /api/status 轮询都走这里)。结果与原实现逐字一致:授权按上面数组的顺序,
+  // 同一节点内的 alias 按 UNION 的去重升序 —— agent-access-batch.test.ts 在随机夹具上逐字比对。
+  // 分块只为绑定参数个数的上限;同一节点的所有 alias 必在同一块里,顺序不受分块影响。
+  const grantedNodeIds = [...new Set(grants.map((grant) => grant.node_id).filter((id): id is string => !!id))];
+  const aliasesByNode = new Map<string, string[]>();
+  for (let start = 0; start < grantedNodeIds.length; start += VISIBLE_AGENTS_CHUNK) {
+    const chunk = grantedNodeIds.slice(start, start + VISIBLE_AGENTS_CHUNK);
+    const inList = chunk.map((_, i) => `?${i + 2}`).join(", ");
+    for (const row of db.all<{ node_id: string; alias: string | null }>(
+      `SELECT node_id, alias FROM nodes WHERE network_id = ?1 AND node_id IN (${inList})
+       UNION SELECT node_id, alias FROM sessions WHERE network_id = ?1 AND node_id IN (${inList})
+       ORDER BY node_id, alias`,
+      networkId, ...chunk,
+    )) {
+      if (!row.alias) continue;
+      const list = aliasesByNode.get(row.node_id);
+      if (list) list.push(row.alias); else aliasesByNode.set(row.node_id, [row.alias]);
+    }
+  }
   for (const grant of grants) {
-    const grantAliases: string[] = [];
+    let grantAliases: readonly string[] = [];
     if (grant.node_id) {
       nodeIds.add(grant.node_id);
       if (grant.can_message) messageNodeIds.add(grant.node_id);
-      for (const row of db.all<{ alias: string | null }>(
-        `SELECT alias FROM nodes WHERE node_id = ?1 AND network_id = ?2
-         UNION SELECT alias FROM sessions WHERE node_id = ?1 AND network_id = ?2`,
-        grant.node_id, networkId,
-      )) {
-        if (row.alias) grantAliases.push(row.alias);
-      }
+      grantAliases = aliasesByNode.get(grant.node_id) ?? [];
     } else if (grant.alias) {
-      grantAliases.push(grant.alias);
+      grantAliases = [grant.alias];
     }
     for (const alias of grantAliases) {
       aliases.add(alias);

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

@@ -368,6 +368,14 @@ describe("requirements: agent references alice cannot see are hidden and protect
     const r = await get(aliceToken, `/api/requirements?network_id=${NET}&agent_owner=node:${Z.node}`);
     expect(r.body.requirements).toEqual([]);
   });
+  test("q= does not match on a hidden agent's name (no 'who owns this card' probe); admin's q= does", async () => {
+    const zName = db.get<{ name: string }>("SELECT COALESCE(NULLIF(display_name,''), NULLIF(alias,''), node_name) AS name FROM nodes WHERE node_id = ?1", Z.node)!.name;
+    const ids = async (token: string, q: string) => (await get(token, `/api/requirements?network_id=${NET}&q=${encodeURIComponent(q)}`)).body.requirements.map((r: any) => r.id);
+    expect(await ids(aliceToken, zName)).not.toContain(reqId);
+    expect(await ids(adminToken, zName)).toContain(reqId);
+    // 看得见的字段照样能搜到(标题)
+    expect(await ids(aliceToken, "card")).toContain(reqId);
+  });
 });
 
 describe("cannot be abused", () => {

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

@@ -128,6 +128,29 @@ describe("Agent 分组:性能守卫(50 组 × 300 节点)", () => {
     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) });

package/src/auth.ts

@@ -438,12 +438,15 @@ export function deleteNetwork(userId: string, networkId: string): { ok: boolean;
   // Check if any sessions/tasks still reference this network
   const sessions = db.get<{ cnt: number }>("SELECT COUNT(*) as cnt FROM sessions WHERE network_id = ?1", networkId);
   if (sessions && sessions.cnt > 0) return { ok: false, error: `network has ${sessions.cnt} active session(s) — stop them first` };
-  db.run("DELETE FROM networks WHERE network_id = ?1 AND owner_id = ?2", [networkId, userId]);
-  // PR #519 codex catch: leaving membership rows behind made deleted
-  // networks count toward getUserNetworkIds — a stale row could flip a
-  // single-network user to "ambiguous" or auto-resolve writes INTO the
-  // deleted network. Remove memberships with the network.
-  db.run("DELETE FROM network_members WHERE network_id = ?1", [networkId]);
+  db.transaction(() => {
+    db.run("DELETE FROM networks WHERE network_id = ?1 AND owner_id = ?2", [networkId, userId]);
+    // PR #519 codex catch: leaving membership rows behind made deleted
+    // networks count toward getUserNetworkIds — a stale row could flip a
+    // single-network user to "ambiguous" or auto-resolve writes INTO the
+    // deleted network. Remove memberships with the network.
+    db.run("DELETE FROM network_members WHERE network_id = ?1", [networkId]);
+    deleteNetworkAgentGroups(networkId); // #2144
+  });
   return { ok: true };
 }
 
@@ -814,6 +817,8 @@ const NETWORK_CONTENT_CHECKS: Array<[label: string, sql: string]> = [
   ["network_secrets", "SELECT COUNT(*) AS cnt FROM network_secrets WHERE network_id = ?1"],
   ["skillhub_skills", "SELECT COUNT(*) AS cnt FROM skillhub_skills WHERE network_id = ?1"],
   ["side_chats", "SELECT COUNT(*) AS cnt FROM side_chats WHERE network_id = ?1"],
+  // #2144 —— 组是管理员手工建的配置,和 requirements 一样算内容:有组就拒,别替人删掉。
+  ["agent_groups", "SELECT COUNT(*) AS cnt FROM agent_groups WHERE network_id = ?1"],
   ["pending_node_create_requests", "SELECT COUNT(*) AS cnt FROM node_create_requests WHERE network_id = ?1 AND status IN ('pending', 'delivered')"],
   ["pending_node_start_requests", "SELECT COUNT(*) AS cnt FROM node_start_requests WHERE network_id = ?1 AND status IN ('pending', 'delivered')"],
 ];
@@ -864,7 +869,18 @@ export function adminDeleteEmptyNetwork(networkId: string, extraCounts: Record<s
       const changes = db.run(`DELETE FROM ${table} WHERE network_id = ?1`, [networkId]).changes;
       if (changes > 0) cleaned[table] = changes;
     }
+    for (const [table, changes] of Object.entries(deleteNetworkAgentGroups(networkId))) if (changes > 0) cleaned[table] = changes;
     db.run("DELETE FROM networks WHERE network_id = ?1", [networkId]);
     return { ok: true, owner_id: net.owner_id, network_name: net.network_name, cleaned };
   });
 }
+
+// #2144 —— Agent 分组(#2131)的三张表跟着网络一起删。agent_group_members 没有 network_id 列,
+// 只能按该网络的 group_id 删,所以必须在删 agent_groups 之前删它。owner 删网络与管理员删空网络共用。
+export function deleteNetworkAgentGroups(networkId: string): Record<string, number> {
+  return {
+    network_member_group_grants: db.run("DELETE FROM network_member_group_grants WHERE network_id = ?1", [networkId]).changes,
+    agent_group_members: db.run("DELETE FROM agent_group_members WHERE group_id IN (SELECT group_id FROM agent_groups WHERE network_id = ?1)", [networkId]).changes,
+    agent_groups: db.run("DELETE FROM agent_groups WHERE network_id = ?1", [networkId]).changes,
+  };
+}

package/src/db-adapter-guard.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import {
   assertSafeTestDatabaseEnv,
+  redactPgUrl,
   resolveDatabaseTarget,
 } from "./db-adapter";
 
@@ -83,3 +84,65 @@ describe("#435 inherited DATABASE_URL guard", () => {
     }
   });
 });
+
+describe("RFC-039 §9 COMMHUB_TEST_PG_URL (test-only PostgreSQL)", () => {
+  const TEST = { ...BASE_ENV, NODE_ENV: "test" };
+  const ok = (url: string) => expect(resolveDatabaseTarget({ ...TEST, COMMHUB_TEST_PG_URL: url })).toEqual({ kind: "postgres", url });
+  const refused = (url: string, why: RegExp) => {
+    let message = "";
+    try { resolveDatabaseTarget({ ...TEST, COMMHUB_TEST_PG_URL: url }); } catch (e: any) { message = String(e?.message ?? e); }
+    expect(message).toMatch(/REFUSING COMMHUB_TEST_PG_URL/);
+    expect(message).toMatch(why);
+    // Credentials never reach an error message.
+    expect(message).not.toContain("s3cret");
+    expect(message).not.toContain("tester");
+  };
+
+  test("loopback host + anet_*_test database is accepted under NODE_ENV=test", () => {
+    ok("postgres://tester:s3cret@127.0.0.1:5432/anet_sched_test");
+    ok("postgresql://tester:s3cret@localhost/anet_side_thread_test");
+    ok("postgres://tester:s3cret@[::1]:6543/anet_x_test?connect_timeout=2&sslmode=disable");
+  });
+
+  test("ignored outside NODE_ENV=test", () => {
+    expect(resolveDatabaseTarget({ ...BASE_ENV, NODE_ENV: "production", COMMHUB_DB: "/tmp/i.db", COMMHUB_TEST_PG_URL: "postgres://tester:s3cret@127.0.0.1/anet_x_test" }))
+      .toEqual({ kind: "sqlite", path: "/tmp/i.db" });
+  });
+
+  test("inherited DATABASE_URL still refuses even when COMMHUB_TEST_PG_URL is set", () => {
+    expect(() => resolveDatabaseTarget({
+      ...TEST,
+      DATABASE_URL: "postgres://user:pw@prod.example:5432/commhub",
+      COMMHUB_TEST_PG_URL: "postgres://tester:s3cret@127.0.0.1/anet_x_test",
+    })).toThrow(/REFUSING to honor inherited DATABASE_URL/);
+  });
+
+  test("refuses a value that is not a URL or not postgres", () => {
+    refused("not a url", /not a URL/);
+    refused("mysql://tester:s3cret@127.0.0.1/anet_x_test", /scheme/);
+  });
+
+  test("refuses every host that is not literally loopback", () => {
+    for (const host of ["10.0.0.5", "db.internal", "localhost.evil.example", "127.0.0.2", "127.0.0.1,evil.example", "LOCALHOST", "%2Ftmp"]) {
+      refused(`postgres://tester:s3cret@${host}/anet_x_test`, /host must be/);
+    }
+  });
+
+  test("refuses database names outside /^anet_[a-z0-9_]*_test$/", () => {
+    for (const name of ["commhub", "anet_x", "anet_x_test2", "ANET_X_TEST", "anet-x_test", "anet_x_test/extra", ""]) {
+      refused(`postgres://tester:s3cret@127.0.0.1/${name}`, /database name/);
+    }
+  });
+
+  test("refuses connection-steering query parameters", () => {
+    refused("postgres://tester:s3cret@127.0.0.1/anet_x_test?host=db.internal", /"host" is not allowed/);
+    refused("postgres://tester:s3cret@127.0.0.1/anet_x_test?options=-csearch_path%3Dprod", /"options" is not allowed/);
+  });
+
+  test("redactPgUrl drops user and password", () => {
+    const out = redactPgUrl("postgres://tester:s3cret@127.0.0.1:5432/anet_x_test");
+    expect(out).not.toContain("tester");
+    expect(out).not.toContain("s3cret");
+    expect(out).toContain("127.0.0.1:5432/anet_x_test");
+  });
+});

package/src/db-adapter-translate.test.ts

@@ -15,6 +15,12 @@ describe("RFC-039 S2a sqliteToPostgres", () => {
     expect(out).not.toContain("TIMESTAMP");
   });
 
+  test("strftime with milliseconds keeps SQLite's %f shape", () => {
+    expect(sqliteToPostgres("VALUES (strftime('%Y-%m-%d %H:%M:%f', 'now'))")).toBe(
+      "VALUES (to_char(NOW() AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS.MS'))",
+    );
+  });
+
   test("literal offset", () => {
     expect(sqliteToPostgres("x < datetime('now', '+14 days')")).toBe(
       "x < to_char((NOW() + INTERVAL '14 days') AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS')",
@@ -27,6 +33,11 @@ describe("RFC-039 S2a sqliteToPostgres", () => {
     );
   });
 
+  test("INTEGER → BIGINT (epoch-ms columns), identifiers containing integer untouched", () => {
+    expect(sqliteToPostgres("created_at INTEGER NOT NULL, integer_ref TEXT")).toBe("created_at BIGINT NOT NULL, integer_ref TEXT");
+    expect(sqliteToPostgres("CAST(x AS INTEGER)")).toBe("CAST(x AS BIGINT)");
+  });
+
   test("BLOB → BYTEA, identifiers containing blob untouched", () => {
     expect(sqliteToPostgres("iv BLOB NOT NULL, blob_ref TEXT")).toBe("iv BYTEA NOT NULL, blob_ref TEXT");
   });
@@ -34,7 +45,7 @@ describe("RFC-039 S2a sqliteToPostgres", () => {
   test("placeholders and AUTOINCREMENT unchanged in behaviour", () => {
     expect(sqliteToPostgres("SELECT * FROM t WHERE a = ?1 AND b = ?2")).toBe("SELECT * FROM t WHERE a = $1 AND b = $2");
     expect(sqliteToPostgres("a = ? AND b = ?")).toBe("a = $1 AND b = $2");
-    expect(sqliteToPostgres("id INTEGER PRIMARY KEY AUTOINCREMENT")).toBe("id SERIAL PRIMARY KEY");
+    expect(sqliteToPostgres("id INTEGER PRIMARY KEY AUTOINCREMENT")).toBe("id BIGSERIAL PRIMARY KEY");
   });
 });