@sleep2agi/commhub-server 0.9.0-preview.14 → 0.9.0-preview.141

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

@@ -0,0 +1,152 @@
+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);
+    // Fresh sessions is NOT NULL. Exercise the historical nullable shape in
+    // an actual temporary SQL table, without changing the production schema
+    // or mocking returned rows. Only the heartbeat read uses this table;
+    // the production node/token/scoped SQL and both HTTP/MCP paths stay real.
+    db.exec("CREATE TEMP TABLE lhs1109_legacy_sessions AS SELECT * FROM sessions WHERE 0=1");
+    for (const id of [unique, shared]) {
+      const n = db.get<any>("SELECT alias FROM nodes WHERE node_id=?1", id)!;
+      db.run(`INSERT INTO lhs1109_legacy_sessions(resume_id,alias,network_id,node_id,last_seen_at,updated_at,status)
+        VALUES(?1,?2,NULL,NULL,?3,?3,'idle')`, [`s_lhs1109_${++sequence}`, n.alias, new Date().toISOString()]);
+    }
+    const original = db.all.bind(db);
+    db.all = ((sql: string, ...params: any[]) => original(sql.replace("FROM sessions s", "FROM lhs1109_legacy_sessions s"), ...params)) as any;
+    try {
+      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);
+    } finally {
+      db.all = original;
+      db.exec("DROP TABLE lhs1109_legacy_sessions");
+    }
+  });
+  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/http-gzip.test.ts

