ops-toolkit 1.2.0 → 1.2.1

package/src/utils/config.ts

@@ -1,146 +1,467 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import { Logger } from './logger';
+import { Logger, LogLevel } from './logger';
+import { ConfigError } from './error-handlers';
 
-// 配置管理类
-export class Config {
+/**
+ * 配置接口定义
+ */
+export interface OpsConfig {
+  version?: string;
+  environment?: 'development' | 'production' | 'test';
+  monitor: {
+    refreshInterval: number;
+    showProcesses: boolean;
+    maxProcesses: number;
+    enableRealTime: boolean;
+  };
+  logs: {
+    defaultPath: string;
+    maxLines: number;
+    follow: boolean;
+    level: LogLevel;
+    enableFileLogging: boolean;
+    logDirectory: string;
+  };
+  deploy: {
+    defaultEnv: string;
+    backupEnabled: boolean;
+    confirmBeforeDeploy: boolean;
+    rollbackEnabled: boolean;
+    maxRetries: number;
+  };
+  system: {
+    showHiddenServices: boolean;
+    cacheTimeout: number;
+    enableNotifications: boolean;
+  };
+  ui: {
+    theme: string;
+    animations: boolean;
+    sound: boolean;
+    language: string;
+  };
+  [key: string]: unknown;
+}
+
+/**
+ * 配置验证器
+ */
+export interface ConfigValidator {
+  validate(config: OpsConfig): boolean;
+  getErrors(): string[];
+}
+
+/**
+ * 配置管理器
+ */
+export class ConfigManager {
   private static configDir = path.join(os.homedir(), '.ops-toolkit');
-  private static configFile = path.join(Config.configDir, 'config.json');
-  private static defaultConfig = {
+  private static configFile = path.join(ConfigManager.configDir, 'config.json');
+  private static backupDir = path.join(ConfigManager.configDir, 'backups');
+  private static config: OpsConfig | null = null;
+  private static validators: Map<string, ConfigValidator> = new Map();
+
+  private static defaultConfig: OpsConfig = {
+    environment: 'development',
+    version: '1.2.0',
     monitor: {
       refreshInterval: 5000,
       showProcesses: true,
       maxProcesses: 20,
+      enableRealTime: false,
     },
     logs: {
       defaultPath: '/var/log',
       maxLines: 1000,
       follow: false,
+      level: LogLevel.INFO,
+      enableFileLogging: false,
+      logDirectory: path.join(os.homedir(), '.ops-toolkit', 'logs'),
     },
     deploy: {
       defaultEnv: 'production',
       backupEnabled: true,
       confirmBeforeDeploy: true,
+      rollbackEnabled: true,
+      maxRetries: 3,
     },
     system: {
       showHiddenServices: false,
       cacheTimeout: 30000,
+      enableNotifications: true,
     },
     ui: {
       theme: 'default',
       animations: true,
       sound: false,
+      language: 'zh-CN',
     },
   };
 
-  // 获取配置
-  static get(key?: string): any {
+  /**
+   * 初始化配置系统
+   */
+  static async initialize(): Promise<void> {
     try {
+      await this.ensureDirectories();
+
       if (!fs.existsSync(this.configFile)) {
-        this.createDefaultConfig();
+        await this.createDefaultConfig();
       }
 
-      const configData = fs.readFileSync(this.configFile, 'utf8');
-      const config = JSON.parse(configData);
+      await this.loadConfig();
+      await this.validateConfig();
 
-      if (key) {
-        return this.getNestedValue(config, key);
+      Logger.info('配置系统初始化完成', { configDir: this.configDir });
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      throw new ConfigError(`配置系统初始化失败: ${err.message}`);
+    }
+  }
+
+  /**
+   * 确保必要的目录存在
+   */
+  private static async ensureDirectories(): Promise<void> {
+    const directories = [this.configDir, this.backupDir];
+
+    for (const dir of directories) {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+        Logger.debug(`创建目录: ${dir}`);
       }
+    }
+  }
 
-      return config;
+  /**
+   * 创建默认配置
+   */
+  private static async createDefaultConfig(): Promise<void> {
+    try {
+      const configJson = JSON.stringify(this.defaultConfig, null, 2);
+      fs.writeFileSync(this.configFile, configJson, 'utf8');
+      Logger.success('创建默认配置文件', { configFile: this.configFile });
     } catch (error) {
-      Logger.error(`Failed to read config: ${error}`);
-      return this.defaultConfig;
+      throw new ConfigError(`创建默认配置失败: ${error}`);
     }
   }
 
-  // 设置配置
-  static set(key: string, value: any): void {
+  /**
+   * 加载配置
+   */
+  private static async loadConfig(): Promise<void> {
     try {
-      const config = this.get();
-      this.setNestedValue(config, key, value);
+      const configData = fs.readFileSync(this.configFile, 'utf8');
+      const loadedConfig = JSON.parse(configData) as OpsConfig;
+
+      // 合并默认配置和加载的配置
+      this.config = this.mergeConfigs(this.defaultConfig, loadedConfig);
 
-      fs.writeFileSync(this.configFile, JSON.stringify(config, null, 2));
-      Logger.success(`Configuration updated: ${key}`);
+      Logger.debug('配置加载完成', {
+        environment: this.config.environment,
+        version: this.config.version,
+      });
     } catch (error) {
-      Logger.error(`Failed to set config: ${error}`);
+      throw new ConfigError(`加载配置失败: ${error}`);
+    }
+  }
+
+  /**
+   * 合并配置对象
+   */
+  private static mergeConfigs(defaultConfig: OpsConfig, userConfig: OpsConfig): OpsConfig {
+    const merged = { ...defaultConfig, ...userConfig };
+
+    // 深度合并嵌套对象
+    for (const key in defaultConfig) {
+      if (
+        key in userConfig &&
+        typeof defaultConfig[key] === 'object' &&
+        typeof userConfig[key] === 'object' &&
+        !Array.isArray(defaultConfig[key]) &&
+        !Array.isArray(userConfig[key])
+      ) {
+        merged[key] = {
+          ...defaultConfig[key],
+          ...userConfig[key],
+        } as OpsConfig[Extract<keyof OpsConfig, string>];
+      }
     }
+
+    return merged;
+  }
+
+  /**
+   * 验证配置
+   */
+  private static async validateConfig(): Promise<void> {
+    if (!this.config) {
+      throw new ConfigError('配置未初始化');
+    }
+
+    let allValid = true;
+    const allErrors: string[] = [];
+
+    // 运行所有验证器
+    for (const [name, validator] of this.validators) {
+      const isValid = validator.validate(this.config);
+      if (!isValid) {
+        allValid = false;
+        const errors = validator.getErrors();
+        allErrors.push(...errors.map(err => `[${name}] ${err}`));
+      }
+    }
+
+    if (!allValid) {
+      const errorMessage = `配置验证失败:\n${allErrors.join('\n')}`;
+      Logger.error(errorMessage);
+      throw new ConfigError(errorMessage);
+    }
+
+    Logger.debug('配置验证通过');
   }
 
-  // 重置配置
-  static reset(): void {
+  /**
+   * 注册配置验证器
+   */
+  static registerValidator(name: string, validator: ConfigValidator): void {
+    this.validators.set(name, validator);
+    Logger.debug(`注册配置验证器: ${name}`);
+  }
+
+  /**
+   * 获取配置
+   */
+  static get<T = OpsConfig>(key?: string): OpsConfig | T {
+    if (!this.config) {
+      throw new ConfigError('配置未初始化，请先调用 initialize()');
+    }
+
+    if (!key) {
+      return { ...this.config };
+    }
+
+    return this.getNestedValue<T>(this.config, key);
+  }
+
+  /**
+   * 设置配置
+   */
+  static async set<T = unknown>(key: string, value: T): Promise<void> {
+    if (!this.config) {
+      throw new ConfigError('配置未初始化，请先调用 initialize()');
+    }
+
     try {
-      this.createDefaultConfig();
-      Logger.success('Configuration reset to defaults');
+      // 创建备份
+      await this.createBackup();
+
+      // 设置值
+      this.setNestedValue(this.config, key, value);
+
+      // 保存配置
+      await this.saveConfig();
+
+      // 验证配置
+      await this.validateConfig();
+
+      Logger.success(`配置更新成功: ${key}`, { value });
     } catch (error) {
-      Logger.error(`Failed to reset config: ${error}`);
+      // 回滚配置
+      await this.rollbackFromBackup();
+      throw new ConfigError(`设置配置失败: ${error}`);
     }
   }
 
-  // 创建默认配置
-  private static createDefaultConfig(): void {
+  /**
+   * 保存配置
+   */
+  private static async saveConfig(): Promise<void> {
+    if (!this.config) {
+      throw new ConfigError('配置未初始化');
+    }
+
     try {
-      if (!fs.existsSync(this.configDir)) {
-        fs.mkdirSync(this.configDir, { recursive: true });
+      const configJson = JSON.stringify(this.config, null, 2);
+      fs.writeFileSync(this.configFile, configJson, 'utf8');
+      Logger.debug('配置保存完成');
+    } catch (error) {
+      throw new ConfigError(`保存配置失败: ${error}`);
+    }
+  }
+
+  /**
+   * 创建配置备份
+   */
+  private static async createBackup(): Promise<void> {
+    if (!fs.existsSync(this.configFile)) {
+      return;
+    }
+
+    try {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupFile = path.join(this.backupDir, `config-backup-${timestamp}.json`);
+
+      fs.copyFileSync(this.configFile, backupFile);
+      Logger.debug('配置备份创建完成', { backupFile });
+    } catch (error) {
+      Logger.warning('创建配置备份失败', { error: String(error) });
+    }
+  }
+
+  /**
+   * 从备份回滚
+   */
+  private static async rollbackFromBackup(): Promise<void> {
+    try {
+      const backupFiles = fs
+        .readdirSync(this.backupDir)
+        .filter(file => file.startsWith('config-backup-'))
+        .sort()
+        .reverse();
+
+      if (backupFiles.length > 0) {
+        const latestBackup = backupFiles[0];
+        if (latestBackup) {
+          const backupPath = path.join(this.backupDir, latestBackup);
+
+          fs.copyFileSync(backupPath, this.configFile);
+          await this.loadConfig();
+
+          Logger.info('配置已回滚到最新备份', { backupFile: latestBackup });
+        }
       }
+    } catch (error) {
+      Logger.error('配置回滚失败', { error });
+    }
+  }
+
+  /**
+   * 重置配置
+   */
+  static async reset(): Promise<void> {
+    try {
+      await this.createBackup();
+      this.config = { ...this.defaultConfig };
+      await this.saveConfig();
+      await this.validateConfig();
 
-      fs.writeFileSync(this.configFile, JSON.stringify(this.defaultConfig, null, 2));
+      Logger.success('配置已重置为默认值');
     } catch (error) {
-      Logger.error(`Failed to create default config: ${error}`);
+      throw new ConfigError(`重置配置失败: ${error}`);
     }
   }
 
-  // 获取嵌套值
-  private static getNestedValue(obj: any, key: string): any {
-    return key.split('.').reduce((current, keyPart) => {
-      return current && current[keyPart];
-    }, obj);
+  /**
+   * 重新加载配置
+   */
+  static async reload(): Promise<void> {
+    try {
+      await this.loadConfig();
+      await this.validateConfig();
+      Logger.info('配置重新加载完成');
+    } catch (error) {
+      throw new ConfigError(`重新加载配置失败: ${error}`);
+    }
   }
 
-  // 设置嵌套值
-  private static setNestedValue(obj: any, key: string, value: any): void {
+  /**
+   * 获取嵌套值
+   */
+  private static getNestedValue<T = unknown>(obj: OpsConfig, key: string): T {
     const keys = key.split('.');
-    const lastKey = keys.pop()!;
+    let current: unknown = obj;
 
-    const target = keys.reduce((current, keyPart) => {
-      if (!current[keyPart]) {
-        current[keyPart] = {};
+    for (const keyPart of keys) {
+      if (current && typeof current === 'object' && keyPart in current) {
+        current = (current as Record<string, unknown>)[keyPart];
+      } else {
+        return undefined as T;
       }
-      return current[keyPart];
-    }, obj);
+    }
 
-    target[lastKey] = value;
+    return current as T;
   }
 
-  // 验证配置
-  static validate(): boolean {
-    try {
-      const config = this.get();
+  /**
+   * 设置嵌套值
+   */
+  private static setNestedValue(obj: OpsConfig, key: string, value: unknown): void {
+    const keys = key.split('.');
+    const lastKey = keys.pop();
 
-      // 基本验证
-      if (!config.monitor || !config.logs || !config.deploy) {
-        return false;
-      }
+    if (!lastKey) return;
 
-      // 类型验证
-      if (typeof config.monitor.refreshInterval !== 'number') {
-        return false;
-      }
+    let current: Record<string, unknown> = obj as Record<string, unknown>;
 
-      return true;
-    } catch {
-      return false;
+    for (const keyPart of keys) {
+      if (!(keyPart in current) || !current[keyPart] || typeof current[keyPart] !== 'object') {
+        current[keyPart] = {};
+      }
+      current = current[keyPart] as Record<string, unknown>;
     }
+
+    current[lastKey] = value;
   }
 
-  // 获取配置目录
+  /**
+   * 获取配置目录
+   */
   static getConfigDir(): string {
     return this.configDir;
   }
 
-  // 获取配置文件路径
+  /**
+   * 获取配置文件路径
+   */
   static getConfigFile(): string {
     return this.configFile;
   }
+
+  /**
+   * 获取备份目录
+   */
+  static getBackupDir(): string {
+    return this.backupDir;
+  }
+
+  /**
+   * 清理旧备份
+   */
+  static async cleanOldBackups(maxBackups: number = 10): Promise<void> {
+    try {
+      const backupFiles = fs
+        .readdirSync(this.backupDir)
+        .filter(file => file.startsWith('config-backup-'))
+        .map(file => ({
+          file,
+          path: path.join(this.backupDir, file),
+          mtime: fs.statSync(path.join(this.backupDir, file)).mtime,
+        }))
+        .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+
+      if (backupFiles.length > maxBackups) {
+        const filesToDelete = backupFiles.slice(maxBackups);
+
+        for (const { file, path: filePath } of filesToDelete) {
+          if (filePath) {
+            fs.unlinkSync(filePath);
+            Logger.debug('删除旧备份文件', { file });
+          }
+        }
+      }
+
+      Logger.debug('备份清理完成', {
+        totalBackups: backupFiles.length,
+        keptBackups: Math.min(maxBackups, backupFiles.length),
+      });
+    } catch (error) {
+      Logger.warning('清理备份文件失败', { error });
+    }
+  }
 }
+
+// 向后兼容的Config类
+export class Config extends ConfigManager {}

package/src/utils/error-handlers.ts

@@ -0,0 +1,94 @@
+import { ErrorSeverity, errorHandler } from './error-reporter';
+
+/**
+ * 自定义错误类型
+ */
+export class CLIError extends Error {
+  public readonly code: string;
+  public readonly exitCode: number;
+
+  constructor(message: string, code: string = 'CLI_ERROR', exitCode: number = 1) {
+    super(message);
+    this.name = 'CLIError';
+    this.code = code;
+    this.exitCode = exitCode;
+  }
+}
+
+export class CommandError extends CLIError {
+  constructor(message: string, command: string = '') {
+    super(`命令执行失败: ${command} - ${message}`, 'COMMAND_ERROR');
+    this.name = 'CommandError';
+  }
+}
+
+export class ConfigError extends CLIError {
+  constructor(message: string) {
+    super(`配置错误: ${message}`, 'CONFIG_ERROR');
+    this.name = 'ConfigError';
+  }
+}
+
+export class SystemError extends CLIError {
+  constructor(message: string) {
+    super(`系统错误: ${message}`, 'SYSTEM_ERROR');
+    this.name = 'SystemError';
+  }
+}
+
+/**
+ * 设置全局错误处理器
+ */
+export function setupErrorHandlers(): void {
+  // 未捕获异常处理
+  process.on('uncaughtException', (error: Error) => {
+    errorHandler(error, { action: 'uncaught_exception' }, ErrorSeverity.CRITICAL);
+  });
+
+  // 未处理的Promise拒绝
+  process.on('unhandledRejection', (reason: unknown, promise: Promise<unknown>) => {
+    const error = reason instanceof Error ? reason : new Error(String(reason));
+    errorHandler(
+      error,
+      {
+        action: 'unhandled_rejection',
+        additionalInfo: { promise: promise.toString() },
+      },
+      ErrorSeverity.HIGH
+    );
+  });
+}
+
+/**
+ * 包装异步函数，提供错误处理
+ */
+export function withErrorHandling<T extends unknown[]>(
+  fn: (...args: T) => Promise<void>,
+  context?: string
+) {
+  return async (...args: T): Promise<void> => {
+    try {
+      await fn(...args);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+
+      if (err instanceof CLIError) {
+        errorHandler(
+          err,
+          {
+            action: context || 'unknown_action',
+            additionalInfo: {
+              errorCode: err.code,
+              exitCode: err.exitCode,
+            },
+          },
+          err.exitCode === 1 ? ErrorSeverity.HIGH : ErrorSeverity.MEDIUM
+        );
+        process.exit(err.exitCode);
+      } else {
+        errorHandler(err, { action: context || 'unknown_action' }, ErrorSeverity.HIGH);
+        process.exit(1);
+      }
+    }
+  };
+}