c0de-agent 0.0.0 → 1.0.0

package/dist/server/context.js

@@ -0,0 +1,47 @@
+// src/server/context.ts
+import { BUILTIN_AGENTS, createAgentRegistry } from '../core/agents/index.js';
+import { DEFAULT_CONFIG, mergeConfig } from '../core/config.js';
+import { createHookRunner, createPluginRegistry } from '../plugins/index.js';
+import { createDefaultRegistry, createDefaultURLRegistry } from '../tools/index.js';
+import { createUpdateScheduler } from '../update/index.js';
+import { createAgentManager } from './agent-manager.js';
+import { createPermissionStore } from './permission/store.js';
+function createServerContext(opts) {
+    // 测试/dev 工厂：补足 urlRegistry + hookRunner + pluginRegistry（空壳，不激活插件），
+    // 生产启动走 bootstrapServerContext → initPlugins（激活 builtin + 发现外部插件）。
+    // 用 mergeConfig 合并 DEFAULT_CONFIG，兼容测试传入 Partial<Config>（历史 cast 用法）。
+    const config = mergeConfig(opts.config ?? DEFAULT_CONFIG);
+    const hookRunner = createHookRunner();
+    // Agent 注册表：测试可注入；默认含 4 个内置 agent（general/coder/researcher/reviewer）。
+    const agentRegistry = opts.agentRegistry ??
+        (() => {
+            const reg = createAgentRegistry();
+            for (const def of BUILTIN_AGENTS)
+                reg.register(def);
+            return reg;
+        })();
+    return {
+        db: opts.db,
+        config,
+        toolRegistry: opts.toolRegistry ?? createDefaultRegistry(config),
+        llmRegistry: opts.llmRegistry,
+        urlRegistry: createDefaultURLRegistry(),
+        hookRunner,
+        pluginRegistry: createPluginRegistry(hookRunner),
+        agentManager: createAgentManager(),
+        permissionStore: createPermissionStore(),
+        permissionMode: config.permission.defaultMode,
+        agentRegistry,
+        // 测试上下文：默认 scheduler 不启动（enabled=false 由调用方控制）。
+        updateScheduler: createUpdateScheduler({
+            checkFn: async () => ({
+                hasUpdate: false,
+                currentVersion: '0.0.0',
+                latestVersion: '0.0.0',
+            }),
+        }),
+        cwd: opts.cwd ?? process.cwd(),
+        ...(opts.chatStream ? { chatStream: opts.chatStream } : {}),
+    };
+}
+export { createServerContext, DEFAULT_CONFIG };

package/dist/server/dev.d.ts

@@ -0,0 +1,11 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Hono } from 'hono';
+declare function getDevApp(): Promise<Hono>;
+/** vite dev server 关闭时调用，确保 PGLite WASM 正常 close 并刷写 WAL。 */
+declare function closeDevApp(): Promise<void>;
+/**
+ * 把 Node 请求桥接到 Hono app 并流式回写响应（支持 SSE）。
+ * 用 Readable.fromWeb 管道转发 Response body，原生处理背压与分块。
+ */
+declare function handleApiRequest(app: Hono, req: IncomingMessage, res: ServerResponse): Promise<void>;
+export { closeDevApp, getDevApp, handleApiRequest };

package/dist/server/dev.js

