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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.123",
+  "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

@@ -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);

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);
@@ -170,7 +200,7 @@ export function getProviderSnapshot(h: Human, requestId: string, includeDiscover
     ...(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, acceptDiscovery = 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);
@@ -195,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), ...(acceptDiscovery ? { discover_local: true } : {}) }];
+    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) {
@@ -264,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/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/shared/provider-collection.ts

@@ -0,0 +1,14 @@
+// #906 intent contains identifiers only. API keys remain on the owning daemon.
+export type ProviderCollection = {
+  node_id: string; alias: string; node_revision: string;
+  provider_id: string; auth_id: string; label: string;
+};
+const id = (v: unknown) => typeof v === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(v);
+export function validProviderCollection(v: any): v is ProviderCollection {
+  return !!v && typeof v === 'object' && !Array.isArray(v)
+    && Object.keys(v).every(k => ['node_id', 'alias', 'node_revision', 'provider_id', 'auth_id', 'label'].includes(k))
+    && id(v.node_id) && id(v.provider_id) && id(v.auth_id)
+    && typeof v.alias === 'string' && /^[\p{L}\p{N}][\p{L}\p{N}_.-]{0,99}$/u.test(v.alias)
+    && typeof v.node_revision === 'string' && /^[a-f0-9]{64}$/.test(v.node_revision)
+    && typeof v.label === 'string' && !!v.label.trim() && v.label.length <= 100 && !/[\x00-\x1f\x7f]/.test(v.label);
+}

package/src/shared/provider-initialization.ts

@@ -0,0 +1,8 @@
+export type ProviderInitialization = { revision: number; provider_id: string; auth_id: string; model: string };
+export function validProviderInitialization(value: any): value is ProviderInitialization {
+  const id = (v: unknown) => typeof v === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(v);
+  return !!value && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).every(key => ['revision', 'provider_id', 'auth_id', 'model'].includes(key))
+    && Number.isSafeInteger(value.revision) && value.revision >= 0 && id(value.provider_id) && id(value.auth_id)
+    && typeof value.model === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,99}$/.test(value.model);
+}

package/src/tools.ts

@@ -1,5 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { requestProviderSnapshot, requestProviderWrite, requestProviderApplication, requestProviderLogin, getProviderSnapshot, pullProviderSnapshots, ackProviderSnapshot } from "./daemon-provider-snapshots.js";
+import { requestProviderSnapshot, requestProviderWrite, requestProviderCollection, requestProviderApplication, requestProviderLogin, getProviderSnapshot, pullProviderSnapshots, ackProviderSnapshot } from "./daemon-provider-snapshots.js";
+import { readHubProviders, putHubProvider, bindHubProvider } from './hub-provider-config.js';
 import { requestAdopt, getAdopt, ackAdopt, unadopt, resolveManagedDaemon, activeBinding, createdDaemon } from "./node-daemon-bindings.js";
 import { runtimeReadinessSchema } from "./runtime-readiness.js";
 import { adoptionCandidatesReportSchema } from "./adoption-candidates.js";
@@ -4128,13 +4129,25 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
   const providerHuman = (net?: string) => ({ userId: enforceUserId, isNode: callerTokenIsNetwork, networkId: getNetworkId(net) });
   const providerReply = (value: unknown) => ({ content: [{ type: "text" as const, text: JSON.stringify(value) }] });
   server.tool(
-    "daemon_provider_snapshot", "Admin Provider: refresh/put/apply/login use daemon id; read uses request id. put: revision+provider; apply: revision+node selection; login: provider={action:start|read|cancel|save|accounts,session_id?,label?}. No login tokens.",
-    { action: z.enum(["refresh", "read", "put", "apply", "login"]), id: z.string().min(1).max(200), network_id: z.string().max(200).optional(), revision: z.number().int().min(0).optional(), provider: z.unknown().optional(), include_discovery: z.boolean().optional() },
+    "daemon_provider_snapshot", "Provider: daemon refresh/put/collect/apply/login; read=request id. login provider={action:start|read|cancel|save|accounts,session_id?,label?}. hub_read=catalog; hub_put=owner config; hub_bind=id+revision,provider={daemon_node_id,daemon_revision,confirm:true}. No login tokens.",
+    { action: z.enum(["refresh", "read", "put", "collect", "apply", "login", "hub_read", "hub_put", "hub_bind"]), id: z.string().min(1).max(200), network_id: z.string().max(200).optional(), revision: z.number().int().min(0).optional(), provider: z.unknown().optional(), include_discovery: z.boolean().optional() },
     async ({ action, id, network_id, revision, provider, include_discovery }) => {
       const human = providerHuman(network_id);
+      if (action === 'hub_read') return providerReply(readHubProviders(human));
+      if (action === 'hub_put') return providerReply(putHubProvider(human, revision!, provider));
+      if (action === 'hub_bind') {
+        const selection = provider as { daemon_node_id?: string; daemon_revision?: number; confirm?: boolean } | undefined;
+        const result = bindHubProvider(human, { id, revision: revision!, daemon_node_id: selection?.daemon_node_id!, daemon_revision: selection?.daemon_revision!, confirm: selection?.confirm! });
+        if (result.ok && 'request_id' in result) {
+          const target = db.get<{ alias: string }>('SELECT alias FROM nodes WHERE node_id=?1 AND network_id=?2', selection?.daemon_node_id!, human.networkId!);
+          if (target) pushEvent(target.alias, { type: 'daemon_provider_snapshot', request_id: result.request_id }, human.networkId!);
+        }
+        return providerReply(result);
+      }
       if (action === "read") return providerReply(getProviderSnapshot(human, id, include_discovery));
       const daemon_node_id = id;
       const result = action === 'login' ? requestProviderLogin(human, daemon_node_id, provider)
+        : action === 'collect' ? requestProviderCollection(human, daemon_node_id, revision!, provider)
         : action === 'apply' ? requestProviderApplication(human, daemon_node_id, revision!, provider)
         : action === 'put' ? requestProviderWrite(human, daemon_node_id, revision!, provider) : requestProviderSnapshot(human, daemon_node_id);
       if (result.ok) {
@@ -4145,8 +4158,8 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
     },
   );
   server.tool(
-    "pull_daemon_provider_snapshots", "Daemon Provider work; advertise only implemented secure write/apply/login capabilities.", { accept_writes: z.boolean().optional(), accept_applications: z.boolean().optional(), accept_logins: z.boolean().optional(), accept_local_discovery: z.boolean().optional() },
-    async ({ accept_writes, accept_applications, accept_logins, accept_local_discovery }) => providerReply(pullProviderSnapshots(resolveCallerDaemonTokenBound(), accept_writes, accept_applications, accept_logins, accept_local_discovery)),
+    "pull_daemon_provider_snapshots", "Daemon Provider work; advertise only implemented secure write/collect/apply/login capabilities.", { accept_writes: z.boolean().optional(), accept_applications: z.boolean().optional(), accept_logins: z.boolean().optional(), accept_local_discovery: z.boolean().optional(), accept_collections: z.boolean().optional() },
+    async ({ accept_writes, accept_applications, accept_logins, accept_local_discovery, accept_collections }) => providerReply(pullProviderSnapshots(resolveCallerDaemonTokenBound(), accept_writes, accept_applications, accept_logins, accept_local_discovery, accept_collections)),
   );
   server.tool(
     "ack_daemon_provider_snapshot", "Target daemon acknowledges redacted Provider configuration readback; fixed failure code only.",