sloth-d2c-mcp 1.0.4-beta89 → 1.0.4-beta91

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/core/prompt-builder.js

@@ -164,7 +164,20 @@ export function buildComponentMappingPrompt(componentMappings, componentContexts
             }
         });
         prompt +=
-            '**重要**：在最终写入代码时，请根据设计稿需求合理传递 props 参数。请按照项目路径规范合理引入组件。如果组件有继承关系，请注意父类的 props 和方法也可以使用。\n';
+            '**重要**：在最终写入代码时，请根据设计稿需求合理传递组件参数。请按照项目路径规范合理引入组件。如果组件有继承关系，请注意父类的参数和方法也可以使用。\n';
+    }
+    // 构建组件映射的设计稿代码（用于 AI 提取组件参数）
+    const mappingsWithCode = componentMappings.filter((m) => m.code);
+    if (mappingsWithCode.length > 0) {
+        prompt += '\n\n## 组件映射设计稿代码\n\n';
+        prompt += '以下是已映射组件对应的设计稿绝对定位代码，请根据这些代码提取信息，在使用组件时传入相应参数：\n\n';
+        mappingsWithCode.forEach((mapping) => {
+            prompt += `### ${mapping.groupName}\n\n`;
+            prompt += '```html\n';
+            prompt += mapping.code;
+            prompt += '\n```\n\n';
+        });
+        prompt += '**重要**：请从上述 HTML 代码中提取信息，作为对应组件的初始化参数。\n';
     }
     // 构建标记组件提示词
     if (markedComponents.length > 0) {

package/dist/build/core/sampling.js

@@ -40,21 +40,33 @@ export function buildNestingStructure(groupsData) {
     return { childrenMap, rootGroups, groupMap, allChildIndices };
 }
 /**
- * 处理组件映射（如果已映射则跳过采样）
+ * 处理组件映射（生成 HTML 代码供 AI 提取 props）
  * @param group 分组数据
+ * @param nodeList 节点列表
  * @param componentMappings 组件映射数组
+ * @param imageMap 图片映射
+ * @param convertConfig 转换配置
  * @returns 采样结果或 null
  */
-export function handleComponentMapping(group, componentMappings) {
+export async function handleComponentMapping(group, nodeList, componentMappings, imageMap, convertConfig) {
     if (group.componentMapping) {
         const componentName = group.componentMapping.name || `Group${group.groupIndex + 1}`;
         group.name = componentName;
+        // 生成带绝对定位的 HTML 代码，供 AI 提取 props 信息
+        const resetNodeList = resetNodeListPosition(nodeList);
+        const code = await getCode({
+            d2cNodeList: resetNodeList,
+            config: convertConfig,
+        });
+        const replacedCode = replaceImageSrc(code, imageMap);
         componentMappings.push({
             groupIndex: group.groupIndex,
             groupName: componentName,
             component: group.componentMapping,
+            code: replacedCode,
         });
-        return { skipped: true, groupIndex: group.groupIndex, componentName };
+        Logger.log(`组 ${group.groupIndex} 已映射组件 ${componentName}，生成 HTML 代码长度: ${replacedCode.length}`);
+        return { skipped: true, groupIndex: group.groupIndex, componentName, code: replacedCode };
     }
     return null;
 }
@@ -138,7 +150,7 @@ export async function sampleSingleGroup(group, nodeList, config) {
     const { d2cNodeList, imageMap, convertConfig, frameworkPrompt, chunkPrompt, mcpServer, componentMappings, codeSnippets, componentContexts, isSupportSampling } = config;
     Logger.log(`开始采样组 ${group.groupIndex}, 元素数量: ${group.elements.length}, nodeList 长度: ${nodeList.length}`);
     // 检查组件映射
-    const mappingResult = handleComponentMapping(group, componentMappings);
+    const mappingResult = await handleComponentMapping(group, nodeList, componentMappings, imageMap, convertConfig);
     if (mappingResult) {
         Logger.log(`组 ${group.groupIndex} 已映射组件，跳过采样: ${mappingResult.componentName}`);
         return mappingResult;

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;
+    }
+}