c0de-agent 0.0.0 → 1.1.0

package/dist/server/routes/session.js

@@ -0,0 +1,204 @@
+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 { deleteEntriesByIds, getMessages, insertEntry } from '../../session/message.js';
+import { createSession, deleteSession, getLLMSegments, getSession, listSessions, listSessionsByProject, } 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';
+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' });
+    });
+    // shake preview：返回可 shake 的区域列表
+    app.post('/:id/shake/preview', 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 messages = await getMessages(ctx.db, id);
+        // Manual shake: show ALL candidates (protectTokens=0, minSavings=0).
+        // toRegionViews still marks isAfterProtectWindow using the real config.
+        const manualConfig = { ...DEFAULT_SHAKE_CONFIG, protectTokens: 0, minSavings: 0 };
+        const regions = collectShakeRegions(messages, manualConfig);
+        const views = toRegionViews(regions, DEFAULT_SHAKE_CONFIG, messages);
+        return c.json({ regions: views });
+    });
+    // shake apply：归档原始内容 + 原位替换
+    app.post('/:id/shake/apply', 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 body = await c.req.json().catch(() => ({}));
+        const regionIds = body.regionIds ?? [];
+        const messages = await getMessages(ctx.db, id);
+        const manualConfig = { ...DEFAULT_SHAKE_CONFIG, protectTokens: 0, minSavings: 0 };
+        const regions = collectShakeRegions(messages, manualConfig);
+        // 校验：所有 regionIds 必须命中当前 preview 结果（原子性）
+        const availableIds = new Set(regions.map((r) => r.id));
+        const unknownIds = regionIds.filter((rid) => !availableIds.has(rid));
+        if (unknownIds.length > 0) {
+            return apiError(c, 400, 'INVALID_REGIONS', '消息已变化，请重新预览');
+        }
+        const selectedSet = new Set(regionIds);
+        const selected = regions.filter((r) => selectedSet.has(r.id));
+        if (selected.length === 0) {
+            return c.json({ shaken: 0, archiveId: '' });
+        }
+        const affectedIds = [...new Set(selected.map((r) => r.messageId))];
+        const originalMessages = messages.filter((m) => affectedIds.includes(m.id));
+        const archiveId = generateId();
+        const totalTokens = selected.reduce((sum, r) => sum + r.tokens, 0);
+        await archiveOriginalEntries(ctx.db, id, originalMessages, 'shake', `Shaken ${selected.length} regions, saved ${totalTokens} tokens`, archiveId);
+        const shakenMessages = applyShakeRegions(messages, selected);
+        await deleteEntriesByIds(ctx.db, affectedIds);
+        for (const msg of shakenMessages) {
+            if (!affectedIds.includes(msg.id))
+                continue;
+            await insertEntry(ctx.db, {
+                id: msg.id,
+                sessionId: id,
+                tag: 'message',
+                role: msg.role,
+                content: msg.content,
+                tokenCount: estimateMessageTokens(msg.content),
+                createdAt: new Date(msg.createdAt),
+            });
+        }
+        return c.json({ shaken: selected.length, archiveId });
+    });
+    // 获取分支
+    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/terminal.d.ts

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import type { ServerContext } from '../types.js';
+/** 创建终端路由（REST 部分；WebSocket 升级在 server.ts 中处理）。 */
+declare function createTerminalRoute(ctx: ServerContext): Hono;
+export { createTerminalRoute };

package/dist/server/routes/terminal.js

