axon-code 2.4.0

package/dist/plugins/index.js

@@ -0,0 +1,1978 @@
+/**
+ * 插件系统
+ * 支持加载和管理第三方插件
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { EventEmitter } from 'events';
+import { VERSION } from '../version.js';
+/**
+ * Void hooks：通知型，并行执行，不能修改 context（参考 OpenClaw void/blocking 双模式）
+ * Blocking hooks：拦截型，串行执行，可以修改 context
+ */
+const VOID_HOOKS = new Set([
+    'onError', 'onSessionStart', 'onSessionEnd', 'onPluginLoad', 'onPluginUnload',
+]);
+// ============ 版本检查工具 ============
+/**
+ * 简化的 semver 版本比较
+ */
+class VersionChecker {
+    /**
+     * 检查版本是否满足范围要求
+     * 支持: ^1.0.0, ~1.0.0, >=1.0.0, 1.0.0, *
+     */
+    static satisfies(version, range) {
+        if (range === '*' || range === 'latest')
+            return true;
+        const v = this.parseVersion(version);
+        if (!v)
+            return false;
+        // 精确匹配
+        if (!range.match(/[~^><=]/)) {
+            return version === range;
+        }
+        // ^1.0.0 - 兼容主版本
+        if (range.startsWith('^')) {
+            const r = this.parseVersion(range.slice(1));
+            if (!r)
+                return false;
+            return v.major === r.major && this.compareVersion(v, r) >= 0;
+        }
+        // ~1.0.0 - 兼容次版本
+        if (range.startsWith('~')) {
+            const r = this.parseVersion(range.slice(1));
+            if (!r)
+                return false;
+            return v.major === r.major && v.minor === r.minor && v.patch >= r.patch;
+        }
+        // >=1.0.0
+        if (range.startsWith('>=')) {
+            const r = this.parseVersion(range.slice(2));
+            if (!r)
+                return false;
+            return this.compareVersion(v, r) >= 0;
+        }
+        // >1.0.0
+        if (range.startsWith('>')) {
+            const r = this.parseVersion(range.slice(1));
+            if (!r)
+                return false;
+            return this.compareVersion(v, r) > 0;
+        }
+        // <=1.0.0
+        if (range.startsWith('<=')) {
+            const r = this.parseVersion(range.slice(2));
+            if (!r)
+                return false;
+            return this.compareVersion(v, r) <= 0;
+        }
+        // <1.0.0
+        if (range.startsWith('<')) {
+            const r = this.parseVersion(range.slice(1));
+            if (!r)
+                return false;
+            return this.compareVersion(v, r) < 0;
+        }
+        return false;
+    }
+    static parseVersion(version) {
+        const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+        if (!match)
+            return null;
+        return {
+            major: parseInt(match[1], 10),
+            minor: parseInt(match[2], 10),
+            patch: parseInt(match[3], 10),
+        };
+    }
+    static compareVersion(v1, v2) {
+        if (v1.major !== v2.major)
+            return v1.major - v2.major;
+        if (v1.minor !== v2.minor)
+            return v1.minor - v2.minor;
+        return v1.patch - v2.patch;
+    }
+}
+// ============ 插件管理器 ============
+/**
+ * 插件管理器
+ * 负责插件的发现、加载、卸载、依赖管理、版本检查、配置管理等
+ */
+export class PluginManager extends EventEmitter {
+    plugins = new Map();
+    pluginStates = new Map();
+    pluginContexts = new Map();
+    pluginConfigs = new Map();
+    pluginDirs = [];
+    configDir;
+    pluginConfigFile;
+    fileWatchers = new Map();
+    claudeCodeVersion = VERSION;
+    // 注册的工具、命令、技能和钩子
+    registeredTools = new Map();
+    registeredCommands = new Map();
+    registeredSkills = new Map();
+    registeredHooks = new Map();
+    constructor(claudeCodeVersion) {
+        super();
+        if (claudeCodeVersion) {
+            this.claudeCodeVersion = claudeCodeVersion;
+        }
+        this.configDir = process.env.AXON_CONFIG_DIR ||
+            path.join(os.homedir(), '.axon');
+        this.pluginConfigFile = path.join(this.configDir, 'plugins.json');
+        // 默认插件目录
+        this.pluginDirs = [
+            path.join(this.configDir, 'plugins'),
+            path.join(process.cwd(), '.axon', 'plugins'),
+        ];
+        // 确保目录存在
+        this.ensureDirectories();
+        // 加载插件配置
+        this.loadPluginConfigs();
+    }
+    /**
+     * 确保必要的目录存在
+     */
+    ensureDirectories() {
+        if (!fs.existsSync(this.configDir)) {
+            fs.mkdirSync(this.configDir, { recursive: true });
+        }
+        for (const dir of this.pluginDirs) {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        }
+    }
+    /**
+     * 加载插件配置文件
+     */
+    loadPluginConfigs() {
+        try {
+            if (fs.existsSync(this.pluginConfigFile)) {
+                const configs = JSON.parse(fs.readFileSync(this.pluginConfigFile, 'utf-8'));
+                for (const [name, config] of Object.entries(configs)) {
+                    this.pluginConfigs.set(name, config);
+                }
+            }
+        }
+        catch (err) {
+            console.warn('Failed to load plugin configs:', err);
+        }
+    }
+    /**
+     * 保存插件配置文件
+     */
+    savePluginConfigs() {
+        try {
+            const configs = {};
+            for (const [name, config] of Array.from(this.pluginConfigs.entries())) {
+                configs[name] = config;
+            }
+            fs.writeFileSync(this.pluginConfigFile, JSON.stringify(configs, null, 2));
+        }
+        catch (err) {
+            console.error('Failed to save plugin configs:', err);
+        }
+    }
+    /**
+     * 添加插件搜索目录
+     */
+    addPluginDir(dir) {
+        if (!this.pluginDirs.includes(dir)) {
+            this.pluginDirs.push(dir);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        }
+    }
+    /**
+     * 发现所有插件
+     */
+    async discover() {
+        const discovered = [];
+        for (const dir of this.pluginDirs) {
+            if (!fs.existsSync(dir))
+                continue;
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const pluginPath = path.join(dir, entry.name);
+                const packagePath = path.join(pluginPath, 'package.json');
+                if (!fs.existsSync(packagePath))
+                    continue;
+                try {
+                    const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+                    const metadata = {
+                        name: packageJson.name || entry.name,
+                        version: packageJson.version || '0.0.0',
+                        description: packageJson.description,
+                        author: packageJson.author,
+                        homepage: packageJson.homepage,
+                        license: packageJson.license,
+                        main: packageJson.main || 'index.js',
+                        engines: packageJson.engines,
+                        dependencies: packageJson.claudePluginDependencies || packageJson.dependencies,
+                        peerDependencies: packageJson.peerDependencies,
+                    };
+                    // 从配置中读取启用状态
+                    const config = this.pluginConfigs.get(metadata.name);
+                    const state = {
+                        metadata,
+                        path: pluginPath,
+                        enabled: config?.enabled !== false,
+                        loaded: false,
+                        initialized: false,
+                        activated: false,
+                        dependencies: [],
+                        dependents: [],
+                    };
+                    this.pluginStates.set(metadata.name, state);
+                    discovered.push(state);
+                }
+                catch (err) {
+                    console.warn(`Failed to read plugin at ${pluginPath}:`, err);
+                }
+            }
+        }
+        // 解析依赖关系
+        this.resolveDependencies();
+        return discovered;
+    }
+    /**
+     * 解析插件依赖关系
+     */
+    resolveDependencies() {
+        for (const state of Array.from(this.pluginStates.values())) {
+            state.dependencies = [];
+            state.dependents = [];
+            if (state.metadata.dependencies) {
+                for (const depName of Object.keys(state.metadata.dependencies)) {
+                    // 只处理插件依赖
+                    if (this.pluginStates.has(depName)) {
+                        state.dependencies.push(depName);
+                    }
+                }
+            }
+        }
+        // 构建反向依赖
+        for (const state of Array.from(this.pluginStates.values())) {
+            for (const depName of state.dependencies) {
+                const depState = this.pluginStates.get(depName);
+                if (depState && !depState.dependents.includes(state.metadata.name)) {
+                    depState.dependents.push(state.metadata.name);
+                }
+            }
+        }
+    }
+    /**
+     * 检查插件引擎兼容性
+     */
+    checkEngineCompatibility(metadata) {
+        if (!metadata.engines)
+            return true;
+        // 检查 Node.js 版本
+        if (metadata.engines.node) {
+            const nodeVersion = process.version.slice(1); // 去掉 'v'
+            if (!VersionChecker.satisfies(nodeVersion, metadata.engines.node)) {
+                return false;
+            }
+        }
+        // 检查 Axon 版本
+        if (metadata.engines['claude-code']) {
+            if (!VersionChecker.satisfies(this.claudeCodeVersion, metadata.engines['claude-code'])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * 检查插件依赖
+     */
+    checkDependencies(name) {
+        const state = this.pluginStates.get(name);
+        if (!state || !state.metadata.dependencies) {
+            return { satisfied: true, missing: [] };
+        }
+        const missing = [];
+        for (const [depName, versionRange] of Object.entries(state.metadata.dependencies)) {
+            const depState = this.pluginStates.get(depName);
+            if (!depState) {
+                missing.push(`${depName}@${versionRange} (not found)`);
+                continue;
+            }
+            if (!depState.loaded) {
+                missing.push(`${depName}@${versionRange} (not loaded)`);
+                continue;
+            }
+            if (!VersionChecker.satisfies(depState.metadata.version, versionRange)) {
+                missing.push(`${depName}@${versionRange} (found ${depState.metadata.version})`);
+            }
+        }
+        return { satisfied: missing.length === 0, missing };
+    }
+    /**
+     * 创建插件上下文（沙箱）
+     */
+    createPluginContext(name, pluginPath) {
+        const events = new EventEmitter();
+        // 配置 API
+        const configAPI = {
+            get: (key, defaultValue) => {
+                const config = this.pluginConfigs.get(name);
+                return config?.[key] ?? defaultValue;
+            },
+            set: async (key, value) => {
+                let config = this.pluginConfigs.get(name);
+                if (!config) {
+                    config = {};
+                    this.pluginConfigs.set(name, config);
+                }
+                config[key] = value;
+                this.savePluginConfigs();
+            },
+            getAll: () => {
+                return { ...this.pluginConfigs.get(name) };
+            },
+            has: (key) => {
+                return this.pluginConfigs.get(name)?.[key] !== undefined;
+            },
+            delete: async (key) => {
+                const config = this.pluginConfigs.get(name);
+                if (config) {
+                    delete config[key];
+                    this.savePluginConfigs();
+                }
+            },
+        };
+        // 日志 API
+        const logger = {
+            debug: (message, ...args) => {
+                console.debug(`[Plugin:${name}]`, message, ...args);
+            },
+            info: (message, ...args) => {
+                console.info(`[Plugin:${name}]`, message, ...args);
+            },
+            warn: (message, ...args) => {
+                console.warn(`[Plugin:${name}]`, message, ...args);
+            },
+            error: (message, ...args) => {
+                console.error(`[Plugin:${name}]`, message, ...args);
+            },
+        };
+        // 文件系统 API（限制在插件目录内）
+        const fsAPI = {
+            readFile: async (relativePath) => {
+                const fullPath = path.join(pluginPath, relativePath);
+                if (!fullPath.startsWith(pluginPath)) {
+                    throw new Error('Access denied: path outside plugin directory');
+                }
+                return fs.promises.readFile(fullPath, 'utf-8');
+            },
+            writeFile: async (relativePath, content) => {
+                const fullPath = path.join(pluginPath, relativePath);
+                if (!fullPath.startsWith(pluginPath)) {
+                    throw new Error('Access denied: path outside plugin directory');
+                }
+                await fs.promises.writeFile(fullPath, content, 'utf-8');
+            },
+            exists: async (relativePath) => {
+                const fullPath = path.join(pluginPath, relativePath);
+                if (!fullPath.startsWith(pluginPath)) {
+                    throw new Error('Access denied: path outside plugin directory');
+                }
+                return fs.existsSync(fullPath);
+            },
+            readdir: async (relativePath = '') => {
+                const fullPath = path.join(pluginPath, relativePath);
+                if (!fullPath.startsWith(pluginPath)) {
+                    throw new Error('Access denied: path outside plugin directory');
+                }
+                return fs.promises.readdir(fullPath);
+            },
+        };
+        // 工具 API
+        const toolsAPI = {
+            register: (tool) => {
+                let tools = this.registeredTools.get(name);
+                if (!tools) {
+                    tools = [];
+                    this.registeredTools.set(name, tools);
+                }
+                tools.push(tool);
+                this.emit('tool:registered', name, tool);
+            },
+            unregister: (toolName) => {
+                const tools = this.registeredTools.get(name);
+                if (tools) {
+                    const index = tools.findIndex(t => t.name === toolName);
+                    if (index !== -1) {
+                        tools.splice(index, 1);
+                        this.emit('tool:unregistered', name, toolName);
+                    }
+                }
+            },
+            getRegistered: () => {
+                return [...(this.registeredTools.get(name) || [])];
+            },
+        };
+        // 命令 API
+        const commandsAPI = {
+            register: (command) => {
+                let commands = this.registeredCommands.get(name);
+                if (!commands) {
+                    commands = [];
+                    this.registeredCommands.set(name, commands);
+                }
+                commands.push(command);
+                this.emit('command:registered', name, command);
+            },
+            unregister: (commandName) => {
+                const commands = this.registeredCommands.get(name);
+                if (commands) {
+                    const index = commands.findIndex(c => c.name === commandName);
+                    if (index !== -1) {
+                        commands.splice(index, 1);
+                        this.emit('command:unregistered', name, commandName);
+                    }
+                }
+            },
+            getRegistered: () => {
+                return [...(this.registeredCommands.get(name) || [])];
+            },
+        };
+        // Skills API
+        const skillsAPI = {
+            register: (skill) => {
+                let skills = this.registeredSkills.get(name);
+                if (!skills) {
+                    skills = [];
+                    this.registeredSkills.set(name, skills);
+                }
+                skills.push(skill);
+                this.emit('skill:registered', name, skill);
+            },
+            unregister: (skillName) => {
+                const skills = this.registeredSkills.get(name);
+                if (skills) {
+                    const index = skills.findIndex(s => s.name === skillName);
+                    if (index !== -1) {
+                        skills.splice(index, 1);
+                        this.emit('skill:unregistered', name, skillName);
+                    }
+                }
+            },
+            getRegistered: () => {
+                return [...(this.registeredSkills.get(name) || [])];
+            },
+        };
+        // 钩子 API
+        const hooksAPI = {
+            on: (hookType, handler) => {
+                let hooks = this.registeredHooks.get(name);
+                if (!hooks) {
+                    hooks = [];
+                    this.registeredHooks.set(name, hooks);
+                }
+                hooks.push({ type: hookType, handler });
+                this.emit('hook:registered', name, hookType);
+            },
+            off: (hookType, handler) => {
+                const hooks = this.registeredHooks.get(name);
+                if (hooks) {
+                    const index = hooks.findIndex(h => h.type === hookType && h.handler === handler);
+                    if (index !== -1) {
+                        hooks.splice(index, 1);
+                        this.emit('hook:unregistered', name, hookType);
+                    }
+                }
+            },
+            getRegistered: () => {
+                return [...(this.registeredHooks.get(name) || [])];
+            },
+        };
+        const context = {
+            pluginName: name,
+            pluginPath,
+            config: configAPI,
+            logger,
+            fs: fsAPI,
+            tools: toolsAPI,
+            commands: commandsAPI,
+            skills: skillsAPI,
+            hooks: hooksAPI,
+            events,
+        };
+        this.pluginContexts.set(name, context);
+        return context;
+    }
+    /**
+     * 加载插件（完整生命周期）
+     */
+    async load(name, options = {}) {
+        const state = this.pluginStates.get(name);
+        if (!state) {
+            throw new Error(`Plugin not found: ${name}`);
+        }
+        if (state.loaded && !options.force) {
+            return true;
+        }
+        try {
+            // 1. 检查引擎兼容性
+            if (!this.checkEngineCompatibility(state.metadata)) {
+                throw new Error(`Plugin ${name} is not compatible with current environment. ` +
+                    `Requires: ${JSON.stringify(state.metadata.engines)}`);
+            }
+            // 2. 检查并加载依赖
+            if (!options.skipDeps) {
+                for (const depName of state.dependencies) {
+                    const depState = this.pluginStates.get(depName);
+                    if (!depState) {
+                        throw new Error(`Dependency not found: ${depName}`);
+                    }
+                    if (!depState.loaded) {
+                        const loaded = await this.load(depName, options);
+                        if (!loaded) {
+                            throw new Error(`Failed to load dependency: ${depName}`);
+                        }
+                    }
+                }
+                // 验证依赖版本
+                const depCheck = this.checkDependencies(name);
+                if (!depCheck.satisfied) {
+                    throw new Error(`Dependency requirements not satisfied: ${depCheck.missing.join(', ')}`);
+                }
+            }
+            // 3. 查找主文件
+            const mainFile = path.join(state.path, state.metadata.main || 'index.js');
+            if (!fs.existsSync(mainFile)) {
+                throw new Error(`Plugin main file not found: ${mainFile}`);
+            }
+            // 4. 创建插件上下文（沙箱）
+            const context = this.createPluginContext(name, state.path);
+            // 5. 动态导入插件
+            const pluginModule = await import(`file://${mainFile}?t=${Date.now()}`);
+            const plugin = pluginModule.default || pluginModule;
+            // 6. 验证插件
+            if (!plugin.metadata) {
+                plugin.metadata = state.metadata;
+            }
+            // 7. 初始化插件（新增）
+            if (plugin.init) {
+                await plugin.init(context);
+                state.initialized = true;
+            }
+            // 8. 激活插件
+            if (plugin.activate) {
+                await plugin.activate(context);
+                state.activated = true;
+            }
+            // 9. 注册插件提供的工具、命令、技能、钩子
+            if (plugin.tools) {
+                for (const tool of plugin.tools) {
+                    context.tools.register(tool);
+                }
+            }
+            if (plugin.commands) {
+                for (const command of plugin.commands) {
+                    context.commands.register(command);
+                }
+            }
+            if (plugin.skills) {
+                for (const skill of plugin.skills) {
+                    context.skills.register(skill);
+                }
+            }
+            if (plugin.hooks) {
+                for (const hook of plugin.hooks) {
+                    context.hooks.on(hook.type, hook.handler);
+                }
+            }
+            // 10. 保存插件实例
+            this.plugins.set(name, plugin);
+            state.loaded = true;
+            state.loadTime = Date.now();
+            state.error = undefined;
+            this.emit('plugin:loaded', name, plugin);
+            await this.executeHook('onPluginLoad', { pluginName: name, plugin });
+            return true;
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            state.error = errorMsg;
+            state.loaded = false;
+            state.initialized = false;
+            state.activated = false;
+            this.emit('plugin:error', name, err);
+            console.error(`Failed to load plugin ${name}:`, errorMsg);
+            return false;
+        }
+    }
+    /**
+     * 卸载插件
+     */
+    async unload(name, options = {}) {
+        const plugin = this.plugins.get(name);
+        const state = this.pluginStates.get(name);
+        if (!plugin || !state) {
+            return false;
+        }
+        try {
+            // 1. 检查是否有其他插件依赖此插件
+            if (!options.force && state.dependents.length > 0) {
+                const loadedDependents = state.dependents.filter(depName => this.pluginStates.get(depName)?.loaded);
+                if (loadedDependents.length > 0) {
+                    throw new Error(`Cannot unload plugin ${name}: it is required by ${loadedDependents.join(', ')}`);
+                }
+            }
+            // 2. 停止文件监听（如果启用了热重载）
+            const watcher = this.fileWatchers.get(name);
+            if (watcher) {
+                watcher.close();
+                this.fileWatchers.delete(name);
+            }
+            // 3. 执行卸载钩子
+            await this.executeHook('onPluginUnload', { pluginName: name, plugin });
+            // 4. 调用插件的 deactivate
+            if (plugin.deactivate) {
+                await plugin.deactivate();
+            }
+            // 5. 清理注册的工具、命令、技能、钩子
+            this.registeredTools.delete(name);
+            this.registeredCommands.delete(name);
+            this.registeredSkills.delete(name);
+            this.registeredHooks.delete(name);
+            // 6. 清理插件上下文
+            this.pluginContexts.delete(name);
+            // 7. 删除插件实例
+            this.plugins.delete(name);
+            // 8. 更新状态
+            state.loaded = false;
+            state.initialized = false;
+            state.activated = false;
+            this.emit('plugin:unloaded', name);
+            return true;
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            state.error = errorMsg;
+            console.error(`Failed to unload plugin ${name}:`, errorMsg);
+            return false;
+        }
+    }
+    /**
+     * 重载插件（热重载）
+     */
+    async reload(name) {
+        const state = this.pluginStates.get(name);
+        if (!state) {
+            return false;
+        }
+        const wasLoaded = state.loaded;
+        if (wasLoaded) {
+            await this.unload(name);
+        }
+        const result = await this.load(name, { force: true });
+        if (result) {
+            state.lastReloadTime = Date.now();
+            this.emit('plugin:reloaded', name);
+        }
+        return result;
+    }
+    /**
+     * 启用插件热重载
+     */
+    enableHotReload(name) {
+        const state = this.pluginStates.get(name);
+        if (!state || this.fileWatchers.has(name)) {
+            return;
+        }
+        try {
+            const watcher = fs.watch(state.path, { recursive: true }, async (eventType, filename) => {
+                if (!filename)
+                    return;
+                // 忽略 node_modules 和隐藏文件
+                if (filename.includes('node_modules') || filename.startsWith('.')) {
+                    return;
+                }
+                // 只监听 JS/TS 文件
+                if (!/\.(js|ts|mjs|cjs)$/.test(filename)) {
+                    return;
+                }
+                console.info(`[Plugin:${name}] File changed: ${filename}, reloading...`);
+                // 防抖：延迟重载以避免多次快速触发
+                const timeoutKey = `${name}_reload`;
+                const existingTimeout = this[timeoutKey];
+                if (existingTimeout) {
+                    clearTimeout(existingTimeout);
+                }
+                this[timeoutKey] = setTimeout(async () => {
+                    await this.reload(name);
+                }, 500);
+            });
+            this.fileWatchers.set(name, watcher);
+            console.info(`[Plugin:${name}] Hot reload enabled`);
+        }
+        catch (err) {
+            console.error(`Failed to enable hot reload for plugin ${name}:`, err);
+        }
+    }
+    /**
+     * 禁用插件热重载
+     */
+    disableHotReload(name) {
+        const watcher = this.fileWatchers.get(name);
+        if (watcher) {
+            watcher.close();
+            this.fileWatchers.delete(name);
+            console.info(`[Plugin:${name}] Hot reload disabled`);
+        }
+    }
+    /**
+     * 加载所有已发现的插件（拓扑排序）
+     */
+    async loadAll(options = {}) {
+        await this.discover();
+        // 拓扑排序：按依赖顺序加载
+        const loaded = new Set();
+        const loading = new Set();
+        const loadWithDeps = async (name) => {
+            const state = this.pluginStates.get(name);
+            if (!state || !state.enabled || loaded.has(name)) {
+                return;
+            }
+            if (loading.has(name)) {
+                throw new Error(`Circular dependency detected: ${name}`);
+            }
+            loading.add(name);
+            // 先加载依赖
+            for (const depName of state.dependencies) {
+                await loadWithDeps(depName);
+            }
+            // 再加载自己
+            await this.load(name);
+            loaded.add(name);
+            loading.delete(name);
+            // 启用热重载
+            if (options.enableHotReload) {
+                this.enableHotReload(name);
+            }
+        };
+        for (const name of Array.from(this.pluginStates.keys())) {
+            await loadWithDeps(name);
+        }
+    }
+    /**
+     * 卸载所有插件（反向拓扑排序）
+     */
+    async unloadAll() {
+        // 按依赖的反向顺序卸载
+        const unloaded = new Set();
+        const unloadWithDependents = async (name) => {
+            if (unloaded.has(name)) {
+                return;
+            }
+            const state = this.pluginStates.get(name);
+            if (!state) {
+                return;
+            }
+            // 先卸载依赖此插件的其他插件
+            for (const depName of state.dependents) {
+                await unloadWithDependents(depName);
+            }
+            // 再卸载自己
+            await this.unload(name, { force: true });
+            unloaded.add(name);
+        };
+        for (const name of Array.from(this.plugins.keys())) {
+            await unloadWithDependents(name);
+        }
+    }
+    /**
+     * 获取所有注册的工具
+     */
+    getTools() {
+        const tools = [];
+        for (const toolList of Array.from(this.registeredTools.values())) {
+            tools.push(...toolList);
+        }
+        return tools;
+    }
+    /**
+     * 获取所有注册的命令
+     */
+    getCommands() {
+        const commands = [];
+        for (const commandList of Array.from(this.registeredCommands.values())) {
+            commands.push(...commandList);
+        }
+        return commands;
+    }
+    /**
+     * 获取所有注册的技能
+     */
+    getSkills() {
+        const skills = [];
+        for (const skillList of Array.from(this.registeredSkills.values())) {
+            skills.push(...skillList);
+        }
+        return skills;
+    }
+    /**
+     * 获取指定插件的工具
+     */
+    getPluginTools(name) {
+        return this.registeredTools.get(name) || [];
+    }
+    /**
+     * 获取指定插件的命令
+     */
+    getPluginCommands(name) {
+        return this.registeredCommands.get(name) || [];
+    }
+    /**
+     * 获取指定插件的技能
+     */
+    getPluginSkills(name) {
+        return this.registeredSkills.get(name) || [];
+    }
+    /**
+     * 获取指定插件的钩子
+     */
+    getPluginHooks(name) {
+        return this.registeredHooks.get(name) || [];
+    }
+    /**
+     * 执行钩子（按优先级排序）
+     */
+    async executeHook(hookType, context) {
+        // 收集所有相关钩子
+        const hooks = [];
+        for (const [pluginName, hookList] of Array.from(this.registeredHooks.entries())) {
+            for (const hook of hookList) {
+                if (hook.type === hookType) {
+                    hooks.push({ plugin: pluginName, hook });
+                }
+            }
+        }
+        if (hooks.length === 0)
+            return context;
+        // 按优先级排序（数字越小优先级越高）
+        hooks.sort((a, b) => (a.hook.priority || 100) - (b.hook.priority || 100));
+        // Void hooks（on* 系列）：并行执行，不修改 context
+        if (VOID_HOOKS.has(hookType)) {
+            await Promise.allSettled(hooks.map(async ({ plugin, hook }) => {
+                try {
+                    await hook.handler(context);
+                }
+                catch (err) {
+                    this.emit('hook:error', hookType, plugin, err);
+                    console.error(`Error in void hook ${hookType} from plugin ${plugin}:`, err);
+                }
+            }));
+            return context;
+        }
+        // Blocking hooks（before*/after* 系列）：串行执行，可修改 context
+        let result = context;
+        for (const { plugin, hook } of hooks) {
+            try {
+                const hookResult = await hook.handler(result);
+                if (hookResult !== undefined) {
+                    result = hookResult;
+                }
+            }
+            catch (err) {
+                this.emit('hook:error', hookType, plugin, err);
+                console.error(`Error in hook ${hookType} from plugin ${plugin}:`, err);
+            }
+        }
+        return result;
+    }
+    /**
+     * 获取已加载的插件
+     */
+    getLoadedPlugins() {
+        return Array.from(this.plugins.values());
+    }
+    /**
+     * 获取插件状态列表
+     */
+    getPluginStates() {
+        return Array.from(this.pluginStates.values());
+    }
+    /**
+     * 获取插件
+     */
+    getPlugin(name) {
+        return this.plugins.get(name);
+    }
+    /**
+     * 获取插件状态
+     */
+    getPluginState(name) {
+        return this.pluginStates.get(name);
+    }
+    /**
+     * 获取插件上下文
+     */
+    getPluginContext(name) {
+        return this.pluginContexts.get(name);
+    }
+    /**
+     * 安装插件（从路径复制）
+     */
+    async install(sourcePath, options = {}) {
+        const packagePath = path.join(sourcePath, 'package.json');
+        if (!fs.existsSync(packagePath)) {
+            throw new Error('Invalid plugin: package.json not found');
+        }
+        const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+        const name = packageJson.name;
+        if (!name) {
+            throw new Error('Invalid plugin: name not specified in package.json');
+        }
+        // 检查是否已安装
+        const existingState = this.pluginStates.get(name);
+        if (existingState) {
+            // 卸载旧版本
+            await this.unload(name);
+        }
+        // 目标路径
+        const targetDir = path.join(this.pluginDirs[0], name);
+        // 复制插件文件
+        if (fs.existsSync(targetDir)) {
+            fs.rmSync(targetDir, { recursive: true });
+        }
+        fs.cpSync(sourcePath, targetDir, { recursive: true });
+        // 重新发现
+        await this.discover();
+        const state = this.pluginStates.get(name);
+        if (!state) {
+            throw new Error(`Failed to discover installed plugin: ${name}`);
+        }
+        // 自动加载
+        if (options.autoLoad !== false) {
+            await this.load(name);
+            if (options.enableHotReload) {
+                this.enableHotReload(name);
+            }
+        }
+        this.emit('plugin:installed', name, state);
+        return state;
+    }
+    /**
+     * 卸载插件（从磁盘删除）
+     */
+    async uninstall(name) {
+        const state = this.pluginStates.get(name);
+        if (!state) {
+            return false;
+        }
+        // 检查依赖
+        if (state.dependents.length > 0) {
+            throw new Error(`Cannot uninstall plugin ${name}: it is required by ${state.dependents.join(', ')}`);
+        }
+        // 先卸载
+        if (state.loaded) {
+            await this.unload(name, { force: true });
+        }
+        // 清理该插件注册的 MCP servers（plugin:{name}:* 前缀）
+        this.cleanupPluginMcpServers(name);
+        // 删除文件
+        if (fs.existsSync(state.path)) {
+            fs.rmSync(state.path, { recursive: true });
+        }
+        // 删除配置
+        this.pluginConfigs.delete(name);
+        this.savePluginConfigs();
+        this.pluginStates.delete(name);
+        this.emit('plugin:uninstalled', name);
+        return true;
+    }
+    /**
+     * 清理插件注册的 MCP servers（plugin:{name}:* 前缀）
+     */
+    cleanupPluginMcpServers(pluginName) {
+        const prefix = `plugin:${pluginName}:`;
+        const settingsPath = path.join(os.homedir(), '.axon', 'settings.json');
+        try {
+            if (!fs.existsSync(settingsPath))
+                return;
+            const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+            if (!settings.mcpServers)
+                return;
+            let removed = 0;
+            for (const key of Object.keys(settings.mcpServers)) {
+                if (key.startsWith(prefix)) {
+                    delete settings.mcpServers[key];
+                    removed++;
+                }
+            }
+            if (removed > 0) {
+                fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+                console.log(`[PluginManager] Cleaned up ${removed} MCP server(s) for plugin ${pluginName}`);
+            }
+        }
+        catch (err) {
+            console.warn(`[PluginManager] Failed to cleanup MCP servers for ${pluginName}:`, err);
+        }
+    }
+    /**
+     * 启用/禁用插件
+     */
+    async setEnabled(name, enabled) {
+        const state = this.pluginStates.get(name);
+        if (!state) {
+            return false;
+        }
+        state.enabled = enabled;
+        // 更新配置
+        let config = this.pluginConfigs.get(name);
+        if (!config) {
+            config = {};
+            this.pluginConfigs.set(name, config);
+        }
+        config.enabled = enabled;
+        this.savePluginConfigs();
+        // 如果禁用，卸载插件
+        if (!enabled && state.loaded) {
+            await this.unload(name);
+        }
+        // 如果启用，加载插件
+        if (enabled && !state.loaded) {
+            await this.load(name);
+        }
+        this.emit('plugin:enabled-changed', name, enabled);
+        return true;
+    }
+    /**
+     * 注册内联插件（无需文件系统）
+     * @param definition 内联插件定义
+     */
+    async registerInlinePlugin(definition) {
+        const name = definition.name;
+        // 检查是否已存在
+        if (this.plugins.has(name)) {
+            throw new Error(`Plugin ${name} already registered`);
+        }
+        try {
+            let plugin;
+            if (definition.plugin) {
+                // 直接使用提供的插件对象
+                plugin = definition.plugin;
+            }
+            else if (definition.code) {
+                // 从代码字符串创建插件
+                // 使用 Function 构造器执行代码（注意：这有安全风险，仅用于受信任的代码）
+                const moduleFactory = new Function('return ' + definition.code);
+                const module = moduleFactory();
+                plugin = module.default || module;
+            }
+            else {
+                throw new Error('Either plugin or code must be provided');
+            }
+            // 确保有元数据
+            if (!plugin.metadata) {
+                plugin.metadata = {
+                    name,
+                    version: definition.version || '1.0.0',
+                    description: definition.description,
+                };
+            }
+            // 创建虚拟状态
+            const state = {
+                metadata: plugin.metadata,
+                path: '<inline>', // 标记为内联插件
+                enabled: true,
+                loaded: false,
+                initialized: false,
+                activated: false,
+                dependencies: [],
+                dependents: [],
+            };
+            this.pluginStates.set(name, state);
+            // 创建上下文（使用内存路径）
+            const context = this.createPluginContext(name, '<inline>');
+            // 初始化插件
+            if (plugin.init) {
+                await plugin.init(context);
+                state.initialized = true;
+            }
+            // 激活插件
+            if (plugin.activate) {
+                await plugin.activate(context);
+                state.activated = true;
+            }
+            // 注册功能
+            if (plugin.tools) {
+                for (const tool of plugin.tools) {
+                    context.tools.register(tool);
+                }
+            }
+            if (plugin.commands) {
+                for (const command of plugin.commands) {
+                    context.commands.register(command);
+                }
+            }
+            if (plugin.skills) {
+                for (const skill of plugin.skills) {
+                    context.skills.register(skill);
+                }
+            }
+            if (plugin.hooks) {
+                for (const hook of plugin.hooks) {
+                    context.hooks.on(hook.type, hook.handler);
+                }
+            }
+            // 保存插件实例
+            this.plugins.set(name, plugin);
+            state.loaded = true;
+            state.loadTime = Date.now();
+            this.emit('plugin:inline-registered', name, plugin);
+            return true;
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to register inline plugin ${name}:`, errorMsg);
+            return false;
+        }
+    }
+    /**
+     * 注销内联插件
+     */
+    async unregisterInlinePlugin(name) {
+        const state = this.pluginStates.get(name);
+        if (!state || state.path !== '<inline>') {
+            return false;
+        }
+        return await this.unload(name, { force: true });
+    }
+    /**
+     * 获取所有内联插件
+     */
+    getInlinePlugins() {
+        return Array.from(this.pluginStates.values()).filter(s => s.path === '<inline>');
+    }
+    /**
+     * 清理所有资源
+     */
+    async cleanup() {
+        // 停止所有文件监听
+        for (const watcher of Array.from(this.fileWatchers.values())) {
+            watcher.close();
+        }
+        this.fileWatchers.clear();
+        // 卸载所有插件
+        await this.unloadAll();
+    }
+}
+// ============ 插件执行器 ============
+/**
+ * 插件工具执行器
+ * 用于执行插件提供的工具
+ */
+export class PluginToolExecutor {
+    manager;
+    toolExecutors = new Map();
+    constructor(manager) {
+        this.manager = manager;
+        // 监听工具注册事件
+        this.manager.on('tool:registered', (pluginName, tool) => {
+            this.registerToolExecutor(pluginName, tool);
+        });
+        this.manager.on('tool:unregistered', (pluginName, toolName) => {
+            this.toolExecutors.delete(toolName);
+        });
+    }
+    /**
+     * 注册工具执行器
+     */
+    registerToolExecutor(pluginName, tool) {
+        // 获取插件实例
+        const plugin = this.manager.getPlugin(pluginName);
+        if (!plugin)
+            return;
+        // 查找工具的执行方法
+        const pluginWithExecutor = plugin;
+        // 创建执行器
+        const executor = async (input) => {
+            try {
+                // 尝试调用插件的 executeTool 方法
+                if (pluginWithExecutor.executeTool) {
+                    return await pluginWithExecutor.executeTool(tool.name, input);
+                }
+                // 尝试查找同名方法
+                const methodName = `execute_${tool.name}`;
+                const method = pluginWithExecutor[methodName];
+                if (typeof method === 'function') {
+                    return await method.call(plugin, input);
+                }
+                return {
+                    success: false,
+                    error: `Plugin ${pluginName} does not provide an executor for tool ${tool.name}`,
+                };
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                return {
+                    success: false,
+                    error: `Error executing tool ${tool.name}: ${errorMsg}`,
+                };
+            }
+        };
+        this.toolExecutors.set(tool.name, executor);
+    }
+    /**
+     * 执行工具
+     */
+    async execute(toolName, input) {
+        const executor = this.toolExecutors.get(toolName);
+        if (!executor) {
+            return {
+                success: false,
+                error: `Tool not found: ${toolName}`,
+            };
+        }
+        try {
+            return await executor(input);
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                error: `Error executing tool ${toolName}: ${errorMsg}`,
+            };
+        }
+    }
+    /**
+     * 获取所有可用的工具
+     */
+    getAvailableTools() {
+        return Array.from(this.toolExecutors.keys());
+    }
+    /**
+     * 检查工具是否存在
+     */
+    hasTool(toolName) {
+        return this.toolExecutors.has(toolName);
+    }
+}
+/**
+ * 插件命令执行器
+ */
+export class PluginCommandExecutor {
+    manager;
+    constructor(manager) {
+        this.manager = manager;
+    }
+    /**
+     * 执行命令
+     */
+    async execute(commandName, args) {
+        const commands = this.manager.getCommands();
+        const command = commands.find(c => c.name === commandName);
+        if (!command) {
+            throw new Error(`Command not found: ${commandName}`);
+        }
+        // 查找提供此命令的插件
+        let pluginName;
+        for (const [name, cmds] of this.manager.registeredCommands) {
+            if (cmds.some((c) => c.name === commandName)) {
+                pluginName = name;
+                break;
+            }
+        }
+        if (!pluginName) {
+            throw new Error(`Plugin for command ${commandName} not found`);
+        }
+        const context = this.manager.getPluginContext(pluginName);
+        if (!context) {
+            throw new Error(`Context for plugin ${pluginName} not found`);
+        }
+        await command.execute(args, context);
+    }
+    /**
+     * 获取所有可用的命令
+     */
+    getAvailableCommands() {
+        return this.manager.getCommands();
+    }
+    /**
+     * 获取命令帮助信息
+     */
+    getCommandHelp(commandName) {
+        const command = this.manager.getCommands().find(c => c.name === commandName);
+        if (!command) {
+            return `Command not found: ${commandName}`;
+        }
+        let help = `Command: ${command.name}\n`;
+        help += `Description: ${command.description}\n`;
+        if (command.usage) {
+            help += `Usage: ${command.usage}\n`;
+        }
+        if (command.examples && command.examples.length > 0) {
+            help += '\nExamples:\n';
+            for (const example of command.examples) {
+                help += `  ${example}\n`;
+            }
+        }
+        return help;
+    }
+}
+/**
+ * 插件技能执行器
+ * 用于执行插件提供的 Skills/Prompts
+ */
+export class PluginSkillExecutor {
+    manager;
+    constructor(manager) {
+        this.manager = manager;
+    }
+    /**
+     * 获取技能
+     */
+    getSkill(skillName) {
+        const skills = this.manager.getSkills();
+        return skills.find(s => s.name === skillName);
+    }
+    /**
+     * 执行技能（返回提示词）
+     * @param skillName 技能名称
+     * @param params 参数对象
+     * @returns 处理后的提示词
+     */
+    execute(skillName, params = {}) {
+        const skill = this.getSkill(skillName);
+        if (!skill) {
+            throw new Error(`Skill not found: ${skillName}`);
+        }
+        // 验证必需参数
+        if (skill.parameters) {
+            for (const param of skill.parameters) {
+                if (param.required && !(param.name in params)) {
+                    throw new Error(`Missing required parameter: ${param.name}`);
+                }
+            }
+        }
+        // 替换提示词中的参数占位符
+        let prompt = skill.prompt;
+        for (const [key, value] of Object.entries(params)) {
+            const placeholder = new RegExp(`\\{${key}\\}`, 'g');
+            prompt = prompt.replace(placeholder, String(value));
+        }
+        return prompt;
+    }
+    /**
+     * 获取所有可用的技能
+     */
+    getAvailableSkills() {
+        return this.manager.getSkills();
+    }
+    /**
+     * 按分类获取技能
+     */
+    getSkillsByCategory(category) {
+        return this.manager.getSkills().filter(s => s.category === category);
+    }
+    /**
+     * 获取技能帮助信息
+     */
+    getSkillHelp(skillName) {
+        const skill = this.getSkill(skillName);
+        if (!skill) {
+            return `Skill not found: ${skillName}`;
+        }
+        let help = `Skill: /${skill.name}\n`;
+        help += `Description: ${skill.description}\n`;
+        if (skill.category) {
+            help += `Category: ${skill.category}\n`;
+        }
+        if (skill.parameters && skill.parameters.length > 0) {
+            help += '\nParameters:\n';
+            for (const param of skill.parameters) {
+                const required = param.required ? ' (required)' : ' (optional)';
+                const type = param.type ? ` [${param.type}]` : '';
+                help += `  ${param.name}${type}${required}: ${param.description}\n`;
+            }
+        }
+        if (skill.examples && skill.examples.length > 0) {
+            help += '\nExamples:\n';
+            for (const example of skill.examples) {
+                help += `  ${example}\n`;
+            }
+        }
+        return help;
+    }
+    /**
+     * 列出所有技能（格式化输出）
+     */
+    listSkills() {
+        const skills = this.getAvailableSkills();
+        if (skills.length === 0) {
+            return 'No skills available.';
+        }
+        // 按分类分组
+        const categories = new Map();
+        for (const skill of skills) {
+            const category = skill.category || 'General';
+            if (!categories.has(category)) {
+                categories.set(category, []);
+            }
+            categories.get(category).push(skill);
+        }
+        let output = 'Available Plugin Skills:\n\n';
+        for (const [category, categorySkills] of Array.from(categories.entries())) {
+            output += `${category}:\n`;
+            for (const skill of categorySkills) {
+                output += `  /${skill.name}: ${skill.description}\n`;
+            }
+            output += '\n';
+        }
+        return output;
+    }
+}
+/**
+ * 插件推荐器
+ * 基于上下文智能推荐插件
+ */
+export class PluginRecommender {
+    manager;
+    // 插件推荐规则
+    recommendationRules = [
+        // 前端开发插件推荐
+        {
+            pluginPattern: /frontend|html|css|design/i,
+            triggers: {
+                fileExtensions: ['.html', '.htm', '.css', '.scss', '.sass', '.less'],
+                keywords: ['html', 'css', 'frontend', 'design', 'styling'],
+            },
+            reason: 'Working with HTML/CSS files',
+        },
+        // React 开发插件推荐
+        {
+            pluginPattern: /react/i,
+            triggers: {
+                fileExtensions: ['.jsx', '.tsx'],
+                keywords: ['react', 'component', 'hook'],
+            },
+            reason: 'Working with React components',
+        },
+        // Vue 开发插件推荐
+        {
+            pluginPattern: /vue/i,
+            triggers: {
+                fileExtensions: ['.vue'],
+                keywords: ['vue', 'composition'],
+            },
+            reason: 'Working with Vue.js',
+        },
+        // Python 数据科学插件推荐
+        {
+            pluginPattern: /data|science|analysis|ml/i,
+            triggers: {
+                fileExtensions: ['.ipynb', '.py'],
+                keywords: ['pandas', 'numpy', 'scikit', 'tensorflow', 'pytorch', 'jupyter'],
+            },
+            reason: 'Working with data science/ML',
+        },
+        // API 测试插件推荐
+        {
+            pluginPattern: /api|test|http/i,
+            triggers: {
+                keywords: ['api', 'http', 'rest', 'graphql', 'postman'],
+                taskTypes: ['testing', 'debugging'],
+            },
+            reason: 'Testing APIs',
+        },
+        // 文档生成插件推荐
+        {
+            pluginPattern: /doc|markdown|readme/i,
+            triggers: {
+                fileExtensions: ['.md', '.mdx', '.rst'],
+                keywords: ['documentation', 'readme', 'doc'],
+                taskTypes: ['documentation'],
+            },
+            reason: 'Writing documentation',
+        },
+    ];
+    constructor(manager) {
+        this.manager = manager;
+    }
+    /**
+     * 添加自定义推荐规则
+     */
+    addRule(rule) {
+        this.recommendationRules.push(rule);
+    }
+    /**
+     * 基于上下文推荐插件
+     */
+    async recommend(context) {
+        const recommendations = [];
+        const allPlugins = this.manager.getPluginStates();
+        const installedPluginNames = new Set(allPlugins.filter(p => p.loaded).map(p => p.metadata.name));
+        // 提取文件扩展名
+        const fileExtensions = [];
+        if (context.currentFiles) {
+            for (const file of context.currentFiles) {
+                const ext = file.substring(file.lastIndexOf('.'));
+                if (ext)
+                    fileExtensions.push(ext.toLowerCase());
+            }
+        }
+        // 提取关键词
+        const keywords = [];
+        if (context.userQuery) {
+            keywords.push(...context.userQuery.toLowerCase().split(/\s+/));
+        }
+        if (context.recentCommands) {
+            for (const cmd of context.recentCommands) {
+                keywords.push(...cmd.toLowerCase().split(/\s+/));
+            }
+        }
+        // 检查每个规则
+        for (const rule of this.recommendationRules) {
+            let relevance = 0;
+            const matchedContext = {};
+            // 检查文件扩展名匹配
+            if (rule.triggers.fileExtensions && fileExtensions.length > 0) {
+                const matched = fileExtensions.filter(ext => rule.triggers.fileExtensions.includes(ext));
+                if (matched.length > 0) {
+                    relevance += 0.4;
+                    matchedContext.fileTypes = matched;
+                }
+            }
+            // 检查关键词匹配
+            if (rule.triggers.keywords && keywords.length > 0) {
+                const matched = keywords.filter(kw => rule.triggers.keywords.some(trigger => kw.includes(trigger)));
+                if (matched.length > 0) {
+                    relevance += 0.3;
+                    matchedContext.keywords = matched;
+                }
+            }
+            // 检查任务类型匹配
+            if (rule.triggers.taskTypes && context.taskType) {
+                if (rule.triggers.taskTypes.includes(context.taskType)) {
+                    relevance += 0.3;
+                    matchedContext.taskType = context.taskType;
+                }
+            }
+            // 如果有匹配，查找符合规则的未安装插件
+            if (relevance > 0) {
+                for (const plugin of allPlugins) {
+                    const pluginName = plugin.metadata.name;
+                    // 跳过已安装的插件
+                    if (installedPluginNames.has(pluginName)) {
+                        continue;
+                    }
+                    // 检查插件名称是否符合规则
+                    if (rule.pluginPattern.test(pluginName) ||
+                        rule.pluginPattern.test(plugin.metadata.description || '')) {
+                        recommendations.push({
+                            pluginName,
+                            reason: rule.reason,
+                            relevance,
+                            context: matchedContext,
+                        });
+                    }
+                }
+            }
+        }
+        // 按相关度排序并去重
+        const uniqueRecommendations = new Map();
+        for (const rec of recommendations) {
+            const existing = uniqueRecommendations.get(rec.pluginName);
+            if (!existing || rec.relevance > existing.relevance) {
+                uniqueRecommendations.set(rec.pluginName, rec);
+            }
+        }
+        return Array.from(uniqueRecommendations.values())
+            .sort((a, b) => b.relevance - a.relevance)
+            .slice(0, 5); // 最多返回5个推荐
+    }
+    /**
+     * 格式化推荐输出
+     */
+    formatRecommendations(recommendations) {
+        if (recommendations.length === 0) {
+            return '';
+        }
+        let output = '\n**Recommended Plugins:**\n\n';
+        for (const rec of recommendations) {
+            output += `- **${rec.pluginName}** (relevance: ${(rec.relevance * 100).toFixed(0)}%)\n`;
+            output += `  ${rec.reason}\n`;
+            if (rec.context) {
+                const details = [];
+                if (rec.context.fileTypes) {
+                    details.push(`files: ${rec.context.fileTypes.join(', ')}`);
+                }
+                if (rec.context.keywords) {
+                    details.push(`keywords: ${rec.context.keywords.join(', ')}`);
+                }
+                if (rec.context.taskType) {
+                    details.push(`task: ${rec.context.taskType}`);
+                }
+                if (details.length > 0) {
+                    output += `  (${details.join('; ')})\n`;
+                }
+            }
+            output += `  Install: \`claude plugin install ${rec.pluginName}\`\n\n`;
+        }
+        return output;
+    }
+}
+// ============ 默认实例 ============
+/**
+ * 默认插件管理器实例
+ */
+export const pluginManager = new PluginManager();
+/**
+ * 默认工具执行器实例
+ */
+export const pluginToolExecutor = new PluginToolExecutor(pluginManager);
+/**
+ * 默认命令执行器实例
+ */
+export const pluginCommandExecutor = new PluginCommandExecutor(pluginManager);
+/**
+ * 默认技能执行器实例
+ */
+export const pluginSkillExecutor = new PluginSkillExecutor(pluginManager);
+/**
+ * 默认插件推荐器实例
+ */
+export const pluginRecommender = new PluginRecommender(pluginManager);
+// ============ 便捷导出 ============
+/**
+ * 创建新的插件管理器实例
+ */
+export function createPluginManager(claudeCodeVersion) {
+    return new PluginManager(claudeCodeVersion);
+}
+export const pluginHelper = {
+    validateMetadata(metadata) {
+        const errors = [];
+        if (!metadata.name || typeof metadata.name !== 'string') {
+            errors.push('Invalid or missing name');
+        }
+        if (!metadata.version || typeof metadata.version !== 'string') {
+            errors.push('Invalid or missing version');
+        }
+        if (metadata.engines) {
+            if (metadata.engines.node && typeof metadata.engines.node !== 'string') {
+                errors.push('Invalid engines.node');
+            }
+            if (metadata.engines['claude-code'] && typeof metadata.engines['claude-code'] !== 'string') {
+                errors.push('Invalid engines.claude-code');
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    },
+    createTemplate(name, options = {}) {
+        const author = options.author || 'Your Name';
+        const description = options.description || 'An Axon plugin';
+        const version = options.version || '1.0.0';
+        return `
+// ${name} - Axon Plugin
+
+export default {
+  metadata: {
+    name: '${name}',
+    version: '${version}',
+    description: '${description}',
+    author: '${author}',
+    engines: {
+      'claude-code': '^2.0.0',
+      'node': '>=18.0.0'
+    }
+  },
+
+  async init(context) {
+    context.logger.info('Initializing ${name} plugin');
+    // Plugin initialization code
+  },
+
+  async activate(context) {
+    context.logger.info('Activating ${name} plugin');
+
+    // Register tools
+    // context.tools.register({
+    //   name: 'my-tool',
+    //   description: 'My custom tool',
+    //   inputSchema: {
+    //     type: 'object',
+    //     properties: {},
+    //     required: []
+    //   }
+    // });
+
+    // Register commands
+    // context.commands.register({
+    //   name: 'my-command',
+    //   description: 'My custom command',
+    //   async execute(args, ctx) {
+    //     ctx.logger.info('Executing command');
+    //   }
+    // });
+
+    // Register hooks
+    // context.hooks.on('beforeMessage', async (msg) => {
+    //   // Process message
+    //   return msg;
+    // });
+  },
+
+  async deactivate() {
+    console.log('Deactivating ${name} plugin');
+  },
+
+  // Optional: Execute tool
+  async executeTool(toolName, input) {
+    // Handle tool execution
+    return { success: true, output: 'Tool executed' };
+  }
+};
+`.trim();
+    },
+};
+// ============ 插件自动更新 (v2.1.2+) ============
+import { shouldSkipPluginAutoUpdate, isForcePluginAutoUpdateEnabled, isAutoUpdaterDisabled, getAutoUpdaterDisabledReason, } from '../utils/env-check.js';
+/**
+ * 插件自动更新器
+ * 实现 FORCE_AUTOUPDATE_PLUGINS 环境变量功能 (v2.1.2)
+ *
+ * 官网 changelog:
+ * "Added FORCE_AUTOUPDATE_PLUGINS environment variable to allow plugin autoupdate
+ *  even when the main auto-updater is disabled"
+ */
+export class PluginAutoUpdater {
+    manager;
+    updateCheckInterval = null;
+    lastUpdateCheck = null;
+    pendingUpdates = new Map();
+    constructor(manager) {
+        this.manager = manager;
+    }
+    /**
+     * 检查是否应该跳过插件自动更新
+     * 官网源码实现:
+     * function BOA(){return Ku()&&!i1(process.env.FORCE_AUTOUPDATE_PLUGINS)}
+     */
+    shouldSkipAutoUpdate() {
+        return shouldSkipPluginAutoUpdate();
+    }
+    /**
+     * 检查是否强制启用插件自动更新
+     */
+    isForceUpdateEnabled() {
+        return isForcePluginAutoUpdateEnabled();
+    }
+    /**
+     * 启动自动更新检查
+     * @param intervalMs 检查间隔（毫秒），默认 1 小时
+     */
+    startAutoUpdate(intervalMs = 60 * 60 * 1000) {
+        // 检查是否应该跳过自动更新
+        if (this.shouldSkipAutoUpdate()) {
+            console.log('[Plugins] Auto-update: skipped (auto-updater disabled)');
+            return;
+        }
+        // 如果是因为 FORCE_AUTOUPDATE_PLUGINS 启用而允许更新，记录日志
+        if (isAutoUpdaterDisabled() && this.isForceUpdateEnabled()) {
+            console.log('[Plugins] Force auto-update enabled via FORCE_AUTOUPDATE_PLUGINS environment variable');
+        }
+        // 立即执行一次检查
+        this.checkForUpdates().catch(err => {
+            console.error('[Plugins] Auto-update check failed:', err);
+        });
+        // 设置定期检查
+        this.updateCheckInterval = setInterval(() => {
+            this.checkForUpdates().catch(err => {
+                console.error('[Plugins] Auto-update check failed:', err);
+            });
+        }, intervalMs);
+    }
+    /**
+     * 停止自动更新检查
+     */
+    stopAutoUpdate() {
+        if (this.updateCheckInterval) {
+            clearInterval(this.updateCheckInterval);
+            this.updateCheckInterval = null;
+        }
+    }
+    /**
+     * 检查所有已安装插件的更新
+     */
+    async checkForUpdates() {
+        // 再次检查是否应该跳过
+        if (this.shouldSkipAutoUpdate()) {
+            console.log('[Plugins] Plugin autoupdate: skipped (auto-updater disabled)');
+            return new Map();
+        }
+        this.lastUpdateCheck = new Date();
+        const updates = new Map();
+        const installedPlugins = this.manager.getPluginStates();
+        if (installedPlugins.length === 0) {
+            return updates;
+        }
+        console.log(`[Plugins] Checking updates for ${installedPlugins.length} plugins...`);
+        for (const state of installedPlugins) {
+            if (!state.loaded)
+                continue;
+            try {
+                const updateInfo = await this.checkPluginUpdate(state);
+                if (updateInfo.hasUpdate) {
+                    updates.set(state.metadata.name, updateInfo);
+                    this.pendingUpdates.set(state.metadata.name, updateInfo);
+                    console.log(`[Plugins] Update available: ${state.metadata.name} ${updateInfo.currentVersion} -> ${updateInfo.latestVersion}`);
+                }
+            }
+            catch (err) {
+                console.warn(`[Plugins] Failed to check update for ${state.metadata.name}:`, err);
+            }
+        }
+        this.manager.emit('plugins:updates-checked', updates);
+        return updates;
+    }
+    /**
+     * 检查单个插件的更新
+     */
+    async checkPluginUpdate(state) {
+        const name = state.metadata.name;
+        const currentVersion = state.metadata.version;
+        // 这里应该从远程仓库获取最新版本信息
+        // 由于是本地实现，这里模拟返回当前版本（无更新）
+        // 实际实现需要根据插件来源（marketplace、git、npm 等）获取最新版本
+        return {
+            name,
+            currentVersion,
+            latestVersion: currentVersion, // 模拟：当前已是最新版本
+            hasUpdate: false,
+        };
+    }
+    /**
+     * 更新指定插件
+     */
+    async updatePlugin(name) {
+        if (this.shouldSkipAutoUpdate()) {
+            console.log(`[Plugins] Cannot update ${name}: auto-updater disabled`);
+            return false;
+        }
+        const state = this.manager.getPluginState(name);
+        if (!state) {
+            console.error(`[Plugins] Plugin not found: ${name}`);
+            return false;
+        }
+        const updateInfo = this.pendingUpdates.get(name);
+        if (!updateInfo || !updateInfo.hasUpdate) {
+            console.log(`[Plugins] No update available for ${name}`);
+            return false;
+        }
+        try {
+            console.log(`[Plugins] Updating ${name} from ${updateInfo.currentVersion} to ${updateInfo.latestVersion}...`);
+            // 这里应该执行实际的更新逻辑
+            // 1. 下载新版本
+            // 2. 卸载旧版本
+            // 3. 安装新版本
+            // 4. 重新加载插件
+            // 模拟更新成功
+            this.pendingUpdates.delete(name);
+            this.manager.emit('plugin:updated', name, updateInfo);
+            console.log(`[Plugins] Successfully updated ${name} to ${updateInfo.latestVersion}`);
+            return true;
+        }
+        catch (err) {
+            console.error(`[Plugins] Failed to update ${name}:`, err);
+            return false;
+        }
+    }
+    /**
+     * 更新所有有更新的插件
+     */
+    async updateAll() {
+        const success = [];
+        const failed = [];
+        const names = Array.from(this.pendingUpdates.keys());
+        for (const name of names) {
+            const result = await this.updatePlugin(name);
+            if (result) {
+                success.push(name);
+            }
+            else {
+                failed.push(name);
+            }
+        }
+        return { success, failed };
+    }
+    /**
+     * 获取待更新的插件列表
+     */
+    getPendingUpdates() {
+        return Array.from(this.pendingUpdates.values());
+    }
+    /**
+     * 获取上次更新检查时间
+     */
+    getLastUpdateCheck() {
+        return this.lastUpdateCheck;
+    }
+    /**
+     * 获取自动更新状态信息
+     */
+    getStatus() {
+        const disabled = isAutoUpdaterDisabled();
+        const forceEnabled = this.isForceUpdateEnabled();
+        const skipUpdate = this.shouldSkipAutoUpdate();
+        return {
+            enabled: !skipUpdate,
+            reason: disabled ? getAutoUpdaterDisabledReason() || undefined : undefined,
+            forceEnabled,
+            lastCheck: this.lastUpdateCheck,
+            pendingUpdates: this.pendingUpdates.size,
+        };
+    }
+}
+/**
+ * 默认插件自动更新器实例
+ */
+export const pluginAutoUpdater = new PluginAutoUpdater(pluginManager);
+/**
+ * 启动插件自动更新（在应用启动时调用）
+ * 官网源码实现参考:
+ * function TA9(){(async()=>{
+ *   if(BOA()){k("Plugin autoupdate: skipped (auto-updater disabled)");return}
+ *   try{let A=await qt5();if(A.size===0)...
+ * })()}
+ */
+export async function startPluginAutoUpdate() {
+    // 检查是否应该跳过
+    if (shouldSkipPluginAutoUpdate()) {
+        console.log('[Plugins] Plugin autoupdate: skipped (auto-updater disabled)');
+        return;
+    }
+    // 如果是强制启用，记录日志
+    if (isAutoUpdaterDisabled() && isForcePluginAutoUpdateEnabled()) {
+        console.log('[Plugins] Force auto-update enabled via FORCE_AUTOUPDATE_PLUGINS environment variable');
+    }
+    try {
+        const updates = await pluginAutoUpdater.checkForUpdates();
+        if (updates.size === 0) {
+            console.log('[Plugins] All plugins are up to date');
+        }
+        else {
+            console.log(`[Plugins] ${updates.size} plugin update(s) available`);
+        }
+    }
+    catch (err) {
+        console.error('[Plugins] Failed to check for plugin updates:', err);
+    }
+}
+// 导出环境变量检查函数以便外部使用
+export { shouldSkipPluginAutoUpdate, isForcePluginAutoUpdateEnabled, isAutoUpdaterDisabled, getAutoUpdaterDisabledReason, };
+// 导出插件市场管理器
+export { MarketplaceManager } from './marketplace.js';
+//# sourceMappingURL=index.js.map