@sleep2agi/commhub-server 0.9.0-preview.135 → 0.9.0-preview.137

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.135",
-  "description": "CommHub Server \u2014 AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and MCP tools (17 collaboration-core + node/provider ops tools; authoritative list: docs-site/docs/api/mcp-tools.md).",
+  "version": "0.9.0-preview.137",
+  "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",
   "bin": {

package/src/auth-password-change-cli-tokens-http.test.ts

@@ -6,7 +6,7 @@
 //   · 默认(旧 app、dashboard 代理不带字段):撤销全部不绑网络的令牌 —— 客户端自报的 cli 也活不下来;
 //   · keep_cli_tokens=true(anet passwd 默认带):只撤其他 kind='login' 会话,保留的 cli 令牌列在响应里、不含令牌值;
 //   · 当前会话(换发后的新令牌)永远可用,而且沿用当前令牌的种类;
-//   · 节点 / 网络令牌永远不动;
+//   · 节点令牌不动;具名网络令牌默认保留,可显式revoke_network_tokens;
 //   · 启动迁移按 client_label / scope 回填存量令牌的 kind(夹具库,跑两遍幂等)。
 // SQLite 由 test798 自动收进;PostgreSQL 由 tests/test2123-hub-postgres-ladder 的 run_pg_tests_rc 跑同一个文件。
 
@@ -15,7 +15,7 @@ import { mkdtempSync, rmSync } from "fs";
 import { join } from "path";
 import { tmpdir } from "os";
 import { spawnSync } from "child_process";
-import { register, createNetworkTokenForNode, createToken, changePassword } from "./auth.js";
+import { register, createNetworkTokenForNode, createToken, createNetwork, changePassword } from "./auth.js";
 import { db, hashToken } from "./db.js";
 
 const DIR = mkdtempSync(join(tmpdir(), "anet-pwchange-kind-"));
@@ -292,3 +292,132 @@ describe("startup migration backfills api_tokens.kind on a fixture DB", () => {
     expect(Number(db.get<any>("SELECT COUNT(*) AS n FROM api_tokens WHERE token_id = ?1", id("node")).n)).toBe(1);
   }, 120_000);
 });
