c0de-agent 0.0.0 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wmzy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# c0de-agent
+
+开源 AI 编码助手，采用 Browser-Server 架构（Hono + SSE 后端 / React 前端 / PGLite 本地数据库 / CLI）。
+
+## 特性
+
+- **Browser-Server 架构**：Hono 后端通过 SSE 推送 LLM 流式响应；React 前端单页应用。
+- **本地优先**：会话与索引存储在 PGLite（浏览器/进程内 PostgreSQL），数据随用随取。
+- **多项目**：工作区隔离的多项目管理，每个项目独立会话历史与配置。
+- **工具系统**：内置文件读写、bash、grep、glob、编辑等工具，可按需启用/禁用。
+- **权限模式**：`default` / `yolo` 等授权模式，控制工具执行前是否需用户确认。
+- **会话可恢复**：会话快照序列化/反序列化，支持进程重启后无缝恢复。
+- **无感知热更新**：后台定期检查新版本，序列化当前会话 → npm 自更新 → 端口 handoff 接管，用户无感升级。
+- **Web 搜索**：内置 websearch 工具，支持多搜索引擎。
+- **斜杠命令**：`/compact`、`/model`、`/clear` 等可配置的斜杠命令。
+- **主题与多语言**：亮/暗主题，简体中文 / English。
+
+## 安装
+
+```bash
+# 全局安装（推荐）
+npm install -g c0de-agent
+
+# 或用 pnpm / yarn
+pnpm add -g c0de-agent
+```
+
+要求 Node.js >= 22.0.0。
+
+## 使用
+
+```bash
+# 在项目目录启动
+c0de serve
+
+# 指定端口并自动打开浏览器
+c0de serve --port 3000 --open
+
+# 从快照恢复会话
+c0de serve --restore snapshot.json
+
+# 打印模式（单次问答，不启动服务）
+c0de chat "解释这段代码"
+
+# 更新检查
+c0de update --check
+```
+
+启动后访问 `http://localhost:3000`。
+
+## 开发
+
+```bash
+# 安装依赖
+pnpm install
+
+# 启动开发服务器（前端热更新）
+pnpm dev
+
+# 类型检查
+pnpm typecheck       # 后端
+pnpm typecheck:web   # 前端
+
+# 测试
+pnpm test
+
+# 构建
+pnpm build         # 编译 CLI/后端到 dist/
+pnpm build:web     # 构建前端到 dist-web/
+
+# 代码检查与格式化
+pnpm lint
+pnpm format
+```
+
+## 架构
+
+```
+src/
+├── cli/           # CLI 入口与命令（serve / chat / update）
+├── core/          # 配置、agent 注册、权限、工具注册
+├── llm/           # LLM provider 抽象与调用
+├── server/        # Hono HTTP 服务、SSE 流、路由、handoff
+├── session/       # 会话上下文与消息转换
+├── shared/        # 前后端共享类型
+├── tools/         # 内置工具实现
+├── update/        # 版本检查、热更新调度器、会话快照
+└── web/           # React 前端（组件、视图、服务、hooks）
+```
+
+## 发布
+
+采用 [semantic-release](https://github.com/semantic-release/semantic-release) 自动化发布，基于 conventional commits（`feat:`、`fix:`、`refactor:` 等）自动计算版本号、生成 changelog 并发布到 npm。
+
+- `main` 分支推送触发 `.github/workflows/release.yml`
+- 通过 GitHub Actions OIDC trusted publishing 发布（无需 NPM_TOKEN）
+- 发布产物带 npm provenance（可验证来源）
+
+## License
+
+[MIT](./LICENSE)

package/dist/cli/commands/acp.d.ts

@@ -0,0 +1,19 @@
+import type { LoopDeps } from '../../core/loop.js';
+import type { Config } from '../../shared/types/config.js';
+import type { ACPHandler } from '../modes/acp.js';
+type AcpHandlersOptions = {
+    onEvent: (method: string, params: Record<string, unknown>) => void;
+};
+/** 构造 ACP method → handler 映射。chat 复用 Print 模式。 */
+declare function createAcpHandlers(config: Config, deps: LoopDeps, opts: AcpHandlersOptions): Record<string, ACPHandler>;
+/** 写一行 ACP event 到给定 writer（命令层用于接 stdout）。 */
+declare function writeAcpEvent(writer: (line: string) => void, method: string, params: Record<string, unknown>): void;
+type AcpCommandContext = {
+    config: Config;
+    deps: LoopDeps;
+    stdin?: NodeJS.ReadableStream;
+    stdout?: NodeJS.WritableStream;
+};
+declare function runAcpCommand(ctx: AcpCommandContext): Promise<void>;
+export type { AcpCommandContext, AcpHandlersOptions };
+export { createAcpHandlers, runAcpCommand, writeAcpEvent };

package/dist/cli/commands/acp.js

@@ -0,0 +1,50 @@
+import readline from 'node:readline/promises';
+import { createSession, listSessions } from '../../session/session.js';
+import { formatACPEvent, runAcpLoop } from '../modes/acp.js';
+import { runPrintMode } from '../modes/print.js';
+/** 构造 ACP method → handler 映射。chat 复用 Print 模式。 */
+function createAcpHandlers(config, deps, opts) {
+    return {
+        'session/create': async (params) => {
+            const title = params.title ?? 'acp-session';
+            const session = await createSession(deps.db, title);
+            return { sessionId: session.id };
+        },
+        'session/list': async () => {
+            const sessions = await listSessions(deps.db);
+            return { sessions };
+        },
+        chat: async (params) => {
+            const message = params.message;
+            if (!message)
+                throw new Error('chat: message is required');
+            const text = await runPrintMode(config, message, deps, {
+                onEvent: (e) => opts.onEvent('event', e),
+            });
+            return { text };
+        },
+        abort: async () => ({ ok: true }),
+        'tool/confirm': async () => ({ ok: true }),
+    };
+}
+/** 写一行 ACP event 到给定 writer（命令层用于接 stdout）。 */
+function writeAcpEvent(writer, method, params) {
+    writer(formatACPEvent(method, params));
+}
+async function runAcpCommand(ctx) {
+    const out = ctx.stdout ?? process.stdout;
+    const rl = readline.createInterface({ input: ctx.stdin ?? process.stdin });
+    async function* reader() {
+        for await (const line of rl)
+            yield line;
+    }
+    const handlers = createAcpHandlers(ctx.config, ctx.deps, {
+        onEvent: (_method, params) => out.write(`${formatACPEvent('event', params)}\n`),
+    });
+    await runAcpLoop({
+        reader: reader(),
+        writer: (line) => out.write(`${line}\n`),
+        handlers,
+    });
+}
+export { createAcpHandlers, runAcpCommand, writeAcpEvent };

package/dist/cli/commands/chat.d.ts

@@ -0,0 +1,13 @@
+import type { LoopDeps } from '../../core/loop.js';
+import type { Config } from '../../shared/types/config.js';
+import type { CommandArgs } from '../parser.js';
+type ChatCommandContext = {
+    args: CommandArgs;
+    config: Config;
+    deps: LoopDeps;
+    stdout?: (s: string) => void;
+    stderr?: (s: string) => void;
+};
+declare function runChatCommand(ctx: ChatCommandContext): Promise<void>;
+export type { ChatCommandContext };
+export { runChatCommand };

package/dist/cli/commands/chat.js

@@ -0,0 +1,26 @@
+import { runPrintMode } from '../modes/print.js';
+async function runChatCommand(ctx) {
+    const message = ctx.args.positionals.join(' ').trim();
+    if (!message)
+        throw new Error('chat: a message is required (c0de chat "your question")');
+    const out = ctx.stdout ?? process.stdout.write.bind(process.stdout);
+    const err = ctx.stderr ?? process.stderr.write.bind(process.stderr);
+    const format = ctx.args.options.format ?? 'text';
+    const model = ctx.args.options.model;
+    const text = await runPrintMode(ctx.config, message, ctx.deps, {
+        ...(model ? { model } : {}),
+        onEvent: (e) => {
+            if (e._tag === 'tool_call_start')
+                err(`[tool] ${e.tool}\n`);
+            else if (e._tag === 'thinking')
+                err(`[thinking] ${e.text}\n`);
+        },
+    });
+    if (format === 'json') {
+        out(`${JSON.stringify({ text })}\n`);
+    }
+    else {
+        out(`${text}\n`);
+    }
+}
+export { runChatCommand };

package/dist/cli/commands/config.d.ts

@@ -0,0 +1,17 @@
+import type { CommandArgs } from '../parser.js';
+type ConfigCommandContext = {
+    args: CommandArgs;
+    cwd: string;
+    write?: (s: string) => void;
+};
+/** 按 a.b.c 点路径从对象取值；找不到抛错。 */
+declare function getByPath(obj: unknown, path: string): unknown;
+/** 按 a.b.c 点路径写值（创建中间对象）。 */
+declare function setByPath(obj: Record<string, unknown>, path: string, value: unknown): void;
+/** 把字符串解析为合适的标量类型。 */
+declare function coerce(value: string): unknown;
+/** 构造 a.b.c → { a: { b: { c: value } } } 的 patch 对象。 */
+declare function setPathPatch(path: string, value: unknown): Record<string, unknown>;
+declare function runConfigCommand(ctx: ConfigCommandContext): Promise<void>;
+export type { ConfigCommandContext };
+export { coerce, getByPath, runConfigCommand, setByPath, setPathPatch };

package/dist/cli/commands/config.js

@@ -0,0 +1,77 @@
+import { loadConfig, mergeConfig, saveConfig } from '../../core/config.js';
+/** 按 a.b.c 点路径从对象取值；找不到抛错。 */
+function getByPath(obj, path) {
+    const parts = path.split('.');
+    let cur = obj;
+    for (const p of parts) {
+        if (cur === null || typeof cur !== 'object')
+            throw new Error(`config: key "${path}" not found`);
+        cur = cur[p];
+        if (cur === undefined)
+            throw new Error(`config: key "${path}" not found`);
+    }
+    return cur;
+}
+/** 按 a.b.c 点路径写值（创建中间对象）。 */
+function setByPath(obj, path, value) {
+    const parts = path.split('.');
+    let cur = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const k = parts[i];
+        const next = cur[k];
+        cur[k] = (next !== null && typeof next === 'object' ? next : {});
+        cur = cur[k];
+    }
+    cur[parts[parts.length - 1]] = value;
+}
+/** 把字符串解析为合适的标量类型。 */
+function coerce(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (/^-?\d+(\.\d+)?$/.test(value))
+        return Number(value);
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+/** 构造 a.b.c → { a: { b: { c: value } } } 的 patch 对象。 */
+function setPathPatch(path, value) {
+    const root = {};
+    setByPath(root, path, value);
+    return root;
+}
+async function runConfigCommand(ctx) {
+    const write = ctx.write ?? process.stdout.write.bind(process.stdout);
+    const sub = ctx.args.positionals[0];
+    const config = await loadConfig(ctx.cwd);
+    if (sub === 'get') {
+        const key = ctx.args.positionals[1];
+        if (!key) {
+            write(`${JSON.stringify(config, null, 2)}\n`);
+            return;
+        }
+        const val = getByPath(config, key);
+        write(`${typeof val === 'object' ? JSON.stringify(val) : String(val)}\n`);
+        return;
+    }
+    if (sub === 'set') {
+        const key = ctx.args.positionals[1];
+        const rawValue = ctx.args.positionals[2];
+        if (!key)
+            throw new Error('config set: a key is required');
+        if (rawValue === undefined)
+            throw new Error('config set: a value is required');
+        const scope = ctx.args.options.global ? 'global' : 'project';
+        const merged = mergeConfig(config, setPathPatch(key, coerce(rawValue)));
+        await saveConfig(merged, scope, ctx.cwd);
+        write(`Set ${key} (scope: ${scope})\n`);
+        return;
+    }
+    throw new Error(`config: unknown subcommand "${sub ?? ''}" (expected get|set)`);
+}
+export { coerce, getByPath, runConfigCommand, setByPath, setPathPatch };

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,9 @@
+import type { CommandArgs } from '../parser.js';
+type InitCommandContext = {
+    args: CommandArgs;
+    cwd: string;
+    log?: (s: string) => void;
+};
+declare function runInitCommand(ctx: InitCommandContext): Promise<void>;
+export type { InitCommandContext };
+export { runInitCommand };

package/dist/cli/commands/init.js

@@ -0,0 +1,14 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { DEFAULT_CONFIG, saveConfig } from '../../core/config.js';
+async function runInitCommand(ctx) {
+    const log = ctx.log ?? process.stdout.write.bind(process.stdout);
+    const force = ctx.args.options.force ?? false;
+    const path = join(ctx.cwd, '.c0de', 'config.json');
+    if (existsSync(path) && !force) {
+        throw new Error(`init: config already exists at ${path} (use --force to overwrite)`);
+    }
+    await saveConfig(DEFAULT_CONFIG, 'project', ctx.cwd);
+    log(`Created ${path}\n`);
+}
+export { runInitCommand };

package/dist/cli/commands/plugin.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from '../../plugins/types.js';
+import type { CommandArgs } from '../parser.js';
+type PluginCommandContext = {
+    args: CommandArgs;
+    cwd: string;
+    discover?: (cwd: string) => Promise<Plugin[]>;
+    write?: (s: string) => void;
+};
+declare function runPluginCommand(ctx: PluginCommandContext): Promise<void>;
+export type { PluginCommandContext };
+export { runPluginCommand };

package/dist/cli/commands/plugin.js

@@ -0,0 +1,31 @@
+import { loadConfig, saveConfig } from '../../core/config.js';
+async function runPluginCommand(ctx) {
+    const write = ctx.write ?? process.stdout.write.bind(process.stdout);
+    const discover = ctx.discover ?? (async () => []);
+    const sub = ctx.args.positionals[0];
+    if (sub === 'list') {
+        const plugins = await discover(ctx.cwd);
+        if (plugins.length === 0) {
+            write('No plugins found.\n');
+            return;
+        }
+        for (const p of plugins) {
+            write(`- ${p.name}${p.version ? `@${p.version}` : ''}\n`);
+        }
+        return;
+    }
+    if (sub === 'install') {
+        const name = ctx.args.positionals[1];
+        if (!name)
+            throw new Error('plugin install: a plugin name is required');
+        const config = await loadConfig(ctx.cwd);
+        const enabled = config.plugins.enabled;
+        if (!enabled.includes(name))
+            enabled.push(name);
+        await saveConfig(config, 'project', ctx.cwd);
+        write(`Enabled plugin "${name}".\n`);
+        return;
+    }
+    throw new Error(`plugin: unknown subcommand "${sub ?? ''}" (expected list|install)`);
+}
+export { runPluginCommand };

package/dist/cli/commands/serve.d.ts

@@ -0,0 +1,18 @@
+import type { StartServerOptions } from '../../server/index.js';
+import type { CommandArgs } from '../parser.js';
+type RunningHandle = {
+    port: number;
+    close(): Promise<void>;
+};
+type ServeCommandContext = {
+    args: CommandArgs;
+    cwd: string;
+    serverStarter?: (opts: StartServerOptions) => Promise<RunningHandle>;
+    banner?: (s: string) => void;
+    opener?: (url: string) => void | Promise<void>;
+    /** false = 测试时不挂起进程（不 await 永久 promise）。 */
+    hold?: boolean;
+};
+declare function runServeCommand(ctx: ServeCommandContext): Promise<void>;
+export type { RunningHandle, ServeCommandContext };
+export { runServeCommand };

package/dist/cli/commands/serve.js

@@ -0,0 +1,35 @@
+import { startServer } from '../../server/index.js';
+import { openBrowser, printStartupBanner } from '../utils/output.js';
+async function runServeCommand(ctx) {
+    const port = ctx.args.options.port ?? 3000;
+    const shouldOpen = ctx.args.options.open ?? true;
+    const starter = ctx.serverStarter ?? startServer;
+    const restore = ctx.args.options.restore;
+    const handoffPort = ctx.args.options['handoff-port'];
+    const handle = await starter({
+        port,
+        cwd: ctx.cwd,
+        ...(restore ? { restoreFrom: restore } : {}),
+        ...(handoffPort ? { handoffPort } : {}),
+    });
+    const url = `http://localhost:${handle.port}`;
+    (ctx.banner ?? printStartupBanner)(url);
+    if (shouldOpen) {
+        const opener = ctx.opener ?? ((u) => openBrowser(u));
+        await opener(url);
+    }
+    // 生产：阻塞直到进程被杀；测试：立即返回。
+    if (ctx.hold === false) {
+        await handle.close();
+        return;
+    }
+    await new Promise((resolve) => {
+        const shutdown = () => {
+            // await close 确保 PGLite WASM 正常关闭刷写 WAL，否则下次启动 dataDir 损坏 abort。
+            void handle.close().then(resolve);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    });
+}
+export { runServeCommand };

package/dist/cli/commands/update.d.ts

@@ -0,0 +1,24 @@
+import type { DB } from '../../db/client.js';
+import { checkForUpdate, type HotUpdateOptions } from '../../update/index.js';
+import type { CommandArgs } from '../parser.js';
+type UpdateCommandContext = {
+    args: CommandArgs;
+    cwd: string;
+    /** 可选 DB：提供则把当前会话状态序列化进快照（迁移活跃会话）。 */
+    db?: DB;
+    config?: unknown;
+    /** 测试注入版本检查（默认走真实 npm registry）。 */
+    checkFn?: typeof checkForUpdate;
+    /** 透传给 performHotUpdate（测试注入 install/spawn mock）。 */
+    updateOpts?: HotUpdateOptions;
+    out?: (s: string) => void;
+};
+/**
+ * `c0de update`：检查 npm registry 新版本。
+ * - 默认：check-only，报告有无更新。
+ * - `--apply`：执行热更新（序列化快照 → npm install -g → 接力新实例）。
+ *   活跃会话迁移需要注入 db（server 内触发时提供；独立 CLI 无活跃会话）。
+ */
+declare function runUpdateCommand(ctx: UpdateCommandContext): Promise<void>;
+export type { UpdateCommandContext };
+export { runUpdateCommand };

package/dist/cli/commands/update.js

@@ -0,0 +1,40 @@
+import { checkForUpdate, performHotUpdate, serializeSessions, } from '../../update/index.js';
+/**
+ * `c0de update`：检查 npm registry 新版本。
+ * - 默认：check-only，报告有无更新。
+ * - `--apply`：执行热更新（序列化快照 → npm install -g → 接力新实例）。
+ *   活跃会话迁移需要注入 db（server 内触发时提供；独立 CLI 无活跃会话）。
+ */
+async function runUpdateCommand(ctx) {
+    const out = ctx.out ?? ((s) => process.stdout.write(`${s}\n`));
+    const check = ctx.checkFn ?? checkForUpdate;
+    const result = await check();
+    out(`当前版本 ${result.currentVersion}，最新版本 ${result.latestVersion}`);
+    if (!result.hasUpdate) {
+        out('已是最新版本');
+        return;
+    }
+    const apply = ctx.args.options.apply ?? false;
+    if (!apply) {
+        out(`发现新版本 ${result.latestVersion}。加 --apply 执行热更新。`);
+        return;
+    }
+    out(`发现新版本 ${result.latestVersion}，开始热更新…`);
+    const snapshot = ctx.db
+        ? await serializeSessions(ctx.db, ctx.config)
+        : {
+            version: result.currentVersion,
+            sessions: [],
+            entries: [],
+            config: ctx.config ?? null,
+            timestamp: Date.now(),
+        };
+    const r = await performHotUpdate(snapshot, ctx.updateOpts);
+    if (r._tag === 'success') {
+        out(`热更新完成，快照写入 ${r.snapshotPath}。新实例将接管。`);
+    }
+    else {
+        out(`热更新失败（${r._tag}）：${'error' in r ? r.error : ''}`);
+    }
+}
+export { runUpdateCommand };

package/dist/cli/deps.d.ts

@@ -0,0 +1,30 @@
+import type { LoopDeps } from '../core/loop.js';
+import type { DB } from '../db/client.js';
+import type { Registry } from '../llm/registry.js';
+import type { Config } from '../shared/types/config.js';
+import type { PermissionChecker } from '../tools/types.js';
+/** 权限策略：
+ * - 'full-auto'：所有工具无条件放行（print/acp 等非交互模式）。
+ * - 'safe'（默认）：只读工具放行，写/执行工具需确认（chat 等 agent 自主执行场景）。 */
+type PermissionStrategy = 'full-auto' | 'safe';
+/** 真正非交互模式（print/acp）：所有工具无条件放行（命令由用户显式触发）。 */
+declare const fullyAutoApproveChecker: PermissionChecker;
+/** 安全策略：只读工具（permission: 'auto'，如 read/grep/glob/websearch）自动放行；
+ * 写/执行工具（permission: 'ask'，如 bash/write/edit）返回 ask 需确认；
+ * permission: 'deny' 拒绝。复用 tools 层 autoAllowChecker（按工具自身声明的权限分级）。 */
+declare const readOnlySafeChecker: PermissionChecker;
+/** 把 config.providers 注册到新建的 LLM registry。 */
+declare function buildLLMRegistry(config: Config): Registry;
+type BuildDepsOptions = {
+    db: DB;
+    cwd: string;
+    /** 权限策略：'full-auto' 全部放行；'safe' 只读放行、写操作 ask。不传时按
+     * config.permission.defaultMode 决定（'auto'→full-auto，'default'→safe）。 */
+    permissionStrategy?: PermissionStrategy;
+    /** 测试注入 mock chatStream。 */
+    chatStream?: LoopDeps['chatStream'];
+};
+/** 组装完整 LoopDeps（默认 safe 放行 + 默认工具注册表）。 */
+declare function buildAgentDeps(config: Config, opts: BuildDepsOptions): Promise<LoopDeps>;
+export type { BuildDepsOptions, PermissionStrategy };
+export { buildAgentDeps, buildLLMRegistry, fullyAutoApproveChecker, readOnlySafeChecker };

package/dist/cli/deps.js

@@ -0,0 +1,70 @@
+import { decryptSecret } from '../core/secret.js';
+import { createRegistry, registerProvider } from '../llm/index.js';
+import { initPlugins } from '../plugins/index.js';
+import { createDefaultRegistry, createDefaultURLRegistry } from '../tools/index.js';
+import { autoAllowChecker } from '../tools/permission.js';
+/** 真正非交互模式（print/acp）：所有工具无条件放行（命令由用户显式触发）。 */
+const fullyAutoApproveChecker = {
+    check: async (_tool, _input, _ctx) => {
+        return { _tag: 'allow' };
+    },
+    confirm: (_toolCallId, _approved) => { },
+};
+/** 安全策略：只读工具（permission: 'auto'，如 read/grep/glob/websearch）自动放行；
+ * 写/执行工具（permission: 'ask'，如 bash/write/edit）返回 ask 需确认；
+ * permission: 'deny' 拒绝。复用 tools 层 autoAllowChecker（按工具自身声明的权限分级）。 */
+const readOnlySafeChecker = autoAllowChecker;
+/** 把 config.providers 注册到新建的 LLM registry。 */
+function buildLLMRegistry(config) {
+    const registry = createRegistry();
+    for (const p of config.providers) {
+        registerProviderFromConfig(registry, p);
+    }
+    return registry;
+}
+function registerProviderFromConfig(registry, p) {
+    // 兼容 config.json 中以 _tag 标识 provider 的格式（name 缺失时回退到 _tag）
+    const name = p.name || p._tag;
+    if (!name || !p.baseURL)
+        return;
+    // baseURL 已含 /v1 时用 /chat/completions，避免 /v1/v1 双重前缀
+    const path = p.baseURL.replace(/\/+$/, '').endsWith('/v1') ? '/chat/completions' : undefined;
+    registerProvider(registry, {
+        name,
+        baseURL: p.baseURL,
+        apiKey: p.apiKey ? decryptSecret(p.apiKey) : p.apiKey,
+        ...(path ? { path } : {}),
+    });
+}
+/** 解析权限 checker：显式策略优先，否则回退到 config.permission.defaultMode。 */
+function resolvePermissionChecker(config, strategy) {
+    if (strategy === 'full-auto')
+        return fullyAutoApproveChecker;
+    if (strategy === 'safe')
+        return readOnlySafeChecker;
+    return config.permission.defaultMode === 'auto' ? fullyAutoApproveChecker : readOnlySafeChecker;
+}
+/** 组装完整 LoopDeps（默认 safe 放行 + 默认工具注册表）。 */
+async function buildAgentDeps(config, opts) {
+    const llmRegistry = buildLLMRegistry(config);
+    const toolRegistry = createDefaultRegistry(config);
+    const { hookRunner } = await initPlugins({
+        cwd: opts.cwd,
+        config,
+        toolRegistry,
+        llmRegistry,
+    });
+    const deps = {
+        db: opts.db,
+        llmRegistry,
+        toolRegistry,
+        urlRegistry: createDefaultURLRegistry(),
+        hookRunner,
+        permission: resolvePermissionChecker(config, opts.permissionStrategy),
+        config,
+        cwd: opts.cwd,
+        ...(opts.chatStream ? { chatStream: opts.chatStream } : {}),
+    };
+    return deps;
+}
+export { buildAgentDeps, buildLLMRegistry, fullyAutoApproveChecker, readOnlySafeChecker };

package/dist/cli/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import type { CommandSpec } from './parser.js';
+declare const COMMANDS: CommandSpec[];
+type DispatchOverrides = {
+    runServe?: () => Promise<void>;
+};
+declare function dispatch(argv: string[], overrides?: DispatchOverrides): Promise<void>;
+export { COMMANDS, dispatch };