c0de-agent 1.10.0 → 1.12.0

package/dist/server/auth-manager.js

@@ -0,0 +1,289 @@
+// src/server/auth-manager.ts
+// P2-16：认证 token 轮换 + 新设备配对审批。
+//
+// 安全模型（基于用户决策：URL token / shell history 不可视为安全）：
+//   - bootstrap token（auth-token 文件 / security.token / C0DE_AUTH_TOKEN）只用于
+//     「首次设备注册」：首个设备凭 bootstrap 换发设备 token 后，bootstrap 立即轮换失效。
+//   - 所有 API/WS 请求只认设备 token（sha256 哈希存储）。
+//   - 新设备无有效 token 时走配对流程：请求配对码 → 已授权设备审批 → 下发设备 token。
+//   - 显式配置 security.token 时为静态模式：不轮换、不配对（CI/脚本场景）。
+//   - authEnabled=false 时不启用。
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, statSync, watch, writeFileSync, } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+const DEVICES_FILENAME = 'devices.json';
+/** 首设备 bootstrap token 默认有效期：5 分钟。缩短「URL 泄漏后抢先注册」竞态窗口。
+ *  重新 `c0de serve` 会重新生成 bootstrap（无已注册设备时），刷新该窗口。 */
+const DEFAULT_FIRST_DEVICE_TTL_MS = 5 * 60 * 1000;
+function hashToken(token) {
+    return createHash('sha256').update(token).digest('hex');
+}
+function safeEqual(a, b) {
+    const ba = Buffer.from(a);
+    const bb = Buffer.from(b);
+    if (ba.length !== bb.length)
+        return false;
+    return timingSafeEqual(ba, bb);
+}
+export function createAuthManager(opts) {
+    const { dataDir, staticToken, tokenFilePath, now = Date.now } = opts;
+    const pairingTtlMs = opts.pairingTtlMs ?? 10 * 60 * 1000;
+    const firstDeviceTtlMs = opts.firstDeviceTtlMs ?? DEFAULT_FIRST_DEVICE_TTL_MS;
+    const tokenPath = tokenFilePath ?? join(dataDir, 'auth-token');
+    const devicesPath = join(dataDir, DEVICES_FILENAME);
+    // ── 状态加载 ──
+    let bootstrap = staticToken && staticToken.length > 0 ? staticToken : readBootstrapToken(tokenPath);
+    const devices = new Map();
+    loadDevices();
+    const pending = new Map();
+    function readBootstrapToken(path) {
+        try {
+            if (!existsSync(path))
+                return undefined;
+            const t = readFileSync(path, 'utf-8').trim();
+            return t.length > 0 ? t : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    function loadDevices() {
+        devices.clear();
+        try {
+            if (!existsSync(devicesPath))
+                return;
+            const raw = JSON.parse(readFileSync(devicesPath, 'utf-8'));
+            for (const d of raw.devices ?? []) {
+                if (d && typeof d.id === 'string' && typeof d.tokenHash === 'string') {
+                    devices.set(d.id, d);
+                }
+            }
+        }
+        catch {
+            // 注册表损坏：视为空（设备需重新配对/注册）
+        }
+    }
+    // 热重载：CLI `c0de auth revoke/reset` 或手工编辑 devices.json 后立即生效。
+    // 监听目录而非文件——文件可能尚不存在（首启），persist/revoke 会创建它。
+    // 自身 persist 写入也会触发一次无伤重载。
+    let watcher;
+    try {
+        watcher = watch(dirname(devicesPath), (_event, filename) => {
+            if (filename === basename(devicesPath))
+                loadDevices();
+        });
+        // 不让 watcher 独占事件循环（测试/短生命周期进程可正常退出）
+        watcher.unref();
+    }
+    catch {
+        // 目录不可 watch（极端环境）：降级为仅启动时加载
+    }
+    function persist() {
+        try {
+            if (!existsSync(dataDir))
+                mkdirSync(dataDir, { recursive: true });
+            const file = {
+                version: 1,
+                devices: Array.from(devices.values()),
+            };
+            writeFileSync(devicesPath, JSON.stringify(file, null, 2), 'utf-8');
+        }
+        catch {
+            // 持久化失败不致命（内存态继续有效，重启后需重新注册）
+        }
+    }
+    /** 轮换 bootstrap：写入新 token 文件并保留历史（handoff 用）。 */
+    function rotateBootstrap() {
+        if (staticToken && staticToken.length > 0)
+            return; // 静态模式不轮换
+        bootstrap = randomBytes(32).toString('hex');
+        try {
+            if (!existsSync(dataDir))
+                mkdirSync(dataDir, { recursive: true });
+            writeFileSync(tokenPath, bootstrap, 'utf-8');
+        }
+        catch {
+            // 写文件失败：内存 token 仍已轮换，进程内一致
+        }
+    }
+    function verifyDeviceToken(token) {
+        const h = hashToken(token);
+        for (const d of devices.values()) {
+            if (safeEqual(d.tokenHash, h))
+                return true;
+        }
+        return false;
+    }
+    function verifyBootstrap(token) {
+        if (!token || !bootstrap)
+            return false;
+        return safeEqual(token, bootstrap);
+    }
+    /** bootstrap 自生成（token 文件 mtime）起的存活时长；静态模式或无法读取返回 null。 */
+    function bootstrapAge() {
+        if (staticToken && staticToken.length > 0)
+            return null;
+        try {
+            return now() - statSync(tokenPath).mtimeMs;
+        }
+        catch {
+            return null;
+        }
+    }
+    function cleanExpiredPairings() {
+        const cutoff = now() - pairingTtlMs;
+        for (const [id, p] of pending) {
+            if (p.status === 'pending' && p.createdAt <= cutoff) {
+                pending.delete(id);
+            }
+        }
+    }
+    return {
+        get bootstrap() {
+            return bootstrap;
+        },
+        verify(token) {
+            if (!token)
+                return false;
+            if (staticToken && staticToken.length > 0)
+                return safeEqual(token, staticToken);
+            return verifyDeviceToken(token);
+        },
+        verifyHandoff(token) {
+            if (!token)
+                return false;
+            if (verifyDeviceToken(token))
+                return true;
+            if (verifyBootstrap(token))
+                return true;
+            return false;
+        },
+        async registerFirstDevice(bootstrapToken, deviceName) {
+            if (staticToken && staticToken.length > 0)
+                return null; // 静态模式无设备注册
+            if (!verifyBootstrap(bootstrapToken))
+                return null;
+            // 已有设备 → bootstrap 已失效，不得再凭它注册（需配对审批）
+            if (devices.size > 0)
+                return null;
+            // 首设备注册窗口：bootstrap 超过 firstDeviceTtlMs 后拒绝（缩短先到先得竞态窗口）。
+            if (firstDeviceTtlMs > 0) {
+                const age = bootstrapAge();
+                if (age != null && age > firstDeviceTtlMs)
+                    return null;
+            }
+            const deviceToken = randomBytes(32).toString('hex');
+            const record = {
+                id: randomBytes(16).toString('hex'),
+                name: deviceName || '设备',
+                tokenHash: hashToken(deviceToken),
+                createdAt: now(),
+            };
+            devices.set(record.id, record);
+            persist();
+            rotateBootstrap(); // 注册成功即轮换，旧 bootstrap（URL/shell history 中）立即失效
+            return deviceToken;
+        },
+        requestPairing(deviceName, source) {
+            if (staticToken && staticToken.length > 0)
+                return null;
+            cleanExpiredPairings();
+            // 限流：最多 10 个待审批；同一来源最多 3 个（防本地/远程进程刷满队列，
+            // 使合法设备 10 分钟内无法配对）。source 尽力而为，缺省视为 'unknown'。
+            const pendingCount = Array.from(pending.values()).filter((p) => p.status === 'pending').length;
+            if (pendingCount >= 10)
+                return null;
+            const src = source ?? 'unknown';
+            const perSource = Array.from(pending.values()).filter((p) => p.status === 'pending' && p.source === src).length;
+            if (perSource >= 3)
+                return null;
+            const pairingId = randomBytes(16).toString('hex');
+            const code = String(100000 + Math.floor(Math.random() * 900000)); // 6 位数字
+            pending.set(pairingId, {
+                pairingId,
+                deviceName: deviceName || '新设备',
+                code,
+                createdAt: now(),
+                status: 'pending',
+                source: src,
+            });
+            return { pairingId, code };
+        },
+        pairingStatus(pairingId) {
+            const p = pending.get(pairingId);
+            if (!p)
+                return { status: 'not_found' };
+            if (p.status === 'approved')
+                return { status: 'approved', deviceToken: p.deviceToken ?? '' };
+            if (p.status === 'denied')
+                return { status: 'denied' };
+            if (p.createdAt <= now() - pairingTtlMs) {
+                pending.delete(pairingId);
+                return { status: 'not_found' };
+            }
+            return { status: 'pending' };
+        },
+        listPairings() {
+            cleanExpiredPairings();
+            return Array.from(pending.values())
+                .filter((p) => p.status === 'pending')
+                .map((p) => ({
+                pairingId: p.pairingId,
+                deviceName: p.deviceName,
+                code: p.code,
+                createdAt: p.createdAt,
+                source: p.source,
+            }));
+        },
+        approvePairing(pairingId) {
+            const p = pending.get(pairingId);
+            if (!p)
+                return false;
+            if (p.status !== 'pending')
+                return false;
+            if (p.createdAt <= now() - pairingTtlMs) {
+                pending.delete(pairingId);
+                return false;
+            }
+            const deviceToken = randomBytes(32).toString('hex');
+            const record = {
+                id: randomBytes(16).toString('hex'),
+                name: p.deviceName,
+                tokenHash: hashToken(deviceToken),
+                createdAt: now(),
+            };
+            devices.set(record.id, record);
+            p.status = 'approved';
+            p.deviceToken = deviceToken;
+            persist();
+            return true;
+        },
+        denyPairing(pairingId) {
+            const p = pending.get(pairingId);
+            if (!p)
+                return false;
+            if (p.status !== 'pending')
+                return false;
+            p.status = 'denied';
+            return true;
+        },
+        listDevices() {
+            return Array.from(devices.values()).map((d) => ({
+                id: d.id,
+                name: d.name,
+                createdAt: d.createdAt,
+            }));
+        },
+        revokeDevice(id) {
+            const ok = devices.delete(id);
+            if (ok)
+                persist();
+            return ok;
+        },
+        dispose() {
+            watcher?.close();
+            watcher = undefined;
+        },
+        persist,
+    };
+}

package/dist/server/context.js

@@ -35,6 +35,10 @@ function createServerContext(opts) {
         agentManager: createAgentManager(),
         permissionStore: createPermissionStore(),
         permissionMode: config.permission.defaultMode,
+        sessionPermissionModes: new Map(),
+        sessionAlwaysAllow: new Map(),
+        // P1-1：项目级 LLM 注册表缓存（按项目合并配置构建，chat 路由按需创建）。
+        projectRegistries: new Map(),
         // 测试工厂不解析/生成 token（不触碰用户全局数据目录）。
         authToken: undefined,
         agentRegistry,

package/dist/server/middleware/auth.d.ts

@@ -2,14 +2,15 @@ import type { MiddlewareHandler } from 'hono';
 export type AuthOptions = {
     /** 不需认证的路径（默认放行 /api/health 探活）。 */
     publicPaths?: string[];
+    /** P2-16：自定义校验函数（authManager.verify）。提供时忽略 token 字符串比较。 */
+    verify?: (token: string | undefined) => boolean;
 };
 /**
  * Bearer token 认证中间件（spec §24.2「认证」）。
  *
  * - 未配置 token（undefined/空）→ 放行，适配本地开发场景。
  * - 配置了 token → 校验 `Authorization: Bearer <token>`，不匹配返回 401。
- * - publicPaths 中的路径始终放行（如健康检查）。
- *
- * 生产或远程访问场景应在 config.security.token 配置随机 token。
+ * - verify 提供时（P2-16 设备 token）→ 以 verify 结果为准。
+ * - publicPaths 中的路径始终放行（如健康检查、认证/配对引导端点）。
  */
 export declare function createAuthMiddleware(token: string | undefined, opts?: AuthOptions): MiddlewareHandler;

package/dist/server/middleware/auth.js

@@ -4,15 +4,14 @@ import { apiError } from './error.js';
  *
  * - 未配置 token（undefined/空）→ 放行，适配本地开发场景。
  * - 配置了 token → 校验 `Authorization: Bearer <token>`，不匹配返回 401。
- * - publicPaths 中的路径始终放行（如健康检查）。
- *
- * 生产或远程访问场景应在 config.security.token 配置随机 token。
+ * - verify 提供时（P2-16 设备 token）→ 以 verify 结果为准。
+ * - publicPaths 中的路径始终放行（如健康检查、认证/配对引导端点）。
  */
 export function createAuthMiddleware(token, opts = {}) {
     const expected = token && token.length > 0 ? `Bearer ${token}` : '';
     const publicPaths = new Set(opts.publicPaths ?? ['/api/health']);
     return async (c, next) => {
-        if (!expected) {
+        if (!expected && !opts.verify) {
             await next();
             return;
         }
@@ -21,7 +20,8 @@ export function createAuthMiddleware(token, opts = {}) {
             return;
         }
         const auth = c.req.header('Authorization') ?? '';
-        if (auth !== expected) {
+        const ok = opts.verify ? opts.verify(auth.replace(/^Bearer\s+/i, '')) : auth === expected;
+        if (!ok) {
             return apiError(c, 401, 'UNAUTHORIZED', 'Missing or invalid bearer token');
         }
         await next();

package/dist/server/permission/interactive.d.ts

@@ -3,14 +3,19 @@ import type { PermissionRequest, PermissionStore } from './store.js';
 export type { PermissionRequest };
 type PermissionMode = 'default' | 'auto';
 type InteractivePermissionCheckerOptions = {
-    /** 始终允许的工具名（覆盖 permission 字段）。 */
-    alwaysAllow?: string[];
+    /** 始终允许的工具名（覆盖 permission 字段）。可为 getter：会话级「始终允许」
+     *  白名单在 run 期间可被用户追加，getter 使每次 check 读取最新集合。 */
+    alwaysAllow?: string[] | (() => string[]);
     /** 始终拒绝的工具名（覆盖 permission 字段）。 */
     alwaysDeny?: string[];
     /** 读取当前授权模式：'auto' 时跳过 ask 交互确认（YOLO 自动授权）。 */
     getMode?: () => PermissionMode;
     /** 遇到 ask 权限时调用（用于通知前端）。 */
     onPermissionRequired?: (request: PermissionRequest) => void | Promise<void>;
+    /** 首层确认超时（仅提示，pending 保持）时调用（P1-6：SSE 通知前端）。 */
+    onPermissionTimeout?: (request: PermissionRequest) => void;
+    /** 兜底过期（提示后仍无响应，自动拒绝）时调用（P0 双层超时：前端清理弹窗状态）。 */
+    onPermissionExpired?: (request: PermissionRequest) => void;
 };
 /** 阻塞式权限检查器：ask 权限会阻塞等待用户确认。
  *  pending 存在全局 PermissionStore 中，独立于 agent run 生命周期。 */

package/dist/server/permission/interactive.js

@@ -1,13 +1,21 @@
 import { randomUUID } from 'node:crypto';
 function createInteractivePermissionChecker(store, opts = {}) {
-    const allowSet = new Set(opts.alwaysAllow ?? []);
+    const allowSet = opts.alwaysAllow
+        ? Array.isArray(opts.alwaysAllow)
+            ? new Set(opts.alwaysAllow)
+            : null
+        : null;
     const denySet = new Set(opts.alwaysDeny ?? []);
     return {
         check: async (tool, input, ctx) => {
             if (denySet.has(tool.name)) {
                 return { _tag: 'deny', reason: `Tool "${tool.name}" is denied by configuration` };
             }
-            if (allowSet.has(tool.name) || tool.permission === 'auto') {
+            // 静态集合或动态 getter（会话级白名单可在 run 期间追加）
+            const dynamicAllowed = allowSet === null && typeof opts.alwaysAllow === 'function'
+                ? opts.alwaysAllow().includes(tool.name)
+                : allowSet?.has(tool.name);
+            if (dynamicAllowed || tool.permission === 'auto') {
                 return { _tag: 'allow' };
             }
             if (tool.permission === 'deny') {
@@ -21,12 +29,24 @@ function createInteractivePermissionChecker(store, opts = {}) {
             }
             // 交互式确认
             const toolCallId = randomUUID();
-            const request = { toolCallId, tool: tool.name, input };
+            const request = {
+                toolCallId,
+                tool: tool.name,
+                input,
+                // P1：绑定会话 id——挂起期间用户切换页面后，前端经
+                // GET /api/permissions/:sessionId/pending 重挂确认弹窗。
+                ...(ctx.session?.id ? { sessionId: ctx.session.id } : {}),
+            };
             const promise = new Promise((resolve) => {
                 // pending 注册到全局 store，confirm 端点按 toolCallId 直接寻址，
                 // 不依赖当前 agent run 是否仍在 agentManager 中注册。
-                // store 内置超时：到期自动 deny 并清理条目（防永久挂起 + Map 泄漏）。
-                store.register(toolCallId, { request, resolve });
+                // store 内置双层超时：首层提示（pending 保持），宽限期后兜底 deny。
+                store.register(toolCallId, {
+                    request,
+                    resolve,
+                    ...(opts.onPermissionTimeout ? { onTimeout: opts.onPermissionTimeout } : {}),
+                    ...(opts.onPermissionExpired ? { onExpired: opts.onPermissionExpired } : {}),
+                });
             });
             await opts.onPermissionRequired?.(request);
             // agent abort 联动：abort 时主动 deny 并清理 store 条目，

package/dist/server/permission/store.d.ts

@@ -2,21 +2,33 @@ import type { PermissionResult } from '../../tools/types.js';
 /** 默认 pending 超时时长：5 分钟（300_000ms）。
  *  超过后自动 resolve 为 deny 并清理 store 条目，避免 promise 永久挂起与 pending Map 泄漏。 */
 declare const DEFAULT_PERMISSION_TIMEOUT_MS: number;
+/** 首层超时（仅提示）后到兜底自动拒绝的宽限期：25 分钟。双层超时总窗口 30 分钟。 */
+declare const DEFAULT_PERMISSION_EXPIRE_GRACE_MS: number;
 /** 权限请求（需要用户确认）。 */
 type PermissionRequest = {
     toolCallId: string;
     tool: string;
     input: unknown;
+    /** 请求所属会话（P1：跨页面挂起恢复用；无会话上下文的调用方省略）。 */
+    sessionId?: string;
 };
 /** 待处理的权限确认。 */
 type PendingPermission = {
     request: PermissionRequest;
     resolve: (result: PermissionResult) => void;
+    /** 首层超时回调（P1-6：按请求绑定 SSE 流，仅提示不终结）。 */
+    onTimeout?: (request: PermissionRequest) => void;
+    /** 兜底过期回调（P0 双层超时：提示后仍无响应 → 自动拒绝，通知前端清理弹窗状态）。 */
+    onExpired?: (request: PermissionRequest) => void;
 };
 /** createPermissionStore 的配置。 */
 type PermissionStoreOptions = {
     /** pending 超时毫秒数；省略时取 DEFAULT_PERMISSION_TIMEOUT_MS（5 分钟）。 */
     timeoutMs?: number;
+    /** 首层超时后到兜底自动拒绝的宽限毫秒数；省略时 25 分钟。 */
+    expireGraceMs?: number;
+    /** 超时自动拒绝时回调（P1-6：通知前端「确认超时已拒绝」，提供重新询问入口）。 */
+    onTimeout?: (request: PermissionRequest) => void;
 };
 /** 全局权限确认 store：注册/解析 pending permission。 */
 type PermissionStore = {
@@ -24,9 +36,11 @@ type PermissionStore = {
     resolve(toolCallId: string, approved: boolean): boolean;
     has(toolCallId: string): boolean;
     size(): number;
+    /** 查询某会话当前挂起的权限请求（P1：前端重挂弹窗；无则 null）。 */
+    pendingForSession(sessionId: string): PermissionRequest | null;
     /** settle 所有 pending 为 deny 并清空（dev 热重载重建前调用）。 */
     dispose(): void;
 };
 declare function createPermissionStore(opts?: PermissionStoreOptions): PermissionStore;
 export type { PendingPermission, PermissionRequest, PermissionStore, PermissionStoreOptions };
-export { createPermissionStore, DEFAULT_PERMISSION_TIMEOUT_MS };
+export { createPermissionStore, DEFAULT_PERMISSION_EXPIRE_GRACE_MS, DEFAULT_PERMISSION_TIMEOUT_MS };

package/dist/server/permission/store.js

@@ -7,8 +7,11 @@
 /** 默认 pending 超时时长：5 分钟（300_000ms）。
  *  超过后自动 resolve 为 deny 并清理 store 条目，避免 promise 永久挂起与 pending Map 泄漏。 */
 const DEFAULT_PERMISSION_TIMEOUT_MS = 5 * 60 * 1000;
+/** 首层超时（仅提示）后到兜底自动拒绝的宽限期：25 分钟。双层超时总窗口 30 分钟。 */
+const DEFAULT_PERMISSION_EXPIRE_GRACE_MS = 25 * 60 * 1000;
 function createPermissionStore(opts = {}) {
     const timeoutMs = opts.timeoutMs ?? DEFAULT_PERMISSION_TIMEOUT_MS;
+    const expireGraceMs = opts.expireGraceMs ?? DEFAULT_PERMISSION_EXPIRE_GRACE_MS;
     const pending = new Map();
     // 统一终结路径：clearTimeout → 删除条目 → resolve。
     // 三处调用（confirm、超时回调、abort 联动）都汇聚于此：
@@ -28,8 +31,27 @@ function createPermissionStore(opts = {}) {
             const existing = pending.get(toolCallId);
             if (existing)
                 clearTimeout(existing.timer);
+            // P0 双层超时：首层仅提示（pending 保持，用户可「重新询问」）；提示后仍无响应
+            // 则宽限期后兜底自动拒绝——否则用户离开页面后 run 被永久阻塞、会话 409 锁死。
+            // 无 onTimeout（非交互式 store）保留旧的单层自动拒绝语义。
             const timer = setTimeout(() => {
-                settle(toolCallId, { _tag: 'deny', reason: 'Permission request timed out' });
+                if (!entry.onTimeout) {
+                    settle(toolCallId, { _tag: 'deny', reason: 'Permission request timed out' });
+                    return;
+                }
+                entry.onTimeout(entry.request);
+                // 首层提示后：重新挂宽限定时器（句柄回写 entry，settle 才能清理它）
+                const expireTimer = setTimeout(() => {
+                    const cur = pending.get(toolCallId);
+                    if (!cur)
+                        return;
+                    pending.set(toolCallId, { ...cur, timer: expireTimer });
+                    cur.onExpired?.(cur.request);
+                    settle(toolCallId, { _tag: 'deny', reason: 'Permission request expired' });
+                }, expireGraceMs);
+                const cur = pending.get(toolCallId);
+                if (cur)
+                    pending.set(toolCallId, { ...cur, timer: expireTimer });
             }, timeoutMs);
             pending.set(toolCallId, { ...entry, timer });
         },
@@ -42,6 +64,13 @@ function createPermissionStore(opts = {}) {
         size() {
             return pending.size;
         },
+        pendingForSession(sessionId) {
+            for (const p of pending.values()) {
+                if (p.request.sessionId === sessionId)
+                    return p.request;
+            }
+            return null;
+        },
         dispose() {
             // dev 热重载重建前调用：所有 pending settle 为 deny（避免悬空 Promise +
             // timer 泄漏），clearTimeout 后清空 Map。
@@ -53,4 +82,4 @@ function createPermissionStore(opts = {}) {
         },
     };
 }
-export { createPermissionStore, DEFAULT_PERMISSION_TIMEOUT_MS };
+export { createPermissionStore, DEFAULT_PERMISSION_EXPIRE_GRACE_MS, DEFAULT_PERMISSION_TIMEOUT_MS };

package/dist/server/registry-config.d.ts

@@ -0,0 +1,14 @@
+import { type Registry } from '../llm/registry.js';
+import type { Config } from '../shared/types/config.js';
+import type { ProviderConfig } from '../shared/types/llm.js';
+/** 把 config.providers 注册到新建的 LLM registry（修复此前空 registry 的遗漏）。 */
+declare function buildRegistryFromConfig(config: Config): Registry;
+declare function registerProviderFromConfig(registry: Registry, p: ProviderConfig): void;
+/**
+ * config 变更后原子地同步 registry：在隔离的 next registry 上重建全部路由，
+ * 完成后一次性替换 registry 内部 table 引用。运行中的 resolveRoute 任何时刻
+ * 看到的都是完整的旧表或完整的新表，不会读到「已清空但未注册完」的半状态，
+ * 因此不会把本可用的 provider 误判为 NoRoute。ServerContext 立即生效，无需重启。
+ */
+declare function syncRegistryFromConfig(registry: Registry, config: Config): void;
+export { buildRegistryFromConfig, registerProviderFromConfig, syncRegistryFromConfig };

package/dist/server/registry-config.js

@@ -0,0 +1,44 @@
+// src/server/registry-config.ts
+// config.providers ↔ LLM registry 的构建/同步逻辑（P1-1 从 server.ts 拆出，
+// 供 chat 路由按项目配置构建注册表，避免 routes → server.ts 循环依赖）。
+import { decryptSecret } from '../core/secret.js';
+import { createRegistry, overrideToCapabilities, rebuildRegistry, registerProvider, } from '../llm/registry.js';
+/** 把 config.providers 注册到新建的 LLM registry（修复此前空 registry 的遗漏）。 */
+function buildRegistryFromConfig(config) {
+    const registry = createRegistry();
+    for (const p of config.providers) {
+        registerProviderFromConfig(registry, p);
+    }
+    return registry;
+}
+function registerProviderFromConfig(registry, p) {
+    // 兼容 config.json 中以 _tag 标识 provider 的格式（name 缺失时回退到 _tag）
+    const name = p.name || p._tag;
+    if (!name || !p.baseURL)
+        return;
+    // baseURL 已含 /v1 时用 /chat/completions，避免 /v1/v1 双重前缀
+    const path = p.baseURL.replace(/\/+$/, '').endsWith('/v1') ? '/chat/completions' : undefined;
+    registerProvider(registry, {
+        name,
+        baseURL: p.baseURL,
+        apiKey: p.apiKey ? decryptSecret(p.apiKey) : p.apiKey,
+        ...(path ? { path } : {}),
+        // 传递用户配置的 per-model capabilities（contextWindow 等），
+        // 否则 resolveRoute 回退到 DEFAULT_MODEL_CAPABILITIES，可能导致预算过小。
+        ...(p.models ? { models: overrideToCapabilities(p.models) } : {}),
+    });
+}
+/**
+ * config 变更后原子地同步 registry：在隔离的 next registry 上重建全部路由，
+ * 完成后一次性替换 registry 内部 table 引用。运行中的 resolveRoute 任何时刻
+ * 看到的都是完整的旧表或完整的新表，不会读到「已清空但未注册完」的半状态，
+ * 因此不会把本可用的 provider 误判为 NoRoute。ServerContext 立即生效，无需重启。
+ */
+function syncRegistryFromConfig(registry, config) {
+    rebuildRegistry(registry, (next) => {
+        for (const p of config.providers) {
+            registerProviderFromConfig(next, p);
+        }
+    });
+}
+export { buildRegistryFromConfig, registerProviderFromConfig, syncRegistryFromConfig };

package/dist/server/routes/auth.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import type { ServerContext } from '../types.js';
+declare function createAuthRoute(ctx: ServerContext): Hono;
+export { createAuthRoute };