c0de-agent 1.12.0 → 1.13.0

package/dist/server/auth-manager.d.ts

@@ -27,6 +27,15 @@ type AuthManagerOptions = {
     firstDeviceTtlMs?: number;
     now?: () => number;
 };
+/** 首设备注册结果：成功返回设备 token；失败返回可区分原因（路由据此给出
+ *  正确的恢复指引——「注册链接过期」与「已有设备」的补救动作完全不同）。 */
+type FirstDeviceRegistration = {
+    ok: true;
+    deviceToken: string;
+} | {
+    ok: false;
+    reason: 'static_mode' | 'invalid_bootstrap' | 'devices_exist' | 'ttl_expired';
+};
 export type AuthManager = {
     /** 当前 bootstrap token（静态模式下即 staticToken）。 */
     readonly bootstrap: string | undefined;
@@ -37,8 +46,8 @@ export type AuthManager = {
     verifyHandoff(token: string | undefined): boolean;
     /** 首次设备注册：校验 bootstrap 后换发设备 token 并轮换 bootstrap。
      *  无设备时首个凭 bootstrap 的请求即视为首设备（免审批），后续请求需配对审批。
-     *  返回新设备 token；bootstrap 已失效/已注册过 → 返回 null。 */
-    registerFirstDevice(bootstrapToken: string, deviceName: string): Promise<string | null>;
+     *  失败返回具体原因（static_mode / invalid_bootstrap / devices_exist / ttl_expired）。 */
+    registerFirstDevice(bootstrapToken: string, deviceName: string): Promise<FirstDeviceRegistration>;
     /** 发起配对请求（未认证）：返回 { pairingId, code }；静态模式/未启用返回 null。
      *  source 为请求来源（IP 等，尽力而为），用于审批展示与按来源限流。 */
     requestPairing(deviceName: string, source?: string): {
@@ -64,8 +73,10 @@ export type AuthManager = {
         createdAt: number;
         source: string;
     }>;
-    /** 审批配对（需已认证设备调用）：通过后为请求设备签发 token。 */
-    approvePairing(pairingId: string): boolean;
+    /** 审批配对（需已认证设备调用）：核对审批方输入的 6 位配对码，匹配才签发 token。
+     *  P2-9：此前按 pairingId 直接批准，多请求并存时看错行批准即给错设备发 token；
+     *  码是展示信息不参与校验。现在码必须由审批方输入（新设备屏幕显示）——防误批。 */
+    approvePairing(pairingId: string, code: string): 'approved' | 'not_found' | 'expired' | 'code_mismatch' | 'already_handled';
     /** 拒绝配对。 */
     denyPairing(pairingId: string): boolean;
     /** 列出已授权设备（id/name/createdAt）。 */

package/dist/server/auth-manager.js

@@ -133,9 +133,10 @@ export function createAuthManager(opts) {
     function cleanExpiredPairings() {
         const cutoff = now() - pairingTtlMs;
         for (const [id, p] of pending) {
-            if (p.status === 'pending' && p.createdAt <= cutoff) {
+            // 不论状态一律过期清理：approved 但新设备始终未取走 token 的条目（客户端放弃轮询）
+            // 同样需要回收，否则长驻内存且其明文 token 无期限留存。
+            if (p.createdAt <= cutoff)
                 pending.delete(id);
-            }
         }
     }
     return {
@@ -160,17 +161,19 @@ export function createAuthManager(opts) {
         },
         async registerFirstDevice(bootstrapToken, deviceName) {
             if (staticToken && staticToken.length > 0)
-                return null; // 静态模式无设备注册
-            if (!verifyBootstrap(bootstrapToken))
-                return null;
-            // 已有设备 → bootstrap 已失效，不得再凭它注册（需配对审批）
+                return { ok: false, reason: 'static_mode' };
+            // 已有设备 → bootstrap 已失效（注册即轮换），不得再凭它注册（需配对审批）。
+            // 先于 verifyBootstrap 判定：轮换后的旧 URL token 属「已消费」而非「无效」，
+            // 两者给用户的恢复指引不同（配对审批 vs 检查 token）。
             if (devices.size > 0)
-                return null;
+                return { ok: false, reason: 'devices_exist' };
+            if (!verifyBootstrap(bootstrapToken))
+                return { ok: false, reason: 'invalid_bootstrap' };
             // 首设备注册窗口：bootstrap 超过 firstDeviceTtlMs 后拒绝（缩短先到先得竞态窗口）。
             if (firstDeviceTtlMs > 0) {
                 const age = bootstrapAge();
                 if (age != null && age > firstDeviceTtlMs)
-                    return null;
+                    return { ok: false, reason: 'ttl_expired' };
             }
             const deviceToken = randomBytes(32).toString('hex');
             const record = {
@@ -182,7 +185,7 @@ export function createAuthManager(opts) {
             devices.set(record.id, record);
             persist();
             rotateBootstrap(); // 注册成功即轮换，旧 bootstrap（URL/shell history 中）立即失效
-            return deviceToken;
+            return { ok: true, deviceToken };
         },
         requestPairing(deviceName, source) {
             if (staticToken && staticToken.length > 0)
@@ -213,8 +216,24 @@ export function createAuthManager(opts) {
             const p = pending.get(pairingId);
             if (!p)
                 return { status: 'not_found' };
-            if (p.status === 'approved')
-                return { status: 'approved', deviceToken: p.deviceToken ?? '' };
+            if (p.status === 'approved') {
+                // 交付点：把设备登记落盘与「新设备取走 token」原子化到同一时刻——
+                // 审批后、取 token 前服务重启时 pending 随内存清空（status=not_found），
+                // 不会留下拿不到 token 的僵尸设备条目；此后新设备重新发起配对即可。
+                const deviceToken = p.deviceToken ?? '';
+                if (deviceToken) {
+                    const record = {
+                        id: randomBytes(16).toString('hex'),
+                        name: p.deviceName,
+                        tokenHash: hashToken(deviceToken),
+                        createdAt: now(),
+                    };
+                    devices.set(record.id, record);
+                    persist();
+                    pending.delete(pairingId);
+                }
+                return { status: 'approved', deviceToken };
+            }
             if (p.status === 'denied')
                 return { status: 'denied' };
             if (p.createdAt <= now() - pairingTtlMs) {
@@ -235,28 +254,26 @@ export function createAuthManager(opts) {
                 source: p.source,
             }));
         },
-        approvePairing(pairingId) {
+        approvePairing(pairingId, code) {
             const p = pending.get(pairingId);
             if (!p)
-                return false;
+                return 'not_found';
             if (p.status !== 'pending')
-                return false;
+                return 'already_handled';
             if (p.createdAt <= now() - pairingTtlMs) {
                 pending.delete(pairingId);
-                return false;
+                return 'expired';
             }
+            if (String(code ?? '').trim() !== p.code)
+                return 'code_mismatch';
+            // P：登记推迟到新设备真正取走 token 时（pairingStatus 消费）。此前审批即落盘，
+            // 若审批后、新设备轮询前服务重启，devices.json 里会出现一个永远拿不到 token
+            // 的僵尸条目（pending 不落盘、明文 token 只在内存）——「已授权设备」列表与
+            // 实际可登录设备自相矛盾，用户只能撤销后重新配对。
             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;
+            return 'approved';
         },
         denyPairing(pairingId) {
             const p = pending.get(pairingId);

package/dist/server/context.js

@@ -33,10 +33,20 @@ function createServerContext(opts) {
         hookRunner,
         pluginRegistry: createPluginRegistry(hookRunner),
         agentManager: createAgentManager(),
-        permissionStore: createPermissionStore(),
+        // P3：与生产 buildServerContext 同口径——配置的确认超时/宽限期生效。
+        permissionStore: createPermissionStore({
+            ...(config.permission.timeoutMs !== undefined && config.permission.timeoutMs > 0
+                ? { timeoutMs: config.permission.timeoutMs }
+                : {}),
+            ...(config.permission.expireGraceMs !== undefined && config.permission.expireGraceMs > 0
+                ? { expireGraceMs: config.permission.expireGraceMs }
+                : {}),
+        }),
         permissionMode: config.permission.defaultMode,
         sessionPermissionModes: new Map(),
         sessionAlwaysAllow: new Map(),
+        workflowBusyBySession: new Map(),
+        workflowBusyByScope: new Map(),
         // P1-1：项目级 LLM 注册表缓存（按项目合并配置构建，chat 路由按需创建）。
         projectRegistries: new Map(),
         // 测试工厂不解析/生成 token（不触碰用户全局数据目录）。

package/dist/server/index.d.ts

@@ -7,5 +7,5 @@ export { apiError, errorHandler } from './middleware/error.js';
 export type { InteractivePermissionChecker, InteractivePermissionCheckerOptions, PermissionRequest, } from './permission/interactive.js';
 export { createInteractivePermissionChecker } from './permission/interactive.js';
 export type { RunningServer, StartServerOptions } from './server.js';
-export { startServer } from './server.js';
+export { DEFAULT_SERVE_PORT, startServer } from './server.js';
 export type { APIErrorBody, ChatRequest, ConfirmRequest, ControlRequest, ServerContext, SteerRequest, } from './types.js';

package/dist/server/index.js

@@ -4,4 +4,4 @@ export { createApp } from './app.js';
 export { createServerContext } from './context.js';
 export { apiError, errorHandler } from './middleware/error.js';
 export { createInteractivePermissionChecker } from './permission/interactive.js';
-export { startServer } from './server.js';
+export { DEFAULT_SERVE_PORT, startServer } from './server.js';

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

@@ -4,11 +4,21 @@ export type AuthOptions = {
     publicPaths?: string[];
     /** P2-16：自定义校验函数（authManager.verify）。提供时忽略 token 字符串比较。 */
     verify?: (token: string | undefined) => boolean;
+    /** 认证未启用时的跨域写防线（盲 CSRF）：CORS 回显只拦「读」——恶意网页对本地
+     *  服务的 POST/DELETE 等请求副作用仍会执行，只是读不到响应。开启认证（token/verify
+     *  存在）时凭 token 校验已构成防线，此项不生效。 */
+    allowedOrigins?: string[];
+    /** 允许经 `?token=` 查询参数认证的路径判定（P1 媒体预览修复：浏览器
+     *  <img>/<audio>/<video>/<embed> 元素无法携带 Authorization 头，与终端
+     *  WebSocket 的 query token 同口径）。仅当 Authorization 头缺失/无效时才
+     *  检查 query token——头优先，不会因路径匹配而放行任意 query token。 */
+    queryTokenPath?: (path: string) => boolean;
 };
 /**
  * Bearer token 认证中间件（spec §24.2「认证」）。
  *
- * - 未配置 token（undefined/空）→ 放行，适配本地开发场景。
+ * - 未配置 token（undefined/空）→ 放行，适配本地开发场景；但对「写」请求校验
+ *   Origin（仅本地回环 + allowedOrigins），补上 authEnabled=false 时 CORS 不设防的盲写面。
  * - 配置了 token → 校验 `Authorization: Bearer <token>`，不匹配返回 401。
  * - verify 提供时（P2-16 设备 token）→ 以 verify 结果为准。
  * - publicPaths 中的路径始终放行（如健康检查、认证/配对引导端点）。

package/dist/server/middleware/auth.js

@@ -1,8 +1,10 @@
+import { isAllowedOrigin } from './cors.js';
 import { apiError } from './error.js';
 /**
  * Bearer token 认证中间件（spec §24.2「认证」）。
  *
- * - 未配置 token（undefined/空）→ 放行，适配本地开发场景。
+ * - 未配置 token（undefined/空）→ 放行，适配本地开发场景；但对「写」请求校验
+ *   Origin（仅本地回环 + allowedOrigins），补上 authEnabled=false 时 CORS 不设防的盲写面。
  * - 配置了 token → 校验 `Authorization: Bearer <token>`，不匹配返回 401。
  * - verify 提供时（P2-16 设备 token）→ 以 verify 结果为准。
  * - publicPaths 中的路径始终放行（如健康检查、认证/配对引导端点）。
@@ -10,8 +12,19 @@ import { apiError } from './error.js';
 export function createAuthMiddleware(token, opts = {}) {
     const expected = token && token.length > 0 ? `Bearer ${token}` : '';
     const publicPaths = new Set(opts.publicPaths ?? ['/api/health']);
+    const queryTokenPath = opts.queryTokenPath;
     return async (c, next) => {
         if (!expected && !opts.verify) {
+            // 认证关闭：无 token 可验证。带 Origin 的非安全方法（浏览器跨域写）需显式放行
+            // 本地/已配置 origin；无 Origin 的请求（curl/CLI/脚本/服务间调用）不受影响。
+            const method = c.req.method;
+            const stateChanging = method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS';
+            if (stateChanging) {
+                const origin = c.req.header('Origin') ?? '';
+                if (origin.length > 0 && !isAllowedOrigin(origin, opts.allowedOrigins)) {
+                    return apiError(c, 403, 'ORIGIN_FORBIDDEN', 'Cross-origin write rejected while authentication is disabled');
+                }
+            }
             await next();
             return;
         }
@@ -19,8 +32,17 @@ export function createAuthMiddleware(token, opts = {}) {
             await next();
             return;
         }
-        const auth = c.req.header('Authorization') ?? '';
-        const ok = opts.verify ? opts.verify(auth.replace(/^Bearer\s+/i, '')) : auth === expected;
+        const headerAuth = c.req.header('Authorization') ?? '';
+        let ok = opts.verify
+            ? opts.verify(headerAuth.replace(/^Bearer\s+/i, ''))
+            : headerAuth === expected;
+        // P1 媒体预览：浏览器媒体元素无 Authorization 头——对判定命中的路径尝试
+        // query token 认证。头已有效则不再检查（头优先）；路径不匹配时 query token
+        // 不参与判定，仅在白名单路径上接受 query 认证。
+        if (!ok && queryTokenPath?.(c.req.path)) {
+            const queryToken = c.req.query('token') ?? '';
+            ok = opts.verify ? opts.verify(queryToken) : `Bearer ${queryToken}` === expected;
+        }
         if (!ok) {
             return apiError(c, 401, 'UNAUTHORIZED', 'Missing or invalid bearer token');
         }

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

@@ -16,6 +16,11 @@ type InteractivePermissionCheckerOptions = {
     onPermissionTimeout?: (request: PermissionRequest) => void;
     /** 兜底过期（提示后仍无响应，自动拒绝）时调用（P0 双层超时：前端清理弹窗状态）。 */
     onPermissionExpired?: (request: PermissionRequest) => void;
+    /** 权限请求「报告归属」的会话 id。缺省取 tool context 的会话——子 agent 的 ask
+     *  请求会挂在各自子会话上，用户所在的主/工作流会话按 sessionId 重挂 pending
+     *  弹窗时找不到。传入发起 run 的用户可见会话 id，使 GET /api/permissions/:id/pending
+     *  能从该会话恢复全部子 agent 的挂起请求。 */
+    reportSessionId?: string;
 };
 /** 阻塞式权限检查器：ask 权限会阻塞等待用户确认。
  *  pending 存在全局 PermissionStore 中，独立于 agent run 生命周期。 */

package/dist/server/permission/interactive.js

@@ -29,13 +29,16 @@ function createInteractivePermissionChecker(store, opts = {}) {
             }
             // 交互式确认
             const toolCallId = randomUUID();
+            const reportedSessionId = opts.reportSessionId ?? ctx.session?.id;
             const request = {
                 toolCallId,
                 tool: tool.name,
                 input,
                 // P1：绑定会话 id——挂起期间用户切换页面后，前端经
                 // GET /api/permissions/:sessionId/pending 重挂确认弹窗。
-                ...(ctx.session?.id ? { sessionId: ctx.session.id } : {}),
+                // 子 agent 请求按 reportSessionId 归属到发起 run 的用户可见会话，
+                // 而不是各自的子会话（用户不会停留在子会话页面上等确认）。
+                ...(reportedSessionId ? { sessionId: reportedSessionId } : {}),
             };
             const promise = new Promise((resolve) => {
                 // pending 注册到全局 store，confirm 端点按 toolCallId 直接寻址，

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

@@ -38,6 +38,8 @@ type PermissionStore = {
     size(): number;
     /** 查询某会话当前挂起的权限请求（P1：前端重挂弹窗；无则 null）。 */
     pendingForSession(sessionId: string): PermissionRequest | null;
+    /** P3：统计指定会话集合内的挂起请求数（update 影响面按受影响会话过滤用）。 */
+    countForSessions(sessionIds: ReadonlySet<string>): number;
     /** settle 所有 pending 为 deny 并清空（dev 热重载重建前调用）。 */
     dispose(): void;
 };

package/dist/server/permission/store.js

@@ -71,6 +71,14 @@ function createPermissionStore(opts = {}) {
             }
             return null;
         },
+        countForSessions(sessionIds) {
+            let n = 0;
+            for (const p of pending.values()) {
+                if (p.request.sessionId && sessionIds.has(p.request.sessionId))
+                    n += 1;
+            }
+            return n;
+        },
         dispose() {
             // dev 热重载重建前调用：所有 pending settle 为 deny（避免悬空 Promise +
             // timer 泄漏），clearTimeout 后清空 Map。

package/dist/server/routes/auth.js

@@ -35,13 +35,24 @@ function createAuthRoute(ctx) {
         if (!body.token) {
             return apiError(c, 400, 'BAD_REQUEST', 'token is required');
         }
-        const deviceToken = await ctx.authManager.registerFirstDevice(body.token, body.deviceName ?? '设备');
-        if (!deviceToken) {
-            // bootstrap 已失效/已注册过设备 → 引导走配对审批
-            return apiError(c, 403, 'BOOTSTRAP_CONSUMED', 'bootstrap token 已失效（已有设备注册）。请在新设备发起配对，由已授权设备审批。');
+        const result = await ctx.authManager.registerFirstDevice(body.token, body.deviceName ?? '设备');
+        if (!result.ok) {
+            // 区分失败原因给正确的恢复指引：链接过期 → 重启 serve 换新链接；
+            // 已有设备 → 走配对审批；两者补救动作完全不同，不得混用同一文案。
+            if (result.reason === 'ttl_expired') {
+                return apiError(c, 403, 'BOOTSTRAP_EXPIRED', '注册链接已过期（超过安全窗口未使用）。请重启 c0de serve——无已注册设备时' +
+                    '重启会重新生成注册链接，打开启动日志中打印的新 URL 完成首次注册。');
+            }
+            if (result.reason === 'devices_exist') {
+                return apiError(c, 403, 'BOOTSTRAP_CONSUMED', 'bootstrap token 已失效（已有设备注册）。请在新设备发起配对，由已授权设备审批。');
+            }
+            if (result.reason === 'invalid_bootstrap') {
+                return apiError(c, 403, 'BOOTSTRAP_INVALID', 'bootstrap token 无效。');
+            }
+            return apiError(c, 403, 'STATIC_TOKEN_MODE', '静态 token 模式不支持设备注册。');
         }
         // P1-3：回传注册成功的设备名，前端展示一次性确认（用户可核对注册的是否自己）。
-        return c.json({ deviceToken, deviceName: body.deviceName ?? '设备' });
+        return c.json({ deviceToken: result.deviceToken, deviceName: body.deviceName ?? '设备' });
     });
     // 新设备发起配对请求（公开）。
     app.post('/pairing/request', async (c) => {
@@ -53,7 +64,12 @@ function createAuthRoute(ctx) {
         if (!result) {
             return apiError(c, 429, 'PAIRING_LIMIT', '待审批的配对请求过多，请稍后再试');
         }
-        return c.json(result);
+        // L3：零已授权设备时配对审批不可能完成（无人可批准）——前端据此展示
+        // 恢复指引（重启 serve 重新生成 bootstrap 注册链接）而非干等审批。
+        return c.json({
+            ...result,
+            hasAuthorizedDevices: ctx.authManager.listDevices().length > 0,
+        });
     });
     // 新设备轮询配对审批结果（公开）。
     app.get('/pairing/status', (c) => {
@@ -76,7 +92,8 @@ function createAuthRoute(ctx) {
         }
         return c.json({ pairings: ctx.authManager.listPairings() });
     });
-    // 审批通过（需认证）。
+    // 审批通过（需认证）。P2-9：必须携带审批方输入的 6 位配对码（新设备屏幕显示），
+    // 服务端核对匹配才签发——防多请求并存时看错行误批给错设备。
     app.post('/pairing/approve', async (c) => {
         if (!ctx.authManager) {
             return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
@@ -84,9 +101,18 @@ function createAuthRoute(ctx) {
         const body = (await c.req.json().catch(() => ({})));
         if (!body.pairingId)
             return apiError(c, 400, 'BAD_REQUEST', 'pairingId is required');
-        const ok = ctx.authManager.approvePairing(body.pairingId);
-        if (!ok)
+        if (!body.code)
+            return apiError(c, 400, 'BAD_REQUEST', 'code is required');
+        const result = ctx.authManager.approvePairing(body.pairingId, body.code);
+        if (result === 'code_mismatch') {
+            return apiError(c, 400, 'PAIRING_CODE_MISMATCH', '配对码不匹配：请核对新设备屏幕显示的 6 位配对码后重新输入');
+        }
+        if (result === 'not_found' || result === 'expired') {
             return apiError(c, 404, 'PAIRING_NOT_FOUND', '配对请求不存在或已过期');
+        }
+        if (result === 'already_handled') {
+            return apiError(c, 409, 'PAIRING_ALREADY_HANDLED', '该配对请求已被处理');
+        }
         return c.json({ ok: true });
     });
     // 拒绝配对（需认证）。

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

@@ -1,5 +1,7 @@
 import { Hono } from 'hono';
 import { type SSEStreamingApi } from 'hono/streaming';
+import type { RegisterChildRun } from '../../core/types.js';
+import type { AgentManager } from '../agent-manager.js';
 import type { ServerContext } from '../types.js';
 /** 按 session.projectId / worktreePath 解析 agent 工作目录：
  *  - 有 projectId → 项目 worktree（缺失/目录失效时抛错，由上层转 409）。
@@ -10,16 +12,23 @@ export declare function resolveAgentCwd(ctx: ServerContext, session: {
     projectId: string | null;
     worktreePath?: string | null;
 }): Promise<string>;
-/**
- * SSE 心跳间隔。前端有 90s 静默看门狗（web/services/chat.ts），而服务端各
- * 等待语义远长于此：bash 默认超时 120s、权限确认 5 分钟、子 agent 执行数分钟。
- * 这些等待期间没有业务事件帧——若无心跳，前端会在 90s 时 abort 连接，
- * 服务端 stream.onAbort 随即中止 agent，长命令/权限弹窗/多 agent 全部误杀。
- * 30s 心跳保证看门狗只对「连接真正死亡」（连续 3 个心跳周期无数据）生效。
- */
 declare const SSE_HEARTBEAT_INTERVAL_MS = 30000;
 /** 启动心跳定时器；返回停止函数（幂等）。流关闭后写入会被吞掉，安全。 */
 declare function startHeartbeat(stream: SSEStreamingApi): () => void;
 export { SSE_HEARTBEAT_INTERVAL_MS, startHeartbeat };
+/**
+ * 子 agent run 注册桥接：core 的 registerChildRun → agentManager 槽位。
+ * P1：此前子 run（含后台任务）从不注册，暂停/热更新/删除级联/更新影响面
+ * 全部绕过它们；core 无 agentManager 引用，桥接由 Web 宿主注入。
+ * 返回的注销函数幂等（unregister 对不存在的 key 安全）。
+ */
+export declare function childRunBridge(manager: AgentManager): RegisterChildRun;
+/**
+ * 会话「忙」判定统一口径：活跃 run / tryAcquire 占位（starting）/ 工作流运行期
+ * （发起会话无主 run，busy 映射承载）。变更型操作（fork/compact/clear 等）在斜杠与
+ * REST 双入口共用本判定，防止守卫漂移——REST fork 此前只查 get()，漏 starting
+ * 占位窗口与工作流运行期两种态（斜杠守卫早已覆盖）。
+ */
+export declare function hasBusySession(ctx: ServerContext, sessionId: string): 'run' | 'starting' | 'workflow' | null;
 declare function createChatRoute(ctx: ServerContext): Hono;
 export { createChatRoute };