@@ -0,0 +1,66 @@
+// src/server/routes/terminal.ts
+import { Hono } from 'hono';
+import { apiError } from '../middleware/error.js';
+/** 创建终端路由（REST 部分；WebSocket 升级在 server.ts 中处理）。 */
+function createTerminalRoute(ctx) {
+    const app = new Hono();
+    const mgr = ctx.ptyManager;
+    // 列出所有活跃 PTY
+    app.get('/', (c) => {
+        return c.json({ terminals: mgr.list() });
+    });
+    // 创建新 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 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;
+        try {
+            const info = mgr.create({ cwd, cols, rows, title, shell });
+            return c.json(info, 201);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Failed to create terminal';
+            return apiError(c, 500, 'PTY_CREATE_FAILED', message);
+        }
+    });
+    // 获取单个 PTY 信息
+    app.get('/:id', (c) => {
+        const info = mgr.get(c.req.param('id'));
+        if (!info)
+            return apiError(c, 404, 'PTY_NOT_FOUND', 'Terminal not found');
+        return c.json(info);
+    });
+    // 调整尺寸 / 更新标题
+    app.put('/:id', async (c) => {
+        const id = c.req.param('id');
+        const info = mgr.get(id);
+        if (!info)
+            return apiError(c, 404, 'PTY_NOT_FOUND', 'Terminal not found');
+        const body = await c.req.json().catch(() => ({}));
+        if (body.cols != null && body.rows != null) {
+            const cols = Number(body.cols);
+            const rows = Number(body.rows);
+            if (!Number.isFinite(cols) || !Number.isFinite(rows)) {
+                return apiError(c, 400, 'INVALID_SIZE', 'cols and rows must be numbers');
+            }
+            mgr.resize(id, cols, rows);
+        }
+        if (typeof body.title === 'string') {
+            mgr.setTitle(id, body.title);
+        }
+        return c.json(mgr.get(id));
+    });
+    // 终止 PTY
+    app.delete('/:id', (c) => {
+        const id = c.req.param('id');
+        if (!mgr.get(id))
+            return apiError(c, 404, 'PTY_NOT_FOUND', 'Terminal not found');
+        mgr.kill(id);
+        return c.json({ ok: true });
+    });
+    return app;
+}
+export { createTerminalRoute };

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 };

package/dist/server/routes/tool.js

@@ -0,0 +1,28 @@
+import { Hono } from 'hono';
+import { listTools } from '../../tools/registry.js';
+import { apiError } from '../middleware/error.js';
+function createToolRoute(ctx) {
+    const app = new Hono();
+    // 列出可用工具（不含 execute 函数）
+    app.get('/', (c) => {
+        const tools = listTools(ctx.toolRegistry, { config: {}, cwd: ctx.cwd });
+        const serializable = tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+            permission: t.permission,
+        }));
+        return c.json(serializable);
+    });
+    // 确认工具执行权限
+    app.post('/confirm', async (c) => {
+        const body = await c.req.json();
+        const ok = ctx.permissionStore.resolve(body.toolCallId, body.approved);
+        if (!ok) {
+            return apiError(c, 404, 'NOT_FOUND', 'No pending permission for this tool call');
+        }
+        return c.json({ confirmed: true });
+    });
+    return app;
+}
+export { createToolRoute };

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

@@ -0,0 +1,14 @@
+import { Hono } from 'hono';
+import type { ServerContext } from '../types.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 异步完成。
+ */
+declare function createUpdateRoute(ctx: ServerContext): Hono;
+export { createUpdateRoute };

package/dist/server/routes/update.js

@@ -0,0 +1,49 @@
+import { Hono } from 'hono';
+import { performHotUpdate, serializeSessions } from '../../update/index.js';
+import { apiError } from '../middleware/error.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 异步完成。
+ */
+function createUpdateRoute(ctx) {
+    const app = new Hono();
+    app.get('/', (c) => {
+        const cached = ctx.updateScheduler.getLastResult();
+        if (cached)
+            return c.json(cached);
+        // 无缓存（首次启动延迟未到）：同步触发一次，避免前端首屏空。
+        // 不 await——保持 GET 语义非阻塞；前端下次轮询拿到结果。
+        void ctx.updateScheduler.checkNow();
+        return c.json({
+            hasUpdate: false,
+            currentVersion: '0.0.0',
+            latestVersion: '0.0.0',
+        });
+    });
+    app.post('/apply', async (c) => {
+        const result = await ctx.updateScheduler.checkNow();
+        if (!result.hasUpdate) {
+            return apiError(c, 409, 'NO_UPDATE', '已是最新版本，无需热更新');
+        }
+        const snapshot = await serializeSessions(ctx.db, ctx.config);
+        const r = await performHotUpdate(snapshot, {
+            handoffPort: ctx.handoff?.port,
+        });
+        if (r._tag === 'success') {
+            return c.json({
+                ok: true,
+                snapshotPath: r.snapshotPath,
+                latestVersion: result.latestVersion,
+            });
+        }
+        return apiError(c, 500, 'HOT_UPDATE_FAILED', `${r._tag}: ${'error' in r ? r.error : 'unknown'}`);
+    });
+    return app;
+}
+export { createUpdateRoute };

