c0de-agent 1.9.0 → 1.11.0

package/dist/server/routes/permissions.js

@@ -1,14 +1,16 @@
 import { Hono } from 'hono';
 import { apiError } from '../middleware/error.js';
-/** GET/PUT /api/permissions — 全局授权模式（default 逐个确认 / auto 自动放行 ask 工具）。 */
+/** GET/PUT /api/permissions — 授权模式（default 逐个确认 / auto 自动放行 ask 工具）。
+ *  - 根路径：默认模式（全局，启动时取 config.permission.defaultMode）
+ *  - /:sessionId：会话级覆盖（P1-5 按会话隔离 auto 高风险状态）
+ */
 function createPermissionsRoute(ctx) {
     const app = new Hono();
-    // GET / — 当前授权模式
+    // GET / — 默认授权模式
     app.get('/', (c) => {
         return c.json({ mode: ctx.permissionMode });
     });
-    // PUT / — 运行时切换授权模式（仅本次运行生效，不回写 config；
-    // 重启后回到 config.permission.defaultMode 持久化默认值）
+    // PUT / — 运行时切换默认模式（仅本次运行生效，不回写 config）
     app.put('/', async (c) => {
         const body = (await c.req.json().catch(() => null));
         const mode = body?.mode;
@@ -18,6 +20,27 @@ function createPermissionsRoute(ctx) {
         ctx.permissionMode = mode;
         return c.json({ mode: ctx.permissionMode });
     });
+    // GET /:sessionId — 会话实际生效模式（覆盖优先，回退默认）
+    app.get('/:sessionId', (c) => {
+        const sessionId = c.req.param('sessionId');
+        return c.json({ mode: ctx.sessionPermissionModes.get(sessionId) ?? ctx.permissionMode });
+    });
+    // PUT /:sessionId — 设置会话级覆盖；不传 mode 则清除覆盖
+    app.put('/:sessionId', async (c) => {
+        const sessionId = c.req.param('sessionId');
+        const body = (await c.req.json().catch(() => null));
+        const mode = body?.mode;
+        if (mode !== undefined && mode !== 'default' && mode !== 'auto') {
+            return apiError(c, 400, 'INVALID_MODE', "mode 必须是 'default' 或 'auto'");
+        }
+        if (mode === undefined) {
+            ctx.sessionPermissionModes.delete(sessionId);
+        }
+        else {
+            ctx.sessionPermissionModes.set(sessionId, mode);
+        }
+        return c.json({ mode: ctx.sessionPermissionModes.get(sessionId) ?? ctx.permissionMode });
+    });
     return app;
 }
 export { createPermissionsRoute };

package/dist/server/routes/project.js

@@ -1,10 +1,15 @@
+// src/server/routes/project.ts
+import { existsSync } from 'node:fs';
+import { and, eq, isNull } from 'drizzle-orm';
 import { Hono } from 'hono';
+import { kanbanBoards, projects, sessions } from '../../db/schema.js';
 import { fromDirectory, getProject, listProjects, resolveProject, updateProjectName, } from '../../project/index.js';
 import { apiError } from '../middleware/error.js';
 import { expandPath } from './filesystem.js';
-/** 实时取 git 分支（分支随时变，不存 DB）。 */
+/** 实时取 git 分支（分支随时变，不存 DB）。worktree 不存在时标记缺失。 */
 function withBranch(project) {
-    return { ...project, gitBranch: resolveProject(project.worktree).gitBranch };
+    const worktreeMissing = !existsSync(project.worktree);
+    return { ...project, gitBranch: resolveProject(project.worktree).gitBranch, worktreeMissing };
 }
 function createProjectRoute(ctx) {
     const app = new Hono();
@@ -46,6 +51,55 @@ function createProjectRoute(ctx) {
             return apiError(c, 404, 'NOT_FOUND', 'Project not found');
         return c.json(withBranch(project));
     });
+    // P1-9 + P2-2：删除项目记录（看板级联删除）。
+    // 会话不再留孤儿（FK set null 后在任何项目视图都不可见且 cwd 回退 serve 目录）：
+    // 删除前把该项目全部未删除会话软删除进回收站（30 天内可恢复），
+    // 并把 worktreePath 落盘——恢复后 resolveAgentCwd 仍能解析原工作目录。
+    // 有活跃 run 绑定该项目时拒绝删除，避免 agent 工作目录悬空。
+    app.delete('/:id', async (c) => {
+        const id = c.req.param('id');
+        const project = await getProject(ctx.db, id);
+        if (!project)
+            return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+        // 活跃 run 守卫：任一活跃会话归属于该项目 → 拒绝
+        const activeSessionIds = new Set();
+        for (const run of ctx.agentManager.children(id)) {
+            activeSessionIds.add(run.sessionId);
+        }
+        if (activeSessionIds.size === 0) {
+            // 检查该项目下是否有正在进行（含占位）的会话
+            const rows = await ctx.db.db
+                .select({ id: sessions.id, projectId: sessions.projectId })
+                .from(sessions)
+                .where(and(eq(sessions.projectId, id)));
+            const active = rows.filter((r) => ctx.agentManager.get(r.id));
+            if (active.length > 0) {
+                return apiError(c, 409, 'PROJECT_HAS_ACTIVE_SESSIONS', `项目下有 ${active.length} 个进行中的对话，请先中止后再删除`);
+            }
+        }
+        let deletedSessions = 0;
+        await ctx.db.db.transaction(async (tx) => {
+            // 该项目下所有未删除会话：记录 worktreePath（若尚无）并软删除进回收站
+            const now = new Date();
+            const bound = await tx
+                .select({ id: sessions.id, worktreePath: sessions.worktreePath })
+                .from(sessions)
+                .where(and(eq(sessions.projectId, id), isNull(sessions.deletedAt)));
+            for (const s of bound) {
+                if (!s.worktreePath) {
+                    await tx
+                        .update(sessions)
+                        .set({ worktreePath: project.worktree })
+                        .where(eq(sessions.id, s.id));
+                }
+                await tx.update(sessions).set({ deletedAt: now }).where(eq(sessions.id, s.id));
+                deletedSessions += 1;
+            }
+            await tx.delete(kanbanBoards).where(eq(kanbanBoards.projectId, id));
+            await tx.delete(projects).where(eq(projects.id, id));
+        });
+        return c.json({ ok: true, deletedSessions });
+    });
     return app;
 }
 export { createProjectRoute };

