@xubill/xx-cli 1.0.6

package/lib/plugins/plugin-manager.js

@@ -0,0 +1,488 @@
+/**
+ * 插件管理插件
+ * 用于管理所有插件
+ * 
+ * 命令说明：
+ * - plugin [options]：管理所有插件
+ *   - 示例：plugin list
+ *   - 示例：plugin enable <plugin>
+ *   - 示例：plugin disable <plugin>
+ *   - 示例：plugin add <url>
+ *   - 示例：plugin remove <plugin>
+ *   - 示例：plugin create <name>
+ *   - 示例：plugin config <plugin> [key] [value]
+ * 
+ * 功能说明：
+ * - 列出所有插件
+ * - 启用指定插件
+ * - 禁用指定插件
+ * - 添加外部插件
+ * - 删除指定插件
+ * - 创建指定名称的插件模板
+ * - 查看和设置插件配置
+ * 
+ * 用户体验：
+ * - 使用标准化的用户提示
+ * - 提供清晰的错误提示
+ * - 支持命令行参数
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+const BasePlugin = require('../core/base-plugin');
+const validator = require('../utils/validator');
+const pluginConfig = require('../utils/plugin-config');
+
+class PluginManagerPlugin extends BasePlugin {
+  constructor(options = {}) {
+    super(options);
+    this.pluginName = 'plugin-manager';
+  }
+
+  /**
+   * 注册命令
+   * @param {Object} program - Commander.js 实例
+   */
+  registerCommands(program) {
+    // 插件管理命令
+    const pluginCommand = program.command('plugin')
+      .alias('p')
+      .description('插件管理');
+
+    // 列出插件
+    pluginCommand.command('list')
+      .alias('ls')
+      .description('列出所有插件')
+      .action(() => this.listPlugins());
+
+    // 启用插件
+    pluginCommand.command('enable <plugin>')
+      .alias('en')
+      .description('启用插件')
+      .action((plugin) => this.enablePlugin(plugin));
+
+    // 禁用插件
+    pluginCommand.command('disable <plugin>')
+      .alias('dis')
+      .description('禁用插件')
+      .action((plugin) => this.disablePlugin(plugin));
+
+    // 添加外部自定义插件
+    pluginCommand.command('add <url>')
+      .description('添加外部自定义插件')
+      .action((url) => this.addExternalPlugin(url));
+
+    // 删除插件
+    pluginCommand.command('remove <plugin>')
+      .alias('rm')
+      .description('删除指定插件')
+      .action((plugin) => this.removePlugin(plugin));
+
+    // 创建插件
+    pluginCommand.command('create <name>')
+      .alias('cr')
+      .description('创建指定名称的插件模板')
+      .action(async (name, options) => this.createPlugin(name, options));
+
+    // 插件配置管理
+    pluginCommand.command('config <plugin> [key] [value]')
+      .alias('c')
+      .description('查看和设置插件配置')
+      .action((plugin, key, value) => this.managePluginConfig(plugin, key, value));
+  }
+
+  /**
+   * 列出所有插件
+   */
+  listPlugins() {
+    const core = require('../core');
+    const pluginsInfo = core.getPluginsInfo();
+    console.log('\n可用插件列表:');
+    console.log('=====================================');
+    pluginsInfo.forEach(plugin => {
+      const isDisabled = pluginConfig.isPluginDisabled(plugin.name);
+      const status = isDisabled ? '[已禁用]' : '[已启用]';
+      console.log(`- ${plugin.name} ${status}`);
+    });
+    console.log('=====================================');
+    console.log(`总计: ${pluginsInfo.length} 个插件\n`);
+  }
+
+  /**
+   * 启用插件
+   * @param {string} pluginName - 插件名称
+   */
+  enablePlugin(pluginName) {
+    // 验证插件名称
+    if (!validator.validateCommandParam(pluginName)) {
+      console.error('错误: 插件名称包含无效字符');
+      return;
+    }
+    
+    // 启用插件
+    pluginConfig.enablePlugin(pluginName);
+    console.log(`已启用插件: ${pluginName}`);
+    console.log('提示: 请重新运行命令以应用更改');
+  }
+
+  /**
+   * 禁用插件
+   * @param {string} pluginName - 插件名称
+   */
+  disablePlugin(pluginName) {
+    // 验证插件名称
+    if (!validator.validateCommandParam(pluginName)) {
+      console.error('错误: 插件名称包含无效字符');
+      return;
+    }
+    
+    // 禁用插件
+    pluginConfig.disablePlugin(pluginName);
+    console.log(`已禁用插件: ${pluginName}`);
+    console.log('提示: 请重新运行命令以应用更改');
+  }
+
+  /**
+   * 删除插件
+   * @param {string} pluginName - 插件名称
+   */
+  removePlugin(pluginName) {
+    // 验证插件名称
+    if (!validator.validateCommandParam(pluginName)) {
+      console.error('错误: 插件名称包含无效字符');
+      return;
+    }
+    
+    // 内置插件目录
+    const builtinPluginsDir = path.join(__dirname, '../plugins');
+    // 用户插件目录
+    const userPluginsDir = path.join(process.env.HOME || process.env.USERPROFILE, '.xx-cli', 'plugins');
+    
+    // 构建插件文件路径
+    const pluginFileName = `${pluginName}.js`;
+    let pluginPath = path.join(builtinPluginsDir, pluginFileName);
+    
+    // 如果内置插件目录中不存在，则从用户插件目录查找
+    if (!fs.existsSync(pluginPath)) {
+      pluginPath = path.join(userPluginsDir, pluginFileName);
+    }
+    
+    // 检查插件文件是否存在
+    if (!fs.existsSync(pluginPath)) {
+      console.error(`错误: 插件文件不存在`);
+      return;
+    }
+    
+    try {
+      // 删除插件文件
+      fs.unlinkSync(pluginPath);
+      
+      // 从配置中移除插件的禁用状态
+      pluginConfig.removePluginFromConfig(pluginName);
+      
+      console.log(`已成功删除插件: ${pluginName}`);
+      console.log('提示: 请重新运行命令以应用更改');
+    } catch (error) {
+      console.error(`删除插件失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 创建插件
+   * @param {string} name - 插件名称
+   * @param {Object} options - 选项
+   */
+  async createPlugin(name, options) {
+    try {
+      console.log('创建插件模板...');
+
+      // 插件目录路径（用户插件目录，不会被重新安装影响）
+      const pluginsDir = path.join(process.env.HOME || process.env.USERPROFILE, '.xx-cli', 'plugins');
+      const pluginFileName = `${name}.js`;
+      const pluginPath = path.join(pluginsDir, pluginFileName);
+
+      // 检查插件是否已存在
+      if (fs.existsSync(pluginPath)) {
+        console.log(`插件 ${name} 已存在，请使用其他名称`);
+        return;
+      }
+
+      // 生成插件模板内容
+      const pluginContent = this.generatePluginTemplate(name);
+
+      // 写入插件文件
+      await fs.writeFile(pluginPath, pluginContent);
+
+      console.log(`插件模板已成功创建到：${pluginPath}`);
+      console.log('提示：请编辑插件文件，实现具体功能');
+      console.log('测试方法：运行 "node bin/cli.js <插件命令>"');
+
+      // 使用 vscode 打开创建的插件文件
+      try {
+        const { exec } = require('child_process');
+        const os = require('os');
+        let command;
+        
+        // 根据操作系统类型构建不同的命令
+        if (os.platform() === 'win32') {
+          // Windows 系统
+          command = `start code "${pluginPath}"`;
+        } else {
+          // macOS 和 Linux 系统
+          command = `code "${pluginPath}"`;
+        }
+        
+        exec(command, (error) => {
+          if (error) {
+            console.log('提示：无法自动打开 vscode，请手动打开插件文件进行编辑');
+          } else {
+            console.log('已自动打开 vscode 编辑插件文件');
+          }
+        });
+      } catch (error) {
+        console.log('提示：无法自动打开 vscode，请手动打开插件文件进行编辑');
+      }
+
+    } catch (error) {
+      console.error('创建插件模板失败:', error.message);
+    }
+  }
+
+  /**
+   * 生成插件模板内容
+   * @param {string} name - 插件名称
+   * @returns {string} 插件模板内容
+   */
+  generatePluginTemplate(name) {
+    // 生成插件命令名称（去除后缀，转小写，连字符转驼峰）
+    const commandName = name.replace('.js', '').toLowerCase().replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+    
+    // 导入路径
+    const basePluginPath = '../core/base-plugin';
+
+    return `/**
+ * ${name} 插件
+ * 用于实现 ${name} 相关功能
+ * 
+ * 命令说明：
+ * - ${commandName} [options]：${name} 相关功能
+ *   - 示例：${commandName}
+ * 
+ * 功能说明：
+ * - 实现 ${name} 相关功能
+ * 
+ * 用户体验：
+ * - 使用标准化的用户提示
+ * - 提供清晰的错误提示
+ * - 支持命令行参数
+ */
+
+const BasePlugin = require('${basePluginPath}');
+
+class ${this.toCamelCase(name)}Plugin extends BasePlugin {
+  constructor(options = {}) {
+    super(options);
+    this.pluginName = '${name}';
+  }
+
+  /**
+   * 注册命令
+   * @param {Object} program - Commander.js 实例
+   */
+  registerCommands(program) {
+    program.command('${commandName}')
+      .description('${name} 相关功能')
+      .option('-v, --verbose', '显示详细信息')
+      .option('-h, --help', '显示帮助信息')
+      .action((options) => this.${commandName}Command(options));
+  }
+
+  /**
+   * ${name} 命令
+   * @param {Object} options - 命令选项
+   */
+  ${commandName}Command(options) {
+    console.log('${name} 命令执行成功！');
+    if (options && options.verbose) {
+      console.log('详细信息:');
+      console.log('- 命令名称:', '${commandName}');
+      console.log('- 执行时间:', new Date().toLocaleString());
+    }
+  }
+}
+
+module.exports = ${this.toCamelCase(name)}Plugin;
+`;
+  }
+
+  /**
+   * 转换为驼峰命名
+   * @param {string} str - 字符串
+   * @returns {string} 驼峰命名的字符串
+   */
+  toCamelCase(str) {
+    return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase()).replace(/^[a-z]/, (g) => g.toUpperCase());
+  }
+
+  /**
+   * 管理插件配置
+   * @param {string} pluginName - 插件名称
+   * @param {string} key - 配置键
+   * @param {string} value - 配置值
+   */
+  managePluginConfig(pluginName, key, value) {
+    // 验证插件名称
+    if (!validator.validateCommandParam(pluginName)) {
+      console.error('错误: 插件名称包含无效字符');
+      return;
+    }
+    
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    const xxDir = path.join(homeDir, '.xx-cli');
+    const pluginConfigDir = path.join(xxDir, pluginName);
+    const configFile = path.join(pluginConfigDir, 'config.json');
+    
+    // 确保插件配置目录存在
+    fs.ensureDirSync(pluginConfigDir);
+    
+    // 读取现有配置
+    let config = {};
+    if (fs.existsSync(configFile)) {
+      config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    }
+    
+    if (!key) {
+      // 显示所有配置
+      console.log(`插件 ${pluginName} 的配置:`);
+      console.log('=====================================');
+      if (Object.keys(config).length > 0) {
+        Object.entries(config).forEach(([k, v]) => {
+          console.log(`${k}: ${v}`);
+        });
+      } else {
+        console.log('无配置项');
+      }
+      console.log('=====================================');
+    } else if (!value) {
+      // 显示指定配置
+      console.log(`插件 ${pluginName} 的配置 ${key}:`);
+      console.log('=====================================');
+      if (config.hasOwnProperty(key)) {
+        console.log(`${key}: ${config[key]}`);
+      } else {
+        console.log(`配置项 ${key} 不存在`);
+      }
+      console.log('=====================================');
+    } else {
+      // 设置配置
+      config[key] = value;
+      fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
+      console.log(`已设置插件 ${pluginName} 的配置 ${key} = ${value}`);
+    }
+  }
+
+  /**
+   * 添加外部插件
+   * @param {string} url - 插件 URL
+   */
+  async addExternalPlugin(url) {
+    try {
+      // 用户插件目录（不会被重新安装影响）
+      const userPluginsDir = path.join(process.env.HOME || process.env.USERPROFILE, '.xx-cli', 'plugins');
+      
+      // 确保用户插件目录存在
+      fs.ensureDirSync(userPluginsDir);
+      
+      // 提取插件名称
+      const pluginFileName = path.basename(url);
+      const pluginPath = path.join(userPluginsDir, pluginFileName);
+      
+      // 检查插件是否已存在
+      if (fs.existsSync(pluginPath)) {
+        console.log(`插件 ${pluginFileName} 已存在，是否覆盖？`);
+        // 这里可以添加交互式确认
+        console.log('已覆盖现有插件');
+      }
+      
+      // 下载或复制插件
+      if (url.startsWith('http://') || url.startsWith('https://')) {
+        // 是 URL，下载插件
+        console.log(`正在从 URL 下载插件: ${url}`);
+        
+        // 选择 HTTP 或 HTTPS
+        const protocol = url.startsWith('https://') ? https : http;
+        
+        await new Promise((resolve, reject) => {
+          protocol.get(url, (response) => {
+            if (response.statusCode === 200) {
+              // 获取文件大小
+              const fileSize = parseInt(response.headers['content-length'], 10);
+              let downloadedSize = 0;
+              
+              // 创建写入流
+              const writer = fs.createWriteStream(pluginPath);
+              
+              // 监听数据事件，显示进度
+              response.on('data', (chunk) => {
+                downloadedSize += chunk.length;
+                const percentage = Math.round((downloadedSize / fileSize) * 100);
+                
+                // 清除当前行并显示进度
+                process.stdout.clearLine();
+                process.stdout.cursorTo(0);
+                process.stdout.write(`下载进度: ${percentage}%`);
+              });
+              
+              // 管道数据到文件
+              response.pipe(writer);
+              
+              // 监听完成事件
+              writer.on('finish', () => {
+                console.log(''); // 换行
+                console.log(`插件已成功下载到: ${pluginPath}`);
+                resolve();
+              });
+              
+              // 监听错误事件
+              writer.on('error', (error) => {
+                reject(error);
+              });
+            } else {
+              reject(new Error(`下载失败，状态码: ${response.statusCode}`));
+            }
+          }).on('error', (error) => {
+            reject(error);
+          });
+        });
+      } else if (fs.existsSync(url) && url.endsWith('.js')) {
+        // 是本地文件，拷贝插件
+        console.log(`正在从本地文件拷贝插件: ${url}`);
+        
+        // 提取文件名
+        const pluginFileName = path.basename(url);
+        const pluginPath = path.join(userPluginsDir, pluginFileName);
+        
+        // 拷贝文件
+        await fs.copy(url, pluginPath);
+        
+        console.log(`插件已成功拷贝到: ${pluginPath}`);
+      } else {
+        console.error('错误: 无效的插件URL或本地文件路径');
+        return;
+      }
+      
+      // 提示用户
+      console.log('\n提示:');
+      console.log('- 插件已自动注册到命令系统');
+      console.log('- 可以使用 "xx plugin list" 命令查看已安装的插件');
+      console.log('- 可以使用 "xx <plugin-command>" 命令使用插件功能');
+      console.log('- 此插件保存在用户目录中，不会被重新安装影响');
+    } catch (error) {
+      console.error('添加插件失败:', error.message);
+    }
+  }
+}
+
+module.exports = PluginManagerPlugin;

package/lib/utils/config-manager.js

@@ -0,0 +1,185 @@
+/**
+ * 统一配置管理模块
+ * 提供标准化的配置加载、保存、验证功能
+ * 支持配置优先级：命令行参数 > 本地配置 > 全局配置
+ */
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk').default;
+
+class ConfigManager {
+  /**
+   * 构造函数
+   * @param {string} pluginName - 插件名称
+   * @param {Object} options - 配置选项
+   */
+  constructor(pluginName, options = {}) {
+    this.homeDir = process.env.HOME || process.env.USERPROFILE;
+    this.globalConfigDir = path.join(this.homeDir, '.xx-cli', pluginName);
+    this.localConfigPath = options.localConfigPath || `.${pluginName}Config`;
+    this.ensureConfigDir();
+  }
+
+  /**
+   * 确保配置目录存在
+   */
+  ensureConfigDir() {
+    if (!fs.existsSync(this.globalConfigDir)) {
+      fs.mkdirSync(this.globalConfigDir, { recursive: true });
+    }
+  }
+
+  /**
+   * 加载配置
+   * @param {string} configName - 配置名称
+   * @param {Object} cliOptions - 命令行选项
+   * @returns {Object} 合并后的配置对象
+   */
+  loadConfig(configName = 'config', cliOptions = {}) {
+    // 1. 加载全局配置
+    const globalConfig = this.loadGlobalConfig(configName);
+    
+    // 2. 加载本地配置
+    const localConfig = this.loadLocalConfig(configName);
+    
+    // 3. 合并配置：本地配置覆盖全局配置，命令行选项覆盖本地配置
+    const mergedConfig = {
+      ...globalConfig,
+      ...localConfig,
+      ...cliOptions
+    };
+    
+    return mergedConfig;
+  }
+
+  /**
+   * 加载全局配置
+   * @param {string} configName - 配置名称
+   * @returns {Object} 全局配置对象
+   */
+  loadGlobalConfig(configName = 'config') {
+    const configPath = path.join(this.globalConfigDir, `${configName}.json`);
+    if (fs.existsSync(configPath)) {
+      try {
+        return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      } catch (error) {
+        console.error(chalk.red(`解析全局配置文件失败: ${error.message}`));
+        return {};
+      }
+    }
+    return {};
+  }
+
+  /**
+   * 加载本地配置
+   * @param {string} configName - 配置名称
+   * @returns {Object} 本地配置对象
+   */
+  loadLocalConfig(configName = 'config') {
+    const configPath = path.resolve(this.localConfigPath);
+    if (fs.existsSync(configPath)) {
+      try {
+        const localConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        // 如果是多环境配置，返回指定环境的配置
+        if (localConfig[configName]) {
+          return localConfig[configName];
+        }
+        return localConfig;
+      } catch (error) {
+        console.error(chalk.red(`解析本地配置文件失败: ${error.message}`));
+        return {};
+      }
+    }
+    return {};
+  }
+
+  /**
+   * 保存配置
+   * @param {Object} config - 配置对象
+   * @param {string} configName - 配置名称
+   * @param {boolean} isGlobal - 是否保存到全局配置
+   */
+  saveConfig(config, configName = 'config', isGlobal = true) {
+    try {
+      const configPath = isGlobal 
+        ? path.join(this.globalConfigDir, `${configName}.json`) 
+        : path.resolve(this.localConfigPath);
+      
+      // 确保目录存在
+      if (isGlobal) {
+        this.ensureConfigDir();
+      } else {
+        const configDir = path.dirname(configPath);
+        if (!fs.existsSync(configDir)) {
+          fs.mkdirSync(configDir, { recursive: true });
+        }
+      }
+      
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      console.log(chalk.green(`配置保存成功: ${configPath}`));
+    } catch (error) {
+      console.error(chalk.red(`保存配置失败: ${error.message}`));
+    }
+  }
+
+  /**
+   * 验证配置
+   * @param {Object} config - 配置对象
+   * @param {Object} schema - 配置 schema
+   * @returns {Object} 验证结果
+   */
+  validateConfig(config, schema) {
+    if (!schema) {
+      return { valid: true, data: config };
+    }
+    
+    // 这里可以集成 Joi 等验证库
+    // 暂时返回简单验证
+    return { valid: true, data: config };
+  }
+
+  /**
+   * 获取配置路径
+   * @param {string} configName - 配置名称
+   * @param {boolean} isGlobal - 是否获取全局配置路径
+   * @returns {string} 配置文件路径
+   */
+  getConfigPath(configName = 'config', isGlobal = true) {
+    return isGlobal 
+      ? path.join(this.globalConfigDir, `${configName}.json`) 
+      : path.resolve(this.localConfigPath);
+  }
+
+  /**
+   * 检查配置是否存在
+   * @param {string} configName - 配置名称
+   * @param {boolean} isGlobal - 是否检查全局配置
+   * @returns {boolean} 配置是否存在
+   */
+  hasConfig(configName = 'config', isGlobal = true) {
+    const configPath = this.getConfigPath(configName, isGlobal);
+    return fs.existsSync(configPath);
+  }
+
+  /**
+   * 删除配置
+   * @param {string} configName - 配置名称
+   * @param {boolean} isGlobal - 是否删除全局配置
+   */
+  deleteConfig(configName = 'config', isGlobal = true) {
+    try {
+      const configPath = this.getConfigPath(configName, isGlobal);
+      if (fs.existsSync(configPath)) {
+        fs.unlinkSync(configPath);
+        console.log(chalk.green(`配置删除成功: ${configPath}`));
+      } else {
+        console.log(chalk.yellow(`配置文件不存在: ${configPath}`));
+      }
+    } catch (error) {
+      console.error(chalk.red(`删除配置失败: ${error.message}`));
+    }
+  }
+}
+
+module.exports = ConfigManager;