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

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-provider-config.test.ts

@@ -0,0 +1,139 @@
+import './require-explicit-test-db';
+import { afterAll, beforeEach, expect, test } from 'bun:test';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { db } from './db';
+import { registerTools } from './tools';
+import { vaultGet } from './vault';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { reconcileProviderSnapshots, secureProviderTransport } from '../../agent-node/src/runtime/daemon-provider-snapshot';
+import { DaemonProviderStore } from '../../agent-network/src/daemon-provider-store';
+const net = 'net_hub907', user = 'u_hub907', daemonId = 'n_hub907', alias = 'daemon907', token = 'tok_hub907';
+const root = mkdtempSync(join(tmpdir(), 'hub907-')), key = 'TEST-ONLY-shared-provider-key';
+function cleanup() {
+  for (const t of ['daemon_provider_writes', 'daemon_provider_applications', 'daemon_provider_logins']) db.run(`DELETE FROM ${t} WHERE request_id IN (SELECT request_id FROM daemon_provider_snapshots WHERE network_id=?1)`, [net]);
+  for (const t of ['hub_provider_bindings', 'hub_provider_configs', 'network_secrets', 'daemon_provider_snapshots', 'nodes', 'api_tokens', 'network_members']) db.run(`DELETE FROM ${t} WHERE network_id=?1`, [net]);
+  db.run('DELETE FROM networks WHERE network_id=?1', [net]); db.run('DELETE FROM users WHERE user_id=?1', [user]);
+}
+beforeEach(() => {
+  cleanup(); rmSync(join(root, '.anet'), { recursive: true, force: true });
+  process.env.ANET_HUB_SECRET_VAULT_KEY = '42'.repeat(32);
+  db.run("INSERT INTO users(user_id,username,password_hash,role) VALUES(?1,?1,'x','user')", [user]);
+  db.run('INSERT INTO networks(network_id,network_name,owner_id) VALUES(?1,?1,?2)', [net, user]);
+  db.run("INSERT INTO network_members(user_id,network_id,role) VALUES(?1,?2,'owner')", [user, net]);
+  db.run('INSERT INTO nodes(node_id,node_name,alias,network_id,config_snapshot) VALUES(?1,?2,?2,?3,?4)', [daemonId, alias, net, JSON.stringify({ role: 'host_supervisor' })]);
+  db.run("INSERT INTO api_tokens(token_id,user_id,network_id,scope,name,token_hash) VALUES(?1,?2,?3,'network',?4,?5)", [token, user, net, `node:${alias}`, `hash_${token}`]);
+  const dir = join(root, '.anet/nodes', alias); mkdirSync(dir, { recursive: true, mode: 0o700 });
+  writeFileSync(join(dir, 'config.json'), JSON.stringify({ role: 'host_supervisor', node_id: daemonId, network_id: net }), { mode: 0o600 });
+});
+afterAll(() => { cleanup(); rmSync(root, { recursive: true, force: true }); });
+function client(kind = 'human') {
+  const handlers: Record<string, any> = {}, server = new McpServer({ name: 'test907', version: '0' }) as any;
+  const tool = server.tool.bind(server), register = server.registerTool.bind(server);
+  server.tool = (name: string, desc: any, shape: any, handler: any) => { handlers[name] = handler; return tool(name, desc, shape, handler); };
+  server.registerTool = (name: string, config: any, handler: any) => { handlers[name] = handler; return register(name, config, handler); };
+  registerTools(server, undefined, kind === 'daemon' ? net : null, kind === 'anonymous' ? null : user, alias, kind === 'daemon', kind === 'daemon' ? token : null);
+  return async (name: string, args: any = {}) => JSON.parse((await handlers[name](args)).content[0].text);
+}
+const provider = () => ({ id: 'shared', label: 'Shared model', enabled: true, protocol: 'openai-responses', baseUrl: 'https://provider.example/v1', models: ['fixture-model'], key });
+const save = (human: ReturnType<typeof client>, value = provider(), revision = 0) => human('daemon_provider_snapshot', { action: 'hub_put', id: value.id, network_id: net, revision, provider: value });
+const bind = (human: ReturnType<typeof client>, target = daemonId, revision = 1) => human('daemon_provider_snapshot', { action: 'hub_bind', network_id: net, id: 'shared', revision, provider: { daemon_node_id: target, daemon_revision: 0, confirm: true } });
+test('HTTP Hub and API endpoint support save, explicit bind and exact private-store readback', async () => {
+  expect(secureProviderTransport('http://hub907.example.test')).toBe(true);
+  expect(secureProviderTransport('ftp://hub907.example.test')).toBe(false);
+  expect(secureProviderTransport('http://user:password@hub907.example.test')).toBe(false);
+  const human = client(), daemon = client('daemon');
+  const config = { ...provider(), baseUrl: 'http://provider.example/v1' };
+  const saved = await save(human, config); expect(saved.ok).toBe(true);
+  expect(saved.provider.baseUrl).toBe(config.baseUrl);
+  const queued = await bind(human); expect(queued.ok).toBe(true);
+  await reconcileProviderSnapshots({ workDir: root, alias, networkId: net, daemonId,
+    serverUrl: 'http://hub907.example.test', callCommHub: daemon, warn: message => console.warn(message) });
+  const receipt = await human('daemon_provider_snapshot', { action: 'read', id: queued.request_id, network_id: net });
+  expect(receipt.status).toBe('succeeded');
+  expect(receipt.snapshot.providers[0].runtimes[0].auth[0].baseUrl).toBe(config.baseUrl);
+  expect(JSON.stringify([saved, queued, receipt])).not.toContain(key);
+  const store = new DaemonProviderStore(join(root, '.anet/nodes', alias));
+  await store.withApiKey({ revision: 1, providerId: queued.provider_reference.daemon_provider_id, authId: 'hub_key', model: 'fixture-model' }, async actual => {
+    expect(actual.baseUrl).toBe(config.baseUrl); expect(actual.key).toBe(key);
+  }); // Exact synthetic key in local callback, no external model request.
+  for (const baseUrl of ['ftp://provider.example/v1', 'http://user:pass@provider.example/v1', 'http://provider.example/v1?key=secret']) {
+    expect(await save(human, { ...provider(), id: 'invalid', baseUrl })).toMatchObject({ ok: false, error: 'invalid_hub_provider' });
+  }
+});
+test('existing names-only vault key → Provider reference → actual daemon store, without re-entering key', async () => {
+  const human = client(), daemon = client('daemon');
+  expect(await human('upsert_network_secret', { network_id: net, key: 'SHARED_API_KEY', value: key })).toMatchObject({ ok: true });
+  const { key: ignored, ...config } = provider();
+  const saved = await save(human, { ...config, secretKeyRef: 'SHARED_API_KEY' } as any);
+  expect(saved.provider).toMatchObject({ secret_key_ref: 'SHARED_API_KEY', credential_present: true });
+  expect(db.get<any>('SELECT secret_key_ref FROM hub_provider_configs WHERE network_id=?1', net).secret_key_ref).toBe('SHARED_API_KEY');
+  const legacy = await human('daemon_provider_snapshot', { action: 'hub_read', id: 'hub', network_id: net });
+  expect(legacy.providers[0].secret_key_ref).toBeUndefined(); // older strict client shape unchanged
+  const modern = await human('daemon_provider_snapshot', { action: 'hub_read', id: 'hub', network_id: net, provider: { include_secret_refs: true } });
+  expect(modern.secret_reference_supported).toBe(true); expect(modern.providers[0].secret_key_ref).toBe('SHARED_API_KEY');
+  expect(JSON.stringify([saved, legacy, modern])).not.toContain(key);
+  const queued = await bind(human); expect(queued.ok).toBe(true);
+  await reconcileProviderSnapshots({ workDir: root, alias, networkId: net, daemonId, serverUrl: 'https://hub907.example.test', callCommHub: daemon, warn: message => console.warn(message) });
+  const receipt = await human('daemon_provider_snapshot', { action: 'read', id: queued.request_id, network_id: net });
+  expect(receipt.status).toBe('succeeded'); expect(receipt.snapshot.providers[0].runtimes[0].auth[0].credential_present).toBe(true);
+  const store = new DaemonProviderStore(join(root, '.anet/nodes', alias));
+  await store.withApiKey({ revision: receipt.snapshot.revision, providerId: queued.provider_reference.daemon_provider_id, authId: 'hub_key', model: 'fixture-model' }, async profile => {
+    expect(profile.key).toBe(key); expect(profile.baseUrl).toBe(config.baseUrl);
+  }); // synthetic local callback only; no model/vendor request
+  expect(JSON.stringify(receipt)).not.toContain(key);
+  // Switching back to Provider-owned plaintext never changes the reusable named key.
+  await save(human, { ...provider(), key: 'TEST-ONLY-provider-specific' }, 1);
+  expect(vaultGet(net, 'SHARED_API_KEY')).toBe(key);
+  expect(db.get<any>('SELECT secret_key_ref FROM hub_provider_configs WHERE network_id=?1', net).secret_key_ref).not.toBe('SHARED_API_KEY');
+});
+test('missing or ambiguous references do not save; explicit ref replacement updates the stored reference', async () => {
+  const human = client(); const { key: ignored, ...config } = provider();
+  expect(await save(human, { ...config, secretKeyRef: 'MISSING_KEY' } as any)).toMatchObject({ ok: false, error: 'provider_secret_reference_missing' });
+  expect(await save(human, { ...provider(), secretKeyRef: 'SHARED_API_KEY' } as any)).toMatchObject({ ok: false, error: 'invalid_provider_secret_reference' });
+  await save(human);
+  await human('upsert_network_secret', { network_id: net, key: 'SECOND_API_KEY', value: 'TEST-ONLY-second-key' });
+  expect((await save(human, { ...config, secretKeyRef: 'SECOND_API_KEY' } as any, 1)).provider.secret_key_ref).toBe('SECOND_API_KEY');
+  expect(db.get<any>('SELECT secret_key_ref FROM hub_provider_configs WHERE network_id=?1', net).secret_key_ref).toBe('SECOND_API_KEY');
+});
+test('actual Hub tool atomically saves encrypted Provider; metadata read and conflict never echo key', async () => {
+  const human = client(); const result = await save(human); expect(result.ok).toBe(true);
+  expect(result.provider).toMatchObject({ id: 'shared', revision: 1, source: 'hub', credential_present: true, compatible_runtimes: ['codex-tui'] });
+  const read = await human('daemon_provider_snapshot', { action: 'hub_read', id: 'hub', network_id: net }); expect(read.providers).toHaveLength(1);
+  expect(JSON.stringify([result, read])).not.toContain(key);
+  expect(await save(human)).toMatchObject({ ok: false, error: 'hub_provider_revision_conflict' });
+  const secret = db.get<any>('SELECT ciphertext FROM network_secrets WHERE network_id=?1', net);
+  expect(Buffer.from(secret.ciphertext).toString()).not.toContain(key);
+});
+test('Hub → actual daemon queue → pinned CLI store → redacted receipt, not runtime application', async () => {
+  const human = client(), daemon = client('daemon'); await save(human);
+  const queued = await bind(human); expect(queued.ok).toBe(true); expect(queued.status).toBe('pending');
+  expect(JSON.stringify(queued)).not.toContain(key);
+  await reconcileProviderSnapshots({ workDir: root, alias, networkId: net, daemonId, serverUrl: 'https://hub907.example.test', callCommHub: daemon, warn: message => console.warn(message) });
+  const read = await human('daemon_provider_snapshot', { action: 'read', id: queued.request_id, network_id: net });
+  expect(read.status).toBe('succeeded'); expect(read.snapshot.revision).toBe(1);
+  expect(read.snapshot.providers[0]).toMatchObject({ id: queued.provider_reference.daemon_provider_id, label: 'Hub · Shared model' });
+  expect(read.snapshot.providers[0].runtimes[0].auth[0]).toMatchObject({ id: 'hub_key', models: ['fixture-model'], application: 'not_applied', verification: 'not_checked' });
+  expect(JSON.stringify(read)).not.toContain(key);
+});
+test('scope/role boundaries: no node or anonymous writes, no viewer distribution or foreign daemon', async () => {
+  expect(await save(client('daemon'))).toMatchObject({ ok: false, error: 'user_token_required' });
+  expect(await save(client('anonymous'))).toMatchObject({ ok: false, error: 'user_token_required' });
+  const human = client(); await save(human);
+  expect(await human('daemon_provider_snapshot', { action: 'hub_read', id: 'hub', network_id: 'foreign' })).toMatchObject({ ok: false, error: 'provider_access_denied' });
+  expect(await bind(human, 'foreign')).toMatchObject({ ok: false, error: 'daemon_not_found' });
+  db.run("UPDATE network_members SET role='viewer' WHERE network_id=?1 AND user_id=?2", [net, user]);
+  expect(await bind(human)).toMatchObject({ ok: false, error: 'provider_access_denied' });
+  expect(await save(human)).toMatchObject({ ok: false, error: 'provider_owner_required' });
+});
+test('protocol mismatch never queues Codex; editing source cancels pending distribution, not installed copies', async () => {
+  const human = client(); await save(human, { ...provider(), protocol: 'openai-chat-completions' });
+  expect(await bind(human)).toMatchObject({ ok: false, error: 'runtime_protocol_not_supported' });
+  await save(human, provider(), 1);
+  const queued = await bind(human, daemonId, 2);
+  expect(queued.ok).toBe(true); await save(human, { ...provider(), enabled: false }, 2);
+  const read = await human('daemon_provider_snapshot', { action: 'read', id: queued.request_id, network_id: net });
+  expect(read).toMatchObject({ status: 'failed', error: 'hub_provider_source_changed' });
+  expect(db.get('SELECT request_id FROM daemon_provider_writes WHERE request_id=?1', queued.request_id)).toBeNull();
+});