@@ -0,0 +1,94 @@
+import { expect, test } from "bun:test";
+import { maybeGzipResponse, wantsGzip, isCompressibleResponse, trimLightTask, GZIP_MIN_BYTES, LIGHT_TASK_MAX_CHARS } from "./http-gzip";
+
+const big = JSON.stringify({ sessions: Array.from({ length: 200 }, (_, i) => ({ alias: `节点${i}`, task: "x".repeat(50) })) });
+const json = (body: string, extra: Record<string, string> = {}) =>
+  new Response(body, { status: 200, headers: { "Content-Type": "application/json; charset=utf-8", ...extra } });
+const reqWith = (ae?: string, method = "GET") =>
+  new Request("http://hub/api/status?light=1", { method, headers: ae === undefined ? {} : { "Accept-Encoding": ae } });
+
+test("wantsGzip reads Accept-Encoding, including q-values", () => {
+  expect(wantsGzip(reqWith("gzip, deflate, br"))).toBe(true);
+  expect(wantsGzip(reqWith("br;q=1.0, gzip;q=0.8"))).toBe(true);
+  expect(wantsGzip(reqWith("identity"))).toBe(false);
+  expect(wantsGzip(reqWith("gzip;q=0"))).toBe(false);
+  expect(wantsGzip(reqWith())).toBe(false);
+});
+
+test("a large JSON body is gzipped only when the client asked, and round-trips", async () => {
+  const out = await maybeGzipResponse(reqWith("gzip"), json(big));
+  expect(out!.headers.get("Content-Encoding")).toBe("gzip");
+  expect(out!.headers.get("Vary")).toContain("Accept-Encoding");
+  const bytes = new Uint8Array(await out!.arrayBuffer());
+  expect(bytes.byteLength).toBeLessThan(big.length / 3);
+  expect(Number(out!.headers.get("Content-Length"))).toBe(bytes.byteLength);
+  expect(new TextDecoder().decode(Bun.gunzipSync(bytes))).toBe(big);
+  expect(out!.headers.get("Content-Type")).toContain("application/json");
+
+  const plain = json(big);
+  expect(await maybeGzipResponse(reqWith(), plain)).toBe(plain); // untouched object
+});
+
+test("small, streamed, already-encoded, SSE, 204 and HEAD responses are left alone", async () => {
+  const small = json("{\"ok\":true}");
+  const outSmall = await maybeGzipResponse(reqWith("gzip"), small);
+  expect(outSmall!.headers.get("Content-Encoding")).toBeNull();
+  expect(await outSmall!.text()).toBe("{\"ok\":true}");
+  expect(GZIP_MIN_BYTES).toBe(1024);
+
+  const sse = new Response(new ReadableStream(), { headers: { "Content-Type": "text/event-stream" } });
+  expect(isCompressibleResponse(sse)).toBe(false);
+  expect(await maybeGzipResponse(reqWith("gzip"), sse)).toBe(sse);
+
+  const encoded = json(big, { "Content-Encoding": "br" });
+  expect(await maybeGzipResponse(reqWith("gzip"), encoded)).toBe(encoded);
+
+  const noContent = new Response(null, { status: 204 });
+  expect(await maybeGzipResponse(reqWith("gzip"), noContent)).toBe(noContent);
+
+  const head = json(big);
+  expect(await maybeGzipResponse(reqWith("gzip", "HEAD"), head)).toBe(head);
+
+  // /api/files downloads: Range replies and attachments keep their exact byte lengths (CI #509/#514 caught this)
+  const partial = new Response("x".repeat(4096), { status: 206, headers: { "Content-Type": "text/plain", "Content-Range": "bytes 0-4095/8192" } });
+  expect(await maybeGzipResponse(reqWith("gzip"), partial)).toBe(partial);
+  const attachment = new Response("y".repeat(4096), { status: 200, headers: { "Content-Type": "text/plain", "Content-Disposition": "attachment; filename=\"a.txt\"" } });
+  expect(await maybeGzipResponse(reqWith("gzip"), attachment)).toBe(attachment);
+
+  const binary = new Response(new Uint8Array(4096), { headers: { "Content-Type": "image/png" } });
+  expect(await maybeGzipResponse(reqWith("gzip"), binary)).toBe(binary);
+
+  expect(await maybeGzipResponse(reqWith("gzip"), undefined)).toBeUndefined();
+});
+
+test("trimLightTask keeps a one-line preview under the cap", () => {
+  expect(trimLightTask(null)).toBeNull();
+  expect(trimLightTask("   ")).toBeNull();
+  expect(trimLightTask("a\n  b")).toBe("a b");
+  const long = "字".repeat(LIGHT_TASK_MAX_CHARS + 40);
+  const t = trimLightTask(long)!;
+  expect(t.endsWith("…")).toBe(true);
+  expect([...t].length).toBe(LIGHT_TASK_MAX_CHARS + 1);
+  expect(trimLightTask("short")).toBe("short");
+});
+
+test("a response marked reusable is gzipped once per key; unmarked ones every time; different keys never share bytes", async () => {
+  const { markGzipReusable, gzipCacheStats, __resetGzipCacheForTest } = await import("./http-gzip");
+  __resetGzipCacheForTest();
+  const first = await maybeGzipResponse(reqWith("gzip"), markGzipReusable(json(big), "W/\"k1\""));
+  const second = await maybeGzipResponse(reqWith("gzip"), markGzipReusable(json(big), "W/\"k1\""));
+  expect(gzipCacheStats).toEqual({ hits: 1, misses: 1 });
+  const a = new Uint8Array(await first!.arrayBuffer());
+  const b = new Uint8Array(await second!.arrayBuffer());
+  expect(new TextDecoder().decode(Bun.gunzipSync(b))).toBe(big);
+  expect(Buffer.from(b).equals(Buffer.from(a))).toBe(true);
+  expect(Number(second!.headers.get("Content-Length"))).toBe(b.byteLength);
+  const other = big.replace("节点0", "节点X");
+  const third = await maybeGzipResponse(reqWith("gzip"), markGzipReusable(json(other), "W/\"k2\""));
+  expect(new TextDecoder().decode(Bun.gunzipSync(new Uint8Array(await third!.arrayBuffer())))).toBe(other);
+  await maybeGzipResponse(reqWith("gzip"), json(big));
+  expect(gzipCacheStats).toEqual({ hits: 1, misses: 2 });
+  // 没要 gzip 的客户端照旧拿原样正文,不碰缓存
+  const plain = markGzipReusable(json(big), "W/\"k1\"");
+  expect(await maybeGzipResponse(reqWith(), plain)).toBe(plain);
+});

