c0de-agent 1.11.0 → 1.13.0

package/dist/server/routes/update.js

@@ -1,29 +1,96 @@
 import { Hono } from 'hono';
-import { getCurrentVersion, performHotUpdate, serializeSessions } from '../../update/index.js';
+import { getSession } from '../../session/session.js';
+import { getCurrentVersion, manualInstallCommand, performHandoff, performInstall, serializeSessions, } from '../../update/index.js';
 import { apiError } from '../middleware/error.js';
+import { captureForegroundCommand } from '../terminal/pty-manager.js';
 /**
  * GET /api/update — 返回后台调度器缓存的版本检查结果（spec §18.1）。
  * 路由本身不触发 npm registry 请求；调度器周期性 checkNow 写入缓存，
  * 路由读缓存（避免每个前端轮询都打外网）。
  *
- * POST /api/update/apply — 手动触发热更新（spec §18.2）：
- *   序列化当前会话 → performHotUpdate（npm install -g + spawn 新实例 + handoffPort）。
- *   旧实例通过 handoff 端点优雅退出，新实例 restore 快照并接管端口。
- *   响应立即返回（不阻塞 spawn），实际接管由 handoff IPC 异步完成。
- *   dev（vite）模式无 handoff server，返回 409——热更新仅在独立 serve 进程可用。
+ * POST /api/update/apply — 手动触发热更新（spec §18.2），P0 修复后顺序：
+ *   1. checkNow 确认有更新；
+ *   2. performInstall（仅安装新版本）——失败时**尚未暂停任何会话**，
+ *      直接返回可操作错误（409 + 手动更新命令），用户工作零损失；
+ *   3. 安装成功 → pauseAll 暂停活跃 run 至安全点（原子操作完成）；
+ *   4. serializeSessions → performHandoff（写快照 + spawn 新实例）；
+ *   5. spawn 失败 → resumeAll 回滚暂停的会话，返回明确错误。
+ *
+ * 旧实例通过 handoff 端点优雅退出，新实例 restore 快照并接管端口。
+ * 响应立即返回（不阻塞 spawn），实际接管由 handoff IPC 异步完成。
+ * dev（vite）模式无 handoff server，返回 409——热更新仅在独立 serve 进程可用。
  */
 function createUpdateRoute(ctx) {
     const app = new Hono();
-    app.get('/', (c) => {
+    app.get('/', async (c) => {
+        // 热更新影响面（P2-11）：apply 前由前端确认框逐项展示受影响对象。
+        // 顶层 run（主 agent）+ 终端数；子 agent 归父会话，不重复列出。
+        const active = ctx.agentManager.listActive();
+        const topRuns = active.filter((r) => !r.parentSessionId);
+        // P3：受影响会话集合——全部活跃 run 会话 + workflow busy 的发起/工作流会话
+        //（工作流运行期发起会话无主 run，但其挂起权限同样会被更新中断）。
+        const affectedSessionIds = new Set(active.map((r) => r.sessionId));
+        for (const [initiator, wf] of ctx.workflowBusyBySession) {
+            affectedSessionIds.add(initiator);
+            affectedSessionIds.add(wf);
+        }
+        const runs = [];
+        for (const r of topRuns) {
+            let title = r.sessionId.slice(0, 8);
+            try {
+                const session = await getSession(ctx.db, r.sessionId);
+                if (session)
+                    title = session.title;
+            }
+            catch {
+                // 会话查询失败：回退 id 前缀展示
+            }
+            runs.push({
+                sessionId: r.sessionId,
+                title,
+                ...(r.agentType ? { agentType: r.agentType } : {}),
+                ...(r.status ? { status: r.status } : {}),
+                ...(r.currentTool ? { currentTool: r.currentTool } : {}),
+            });
+        }
+        const impact = {
+            runs,
+            terminalCount: ctx.ptyManager.list().length,
+            // P1：逐项列出终端（标题 + shell + 目录），确认弹窗据此展示——
+            // 用户可判断被关闭的终端是否正在跑重要进程。
+            terminals: ctx.ptyManager.list().map((t) => {
+                const command = captureForegroundCommand(t.pid);
+                return {
+                    id: t.id,
+                    title: t.title,
+                    shell: t.shell,
+                    cwd: t.cwd,
+                    // P3-7：检测到的前台命令（仅单一前台子进程时非空），供确认框勾选「自动重启」。
+                    ...(command ? { command } : {}),
+                };
+            }),
+            // P3-9：正在等待确认的权限请求——更新会中断其所属 run，弹窗静默失效
+            // （隐含按拒绝处理），确认层明示数量让用户知情。
+            // P3 修复：仅统计受影响会话（活跃 run 会话 + workflow busy 发起会话）的挂起
+            // 请求——此前用全局 store.size()，其他无关会话/已结束 run 的遗留 pending
+            // 也计入，数量虚高。
+            pendingPermissionCount: ctx.permissionStore.countForSessions(affectedSessionIds),
+        };
         // P2-8：update.enabled=false 时无 handoff server，apply 必然 409。
         // 不再触发 checkNow，也不返回 hasUpdate，避免横幅出现一个点了必失败的应用按钮。
         if (ctx.config.update.enabled === false) {
             const v = getCurrentVersion();
-            return c.json({ hasUpdate: false, disabled: true, currentVersion: v, latestVersion: v });
+            return c.json({
+                hasUpdate: false,
+                disabled: true,
+                currentVersion: v,
+                latestVersion: v,
+                impact,
+            });
         }
         const cached = ctx.updateScheduler.getLastResult();
         if (cached)
-            return c.json(cached);
+            return c.json({ ...cached, impact });
         // 无缓存（首次启动延迟未到）：同步触发一次，避免前端首屏空。
         // 不 await——保持 GET 语义非阻塞；前端下次轮询拿到结果。
         void ctx.updateScheduler.checkNow();
@@ -32,46 +99,95 @@ function createUpdateRoute(ctx) {
             hasUpdate: false,
             currentVersion: v,
             latestVersion: v,
+            impact,
         });
     });
     app.post('/apply', async (c) => {
         if (!ctx.handoff) {
             return apiError(c, 409, 'HOT_UPDATE_UNAVAILABLE', '热更新仅在独立 serve 进程可用（dev 模式请手动更新）');
         }
+        // P3-7：用户勾选「更新后自动重启」的终端 id；命中者在快照中携带前台命令。
+        const body = (await c.req.json().catch(() => ({})));
+        const rerunIds = new Set(Array.isArray(body.rerunTerminalIds)
+            ? body.rerunTerminalIds.filter((x) => typeof x === 'string')
+            : []);
         const result = await ctx.updateScheduler.checkNow();
         if (!result.hasUpdate) {
+            // P3-8：检查失败与「已是最新」分开——网络/registry 异常给可操作的
+            // 重试指引，不再误导为「无需更新」。
+            if (result.checkError) {
+                return apiError(c, 502, 'UPDATE_CHECK_FAILED', '无法检查最新版本（registry 连接失败），请检查网络后重试');
+            }
             return apiError(c, 409, 'NO_UPDATE', '已是最新版本，无需热更新');
         }
-        // P1-8：热更新前先暂停所有活跃 run，等其到达安全暂停点（原子操作完成）。
-        // 暂停状态已持久化（lastRun.status='paused'），新实例接管后可恢复继续执行。
+        // P0 修复：install 先行。失败（网络/权限/unknown 安装方式）时未触碰任何
+        // 会话状态，直接返回可操作错误——旧流程先 pause 后 install，失败时
+        // 已暂停/强杀的会话无回滚路径。
+        const install = await performInstall({});
+        if (install._tag === 'install_failed') {
+            return apiError(c, 409, 'INSTALL_FAILED', install.error, {
+                command: manualInstallCommand('c0de-agent'),
+            });
+        }
+        if (install._tag === 'manual_install_required') {
+            return apiError(c, 409, 'MANUAL_UPDATE_REQUIRED', install.error, {
+                command: install.command,
+            });
+        }
+        const method = { kind: install.installMethod };
+        // 安装已成功 → 暂停所有活跃 run，等其到达安全暂停点（原子操作完成）。
+        // 注意：暂停不是「可恢复快照」——新实例只有 DB 状态、无内存 agent run，
+        // 进行中的对话会以 interrupted 呈现，用户重发上一条消息即可继续（幂等
+        // 检查跳过重复 append）。工具副作用不回滚。
         const pauseTimeoutMs = ctx.config.update.pauseTimeoutMs ?? 30_000;
         const pauseResult = await ctx.agentManager.pauseAll(pauseTimeoutMs);
-        const snapshot = await serializeSessions(ctx.db, ctx.config);
-        const r = await performHotUpdate(snapshot, {
+        const snapshot = await serializeSessions(ctx.db, ctx.config, 
+        // P1：终端元信息随快照迁移——新实例按原 id 原位重建 shell，
+        // 前端持久化布局重连无感（进程内状态无法续命，这是最优恢复）。
+        ctx.ptyManager.list().map((t) => {
+            const command = rerunIds.has(t.id) ? captureForegroundCommand(t.pid) : null;
+            return {
+                id: t.id,
+                shell: t.shell,
+                cwd: t.cwd,
+                title: t.title,
+                ...(t.projectId ? { projectId: t.projectId } : {}),
+                ...(command ? { command } : {}),
+            };
+        }));
+        const r = await performHandoff(snapshot, method, {
             handoffPort: ctx.handoff.port,
             port: ctx.port,
+            ...(ctx.host ? { host: ctx.host } : {}),
             // P2-16：传当前 bootstrap（轮换后 ctx.authToken 可能已过期）；
             // 旧实例 handoff 端点经 verifyHandoff 接受当前/历史 bootstrap 与设备 token。
             authToken: ctx.authManager?.bootstrap ?? ctx.authToken,
         });
-        if (r._tag === 'success') {
-            return c.json({
-                ok: true,
-                snapshotPath: r.snapshotPath,
-                latestVersion: result.latestVersion,
-                installMethod: r.installMethod,
-                pausedSessions: pauseResult.paused,
-                forcedAbort: pauseResult.forcedAbort,
+        if (r._tag !== 'success') {
+            // P0 回滚：spawn 失败（含程序文件未就绪等）→ 恢复被暂停的会话。
+            // forcedAbort 的无法恢复（已中止），但这是超时兜底，属可接受损失。
+            for (const id of pauseResult.pausedIds) {
+                ctx.agentManager.resume(id);
+            }
+            if (r._tag === 'manual_install_required') {
+                return apiError(c, 409, 'MANUAL_UPDATE_REQUIRED', r.error, {
+                    command: r.command,
+                    snapshotPath: r.snapshotPath,
+                    resumedSessions: pauseResult.pausedIds.length,
+                });
+            }
+            return apiError(c, 500, 'HOT_UPDATE_FAILED', `${r._tag}: ${r.error}`, {
+                resumedSessions: pauseResult.pausedIds.length,
             });
         }
-        if (r._tag === 'manual_install_required') {
-            // P0-2：无法自动安装（未知安装方式/自动安装失败/等待超时）→ 引导手动更新
-            return apiError(c, 409, 'MANUAL_UPDATE_REQUIRED', r.error, {
-                command: r.command,
-                snapshotPath: r.snapshotPath,
-            });
-        }
-        return apiError(c, 500, 'HOT_UPDATE_FAILED', `${r._tag}: ${'error' in r ? r.error : 'unknown'}`);
+        return c.json({
+            ok: true,
+            snapshotPath: r.snapshotPath,
+            latestVersion: result.latestVersion,
+            installMethod: r.installMethod,
+            pausedSessions: pauseResult.paused,
+            forcedAbort: pauseResult.forcedAbort,
+        });
     });
     return app;
 }

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

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

package/dist/server/routes/usage.js

@@ -0,0 +1,133 @@
+// src/server/routes/usage.ts
+// 用量/成本聚合端点（P2 成本聚合视图）。数据源：usage_events 账本表——
+// 与 session 生命周期解耦：会话物理清除（回收站到期宽限期满/彻底删除/临时会话
+// 清理）不抹去已发生花费。cost=null 的调用（价格未知）按 $0 计入并单独计数
+// （unknownCostCalls），前端据此提示预算可能低估。
+// ?projectId= 过滤为「该项目口径」聚合：项目设置页的月度预算按本项目成本对比，
+// 不再被其他项目的花费触发告警。月份键为本地时区 YYYY-MM（与服务端同机）。
+import { eq, sql } from 'drizzle-orm';
+import { Hono } from 'hono';
+import { usageEvents } from '../../db/schema.js';
+import { PRICE_CATALOG_VERSION } from '../../llm/registry.js';
+import { localMonthKey } from '../../session/usage.js';
+const emptyTotals = () => ({
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheRead: 0,
+    cost: 0,
+    unknownCostCalls: 0,
+    calls: 0,
+});
+const add = (t, input, output, cacheRead, cost, unknownCostCalls, calls) => {
+    t.inputTokens += input;
+    t.outputTokens += output;
+    t.cacheRead += cacheRead;
+    t.cost += cost;
+    t.unknownCostCalls += unknownCostCalls;
+    t.calls += calls;
+};
+/** 服务端本地时区名（SQL 月份分组用；与 localMonthKey 的本地口径一致）。
+ *  IANA 名在 PGLite 的 tzdata 中可用（已实证 Asia/Shanghai 等常见时区）；
+ *  极端不可用时回退 UTC——分组可能跨月边界漂移，但聚合不再 O(全表)。 */
+function serverTimeZone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+    }
+    catch {
+        return 'UTC';
+    }
+}
+function createUsageRoute(ctx) {
+    const app = new Hono();
+    // GET /api/usage/summary?projectId= — 总量 + 按月 + 按模型。
+    // projectId 提供时仅聚合该项目的调用（项目设置页预算口径）；
+    // 省略时全库聚合（含已删除项目产生的无归属调用）。
+    // P2 修复：此前全表 select 进内存手工聚合，usage_events 无界增长后每次
+    // 打开用量面板 O(全部行) 内存与耗时。现在按（本地月份，provider, model,
+    // projectId）SQL GROUP BY 聚合，结果行数 O(月份数 × 模型数)。
+    app.get('/summary', async (c) => {
+        const projectId = c.req.query('projectId');
+        const where = projectId ? eq(usageEvents.projectId, projectId) : undefined;
+        // SQL 注入面：tz 名来自本机运行时（Intl），经字符白名单校验后以内联字面量
+        // 拼接（白名单已排除单引号，无注入面）。必须内联而非参数占位——SELECT 与
+        // GROUP BY 中各出现一次的参数化表达式被 PG 判定为不同表达式而拒绝 group by。
+        const tz = serverTimeZone();
+        if (!/^[A-Za-z0-9_+\-/]+$/.test(tz)) {
+            const monthKey = localMonthKey(Date.now());
+            return c.json({
+                totals: emptyTotals(),
+                byMonth: [],
+                byModel: [],
+                currentMonth: { key: monthKey, ...emptyTotals() },
+            });
+        }
+        const monthExpr = sql `to_char(to_timestamp(${usageEvents.timestamp} / 1000.0) AT TIME ZONE '${sql.raw(tz)}', 'YYYY-MM')`;
+        const rows = await ctx.db.db
+            .select({
+            month: monthExpr,
+            provider: usageEvents.provider,
+            model: usageEvents.model,
+            projectId: usageEvents.projectId,
+            input: sql `coalesce(sum(${usageEvents.inputTokens}), 0)::float8`,
+            output: sql `coalesce(sum(${usageEvents.outputTokens}), 0)::float8`,
+            cacheRead: sql `coalesce(sum(${usageEvents.cacheRead}), 0)::float8`,
+            cost: sql `coalesce(sum(${usageEvents.cost}), 0)::float8`,
+            calls: sql `count(*)::int`,
+            unknownCalls: sql `count(*) filter (where ${usageEvents.cost} is null)::int`,
+        })
+            .from(usageEvents)
+            .where(where ?? sql `true`)
+            .groupBy(({ month, provider, model, projectId }) => [month, provider, model, projectId]);
+        const totals = emptyTotals();
+        const byMonth = new Map();
+        const byModel = new Map();
+        // P1-3：未归属任何项目的调用（CLI 未绑定会话、孤儿会话）单独聚合——
+        // 它们不计入任何项目预算，全局视图需明示这一桶。
+        const unassigned = emptyTotals();
+        for (const row of rows) {
+            const modelLabel = `${row.provider ?? '未知'}/${row.model ?? '未知'}`;
+            // real（float4）列 SQL 求和引入浮点噪声（0.1 → 0.10000000149011612），
+            // 金额口径按 6 位小数规整（USD 分以下精度足够，且与旧 JS 侧求和结果一致）。
+            const cost = Math.round((row.cost ?? 0) * 1e6) / 1e6;
+            const input = row.input;
+            const output = row.output;
+            const cacheRead = row.cacheRead;
+            const unknownCalls = row.unknownCalls;
+            const calls = row.calls;
+            add(totals, input, output, cacheRead, cost, unknownCalls, calls);
+            const m = byMonth.get(row.month) ?? emptyTotals();
+            add(m, input, output, cacheRead, cost, unknownCalls, calls);
+            byMonth.set(row.month, m);
+            const mdl = byModel.get(modelLabel) ?? emptyTotals();
+            add(mdl, input, output, cacheRead, cost, unknownCalls, calls);
+            byModel.set(modelLabel, mdl);
+            if (row.projectId === null) {
+                add(unassigned, input, output, cacheRead, cost, unknownCalls, calls);
+            }
+        }
+        // P1-4：本月口径由服务端本地时区计算并下发——此前前端用自己的时区
+        // 过滤 byMonth 找「本月」，远程访问/容器时区不同时与预算暂停判定
+        // （服务端 budgetOverageParts 同用本地时区口径）不一致，徽标显示未超支却被打断。
+        const monthKey = localMonthKey(Date.now());
+        const current = byMonth.get(monthKey) ?? emptyTotals();
+        return c.json({
+            totals,
+            // H3：价目版本随响应下发，前端标注估算可能过期。
+            priceCatalogVersion: PRICE_CATALOG_VERSION,
+            // P1-4：服务端权威本月（key + 聚合），前端徽标/面板不再自行计算。
+            currentMonth: { key: monthKey, ...current },
+            // P1-3：仅全局视图下发（projectId 过滤时未归属桶与该项目无关）。
+            ...(projectId ? {} : { unassigned }),
+            byMonth: [...byMonth.entries()]
+                .sort((a, b) => (a[0] < b[0] ? 1 : -1))
+                .slice(0, 12)
+                .map(([month, t]) => ({ month, ...t })),
+            byModel: [...byModel.entries()]
+                .sort((a, b) => b[1].cost - a[1].cost)
+                .slice(0, 10)
+                .map(([model, t]) => ({ model, ...t })),
+        });
+    });
+    return app;
+}
+export { createUsageRoute };