@@ -0,0 +1,83 @@
+// src/server/dev.ts
+import { Readable } from 'node:stream';
+import { createApp } from './app.js';
+import { bootstrapServerContext } from './server.js';
+/**
+ * 开发环境入口：初始化并返回 Hono app。
+ * 供 vite dev server 中间件复用，使前后端共享同一端口。
+ *
+ * 用 globalThis 缓存而非模块级变量：Vite ssrLoadModule 在 server 端代码变更时会
+ * 重新执行本模块，模块级 cachedApp 会重置；这会导致运行中的 AgentManager（含
+ * 权限确认 pending）丢失，前端 POST /api/tools/confirm 拿不到 pending 而 404。
+ * globalThis 跨模块重载保持单例，避免权限流程中途断裂。
+ */
+const DEV_APP_KEY = '__c0de_dev_app__';
+const DEV_CLOSE_KEY = '__c0de_dev_close__';
+async function getDevApp() {
+    const g = globalThis;
+    if (!g[DEV_APP_KEY]) {
+        const { ctx, close } = await bootstrapServerContext({ cwd: process.cwd() });
+        g[DEV_APP_KEY] = createApp(ctx);
+        g[DEV_CLOSE_KEY] = close;
+    }
+    return g[DEV_APP_KEY];
+}
+/** vite dev server 关闭时调用，确保 PGLite WASM 正常 close 并刷写 WAL。 */
+async function closeDevApp() {
+    const g = globalThis;
+    const close = g[DEV_CLOSE_KEY];
+    if (close) {
+        await close();
+        delete g[DEV_APP_KEY];
+        delete g[DEV_CLOSE_KEY];
+    }
+}
+/**
+ * 把 Node 请求桥接到 Hono app 并流式回写响应（支持 SSE）。
+ * 用 Readable.fromWeb 管道转发 Response body，原生处理背压与分块。
+ */
+async function handleApiRequest(app, req, res) {
+    const host = req.headers.host ?? 'localhost';
+    const url = new URL(req.url ?? '/', `http://${host}`);
+    let body;
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+        const chunks = [];
+        for await (const chunk of req) {
+            chunks.push(chunk);
+        }
+        body = Buffer.concat(chunks);
+    }
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (value != null) {
+            headers.set(key, Array.isArray(value) ? value.join(', ') : value);
+        }
+    }
+    const init = {
+        method: req.method,
+        headers,
+        body: body ?? undefined,
+    };
+    if (body !== undefined) {
+        init.duplex = 'half';
+    }
+    const request = new Request(url.toString(), init);
+    const response = await app.fetch(request);
+    res.statusCode = response.status;
+    response.headers.forEach((value, key) => {
+        res.setHeader(key, value);
+    });
+    const responseBody = response.body;
+    if (responseBody) {
+        res.flushHeaders();
+        await new Promise((resolve, reject) => {
+            const nodeStream = Readable.fromWeb(responseBody);
+            nodeStream.on('error', reject);
+            nodeStream.pipe(res).on('finish', resolve);
+        });
+    }
+    else {
+        res.end();
+    }
+}
+export { closeDevApp, getDevApp, handleApiRequest };

package/dist/server/index.d.ts

@@ -0,0 +1,11 @@
+export type { ActiveRun, AgentManager } from './agent-manager.js';
+export { createAgentManager } from './agent-manager.js';
+export { createApp } from './app.js';
+export type { CreateServerContextOptions } from './context.js';
+export { createServerContext } from './context.js';
+export { apiError, errorHandler } from './middleware/error.js';
+export type { InteractivePermissionChecker, InteractivePermissionCheckerOptions, PermissionRequest, } from './permission/interactive.js';
+export { createInteractivePermissionChecker } from './permission/interactive.js';
+export type { RunningServer, StartServerOptions } from './server.js';
+export { startServer } from './server.js';
+export type { APIErrorBody, ChatRequest, ConfirmRequest, ControlRequest, ServerContext, SteerRequest, } from './types.js';

package/dist/server/index.js

@@ -0,0 +1,7 @@
+// src/server/index.ts
+export { createAgentManager } from './agent-manager.js';
+export { createApp } from './app.js';
+export { createServerContext } from './context.js';
+export { apiError, errorHandler } from './middleware/error.js';
+export { createInteractivePermissionChecker } from './permission/interactive.js';
+export { startServer } from './server.js';

package/dist/server/middleware/auth.d.ts