+
+
+describe("network password opt-in", () => {
+  const id = (token: string) => db.get<any>("SELECT token_id FROM api_tokens WHERE token_hash=?1", hashToken(token)).token_id;
+
+  test("default lists only the caller's active named network tokens across networks, without credentials", async () => {
+    const f = await fleet();
+    const second = createNetwork(f.userId, `pwk-second-${seq}`);
+    expect(second.ok).toBe(true);
+    const extra = createToken(f.userId, "second-network-script", second.network_id);
+    const other = await fleet();
+    const r = await call(f.app, "POST", "/api/auth/password", { old_password: PW, new_password: PW2 });
+    expect(r.status).toBe(200);
+    expect(r.body.revoked_network).toBe(0);
+    expect(r.body.revoked).toBe(5);
+    expect(r.body.kept_network_tokens.map((x: any) => x.token_id).sort()).toEqual([id(f.netToken), id(extra.token!)].sort());
+    for (const row of r.body.kept_network_tokens) {
+      expect(Object.keys(row).sort()).toEqual(["created_at", "last_used_at", "name", "network_id", "token_id"]);
+    }
+    const body = JSON.stringify(r.body);
+    expect(body.includes("token_hash")).toBe(false);
+    for (const t of [f.netToken, extra.token!, f.nodeToken, other.netToken]) expect(body.includes(t)).toBe(false);
+    expect(await works(f.netToken)).toBe(true);
+    expect(await works(extra.token!)).toBe(true);
+    expect(await works(other.netToken)).toBe(true);
+    expect(await works(r.body.token)).toBe(true);
+  });
+
+  test("explicit boolean opt-in revokes only own named network tokens, independently of keep_cli_tokens", async () => {
+    const f = await fleet();
+    const other = await fleet();
+    const second = createNetwork(f.userId, `pwk-revoke-second-${seq}`);
+    const extra = createToken(f.userId, "second-network-script", second.network_id);
+    const r = await call(f.app, "POST", "/api/auth/password", { old_password: PW, new_password: PW2, keep_cli_tokens: true, revoke_network_tokens: true });
+    expect(r.status).toBe(200);
+    expect(r.body.revoked_network).toBe(2);
+    expect(r.body.revoked_login).toBe(2);
+    expect(r.body.revoked_cli).toBe(0);
+    expect(r.body.revoked).toBe(4);
+    expect(r.body.kept_network_tokens).toEqual([]);
+    expect(await works(f.netToken)).toBe(false);
+    expect(await works(extra.token!)).toBe(false);
+    expect(await works(other.netToken)).toBe(true);
+    expect(await works(other.app)).toBe(true);
+    expect(await works(f.nodeToken)).toBe(true);
+    expect(await works(f.apiToken)).toBe(true);
+    expect(await works(r.body.token)).toBe(true);
+    expect(await works(f.app)).toBe(false);
+  });
+
+  for (const value of [false, "true", 1, null, {}]) {
+    test(`non-true option ${JSON.stringify(value)} cannot revoke network tokens`, async () => {
+      const f = await fleet();
+      const r = await call(f.app, "POST", "/api/auth/password", { old_password: PW, new_password: PW2, revoke_network_tokens: value });
+      expect(r.status).toBe(200);
+      expect(r.body.revoked_network).toBe(0);
+      expect(r.body.kept_network_tokens).toHaveLength(1);
+      expect(await works(f.netToken)).toBe(true);
+    });
+  }
+
+  test("scope and binding protect node credentials; inactive rows are neither listed nor counted", async () => {
+    const f = await fleet();
+    const legacy = createNetworkTokenForNode(f.userId, f.net, `legacy-pwk-${seq}`);
+    expect(legacy.ok).toBe(true);
+    const bound = createToken(f.userId, "mislabelled-bound-node", f.net);
+    db.run("UPDATE api_tokens SET bound_node_id=?1 WHERE token_id=?2", ["n-protected717", bound.token_id]);
+    const expired = createToken(f.userId, "expired-script", f.net);
+    db.run("UPDATE api_tokens SET expires_at=datetime('now','-1 day') WHERE token_id=?1", [expired.token_id]);
+    const revoked = createToken(f.userId, "revoked-script", f.net);
+    db.run("UPDATE api_tokens SET revoked_at=datetime('now') WHERE token_id=?1", [revoked.token_id]);
+    const r = await call(f.app, "POST", "/api/auth/password", { old_password: PW, new_password: PW2, revoke_network_tokens: true });
+    expect(r.status).toBe(200);
+    expect(r.body.revoked_network).toBe(1);
+    expect(await works(f.nodeToken)).toBe(true);
+    expect(await works(bound.token!)).toBe(true);
+    for (const t of [bound, expired, revoked, legacy]) expect(db.get("SELECT token_id FROM api_tokens WHERE token_id=?1", t.token_id)).not.toBeNull();
+  });
+
+  test("bad old password or weak new password has no token side effects", async () => {
+    for (const body of [{ old_password: "wrong", new_password: PW2 }, { old_password: PW, new_password: "123" }]) {
+      const f = await fleet();
+      const r = await call(f.app, "POST", "/api/auth/password", { ...body, revoke_network_tokens: true });
+      expect(r.status).toBe(400);
+      for (const t of [f.app, f.netToken, f.apiToken, f.nodeToken]) expect(await works(t)).toBe(true);
+      expect((await call("", "POST", "/api/auth/login", { username: f.user, password: PW })).status).toBe(200);
+    }
+  });
+
+  test("network-scoped and unauthenticated credentials cannot invoke password change", async () => {
+    const f = await fleet();
+    for (const t of [f.netToken, f.nodeToken, ""]) {
+      expect((await call(t, "POST", "/api/auth/password", { old_password: PW, new_password: PW2, revoke_network_tokens: true })).status).toBe(t ? 403 : 401);
+    }
+    expect(await works(f.netToken)).toBe(true);
+    expect(await works(f.app)).toBe(true);
+  });
+
+  test("a failed network revoke rolls back the password and earlier session deletions", async () => {
+    const f = await fleet();
+    const victim = id(f.netToken);
+    const fn = `pw717_failure_${seq}`;
+    const trigger = `pw717_trigger_${seq}`;
+    if (db.dialect === "postgres") db.exec(`CREATE FUNCTION ${fn}() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF OLD.token_id='${victim}' THEN RAISE EXCEPTION 'fixture717_delete_failure'; END IF; RETURN OLD; END; $$; CREATE TRIGGER ${trigger} BEFORE DELETE ON api_tokens FOR EACH ROW EXECUTE FUNCTION ${fn}()`);
+    else db.exec(`CREATE TRIGGER ${trigger} BEFORE DELETE ON api_tokens WHEN OLD.token_id='${victim}' BEGIN SELECT RAISE(ABORT,'fixture717_delete_failure'); END`);
+    try {
+      expect((await call(f.app, "POST", "/api/auth/password", { old_password: PW, new_password: PW2, revoke_network_tokens: true })).status).toBe(400);
+      for (const t of [f.app, f.appB, f.apiToken, f.netToken, f.nodeToken]) expect(await works(t)).toBe(true);
+      expect((await call("", "POST", "/api/auth/login", { username: f.user, password: PW })).status).toBe(200);
+      expect((await call("", "POST", "/api/auth/login", { username: f.user, password: PW2 })).status).toBe(401);
+    } finally {
+      db.exec(db.dialect === "postgres" ? `DROP TRIGGER ${trigger} ON api_tokens; DROP FUNCTION ${fn}()` : `DROP TRIGGER ${trigger}`);
+    }
+  });
+
+  test("direct changePassword keeps its current row and defaults to listing network tokens", async () => {
+    const f = await fleet();
+    const cur = id(f.app);
+    const r = changePassword(f.userId, PW, PW2, cur);
+    expect(r.ok).toBe(true);
+    expect(r.kept_network_tokens).toHaveLength(1);
+    expect(await works(f.app)).toBe(true);
+    const r2 = changePassword(f.userId, PW2, PW, cur, { revokeNetworkTokens: true, keepCliTokens: true });
+    expect(r2.ok).toBe(true);
+    expect(r2.revoked_network).toBe(1);
+    expect(await works(f.app)).toBe(true);
+    expect(await works(f.nodeToken)).toBe(true);
+  });
+});

package/src/auth.ts

@@ -2,7 +2,7 @@
  * V3 Auth module — user registration, login, token management
  */
 import { db, generateId, hashPassword, verifyPassword, hashToken, generateToken, generateUserToken, generateNetworkToken, uuidv4 } from "./db.js"; import { deleteDepartmentsForNetwork, groupTx, removeMemberFromChatGroups } from "./departments.js"; // #419: also ensures network_members.department_id exists (same line on purpose: docs pin auth.ts line numbers)
-import { WEAK_PASSWORDS } from "./password-dict.js";
+import { WEAK_PASSWORDS } from "./password-dict.js"; import { passwordNetworkTokens, type KeptNetworkToken } from "./password-network-tokens.js";
 import { checkNodeTokenClaim, legacyNodeHolder } from "./node-token-ownership.js";
 import { NETWORK_REST_COLUMNS, NETWORK_REST_SELECT, sqlColumns } from "./rest-projections.js";
 import { deleteAgentGrants, isAgentRestricted } from "./agent-access.js"; import { deleteTaskGrantsForMember, newMemberTaskAccess, type TaskAccessMode } from "./task-access.js"; // 一行两个 import:文档钉着 auth.ts 的行号