package/src/hub-provider-config.ts

@@ -0,0 +1,105 @@
+// #907: real network-scoped catalog + explicit dispatch; not a Provider proxy.
+import { createHash } from 'node:crypto';
+import { db } from './db';
+import { getUserNetworkRole } from './auth';
+import { vaultUpsert, vaultGet, vaultListKeys, VaultError } from './vault';
+import { requestProviderWrite } from './daemon-provider-snapshots';
+type Human = { userId?: string | null; isNode: boolean; networkId: string | null };
+type Config = { id: string; label: string; enabled: boolean; protocol: 'openai-responses' | 'openai-chat-completions' | 'anthropic-messages'; baseUrl: string; models: string[] };
+const denied = (error: string) => ({ ok: false as const, error });
+const idValid = (id: unknown) => typeof id === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(id);
+function auth(h: Human, write: boolean, owner = false) {
+  if (h.isNode || !h.userId || !h.networkId) return denied('user_token_required');
+  const role = getUserNetworkRole(h.userId, h.networkId);
+  if (!role || (owner && role !== 'owner') || (write && !['owner', 'admin'].includes(role))) return denied(owner ? 'provider_owner_required' : 'provider_access_denied');
+  return null;
+}
+function validConfig(value: any): value is Config {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || Object.keys(value).some(k => !['id', 'label', 'enabled', 'protocol', 'baseUrl', 'models', 'key', 'secretKeyRef'].includes(k))
+    || !idValid(value.id) || typeof value.label !== 'string' || !value.label.trim() || value.label.length > 100
+    || /[\x00-\x1f\x7f]/.test(value.label) || typeof value.enabled !== 'boolean'
+    || !['openai-responses', 'openai-chat-completions', 'anthropic-messages'].includes(value.protocol)
+    || typeof value.baseUrl !== 'string' || value.baseUrl.length > 2048
+    || !Array.isArray(value.models) || !value.models.length || value.models.length > 200
+    || new Set(value.models).size !== value.models.length
+    || value.models.some((m: unknown) => typeof m !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,99}$/.test(m))) return false;
+  try { const u = new URL(value.baseUrl); return ['https:', 'http:'].includes(u.protocol) && !u.username && !u.password && !u.search && !u.hash; }
+  catch { return false; }
+}
+type Row = { revision: number; config_json: string; secret_key_ref: string; updated_at: number };
+function row(networkId: string, id: string) {
+  return db.get<Row>('SELECT revision,config_json,secret_key_ref,updated_at FROM hub_provider_configs WHERE network_id=?1 AND provider_id=?2', networkId, id);
+}
+function publicRow(networkId: string, stored: Row, exposeRef = false) {
+  const config = JSON.parse(stored.config_json) as Config;
+  return { ...config, ...(exposeRef ? { secret_key_ref: stored.secret_key_ref } : {}), revision: stored.revision, updated_at: stored.updated_at, source: 'hub',
+    credential_present: vaultListKeys(networkId).includes(stored.secret_key_ref), verification: 'not_checked',
+    compatible_runtimes: config.protocol === 'openai-responses' ? ['codex-tui'] : [] };
+}
+export function readHubProviders(h: Human, exposeRefs = false) {
+  const refusal = auth(h, false); if (refusal) return refusal;
+  const rows = db.all<Row>('SELECT revision,config_json,secret_key_ref,updated_at FROM hub_provider_configs WHERE network_id=?1 ORDER BY provider_id', h.networkId!);
+  return { ok: true as const, network_id: h.networkId!, source: 'hub' as const,
+    ...(exposeRefs ? { secret_reference_supported: true } : {}), providers: rows.map(r => publicRow(h.networkId!, r, exposeRefs)) };
+}
+export function putHubProvider(h: Human, revision: number, input: unknown) {
+  // This operation stores/rotates a shared secret: same OWNER boundary as vault writes.
+  const refusal = auth(h, true, true); if (refusal) return refusal;
+  if (!Number.isSafeInteger(revision) || revision < 0 || revision >= Number.MAX_SAFE_INTEGER) return denied('invalid_revision');
+  if (!validConfig(input)) return denied('invalid_hub_provider');
+  const value = input as Config & { key?: string; secretKeyRef?: string };
+  if (value.key !== undefined && (typeof value.key !== 'string' || !value.key || value.key.length > 8192 || /[\s\x00-\x1f\x7f]/.test(value.key))) return denied('invalid_provider_key');
+  if (value.secretKeyRef !== undefined && (typeof value.secretKeyRef !== 'string' || !/^[A-Z][A-Z0-9_]{0,63}$/.test(value.secretKeyRef)
+    || value.key !== undefined)) return denied('invalid_provider_secret_reference');
+  if (value.secretKeyRef && !vaultListKeys(h.networkId!).includes(value.secretKeyRef)) return denied('provider_secret_reference_missing');
+  const old = row(h.networkId!, value.id);
+  if ((old?.revision ?? 0) !== revision) return denied('hub_provider_revision_conflict');
+  const previous = old ? JSON.parse(old.config_json) as Config : null;
+  if (!value.key && !value.secretKeyRef && (!old || previous?.baseUrl !== value.baseUrl || previous?.protocol !== value.protocol)) return denied('provider_key_required');
+  // A new plaintext key belongs to this Provider. Never overwrite a separately
+  // named shared key merely because the previous config referenced it.
+  const privateRef = `HUB_PROVIDER_${createHash('sha256').update(JSON.stringify([h.networkId, value.id])).digest('hex').slice(0, 32).toUpperCase()}`;
+  const ref = value.secretKeyRef ?? (value.key ? privateRef : old!.secret_key_ref);
+  const { key, secretKeyRef, ...config } = value;
+  try {
+    db.transaction(() => {
+      if ((row(h.networkId!, value.id)?.revision ?? 0) !== revision) throw new Error('hub_provider_revision_conflict');
+      if (key) vaultUpsert(h.networkId!, ref, key);
+      db.run(`INSERT INTO hub_provider_configs(network_id,provider_id,revision,config_json,secret_key_ref,updated_at) VALUES(?1,?2,?3,?4,?5,?6)
+        ON CONFLICT(network_id,provider_id) DO UPDATE SET revision=excluded.revision,config_json=excluded.config_json,secret_key_ref=excluded.secret_key_ref,updated_at=excluded.updated_at`,
+        [h.networkId!, value.id, revision + 1, JSON.stringify(config), ref, Date.now()]);
+      // Cancel still-pending dispatches when the source is edited/rotated/disabled.
+      // Already installed copies are NOT remotely revoked by this change.
+      db.run(`UPDATE daemon_provider_snapshots SET status='failed',error='hub_provider_source_changed'
+        WHERE status='pending' AND request_id IN (SELECT request_id FROM hub_provider_bindings WHERE network_id=?1 AND provider_id=?2)`, [h.networkId!, value.id]);
+      db.run(`DELETE FROM daemon_provider_writes WHERE request_id IN (SELECT b.request_id FROM hub_provider_bindings b
+        JOIN daemon_provider_snapshots s ON s.request_id=b.request_id WHERE b.network_id=?1 AND b.provider_id=?2 AND s.status!='pending')`, [h.networkId!, value.id]);
+    });
+    return { ok: true as const, network_id: h.networkId!, provider: publicRow(h.networkId!, row(h.networkId!, value.id)!, secretKeyRef !== undefined) };
+  } catch (error) { return denied(error instanceof VaultError ? error.code : 'hub_provider_save_failed'); }
+}
+export function bindHubProvider(h: Human, input: { id: string; revision: number; daemon_node_id: string; daemon_revision: number; confirm: boolean }) {
+  const refusal = auth(h, true); if (refusal) return refusal;
+  if (!input || !idValid(input.id) || input.confirm !== true || !Number.isSafeInteger(input.revision)
+    || !Number.isSafeInteger(input.daemon_revision) || input.daemon_revision < 0) return denied('invalid_hub_provider_binding');
+  const stored = row(h.networkId!, input.id);
+  if (!stored || stored.revision !== input.revision) return denied('hub_provider_revision_conflict');
+  const config = JSON.parse(stored.config_json) as Config;
+  if (!config.enabled) return denied('hub_provider_disabled');
+  // Never silently treat Chat Completions/Anthropic as Codex Responses.
+  if (config.protocol !== 'openai-responses') return denied('runtime_protocol_not_supported');
+  const targetId = `hub_${createHash('sha256').update(JSON.stringify([h.networkId, input.id])).digest('hex').slice(0, 24)}`;
+  try {
+    const key = vaultGet(h.networkId!, stored.secret_key_ref); if (!key) return denied('provider_key_missing');
+    const queued = requestProviderWrite(h, input.daemon_node_id, input.daemon_revision, { id: targetId,
+      label: `Hub · ${config.label}`.slice(0, 100), enabled: true, runtimes: [{ runtime: 'codex-tui', auth: [
+        { id: 'hub_key', kind: 'api_key', models: config.models, baseUrl: config.baseUrl, key },
+      ] }] });
+    if (!queued.ok) return queued;
+    db.run(`INSERT INTO hub_provider_bindings(request_id,network_id,provider_id,provider_revision,daemon_node_id,daemon_provider_id,created_at)
+      VALUES(?1,?2,?3,?4,?5,?6,?7)`, [queued.request_id, h.networkId!, input.id, input.revision, input.daemon_node_id, targetId, Date.now()]);
+    return { ...queued, daemon_node_id: input.daemon_node_id,
+      provider_reference: { network_id: h.networkId!, id: input.id, revision: input.revision, daemon_provider_id: targetId } };
+  } catch (error) { return denied(error instanceof VaultError ? error.code : 'hub_provider_binding_failed'); }
+}