@@ -0,0 +1,15 @@
+import type { MiddlewareHandler } from 'hono';
+export type AuthOptions = {
+    /** 不需认证的路径（默认放行 /api/health 探活）。 */
+    publicPaths?: string[];
+};
+/**
+ * Bearer token 认证中间件（spec §24.2「认证」）。
+ *
+ * - 未配置 token（undefined/空）→ 放行，适配本地开发场景。
+ * - 配置了 token → 校验 `Authorization: Bearer <token>`，不匹配返回 401。
+ * - publicPaths 中的路径始终放行（如健康检查）。
+ *
+ * 生产或远程访问场景应在 config.security.token 配置随机 token。
+ */
+export declare function createAuthMiddleware(token: string | undefined, opts?: AuthOptions): MiddlewareHandler;

package/dist/server/middleware/auth.js

@@ -0,0 +1,29 @@
+import { apiError } from './error.js';
+/**
+ * Bearer token 认证中间件（spec §24.2「认证」）。
+ *
+ * - 未配置 token（undefined/空）→ 放行，适配本地开发场景。
+ * - 配置了 token → 校验 `Authorization: Bearer <token>`，不匹配返回 401。
+ * - publicPaths 中的路径始终放行（如健康检查）。
+ *
+ * 生产或远程访问场景应在 config.security.token 配置随机 token。
+ */
+export function createAuthMiddleware(token, opts = {}) {
+    const expected = token && token.length > 0 ? `Bearer ${token}` : '';
+    const publicPaths = new Set(opts.publicPaths ?? ['/api/health']);
+    return async (c, next) => {
+        if (!expected) {
+            await next();
+            return;
+        }
+        if (publicPaths.has(c.req.path)) {
+            await next();
+            return;
+        }
+        const auth = c.req.header('Authorization') ?? '';
+        if (auth !== expected) {
+            return apiError(c, 401, 'UNAUTHORIZED', 'Missing or invalid bearer token');
+        }
+        await next();
+    };
+}

package/dist/server/middleware/cors.d.ts

@@ -0,0 +1,16 @@
+import type { MiddlewareHandler } from 'hono';
+/**
+ * 判断 origin 是否为本地/可信来源（spec §24.2「CORS 限制本地 origin」）。
+ * 允许：本机回环任意端口、file://（PWA 安装后）、浏览器扩展、'null'
+ * （file 协议/隐私沙箱发出的 Origin 头）。
+ */
+export declare function isLocalOrigin(origin: string): boolean;
+export type CORSOptions = {
+    /** 额外允许的 origin（如远程访问场景配置的域名）。 */
+    allowedOrigins?: string[];
+};
+/**
+ * CORS 中间件：仅对本地/可信 origin 回显 Access-Control-Allow-Origin，
+ * 拒绝外部网页跨域读取本地 server（spec §24.2）。处理 OPTIONS 预检。
+ */
+export declare function createCORSMiddleware(opts?: CORSOptions): MiddlewareHandler;

package/dist/server/middleware/cors.js

@@ -0,0 +1,44 @@
+/** 本地回环 origin 模式：http(s)://(localhost|127.0.0.1|[::1])(:port)。 */
+const LOCAL_ORIGIN = /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/;
+/**
+ * 判断 origin 是否为本地/可信来源（spec §24.2「CORS 限制本地 origin」）。
+ * 允许：本机回环任意端口、file://（PWA 安装后）、浏览器扩展、'null'
+ * （file 协议/隐私沙箱发出的 Origin 头）。
+ */
+export function isLocalOrigin(origin) {
+    if (!origin)
+        return false;
+    if (LOCAL_ORIGIN.test(origin))
+        return true;
+    if (origin === 'null')
+        return true;
+    if (origin.startsWith('file://'))
+        return true;
+    if (origin.startsWith('chrome-extension://'))
+        return true;
+    if (origin.startsWith('moz-extension://'))
+        return true;
+    return false;
+}
+/**
+ * CORS 中间件：仅对本地/可信 origin 回显 Access-Control-Allow-Origin，
+ * 拒绝外部网页跨域读取本地 server（spec §24.2）。处理 OPTIONS 预检。
+ */
+export function createCORSMiddleware(opts = {}) {
+    const extra = new Set(opts.allowedOrigins ?? []);
+    return async (c, next) => {
+        const origin = c.req.header('Origin') ?? '';
+        const allowed = isLocalOrigin(origin) || extra.has(origin);
+        if (origin.length > 0 && allowed) {
+            c.header('Access-Control-Allow-Origin', origin);
+            c.header('Vary', 'Origin');
+        }
+        if (c.req.method === 'OPTIONS') {
+            c.header('Access-Control-Allow-Methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS');
+            c.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+            c.header('Access-Control-Max-Age', '86400');
+            return c.body(null, 204);
+        }
+        await next();
+    };
+}