@@ -330,7 +330,7 @@ export type SessionClientInfo = { label?: unknown; userAgent?: unknown; kind?: u
 // 种类由客户端自报(client_kind / client_label),**只用于展示和「显式保留」那条路**:
 // 改密码默认仍撤销全部不绑网络的令牌(当前这条除外),调用方显式 keep_cli_tokens=true 才保留 'cli'。
 // 所以一个自称 cli 的令牌永远不能靠自报在默认改密码里活下来。
-// 节点 / 网络令牌(network_id 非空)不分类,改密码永远不碰。
+// 节点 / 网络令牌(network_id 非空)不按cli分类;具名网络令牌另有显式撤销选项。
 export type UserTokenKind = "login" | "cli";
 
 /** 登录 / 注册请求签发的令牌算哪一类:客户端显式报 kind='cli',或 client_label 是 anet 自报的「anet <版本> · …」。 */
@@ -642,14 +642,14 @@ export function revokeOtherSessions(userId: string, currentTokenId: string): num
   return db.run(`DELETE FROM api_tokens WHERE user_id = ?1 AND ${SESSION_TOKEN_SQL} AND token_id != ?2`, [userId, currentTokenId]).changes;
 }
 
-export type ChangePasswordResult = { ok: boolean; error?: string; revoked?: number; revoked_login?: number; revoked_cli?: number; kept_cli_tokens?: KeptCliToken[] };
+export type ChangePasswordResult = { ok: boolean; error?: string; revoked?: number; revoked_login?: number; revoked_cli?: number; kept_cli_tokens?: KeptCliToken[]; revoked_network?: number; kept_network_tokens?: KeptNetworkToken[] };
 
 /**
  * 改密码。默认撤销该用户全部不绑网络的令牌(改密码前的行为,旧 app 依赖它)。#711:opts.keepCliTokens=true
  * 时保留 kind='cli' 的(anet 命令行登录、具名脚本令牌),并在 kept_cli_tokens 里列出。当前会话和节点令牌永远保留。
- * revoked = 两类合计(旧字段,兼容旧客户端)。
+ * revokeNetworkTokens=true显式撤销具名网络令牌;默认列出保留清单。revoked含三类合计。
  */