package/src/hub-timestamp.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test";
+import { parseHubTimestamp } from "./hub-timestamp";
+
+const RAW = "2026-08-30 21:11:24";                    // sessions.last_seen_at 的真实取值
+const TRUE_UTC = Date.UTC(2026, 7, 30, 21, 11, 24);
+
+describe("parseHubTimestamp (#1650)", () => {
+  test("🔴 非 UTC 时区下也必须解出同一个 UTC 时刻", () => {
+    // `bun test` 把测试进程时区固定成 UTC(getTimezoneOffset() === 0)。
+    // 在 UTC 下,「补 Z」和「不补 Z」解析出**同一个数** —— 这个函数存在的那个
+    // 缺陷在测试进程里**结构上不可见**。所以这一条必须开 TZ≠UTC 的子进程。
+    // 实测:去掉补 Z,本文件其余各条**全绿**。
+    const child = `import { parseHubTimestamp } from ${JSON.stringify(import.meta.dir + "/hub-timestamp.ts")};
+process.stdout.write(new Date().getTimezoneOffset() + "," + parseHubTimestamp(${JSON.stringify(RAW)}));`;
+    const r = Bun.spawnSync(["bun", "-e", child], { env: { ...process.env, TZ: "Asia/Shanghai" } });
+    const [offset, parsed] = r.stdout.toString().trim().split(",");
+    // 🔴 先断言控制生效:子进程真的不在 UTC。否则 TZ 被忽略时这条又变成空测试。
+    expect(Number(offset)).not.toBe(0);
+    expect(parsed).toBe(String(TRUE_UTC));
+  });
+
+  test("已带 Z / ±HH:MM 的串不再追加时区", () => {
+    expect(parseHubTimestamp("2026-08-30T21:11:24Z")).toBe(TRUE_UTC);
+    expect(parseHubTimestamp("2026-08-30T22:11:24+01:00")).toBe(TRUE_UTC);
+  });
+
+  test("拿不到就返回 null,不返回一个看起来合理的数", () => {
+    for (const bad of [undefined, null, "", "  ", 0, 1788124284000, {}, [], "2026-08-30", "垃圾"]) {
+      expect(parseHubTimestamp(bad as unknown)).toBeNull();
+    }
+  });
+
+  test("🔴 INTEGER 列(epoch 毫秒)不归它管 —— 传数字必须返回 null,而不是悄悄接受", () => {
+    // external_schedule_edits.* 是 INTEGER。如果有人把本函数用在那儿,
+    // 应当立刻拿到 null 而不是一个错的时刻。
+    expect(parseHubTimestamp(TRUE_UTC)).toBeNull();
+  });
+});