package/dist/server/middleware/error.d.ts

@@ -0,0 +1,15 @@
+import type { Context } from 'hono';
+import type { ContentfulStatusCode } from 'hono/utils/http-status';
+/** 构建标准 JSON 错误响应。 */
+declare function apiError(c: Context, status: ContentfulStatusCode, code: string, message: string, details?: Record<string, unknown>): Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: {
+            [x: string]: import("hono/utils/types").JSONValue;
+        } | undefined;
+    };
+}, ContentfulStatusCode, "json">;
+/** Hono onError 处理器：捕获未处理异常，返回 500。 */
+declare function errorHandler(err: Error, c: Context): Response;
+export { apiError, errorHandler };

package/dist/server/middleware/error.js

@@ -0,0 +1,11 @@
+// src/server/middleware/error.ts
+/** 构建标准 JSON 错误响应。 */
+function apiError(c, status, code, message, details) {
+    return c.json({ error: { code, message, ...(details ? { details } : {}) } }, status);
+}
+/** Hono onError 处理器：捕获未处理异常，返回 500。 */
+function errorHandler(err, c) {
+    const message = err instanceof Error ? err.message : 'Internal server error';
+    return c.json({ error: { code: 'INTERNAL', message } }, 500);
+}
+export { apiError, errorHandler };

package/dist/server/permission/interactive.d.ts

@@ -0,0 +1,24 @@
+import type { PermissionChecker } from '../../tools/types.js';
+import type { PermissionRequest, PermissionStore } from './store.js';
+export type { PermissionRequest };
+type PermissionMode = 'default' | 'auto';
+type InteractivePermissionCheckerOptions = {
+    /** 始终允许的工具名（覆盖 permission 字段）。 */
+    alwaysAllow?: string[];
+    /** 始终拒绝的工具名（覆盖 permission 字段）。 */
+    alwaysDeny?: string[];
+    /** 读取当前授权模式：'auto' 时跳过 ask 交互确认（YOLO 自动授权）。 */
+    getMode?: () => PermissionMode;
+    /** 遇到 ask 权限时调用（用于通知前端）。 */
+    onPermissionRequired?: (request: PermissionRequest) => void | Promise<void>;
+};
+/** 阻塞式权限检查器：ask 权限会阻塞等待用户确认。
+ *  pending 存在全局 PermissionStore 中，独立于 agent run 生命周期。 */
+type InteractivePermissionChecker = PermissionChecker & {
+    confirm(toolCallId: string, approved: boolean): boolean;
+    hasPending(toolCallId: string): boolean;
+    pendingCount(): number;
+};
+declare function createInteractivePermissionChecker(store: PermissionStore, opts?: InteractivePermissionCheckerOptions): InteractivePermissionChecker;
+export type { InteractivePermissionChecker, InteractivePermissionCheckerOptions };
+export { createInteractivePermissionChecker };

package/dist/server/permission/interactive.js