-export function changePassword(userId: string, oldPassword: string, newPassword: string, currentTokenId?: string | null, opts: { keepCliTokens?: boolean } = {}): ChangePasswordResult {
+export function changePassword(userId: string, oldPassword: string, newPassword: string, currentTokenId?: string | null, opts: { keepCliTokens?: boolean; revokeNetworkTokens?: boolean } = {}): ChangePasswordResult {
   const passwordError = validatePasswordStrength(newPassword, "new password");
   if (passwordError) return { ok: false, error: passwordError };
   const user = db.get<any>("SELECT password_hash FROM users WHERE user_id = ?1", userId);
@@ -663,10 +663,14 @@ export function changePassword(userId: string, oldPassword: string, newPassword:
   // password change. If the user changes via `anet passwd`, the bootstrap
   // nudge goes away on next login. SET to 0 explicitly (rather than skip)
   // so a future flag flip can't drift the state.
-  db.run("UPDATE users SET password_hash = ?1, must_change_password = 0, updated_at = datetime('now') WHERE user_id = ?2", [hashPassword(newPassword), userId]);
-  const keep = opts.keepCliTokens === true;
-  const r = revokeTokensAfterPasswordChange(userId, currentTokenId, keep);
-  return { ok: true, revoked: r.login + r.cli, revoked_login: r.login, revoked_cli: r.cli, ...(keep ? { kept_cli_tokens: r.kept } : {}) };
+  const nextHash = hashPassword(newPassword);
+  return db.transaction(() => {
+    db.run("UPDATE users SET password_hash = ?1, must_change_password = 0, updated_at = datetime('now') WHERE user_id = ?2", [nextHash, userId]);
+    const keep = opts.keepCliTokens === true;
+    const r = revokeTokensAfterPasswordChange(userId, currentTokenId, keep);
+    const network = passwordNetworkTokens(userId, currentTokenId, opts.revokeNetworkTokens === true);
+    return { ok: true, revoked: r.login + r.cli + network.revoked, revoked_login: r.login, revoked_cli: r.cli, ...(keep ? { kept_cli_tokens: r.kept } : {}), revoked_network: network.revoked, kept_network_tokens: network.kept };
+  });
 }
 
 /**

package/src/create-node.ts

@@ -237,7 +237,8 @@ export type NodeCallerResolution =
   | { ok: true; kind: "unregistered"; alias: string; networkId: string }
   | { ok: false; reason: "not_a_node_token" | "bound_node_missing" | "ambiguous" | "not_owner" };
 
-type NodeCallerRow = { node_id: string; alias: string; network_id: string; owner_user_id: string | null };
+export type NodeCallerRow = { node_id: string; alias: string; network_id: string; owner_user_id: string | null };
+export type NodeCallerToken = { name: string; network_id: string | null; user_id: string | null; bound_node_id: string | null; node_identity_epoch: number };
 
 // nodes has no unique (network, alias). An unbound token that hits several
 // rows is not rejected outright: the row owned by the token's issuer wins;
@@ -246,18 +247,12 @@ type NodeCallerRow = { node_id: string; alias: string; network_id: string; owner
 function disambiguateUnboundAlias(
   rows: NodeCallerRow[],
   userId: string | null,
-  alias: string,
-  networkId: string,
+  recentNodeId: string | null,
 ): NodeCallerRow | undefined {
   const owned = userId ? rows.filter((row) => row.owner_user_id === userId) : [];
   if (owned.length === 1) return owned[0]; // board679-unbound-dup
   const pool = owned.length > 1 ? owned : rows;
-  const recent = db.get<{ node_id: string | null }>(
-    `SELECT node_id FROM sessions WHERE alias = ?1 AND network_id = ?2 AND node_id IS NOT NULL ORDER BY updated_at DESC LIMIT 1`,
-    alias,
-    networkId,
-  );
-  const hit = recent?.node_id ? pool.filter((row) => row.node_id === recent.node_id) : [];
+  const hit = recentNodeId ? pool.filter((row) => row.node_id === recentNodeId) : [];
   return hit.length === 1 ? hit[0] : undefined;
 }
 
@@ -268,7 +263,7 @@ function disambiguateUnboundAlias(
 // do not get a second exception.
 export function resolveNodeCaller(tokenId: string | null | undefined): NodeCallerResolution {
   if (!tokenId) return { ok: false, reason: "not_a_node_token" };
-  const tokRow = db.get<{ name: string; network_id: string | null; user_id: string | null; bound_node_id: string | null; node_identity_epoch: number }>(
+  const tokRow = db.get<NodeCallerToken>(
     `SELECT name, network_id, user_id, bound_node_id, node_identity_epoch FROM api_tokens WHERE token_id = ?1 AND revoked_at IS NULL`,
     tokenId,
   );
@@ -280,10 +275,26 @@ export function resolveNodeCaller(tokenId: string | null | undefined): NodeCalle
   const rows = tokRow.bound_node_id
     ? db.all<DaemonRow>(`SELECT node_id, alias, network_id, owner_user_id FROM nodes WHERE node_id = ?1 AND network_id = ?2`, tokRow.bound_node_id, tokRow.network_id)
     : db.all<DaemonRow>(`SELECT node_id, alias, network_id, owner_user_id FROM nodes WHERE alias = ?1 AND network_id = ?2`, tokenAlias, tokRow.network_id);
+  const recent = !tokRow.bound_node_id && rows.length > 1
+    ? db.get<{ node_id: string | null }>(
+      `SELECT node_id FROM sessions WHERE alias = ?1 AND network_id = ?2 AND node_id IS NOT NULL ORDER BY updated_at DESC LIMIT 1`,
+      tokenAlias, tokRow.network_id,
+    ) : null;
+  return resolveNodeCallerFromRows(tokRow, rows, recent?.node_id ?? null);
+}
+
+/** Shared identity contract for individual callers and scoped, batched list reads. */
+export function resolveNodeCallerFromRows(
+  tokRow: NodeCallerToken, rows: NodeCallerRow[], recentNodeId: string | null,
+): NodeCallerResolution {
+  if (!tokRow.name?.startsWith("node:") || !tokRow.network_id) {
+    return { ok: false, reason: "not_a_node_token" };
+  }
+  const tokenAlias = tokRow.name.slice(5);
   const nodeRow = rows.length === 1
     ? rows[0]
     : (!tokRow.bound_node_id && rows.length > 1
-      ? disambiguateUnboundAlias(rows, tokRow.user_id, tokenAlias, tokRow.network_id)
+      ? disambiguateUnboundAlias(rows, tokRow.user_id, recentNodeId)
       : undefined);
   // board679-bound-row-missing: a bound token with no row is refused. Do not look up by name.
   if (tokRow.bound_node_id && !nodeRow) return { ok: false, reason: "bound_node_missing" };

package/src/host-supervisor-identity-http.test.ts

@@ -0,0 +1,136 @@
+import { afterAll, beforeAll, beforeEach, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { db } from "./db.js";
+import { register } from "./auth.js";
+import { registerTools } from "./tools.js";
+import { hostSupervisorIdentityRows } from "./host-supervisor-identity.js";
+
+if (!process.env.COMMHUB_DB && !process.env.COMMHUB_TEST_PG_URL) throw Error("explicit fixture DB required");
+let net: string, foreign: string, user: string, token: string, hub: any, base: string;
+let sequence = 0;
+const next = () => `n_lhs1109_${++sequence}`;
+beforeAll(async () => {
+  const auth = register(`lhs1109_${Date.now()}`, "FixturePassword1109!", undefined, "fixture");
+  if (!auth.ok || !auth.token || !auth.user || !auth.network_id) throw Error("fixture registration failed");
+  user = auth.user.user_id; token = auth.token; net = auth.network_id;
+  foreign = `net_foreign_lhs1109_${Date.now()}`;
+  db.run("INSERT INTO networks(network_id,network_name,owner_id) VALUES(?1,'foreign',?2)", [foreign, user]);
+  process.env.HOST = "127.0.0.1";
+  const { bootServer } = await import("./server.js");
+  hub = await bootServer({ port: 0 }); base = `http://127.0.0.1:${hub.port}`;
+}, 30_000);
+beforeEach(() => {
+  db.run("DELETE FROM api_tokens WHERE name LIKE 'node:lhs1109_%'");
+  db.run("DELETE FROM sessions WHERE alias LIKE 'lhs1109_%'");
+  db.run("DELETE FROM nodes WHERE alias LIKE 'lhs1109_%'");
+});
+afterAll(() => hub?.stop(true));
+
+function node(alias: string, network = net, owner: string | null = user) {
+  const id = next();
+  db.run(`INSERT INTO nodes(node_id,node_name,alias,network_id,owner_user_id,config_snapshot)
+    VALUES(?1,?2,?2,?3,?4,'{"role":"host_supervisor"}')`, [id, `lhs1109_${alias}`, network, owner]);
+  return id;
+}
+function credential(id: string, opts: { bound?: string | null; name?: string; issuer?: string; epoch?: number; network?: string; scope?: string; expired?: boolean; revoked?: boolean } = {}) {
+  const n = db.get<any>("SELECT alias, network_id FROM nodes WHERE node_id=?1", id)!;
+  const tid = `tok_lhs1109_${++sequence}`;
+  db.run(`INSERT INTO api_tokens(token_id,token_hash,user_id,network_id,scope,name,bound_node_id,node_identity_epoch,expires_at,revoked_at)
+    VALUES(?1,?2,?3,?4,?5,?6,?7,?8,?9,?10)`, [tid, `hash_${tid}`, opts.issuer ?? user,
+    opts.network ?? n.network_id, opts.scope ?? "network", `node:${opts.name ?? n.alias}`,
+    opts.bound === undefined ? id : opts.bound, opts.epoch ?? 2,
+    opts.expired ? "2000-01-01 00:00:00" : null, opts.revoked ? "2000-01-01 00:00:00" : null]);
+  return tid;
+}
+function heartbeat(id: string, opts: { bound?: string | null; network?: string | null; alias?: string; age?: number } = {}) {
+  const n = db.get<any>("SELECT alias,network_id FROM nodes WHERE node_id=?1", id)!;
+  db.run(`INSERT INTO sessions(resume_id,alias,network_id,node_id,last_seen_at,status,cpu_cores,mem_total_gb,ip)
+    VALUES(?1,?2,?3,?4,?5,'idle',8,16,'10.1.1.1')`, [`s_lhs1109_${++sequence}`, opts.alias ?? n.alias,
+    opts.network === undefined ? n.network_id : opts.network, opts.bound === undefined ? id : opts.bound,
+    new Date(Date.now() - (opts.age ?? 0)).toISOString()]);
+}
+async function list(entry: "MCP" | "REST") {
+  if (entry === "REST") {
+    const r = await fetch(`${base}/api/host-supervisors?network_id=${net}`, { headers: { Authorization: `Bearer ${token}` } });
+    expect(r.status).toBe(200); return (await r.json() as any).daemons as any[];
+  }
+  const server = new McpServer({ name: "fixture", version: "0" }) as any;
+  let handler: any;
+  const original = server.tool.bind(server);
+  server.tool = (name: string, desc: string, schema: any, fn: any) => {
+    if (name === "list_host_supervisors") handler = fn;
+    return original(name, desc, schema, fn);
+  };
+  registerTools(server, undefined, null, user, null, false, null);
+  const result = await handler({ network_id: net });
+  const parsed = JSON.parse(result.content[0].text); expect(parsed.ok).toBe(true); return parsed.daemons as any[];
+}
+for (const entry of ["MCP", "REST"] as const) {
+  test(`${entry}: bound credentials survive stale token names and rotations dedupe`, async () => {
+    const id = node("renamed"); credential(id, { name: "lhs1109_oldname" }); credential(id); heartbeat(id);
+    const rows = await list(entry); expect(rows.length).toBe(1);
+    expect(rows[0]).toMatchObject({ daemon_node_id: id, online: true });
+    expect(JSON.stringify(rows)).not.toContain("hash_");
+  });
+  test(`${entry}: same-name foreign binding and missing bound node cannot authenticate daemon`, async () => {
+    const id = node("victim"), other = node("victim", foreign);
+    credential(id, { bound: other }); credential(id, { bound: "n_lhs1109_missing" }); heartbeat(id);
+    expect(await list(entry)).toEqual([]);
+  });
+  test(`${entry}: legacy owner and epoch-zero ownerless keep compatibility; squatter and new ownerless rejected`, async () => {
+    const good = node("owned"), old = node("old", net, null), squatter = node("squatter"), recent = node("recent", net, null);
+    credential(good, { bound: null }); credential(old, { bound: null, epoch: 0 });
+    credential(squatter, { bound: null, issuer: "u_foreign_fixture" }); credential(recent, { bound: null, epoch: 1 });
+    const ids = (await list(entry)).map(r => r.daemon_node_id).sort(); expect(ids).toEqual([good, old].sort());
+  });
+  test(`${entry}: same-alias sibling heartbeat cannot make stopped daemon online`, async () => {
+    const stopped = node("duplicate"), live = node("duplicate"); credential(stopped); credential(live); heartbeat(live);
+    const rows = await list(entry);
+    expect(rows.find(r => r.daemon_node_id === stopped)).toMatchObject({ online: false, last_seen_at: null });
+    expect(rows.find(r => r.daemon_node_id === live)).toMatchObject({ online: true });
+  });
+  test(`${entry}: null-ID heartbeat requires unique alias in its network`, async () => {
+    const unique = node("unique"), a = node("ambiguous"), b = node("ambiguous");
+    for (const id of [unique,a,b]) credential(id);
+    heartbeat(unique, { bound: null }); heartbeat(a, { bound: null });
+    const rows = await list(entry);
+    expect(rows.find(r => r.daemon_node_id === unique).online).toBe(true);
+    expect(rows.filter(r => r.daemon_node_id !== unique).map(r => r.online)).toEqual([false,false]);
+  });
+  test(`${entry}: null-network legacy heartbeat is accepted only for globally unique aliases`, async () => {
+    const unique = node("globalunique"), shared = node("globalshared"); node("globalshared", foreign);
+    credential(unique); credential(shared);
+    heartbeat(unique, { bound: null, network: null }); heartbeat(shared, { bound: null, network: null });
+    const rows = await list(entry);
+    expect(rows.find(r => r.daemon_node_id === unique).online).toBe(true);
+    expect(rows.find(r => r.daemon_node_id === shared).online).toBe(false);
+  });
+  test(`${entry}: bound heartbeat ignores stale alias but refuses wrong network and stale timestamps`, async () => {
+    const renamed = node("newalias"), wrong = node("wrongnet"), stale = node("stale");
+    for (const id of [renamed,wrong,stale]) credential(id);
+    heartbeat(renamed, { alias: "lhs1109_stalealias" }); heartbeat(wrong, { network: foreign }); heartbeat(stale, { age: 360_000 });
+    const rows = await list(entry);
+    expect(rows.find(r => r.daemon_node_id === renamed).online).toBe(true);
+    expect(rows.filter(r => r.daemon_node_id !== renamed).map(r => r.online)).toEqual([false,false]);
+  });
+  test(`${entry}: unbound duplicate-owner disambiguation uses authoritative recent session`, async () => {
+    const a = node("unboundduplicate"), b = node("unboundduplicate"); credential(a, { bound: null }); heartbeat(b);
+    const rows = await list(entry); expect(rows.length).toBe(1); expect(rows[0]).toMatchObject({ daemon_node_id: b, online: true });
+  });
+  test(`${entry}: deleted, revoked, expired and wrong-scope credentials excluded`, async () => {
+    for (const [label,opts] of [["expired",{ expired:true }],["revoked",{ revoked:true }],["scope",{ scope:"full" }],["deleted",{}]] as const) {
+      const id = node(label), tid = credential(id, opts); heartbeat(id);
+      if (label === "deleted") db.run("DELETE FROM api_tokens WHERE token_id=?1", [tid]);
+    }
+    expect(await list(entry)).toEqual([]);
+  });
+}
+test("batched list performs three reads for many daemons and multiple scoped networks", () => {
+  for (let i=0;i<30;i++) { const id=node(`fleet${i}`, i%2 ? net : foreign); credential(id); heartbeat(id); }
+  const original = db.all.bind(db); let reads=0;
+  db.all = ((sql: string, ...params: any[]) => { reads++; return original(sql, ...params); }) as any;
+  try {
+    const rows = hostSupervisorIdentityRows("SELECT * FROM nodes WHERE network_id=?1 OR network_id=?2", [net,foreign]);
+    expect(rows.length).toBe(30); expect(reads).toBe(3);
+  } finally { db.all = original; }
+});

package/src/host-supervisor-identity.ts

@@ -0,0 +1,92 @@
+import { db } from "./db.js";
+import { resolveNodeCallerFromRows, type NodeCallerRow, type NodeCallerToken } from "./create-node.js";
+import { parseDbTimestampMs } from "./db-timestamp.js";
+
+type NodeRow = NodeCallerRow & Record<string, any>;
+type SessionRow = {
+  node_id: string | null; alias: string; network_id: string | null;
+  last_seen_at: string | null; status: string | null;
+  cpu_cores: number | null; mem_total_gb: number | null; ip: string | null;
+  legacy_alias_count: number;
+};
+const key = (network: string, alias: string) => JSON.stringify([network, alias]);
+const push = <T>(map: Map<string, T[]>, id: string, value: T) => {
+  const list = map.get(id) ?? []; list.push(value); map.set(id, list);
+};
+
+/** The caller supplies a scoped nodes query, never an unchecked network id.
+ * Three SQL reads regardless of fleet size; no token secrets are selected.
+ * All node roles participate in legacy alias disambiguation.
+ */
+export function hostSupervisorIdentityRows(scopedNodesSql: string, params: any[]): NodeRow[] {
+  const nodes = db.all<NodeRow>(scopedNodesSql, ...params);
+  if (!nodes.length) return [];
+  const tokens = db.all<NodeCallerToken>(`
+    SELECT t.name, t.network_id, t.user_id, t.bound_node_id, t.node_identity_epoch
+    FROM api_tokens t
+    WHERE t.network_id IN (SELECT scoped.network_id FROM (${scopedNodesSql}) scoped)
+      AND t.scope='network' AND t.revoked_at IS NULL
+      AND (t.expires_at IS NULL OR t.expires_at > datetime('now'))
+      AND t.name LIKE 'node:%'
+  `, ...params);
+  const sessions = db.all<SessionRow>(`
+    SELECT s.node_id, s.alias, s.network_id, s.last_seen_at, s.status,
+           s.cpu_cores, s.mem_total_gb, s.ip,
+           CASE WHEN s.network_id IS NULL AND s.node_id IS NULL THEN
+             (SELECT COUNT(*) FROM nodes n WHERE n.alias=s.alias)
+           ELSE 0 END AS legacy_alias_count
+    FROM sessions s
+    WHERE s.network_id IN (SELECT scoped.network_id FROM (${scopedNodesSql}) scoped)
+       OR (s.network_id IS NULL AND (
+         s.alias IN (SELECT scoped.alias FROM (${scopedNodesSql}) scoped)
+         OR s.node_id IN (SELECT scoped.node_id FROM (${scopedNodesSql}) scoped)))
+    ORDER BY s.updated_at DESC
+  `, ...params);
+  const byId = new Map(nodes.map(n => [n.node_id, n]));
+  const byAlias = new Map<string, NodeRow[]>();
+  const byGlobalAlias = new Map<string, NodeRow[]>();
+  for (const n of nodes) {
+    push(byAlias, key(n.network_id, n.alias), n);
+    push(byGlobalAlias, n.alias, n);
+  }
+  const recent = new Map<string, string>();
+  for (const s of sessions) {
+    if (!s.network_id || !s.node_id) continue;
+    const id = key(s.network_id, s.alias);
+    if (!recent.has(id)) recent.set(id, s.node_id);
+  }
+  const credentialed = new Set<string>();
+  for (const t of tokens) {
+    if (!t.network_id) continue;
+    const bound = t.bound_node_id ? byId.get(t.bound_node_id) : null;
+    const rows = t.bound_node_id
+      ? (bound?.network_id === t.network_id ? [bound] : [])
+      : byAlias.get(key(t.network_id, t.name.slice(5))) ?? [];
+    const caller = resolveNodeCallerFromRows(t, rows, recent.get(key(t.network_id, t.name.slice(5))) ?? null);
+    if (caller.ok && caller.kind === "node") credentialed.add(caller.nodeId);
+  }
+  const heartbeat = new Map<string, SessionRow>();
+  for (const s of sessions) {
+    let node: NodeRow | undefined;
+    if (s.node_id) {
+      node = byId.get(s.node_id);
+      if (s.network_id !== null && node?.network_id !== s.network_id) continue;
+    } else if (s.network_id) {
+      const matches = byAlias.get(key(s.network_id, s.alias)) ?? [];
+      if (matches.length === 1) node = matches[0];
+    } else if (Number(s.legacy_alias_count) === 1) {
+      node = byGlobalAlias.get(s.alias)?.[0];
+    }
+    if (!node || !s.last_seen_at || !Number.isFinite(parseDbTimestampMs(s.last_seen_at))) continue;
+    const previous = heartbeat.get(node.node_id);
+    if (!previous || parseDbTimestampMs(s.last_seen_at) > parseDbTimestampMs(previous.last_seen_at!)) {
+      heartbeat.set(node.node_id, s);
+    }
+  }
+  return nodes.filter(n => credentialed.has(n.node_id)).map(n => {
+    const s = heartbeat.get(n.node_id);
+    return { ...n, session_last_seen: s?.last_seen_at ?? null, session_status: s?.status ?? null,
+      session_cpu_cores: s?.cpu_cores ?? null, session_mem_total_gb: s?.mem_total_gb ?? null,
+      session_ip: s?.ip ?? null };
+  });
+}

package/src/list-host-supervisors.test.ts

@@ -40,6 +40,7 @@ function cleanup() {
   try { db.run("DELETE FROM users WHERE user_id LIKE 'u_lhs_%'"); } catch {}
 }
 
+// Each case starts empty; plain INSERT keeps these fixtures portable to PostgreSQL.
 beforeEach(cleanup);
 afterAll(cleanup);
 
@@ -52,7 +53,7 @@ function seedUser(user_id: string) {
 }
 function seedNetwork(net_id: string, owner_id = "u_lhs_owner") {
   db.run(
-    `INSERT OR REPLACE INTO networks (network_id, network_name, owner_id, created_at)
+    `INSERT INTO networks (network_id, network_name, owner_id, created_at)
      VALUES (?1, ?2, ?3, datetime('now'))`,
     [net_id, net_id, owner_id],
   );
@@ -81,7 +82,7 @@ function seedDaemon(opts: {
     allowed_secret_keys: opts.secrets ?? [],
   });
   db.run(
-    `INSERT OR REPLACE INTO nodes (
+    `INSERT INTO nodes (
       node_id, node_name, alias, network_id,
       runtimes_supported, allowed_secret_keys,
       config_snapshot, hostname,
@@ -95,14 +96,14 @@ function seedDaemon(opts: {
   if (opts.sessionAgeMs !== undefined) {
     const ts = new Date(Date.now() - opts.sessionAgeMs).toISOString().replace("T", " ").replace(/\..+/, "");
     db.run(
-      `INSERT OR REPLACE INTO sessions (resume_id, alias, network_id, last_seen_at, status, cpu_cores, mem_total_gb, ip)
+      `INSERT INTO sessions (resume_id, alias, network_id, last_seen_at, status, cpu_cores, mem_total_gb, ip)
        VALUES (?1, ?2, ?3, ?4, 'idle', 8, 16, '10.0.0.5')`,
       [`s_${node_id}`, opts.alias, opts.network_id, ts],
     );
   }
   if (opts.mintToken !== false && !opts.tokenDeleted) {
     db.run(
-      `INSERT OR REPLACE INTO api_tokens (token_id, user_id, network_id, scope, name, token_hash, expires_at, revoked_at)
+      `INSERT INTO api_tokens (token_id, user_id, network_id, scope, name, token_hash, expires_at, revoked_at)
        VALUES (?1, ?2, ?3, 'network', ?4, ?5, NULL, ?6)`,
       [`tok_${node_id}`, `u_seed_${node_id}`, opts.network_id, `node:${opts.alias}`,
        `hash_${node_id}`,

package/src/password-network-tokens.ts

@@ -0,0 +1,25 @@
+import { db } from "./db.js";
+
+export type KeptNetworkToken = {
+  token_id: string;
+  name: string;
+  network_id: string;
+  created_at: string;
+  last_used_at: string | null;
+};
+
+/** Only user-created named network tokens. Node credentials have a different scope or binding. */
+export function passwordNetworkTokens(userId: string, currentTokenId: string | null | undefined, revoke: boolean) {
+  const where = `user_id = ?1 AND network_id IS NOT NULL AND scope = 'full'
+    AND bound_node_id IS NULL AND revoked_at IS NULL
+    AND (expires_at IS NULL OR expires_at > datetime('now'))${currentTokenId ? " AND token_id != ?2" : ""}`;
+  const params = currentTokenId ? [userId, currentTokenId] : [userId];
+  if (revoke) {
+    return { revoked: db.run(`DELETE FROM api_tokens WHERE ${where}`, params).changes, kept: [] as KeptNetworkToken[] };
+  }
+  const kept = db.all<KeptNetworkToken>(
+    `SELECT token_id, name, network_id, created_at, last_used_at FROM api_tokens WHERE ${where} ORDER BY created_at DESC, token_id`,
+    ...params,
+  );
+  return { revoked: 0, kept };
+}

package/src/server.ts

@@ -1,3 +1,4 @@
+import { hostSupervisorIdentityRows } from "./host-supervisor-identity.js";
 import { buildServeErrorResponse } from "./serve-error.js";
 import { sanitizeRuntimeReadiness } from "./runtime-readiness.js";
 import { markGzipReusable, maybeGzipResponse, trimLightTask } from "./http-gzip";
@@ -1520,7 +1521,7 @@ return Bun.serve({
         // #711 不带 keep_cli_tokens 的请求(旧 app、dashboard 代理)= 改密码前的行为:撤销全部不绑网络的令牌。
         // keep_cli_tokens 必须是布尔 true 才保留命令行 / 脚本令牌。
         const meta = resolved.tokenId ? getUserTokenMeta(resolved.user.user_id, resolved.tokenId) : null;
-        const result = changePassword(resolved.user.user_id, body.old_password, body.new_password, resolved.tokenId, { keepCliTokens: body.keep_cli_tokens === true });
+        const result = changePassword(resolved.user.user_id, body.old_password, body.new_password, resolved.tokenId, { keepCliTokens: body.keep_cli_tokens === true, revokeNetworkTokens: body.revoke_network_tokens === true });
         if (result.ok) {
           // 换发的新令牌沿用当前这条的种类和设备标识:anet passwd 换完仍是命令行令牌。
           const issued = issueUserToken(resolved.user.user_id, "password-change", { kind: meta?.kind, clientLabel: meta?.client_label, userAgent: meta?.user_agent });
@@ -4574,31 +4575,10 @@ return Bun.serve({
         isPrivileged = true;
       }
 
-      // EXISTS subquery handles BOTH revoked_at SET and DELETEd token
-      // rows (revokeToken DELETEs the row in production — PR2 v1
-      // SHOULD-FIX per 通信龙 audit). EXISTS naturally dedupes daemons
-      // with rotated tokens.
-      const sqlRows = db.all<Record<string, any>>(`
-        SELECT
-          n.node_id, n.alias, n.hostname, n.network_id,
+      const sqlRows = hostSupervisorIdentityRows(`SELECT n.node_id, n.alias, n.hostname, n.network_id, n.owner_user_id,
           n.runtimes_supported, n.allowed_secret_keys,
-          n.created_at, n.updated_at,
-          s.last_seen_at AS session_last_seen,
-          s.cpu_cores AS session_cpu_cores,
-          s.mem_total_gb AS session_mem_total_gb,
-          s.ip AS session_ip,
-          n.config_snapshot
-        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 n.network_id = ?1
-          AND 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
-          )
-        ORDER BY n.updated_at DESC
-      `, effectiveNetId);
+          n.created_at, n.updated_at, n.config_snapshot
+        FROM nodes n WHERE n.network_id = ?1 ORDER BY n.updated_at DESC`, [effectiveNetId]);
 
       const nowMs = Date.now();
       // 心跳周期是 3 分钟（agent-node/src/cli.ts 的 report_status 定时器），

package/src/tools.ts

@@ -1,3 +1,4 @@
+import { hostSupervisorIdentityRows } from "./host-supervisor-identity.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { markTaskActivity } from "./task-activity.js";
 import { requestProviderSnapshot, requestProviderWrite, requestProviderCollection, requestProviderApplication, requestProviderLogin, getProviderSnapshot, pullProviderSnapshots, ackProviderSnapshot } from "./daemon-provider-snapshots.js";
@@ -4277,35 +4278,14 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
       // (already gate-locked by enforceNetworkId path of resolveReadScope).
       const isPrivileged = callerRole === "admin" || callerRole === "owner" || (!enforceUserId);
 
-      // Pull candidate daemons. Active-token EXISTS subquery handles BOTH
-      // revoked daemon ntoks (revoked_at set) AND DELETEd token rows
-      // (the standard revokeToken path deletes the row, not flagging
-      // revoked_at — PR2 v1 SHOULD-FIX per 通信龙 audit). EXISTS naturally
-      // dedupes if a daemon ever had multiple tokens (e.g. rotation; nit ⚪).
-      let sql = `
-        SELECT
-          n.node_id, n.alias, n.hostname, n.network_id,
+      // Scope first; batch immutable credential + heartbeat identity for both list entry points.
+      let sql = `SELECT n.node_id, n.alias, n.hostname, n.network_id, n.owner_user_id,
           n.runtimes_supported, n.allowed_secret_keys,
-          n.created_at, n.updated_at,
-          s.last_seen_at AS session_last_seen,
-          s.status AS session_status,
-          s.cpu_cores AS session_cpu_cores,
-          s.mem_total_gb AS session_mem_total_gb,
-          s.ip AS session_ip,
-          n.config_snapshot
-        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
-        )
-      `;
+          n.created_at, n.updated_at, n.config_snapshot FROM nodes n WHERE 1=1`;
       const sqlParams: any[] = [];
       sql = addReadScope(sql, sqlParams, readScope, "n.network_id");
       sql += ` ORDER BY n.updated_at DESC`;
-      const rows = db.all<Record<string, any>>(sql, ...sqlParams);
+      const rows = hostSupervisorIdentityRows(sql, sqlParams);
 
       // Filter to role=host_supervisor (read from config_snapshot;
       // schema-promoted columns runtimes_supported/allowed_secret_keys