package/src/hub-timestamp.ts

@@ -0,0 +1,27 @@
+/**
+ * #1650 — hub 的 TEXT 时间戳列是 SQLite `datetime('now')` 写的，
+ * 形如 `2026-08-30 21:11:24`：**UTC，但不带任何时区标记**。
+ *
+ * 🔴 `new Date(raw)` / `Date.parse(raw)` 对这种串按**本地时间**解析（ES 规范：
+ *    带时间的形式无偏移时视为本地时间），误差恰好等于主机时区偏移，**而且不报错**：
+ *
+ *      TZ=UTC                   误差  0h
+ *      TZ=Asia/Shanghai         误差 -8h   （看起来更陈旧）
+ *      TZ=America/Los_Angeles   误差 +7h   （看起来更新鲜 ← 朝好的一侧错）
+ *
+ * 🔴 **只对 TEXT 列用它。** 同一个字段名在不同表里可能是不同类型：
+ *      sessions.last_seen_at / licenses.expires_at   → TEXT（要用本函数）
+ *      external_schedule_edits.expires_at 等 4 列     → INTEGER（epoch 毫秒，直接 new Date 就对）
+ *    按字段名判会判错 —— 见 #1650 里的更正。
+ *
+ * 与 agent-network 侧的同名函数是**有意的重复**：server 包不依赖 agent-network，
+ * 仓里也没有共享 lib。两边各自带测试。
+ */
+export function parseHubTimestamp(raw: unknown): number | null {
+  if (typeof raw !== "string") return null;
+  const t = raw.trim();
+  if (!/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}/.test(t)) return null;
+  const hasZone = /([Zz]|[+-]\d{2}:?\d{2})$/.test(t);
+  const ms = Date.parse(t.replace(" ", "T") + (hasZone ? "" : "Z"));
+  return Number.isFinite(ms) ? ms : null;
+}