package/src/http-gzip.ts

@@ -0,0 +1,112 @@
+// 2026-09-16(Vincent:「发一个消息都要被吞一段时间」「打开窗口历史很久才出来」):
+// 桌面端经 RELAY 连 hub,链路实测只有 ~13 KB/s;/api/status?light=1 128 KB 要 17 s,
+// 一页 20 条任务 41 KB 要 5.6 s,而 hub 从不压缩。gzip 后 128 KB → 31 KB、137 KB → 49 KB。
+// 只在客户端明确 `Accept-Encoding: gzip` 时压;text/event-stream(SSE)与流式 body 一律不碰。
+export const GZIP_MIN_BYTES = 1024;
+
+const COMPRESSIBLE = /^(application\/json|text\/(plain|html|css|javascript)|application\/javascript)\b/i;
+
+export function wantsGzip(req: Request): boolean {
+  const ae = req.headers.get("accept-encoding") || "";
+  for (const part of ae.split(",")) {
+    const [coding, ...params] = part.trim().split(";").map((x) => x.trim());
+    if (coding.toLowerCase() !== "gzip") continue;
+    const q = params.find((x) => /^q=/i.test(x));
+    if (!q) return true;
+    const n = Number(q.slice(2));
+    return Number.isFinite(n) && n > 0;
+  }
+  return false;
+}
+
+export function isCompressibleResponse(res: Response): boolean {
+  // 只压完整的 200:206 Partial Content / Content-Range / 附件下载(Content-Disposition)都有自己的
+  // 字节语义(Range 客户端按 Content-Length 数字节),压了就错 —— CI 的 /api/files Range 测试抓到的。
+  if (res.status !== 200 || !res.body) return false;
+  if (res.headers.get("content-encoding") || res.headers.get("content-range") || res.headers.get("content-disposition")) return false;
+  const ct = res.headers.get("content-type") || "";
+  if (/text\/event-stream/i.test(ct)) return false;
+  return COMPRESSIBLE.test(ct);
+}
+
+// 2026-09-30(连接较慢横幅):任务页每 15 s 轮询 ~1 MB 的需求表,每次都在事件循环上同步 gzip 一遍,
+// 而两次轮询之间表多半没变。带内容哈希 ETag 的响应(conditionalJson)标一个键,同一份正文只压一次。
+// 键就是正文的哈希,所以不同调用者拿到同一份压缩字节是安全的:字节相同 ⇔ 正文相同。
+export const GZIP_CACHE_MAX_BYTES = 16 * 1024 * 1024;
+const gzipKeys = new WeakMap<Response, string>();
+const gzipCache = new Map<string, Uint8Array>();
+let gzipCacheBytes = 0;
+export const gzipCacheStats = { hits: 0, misses: 0 };
+
+/** 标记这个响应的正文由 `key`(正文的内容哈希)唯一决定:压缩结果可以按键复用。 */
+export function markGzipReusable(res: Response, key: string): Response {
+  gzipKeys.set(res, key);
+  return res;
+}
+
+function gzipCached(key: string | undefined, raw: () => Promise<Uint8Array>): Promise<{ raw: Uint8Array | null; gz: Uint8Array | null }> | { raw: null; gz: Uint8Array } {
+  if (key) {
+    const hit = gzipCache.get(key);
+    if (hit) {
+      gzipCacheStats.hits++;
+      gzipCache.delete(key);
+      gzipCache.set(key, hit); // 最近用过的挪到队尾(LRU)
+      return { raw: null, gz: hit };
+    }
+  }
+  return raw().then(bytes => {
+    if (bytes.byteLength < GZIP_MIN_BYTES) return { raw: bytes, gz: null };
+    // 可复用的正文(带键)压一次、存起来、反复发:压缩级别拉到 9 —— 多花的那点 CPU 只花一次,
+    // 而线上每次都少发 ~3%(#431 实测:旧节点别名解析读 29.6 KB → 28.6 KB)。不带键的照旧默认级别。
+    const gz = key ? Bun.gzipSync(bytes, { level: 9 }) : Bun.gzipSync(bytes);
+    if (key) gzipCacheStats.misses++;
+    if (key && gz.byteLength <= GZIP_CACHE_MAX_BYTES / 4) {
+      gzipCache.set(key, gz);
+      gzipCacheBytes += gz.byteLength;
+      for (const [k, v] of gzipCache) {
+        if (gzipCacheBytes <= GZIP_CACHE_MAX_BYTES) break;
+        gzipCache.delete(k);
+        gzipCacheBytes -= v.byteLength;
+      }
+    }
+    return { raw: bytes, gz };
+  });
+}
+
+/** Test-only. */
+export function __resetGzipCacheForTest(): void {
+  gzipCache.clear();
+  gzipCacheBytes = 0;
+  gzipCacheStats.hits = 0;
+  gzipCacheStats.misses = 0;
+}
+
+/**
+ * Gzip a finished response when the client asked for it and the body is worth it.
+ * Reads the body once; callers must not have consumed it. Anything streamed or
+ * not compressible is returned untouched (same object).
+ */
+export async function maybeGzipResponse(req: Request, res: Response | undefined | void): Promise<Response | undefined> {
+  if (!res) return res as undefined;
+  if (req.method === "HEAD" || !wantsGzip(req) || !isCompressibleResponse(res)) return res;
+  const got = await gzipCached(gzipKeys.get(res), async () => new Uint8Array(await res.arrayBuffer()));
+  if (!got.gz) {
+    return new Response(got.raw, { status: res.status, statusText: res.statusText, headers: res.headers });
+  }
+  const gz = got.gz;
+  const headers = new Headers(res.headers);
+  headers.set("Content-Encoding", "gzip");
+  headers.set("Content-Length", String(gz.byteLength));
+  const vary = headers.get("Vary");
+  headers.set("Vary", vary && !/accept-encoding/i.test(vary) ? `${vary}, Accept-Encoding` : (vary || "Accept-Encoding"));
+  return new Response(gz, { status: res.status, statusText: res.statusText, headers });
+}
+
+/** 轻量列表里的 task 只给列表预览用;全文占了 light 载荷的一半以上。 */
+export const LIGHT_TASK_MAX_CHARS = 160;
+export function trimLightTask(task: unknown): string | null {
+  if (typeof task !== "string") return null;
+  const t = task.replace(/\s+/g, " ").trim();
+  if (!t) return null;
+  return t.length > LIGHT_TASK_MAX_CHARS ? `${t.slice(0, LIGHT_TASK_MAX_CHARS)}…` : t;
+}

