c0de-agent 0.0.0 → 1.0.0

package/dist/server/routes/files.js

@@ -0,0 +1,183 @@
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { Hono } from 'hono';
+import { getProject } from '../../project/project.js';
+import { apiError } from '../middleware/error.js';
+import { safeResolve } from '../util/safe-path.js';
+/** 递归收集文件列表（用于搜索）。 */
+async function collectFiles(dir, basePath, maxDepth = 5) {
+    if (maxDepth < 0)
+        return [];
+    const results = [];
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith('.') || entry.name === 'node_modules')
+            continue;
+        const fullPath = join(dir, entry.name);
+        const relPath = relative(basePath, fullPath);
+        if (entry.isDirectory()) {
+            results.push({ path: relPath, type: 'directory' });
+            results.push(...(await collectFiles(fullPath, basePath, maxDepth - 1)));
+        }
+        else {
+            results.push({ path: relPath, type: 'file' });
+        }
+    }
+    return results;
+}
+function contentTypeFor(name) {
+    const ext = name.split('.').pop()?.toLowerCase() ?? '';
+    const map = {
+        png: 'image/png',
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        gif: 'image/gif',
+        svg: 'image/svg+xml',
+        webp: 'image/webp',
+        pdf: 'application/pdf',
+        mp3: 'audio/mpeg',
+        wav: 'audio/wav',
+        ogg: 'audio/ogg',
+        m4a: 'audio/mp4',
+        flac: 'audio/flac',
+        mp4: 'video/mp4',
+        webm: 'video/webm',
+        mov: 'video/quicktime',
+        json: 'application/json; charset=utf-8',
+        html: 'text/html; charset=utf-8',
+        md: 'text/markdown; charset=utf-8',
+        txt: 'text/plain; charset=utf-8',
+        ts: 'text/plain; charset=utf-8',
+        js: 'text/plain; charset=utf-8',
+    };
+    return map[ext] ?? 'application/octet-stream';
+}
+function createFilesRoute(ctx) {
+    const app = new Hono();
+    // 列出目录
+    // projectId 指定时按对应项目 worktree 列出，否则回退 ctx.cwd（向后兼容）。
+    app.get('/', async (c) => {
+        const queryPath = c.req.query('path') ?? '.';
+        const projectId = c.req.query('projectId');
+        let root = ctx.cwd;
+        if (projectId) {
+            const project = await getProject(ctx.db, projectId);
+            if (!project) {
+                return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+            }
+            root = project.worktree;
+        }
+        const resolved = safeResolve(root, queryPath);
+        if (!resolved) {
+            return apiError(c, 403, 'FORBIDDEN', 'Path outside workspace');
+        }
+        try {
+            const entries = await readdir(resolved, { withFileTypes: true });
+            const result = entries
+                .filter((e) => !e.name.startsWith('.'))
+                .map((e) => ({
+                name: e.name,
+                type: (e.isDirectory() ? 'directory' : 'file'),
+            }))
+                .sort((a, b) => {
+                if (a.type !== b.type)
+                    return a.type === 'directory' ? -1 : 1;
+                return a.name.localeCompare(b.name);
+            });
+            return c.json(result);
+        }
+        catch {
+            return apiError(c, 404, 'NOT_FOUND', 'Directory not found');
+        }
+    });
+    // 搜索文件名
+    // projectId 指定时按对应项目 worktree 搜索，否则回退 ctx.cwd（向后兼容）。
+    app.get('/search', async (c) => {
+        const q = c.req.query('q');
+        if (!q) {
+            return apiError(c, 400, 'BAD_REQUEST', 'Query parameter q is required');
+        }
+        const projectId = c.req.query('projectId');
+        let root = ctx.cwd;
+        if (projectId) {
+            const project = await getProject(ctx.db, projectId);
+            if (!project) {
+                return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+            }
+            root = project.worktree;
+        }
+        const all = await collectFiles(root, root);
+        const lower = q.toLowerCase();
+        const matched = all.filter((f) => f.path.toLowerCase().includes(lower));
+        return c.json(matched);
+    });
+    // 读取文件
+    // projectId 指定时按对应项目 worktree 解析，否则回退 ctx.cwd（向后兼容）。
+    app.get('/*', async (c) => {
+        const path = c.req.path.replace(/^\/api\/files\//, '').replace(/^\//, '');
+        const raw = path.endsWith('/raw');
+        const filePath = raw ? path.slice(0, -'/raw'.length) : path;
+        const projectId = c.req.query('projectId');
+        let root = ctx.cwd;
+        if (projectId) {
+            const project = await getProject(ctx.db, projectId);
+            if (!project) {
+                return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+            }
+            root = project.worktree;
+        }
+        const resolved = safeResolve(root, filePath);
+        if (!resolved) {
+            return apiError(c, 403, 'FORBIDDEN', 'Path outside workspace');
+        }
+        try {
+            if (raw) {
+                const buf = await readFile(resolved);
+                return c.body(buf, 200, {
+                    'Content-Type': contentTypeFor(filePath),
+                    'Cache-Control': 'no-store',
+                });
+            }
+            const content = await readFile(resolved, 'utf-8');
+            return c.json({ path, content });
+        }
+        catch {
+            return apiError(c, 404, 'NOT_FOUND', 'File not found');
+        }
+    });
+    // 写入文件
+    // projectId 指定时按对应项目 worktree 解析，否则回退 ctx.cwd（向后兼容）。
+    app.put('/*', async (c) => {
+        const path = c.req.path.replace(/^\/api\/files\//, '').replace(/^\//, '');
+        const projectId = c.req.query('projectId');
+        let root = ctx.cwd;
+        if (projectId) {
+            const project = await getProject(ctx.db, projectId);
+            if (!project) {
+                return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+            }
+            root = project.worktree;
+        }
+        const resolved = safeResolve(root, path);
+        if (!resolved) {
+            return apiError(c, 403, 'FORBIDDEN', 'Path outside workspace');
+        }
+        const body = await c.req.json();
+        try {
+            await mkdir(dirname(resolved), { recursive: true });
+            await writeFile(resolved, body.content, 'utf-8');
+            return c.json({ path, written: true });
+        }
+        catch (err) {
+            return apiError(c, 500, 'WRITE_ERROR', `Failed to write file: ${String(err)}`);
+        }
+    });
+    return app;
+}
+export { createFilesRoute };

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

@@ -0,0 +1,29 @@
+import { Hono } from 'hono';
+import type { ServerContext } from '../types.js';
+/** 目录列表项。 */
+type DirEntry = {
+    name: string;
+    path: string;
+};
+/**
+ * 列出指定目录下的子目录（仅目录，不含文件）。
+ * 用于项目添加时的路径自动补全——可浏览文件系统任意位置。
+ *
+ * 输入 path 为空时返回 home 目录列表。
+ * `~` 开头自动展开为 home 目录。
+ */
+declare function listDirectories(dirPath: string): Promise<DirEntry[]>;
+/** 递归搜索目录：从 directory 起收集 type=directory 的相对路径。
+ *
+ * - 起点经 expandPath 展开 `~`，可为任意绝对路径。
+ * - 跳过隐藏目录（`.` 开头）与 SKIP_DIRS。
+ * - 限深（默认 5）+ 数量上限 limit（默认 50），避免大目录爆炸。
+ * - 匹配：相对路径（小写）includes query（小写），可命中任意层级目录名。
+ *
+ * 服务端粗筛；客户端 fuzzysort 精排与排序。
+ */
+declare function searchDirectories(directory: string, query: string, limit?: number, maxDepth?: number): Promise<string[]>;
+/** 把 `~/...` 或空路径展开为绝对路径。 */
+declare function expandPath(input: string): string;
+declare function createFilesystemRoute(ctx: ServerContext): Hono;
+export { createFilesystemRoute, expandPath, listDirectories, searchDirectories };

package/dist/server/routes/filesystem.js

@@ -0,0 +1,108 @@
+import { readdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { relative as relativePath, resolve as resolvePath } from 'node:path';
+import { Hono } from 'hono';
+/**
+ * 列出指定目录下的子目录（仅目录，不含文件）。
+ * 用于项目添加时的路径自动补全——可浏览文件系统任意位置。
+ *
+ * 输入 path 为空时返回 home 目录列表。
+ * `~` 开头自动展开为 home 目录。
+ */
+async function listDirectories(dirPath) {
+    let entries;
+    try {
+        entries = await readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const dirs = entries
+        .filter((e) => e.isDirectory() && !e.name.startsWith('.'))
+        .map((e) => ({
+        name: e.name,
+        path: resolvePath(dirPath, e.name),
+    }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    return dirs;
+}
+/** 跳过的目录名（无价值、体量大或为噪音）。 */
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.cache']);
+/** 递归搜索目录：从 directory 起收集 type=directory 的相对路径。
+ *
+ * - 起点经 expandPath 展开 `~`，可为任意绝对路径。
+ * - 跳过隐藏目录（`.` 开头）与 SKIP_DIRS。
+ * - 限深（默认 5）+ 数量上限 limit（默认 50），避免大目录爆炸。
+ * - 匹配：相对路径（小写）includes query（小写），可命中任意层级目录名。
+ *
+ * 服务端粗筛；客户端 fuzzysort 精排与排序。
+ */
+async function searchDirectories(directory, query, limit = 50, maxDepth = 5) {
+    const base = directory;
+    const lowerQuery = query.toLowerCase();
+    const results = [];
+    async function walk(dir, depth) {
+        if (results.length >= limit || depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (results.length >= limit)
+                return;
+            // 跳过隐藏目录与噪音目录
+            if (!entry.isDirectory() || entry.name.startsWith('.') || SKIP_DIRS.has(entry.name))
+                continue;
+            const fullPath = resolvePath(dir, entry.name);
+            const relPath = relativePath(base, fullPath);
+            if (!lowerQuery || relPath.toLowerCase().includes(lowerQuery)) {
+                results.push(relPath);
+                if (results.length >= limit)
+                    return;
+            }
+            await walk(fullPath, depth + 1);
+        }
+    }
+    await walk(base, 0);
+    return results.slice(0, limit);
+}
+/** 把 `~/...` 或空路径展开为绝对路径。 */
+function expandPath(input) {
+    if (!input || input === '~')
+        return homedir();
+    if (input.startsWith('~/'))
+        return resolvePath(homedir(), input.slice(2));
+    return resolvePath(input);
+}
+function createFilesystemRoute(ctx) {
+    const app = new Hono();
+    // 列出目录下的子目录（用于项目路径自动补全）
+    app.get('/browse', async (c) => {
+        const rawPath = c.req.query('path') ?? '';
+        const target = expandPath(rawPath);
+        // 校验：ctx 可用于将来做沙箱限制（当前允许浏览任意路径）
+        void ctx;
+        const dirs = await listDirectories(target);
+        return c.json({ path: target, directories: dirs });
+    });
+    // 递归搜索目录（用于项目路径自动补全——命中深层目录）
+    app.get('/search', async (c) => {
+        const rawDir = c.req.query('directory') ?? '';
+        const q = c.req.query('q') ?? '';
+        const limitRaw = Number.parseInt(c.req.query('limit') ?? '', 10);
+        const limit = Number.isFinite(limitRaw) && limitRaw > 0 ? Math.min(limitRaw, 200) : 50;
+        const directory = expandPath(rawDir);
+        const items = await searchDirectories(directory, q, limit);
+        return c.json({ items });
+    });
+    // 列出 home 目录快捷入口
+    app.get('/home', (c) => {
+        return c.json({ path: homedir() });
+    });
+    return app;
+}
+export { createFilesystemRoute, expandPath, listDirectories, searchDirectories };

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

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare function createHealthRoute(): Hono;
+export { createHealthRoute };

package/dist/server/routes/health.js

@@ -0,0 +1,13 @@
+import { Hono } from 'hono';
+function createHealthRoute() {
+    const app = new Hono();
+    app.get('/', (c) => {
+        return c.json({
+            status: 'ok',
+            version: '0.1.0',
+            timestamp: Date.now(),
+        });
+    });
+    return app;
+}
+export { createHealthRoute };

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

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import type { ServerContext } from '../types.js';
+/** GET/PUT /api/permissions — 全局授权模式（default 逐个确认 / auto 自动放行 ask 工具）。 */
+declare function createPermissionsRoute(ctx: ServerContext): Hono;
+export { createPermissionsRoute };

package/dist/server/routes/permissions.js

@@ -0,0 +1,23 @@
+import { Hono } from 'hono';
+import { apiError } from '../middleware/error.js';
+/** GET/PUT /api/permissions — 全局授权模式（default 逐个确认 / auto 自动放行 ask 工具）。 */
+function createPermissionsRoute(ctx) {
+    const app = new Hono();
+    // GET / — 当前授权模式
+    app.get('/', (c) => {
+        return c.json({ mode: ctx.permissionMode });
+    });
+    // PUT / — 运行时切换授权模式（仅本次运行生效，不回写 config；
+    // 重启后回到 config.permission.defaultMode 持久化默认值）
+    app.put('/', async (c) => {
+        const body = (await c.req.json().catch(() => null));
+        const mode = body?.mode;
+        if (mode !== 'default' && mode !== 'auto') {
+            return apiError(c, 400, 'INVALID_MODE', "mode 必须是 'default' 或 'auto'");
+        }
+        ctx.permissionMode = mode;
+        return c.json({ mode: ctx.permissionMode });
+    });
+    return app;
+}
+export { createPermissionsRoute };

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

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

package/dist/server/routes/project.js

@@ -0,0 +1,51 @@
+import { Hono } from 'hono';
+import { fromDirectory, getProject, listProjects, resolveProject, updateProjectName, } from '../../project/index.js';
+import { apiError } from '../middleware/error.js';
+import { expandPath } from './filesystem.js';
+/** 实时取 git 分支（分支随时变，不存 DB）。 */
+function withBranch(project) {
+    return { ...project, gitBranch: resolveProject(project.worktree).gitBranch };
+}
+function createProjectRoute(ctx) {
+    const app = new Hono();
+    // 解析目录并创建/更新项目记录
+    app.post('/from-directory', async (c) => {
+        const body = await c.req.json().catch(() => ({}));
+        const directory = body.directory;
+        if (!directory)
+            return apiError(c, 400, 'BAD_REQUEST', 'directory is required');
+        // 展开 ~ 前缀为 home 绝对路径（前端可能传 ~/... 形式）
+        const project = await fromDirectory(ctx.db, expandPath(directory));
+        return c.json(withBranch(project), 200);
+    });
+    // 列出所有项目
+    app.get('/', async (c) => {
+        const list = await listProjects(ctx.db);
+        return c.json(list.map(withBranch));
+    });
+    // 解析服务端 cwd 对应的项目（未注册则自动创建）
+    app.get('/current', async (c) => {
+        const project = await fromDirectory(ctx.db, ctx.cwd);
+        return c.json(withBranch(project), 200);
+    });
+    // 按 id 获取项目
+    app.get('/:id', async (c) => {
+        const project = await getProject(ctx.db, c.req.param('id'));
+        if (!project)
+            return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+        return c.json(withBranch(project));
+    });
+    // 更新项目名
+    app.patch('/:id', async (c) => {
+        const body = await c.req.json().catch(() => ({}));
+        const name = body.name;
+        if (!name)
+            return apiError(c, 400, 'BAD_REQUEST', 'name is required');
+        const project = await updateProjectName(ctx.db, c.req.param('id'), name);
+        if (!project)
+            return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+        return c.json(withBranch(project));
+    });
+    return app;
+}
+export { createProjectRoute };

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

@@ -0,0 +1,16 @@
+import { Hono } from 'hono';
+import type { ServerContext } from '../types.js';
+type TestResult = {
+    ok: true;
+    models: string[];
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * 用给定 baseURL/apiKey 探测 OpenAI 兼容的 /models 端点。
+ * baseURL 应自行包含版本路径（如 https://api.openai.com/v1）。
+ */
+declare function probeModels(baseURL: string, apiKey: string): Promise<TestResult>;
+declare function createProviderRoute(ctx: ServerContext): Hono;
+export { createProviderRoute, probeModels };

package/dist/server/routes/provider.js

@@ -0,0 +1,66 @@
+import { Hono } from 'hono';
+import { decryptSecret } from '../../core/secret.js';
+import { apiError } from '../middleware/error.js';
+/**
+ * 用给定 baseURL/apiKey 探测 OpenAI 兼容的 /models 端点。
+ * baseURL 应自行包含版本路径（如 https://api.openai.com/v1）。
+ */
+async function probeModels(baseURL, apiKey) {
+    const base = baseURL.replace(/\/+$/, '');
+    const url = `${base}/models`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 10_000);
+    try {
+        const res = await fetch(url, {
+            method: 'GET',
+            headers: {
+                Accept: 'application/json',
+                ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+            },
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            return { ok: false, error: `HTTP ${res.status} ${text.slice(0, 200) || res.statusText}` };
+        }
+        const json = (await res.json());
+        const models = Array.isArray(json.data)
+            ? json.data.map((m) => m.id).filter((id) => typeof id === 'string')
+            : [];
+        return { ok: true, models };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: msg };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function createProviderRoute(ctx) {
+    const app = new Hono();
+    // 列出已配置 providers（apiKey 脱敏，不含明文）
+    app.get('/', (c) => {
+        const providers = ctx.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 });
+    });
+    // 连接测试：用请求体里的凭据探测 /models，不污染 registry
+    app.post('/test', async (c) => {
+        const body = await c.req.json().catch(() => ({}));
+        const { baseURL, apiKey } = body;
+        if (!baseURL)
+            return apiError(c, 400, 'BAD_REQUEST', 'baseURL is required');
+        // apiKey 可能是 Settings 页回传的 enc: 密文（保存后刷新、未重输时）：探测前解密，
+        // 否则把 enc: 串当 Bearer token 发给上游必然 401，造成「保存了却测试失败」的误判。
+        const secret = apiKey ? decryptSecret(apiKey) : '';
+        const result = await probeModels(baseURL, secret);
+        return c.json(result, result.ok ? 200 : 200);
+    });
+    return app;
+}
+export { createProviderRoute, probeModels };

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

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

package/dist/server/routes/session.js

@@ -0,0 +1,130 @@
+import { Hono } from 'hono';
+import { createSummarizer, runCompaction } from '../../core/compact.js';
+import { fromDirectory } from '../../project/index.js';
+import { forkSession, getBranches, getTree } from '../../session/branch.js';
+import { getMessages } from '../../session/message.js';
+import { createSession, deleteSession, getLLMSegments, getSession, listSessions, listSessionsByProject, } from '../../session/session.js';
+import { apiError } from '../middleware/error.js';
+function createSessionRoute(ctx) {
+    const app = new Hono();
+    // 创建会话
+    app.post('/', async (c) => {
+        const body = await c.req.json().catch(() => ({}));
+        const title = body.title ?? 'New Session';
+        const directory = body.directory;
+        const explicitProjectId = body.projectId;
+        let projectId;
+        if (directory) {
+            const project = await fromDirectory(ctx.db, directory);
+            projectId = project.id;
+        }
+        else if (explicitProjectId) {
+            projectId = explicitProjectId;
+        }
+        const session = await createSession(ctx.db, title, projectId);
+        return c.json(session, 201);
+    });
+    // 列出会话
+    app.get('/', async (c) => {
+        const projectId = c.req.query('projectId');
+        const sessions = projectId
+            ? await listSessionsByProject(ctx.db, projectId)
+            : await listSessions(ctx.db);
+        return c.json(sessions);
+    });
+    // 会话树
+    app.get('/tree', async (c) => {
+        const tree = await getTree(ctx.db);
+        return c.json(tree);
+    });
+    // 获取会话详情
+    app.get('/:id', async (c) => {
+        try {
+            const session = await getSession(ctx.db, c.req.param('id'));
+            if (!session) {
+                return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+            }
+            return c.json(session);
+        }
+        catch {
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        }
+    });
+    // 分支会话
+    app.post('/:id/fork', async (c) => {
+        const id = c.req.param('id');
+        const body = await c.req.json().catch(() => ({}));
+        const messageIndex = body.messageIndex ?? 0;
+        try {
+            const forked = await forkSession(ctx.db, id, messageIndex);
+            return c.json(forked, 201);
+        }
+        catch {
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        }
+    });
+    // 删除会话
+    app.delete('/:id', async (c) => {
+        await deleteSession(ctx.db, c.req.param('id'));
+        return c.body(null, 204);
+    });
+    // 获取消息列表
+    app.get('/:id/messages', async (c) => {
+        const messages = await getMessages(ctx.db, c.req.param('id'));
+        return c.json(messages);
+    });
+    // 获取 LLM 调用分段（段首快照 + 段内轻量 calls）：优先取活跃 run 的内存记录（实时），回退 DB 持久化
+    app.get('/:id/llm-details', async (c) => {
+        const run = ctx.agentManager.get(c.req.param('id'));
+        if (run)
+            return c.json(run.state.segments);
+        const persisted = await getLLMSegments(ctx.db, c.req.param('id'));
+        return c.json(persisted);
+    });
+    // 手动触发会话压缩（段切换确认弹窗「顺便压缩」调用）。用末段的 provider/model 构建摘要器。
+    app.post('/:id/compact', async (c) => {
+        const id = c.req.param('id');
+        let session;
+        try {
+            session = await getSession(ctx.db, id);
+        }
+        catch {
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        }
+        if (!session)
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        const segs = await getLLMSegments(ctx.db, id);
+        const lastSeg = segs[segs.length - 1];
+        const provider = lastSeg?.provider ?? ctx.config.defaultProvider;
+        const model = lastSeg?.model ?? ctx.config.defaultModel;
+        try {
+            const summarizer = createSummarizer(ctx.llmRegistry, provider, model, {});
+            const result = await runCompaction(ctx.db, id, summarizer, {
+                keepRecentTokens: ctx.config.compaction.keepRecentTokens,
+            });
+            return c.json(result);
+        }
+        catch (e) {
+            return apiError(c, 500, 'COMPACTION_FAILED', e instanceof Error ? e.message : 'Compaction failed');
+        }
+    });
+    // 获取会话状态：内存有活跃 run → 返回其 status；否则查 DB lastRun。
+    // lastRun.status='running' 但无活跃 run → 服务重启被中断。
+    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') {
+            return c.json({ _tag: 'interrupted' });
+        }
+        return c.json({ _tag: 'idle' });
+    });
+    // 获取分支
+    app.get('/:id/branches', async (c) => {
+        const branches = await getBranches(ctx.db, c.req.param('id'));
+        return c.json(branches);
+    });
+    return app;
+}
+export { createSessionRoute };

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

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