@@ -0,0 +1,56 @@
+import { randomUUID } from 'node:crypto';
+function createInteractivePermissionChecker(store, opts = {}) {
+    const allowSet = new Set(opts.alwaysAllow ?? []);
+    const denySet = new Set(opts.alwaysDeny ?? []);
+    return {
+        check: async (tool, input, ctx) => {
+            if (denySet.has(tool.name)) {
+                return { _tag: 'deny', reason: `Tool "${tool.name}" is denied by configuration` };
+            }
+            if (allowSet.has(tool.name) || tool.permission === 'auto') {
+                return { _tag: 'allow' };
+            }
+            if (tool.permission === 'deny') {
+                return { _tag: 'deny', reason: `Tool "${tool.name}" is disabled` };
+            }
+            // tool.permission === 'ask'
+            // YOLO 自动授权：mode==='auto' 时跳过交互确认直接放行。
+            // denySet 与 permission==='deny' 已在上游拦截，故此处只剩 ask 工具。
+            if (opts.getMode?.() === 'auto') {
+                return { _tag: 'allow' };
+            }
+            // 交互式确认
+            const toolCallId = randomUUID();
+            const request = { toolCallId, tool: tool.name, input };
+            const promise = new Promise((resolve) => {
+                // pending 注册到全局 store，confirm 端点按 toolCallId 直接寻址，
+                // 不依赖当前 agent run 是否仍在 agentManager 中注册。
+                // store 内置超时：到期自动 deny 并清理条目（防永久挂起 + Map 泄漏）。
+                store.register(toolCallId, { request, resolve });
+            });
+            await opts.onPermissionRequired?.(request);
+            // agent abort 联动：abort 时主动 deny 并清理 store 条目，
+            // 避免 agent 已中止后 promise 仍悬空等待超时。store.resolve 是幂等终结，
+            // 与超时/confirm 互斥——谁先到谁生效。
+            if (ctx.abort.aborted) {
+                store.resolve(toolCallId, false);
+            }
+            else {
+                ctx.abort.addEventListener('abort', () => {
+                    store.resolve(toolCallId, false);
+                }, { once: true });
+            }
+            return promise;
+        },
+        confirm(toolCallId, approved) {
+            return store.resolve(toolCallId, approved);
+        },
+        hasPending(toolCallId) {
+            return store.has(toolCallId);
+        },
+        pendingCount() {
+            return store.size();
+        },
+    };
+}
+export { createInteractivePermissionChecker };

package/dist/server/permission/store.d.ts

@@ -0,0 +1,30 @@
+import type { PermissionResult } from '../../tools/types.js';
+/** 默认 pending 超时时长：5 分钟（300_000ms）。
+ *  超过后自动 resolve 为 deny 并清理 store 条目，避免 promise 永久挂起与 pending Map 泄漏。 */
+declare const DEFAULT_PERMISSION_TIMEOUT_MS: number;
+/** 权限请求（需要用户确认）。 */
+type PermissionRequest = {
+    toolCallId: string;
+    tool: string;
+    input: unknown;
+};
+/** 待处理的权限确认。 */
+type PendingPermission = {
+    request: PermissionRequest;
+    resolve: (result: PermissionResult) => void;
+};
+/** createPermissionStore 的配置。 */
+type PermissionStoreOptions = {
+    /** pending 超时毫秒数；省略时取 DEFAULT_PERMISSION_TIMEOUT_MS（5 分钟）。 */
+    timeoutMs?: number;
+};
+/** 全局权限确认 store：注册/解析 pending permission。 */
+type PermissionStore = {
+    register(toolCallId: string, pending: PendingPermission): void;
+    resolve(toolCallId: string, approved: boolean): boolean;
+    has(toolCallId: string): boolean;
+    size(): number;
+};
+declare function createPermissionStore(opts?: PermissionStoreOptions): PermissionStore;
+export type { PendingPermission, PermissionRequest, PermissionStore, PermissionStoreOptions };
+export { createPermissionStore, DEFAULT_PERMISSION_TIMEOUT_MS };

package/dist/server/permission/store.js

