c0de-agent 1.11.0 → 1.13.0

package/dist/server/routes/project.js

@@ -1,11 +1,24 @@
 // src/server/routes/project.ts
-import { existsSync } from 'node:fs';
+import { existsSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { parse } from 'node:path';
 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 { fromDirectory, getByDirectory, getProject, listProjects, relocateProject, resolveProject, trustProject, updateProjectName, } from '../../project/index.js';
+import { clearTrashMarks } from '../../session/session.js';
+import { generateId } from '../../shared/index.js';
 import { apiError } from '../middleware/error.js';
 import { expandPath } from './filesystem.js';
+/** realpath 失败（目录不存在等）时返回 null，调用方回退原路径。 */
+function realpathSafe(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return null;
+    }
+}
 /** 实时取 git 分支（分支随时变，不存 DB）。worktree 不存在时标记缺失。 */
 function withBranch(project) {
     const worktreeMissing = !existsSync(project.worktree);
@@ -28,8 +41,21 @@ function createProjectRoute(ctx) {
         const list = await listProjects(ctx.db);
         return c.json(list.map(withBranch));
     });
-    // 解析服务端 cwd 对应的项目（未注册则自动创建）
+    // 解析服务端 cwd 对应的项目（未注册则自动创建）。
+    // 注册过滤（P2）：serve 在 home/文件系统根目录启动时不做自动注册——home 不是项目，
+    // 自动注册只会把 home 变成污染项目列表的假项目。已显式注册（/from-directory）的
+    // 目录照常返回，用户主动添加 home 为项目的选择被尊重。
     app.get('/current', async (c) => {
+        const existing = await getByDirectory(ctx.db, ctx.cwd);
+        if (existing)
+            return c.json(withBranch(existing), 200);
+        const dir = realpathSafe(ctx.cwd) ?? ctx.cwd;
+        const home = realpathSafe(homedir());
+        const root = parse(dir).root;
+        if ((home && dir === home) || dir === root) {
+            return apiError(c, 404, 'PROJECT_DIR_REQUIRED', '当前目录（home 目录）不是项目，未自动注册。请在项目目录启动 c0de serve，' +
+                '或在项目列表中显式添加该目录。');
+        }
         const project = await fromDirectory(ctx.db, ctx.cwd);
         return c.json(withBranch(project), 200);
     });
@@ -51,51 +77,128 @@ function createProjectRoute(ctx) {
             return apiError(c, 404, 'NOT_FOUND', 'Project not found');
         return c.json(withBranch(project));
     });
-    // P1-9 + P2-2：删除项目记录（看板级联删除）。
+    // P0-2：显式信任项目——用户在信任确认弹窗中批准项目作用域配置/插件后调用。
+    // 信任是一次性动作（trustedAt 落盘）；此后聊天入口不再拦截本项目。
+    app.post('/:id/trust', async (c) => {
+        const project = await trustProject(ctx.db, c.req.param('id'));
+        if (!project)
+            return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+        return c.json({ ok: true, project: withBranch(project) });
+    });
+    // A1：项目重新定位——目录被移动/重命名后的恢复通道。
+    // 整体迁移会话与看板到新目录身份（替代「删项目 + 逐条恢复 + 看板丢失」）。
+    // 目标目录已注册为另一项目 → 409；有活跃 run → 拒绝（agent 工作目录悬空）。
+    app.post('/:id/relocate', async (c) => {
+        const id = c.req.param('id');
+        const body = (await c.req.json().catch(() => ({})));
+        const directory = typeof body.directory === 'string' ? body.directory.trim() : '';
+        if (!directory)
+            return apiError(c, 400, 'DIRECTORY_REQUIRED', 'directory is required');
+        if (!existsSync(directory)) {
+            return apiError(c, 400, 'DIRECTORY_MISSING', `目录不存在或不可访问：${directory}`);
+        }
+        // 活跃 run 守卫（与 DELETE 同语义；含 starting 占位态）
+        const rows = await ctx.db.db
+            .select({ id: sessions.id })
+            .from(sessions)
+            .where(eq(sessions.projectId, id));
+        const activeCount = rows.filter((r) => ctx.agentManager.get(r.id) !== undefined || ctx.agentManager.isStarting(r.id)).length;
+        if (activeCount > 0) {
+            return apiError(c, 409, 'PROJECT_HAS_ACTIVE_SESSIONS', `项目下有 ${activeCount} 个进行中的对话，请先中止后再重新定位`);
+        }
+        // P2-5：打开的终端守卫——终端绑定项目 worktree，重定位后 shell 仍留在旧目录，
+        // cwd 身份悬空。与活跃 run 同语义：先关闭再操作。
+        const openTerminals = ctx.ptyManager.list().filter((t) => t.projectId === id);
+        if (openTerminals.length > 0) {
+            return apiError(c, 409, 'PROJECT_HAS_OPEN_TERMINALS', `项目下有 ${openTerminals.length} 个打开的终端，请先关闭终端后再重新定位`);
+        }
+        try {
+            const project = await relocateProject(ctx.db, id, directory);
+            return c.json({ ok: true, project: withBranch(project) });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg === 'PROJECT_NOT_FOUND')
+                return apiError(c, 404, 'PROJECT_NOT_FOUND', '项目不存在');
+            if (msg.startsWith('TARGET_OCCUPIED')) {
+                return apiError(c, 409, 'TARGET_OCCUPIED', msg.replace('TARGET_OCCUPIED: ', ''));
+            }
+            return apiError(c, 500, 'RELOCATE_FAILED', msg);
+        }
+    });
+    // P1-9 + P2-2：删除项目记录。
     // 会话不再留孤儿（FK set null 后在任何项目视图都不可见且 cwd 回退 serve 目录）：