package/dist/server/server.d.ts

@@ -0,0 +1,56 @@
+import type { Hono } from 'hono';
+import type { DB } from '../db/client.js';
+import type { Registry } from '../llm/registry.js';
+import type { Config } from '../shared/types/config.js';
+import { checkForUpdate, createHandoffServer } from '../update/index.js';
+import type { ServerContext } from './types.js';
+type StartServerOptions = {
+    port?: number;
+    cwd?: string;
+    /** 注入已有 DB（测试用）。 */
+    db?: DB;
+    /** 热更新新实例启动时从此快照文件恢复会话状态。 */
+    restoreFrom?: string;
+    /** 新实例启动时提供：请求旧实例 handoff 后再绑端口（spec §18.3）。 */
+    handoffPort?: number;
+    /** 测试注入：跳过 handoff 请求与重试绑端口。 */
+    skipHandoff?: boolean;
+    /** 测试注入：覆盖 checkForUpdate（默认走真实 npm registry）。 */
+    checkForUpdateFn?: typeof checkForUpdate;
+    /** 测试注入：覆盖 createHandoffServer。 */
+    createHandoffFn?: typeof createHandoffServer;
+};
+type RunningServer = {
+    app: Hono;
+    port: number;
+    close(): Promise<void>;
+};
+type BootstrappedServer = {
+    ctx: ServerContext;
+    close(): Promise<void>;
+};
+/** 把 config.providers 注册到新建的 LLM registry（修复此前空 registry 的遗漏）。 */
+declare function buildRegistryFromConfig(config: Config): Registry;
+/**
+ * config 变更后原地同步 registry（清空旧路由 + 重新注册），
+ * 使运行中的 ServerContext 立即生效，无需重启。
+ */
+declare function syncRegistryFromConfig(registry: Registry, config: Config): void;
+/**
+ * 围绕已有 DB handle 组装 ServerContext（不建/不关闭 DB）。
+ *
+ * dev 热重载重建复用此函数：PGLite 单写者约束下 DB handle 必须跨重载存活，
+ * 但 ctx 其余资源（agentManager/permissionStore/registries/plugins）全部重建为新实例。
+ * 返回的 dispose 清理 ctx 资源但**不 close db**——db 由调用方持有。
+ */
+declare function buildServerContext(db: DB, opts?: StartServerOptions): Promise<{
+    ctx: ServerContext;
+    dispose: () => Promise<void>;
+}>;
+/** dev 专用：创建 + migrate PGLite，跨热重载复用（单写者，只建一次）。 */
+declare function createDevDb(cwd: string): Promise<DB>;
+/** 初始化 DB + 配置 + 注册表，返回 ServerContext + 清理函数（dev 与独立后端共用）。 */
+declare function bootstrapServerContext(opts?: StartServerOptions): Promise<BootstrappedServer>;
+declare function startServer(opts?: StartServerOptions): Promise<RunningServer>;
+export type { BootstrappedServer, RunningServer, StartServerOptions };
+export { bootstrapServerContext, buildRegistryFromConfig, buildServerContext, createDevDb, startServer, syncRegistryFromConfig, };