@sleep2agi/commhub-server 0.9.0-preview.122 → 0.9.0-preview.124

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.122",
+  "version": "0.9.0-preview.124",
   "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and MCP tools (17 collaboration-core + node/provider ops tools; authoritative list: docs-site/docs/api/mcp-tools.md).",
   "type": "module",
   "main": "src/index.ts",

package/src/create-node-validate.ts

@@ -10,6 +10,7 @@
 import { isReservedEnvKey } from "./shared/reserved-env.js";
 import { checkNodeName } from "./shared/node-name.js";
 import { CODEX_CONFIG_ONLY_FLAG_KEYS, validateCodexConfigFlag } from "./codex-config-flags.js";
+import { validProviderInitialization } from './shared/provider-initialization.js';
 
 export class ValidationError extends Error {
   constructor(public code: string, public detail?: Record<string, unknown>) {
@@ -57,6 +58,7 @@ export const FLAG_KEYS = [
   "permissionMode", "dangerouslySkipPermissions", "maxTurns", "budget", "timeout",
   "copresence", "opencodeGeneration", "opencodeUnsafeTools",
   "approvalPolicy", "sandboxMode", "skipGitRepoCheck", "copresenceFullAccess", "modelReasoningEffort",
+  "daemonProvider",
 ] as const;
 
 /** #584 —— 只有这些 runtime 认 `flags.copresence`。目前只有 codex-app-server 的共存靠 config 字段
@@ -142,6 +144,9 @@ export function isValidTimeoutMs(v: unknown): v is number {
 
 export function validateFlagValue(k: string, v: unknown): void {
   switch (k) {
+    case 'daemonProvider':
+      if (!validProviderInitialization(v)) throw new ValidationError('flag_value_invalid', { field: k });
+      return;
     case "opencodeGeneration":
       if (v !== "v1" && v !== "v2") throw new ValidationError("flag_value_invalid", { field: k, reason: "must be v1 or v2" });
       return;
@@ -188,6 +193,9 @@ export function validateFlagValue(k: string, v: unknown): void {
  *  在别的 runtime 上收下它而什么都不做,就是又一个「选了共存、拿到无头」。 */
 export function validateFlagsForRuntime(runtime: string, flags: Record<string, unknown> | undefined | null): void {
   if (!flags) return;
+  if (flags.daemonProvider !== undefined && (runtime !== 'codex-app-server' || flags.copresence !== true)) {
+    throw new ValidationError('flag_not_applicable_to_runtime', { field: 'daemonProvider', runtime, applicable: ['codex-app-server copresence'] });
+  }
   // Strict flags envelope: old Hub/daemon reject these keys rather than dropping
   // unknown node_spec fields. Opt-in must be explicit on this create request.
   for (const field of ["opencodeGeneration", "opencodeUnsafeTools"]) {
@@ -386,6 +394,8 @@ export function buildAnetArgs(spec: NodeSpec): string[] {
   validateRuntime(spec.runtime);
   validateModel(spec.model);
   validateChannelsP1(spec.channels);
+  if (spec.flags?.daemonProvider !== undefined && (!validProviderInitialization(spec.flags.daemonProvider)
+    || spec.model !== spec.flags.daemonProvider.model)) throw new ValidationError('provider_create_model_mismatch');
 
   const args: string[] = ["node", "create", spec.name, "--runtime", spec.runtime];
   if (spec.model) args.push("--model", spec.model);
@@ -398,7 +408,7 @@ export function buildAnetArgs(spec: NodeSpec): string[] {
       // `anet node create --copresence` 是布尔开关,不吃值。
       if (k === "copresence") { if (v === true) args.push("--copresence"); continue; }
       if (k === "opencodeUnsafeTools") { if (v === true) args.push("--opencode-unsafe-tools"); continue; }
-      if (CODEX_CONFIG_ONLY_FLAG_KEYS.has(k)) continue;
+      if (CODEX_CONFIG_ONLY_FLAG_KEYS.has(k) || k === 'daemonProvider') continue;
       args.push(`--${kebab(k)}`, String(v));
     }
     validateFlagsForRuntime(spec.runtime, spec.flags);

package/src/daemon-provider-snapshots.test.ts

@@ -1,6 +1,6 @@
 import "./require-explicit-test-db";
 import { afterAll, beforeEach, expect, test } from "bun:test";
-import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, rmSync, chmodSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createHash } from 'node:crypto';
@@ -13,6 +13,7 @@ import { registerTools } from "./tools";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { reconcileProviderSnapshots, readLocalProviderSnapshot } from "../../agent-node/src/runtime/daemon-provider-snapshot";
 import { DaemonProviderStore } from "../../agent-network/src/daemon-provider-store";
+import { providerNodeRevision } from '../../agent-network/src/daemon-provider-application';
 import { register, createNetworkTokenForNode } from "./auth";
 
 const net = "net_dps906", user = "u_dps906", node = "node_dps906", token = "token_dps906", alias = "daemon906";
@@ -218,6 +219,56 @@ test('write core chain: encrypted Hub request → target daemon CLI → durable
   expect((await human('daemon_provider_snapshot', { action: 'put', id: node, network_id: net, revision: 1, provider })).error).toBe('provider_admin_required');
 });
 
+test('collection core chain: bound source → capable daemon CLI → durable replay → redacted Provider', async () => {
+  process.env.ANET_HUB_SECRET_VAULT_KEY = '42'.repeat(32);
+  const work = mkdtempSync(join(root, 'collect-')), dir = join(work, '.anet/nodes', alias);
+  const childId = 'n_collect906', childAlias = 'source906', source = join(work, '.anet/nodes', childAlias);
+  mkdirSync(dir, { recursive: true, mode: 0o700 }); mkdirSync(join(source, 'codex-home'), { recursive: true, mode: 0o700 });
+  writeFileSync(join(dir, 'config.json'), JSON.stringify({ role: 'host_supervisor', network_id: net, node_id: node }), { mode: 0o600 });
+  const key = 'TEST-ONLY-collect-private-key';
+  writeFileSync(join(source, 'config.json'), JSON.stringify({ node_id: childId, alias: childAlias, network_id: net,
+    runtime: 'codex-app-server', codexHome: join(source, 'codex-home'), env: { TEST_PROVIDER_KEY: { _envRef: 'TEST_PROVIDER_KEY' } } }), { mode: 0o600 });
+  writeFileSync(join(source, '.env'), `TEST_PROVIDER_KEY=${key}\n`, { mode: 0o600 });
+  writeFileSync(join(source, 'codex-home/config.toml'), 'model_provider = "deepseek"\nmodel = "fixture-model"\n[model_providers.deepseek]\nbase_url = "https://api.example.test/v1"\nenv_key = "TEST_PROVIDER_KEY"\nwire_api = "responses"\n', { mode: 0o600 });
+  db.run("INSERT INTO nodes (node_id,node_name,alias,network_id,runtime) VALUES (?1,?2,?2,?3,'codex-app-server')", [childId, childAlias, net]);
+  db.run("INSERT INTO node_daemon_bindings (request_id,network_id,node_id,daemon_node_id,workdir,requested_by,status,created_at,updated_at) VALUES ('binding_collect906',?1,?2,?3,?4,?5,'active',1,1)", [net, childId, node, work, user]);
+  const selection = { node_id: childId, alias: childAlias, node_revision: providerNodeRevision(source), provider_id: 'deepseek', auth_id: 'imported', label: 'DeepSeek' };
+  const before = providerNodeRevision(source), human = client(), daemon = client('daemon');
+  const requestArgs = { action: 'collect', id: node, network_id: net, revision: 0, provider: selection };
+  expect((await daemon('daemon_provider_snapshot', requestArgs)).error).toBe('user_token_required');
+  expect((await human('daemon_provider_snapshot', { ...requestArgs, provider: { ...selection, alias: 'another' } })).error).toBe('collection_target_not_bound');
+  expect((await human('daemon_provider_snapshot', { ...requestArgs, provider: { ...selection, key } })).error).toBe('invalid_provider_collection');
+  const r = await human('daemon_provider_snapshot', requestArgs); expect(r.ok).toBe(true);
+  expect((await daemon('pull_daemon_provider_snapshots', { accept_writes: true })).requests).toEqual([]);
+  expect((await daemon('pull_daemon_provider_snapshots', { accept_collections: true })).requests[0]).toMatchObject({ operation: 'collect', selection });
+  let drop = true;
+  const deps = { workDir: work, alias, networkId: net, daemonId: node, serverUrl: 'https://hub.example.test', warn: () => {},
+    callCommHub: async (name: string, args: any) => {
+      expect(JSON.stringify(args)).not.toContain(key);
+      if (name === 'ack_daemon_provider_snapshot' && drop) { drop = false; throw Error('lost acknowledgement'); }
+      return daemon(name, args);
+    } };
+  await reconcileProviderSnapshots(deps);
+  expect(new DaemonProviderStore(dir).list().revision).toBe(1);
+  await reconcileProviderSnapshots(deps);
+  const read = await human('daemon_provider_snapshot', { action: 'read', id: r.request_id, network_id: net });
+  expect(read.status).toBe('succeeded'); expect(read.snapshot.revision).toBe(1);
+  expect(read.snapshot.providers[0].runtimes[0].auth[0]).toMatchObject({ id: 'imported', kind: 'api_key', models: ['fixture-model'], credential_present: true, verification: 'not_checked', application: 'not_applied' });
+  expect(JSON.stringify(read)).not.toContain(key);
+  expect(db.get('SELECT * FROM daemon_provider_writes WHERE request_id=?1', r.request_id)).toBeNull();
+  expect(providerNodeRevision(source)).toBe(before); // source config/session/credential is never changed
+  const stale = await human('daemon_provider_snapshot', { ...requestArgs, revision: 1, provider: { ...selection, auth_id: 'second' } });
+  db.run("UPDATE node_daemon_bindings SET daemon_node_id='other' WHERE request_id='binding_collect906'");
+  expect((await daemon('pull_daemon_provider_snapshots', { accept_collections: true })).requests).toEqual([]);
+  expect((await human('daemon_provider_snapshot', { action: 'read', id: stale.request_id, network_id: net })).error).toBe('collection_target_not_bound');
+});
+
+test('collection intent contract mirrors CLI, daemon and Hub exactly', () => {
+  const hub = readFileSync(new URL('./shared/provider-collection.ts', import.meta.url), 'utf8');
+  expect(hub).toBe(readFileSync(new URL('../../agent-node/src/shared/provider-collection.ts', import.meta.url), 'utf8'));
+  expect(hub).toBe(readFileSync(new URL('../../agent-network/src/shared/provider-collection.ts', import.meta.url), 'utf8'));
+});
+
 test("human authorization precedes dispatch; unknown, nodes and non-admins cannot request", async () => {
   expect((await client("anonymous")("daemon_provider_snapshot", { action: "refresh", network_id: net, id: node })).error).toBe("user_token_required");
   expect((await client("daemon")("daemon_provider_snapshot", { action: "refresh", network_id: net, id: node })).ok).toBe(false);
@@ -320,15 +371,17 @@ test("real HTTP authentication -> daemon handler -> pinned CLI -> scoped public
   db.run("UPDATE nodes SET config_snapshot=?1 WHERE node_id=?2", [JSON.stringify({ role: "host_supervisor" }), nodeId]);
   const dir = join(root, ".anet/nodes", daemonAlias); mkdirSync(dir, { recursive: true, mode: 0o700 });
   writeFileSync(join(dir, "config.json"), JSON.stringify({ role: "host_supervisor", network_id: netId, node_id: nodeId }), { mode: 0o600 });
-  for (const child of ['bound', 'neighbour']) {
+  for (const child of ['bound', 'neighbour', 'manual']) {
     const childId = `n_scan_${child}`;
     db.run('INSERT INTO nodes (node_id,node_name,alias,network_id,runtime) VALUES (?1,?2,?2,?3,\'codex-app-server\')', [childId, child, netId]);
-    db.run('INSERT INTO node_daemon_bindings (request_id,network_id,node_id,daemon_node_id,workdir,requested_by,status,created_at,updated_at) VALUES (?1,?2,?3,?4,?5,?6,\'active\',1,1)',
+    if (child !== 'manual') db.run('INSERT INTO node_daemon_bindings (request_id,network_id,node_id,daemon_node_id,workdir,requested_by,status,created_at,updated_at) VALUES (?1,?2,?3,?4,?5,?6,\'active\',1,1)',
       [`binding_scan_${child}`, netId, childId, child === 'bound' ? nodeId : 'another-daemon', root, owner.user!.user_id]);
     const home = join(root, '.anet/nodes', child, 'codex-home'); mkdirSync(home, { recursive: true, mode: 0o700 });
     writeFileSync(join(home, '../config.json'), JSON.stringify({ node_id: childId, alias: child, runtime: 'codex-app-server', network_id: netId }), { mode: 0o600 });
     writeFileSync(join(home, 'config.toml'), 'model_provider = "deepseek"\nmodel = "fixture-model"\n[model_providers.deepseek]\nenv_key = "TEST_API_KEY"\n', { mode: 0o600 });
   }
+  chmodSync(join(root, '.anet'), 0o700);
+  chmodSync(join(root, '.anet/nodes'), 0o775);
   const hub = (await import("./server")).bootServer({ port: 0, hostname: "127.0.0.1" });
   const url = `http://127.0.0.1:${hub.port}/mcp`;
   const rpc = (credential: string) => async (name: string, args: any) => {
@@ -352,6 +405,15 @@ test("real HTTP authentication -> daemon handler -> pinned CLI -> scoped public
     expect(read.status).toBe("succeeded"); expect(read.snapshot).toMatchObject({ network_id: netId, daemon_node_id: nodeId, revision: 0, source: "daemon", providers: [], codex_inventory: { scope: 'hub_bound_nodes' } });
     expect(read.snapshot.codex_inventory.rows).toHaveLength(1);
     expect(read.snapshot.codex_inventory.rows[0]).toMatchObject({ node_id: 'n_scan_bound', configured_provider: 'deepseek', configured_model: 'fixture-model', credential_status: 'unknown' });
+    expect(read.snapshot.codex_inventory.local_discovery).toBeUndefined(); // old client projection
+    const discovered = await human('daemon_provider_snapshot', { action: 'read', id: refresh.request_id, network_id: netId, include_discovery: true });
+    expect(discovered.snapshot.codex_inventory.local_discovery).toMatchObject({ status: 'observed', rows: [
+      { node_id: 'n_scan_manual', alias: 'manual', configured_model: 'fixture-model', config_revision: null },
+    ] });
+    expect(discovered.snapshot.codex_inventory.local_discovery.rows).toHaveLength(1); // other daemon filtered
+    const deniedApply = await human('daemon_provider_snapshot', { action: 'apply', id: nodeId, network_id: netId, revision: 0,
+      provider: { node_id: 'n_scan_manual', node_revision: 'a'.repeat(64), provider_id: 'deepseek', auth_id: 'key', model: 'fixture-model', confirm_restart: true } });
+    expect(deniedApply).toMatchObject({ ok: false, error: 'application_target_not_bound' });
     const foreign = await human('daemon_provider_snapshot', { action: 'refresh', id: nodeId, network_id: netId });
     const bad = structuredClone(read.snapshot); bad.codex_inventory.rows[0].node_id = 'n_scan_neighbour';
     expect((await daemon('ack_daemon_provider_snapshot', { request_id: foreign.request_id, snapshot: bad })).ok).toBe(false);

package/src/daemon-provider-snapshots.ts

@@ -9,6 +9,7 @@ import { encryptSecret, decryptSecret, VaultError } from './vault';
 import { buildControllableMap } from './node-lifecycle-controllable';
 import { validProviderApplicationSelection, validProviderApplicationReceipt, type ProviderApplicationSelection } from './shared/provider-application';
 import { validLoginIntent, validLoginReceipt } from './shared/daemon-provider-login';
+import { validProviderCollection, type ProviderCollection } from './shared/provider-collection';
 
 export function providerScanTargets(networkId: string, daemonId: string) {
   const ownership = buildControllableMap(
@@ -95,8 +96,37 @@ function privateWrite(requestId: string, networkId: string, daemonId: string) {
   if (!row) return null;
   const payload = JSON.parse(decryptSecret({ ciphertext: Buffer.from(row.ciphertext), iv: Buffer.from(row.iv), tag: Buffer.from(row.tag) }));
   if (payload.network_id !== networkId || payload.daemon_node_id !== daemonId) throw new Error('scope_mismatch');
+  if (payload.operation === 'collect') {
+    if (!validProviderCollection(payload.selection)) throw Error('invalid_provider_collection');
+    return { expected_revision: row.expected_revision, operation: 'collect' as const, selection: payload.selection };
+  }
   validateWrite(payload.provider, networkId, daemonId);
-  return { expected_revision: row.expected_revision, provider: payload.provider };
+  return { expected_revision: row.expected_revision, operation: 'put' as const, provider: payload.provider };
+}
+function boundCollectionTarget(networkId: string, daemonId: string, selection: ProviderCollection) {
+  return selection.node_id !== daemonId && providerScanTargets(networkId, daemonId)
+    .some(n => n.node_id === selection.node_id && n.alias === selection.alias);
+}
+export function requestProviderCollection(h: Human, daemonId: string, revision: number, selection: unknown) {
+  const refusal = authorize(h); if (refusal) return refusal;
+  if (!daemonExists(h.networkId!, daemonId)) return denied('daemon_not_found');
+  if (!Number.isSafeInteger(revision) || revision < 0 || revision >= Number.MAX_SAFE_INTEGER) return denied('invalid_revision');
+  if (!validProviderCollection(selection)) return denied('invalid_provider_collection');
+  try {
+    if (!boundCollectionTarget(h.networkId!, daemonId, selection)) return denied('collection_target_not_bound');
+    expire(h.networkId!, daemonId);
+    if (db.get("SELECT request_id FROM daemon_provider_snapshots WHERE network_id=?1 AND daemon_node_id=?2 AND status='pending'", h.networkId!, daemonId)) return denied('provider_snapshot_busy');
+    // Reuse the short-lived write queue, but no credential is supplied to Hub.
+    const enc = encryptSecret(JSON.stringify({ network_id: h.networkId, daemon_node_id: daemonId, operation: 'collect', selection }));
+    const requestId = `dps_${randomUUID()}`, now = Date.now();
+    db.transaction(() => {
+      db.run("INSERT INTO daemon_provider_snapshots (request_id,network_id,daemon_node_id,requested_by,status,created_at,expires_at) VALUES (?1,?2,?3,?4,'pending',?5,?6)",
+        [requestId, h.networkId!, daemonId, h.userId!, now, now + 120_000]);
+      db.run('INSERT INTO daemon_provider_writes (request_id,expected_revision,ciphertext,iv,tag) VALUES (?1,?2,?3,?4,?5)',
+        [requestId, revision, enc.ciphertext, enc.iv, enc.tag]);
+    });
+    return { ok: true as const, request_id: requestId, status: 'pending', expires_at: now + 120_000 };
+  } catch (error) { return denied(error instanceof VaultError ? error.code : 'provider_collection_unavailable'); }
 }
 function applicationIntent(requestId: string) {
   const row = db.get<{ expected_revision: number; selection_json: string }>('SELECT * FROM daemon_provider_applications WHERE request_id=?1', requestId);
@@ -156,18 +186,21 @@ export function requestProviderLogin(h: Human, daemonId: string, intent: unknown
     return { ok: true as const, request_id: requestId, status: 'pending', expires_at: now + 120_000 };
   } catch { return denied('provider_snapshot_busy'); }
 }
-export function getProviderSnapshot(h: Human, requestId: string) {
+export function getProviderSnapshot(h: Human, requestId: string, includeDiscovery = false) {
   const refusal = authorize(h); if (refusal) return refusal;
   expire(h.networkId!);
   const row = db.get<Row>(`SELECT * FROM daemon_provider_snapshots WHERE request_id=?1 AND network_id=?2`, requestId, h.networkId!);
   if (!row) return denied("request_not_found");
+  const snapshot = !/^dp[al]_/.test(row.request_id) && row.snapshot_json ? JSON.parse(row.snapshot_json) : null;
+  // Old clients validate an exact contract. Their default projection stays unchanged.
+  if (!includeDiscovery && snapshot?.codex_inventory) delete snapshot.codex_inventory.local_discovery;
   return { ok: true, request_id: row.request_id, daemon_node_id: row.daemon_node_id, status: row.status,
     expires_at: row.expires_at, observed_at: row.observed_at, error: row.error,
-    snapshot: !/^dp[al]_/.test(row.request_id) && row.snapshot_json ? JSON.parse(row.snapshot_json) : null,
+    snapshot,
     ...(row.request_id.startsWith('dpl_') ? { login: row.snapshot_json ? JSON.parse(row.snapshot_json) : null } : {}),
     ...(row.request_id.startsWith('dpa_') ? { application: row.snapshot_json ? JSON.parse(row.snapshot_json) : null } : {}) };
 }
-export function pullProviderSnapshots(d: Daemon, acceptWrites = false, acceptApplications = false, acceptLogins = false) {
+export function pullProviderSnapshots(d: Daemon, acceptWrites = false, acceptApplications = false, acceptLogins = false, acceptDiscovery = false, acceptCollections = false) {
   if (!d.ok) return denied("caller_not_a_daemon");
   if (!daemonExists(d.networkId, d.daemonNodeId)) return denied("caller_not_a_daemon");
   expire(d.networkId, d.daemonNodeId);
@@ -192,9 +225,16 @@ export function pullProviderSnapshots(d: Daemon, acceptWrites = false, acceptApp
       }
       return [{ ...r, operation: 'apply', ...application!, alias: target.alias }];
     }
-    if (!acceptWrites && db.get('SELECT request_id FROM daemon_provider_writes WHERE request_id=?1', r.request_id)) return [];
     const write = privateWrite(r.request_id, d.networkId, d.daemonNodeId);
-    return [write ? { ...r, operation: 'put', ...write } : { ...r, scan_targets: providerScanTargets(d.networkId, d.daemonNodeId) }];
+    if (write?.operation === 'collect') {
+      if (!acceptCollections) return []; // old write-capable daemons cannot consume collection as put/scan
+      if (!boundCollectionTarget(d.networkId, d.daemonNodeId, write.selection)) {
+        db.run("UPDATE daemon_provider_snapshots SET status='failed',error='collection_target_not_bound',observed_at=?1 WHERE request_id=?2 AND status='pending'", [Date.now(), r.request_id]);
+        db.run('DELETE FROM daemon_provider_writes WHERE request_id=?1', [r.request_id]);
+        return [];
+      }
+    } else if (write && !acceptWrites) return [];
+    return [write ? { ...r, ...write } : { ...r, scan_targets: providerScanTargets(d.networkId, d.daemonNodeId), ...(acceptDiscovery ? { discover_local: true } : {}) }];
   }) }; } catch { return denied('provider_write_unavailable'); }
 }
 export function ackProviderSnapshot(d: Daemon, requestId: string, snapshot?: unknown, failed = false, appliedRevision?: number, application?: unknown, login?: unknown) {
@@ -244,6 +284,16 @@ export function ackProviderSnapshot(d: Daemon, requestId: string, snapshot?: unk
         const targets = new Map(providerScanTargets(d.networkId, d.daemonNodeId).map(n => [n.node_id, n.alias]));
         const rows = (safe as any).codex_inventory.rows;
         if (rows.length !== targets.size || rows.some((r: any) => targets.get(r.node_id) !== r.alias)) return denied('invalid_provider_snapshot');
+        const local = (safe as any).codex_inventory.local_discovery;
+        if (local) {
+          const registered = new Map(db.all<{ node_id: string; alias: string }>('SELECT node_id,alias FROM nodes WHERE network_id=?1', d.networkId).map(n => [n.node_id, n.alias]));
+          const ownership = buildControllableMap(
+            db.all<{ request_id: string; daemon_node_id: string }>('SELECT request_id,daemon_node_id FROM node_create_requests WHERE network_id=?1', d.networkId),
+            db.all<{ node_id: string; daemon_node_id: string }>("SELECT node_id,daemon_node_id FROM node_daemon_bindings WHERE network_id=?1 AND status='active'", d.networkId));
+          // Filesystem discovery is not control authority. Other-daemon and
+          // unregistered identities cannot enter this network's public receipt.
+          local.rows = local.rows.filter((r: any) => registered.get(r.node_id) === r.alias && !ownership.has(r.node_id));
+        }
       } catch { return denied('invalid_provider_snapshot'); }
     }
     try {
@@ -251,12 +301,20 @@ export function ackProviderSnapshot(d: Daemon, requestId: string, snapshot?: unk
       if (write) {
         const actual = safe as any;
         if (appliedRevision !== write.expected_revision + 1 || actual.revision !== appliedRevision) return denied('provider_write_unconfirmed');
+        if (write.operation === 'collect') {
+          if (!boundCollectionTarget(d.networkId, d.daemonNodeId, write.selection)) return denied('collection_target_not_bound');
+          const saved = actual.providers.find((p: any) => p.id === write.selection.provider_id);
+          const auth = saved?.runtimes.find((r: any) => r.runtime === 'codex-tui')?.auth.find((a: any) => a.id === write.selection.auth_id);
+          if (saved?.label !== write.selection.label.trim() || auth?.kind !== 'api_key' || auth.credential_present !== true
+            || auth.models.length !== 1 || auth.verification !== 'not_checked' || auth.application !== 'not_applied') return denied('provider_write_unconfirmed');
+        } else {
         const expected = validateWrite(write.provider, d.networkId, d.daemonNodeId);
         const saved = actual.providers.find((p: any) => p.id === expected.id);
         // CLI canonicalizes label and endpoint. No credential is compared or returned here.
         expected.label = expected.label.trim();
         for (const r of expected.runtimes) for (const a of r.auth) if (a.baseUrl) a.baseUrl = new URL(a.baseUrl).toString().replace(/\/$/, '');
         if (!isDeepStrictEqual(saved, expected)) return denied('provider_write_unconfirmed');
+        }
       }
     } catch { return denied('provider_write_unconfirmed'); }
   }

package/src/daemon-token-owner-http.test.ts

@@ -80,7 +80,8 @@ test("name-only issuance checks existing ownership atomically", async () => {
 });
 
 // Every daemon-facing handler must fail at the shared identity boundary,
-// not incidentally at request lookup or argument validation.
+// not incidentally at request lookup or argument validation. The resolver
+// mutation expects all 15 of these cases to go red together.
 const endpoints: [string, Record<string, unknown>][] = [
   ["list_my_pending_create_requests", {}], ["list_my_pending_lifecycle_requests", {}],
   ["get_create_request", { request_id: "cr_fixture_absent" }],
@@ -92,6 +93,8 @@ const endpoints: [string, Record<string, unknown>][] = [
   ["list_my_children", {}], ["get_adopt_request", {}], ["ack_adopt_request", { status: "adopted" }],
   ["get_probe_request", { probe_id: "probe_fixture_absent" }],
   ["ack_probe_request", { probe_id: "probe_fixture_absent", status: "ok", latency_ms: 1 }],
+  ["get_opencode_catalog_request", { request_id: "cat_fixture_absent" }],
+  ["ack_opencode_catalog", { request_id: "cat_fixture_absent", error: "unavailable" }],
 ];
 for (const [name, arguments_] of endpoints) {
   test(`daemon identity boundary: ${name}`, async () => {

package/src/db.ts

@@ -936,6 +936,19 @@ db.exec(`
   );
   CREATE INDEX IF NOT EXISTS idx_providers_network ON providers(network_id);
 `);
+// #907 network-owned Provider configuration. Keys remain in network_secrets.
+db.exec(`
+  CREATE TABLE IF NOT EXISTS hub_provider_configs (
+    network_id TEXT NOT NULL, provider_id TEXT NOT NULL, revision INTEGER NOT NULL,
+    config_json TEXT NOT NULL, secret_key_ref TEXT NOT NULL, updated_at INTEGER NOT NULL,
+    PRIMARY KEY(network_id, provider_id)
+  );
+  CREATE TABLE IF NOT EXISTS hub_provider_bindings (
+    request_id TEXT PRIMARY KEY, network_id TEXT NOT NULL, provider_id TEXT NOT NULL,
+    provider_revision INTEGER NOT NULL, daemon_node_id TEXT NOT NULL,
+    daemon_provider_id TEXT NOT NULL, created_at INTEGER NOT NULL
+  );
+`);
 db.exec(`
   CREATE TABLE IF NOT EXISTS provider_models (
     model_id        TEXT PRIMARY KEY,

package/src/hub-provider-config.test.ts

@@ -0,0 +1,79 @@
+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 { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { reconcileProviderSnapshots } from '../../agent-node/src/runtime/daemon-provider-snapshot';
+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('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,98 @@
+// #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'].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 u.protocol === 'https:' && !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) {
+  const config = JSON.parse(stored.config_json) as Config;
+  return { ...config, 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) {
+  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, providers: rows.map(r => publicRow(h.networkId!, r)) };
+}
+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 };
+  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');
+  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 && (!old || previous?.baseUrl !== value.baseUrl || previous?.protocol !== value.protocol)) return denied('provider_key_required');
+  const ref = old?.secret_key_ref ?? `HUB_PROVIDER_${createHash('sha256').update(JSON.stringify([h.networkId, value.id])).digest('hex').slice(0, 32).toUpperCase()}`;
+  const { key, ...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,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)!) };
+  } 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/mcp-context-cost-http.test.ts

@@ -26,9 +26,10 @@ if (!activeDbPath) throw new Error("mcp-context-cost requires COMMHUB_DB (or COM
  * 加工具或加说明超过它,就在这里改数字并在 PR 里说为什么。
  */
 // Board #625: two human adoption tools; measured 58 tools / 56,615 B.
-// Hub #938 clone_node is audience both, so this user-token list grows.
-// Measured with #906's tools plus clone_node: 60 tools / 58,169 B. Ceiling keeps ~431 B.
-const TOOLS_LIST_MAX_BYTES = 58_600;
+// Hub #938 clone_node is audience both (60 tools / 58,169 B). OpenCode V2
+// catalog adds read_opencode_catalog and get_opencode_catalog on that user
+// list. Measured together: 62 tools / 59,409 B. Ceiling keeps ~401 B.
+const TOOLS_LIST_MAX_BYTES = 59_810;
 /** 单个工具(名字 + 描述 + 输入 schema)的上限;最大的是 report_status(节点心跳,~8.4 KB 的遥测结构)。 */
 const TOOL_MAX_BYTES = 9_000;
 /** 单条工具描述的上限(说明写进参数的 describe,或者拆短)。 */

package/src/node-permissions.ts

@@ -254,6 +254,7 @@ export const NODE_TOOL_CLASS: Readonly<Record<string, ToolClass>> = {
   get_config_update: "always", ack_config_update: "always", get_rules_file_request: "always", ack_rules_file_request: "always", get_rules_file_result: "always",
   get_create_request: "always", ack_create_request: "always", get_stop_request: "always", ack_stop_request: "always",
   get_start_request: "always", ack_start_request: "always", get_probe_request: "always", ack_probe_request: "always",
+  get_opencode_catalog_request: "always", ack_opencode_catalog: "always",
   list_my_pending_create_requests: "always", list_my_pending_lifecycle_requests: "always", list_my_children: "always",
   request_adopt_node: "human_only", unadopt_node: "human_only",
   get_adopt_request: "always", ack_adopt_request: "always",
@@ -280,4 +281,5 @@ export const NODE_TOOL_CLASS: Readonly<Record<string, ToolClass>> = {
   // 只有人能做
   upsert_network_secret: "human_only", upsert_provider: "human_only", update_provider: "human_only",
   projects_create: "human_only", projects_update: "human_only", review_skill: "human_only",
+  read_opencode_catalog: "human_only", get_opencode_catalog: "human_only",
 };