-    // 删除前把该项目全部未删除会话软删除进回收站（30 天内可恢复），
+    // 删除前把该项目全部未删除会话软删除进回收站（60 天内可恢复），
     // 并把 worktreePath 落盘——恢复后 resolveAgentCwd 仍能解析原工作目录。
+    // P2-5：看板同步软删除进回收站（可恢复/重新归属），不再永久级联销毁。
     // 有活跃 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);
+        // 活跃 run 守卫：该项目下任一进行中（含占位 isStarting）的会话 → 拒绝。
+        // P1 修复：原实现先查 agentManager.children(projectId)——children 按
+        // parentSessionId（子 agent 归属）过滤，项目 id 恒不命中属死代码；且回退
+        // 检查只用 get() 漏掉 tryAcquire 后的 starting 占位态，窗口内删除会让 run
+        // 继续向已软删除会话写消息。现在直接按项目会话查 get()+isStarting()。
+        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) !== undefined || ctx.agentManager.isStarting(r.id));
+        if (active.length > 0) {
+            return apiError(c, 409, 'PROJECT_HAS_ACTIVE_SESSIONS', `项目下有 ${active.length} 个进行中的对话，请先中止后再删除`);
         }
-        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} 个进行中的对话，请先中止后再删除`);
-            }
+        // P2-5：打开的终端守卫——项目删除后其 worktree 上的 PTY 仍继续运行，
+        // cwd 指向已注销身份的目录。与活跃 run 同语义：先关闭再删除。
+        const openTerminals = ctx.ptyManager.list().filter((t) => t.projectId === id);
+        if (openTerminals.length > 0) {
+            return apiError(c, 409, 'PROJECT_HAS_OPEN_TERMINALS', `项目下有 ${openTerminals.length} 个打开的终端，请先关闭终端后再删除项目`);
         }
         let deletedSessions = 0;
         await ctx.db.db.transaction(async (tx) => {
-            // 该项目下所有未删除会话：记录 worktreePath（若尚无）并软删除进回收站
+            // 该项目下所有未删除会话：记录 worktreePath（若尚无）并软删除进回收站。
+            // A2：删除项目是一次用户操作——全部会话共享同一 deletedBatchId，
+            // 恢复任一会话时其 fork 子树一并还原（与 softDeleteSession 语义对齐），
+            // 不再因批次断裂导致分支滞留回收站被静默清除。
             const now = new Date();
+            const batchId = generateId();
             const bound = await tx
-                .select({ id: sessions.id, worktreePath: sessions.worktreePath })
+                .select({
+                id: sessions.id,
+                worktreePath: sessions.worktreePath,
+                metadata: sessions.metadata,
+            })
                 .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));
+                // A3：软删除清除回收站倒计时/宽限期标记（恢复后重删须重新看到才起算）。
+                const metadata = clearTrashMarks((s.metadata ?? {}));
+                await tx
+                    .update(sessions)
+                    .set({
+                    worktreePath: s.worktreePath ?? project.worktree,
+                    deletedAt: now,
+                    deletedBatchId: batchId,
+                    metadata,
+                })
+                    .where(eq(sessions.id, s.id));
                 deletedSessions += 1;
             }
-            await tx.delete(kanbanBoards).where(eq(kanbanBoards.projectId, id));
+            // P2-5：看板不再永久级联销毁——标记软删除（记录原项目名），项目行删除后
+            // FK set null 使其进入回收站「未归属看板」分组，60 天后随清理任务物理清除；
+            // 恢复端点可重新归属到任意项目。
+            await tx
+                .update(kanbanBoards)
+                .set({
+                deletedAt: now,
+                deletedProjectName: project.name ?? project.worktree,
+                deletedProjectWorktree: project.worktree,
+                purgePendingAt: null,
+                updatedAt: now,
+            })
+                .where(and(eq(kanbanBoards.projectId, id), isNull(kanbanBoards.deletedAt)));
             await tx.delete(projects).where(eq(projects.id, id));
         });
         return c.json({ ok: true, deletedSessions });

package/dist/server/routes/provider.js

@@ -1,6 +1,10 @@
 import { Hono } from 'hono';
+import { loadConfigScopes, mergeConfig } from '../../core/config.js';
 import { decryptSecret } from '../../core/secret.js';
+import { resolveRoute } from '../../llm/registry.js';
+import { getProject } from '../../project/project.js';
 import { apiError } from '../middleware/error.js';
+import { buildRegistryFromConfig } from '../registry-config.js';
 /**
  * 用给定 baseURL/apiKey 探测 OpenAI 兼容的 /models 端点。
  * baseURL 应自行包含版本路径（如 https://api.openai.com/v1）。
@@ -39,15 +43,56 @@ async function probeModels(baseURL, apiKey) {
 }
 function createProviderRoute(ctx) {
     const app = new Hono();
+    /** P1-1：解析目标项目配置与注册表（?projectId= 提供时按该项目合并配置）。
+     *  项目配置从磁盘实时读取（配置体量小）；注册表优先用会话聊天路径缓存的。 */
+    const resolveForProject = async (c) => {
+        const projectId = c.req.query('projectId');
+        if (!projectId)
+            return { config: ctx.config, registry: ctx.llmRegistry };
+        const project = await getProject(ctx.db, projectId);
+        if (!project)
+            return null;
+        const scopes = loadConfigScopes(project.worktree);
+        const config = mergeConfig(scopes.global, scopes.project);
+        const registry = config.providers.length > 0 ? buildRegistryFromConfig(config) : ctx.llmRegistry;
+        return { config, registry };
+    };
     // 列出已配置 providers（apiKey 脱敏，不含明文）
-    app.get('/', (c) => {
-        const providers = ctx.config.providers.map((p) => ({
+    app.get('/', async (c) => {
+        const resolved = await resolveForProject(c);
+        if (!resolved)
+            return apiError(c, 404, 'PROJECT_NOT_FOUND', '项目不存在');
+        const providers = resolved.config.providers.map((p) => ({
             name: p.name || p._tag || '',
             protocol: p.protocol,
             baseURL: p.baseURL ?? '',
             hasKey: !!p.apiKey,
         }));
-        return c.json({ providers, defaultProvider: ctx.config.defaultProvider });
+        return c.json({ providers, defaultProvider: resolved.config.defaultProvider });
+    });
+    // 模型能力查询：前端据此控制多模态入口（supportsVision）等
+    app.get('/capabilities', async (c) => {
+        const provider = c.req.query('provider');
+        const model = c.req.query('model');
+        if (!provider || !model) {
+            return apiError(c, 400, 'BAD_REQUEST', 'provider and model are required');
+        }
+        const project = await resolveForProject(c);
+        if (!project)
+            return apiError(c, 404, 'PROJECT_NOT_FOUND', '项目不存在');
+        try {
+            const route = resolveRoute(project.registry, provider, model);
+            return c.json({
+                provider,
+                model,
+                supportsVision: route.capabilities.supportsVision,
+                supportsThinking: route.capabilities.supportsThinking,
+                contextWindow: route.capabilities.contextWindow,
+            });
+        }
+        catch {
+            return apiError(c, 404, 'NOT_FOUND', 'provider/model not registered');
+        }
     });
     // 连接测试：用请求体里的凭据探测 /models，不污染 registry
     app.post('/test', async (c) => {
@@ -55,6 +100,12 @@ function createProviderRoute(ctx) {
         const { baseURL, apiKey } = body;
         if (!baseURL)
             return apiError(c, 400, 'BAD_REQUEST', 'baseURL is required');
+        // P3：仅允许 http/https——服务端按调用方提供的 URL 发起请求，非 http 协议
+        // 不应由「测试连接」端点代理（本机 localhost/Ollama 等 http 服务不受影响）。
+        const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(baseURL)?.[1]?.toLowerCase();
+        if (!scheme || (scheme !== 'http' && scheme !== 'https')) {
+            return apiError(c, 400, 'BAD_REQUEST', 'baseURL must be an http(s) URL');
+        }
         // apiKey 可能是 Settings 页回传的 enc: 密文（保存后刷新、未重输时）：探测前解密，
         // 否则把 enc: 串当 Bearer token 发给上游必然 401，造成「保存了却测试失败」的误判。
         const secret = apiKey ? decryptSecret(apiKey) : '';