package/src/hub-catalog-read-http.test.ts

@@ -0,0 +1,187 @@
+// #1473 (#909) — the Hub's Skills / secrets / Provider catalogs had MCP tools
+// but no HTTP read surface, so the desktop client shipped a fixture page
+// (agent-network-app/src/hub-scope-demo.ts: "Hub 这些写接口还没接通 ... 不发请求").
+//
+// These three endpoints are read-only and user-token only. The load-bearing
+// properties are:
+//   * a NODE token cannot enumerate the network's catalogs;
+//   * a plain member of another network cannot read this network's catalogs;
+//   * pending SkillHub submissions stay invisible unless the caller reviews;
+//   * NO secret value ever appears in a response body (asserted with a
+//     sentinel that would be trivially visible if a value were serialized).
+//
+// The sentinel test is deliberately byte-level on the raw response text: a
+// future field like `value_preview` would pass a JSON-shape assertion while
+// still leaking the secret.
+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 PRIVATE_DB_DIR = mkdtempSync(join(tmpdir(), "anet-hub-catalog-"));
+process.env.COMMHUB_DB ||= join(PRIVATE_DB_DIR, "hub.db");
+// The vault encrypts on write; set the master key before db.ts/vault.ts load.
+process.env.ANET_HUB_SECRET_VAULT_KEY ||= "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff";
+
+let server: ReturnType<typeof Bun.serve>;
+let base = "";
+let ownerToken = "", strangerToken = "", nodeToken = "";
+let ownerNet = "", strangerNet = "", ownerUserId = "";
+const SECRET_NAME = "PROVIDER_SENTINEL_KEY";
+const SECRET_VALUE = "sentinel-value-DO-NOT-LEAK-4f9a2c";
+
+const get = async (path: string, token: string) => {
+  const r = await fetch(`${base}${path}`, { headers: { Authorization: `Bearer ${token}` } });
+  const text = await r.text();
+  let body: any = null;
+  try { body = JSON.parse(text); } catch { body = null; }
+  return { status: r.status, body, text };
+};
+
+beforeAll(async () => {
+  const { db } = await import("./db.js");
+  const { register, createNetworkTokenForNode } = await import("./auth.js");
+  const { vaultUpsert } = await import("./vault.js");
+  const stamp = Date.now();
+
+  const owner = register(`hc_owner_${stamp}`, "HcOwner-Strong-1!");
+  const stranger = register(`hc_stranger_${stamp}`, "HcStranger-Strong-1!");
+  expect(owner.ok && stranger.ok).toBe(true);
+  ownerToken = owner.token!;
+  strangerToken = stranger.token!;
+  ownerNet = owner.network_id!;
+  strangerNet = stranger.network_id!;
+  ownerUserId = db.get<{ user_id: string }>("SELECT user_id FROM users WHERE username = ?1", `hc_owner_${stamp}`)!.user_id;
+
+  // A node token in the SAME network: it must still be refused, because a node
+  // is not a person and may not enumerate catalogs.
+  const nodeTok = createNetworkTokenForNode(ownerUserId, ownerNet, "hc-node", "n_hc_test");
+  expect(nodeTok.ok).toBe(true);
+  nodeToken = nodeTok.token!;
+
+  // Published + pending skills in the owner's network.
+  const skill = (id: string, status: string, slug: string) => db.run(
+    `INSERT INTO skillhub_skills (skill_id, network_id, slug, name, description, content, content_hash, version, status, source_type, source_alias, created_at, updated_at)
+     VALUES (?1, ?2, ?3, ?3, 'd', '# SKILL body', 'hash-' || ?1, '1.0.0', ?4, 'node', 'hc-node', datetime('now'), datetime('now'))`,
+    [id, ownerNet, slug, status],
+  );
+  skill("skill_hc_pub", "published", "hc-published");
+  skill("skill_hc_pending", "pending", "hc-pending");
+
+  // The sentinel secret. Names may be shown; values never.
+  vaultUpsert(ownerNet, SECRET_NAME, SECRET_VALUE);
+
+  db.run(
+    `INSERT INTO hub_provider_configs (network_id, provider_id, revision, config_json, secret_key_ref, updated_at)
+     VALUES (?1, 'hc-provider', 3, ?2, ?3, ?4)`,
+    [ownerNet, JSON.stringify({ id: "hc-provider", label: "HC Provider", enabled: true, protocol: "openai-responses", baseUrl: "https://example.test/v1", models: ["m1"] }), "HC_PROVIDER_KEY", Date.now()],
+  );
+
+  const mod = await import("./server.js");
+  server = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  base = `http://127.0.0.1:${server.port}`;
+});
+
+afterAll(() => {
+  try { server?.stop(true); } catch {}
+  try { rmSync(PRIVATE_DB_DIR, { recursive: true, force: true }); } catch {}
+});
+
+describe("GET /api/skills", () => {
+  test("owner sees published skills and no content body", async () => {
+    const r = await get(`/api/skills?network_id=${ownerNet}`, ownerToken);
+    expect(r.status).toBe(200);
+    expect(r.body.ok).toBe(true);
+    expect(r.body.reviewer).toBe(true);
+    expect(r.body.network_id).toBe(ownerNet);
+    const slugs = r.body.skills.map((s: any) => s.slug);
+    expect(slugs).toContain("hc-published");
+    // Pending is opt-in even for a reviewer.
+    expect(slugs).not.toContain("hc-pending");
+    // The list is metadata only — a body field would mean SKILL.md text leaked.
+    for (const s of r.body.skills) expect(s.content).toBeUndefined();
+  });
+
+  test("reviewer may ask for pending submissions", async () => {
+    const r = await get(`/api/skills?network_id=${ownerNet}&include_pending=1`, ownerToken);
+    expect(r.status).toBe(200);
+    const slugs = r.body.skills.map((s: any) => s.slug);
+    expect(slugs).toContain("hc-pending");
+  });
+
+  test("a member of another network is refused", async () => {
+    const r = await get(`/api/skills?network_id=${ownerNet}`, strangerToken);
+    expect(r.status).toBe(403);
+    // Cross-network access is refused by REST scope resolution BEFORE the role
+    // check runs, so the error names the scope gate. Either way: 403, no data.
+    expect(String(r.body.error)).toMatch(/access denied|permission_denied/);
+  });
+
+  test("a node token is refused even inside its own network", async () => {
+    const r = await get(`/api/skills?network_id=${ownerNet}`, nodeToken);
+    expect(r.status).toBe(403);
+    expect(r.body.error).toBe("user_token_required");
+  });
+
+  test("include_pending is ignored for a non-reviewer of that network", async () => {
+    // The stranger's own network has no skills; the point is that asking for
+    // pending must not widen what they can see when they ask about their own.
+    const r = await get(`/api/skills?network_id=${strangerNet}&include_pending=1`, strangerToken);
+    expect(r.status).toBe(200);
+    expect(r.body.reviewer).toBe(true); // they own their own network
+    expect(r.body.skills).toEqual([]);
+  });
+});
+
+describe("GET /api/secrets", () => {
+  test("returns key names and timestamps, never the value", async () => {
+    const r = await get(`/api/secrets?network_id=${ownerNet}`, ownerToken);
+    expect(r.status).toBe(200);
+    const names = r.body.keys.map((k: any) => k.key);
+    expect(names).toContain(SECRET_NAME);
+    // <-- The load-bearing assertion: raw body text must not contain the value.
+    expect(r.text).not.toContain(SECRET_VALUE);
+    expect(r.text).not.toContain("ciphertext");
+    expect(r.text).not.toContain("iv");
+    expect(r.text).not.toContain("tag");
+  });
+
+  test("a member of another network is refused and learns no key names", async () => {
+    const r = await get(`/api/secrets?network_id=${ownerNet}`, strangerToken);
+    expect(r.status).toBe(403);
+    expect(r.text).not.toContain(SECRET_NAME);
+    expect(r.text).not.toContain(SECRET_VALUE);
+  });
+
+  test("a node token is refused", async () => {
+    const r = await get(`/api/secrets?network_id=${ownerNet}`, nodeToken);
+    expect(r.status).toBe(403);
+    expect(r.body.error).toBe("user_token_required");
+  });
+});
+
+describe("GET /api/providers", () => {
+  test("returns the registry without secret references", async () => {
+    const r = await get(`/api/providers?network_id=${ownerNet}`, ownerToken);
+    expect(r.status).toBe(200);
+    expect(r.body.providers).toHaveLength(1);
+    expect(r.body.providers[0]).toMatchObject({ id: "hc-provider", label: "HC Provider", source: "hub" });
+    // The vault key NAME is a hint an attacker does not need; `exposeRefs` is
+    // false here on purpose.
+    expect(r.body.providers[0].secret_key_ref).toBeUndefined();
+    expect(r.text).not.toContain("HC_PROVIDER_KEY");
+    expect(r.text).not.toContain(SECRET_VALUE);
+  });
+
+  test("a member of another network is refused", async () => {
+    const r = await get(`/api/providers?network_id=${ownerNet}`, strangerToken);
+    expect(r.status).toBe(403);
+    expect(r.text).not.toContain("hc-provider");
+  });
+
+  test("a node token is refused", async () => {
+    const r = await get(`/api/providers?network_id=${ownerNet}`, nodeToken);
+    expect(r.status).toBe(403);
+    expect(r.body.error).toBe("user_token_required");
+  });
+});