sloth-d2c-mcp 1.0.4-beta87 → 1.0.4-beta90

package/cli/run.js

@@ -113,6 +113,21 @@ if (args[0] === 'config') {
   
   console.log(`[sloth] 已在后台启动，PID: ${child.pid}`);
   process.exit(0);
+} else if (args[0] === 'add') {
+  // 设置环境变量标识这是 add 命令（安装插件）
+  process.env.SLOTH_COMMAND = 'add';
+  // 传递插件名称参数
+  process.env.SLOTH_ADD_ARGS = JSON.stringify(args.slice(1));
+} else if (args[0] === 'remove') {
+  // 设置环境变量标识这是 remove 命令（卸载插件）
+  process.env.SLOTH_COMMAND = 'remove';
+  // 传递插件名称参数
+  process.env.SLOTH_REMOVE_ARGS = JSON.stringify(args.slice(1));
+} else if (args[0] === 'plugins') {
+  // 设置环境变量标识这是 plugins 命令（列出插件）
+  process.env.SLOTH_COMMAND = 'plugins';
+  // 传递子命令参数
+  process.env.SLOTH_PLUGINS_ARGS = JSON.stringify(args.slice(1));
 } else if (args[0] === 'stop') {
   // stop 命令：停止监听 3100/3101 端口的 sloth 进程
   const { execSync } = await import('node:child_process');

package/dist/build/index.js

@@ -14,6 +14,8 @@ import { Logger } from './utils/logger.js';
 import { getAvailablePort, saveImageFile, replaceImageSrc, formatListRoots } from './utils/utils.js';
 import { processSampling, buildNestingStructure } from './core/sampling.js';
 import { buildComponentMappingPrompt, buildFullUpdatePromptForAI, buildPlaceholderPrompt } from './core/prompt-builder.js';
+import { pluginManager } from './plugin/manager.js';
+import { installPlugin, uninstallPlugin, listPlugins } from './plugin/loader.js';
 import { detectClientApiSupport, clearCapabilitiesCache } from './utils/client-capabilities.js';
 // @ts-ignore
 import * as flatted from 'flatted';
@@ -103,6 +105,9 @@ mcpServer.tool('d2c_figma', 'Convert Figma Design File to Code', {
             Logger.log('标准化根目录:', root);
             // 设置 fileManager 的工作目录根路径
             fileManager.setWorkspaceRoot(root);
+            // 设置插件管理器的工作区根目录并初始化
+            pluginManager.setWorkspaceRoot(root);
+            await pluginManager.initialize();
         }
         catch (error) {
             Logger.log('获取根目录时出错:', error);
@@ -194,6 +199,8 @@ mcpServer.tool('d2c_figma', 'Convert Figma Design File to Code', {
         console.log('d2cNodeList', d2cNodeList);
         console.log('imageMap', imageMap);
         console.log('absoluteHtml', absoluteHtml);
+        pluginManager.executeHook('onFetchImage', { imageMap });
+        console.log('pluginManager executeHook onFetchImage', imageMap);
         // 如果配置了figmaApiKey，则可以预览，传入absoluteHtml
         if (!hasLaunchWebview) {
             // await fileManager.saveFile(fileKey, nodeId, 'absolute.html', absoluteHtml)
@@ -288,7 +295,7 @@ mcpServer.tool('d2c_figma', 'Convert Figma Design File to Code', {
         const aggregationPrompt = savedPromptSetting?.aggregationOptimizePrompt || aggregationOptimizeCodePrompt;
         const finalPrompt = savedPromptSetting?.finalOptimizePrompt || finalOptimizeCodePrompt;
         const noSamplingPrompt = savedPromptSetting?.noSamplingAggregationPrompt || noSamplingAggregationPrompt;
-        const codeSnippets = [];
+        let codeSnippets = [];
         let isSupportSampling = clientApiSupport.sampling;
         Logger.log(`客户端 API 支持检测: sampling=${isSupportSampling}, roots=${clientApiSupport.roots}`);
         // 收集已映射的组件信息，用于在最终写入时添加提示词
@@ -431,6 +438,14 @@ mcpServer.tool('d2c_figma', 'Convert Figma Design File to Code', {
                 codeSnippets.unshift(placeholderPrompt + '\n' + replacedCode);
             }
         }
+        const onSamplingComplete = await pluginManager.executeHook('onSamplingComplete', {
+            codeSnippets,
+            imageMap
+        });
+        codeSnippets = onSamplingComplete?.codeSnippets || codeSnippets;
+        imageMap = onSamplingComplete?.imageMap || imageMap;
+        console.log('executeHook onSamplingComplete', imageMap);
+        console.log('executeHook onSamplingComplete', codeSnippets);
         // 保存图片文件
         saveImageFile({ imageMap, root });
         Logger.log('处理完成，生成的代码片段数量:', codeSnippets.length);
@@ -651,6 +666,9 @@ async function main() {
         console.log('  config      显示配置文件信息');
         console.log('  page        显示 interceptor-web 页面地址');
         console.log('  framework   添加或管理框架配置');
+        console.log('  add         安装 sloth 插件');
+        console.log('  remove      卸载 sloth 插件');
+        console.log('  plugins     列出已安装的插件');
         console.log('  clear       清理缓存文件');
         console.log('  version     显示版本信息');
         console.log('');
@@ -667,6 +685,9 @@ async function main() {
         console.log('  sloth page --list         # 列出所有页面文件');
         console.log('  sloth framework react     # 添加 react 框架');
         console.log('  sloth framework --list    # 列出所有框架');
+        console.log('  sloth add sloth-plugin-cos  # 安装插件');
+        console.log('  sloth remove sloth-plugin-cos  # 卸载插件');
+        console.log('  sloth plugins             # 列出已安装插件');
         console.log('  sloth clear               # 清理缓存文件');
         console.log('  sloth version             # 显示版本信息');
         console.log('  sloth --version           # 显示版本信息');
@@ -1021,9 +1042,93 @@ async function main() {
         }
         process.exit(0);
     }
+    // 检查是否是 add 命令（安装插件）
+    if (process.env.SLOTH_COMMAND === 'add') {
+        const addArgsStr = process.env.SLOTH_ADD_ARGS || '[]';
+        const addArgs = JSON.parse(addArgsStr);
+        // 处理帮助参数
+        if (addArgs.includes('--help') || addArgs.includes('-h')) {
+            console.log('使用方法: sloth add <插件包名>');
+            console.log('');
+            console.log('安装 sloth 插件');
+            console.log('');
+            console.log('示例:');
+            console.log('  sloth add sloth-plugin-cos    # 安装 COS 上传插件');
+            console.log('  sloth add @my/sloth-plugin    # 安装 scoped 插件');
+            process.exit(0);
+        }
+        if (addArgs.length === 0) {
+            console.log('错误: 请提供插件包名');
+            console.log('使用 "sloth add --help" 查看帮助信息');
+            process.exit(1);
+        }
+        const packageName = addArgs[0];
+        const result = await installPlugin(packageName);
+        process.exit(result.success ? 0 : 1);
+    }
+    // 检查是否是 remove 命令（卸载插件）
+    if (process.env.SLOTH_COMMAND === 'remove') {
+        const removeArgsStr = process.env.SLOTH_REMOVE_ARGS || '[]';
+        const removeArgs = JSON.parse(removeArgsStr);
+        // 处理帮助参数
+        if (removeArgs.includes('--help') || removeArgs.includes('-h')) {
+            console.log('使用方法: sloth remove <插件包名>');
+            console.log('');
+            console.log('卸载 sloth 插件');
+            console.log('');
+            console.log('示例:');
+            console.log('  sloth remove sloth-plugin-cos    # 卸载 COS 上传插件');
+            process.exit(0);
+        }
+        if (removeArgs.length === 0) {
+            console.log('错误: 请提供插件包名');
+            console.log('使用 "sloth remove --help" 查看帮助信息');
+            process.exit(1);
+        }
+        const packageName = removeArgs[0];
+        const result = await uninstallPlugin(packageName);
+        process.exit(result.success ? 0 : 1);
+    }
+    // 检查是否是 plugins 命令（列出插件）
+    if (process.env.SLOTH_COMMAND === 'plugins') {
+        const pluginsArgsStr = process.env.SLOTH_PLUGINS_ARGS || '[]';
+        const pluginsArgs = JSON.parse(pluginsArgsStr);
+        const isJsonOutput = pluginsArgs.includes('--json');
+        // 处理帮助参数
+        if (pluginsArgs.includes('--help') || pluginsArgs.includes('-h')) {
+            console.log('使用方法: sloth plugins [选项]');
+            console.log('');
+            console.log('列出已安装的 sloth 插件');
+            console.log('');
+            console.log('选项:');
+            console.log('  --help, -h    显示帮助信息');
+            console.log('  --json        以 JSON 格式输出');
+            process.exit(0);
+        }
+        const plugins = await listPlugins();
+        if (isJsonOutput) {
+            console.log(JSON.stringify({ plugins }, null, 2));
+        }
+        else {
+            if (plugins.length === 0) {
+                console.log('暂无已安装的插件');
+                console.log('');
+                console.log('使用 "sloth add <插件包名>" 安装插件');
+            }
+            else {
+                console.log('已安装的插件:');
+                plugins.forEach((plugin, index) => {
+                    console.log(`  ${index + 1}. ${plugin}`);
+                });
+            }
+        }
+        process.exit(0);
+    }
     try {
         // 先输出基本启动信息到控制台，确保即使 VSCode 日志失败也能看到启动过程
         console.log(`[${new Date().toISOString()}] Starting Figma transcoding interceptor MCP server...`);
+        // 注意：插件管理器的初始化已移到 d2c_figma 工具中
+        // 因为需要先获取工作区根目录才能加载工作区插件
         // Create config manager instance to pass to server
         await startListening(true);
     }

package/dist/build/plugin/index.js

@@ -0,0 +1,4 @@
+// 导出插件管理器
+export { pluginManager } from './manager.js';
+// 导出插件加载器函数
+export { installPlugin, uninstallPlugin, listPlugins, listWorkspacePlugins, loadAllPlugins, loadWorkspacePlugins, loadPlugin } from './loader.js';

package/dist/build/plugin/loader.js

@@ -0,0 +1,320 @@
+import { execSync } from 'child_process';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import envPaths from 'env-paths';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// 检测是否存在 pnpm
+function hasPnpm() {
+    try {
+        execSync('pnpm --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// 获取包管理器命令
+function getPackageManager() {
+    return hasPnpm() ? 'pnpm' : 'npm';
+}
+// 使用 env-paths 获取配置目录（与 config-manager 保持一致）
+const paths = envPaths('d2c-mcp');
+// 获取全局 sloth-d2c-mcp 包的目录
+function getGlobalPackageDir() {
+    // 在构建后的目录中: dist/build/plugin/loader.js
+    // 需要向上三级才能找到包根目录
+    return path.resolve(__dirname, '..', '..', '..');
+}
+// 获取全局插件配置文件路径（与 config.json 在同一目录）
+function getGlobalPluginsConfigPath() {
+    return path.join(paths.config, 'plugins.json');
+}
+// 获取工作区插件目录路径
+function getWorkspacePluginDir(workspaceRoot) {
+    return path.join(workspaceRoot, '.sloth', 'plugin');
+}
+// 获取工作区插件配置文件路径
+function getWorkspacePluginsConfigPath(workspaceRoot) {
+    return path.join(getWorkspacePluginDir(workspaceRoot), 'plugins.json');
+}
+// 加载全局插件配置
+async function loadGlobalPluginsConfig() {
+    const configPath = getGlobalPluginsConfigPath();
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { plugins: [] };
+    }
+}
+// 保存全局插件配置
+async function saveGlobalPluginsConfig(config) {
+    const configPath = getGlobalPluginsConfigPath();
+    // 确保目录存在
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}
+// 加载工作区插件配置
+async function loadWorkspacePluginsConfig(workspaceRoot) {
+    const configPath = getWorkspacePluginsConfigPath(workspaceRoot);
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { plugins: [] };
+    }
+}
+/**
+ * 解析插件配置项，统一返回 { name, config } 格式
+ */
+function parsePluginConfigItem(item) {
+    if (typeof item === 'string') {
+        return { name: item };
+    }
+    return { name: item.name, config: item.config };
+}
+// 检查本地插件是否存在
+async function checkLocalPlugin(workspaceRoot, pluginName) {
+    const pluginDir = getWorkspacePluginDir(workspaceRoot);
+    const localPluginPath = path.join(pluginDir, pluginName, 'index.cjs');
+    try {
+        await fs.access(localPluginPath);
+        return localPluginPath;
+    }
+    catch {
+        return null;
+    }
+}
+// 检查 npm 包是否已安装
+async function isNpmPackageInstalled(packageName) {
+    try {
+        await import(packageName);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// 尝试安装 npm 包
+async function tryInstallNpmPackage(packageName) {
+    const globalDir = getGlobalPackageDir();
+    const pm = getPackageManager();
+    try {
+        console.log(`[sloth] 尝试安装插件包: ${packageName}`);
+        execSync(`${pm} install ${packageName}`, {
+            cwd: globalDir,
+            stdio: 'pipe',
+        });
+        return true;
+    }
+    catch (error) {
+        console.error(`[sloth] 安装插件包 ${packageName} 失败:`, error);
+        return false;
+    }
+}
+/**
+ * 安装插件 npm 包到全局（sloth add 命令）
+ * 注意：这只是安装到全局，不会直接生效
+ * 需要在工作区的 .sloth/plugin/plugins.json 中声明才会生效
+ * @param packageName 插件包名
+ */
+export async function installPlugin(packageName) {
+    const globalDir = getGlobalPackageDir();
+    console.log(`[sloth] 正在安装插件: ${packageName}`);
+    console.log(`[sloth] 安装目录: ${globalDir}`);
+    try {
+        const pm = getPackageManager();
+        // 在全局包目录下执行安装
+        execSync(`${pm} install ${packageName}`, {
+            cwd: globalDir,
+            stdio: 'inherit',
+        });
+        // 更新全局插件配置（记录已安装的插件）
+        const config = await loadGlobalPluginsConfig();
+        const existingNames = config.plugins.map(item => parsePluginConfigItem(item).name);
+        if (!existingNames.includes(packageName)) {
+            config.plugins.push(packageName);
+            await saveGlobalPluginsConfig(config);
+        }
+        console.log(`[sloth] 插件 ${packageName} 安装成功`);
+        console.log(`[sloth] 注意：需要在工作区的 .sloth/plugin/plugins.json 中声明才会生效`);
+        return {
+            success: true,
+            message: `插件 ${packageName} 安装成功。请在工作区的 .sloth/plugin/plugins.json 中添加该插件以启用。`
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[sloth] 插件安装失败: ${errorMessage}`);
+        return { success: false, message: `插件安装失败: ${errorMessage}` };
+    }
+}
+/**
+ * 卸载插件 npm 包
+ * @param packageName 插件包名
+ */
+export async function uninstallPlugin(packageName) {
+    const globalDir = getGlobalPackageDir();
+    console.log(`[sloth] 正在卸载插件: ${packageName}`);
+    try {
+        const pm = getPackageManager();
+        // 在全局包目录下执行卸载
+        execSync(`${pm} uninstall ${packageName}`, {
+            cwd: globalDir,
+            stdio: 'inherit',
+        });
+        // 更新全局插件配置
+        const config = await loadGlobalPluginsConfig();
+        config.plugins = config.plugins.filter((p) => parsePluginConfigItem(p).name !== packageName);
+        await saveGlobalPluginsConfig(config);
+        console.log(`[sloth] 插件 ${packageName} 卸载成功`);
+        return { success: true, message: `插件 ${packageName} 卸载成功` };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[sloth] 插件卸载失败: ${errorMessage}`);
+        return { success: false, message: `插件卸载失败: ${errorMessage}` };
+    }
+}
+/**
+ * 列出全局已安装的插件
+ */
+export async function listPlugins() {
+    const config = await loadGlobalPluginsConfig();
+    return config.plugins.map(item => parsePluginConfigItem(item).name);
+}
+/**
+ * 列出工作区声明的插件
+ * @param workspaceRoot 工作区根目录
+ */
+export async function listWorkspacePlugins(workspaceRoot) {
+    const config = await loadWorkspacePluginsConfig(workspaceRoot);
+    return config.plugins.map(item => parsePluginConfigItem(item));
+}
+/**
+ * 校验并加载工作区声明的所有插件
+ * 1. 先尝试查找 .sloth/plugin/ 文件夹下的本地插件
+ * 2. 再尝试通过 pnpm/npm 安装声明的 npm 包
+ * 3. 都失败则抛出错误
+ * @param workspaceRoot 工作区根目录
+ */
+export async function loadWorkspacePlugins(workspaceRoot) {
+    const config = await loadWorkspacePluginsConfig(workspaceRoot);
+    const plugins = [];
+    const failedPlugins = [];
+    console.log(`[sloth] 开始加载工作区插件，工作区: ${workspaceRoot}`);
+    const pluginNames = config.plugins.map(item => parsePluginConfigItem(item).name);
+    console.log(`[sloth] 声明的插件: ${pluginNames.join(', ') || '无'}`);
+    for (const pluginItem of config.plugins) {
+        const { name: pluginName, config: pluginConfig } = parsePluginConfigItem(pluginItem);
+        let loaded = false;
+        console.log('pluginConfig', pluginConfig);
+        // 1. 先尝试查找本地插件
+        const localPluginPath = await checkLocalPlugin(workspaceRoot, pluginName);
+        if (localPluginPath) {
+            try {
+                console.log(`[sloth] 尝试加载本地插件: ${localPluginPath}`);
+                const pluginModule = await import(localPluginPath);
+                const plugin = {
+                    name: pluginName,
+                    ...(pluginModule.default || pluginModule),
+                    _config: pluginConfig,
+                };
+                plugins.push(plugin);
+                console.log(`[sloth] 本地插件 ${pluginName} 加载成功`);
+                loaded = true;
+            }
+            catch (error) {
+                console.error(`[sloth] 本地插件 ${pluginName} 加载失败:`, error);
+            }
+        }
+        // 2. 如果本地插件不存在或加载失败，尝试加载 npm 包
+        if (!loaded) {
+            // 检查是否已安装
+            const isInstalled = await isNpmPackageInstalled(pluginName);
+            if (!isInstalled) {
+                // 尝试安装
+                console.log(`[sloth] 插件 ${pluginName} 未安装，尝试安装...`);
+                const installSuccess = await tryInstallNpmPackage(pluginName);
+                if (!installSuccess) {
+                    failedPlugins.push(pluginName);
+                    continue;
+                }
+            }
+            // 加载 npm 包
+            try {
+                const pluginModule = await import(pluginName);
+                console.log('pluginModule', pluginModule);
+                const plugin = {
+                    name: pluginName,
+                    ...(pluginModule.default || pluginModule),
+                    _config: pluginConfig,
+                };
+                plugins.push(plugin);
+                console.log(`[sloth] npm 插件 ${pluginName} 加载成功`);
+                loaded = true;
+            }
+            catch (error) {
+                console.error(`[sloth] npm 插件 ${pluginName} 加载失败:`, error);
+                failedPlugins.push(pluginName);
+            }
+        }
+    }
+    // 如果有插件加载失败，打印错误
+    if (failedPlugins.length > 0) {
+        console.error(`以下插件加载失败: ${failedPlugins.join(', ')}。` +
+            `请确保插件存在于 .sloth/plugin/<pluginName>/index.js 或为有效的 npm 包。`);
+    }
+    return plugins;
+}
+/**
+ * 动态加载所有已安装的全局插件（旧方法，保留兼容）
+ * @deprecated 请使用 loadWorkspacePlugins 代替
+ */
+export async function loadAllPlugins() {
+    const config = await loadGlobalPluginsConfig();
+    const plugins = [];
+    for (const pluginItem of config.plugins) {
+        const { name: packageName, config: pluginConfig } = parsePluginConfigItem(pluginItem);
+        try {
+            // 动态导入插件模块
+            const pluginModule = await import(packageName);
+            console.log('pluginModule', pluginModule);
+            console.log('pluginConfig', pluginConfig);
+            const plugin = {
+                name: packageName,
+                ...(pluginModule.default || pluginModule),
+                _config: pluginConfig,
+            };
+            plugins.push(plugin);
+            console.log(`[sloth] 插件 ${packageName} 加载成功`);
+        }
+        catch (error) {
+            console.error(`[sloth] 插件 ${packageName} 加载失败:`, error);
+        }
+    }
+    return plugins;
+}
+/**
+ * 动态加载单个插件
+ * @param packageName 插件包名
+ */
+export async function loadPlugin(packageName) {
+    try {
+        const pluginModule = await import(packageName);
+        const plugin = {
+            name: packageName,
+            ...(pluginModule.default || pluginModule),
+        };
+        console.log(`[sloth] 插件 ${packageName} 加载成功`);
+        return plugin;
+    }
+    catch (error) {
+        console.error(`[sloth] 插件 ${packageName} 加载失败:`, error);
+        return null;
+    }
+}

package/dist/build/plugin/manager.js

@@ -0,0 +1,127 @@
+import { loadAllPlugins, loadWorkspacePlugins } from './loader.js';
+/**
+ * 插件管理器 - 负责管理生命周期 hooks 并按顺序调用插件
+ */
+class PluginManager {
+    plugins = [];
+    initialized = false;
+    workspaceRoot = '';
+    /**
+     * 设置工作区根目录
+     * @param root 工作区根目录
+     */
+    setWorkspaceRoot(root) {
+        this.workspaceRoot = root;
+        // 重置初始化状态，以便重新加载工作区插件
+        if (this.initialized) {
+            this.reset();
+        }
+    }
+    /**
+     * 获取工作区根目录
+     */
+    getWorkspaceRoot() {
+        return this.workspaceRoot;
+    }
+    /**
+     * 初始化插件管理器
+     * 如果设置了工作区根目录，则加载工作区插件
+     * 否则加载全局插件（兼容旧逻辑）
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        try {
+            if (this.workspaceRoot) {
+                // 加载工作区声明的插件
+                console.log(`[sloth] 从工作区加载插件: ${this.workspaceRoot}`);
+                this.plugins = await loadWorkspacePlugins(this.workspaceRoot);
+            }
+            else {
+                // 兼容旧逻辑：加载全局插件
+                console.log(`[sloth] 未设置工作区，加载全局插件`);
+                this.plugins = await loadAllPlugins();
+            }
+            this.initialized = true;
+            console.log(`[sloth] 插件管理器初始化完成，已加载 ${this.plugins.length} 个插件`);
+        }
+        catch (error) {
+            console.error('[sloth] 插件管理器初始化失败:', error);
+            // 如果是工作区模式，抛出错误让调用方知道
+            if (this.workspaceRoot) {
+                throw error;
+            }
+            this.plugins = [];
+            this.initialized = true;
+        }
+    }
+    /**
+     * 获取已加载的插件列表
+     */
+    getPlugins() {
+        return [...this.plugins];
+    }
+    /**
+     * 注册一个插件
+     */
+    registerPlugin(plugin) {
+        this.plugins.push(plugin);
+        console.log(`[sloth] 插件 ${plugin.name} 已注册`);
+    }
+    /**
+     * 执行指定的 hook
+     * @param hookName hook 名称
+     * @param params hook 参数
+     * 按顺序调用所有插件，每个插件都会执行，返回最后一个成功的结果
+     * 每个插件执行时会收到上一个插件的信息 { lastPlugin, returnVal }
+     */
+    async executeHook(hookName, params) {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        const pluginsWithHook = this.plugins.filter((p) => typeof p[hookName] === 'function');
+        if (pluginsWithHook.length === 0) {
+            console.log(`[sloth] 没有插件注册 ${hookName} hook`);
+            return params;
+        }
+        let lastPlugin = '';
+        let lastReturnVal = null;
+        for (const plugin of pluginsWithHook) {
+            try {
+                console.log(`[sloth] 执行插件 ${plugin.name} 的 ${hookName} hook`);
+                const hookFn = plugin[hookName];
+                const context = {
+                    lastPlugin,
+                    returnVal: lastReturnVal,
+                    config: plugin._config,
+                };
+                const result = await hookFn({
+                    ...params,
+                    ...(lastReturnVal || {}),
+                    _config: context.config,
+                }, context);
+                // 更新上一个插件信息
+                lastPlugin = plugin.name;
+                lastReturnVal = {
+                    ...params,
+                    ...(lastReturnVal || {}),
+                    ...(result || {}),
+                };
+            }
+            catch (error) {
+                console.error(`[sloth] 插件 ${plugin.name} 执行 ${hookName} 出错:`, error);
+            }
+        }
+        return lastReturnVal || params;
+    }
+    /**
+     * 重置插件管理器
+     */
+    reset() {
+        this.plugins = [];
+        this.initialized = false;
+    }
+}
+// 导出单例实例
+export const pluginManager = new PluginManager();

package/dist/build/plugin/types.js

@@ -0,0 +1 @@
+export {};