@@ -0,0 +1,47 @@
+// 全局权限确认 store —— 进程级单例，pending 独立于 agent run 生命周期。
+//
+// 设计参考 opencode 的 PermissionV2.Service：pending 挂在全局/Service 层，
+// reply 按 toolCallId 直接寻址，不依赖 session/agent run 的注册状态。
+// 这样即使 agent run 被覆盖、注销或 abort，pending 仍在 store 里，
+// confirm 仍能找到并 resolve。
+/** 默认 pending 超时时长：5 分钟（300_000ms）。
+ *  超过后自动 resolve 为 deny 并清理 store 条目，避免 promise 永久挂起与 pending Map 泄漏。 */
+const DEFAULT_PERMISSION_TIMEOUT_MS = 5 * 60 * 1000;
+function createPermissionStore(opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_PERMISSION_TIMEOUT_MS;
+    const pending = new Map();
+    // 统一终结路径：clearTimeout → 删除条目 → resolve。
+    // 三处调用（confirm、超时回调、abort 联动）都汇聚于此：
+    // 保证 promise 只 settle 一次（resolve 幂等）、定时器必被清理、Map 条目必被释放。
+    const settle = (toolCallId, result) => {
+        const p = pending.get(toolCallId);
+        if (!p)
+            return false;
+        clearTimeout(p.timer);
+        pending.delete(toolCallId);
+        p.resolve(result);
+        return true;
+    };
+    return {
+        register(toolCallId, entry) {
+            // 重复注册同 id 时先清理旧定时器，避免旧 timer 泄漏。
+            const existing = pending.get(toolCallId);
+            if (existing)
+                clearTimeout(existing.timer);
+            const timer = setTimeout(() => {
+                settle(toolCallId, { _tag: 'deny', reason: 'Permission request timed out' });
+            }, timeoutMs);
+            pending.set(toolCallId, { ...entry, timer });
+        },
+        resolve(toolCallId, approved) {
+            return settle(toolCallId, approved ? { _tag: 'allow' } : { _tag: 'deny', reason: 'User denied permission' });
+        },
+        has(toolCallId) {
+            return pending.has(toolCallId);
+        },
+        size() {
+            return pending.size;
+        },
+    };
+}
+export { createPermissionStore, DEFAULT_PERMISSION_TIMEOUT_MS };

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

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

package/dist/server/routes/agent.js

@@ -0,0 +1,19 @@
+import { Hono } from 'hono';
+function createAgentRoute(ctx) {
+    const app = new Hono();
+    // GET / — 返回所有 agent（前端按 mode 过滤展示）
+    app.get('/', (c) => {
+        const all = ctx.agentRegistry.list();
+        return c.json({
+            agents: all.map((d) => ({
+                name: d.name,
+                description: d.description,
+                mode: d.mode,
+                source: d.source,
+                hasTools: Boolean(d.tools),
+            })),
+        });
+    });
+    return app;
+}
+export { createAgentRoute };

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

@@ -0,0 +1,42 @@
+import { Hono } from 'hono';
+import type { ServerContext } from '../types.js';
+/** 完整目录数据。 */
+type CatalogData = Record<string, CatalogProviderInternal>;
+type CatalogProviderInternal = {
+    id: string;
+    name: string;
+    npm?: string;
+    api?: string;
+    env: string[];
+    doc?: string;
+    models: Record<string, CatalogModelInternal>;
+};
+type CatalogModelInternal = {
+    id: string;
+    name: string;
+    family?: string;
+    reasoning: boolean;
+    tool_call: boolean;
+    attachment: boolean;
+    temperature: boolean;
+    limit: {
+        context: number;
+        output: number;
+    };
+    cost?: {
+        input?: number;
+        output?: number;
+    };
+};
+/** 清除内存 + 磁盘缓存（主要用于测试）。 */
+declare function clearCatalogCache(): void;
+/**
+ * 获取 models.dev 目录数据（带缓存）。
+ * 优先用内存缓存，其次磁盘缓存，最后发起网络请求。
+ */
+declare function fetchCatalog(force?: boolean): Promise<{
+    data: CatalogData;
+    fetchedAt: number;
+}>;
+declare function createCatalogRoute(ctx: ServerContext): Hono;
+export { clearCatalogCache, createCatalogRoute, fetchCatalog };