c0de-agent 0.0.0 → 1.0.0

package/dist/server/routes/catalog.js

@@ -0,0 +1,194 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Hono } from 'hono';
+import { apiError } from '../middleware/error.js';
+/** models.dev API URL，可通过环境变量覆盖。 */
+const MODELS_DEV_URL = process.env.C0DE_MODELS_URL || 'https://models.dev/api.json';
+/** 缓存 TTL：5 分钟。 */
+const CACHE_TTL_MS = 5 * 60 * 1000;
+/** 内存缓存。 */
+let memCache = null;
+function getCachePath() {
+    const cacheDir = join(process.cwd(), '.c0de', 'cache');
+    return join(cacheDir, 'models-dev.json');
+}
+/** 清除内存 + 磁盘缓存（主要用于测试）。 */
+function clearCatalogCache() {
+    memCache = null;
+    const p = getCachePath();
+    if (existsSync(p)) {
+        try {
+            unlinkSync(p);
+        }
+        catch {
+            // 忽略删除失败
+        }
+    }
+}
+function readDiskCache() {
+    const p = getCachePath();
+    if (!existsSync(p))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(p, 'utf-8'));
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+function writeDiskCache(data, fetchedAt) {
+    const cacheDir = join(process.cwd(), '.c0de', 'cache');
+    if (!existsSync(cacheDir))
+        mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(getCachePath(), JSON.stringify({ data, fetchedAt }, null, 2), 'utf-8');
+}
+/**
+ * 获取 models.dev 目录数据（带缓存）。
+ * 优先用内存缓存，其次磁盘缓存，最后发起网络请求。
+ */
+async function fetchCatalog(force = false) {
+    const now = Date.now();
+    if (!force && memCache && now - memCache.fetchedAt < CACHE_TTL_MS) {
+        return memCache;
+    }
+    const disk = readDiskCache();
+    if (!force && disk && now - disk.fetchedAt < CACHE_TTL_MS) {
+        memCache = disk;
+        return disk;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 15_000);
+    try {
+        const res = await fetch(MODELS_DEV_URL, {
+            signal: controller.signal,
+            headers: { Accept: 'application/json' },
+        });
+        if (!res.ok) {
+            throw new Error(`HTTP ${res.status}`);
+        }
+        const data = (await res.json());
+        const fetchedAt = now;
+        memCache = { data, fetchedAt };
+        writeDiskCache(data, fetchedAt);
+        return { data, fetchedAt };
+    }
+    catch (err) {
+        // 网络失败时回退到磁盘缓存（即使过期）
+        if (disk) {
+            memCache = disk;
+            return disk;
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** 把内部 Provider 结构转为前端需要的精简列表项。 */
+function toProviderListItem(id, p) {
+    return {
+        id,
+        name: p.name,
+        npm: p.npm,
+        api: p.api,
+        env: p.env,
+        doc: p.doc,
+        modelCount: Object.keys(p.models).length,
+    };
+}
+/** 把内部 Model 结构转为前端需要的精简列表项。 */
+function toModelItem(m) {
+    return {
+        id: m.id,
+        name: m.name,
+        family: m.family,
+        reasoning: m.reasoning,
+        toolCall: m.tool_call,
+        attachment: m.attachment,
+        temperature: m.temperature,
+        context: m.limit.context,
+        output: m.limit.output,
+        costInput: m.cost?.input,
+        costOutput: m.cost?.output,
+    };
+}
+function createCatalogRoute(ctx) {
+    const app = new Hono();
+    void ctx;
+    // 列出所有 providers（精简）
+    app.get('/providers', async (c) => {
+        try {
+            const { data } = await fetchCatalog();
+            const providers = Object.entries(data)
+                .map(([id, p]) => toProviderListItem(id, p))
+                .sort((a, b) => a.name.localeCompare(b.name));
+            return c.json({ providers });
+        }
+        catch (err) {
+            return apiError(c, 502, 'CATALOG_FETCH_FAILED', `Failed to fetch models.dev catalog: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    // 获取指定 provider 的模型列表
+    app.get('/providers/:id/models', async (c) => {
+        const id = c.req.param('id');
+        try {
+            const { data } = await fetchCatalog();
+            const provider = data[id];
+            if (!provider)
+                return apiError(c, 404, 'NOT_FOUND', `Provider "${id}" not found`);
+            const models = Object.values(provider.models)
+                .map(toModelItem)
+                .sort((a, b) => a.name.localeCompare(b.name));
+            return c.json({
+                provider: toProviderListItem(id, provider),
+                models,
+            });
+        }
+        catch (err) {
+            return apiError(c, 502, 'CATALOG_FETCH_FAILED', `Failed to fetch models.dev catalog: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    // 搜索 providers 和 models
+    app.get('/search', async (c) => {
+        const q = c.req.query('q');
+        if (!q)
+            return apiError(c, 400, 'BAD_REQUEST', 'Query parameter q is required');
+        try {
+            const { data } = await fetchCatalog();
+            const lower = q.toLowerCase();
+            const providers = [];
+            const models = [];
+            for (const [id, p] of Object.entries(data)) {
+                const item = toProviderListItem(id, p);
+                const nameMatch = p.name.toLowerCase().includes(lower) || id.toLowerCase().includes(lower);
+                if (nameMatch)
+                    providers.push(item);
+                for (const m of Object.values(p.models)) {
+                    const modelItem = toModelItem(m);
+                    const modelMatch = m.name.toLowerCase().includes(lower) ||
+                        m.id.toLowerCase().includes(lower) ||
+                        m.family?.toLowerCase().includes(lower);
+                    if (modelMatch)
+                        models.push({ ...item, model: modelItem });
+                }
+            }
+            return c.json({ providers, models });
+        }
+        catch (err) {
+            return apiError(c, 502, 'CATALOG_FETCH_FAILED', `Failed to fetch models.dev catalog: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    // 刷新缓存
+    app.post('/refresh', async (c) => {
+        try {
+            await fetchCatalog(true);
+            return c.json({ refreshed: true });
+        }
+        catch (err) {
+            return apiError(c, 502, 'CATALOG_FETCH_FAILED', `Failed to refresh models.dev catalog: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    return app;
+}
+export { clearCatalogCache, createCatalogRoute, fetchCatalog };

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

@@ -0,0 +1,8 @@
+import { Hono } from 'hono';
+import type { ServerContext } from '../types.js';
+/** 按 session.projectId 解析 agent 工作目录；无项目回退 ctx.cwd。 */
+export declare function resolveAgentCwd(ctx: ServerContext, session: {
+    projectId: string | null;
+}): Promise<string>;
+declare function createChatRoute(ctx: ServerContext): Hono;
+export { createChatRoute };

package/dist/server/routes/chat.js

@@ -0,0 +1,282 @@
+import { readFile } from 'node:fs/promises';
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import { createAgent, runAgent } from '../../core/agent.js';
+import { createSlashRegistry, parseSlashInput } from '../../core/slash.js';
+import { getProject } from '../../project/project.js';
+import { getLLMSegments, getSession, updateSessionLastRun } from '../../session/session.js';
+import { upsertFileSnapshot } from '../../session/snapshot.js';
+import { autoAllowChecker } from '../../tools/permission.js';
+import { listTools } from '../../tools/registry.js';
+import { apiError } from '../middleware/error.js';
+import { createInteractivePermissionChecker } from '../permission/interactive.js';
+import { safeResolve } from '../util/safe-path.js';
+/** 按 session.projectId 解析 agent 工作目录；无项目回退 ctx.cwd。 */
+export async function resolveAgentCwd(ctx, session) {
+    if (!session.projectId)
+        return ctx.cwd;
+    const project = await getProject(ctx.db, session.projectId);
+    return project?.worktree ?? ctx.cwd;
+}
+function createChatRoute(ctx) {
+    const app = new Hono();
+    // POST / — SSE 流式聊天
+    app.post('/', async (c) => {
+        const body = await c.req.json().catch(() => ({}));
+        const sessionId = body.sessionId;
+        const message = body.message;
+        if (!sessionId || !message) {
+            return apiError(c, 400, 'BAD_REQUEST', 'sessionId and message are required');
+        }
+        let session;
+        try {
+            session = await getSession(ctx.db, sessionId);
+        }
+        catch {
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        }
+        if (!session) {
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        }
+        // 提前解析 cwd（slash 拦截与 agent 路径都需使用）
+        const cwd = await resolveAgentCwd(ctx, session);
+        // 斜杠命令拦截
+        const parsed = parseSlashInput(message);
+        if (parsed) {
+            const registry = createSlashRegistry();
+            const cmd = registry.get(parsed.name);
+            if (cmd) {
+                const commandCtx = {
+                    cwd,
+                    config: ctx.config,
+                    // 内置斜杠命令（/clear、/fork、/config）仅需 db + config；
+                    // permission/toolRegistry/llmRegistry 不会触发，用 autoAllow 凑齐类型。
+                    deps: {
+                        db: ctx.db,
+                        config: ctx.config,
+                        cwd,
+                        permission: autoAllowChecker,
+                        toolRegistry: ctx.toolRegistry,
+                        llmRegistry: ctx.llmRegistry,
+                    },
+                };
+                return streamSSE(c, async (stream) => {
+                    try {
+                        const result = await cmd.execute(parsed.args, commandCtx);
+                        if (result._tag === 'error') {
+                            await stream.writeSSE({
+                                event: 'error',
+                                data: JSON.stringify({
+                                    _tag: 'error',
+                                    error: { _tag: 'unexpected', message: result.message },
+                                }),
+                            });
+                        }
+                        else {
+                            const text = result._tag === 'success' ? result.message : result.text;
+                            await stream.writeSSE({
+                                event: 'text_delta',
+                                data: JSON.stringify({ _tag: 'text_delta', text }),
+                            });
+                        }
+                        await stream.writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) });
+                    }
+                    catch (e) {
+                        await stream.writeSSE({
+                            event: 'error',
+                            data: JSON.stringify({
+                                _tag: 'error',
+                                error: { _tag: 'unexpected', message: String(e) },
+                            }),
+                        });
+                    }
+                });
+            }
+            // 未知斜杠命令：回退为正常消息发给 agent
+        }
+        // 构建多模态 user content：文本在前，images（dataURL base64）在后
+        const userContent = [{ _tag: 'text', text: message }];
+        const images = body.images;
+        if (images?.length) {
+            for (const img of images) {
+                userContent.push({ _tag: 'image', mediaType: img.mediaType, data: img.data });
+            }
+        }
+        // @agent 调用 subagent：在消息前注入指令（复用 task 工具派生）
+        const mentionedAgents = body.agents ?? [];
+        if (mentionedAgents.length > 0) {
+            const valid = mentionedAgents
+                .map((n) => ctx.agentRegistry.get(n))
+                .filter((d) => Boolean(d && d.mode !== 'primary'));
+            if (valid.length > 0) {
+                const names = valid.map((d) => d.name).join(', ');
+                const first = userContent[0];
+                if (first && first._tag === 'text') {
+                    first.text = `[User requested subagent(s): ${names}]\n\n${first.text}`;
+                }
+            }
+        }
+        // @文件上下文：读取文件内容写入快照，后续 getSessionContext→injectSnapshots 自动注入。
+        // 路径越界或读取失败静默跳过，不阻塞主对话流。
+        const files = body.files;
+        if (files?.length) {
+            for (const p of files) {
+                const resolved = safeResolve(cwd, p);
+                if (!resolved)
+                    continue;
+                try {
+                    const content = await readFile(resolved, 'utf-8');
+                    await upsertFileSnapshot(ctx.db, sessionId, p, content);
+                }
+                catch {
+                    // 文件读取失败静默跳过
+                }
+            }
+        }
+        const provider = body.provider ?? ctx.config.defaultProvider;
+        const model = body.model ?? ctx.config.defaultModel;
+        // 前端 ToolToggle 全选时不传 tools（undefined），语义为「启用全部注册工具」。
+        // 显式传 [] 才是禁用全部。config.tools.enabled 仅 CLI 模式使用，此处不回退它，
+        // 避免配置里 enabled:[] 把 Web 全选误降级为无工具（LLM 无法 function call）。
+        const tools = body.tools ??
+            listTools(ctx.toolRegistry, { config: {}, cwd }).map((t) => t.name);
+        // primary agent 解析（spec: agent-frontend-switching §4.3）
+        const agentName = body.agent ?? 'default';
+        const agentDef = ctx.agentRegistry.get(agentName);
+        if (!agentDef || agentDef.mode === 'subagent') {
+            return apiError(c, 400, 'INVALID_AGENT', `Unknown or non-primary agent: ${agentName}`);
+        }
+        // agent def 覆盖：tools（plan 限只读）、model（可选）
+        const resolvedTools = agentDef.tools ?? tools;
+        const resolvedModel = agentDef.model ?? model;
+        // 分段预检：切换 provider/model/tools 将开新段（前缀失效→缓存 miss），
+        // 需用户显式确认（confirmSegmentBreak）。首轮无活跃段时跳过。
+        const existingRun = ctx.agentManager.get(sessionId);
+        const segs = existingRun ? existingRun.state.segments : await getLLMSegments(ctx.db, sessionId);
+        const active = segs[segs.length - 1];
+        if (active) {
+            const reqTools = new Set(resolvedTools);
+            const segTools = new Set(active.tools.map((t) => t.name));
+            const toolsDiffer = reqTools.size !== segTools.size || [...reqTools].some((t) => !segTools.has(t));
+            const modelDiffer = active.provider !== provider || active.model !== resolvedModel;
+            // 旧段 agentName undefined 视为 'default'
+            const agentDiffer = (active.agentName ?? 'default') !== agentName;
+            const confirmed = body.confirmSegmentBreak === true;
+            if ((modelDiffer || toolsDiffer || agentDiffer) && !confirmed) {
+                return apiError(c, 409, 'SEGMENT_BREAK_REQUIRED', '切换模型/工具将开始新的上下文段（缓存失效），需用户确认', {
+                    activeSegment: {
+                        provider: active.provider,
+                        model: active.model,
+                        tools: active.tools.map((t) => t.name),
+                    },
+                });
+            }
+        }
+        return streamSSE(c, async (stream) => {
+            // 权限检查器：ask 权限通过 SSE 通知前端，阻塞等待确认
+            const permissionChecker = createInteractivePermissionChecker(ctx.permissionStore, {
+                getMode: () => ctx.permissionMode,
+                onPermissionRequired: async (req) => {
+                    await stream.writeSSE({
+                        event: 'permission_required',
+                        data: JSON.stringify({ _tag: 'permission_required', ...req }),
+                    });
+                },
+            });
+            // cwd 已在斜杠拦截前解析，此处直接复用
+            // 构建 agent 依赖（注入测试用 chatStream）
+            const deps = {
+                db: ctx.db,
+                llmRegistry: ctx.llmRegistry,
+                toolRegistry: ctx.toolRegistry,
+                urlRegistry: ctx.urlRegistry,
+                hookRunner: ctx.hookRunner,
+                permission: permissionChecker,
+                config: ctx.config,
+                agentRegistry: ctx.agentRegistry,
+                cwd,
+                ...(ctx.chatStream ? { chatStream: ctx.chatStream } : {}),
+            };
+            const agentConfig = {
+                provider,
+                model: resolvedModel,
+                tools: resolvedTools,
+                plugins: ctx.config.plugins.enabled,
+                agentName,
+                ...(agentDef.systemPrompt ? { agentRolePrompt: agentDef.systemPrompt } : {}),
+            };
+            const state = await createAgent(session, agentConfig, deps);
+            // 持久化 run 状态：status='running' 写入 DB。服务重启后此字段仍为 'running'
+            // 而进程无活跃 run → 检测为 interrupted。finally 中标记 'completed'。
+            const runStartedAt = Date.now();
+            await updateSessionLastRun(ctx.db, sessionId, {
+                status: 'running',
+                ...(agentName !== 'default' ? { agentName } : {}),
+                provider,
+                model: resolvedModel,
+                startedAt: runStartedAt,
+            });
+            ctx.agentManager.register({ sessionId, state, deps });
+            // 客户端断开时中止 agent
+            stream.onAbort(() => {
+                ctx.agentManager.abort(sessionId);
+            });
+            try {
+                for await (const event of runAgent(state, userContent, deps)) {
+                    await stream.writeSSE({
+                        event: event._tag,
+                        data: JSON.stringify(event),
+                    });
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error
+                    ? err.message
+                    : typeof err === 'object' && err !== null && 'message' in err
+                        ? String(err.message)
+                        : String(err);
+                await stream.writeSSE({
+                    event: 'error',
+                    data: JSON.stringify({
+                        _tag: 'error',
+                        error: {
+                            _tag: 'unexpected',
+                            message,
+                        },
+                    }),
+                });
+            }
+            finally {
+                // 无论正常完成、错误还是 abort，只要服务还活着就标记 completed。
+                // 只有服务崩溃/重启才会留下 status='running' → 下次加载检测为 interrupted。
+                await updateSessionLastRun(ctx.db, sessionId, {
+                    status: 'completed',
+                    ...(agentName !== 'default' ? { agentName } : {}),
+                    provider,
+                    model: resolvedModel,
+                    startedAt: runStartedAt,
+                }).catch(() => { });
+                ctx.agentManager.unregister(sessionId);
+            }
+        });
+    });
+    // 控制端点
+    app.post('/abort', async (c) => {
+        const { sessionId } = await c.req.json();
+        return c.json({ aborted: ctx.agentManager.abort(sessionId) });
+    });
+    app.post('/pause', async (c) => {
+        const { sessionId } = await c.req.json();
+        return c.json({ paused: ctx.agentManager.pause(sessionId) });
+    });
+    app.post('/resume', async (c) => {
+        const { sessionId } = await c.req.json();
+        return c.json({ resumed: ctx.agentManager.resume(sessionId) });
+    });
+    app.post('/steer', async (c) => {
+        const body = await c.req.json();
+        return c.json({ steered: ctx.agentManager.steer(body.sessionId, body.message) });
+    });
+    return app;
+}
+export { createChatRoute };

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

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import type { ServerContext } from '../types.js';
+/** GET / — 返回内置斜杠命令列表（name/description/argsHint）。 */
+declare function createCommandsRoute(_ctx: ServerContext): Hono;
+export { createCommandsRoute };

package/dist/server/routes/commands.js

@@ -0,0 +1,17 @@
+import { Hono } from 'hono';
+import { createSlashRegistry } from '../../core/slash.js';
+/** GET / — 返回内置斜杠命令列表（name/description/argsHint）。 */
+function createCommandsRoute(_ctx) {
+    const app = new Hono();
+    app.get('/', (c) => {
+        const registry = createSlashRegistry();
+        const commands = registry.list().map((cmd) => ({
+            name: cmd.name,
+            description: cmd.description,
+            ...(cmd.argsHint ? { argsHint: cmd.argsHint } : {}),
+        }));
+        return c.json({ commands });
+    });
+    return app;
+}
+export { createCommandsRoute };

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

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

package/dist/server/routes/config.js

@@ -0,0 +1,27 @@
+import { Hono } from 'hono';
+import { mergeConfig, saveConfig } from '../../core/config.js';
+import { encryptSecret, isEncryptedSecret } from '../../core/secret.js';
+import { syncRegistryFromConfig } from '../server.js';
+function createConfigRoute(ctx) {
+    const app = new Hono();
+    app.get('/', (c) => {
+        return c.json(ctx.config);
+    });
+    app.patch('/', async (c) => {
+        const patch = (await c.req.json());
+        // spec §24.2：provider apiKey 落盘前加密，明文不持久化。
+        // 已加密（enc: 前缀）或无 apiKey 的透传。
+        if (Array.isArray(patch.providers)) {
+            patch.providers = patch.providers.map((p) => p.apiKey && !isEncryptedSecret(p.apiKey) ? { ...p, apiKey: encryptSecret(p.apiKey) } : p);
+        }
+        ctx.config = mergeConfig(ctx.config, patch);
+        // providers 变更后原地同步 registry，使运行中的连接立即生效
+        syncRegistryFromConfig(ctx.llmRegistry, ctx.config);
+        await saveConfig(ctx.config, 'project', ctx.cwd).catch(() => {
+            // 保存失败不影响内存配置
+        });
+        return c.json(ctx.config);
+    });
+    return app;
+}
+export { createConfigRoute };

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

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