package/dist/server/routes/session.js

@@ -2,9 +2,9 @@ import { Hono } from 'hono';
 import { createSummarizer, runCompaction } from '../../core/compact.js';
 import { fromDirectory } from '../../project/index.js';
 import { archiveOriginalEntries } from '../../session/archive.js';
-import { forkSession, getBranches, getTree } from '../../session/branch.js';
+import { BranchPointOutOfRangeError, forkSession, getBranches, getTree, } from '../../session/branch.js';
 import { deleteEntriesByIds, getMessages, insertEntry } from '../../session/message.js';
-import { createSession, deleteSession, getLLMSegments, getSession, listSessions, listSessionsByProject, touchLastOpened, } from '../../session/session.js';
+import { createSession, getLLMSegments, getSession, listDeletedSessions, listSessions, listSessionsByProject, restoreSession, softDeleteSession, touchLastOpened, } from '../../session/session.js';
 import { applyShakeRegions, collectShakeRegions, DEFAULT_SHAKE_CONFIG, toRegionViews, } from '../../session/shake.js';
 import { estimateMessageTokens } from '../../session/token.js';
 import { generateId } from '../../shared/index.js';
@@ -41,6 +41,11 @@ function createSessionRoute(ctx) {
         const tree = await getTree(ctx.db);
         return c.json(tree);
     });
