hyacinth-ai 0.9.6

package/dist/tools/bash.js

@@ -0,0 +1,391 @@
+import { spawn, execSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/** 默认的危险命令黑名单（子串匹配） */
+const DEFAULT_BLOCKED_COMMANDS = [
+    'rm -rf /',
+    'mkfs',
+    'dd if=',
+    ':(){:|:&};:',
+    'del /f /s /q C:',
+];
+/** 词边界正则黑名单 — 匹配独立危险命令。
+ *  (?!-) 确保 format 不误杀 PowerShell 的 Format-List/Format-Table/Format-Hex 等 cmdlet */
+const BLOCKED_COMMAND_REGEX = [
+    { pattern: /\bformat\b(?!-)/i, label: 'format' },
+];
+/**
+ * 如果命令是 `powershell -Command "..."` 包装，取出内部脚本。
+ * spawnWindows 已通过 -File 在 PowerShell 中执行，嵌套的 powershell
+ * 会重新引入 cmd.exe 包装层，破坏 $_ / 管道 / 重定向。
+ *
+ * 不靠枚举标志名的正则——只找 -Command/-c 分隔点，拿到后面的内容即可。
+ */
+function unwrapPsCommand(command) {
+    const lc = command.toLowerCase();
+    // 只处理以 powershell 开头的命令行
+    if (!lc.startsWith('powershell'))
+        return command;
+    // 找 -Command 或 -c（必须是独立参数，不能是 -CustomFlag 的一部分）
+    const cmdIdx = lc.search(/\s-(?:command|c)\b/i);
+    if (cmdIdx === -1) {
+        // 没有 -Command 标志，可能是裸 powershell 调用，
+        // 整个 command 就是脚本内容 — 但 powershell 本身不是有效 PS 脚本，
+        // 把整个字符串当 PS 代码执行（PS 会报语法错），也算合理。
+        return command;
+    }
+    let script = command.slice(cmdIdx).trim().replace(/^-(?:command|c)\s*/i, '').trim();
+    // 去掉外层引号
+    if ((script.startsWith('"') && script.endsWith('"')) ||
+        (script.startsWith("'") && script.endsWith("'"))) {
+        script = script.slice(1, -1);
+    }
+    return script || command;
+}
+/**
+ * Windows: 将命令写入临时 .ps1 文件，通过 `powershell -File` 直接执行。
+ *
+ * 绕过了 spawn({ shell: true }) 的 cmd.exe 包装层，命令原文直达 PowerShell。
+ */
+function spawnWindows(command, cwd, env, opts) {
+    // 剥掉可能的 powershell -Command "..." 外壳，避免嵌套调用
+    const script = unwrapPsCommand(command);
+    // 写临时 .ps1 文件，UTF-8 with BOM（PowerShell -File 靠 BOM 识别编码）
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-ps-'));
+    const psFile = path.join(tmpDir, 'script.ps1');
+    // BOM + 编码设置：确保 PS 解析和外部命令都走 UTF-8
+    const preamble = [
+        '[Console]::OutputEncoding = [Text.Encoding]::UTF8',
+        '[Console]::InputEncoding  = [Text.Encoding]::UTF8',
+        '$OutputEncoding = [Text.Encoding]::UTF8',
+        'chcp 65001 > $null', // 让 cmd.exe / 外部命令也走 UTF-8
+    ].join('\n');
+    fs.writeFileSync(psFile, '' + preamble + '\n' + script + '\n', 'utf-8');
+    const child = spawn('powershell.exe', [
+        '-NoProfile',
+        '-NonInteractive',
+        '-ExecutionPolicy', 'Bypass',
+        '-File', psFile,
+    ], {
+        cwd,
+        env,
+        detached: opts.detached,
+        stdio: [opts.stdin, 'pipe', 'pipe'],
+        // shell: false — 不经过 cmd.exe，直接创建 powershell 进程
+        windowsHide: true,
+    });
+    // 子进程退出后清理临时目录
+    child.on('close', () => {
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { }
+    });
+    child.on('error', () => {
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { }
+    });
+    return child;
+}
+/**
+ * BashTool — 在子进程中执行命令
+ *
+ * 参数：
+ * - command (必需): 要执行的命令
+ * - timeout (可选): 超时时间（秒），默认 600
+ * - env (可选): 环境变量映射，会自动持久化到后续调用
+ *
+ * 平台适配：
+ * - Windows: 命令写入临时 .ps1 文件，powershell -File 直接执行
+ * - Linux/macOS: 使用 /bin/sh 执行
+ *
+ * 返回 stdout + stderr，超时后终止进程树
+ * 工作目录为当前 Agent 的工作目录
+ */
+export class BashTool {
+    name = 'bash';
+    description = 'Execute a shell command and return stdout/stderr. On Windows, commands natively run in PowerShell — do NOT prefix with "powershell -Command". On Linux/macOS, commands run in /bin/sh. Set async=true for background execution.';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            command: {
+                type: 'string',
+                description: 'The command to execute',
+            },
+            timeout: {
+                type: 'number',
+                description: 'Timeout in seconds. Default is 600. Applies to both sync and async execution.',
+            },
+            env: {
+                type: 'object',
+                description: 'Environment variables to set for this command. These persist across subsequent bash calls in this session. Example: {"PYTHONIOENCODING": "utf-8"}',
+            },
+            async: {
+                type: 'boolean',
+                description: 'If true, run the command as a background process. Returns a handle immediately (e.g. [background:bg_001]). The process continues running and can be managed with process_list/process_output/process_kill.',
+            },
+        },
+        required: ['command'],
+    };
+    executionMode = 'asyncable';
+    cwd;
+    sandboxConfig;
+    persistentEnv;
+    backgroundRegistry;
+    allowAsync = true;
+    constructor(cwd, sandboxConfig) {
+        this.cwd = cwd ?? process.cwd();
+        this.sandboxConfig = sandboxConfig ?? {
+            blockedCommands: DEFAULT_BLOCKED_COMMANDS,
+        };
+        this.persistentEnv = {};
+    }
+    /** 更新工作目录 */
+    setCwd(cwd) {
+        this.cwd = cwd;
+    }
+    /** 运行时更新沙箱配置 */
+    setSandboxConfig(config) {
+        this.sandboxConfig = config;
+    }
+    /** 注入后台进程注册表（用于 async 模式） */
+    setBackgroundRegistry(registry) {
+        this.backgroundRegistry = registry;
+    }
+    /** 是否允许 async 模式（默认 true，可通过 tools.allowAsync 配置关闭） */
+    setAllowAsync(allow) {
+        this.allowAsync = allow;
+    }
+    /** 获取当前沙箱配置（只读） */
+    getSandboxConfig() {
+        return this.sandboxConfig;
+    }
+    /**
+     * 杀死进程树
+     * - Windows: 使用 taskkill /T /F /PID
+     * - Unix: 使用 process.kill(-pid) 杀进程组
+     */
+    killProcessTree(pid) {
+        try {
+            if (process.platform === 'win32') {
+                execSync(`taskkill /T /F /PID ${pid}`, { stdio: 'ignore' });
+            }
+            else {
+                process.kill(-pid, 'SIGKILL');
+            }
+        }
+        catch {
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch {
+                // 进程已退出，忽略
+            }
+        }
+    }
+    async execute(args, signal) {
+        const command = args.command;
+        if (!command)
+            return '错误：缺少 command 参数。请提供要执行的命令。';
+        const timeout = args.timeout ?? 600;
+        const callEnv = args.env ?? {};
+        const runAsync = args.async === true;
+        // 持久化本次调用指定的环境变量
+        for (const [key, value] of Object.entries(callEnv)) {
+            this.persistentEnv[key] = value;
+        }
+        // 沙箱拦截：检查危险命令黑名单（子串匹配）
+        const commandLower = command.toLowerCase();
+        for (const blocked of this.sandboxConfig.blockedCommands) {
+            if (commandLower.includes(blocked.toLowerCase())) {
+                throw new Error(`Command blocked by sandbox: contains blocked pattern "${blocked}"`);
+            }
+        }
+        // 沙箱拦截：词边界正则匹配
+        for (const { pattern, label } of BLOCKED_COMMAND_REGEX) {
+            if (pattern.test(command)) {
+                throw new Error(`Command blocked by sandbox: contains blocked command "${label}"`);
+            }
+        }
+        // 沙箱路径白名单已废弃 — 不再限制 cd 目标和工作目录，由 LLM 自行约束
+        // （保留注释以供将来可能需要恢复时参考）
+        // if (this.sandboxConfig.allowedPaths?.length) {
+        //   const cdMatch = commandLower.match(/(?:^|\s|&&|\|{1,2}|;)\s*cd\s+([^\s;&|]+)/);
+        //   if (cdMatch) {
+        //     const targetPath = path.resolve(this.cwd, cdMatch[1]);
+        //     const isAllowed = this.sandboxConfig.allowedPaths.some(
+        //       (allowed) => targetPath.startsWith(path.resolve(allowed)),
+        //     );
+        //     if (!isAllowed) {
+        //       return `Error: Directory "${cdMatch[1]}" is outside allowed paths. Blocked by sandbox.`;
+        //     }
+        //   }
+        // }
+        // if (this.sandboxConfig.allowedPaths?.length) {
+        //   const cwdAllowed = this.sandboxConfig.allowedPaths.some(
+        //     (p) => this.cwd === p || this.cwd.startsWith(p + (os.platform() === 'win32' ? '\\' : '/')),
+        //   );
+        //   if (!cwdAllowed) {
+        //     throw new Error(
+        //       `Command blocked by sandbox: working directory "${this.cwd}" is not in allowed paths`,
+        //     );
+        //   }
+        // }
+        const isWin = process.platform === 'win32';
+        // 构建环境变量
+        const mergedEnv = { ...process.env };
+        if (isWin) {
+            mergedEnv.PYTHONIOENCODING = mergedEnv.PYTHONIOENCODING ?? 'utf-8';
+            mergedEnv.PYTHONUTF8 = mergedEnv.PYTHONUTF8 ?? '1';
+        }
+        for (const [key, value] of Object.entries(this.persistentEnv)) {
+            mergedEnv[key] = value;
+        }
+        // ── 异步执行路径 ──
+        if (runAsync) {
+            if (!this.allowAsync) {
+                return 'Error: Async execution is disabled (tools.allowAsync = false). Run the command synchronously by omitting the "async" parameter.';
+            }
+            if (!this.backgroundRegistry) {
+                return 'Error: BackgroundProcessRegistry not available. Cannot run async commands.';
+            }
+            const childProcess = isWin
+                ? spawnWindows(command, this.cwd, mergedEnv, {
+                    timeout,
+                    signal,
+                    detached: false,
+                    stdin: 'ignore',
+                })
+                : spawn(command, [], {
+                    cwd: this.cwd,
+                    shell: '/bin/sh',
+                    env: mergedEnv,
+                    detached: true,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+            const handle = this.backgroundRegistry.register('bash', command, childProcess);
+            const pid = childProcess.pid ?? '?';
+            // 超时自动终止（和同步路径一致）
+            const timeoutMs = timeout * 1000;
+            const timer = setTimeout(() => {
+                if (childProcess.pid) {
+                    this.killProcessTree(childProcess.pid);
+                }
+                this.backgroundRegistry?.kill(handle);
+            }, timeoutMs);
+            // 子进程正常退出时清除定时器，避免重复 kill
+            childProcess.on('exit', () => clearTimeout(timer));
+            return `[background:${handle}] PID ${pid}\nCommand: ${command}\n\nUse process_output("${handle}") to read output, process_kill("${handle}") to stop.`;
+        }
+        // ── 同步执行路径 ──
+        // 输出截断配置
+        const MAX_OUTPUT_BYTES = this.sandboxConfig.maxOutputBytes ?? 500 * 1024;
+        const LIMIT_KB = Math.round(MAX_OUTPUT_BYTES / 1024);
+        let outputSize = 0;
+        let truncated = false;
+        return new Promise((resolve, reject) => {
+            const startTime = Date.now();
+            const childProcess = isWin
+                ? spawnWindows(command, this.cwd, mergedEnv, {
+                    timeout,
+                    signal,
+                    detached: false,
+                    stdin: 'pipe',
+                })
+                : spawn(command, [], {
+                    cwd: this.cwd,
+                    shell: '/bin/sh',
+                    env: mergedEnv,
+                    detached: false,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            let stdout = '';
+            let stderr = '';
+            // 收集 stdout/stderr，超过上限后丢弃数据
+            childProcess.stdout.on('data', (data) => {
+                const chunk = Buffer.from(data);
+                outputSize += chunk.length;
+                if (outputSize <= MAX_OUTPUT_BYTES) {
+                    stdout += chunk.toString();
+                }
+                else if (!truncated) {
+                    truncated = true;
+                    stdout += `\n\n[Output truncated: exceeded ${LIMIT_KB}KB limit]`;
+                }
+            });
+            childProcess.stderr.on('data', (data) => {
+                const chunk = Buffer.from(data);
+                outputSize += chunk.length;
+                if (outputSize <= MAX_OUTPUT_BYTES) {
+                    stderr += chunk.toString();
+                }
+                else if (!truncated) {
+                    truncated = true;
+                    stderr += `\n\n[Output truncated: exceeded ${LIMIT_KB}KB limit]`;
+                }
+            });
+            // 超时处理
+            const timer = setTimeout(() => {
+                if (childProcess.pid) {
+                    this.killProcessTree(childProcess.pid);
+                }
+            }, timeout * 1000);
+            // AbortSignal 监听
+            const onAbort = () => {
+                if (childProcess.pid) {
+                    this.killProcessTree(childProcess.pid);
+                }
+            };
+            signal?.addEventListener('abort', onAbort, { once: true });
+            childProcess.on('close', (code) => {
+                clearTimeout(timer);
+                signal?.removeEventListener('abort', onAbort);
+                const parts = [];
+                if (stdout)
+                    parts.push(stdout);
+                if (stderr)
+                    parts.push(stderr);
+                if (truncated) {
+                    parts.push(`[Output truncated: exceeded ${LIMIT_KB}KB limit]`);
+                }
+                const output = parts.join('\n');
+                if (code === 0) {
+                    const elapsed = Date.now() - startTime;
+                    if (output) {
+                        resolve(output + `\n[Exit code: 0, ${elapsed}ms]`);
+                    }
+                    else {
+                        resolve(`Command completed successfully [Exit code: 0, ${elapsed}ms]`);
+                    }
+                }
+                else {
+                    const elapsed = Date.now() - startTime;
+                    const timedOut = code === null;
+                    if (timedOut) {
+                        parts.push(`[Process timed out after ${timeout} seconds, ${elapsed}ms]`);
+                    }
+                    else {
+                        parts.push(`[Exit code: ${code}, ${elapsed}ms]`);
+                    }
+                    const errOutput = parts.join('\n');
+                    if (errOutput) {
+                        reject(new Error(errOutput));
+                    }
+                    else {
+                        reject(new Error(`Command failed with exit code ${code}`));
+                    }
+                }
+            });
+            childProcess.on('error', (err) => {
+                clearTimeout(timer);
+                reject(new Error(`Command failed: ${err.message}`));
+            });
+            // 关闭 stdin
+            childProcess.stdin.end();
+        });
+    }
+}
+//# sourceMappingURL=bash.js.map

package/dist/tools/bundle-registry.d.ts

@@ -0,0 +1,42 @@
+export interface ToolBundle {
+    name: string;
+    description: string;
+    builtin?: boolean;
+    tools: string[];
+}
+export interface ToolBundlesConfig {
+    /** 当前激活的工具包名列表。空数组 = 全量模式（不限制）。["all"] 等价于空数组。 */
+    activeBundles: string[];
+    bundles: Record<string, ToolBundle>;
+}
+export declare class ToolBundleRegistry {
+    private configPath;
+    private config;
+    constructor(cwd: string);
+    /** 当前是否全量模式（无工具限制） */
+    isAllMode(): boolean;
+    /** 返回当前激活的所有 bundle */
+    getActive(): ToolBundle[];
+    /** 返回当前激活的工具名并集（已去重）。空数组 = 全量。始终包含 common 包。 */
+    getActiveToolNames(): string[];
+    /** 获取指定 bundle */
+    get(name: string): ToolBundle | undefined;
+    /** 列出所有 bundle */
+    list(): ToolBundle[];
+    /** 设置激活的 bundle 列表。空数组或 ["all"] = 全量模式。 */
+    activate(names: string[]): void;
+    /** 取消所有 bundle 限制，回到全量 */
+    deactivate(): void;
+    /** 创建新 bundle */
+    create(name: string, description: string, tools: string[]): ToolBundle;
+    /** 删除 bundle（builtin 不可删，common 不可删） */
+    delete(name: string): void;
+    /** 向 bundle 追加工具 */
+    addTools(bundleName: string, toolNames: string[]): void;
+    /** 从 bundle 移除工具 */
+    removeTools(bundleName: string, toolNames: string[]): void;
+    reload(): void;
+    private load;
+    private save;
+}
+//# sourceMappingURL=bundle-registry.d.ts.map

package/dist/tools/bundle-registry.js

@@ -0,0 +1,239 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createLogger } from '../logging/logger.js';
+const logger = createLogger('tool-bundle');
+// ── Default ────────────────────────────────────────────────────────
+const BUILTIN_ALL = {
+    name: 'all',
+    description: '全量工具包 — 包含所有已注册工具（默认激活，可切换）',
+    builtin: true,
+    tools: [], // 空 = 无过滤
+};
+const BUILTIN_COMMON = {
+    name: 'common',
+    description: '通用工具包 — 始终加载，不可关闭',
+    builtin: true,
+    tools: [
+        'read', 'write', 'edit', 'insert', 'bash', 'glob', 'grep',
+        'list_bundles', 'activate_bundle', 'deactivate_bundle',
+        'create_bundle', 'add_to_bundle', 'remove_from_bundle', 'delete_bundle',
+        'system_info', 'channel_info',
+        'interrupt', 'restart',
+        'add_task', 'list_tasks', 'remove_task', 'toggle_task',
+        'mcp_status', 'session_stats',
+        'diff_files', 'json_edit', 'http_request', 'archive',
+        'companion_mode', 'reset_companion_session', 'trigger_compression',
+        'disk_usage', 'view_image',
+        'process_list', 'process_kill', 'process_output',
+        'rollback_status', 'rollback',
+        'flow_start', 'flow_add', 'flow_complete',
+        'ask_user',
+    ],
+};
+const BUILTIN_CODING = {
+    name: 'coding',
+    description: '编程工具包 — 版本控制、交叉引用、代码技能（通用工具已自动包含）',
+    builtin: true,
+    tools: ['git', 'multi-edit', 'use_skill',
+        'xref_build', 'xref_query', 'xref_graph'],
+};
+const BUILTIN_AGENT = {
+    name: 'agent',
+    description: '子 Agent 编排 — 创建和管理子 Agent 执行复杂任务',
+    builtin: true,
+    tools: ['spawn_sub_agent', 'create_sub_agent', 'update_sub_agent', 'destroy_sub_agent', 'delegate_to_agent', 'use_skill'],
+};
+const BUILTIN_ADMIN = {
+    name: 'admin',
+    description: '系统管理 — Provider 切换、配置管理、权限控制',
+    builtin: true,
+    tools: [
+        'list_providers', 'provider_info', 'switch_provider', 'switch_to_auto_route',
+        'get_config', 'update_config', 'config_schema', 'reset_config',
+        'session_stats', 'list_tools', 'toggle_tool',
+        'list_skills', 'toggle_skill', 'list_sub_agents', 'toggle_sub_agent',
+        'allow_tool', 'disallow_tool', 'list_allowlist',
+        'list_model_channels', 'add_model_channel', 'remove_model_channel',
+        'set_channel_role', 'set_channel_model', 'reset_channel_model',
+    ],
+};
+const BUILTIN_OFFICE = {
+    name: 'office',
+    description: '办公文档 — 读取 Word/Excel 文件（按需激活）',
+    builtin: true,
+    tools: ['docx_read', 'xlsx_read'],
+};
+const BUILTIN_DATABASE = {
+    name: 'database',
+    description: '数据库 — SQLite 参数化查询（按需激活）',
+    builtin: true,
+    tools: ['db_query'],
+};
+const DEFAULT_CONFIG = {
+    activeBundles: [],
+    bundles: { all: BUILTIN_ALL, common: BUILTIN_COMMON, coding: BUILTIN_CODING, agent: BUILTIN_AGENT, admin: BUILTIN_ADMIN, office: BUILTIN_OFFICE, database: BUILTIN_DATABASE },
+};
+// ── Registry ───────────────────────────────────────────────────────
+export class ToolBundleRegistry {
+    configPath;
+    config;
+    constructor(cwd) {
+        this.configPath = path.join(os.homedir(), '.agent', 'tool-bundles.json');
+        this.config = this.load();
+    }
+    // ── Query ────────────────────────────────────────────────────────
+    /** 当前是否全量模式（无工具限制） */
+    isAllMode() {
+        const names = this.config.activeBundles;
+        return names.length === 0 || names.includes('all');
+    }
+    /** 返回当前激活的所有 bundle */
+    getActive() {
+        if (this.isAllMode())
+            return [];
+        return this.config.activeBundles
+            .map(n => this.config.bundles[n])
+            .filter(Boolean);
+    }
+    /** 返回当前激活的工具名并集（已去重）。空数组 = 全量。始终包含 common 包。 */
+    getActiveToolNames() {
+        const actives = this.getActive();
+        if (actives.length === 0)
+            return []; // 全量模式
+        const set = new Set();
+        // common 包始终加载
+        const common = this.config.bundles['common'];
+        if (common) {
+            for (const t of common.tools)
+                set.add(t);
+        }
+        for (const b of actives) {
+            for (const t of b.tools)
+                set.add(t);
+        }
+        return [...set];
+    }
+    /** 获取指定 bundle */
+    get(name) {
+        return this.config.bundles[name];
+    }
+    /** 列出所有 bundle */
+    list() {
+        return Object.values(this.config.bundles);
+    }
+    // ── Mutate ───────────────────────────────────────────────────────
+    /** 设置激活的 bundle 列表。空数组或 ["all"] = 全量模式。 */
+    activate(names) {
+        for (const n of names) {
+            if (!this.config.bundles[n]) {
+                throw new Error(`Bundle "${n}" not found. Use list_bundles to see available bundles.`);
+            }
+        }
+        // "all" 参与则等价于全量
+        this.config.activeBundles = names.includes('all') ? [] : names;
+        this.save();
+    }
+    /** 取消所有 bundle 限制，回到全量 */
+    deactivate() {
+        this.config.activeBundles = [];
+        this.save();
+    }
+    /** 创建新 bundle */
+    create(name, description, tools) {
+        if (this.config.bundles[name]) {
+            throw new Error(`Bundle "${name}" already exists.`);
+        }
+        const bundle = { name, description, tools };
+        this.config.bundles[name] = bundle;
+        this.save();
+        logger.info(`Bundle created: ${name} (${tools.length} tools)`);
+        return bundle;
+    }
+    /** 删除 bundle（builtin 不可删，common 不可删） */
+    delete(name) {
+        const bundle = this.config.bundles[name];
+        if (!bundle)
+            throw new Error(`Bundle "${name}" not found.`);
+        if (bundle.builtin)
+            throw new Error(`Cannot delete builtin bundle "${name}".`);
+        if (name === 'common')
+            throw new Error(`Cannot delete the common bundle — it is always required.`);
+        delete this.config.bundles[name];
+        this.config.activeBundles = this.config.activeBundles.filter(n => n !== name);
+        this.save();
+        logger.info(`Bundle deleted: ${name}`);
+    }
+    /** 向 bundle 追加工具 */
+    addTools(bundleName, toolNames) {
+        const bundle = this.config.bundles[bundleName];
+        if (!bundle)
+            throw new Error(`Bundle "${bundleName}" not found.`);
+        const added = [];
+        for (const t of toolNames) {
+            if (!bundle.tools.includes(t)) {
+                bundle.tools.push(t);
+                added.push(t);
+            }
+        }
+        if (added.length > 0) {
+            this.save();
+            logger.info(`Tools added to bundle ${bundleName}: ${added.join(', ')}`);
+        }
+    }
+    /** 从 bundle 移除工具 */
+    removeTools(bundleName, toolNames) {
+        const bundle = this.config.bundles[bundleName];
+        if (!bundle)
+            throw new Error(`Bundle "${bundleName}" not found.`);
+        bundle.tools = bundle.tools.filter(t => !toolNames.includes(t));
+        this.save();
+        logger.info(`Tools removed from bundle ${bundleName}: ${toolNames.join(', ')}`);
+    }
+    // ── Persist ──────────────────────────────────────────────────────
+    reload() {
+        this.config = this.load();
+        logger.info('Bundle config reloaded');
+    }
+    load() {
+        try {
+            const raw = fs.readFileSync(this.configPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            // Ensure builtin bundles always exist with latest tool lists
+            const builtins = [BUILTIN_ALL, BUILTIN_COMMON, BUILTIN_CODING, BUILTIN_AGENT, BUILTIN_ADMIN, BUILTIN_OFFICE, BUILTIN_DATABASE];
+            for (const b of builtins) {
+                if (!parsed.bundles)
+                    parsed.bundles = { [b.name]: b };
+                else if (!parsed.bundles[b.name]) {
+                    parsed.bundles[b.name] = b;
+                }
+                else {
+                    // Existing builtin: merge tool list (ensure builtin tools are always present,
+                    // preserving any user-added tools)
+                    const existing = parsed.bundles[b.name];
+                    existing.tools = [...new Set([...b.tools, ...existing.tools])];
+                }
+            }
+            return parsed;
+        }
+        catch {
+            const dir = path.dirname(this.configPath);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(this.configPath, JSON.stringify(DEFAULT_CONFIG, null, 2), 'utf-8');
+            return { ...DEFAULT_CONFIG, bundles: { all: { ...BUILTIN_ALL } } };
+        }
+    }
+    save() {
+        try {
+            const dir = path.dirname(this.configPath);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2), 'utf-8');
+        }
+        catch (err) {
+            logger.warn(`Failed to save bundle config: ${err.message}`);
+        }
+    }
+}
+//# sourceMappingURL=bundle-registry.js.map

package/dist/tools/bundle-tools.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 工具包管理工具 — list / activate / deactivate / create / add / remove / delete
+ *
+ * 从 factory.ts 中提取，统一注册到 ToolRegistry。
+ */
+import type { Tool } from './interface.js';
+import type { ToolBundleRegistry } from './bundle-registry.js';
+export declare function registerBundleTools(toolRegistry: {
+    register(tool: Tool): void;
+}, bundleRegistry: ToolBundleRegistry): void;
+//# sourceMappingURL=bundle-tools.d.ts.map