+    // 回收站：已软删除的会话列表（必须注册在 /:id 之前，避免被参数路由吞掉）
+    app.get('/deleted', async (c) => {
+        const sessions = await listDeletedSessions(ctx.db);
+        return c.json(sessions);
+    });
     // 获取会话详情
     app.get('/:id', async (c) => {
         try {
@@ -54,24 +59,44 @@ function createSessionRoute(ctx) {
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         }
     });
-    // 分支会话
+    // 分支会话：未指定 messageIndex 时默认在最新一条消息处分叉（fork=完整副本语义）
     app.post('/:id/fork', async (c) => {
         const id = c.req.param('id');
         const body = await c.req.json().catch(() => ({}));
-        const messageIndex = body.messageIndex ?? 0;
+        let messageIndex = body.messageIndex;
+        if (messageIndex === undefined || !Number.isFinite(messageIndex)) {
+            const messages = await getMessages(ctx.db, id);
+            if (messages.length === 0) {
+                return apiError(c, 400, 'EMPTY_SESSION', '空会话无法分支');
+            }
+            messageIndex = messages.length - 1;
+        }
         try {
             const forked = await forkSession(ctx.db, id, messageIndex);
             return c.json(forked, 201);
         }
-        catch {
+        catch (error) {
+            // 分支点越界是客户端索引/分页 bug → 400 并透出明确语义；归 404 会误导排查
+            if (error instanceof BranchPointOutOfRangeError) {
+                return apiError(c, 400, 'BRANCH_POINT_OUT_OF_RANGE', error.message);
+            }
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         }
     });
-    // 删除会话
+    // 删除会话（软删除：级联其 fork 后代进入回收站，30 天后物理清除）
     app.delete('/:id', async (c) => {
-        await deleteSession(ctx.db, c.req.param('id'));
+        const ok = await softDeleteSession(ctx.db, c.req.param('id'));
+        if (!ok)
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         return c.body(null, 204);
     });
+    // 恢复会话（从回收站还原；仅还原该会话本身）
+    app.post('/:id/restore', async (c) => {
+        const ok = await restoreSession(ctx.db, c.req.param('id'));
+        if (!ok)
+            return apiError(c, 404, 'NOT_FOUND', '会话不存在或未删除');
+        return c.json({ ok: true });
+    });
     // 获取消息列表
     app.get('/:id/messages', async (c) => {
         const messages = await getMessages(ctx.db, c.req.param('id'));
@@ -113,13 +138,16 @@ function createSessionRoute(ctx) {
         }
     });
     // 获取会话状态：内存有活跃 run → 返回其 status；否则查 DB lastRun。
-    // lastRun.status='running' 但无活跃 run → 服务重启被中断。
+    // lastRun.status='running' 且无活跃 run → 服务重启被中断。
+    // lastRun.status='paused' 但无活跃 run（热更新/重启后 run 状态未迁移）→ 同样按中断处理：
+    // agent 内存态已丢失，resume 端点无法恢复，唯一可行路径是重发上一条消息。
     app.get('/:id/status', async (c) => {
         const run = ctx.agentManager.get(c.req.param('id'));
         if (run)
             return c.json(run.state.status);
         const session = await getSession(ctx.db, c.req.param('id'));
-        if (session?.metadata.lastRun?.status === 'running') {
+        if (session?.metadata.lastRun?.status === 'running' ||
+            session?.metadata.lastRun?.status === 'paused') {
             return c.json({ _tag: 'interrupted' });
         }
         return c.json({ _tag: 'idle' });

package/dist/server/routes/terminal.js

@@ -1,6 +1,11 @@
 // src/server/routes/terminal.ts
+import { existsSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
 import { Hono } from 'hono';
+import { getProject } from '../../project/index.js';
 import { apiError } from '../middleware/error.js';
+/** 允许的 shell 白名单（P2-6：拒绝路径分隔符与任意二进制）。 */
+const ALLOWED_SHELLS = new Set(['bash', 'zsh', 'fish', 'sh']);
 /** 创建终端路由（REST 部分；WebSocket 升级在 server.ts 中处理）。 */
 function createTerminalRoute(ctx) {
     const app = new Hono();
@@ -12,12 +17,34 @@ function createTerminalRoute(ctx) {
     // 创建新 PTY 会话
     app.post('/', async (c) => {
         const body = await c.req.json().catch(() => ({}));
-        const cwd = typeof body.cwd === 'string' && body.cwd.length > 0 ? body.cwd : ctx.cwd;
+        const projectId = typeof body.projectId === 'string' && body.projectId.length > 0 ? body.projectId : undefined;
+        // P2-13：未显式传 cwd 且带 projectId 时，默认目录跟随项目 worktree
+        // （与 chat 的 resolveAgentCwd 行为一致；项目缺失/目录失效时回退 ctx.cwd）。
+        let defaultCwd = ctx.cwd;
+        if (!(typeof body.cwd === 'string' && body.cwd.length > 0) && projectId) {
+            try {
+                const project = await getProject(ctx.db, projectId);
+                if (project && existsSync(project.worktree))
+                    defaultCwd = project.worktree;
+            }
+            catch {
+                // db 不可用（测试桩/临时故障）：保持 ctx.cwd
+            }
+        }
+        const cwd = typeof body.cwd === 'string' && body.cwd.length > 0 ? body.cwd : defaultCwd;
         const cols = Number.isFinite(body.cols) ? Number(body.cols) : undefined;
         const rows = Number.isFinite(body.rows) ? Number(body.rows) : undefined;
         const title = typeof body.title === 'string' ? body.title : undefined;
         const shell = typeof body.shell === 'string' && body.shell.length > 0 ? body.shell : undefined;
-        const projectId = typeof body.projectId === 'string' && body.projectId.length > 0 ? body.projectId : undefined;
+        // 入参校验（P2-6）：shell 白名单；cwd 必须为绝对路径。
+        if (shell !== undefined) {
+            if (shell.includes('/') || shell.includes('\\') || !ALLOWED_SHELLS.has(shell)) {
+                return apiError(c, 400, 'INVALID_SHELL', `shell 必须是 ${[...ALLOWED_SHELLS].join('/')} 之一`);
+            }
+        }
+        if (typeof cwd === 'string' && cwd.length > 0 && !isAbsolute(cwd)) {
+            return apiError(c, 400, 'INVALID_CWD', 'cwd 必须是绝对路径');
+        }
         try {
             const info = mgr.create({ cwd, cols, rows, title, shell, projectId });
             return c.json(info, 201);

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

@@ -9,6 +9,7 @@ import type { ServerContext } from '../types.js';
  *   序列化当前会话 → performHotUpdate（npm install -g + spawn 新实例 + handoffPort）。
  *   旧实例通过 handoff 端点优雅退出，新实例 restore 快照并接管端口。
  *   响应立即返回（不阻塞 spawn），实际接管由 handoff IPC 异步完成。
+ *   dev（vite）模式无 handoff server，返回 409——热更新仅在独立 serve 进程可用。
  */
 declare function createUpdateRoute(ctx: ServerContext): Hono;
 export { createUpdateRoute };

package/dist/server/routes/update.js

@@ -1,5 +1,5 @@
 import { Hono } from 'hono';
-import { performHotUpdate, serializeSessions } from '../../update/index.js';
+import { getCurrentVersion, performHotUpdate, serializeSessions } from '../../update/index.js';
 import { apiError } from '../middleware/error.js';
 /**
  * GET /api/update — 返回后台调度器缓存的版本检查结果（spec §18.1）。
@@ -10,36 +10,65 @@ import { apiError } from '../middleware/error.js';
  *   序列化当前会话 → performHotUpdate（npm install -g + spawn 新实例 + handoffPort）。
  *   旧实例通过 handoff 端点优雅退出，新实例 restore 快照并接管端口。
  *   响应立即返回（不阻塞 spawn），实际接管由 handoff IPC 异步完成。
+ *   dev（vite）模式无 handoff server，返回 409——热更新仅在独立 serve 进程可用。
  */
 function createUpdateRoute(ctx) {
     const app = new Hono();
     app.get('/', (c) => {
+        // 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 });
+        }
         const cached = ctx.updateScheduler.getLastResult();
         if (cached)
             return c.json(cached);
         // 无缓存（首次启动延迟未到）：同步触发一次，避免前端首屏空。
         // 不 await——保持 GET 语义非阻塞；前端下次轮询拿到结果。
         void ctx.updateScheduler.checkNow();
+        const v = getCurrentVersion();
         return c.json({
             hasUpdate: false,
-            currentVersion: '0.0.0',
-            latestVersion: '0.0.0',
+            currentVersion: v,
+            latestVersion: v,
         });
     });
     app.post('/apply', async (c) => {
+        if (!ctx.handoff) {
+            return apiError(c, 409, 'HOT_UPDATE_UNAVAILABLE', '热更新仅在独立 serve 进程可用（dev 模式请手动更新）');
+        }
         const result = await ctx.updateScheduler.checkNow();
         if (!result.hasUpdate) {
             return apiError(c, 409, 'NO_UPDATE', '已是最新版本，无需热更新');
         }
+        // P1-8：热更新前先暂停所有活跃 run，等其到达安全暂停点（原子操作完成）。
+        // 暂停状态已持久化（lastRun.status='paused'），新实例接管后可恢复继续执行。
+        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, {
-            handoffPort: ctx.handoff?.port,
+            handoffPort: ctx.handoff.port,
+            port: ctx.port,
+            // 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 === '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'}`);

package/dist/server/routes/workflows.js

@@ -2,9 +2,9 @@ import { unlink } from 'node:fs/promises';
 import { Hono } from 'hono';
 import { streamSSE } from 'hono/streaming';
 import { createAgent } from '../../core/agent.js';
-import { executeWorkflow } from '../../core/workflows/runtime.js';
-import { reloadRegistry } from '../../core/workflows/registry.js';
 import { discoverWorkflows, saveWorkflow } from '../../core/workflows/discovery.js';
+import { reloadRegistry } from '../../core/workflows/registry.js';
+import { executeWorkflow } from '../../core/workflows/runtime.js';
 import { getProject } from '../../project/project.js';
 import { createSession } from '../../session/session.js';
 import { autoAllowChecker } from '../../tools/permission.js';

package/dist/server/server.d.ts

@@ -23,6 +23,8 @@ type StartServerOptions = {
 type RunningServer = {
     app: Hono;
     port: number;
+    /** 认证 token（authEnabled=false 时为 undefined）；serve 命令据此打印带 token 的 URL。 */
+    authToken?: string;
     close(): Promise<void>;
 };
 type BootstrappedServer = {
@@ -43,6 +45,15 @@ declare function syncRegistryFromConfig(registry: Registry, config: Config): voi
  * 历史上数据库放在 <cwd>/.c0de/pglite（项目级），但项目 DB schema 通过 projectId
  * 区分项目，设计本意是全局共享单库。旧路径已在 migrateLegacyPglite 中自动迁移。 */
 declare function resolveDbDir(): string;
+/**
+ * 认证 token 解析（P0 安全修复）：
+ * 1. security.authEnabled 显式为 false → 无认证（用户显式选择）。
+ * 2. 用户配置 security.token → 使用。
+ * 3. 环境变量 C0DE_AUTH_TOKEN（热更新新实例经 updater 传入）→ 采用并落盘。
+ * 4. dataDir 下 auth-token 文件（跨重启/热更新稳定）→ 复用。
+ * 5. 都没有 → 生成随机 token 并写入 auth-token（0600）。
+ */
+declare function resolveAuthToken(config: Config, dataDir: string): string | undefined;
 /**
  * 围绕已有 DB handle 组装 ServerContext（不建/不关闭 DB）。
  *
@@ -54,6 +65,18 @@ declare function buildServerContext(db: DB, opts?: StartServerOptions): Promise<
     ctx: ServerContext;
     dispose: () => Promise<void>;
 }>;
+/**
+ * Cross-process guard for PGLite dataDir.
+ *
+ * PGLite is single-writer WASM Postgres — two processes on the same dataDir
+ * always abort (`RuntimeError: Aborted()`). This lock prevents silent
+ * corruption when multiple dev servers (e.g. different ports) target the
+ * same project.
+ *
+ * - Live PID in lock → throw clear error instead of cryptic WASM abort.
+ * - Dead PID in lock → stale: remove `.dev.lock` + `postmaster.pid`, proceed.
+ */
+declare function acquireDevDbLock(dataDir: string): void;
 /** Release the dev DB lock (best-effort, stale-detection covers missed calls). */
 declare function releaseDevDbLock(dataDir: string): void;
 /** dev 专用：创建 + migrate PGLite，跨热重载复用（单写者，只建一次）。 */
@@ -62,4 +85,4 @@ declare function createDevDb(cwd: string): Promise<DB>;
 declare function bootstrapServerContext(opts?: StartServerOptions): Promise<BootstrappedServer>;
 declare function startServer(opts?: StartServerOptions): Promise<RunningServer>;
 export type { BootstrappedServer, RunningServer, StartServerOptions };
-export { bootstrapServerContext, buildRegistryFromConfig, buildServerContext, createDevDb, releaseDevDbLock, resolveDbDir, startServer, syncRegistryFromConfig, };
+export { acquireDevDbLock, bootstrapServerContext, buildRegistryFromConfig, buildServerContext, createDevDb, releaseDevDbLock, resolveAuthToken, resolveDbDir, startServer, syncRegistryFromConfig, };