@hddz/plugin-harness 0.1.19 → 0.2.1

package/dist/core/validators/config-validator.js

@@ -0,0 +1,235 @@
+"use strict";
+// src/validators/config-validator.ts - 配置验证器
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigValidator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ConfigValidator {
+    workspacePath;
+    configPath;
+    constructor(workspacePath) {
+        this.workspacePath = workspacePath;
+        // OpenClaw 配置文件在 workspace 的父目录
+        this.configPath = path.join(workspacePath, '..', 'openclaw.json');
+    }
+    /**
+     * 验证配置内容（用于包装层拦截）
+     */
+    validateContent(config) {
+        const result = { valid: true, errors: [], warnings: [], info: [] };
+        // 检查是否是有效的对象
+        if (!config || typeof config !== 'object') {
+            result.valid = false;
+            result.errors.push('配置必须是有效的 JSON 对象');
+            return result;
+        }
+        // 检查必填字段
+        const requiredFields = ['models', 'plugins', 'gateway'];
+        requiredFields.forEach(field => {
+            if (!config[field]) {
+                result.valid = false;
+                result.errors.push(`缺少必填字段：${field}`);
+            }
+        });
+        // 检查 models 配置
+        if (config.models) {
+            if (!config.models.providers || Object.keys(config.models.providers).length === 0) {
+                result.warnings.push('未配置任何模型提供商');
+            }
+            else {
+                const providers = Object.keys(config.models.providers);
+                result.info.push(`已配置模型提供商：${providers.join(', ')}`);
+            }
+            if (config.models.defaultModel && !config.models.defaultModel.includes('/')) {
+                result.warnings.push('defaultModel 格式可能不正确（应为 provider/model-name）');
+            }
+        }
+        // 检查 gateway 配置
+        if (config.gateway) {
+            if (config.gateway.port) {
+                if (config.gateway.port < 1024 || config.gateway.port > 65535) {
+                    result.valid = false;
+                    result.errors.push(`无效的端口号：${config.gateway.port}`);
+                }
+                else {
+                    result.info.push(`Gateway 端口：${config.gateway.port}`);
+                }
+            }
+            if (config.gateway.host) {
+                result.info.push(`Gateway 主机：${config.gateway.host}`);
+            }
+        }
+        // 检查 plugins 配置
+        if (config.plugins && config.plugins.entries) {
+            const pluginEntries = Object.entries(config.plugins.entries);
+            const enabledPlugins = pluginEntries
+                .filter(([_, plugin]) => plugin.enabled)
+                .map(([name, _]) => name);
+            if (enabledPlugins.length > 0) {
+                result.info.push(`已启用插件：${enabledPlugins.join(', ')}`);
+            }
+            pluginEntries.forEach(([name, plugin]) => {
+                if (plugin.enabled && !plugin.config) {
+                    result.warnings.push(`插件 ${name} 已启用但缺少配置`);
+                }
+            });
+        }
+        return result;
+    }
+    validate(configPath) {
+        const pathToValidate = configPath || this.configPath;
+        const result = { valid: true, errors: [], warnings: [], info: [] };
+        // 检查文件存在
+        if (!fs.existsSync(pathToValidate)) {
+            result.valid = false;
+            result.errors.push(`配置文件不存在：${pathToValidate}`);
+            return result;
+        }
+        // 检查 JSON 格式
+        let config;
+        try {
+            const content = fs.readFileSync(pathToValidate, 'utf8');
+            config = JSON.parse(content);
+            result.info.push(`配置文件大小：${(content.length / 1024).toFixed(2)} KB`);
+        }
+        catch (e) {
+            result.valid = false;
+            result.errors.push(`JSON 格式错误：${e.message}`);
+            return result;
+        }
+        // 检查必填字段
+        const requiredFields = ['models', 'plugins', 'gateway'];
+        requiredFields.forEach(field => {
+            if (!config[field]) {
+                result.valid = false;
+                result.errors.push(`缺少必填字段：${field}`);
+            }
+        });
+        // 检查 models 配置
+        if (config.models) {
+            if (!config.models.providers || Object.keys(config.models.providers).length === 0) {
+                result.warnings.push('未配置任何模型提供商');
+            }
+            else {
+                const providers = Object.keys(config.models.providers);
+                result.info.push(`已配置模型提供商：${providers.join(', ')}`);
+            }
+            if (config.models.defaultModel && !config.models.defaultModel.includes('/')) {
+                result.warnings.push('defaultModel 格式可能不正确（应为 provider/model-name）');
+            }
+        }
+        // 检查 gateway 配置
+        if (config.gateway) {
+            if (config.gateway.port) {
+                if (config.gateway.port < 1024 || config.gateway.port > 65535) {
+                    result.valid = false;
+                    result.errors.push(`无效的端口号：${config.gateway.port}`);
+                }
+                else {
+                    result.info.push(`Gateway 端口：${config.gateway.port}`);
+                }
+            }
+            if (config.gateway.host) {
+                result.info.push(`Gateway 主机：${config.gateway.host}`);
+            }
+        }
+        // 检查 plugins 配置
+        if (config.plugins && config.plugins.entries) {
+            const pluginEntries = Object.entries(config.plugins.entries);
+            const enabledPlugins = pluginEntries
+                .filter(([_, plugin]) => plugin.enabled)
+                .map(([name, _]) => name);
+            if (enabledPlugins.length > 0) {
+                result.info.push(`已启用插件：${enabledPlugins.join(', ')}`);
+            }
+            pluginEntries.forEach(([name, plugin]) => {
+                if (plugin.enabled && !plugin.config) {
+                    result.warnings.push(`插件 ${name} 已启用但缺少配置`);
+                }
+            });
+        }
+        // 检查记忆配置
+        if (config.memory) {
+            if (config.memory.maxSummaryDays) {
+                result.info.push(`记忆摘要天数：${config.memory.maxSummaryDays}`);
+            }
+        }
+        return result;
+    }
+    validateAndThrow(configPath) {
+        const result = this.validate(configPath);
+        if (!result.valid) {
+            throw new Error(`配置验证失败:\n${result.errors.join('\n')}`);
+        }
+    }
+    /**
+     * 比较两个配置的差异
+     */
+    diffConfigs(oldConfigPath, newConfigPath) {
+        const changes = [];
+        try {
+            const oldConfig = JSON.parse(fs.readFileSync(oldConfigPath, 'utf8'));
+            const newConfig = JSON.parse(fs.readFileSync(newConfigPath, 'utf8'));
+            const compare = (oldObj, newObj, path = '') => {
+                const allKeys = new Set([...Object.keys(oldObj || {}), ...Object.keys(newObj || {})]);
+                for (const key of allKeys) {
+                    const fullPath = path ? `${path}.${key}` : key;
+                    const oldVal = oldObj?.[key];
+                    const newVal = newObj?.[key];
+                    if (typeof oldVal === 'object' && typeof newVal === 'object' &&
+                        oldVal !== null && newVal !== null &&
+                        !Array.isArray(oldVal) && !Array.isArray(newVal)) {
+                        compare(oldVal, newVal, fullPath);
+                    }
+                    else if (JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
+                        changes.push({
+                            field: fullPath,
+                            oldValue: oldVal,
+                            newValue: newVal,
+                        });
+                    }
+                }
+            };
+            compare(oldConfig, newConfig);
+        }
+        catch (error) {
+            // 忽略错误
+        }
+        return changes;
+    }
+}
+exports.ConfigValidator = ConfigValidator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-validator.js","sourceRoot":"","sources":["../../../src/core/validators/config-validator.ts"],"names":[],"mappings":"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","sourcesContent":["// src/validators/config-validator.ts - 配置验证器\n\nimport * as fs from 'fs';\nimport * as path from 'path';\n\nexport interface ValidationResult {\n  valid: boolean;\n  errors: string[];\n  warnings: string[];\n  info: string[];\n}\n\nexport class ConfigValidator {\n  private configPath: string;\n\n  constructor(private workspacePath: string) {\n    // OpenClaw 配置文件在 workspace 的父目录\n    this.configPath = path.join(workspacePath, '..', 'openclaw.json');\n  }\n\n  /**\n   * 验证配置内容（用于包装层拦截）\n   */\n  validateContent(config: any): ValidationResult {\n    const result: ValidationResult = { valid: true, errors: [], warnings: [], info: [] };\n\n    // 检查是否是有效的对象\n    if (!config || typeof config !== 'object') {\n      result.valid = false;\n      result.errors.push('配置必须是有效的 JSON 对象');\n      return result;\n    }\n\n    // 检查必填字段\n    const requiredFields = ['models', 'plugins', 'gateway'];\n    requiredFields.forEach(field => {\n      if (!config[field]) {\n        result.valid = false;\n        result.errors.push(`缺少必填字段：${field}`);\n      }\n    });\n\n    // 检查 models 配置\n    if (config.models) {\n      if (!config.models.providers || Object.keys(config.models.providers).length === 0) {\n        result.warnings.push('未配置任何模型提供商');\n      } else {\n        const providers = Object.keys(config.models.providers);\n        result.info.push(`已配置模型提供商：${providers.join(', ')}`);\n      }\n\n      if (config.models.defaultModel && !config.models.defaultModel.includes('/')) {\n        result.warnings.push('defaultModel 格式可能不正确（应为 provider/model-name）');\n      }\n    }\n\n    // 检查 gateway 配置\n    if (config.gateway) {\n      if (config.gateway.port) {\n        if (config.gateway.port < 1024 || config.gateway.port > 65535) {\n          result.valid = false;\n          result.errors.push(`无效的端口号：${config.gateway.port}`);\n        } else {\n          result.info.push(`Gateway 端口：${config.gateway.port}`);\n        }\n      }\n\n      if (config.gateway.host) {\n        result.info.push(`Gateway 主机：${config.gateway.host}`);\n      }\n    }\n\n    // 检查 plugins 配置\n    if (config.plugins && config.plugins.entries) {\n      const pluginEntries = Object.entries(config.plugins.entries);\n      const enabledPlugins = pluginEntries\n        .filter(([_, plugin]: [string, any]) => plugin.enabled)\n        .map(([name, _]) => name);\n      \n      if (enabledPlugins.length > 0) {\n        result.info.push(`已启用插件：${enabledPlugins.join(', ')}`);\n      }\n\n      pluginEntries.forEach(([name, plugin]: [string, any]) => {\n        if (plugin.enabled && !plugin.config) {\n          result.warnings.push(`插件 ${name} 已启用但缺少配置`);\n        }\n      });\n    }\n\n    return result;\n  }\n\n  validate(configPath?: string): ValidationResult {\n    const pathToValidate = configPath || this.configPath;\n    const result: ValidationResult = { valid: true, errors: [], warnings: [], info: [] };\n\n    // 检查文件存在\n    if (!fs.existsSync(pathToValidate)) {\n      result.valid = false;\n      result.errors.push(`配置文件不存在：${pathToValidate}`);\n      return result;\n    }\n\n    // 检查 JSON 格式\n    let config: any;\n    try {\n      const content = fs.readFileSync(pathToValidate, 'utf8');\n      config = JSON.parse(content);\n      result.info.push(`配置文件大小：${(content.length / 1024).toFixed(2)} KB`);\n    } catch (e: any) {\n      result.valid = false;\n      result.errors.push(`JSON 格式错误：${e.message}`);\n      return result;\n    }\n\n    // 检查必填字段\n    const requiredFields = ['models', 'plugins', 'gateway'];\n    requiredFields.forEach(field => {\n      if (!config[field]) {\n        result.valid = false;\n        result.errors.push(`缺少必填字段：${field}`);\n      }\n    });\n\n    // 检查 models 配置\n    if (config.models) {\n      if (!config.models.providers || Object.keys(config.models.providers).length === 0) {\n        result.warnings.push('未配置任何模型提供商');\n      } else {\n        const providers = Object.keys(config.models.providers);\n        result.info.push(`已配置模型提供商：${providers.join(', ')}`);\n      }\n\n      if (config.models.defaultModel && !config.models.defaultModel.includes('/')) {\n        result.warnings.push('defaultModel 格式可能不正确（应为 provider/model-name）');\n      }\n    }\n\n    // 检查 gateway 配置\n    if (config.gateway) {\n      if (config.gateway.port) {\n        if (config.gateway.port < 1024 || config.gateway.port > 65535) {\n          result.valid = false;\n          result.errors.push(`无效的端口号：${config.gateway.port}`);\n        } else {\n          result.info.push(`Gateway 端口：${config.gateway.port}`);\n        }\n      }\n\n      if (config.gateway.host) {\n        result.info.push(`Gateway 主机：${config.gateway.host}`);\n      }\n    }\n\n    // 检查 plugins 配置\n    if (config.plugins && config.plugins.entries) {\n      const pluginEntries = Object.entries(config.plugins.entries);\n      const enabledPlugins = pluginEntries\n        .filter(([_, plugin]: [string, any]) => plugin.enabled)\n        .map(([name, _]) => name);\n      \n      if (enabledPlugins.length > 0) {\n        result.info.push(`已启用插件：${enabledPlugins.join(', ')}`);\n      }\n\n      pluginEntries.forEach(([name, plugin]: [string, any]) => {\n        if (plugin.enabled && !plugin.config) {\n          result.warnings.push(`插件 ${name} 已启用但缺少配置`);\n        }\n      });\n    }\n\n    // 检查记忆配置\n    if (config.memory) {\n      if (config.memory.maxSummaryDays) {\n        result.info.push(`记忆摘要天数：${config.memory.maxSummaryDays}`);\n      }\n    }\n\n    return result;\n  }\n\n  validateAndThrow(configPath?: string): void {\n    const result = this.validate(configPath);\n    if (!result.valid) {\n      throw new Error(`配置验证失败:\\n${result.errors.join('\\n')}`);\n    }\n  }\n\n  /**\n   * 比较两个配置的差异\n   */\n  diffConfigs(oldConfigPath: string, newConfigPath: string): Array<{\n    field: string;\n    oldValue: any;\n    newValue: any;\n  }> {\n    const changes: Array<{ field: string; oldValue: any; newValue: any }> = [];\n\n    try {\n      const oldConfig = JSON.parse(fs.readFileSync(oldConfigPath, 'utf8'));\n      const newConfig = JSON.parse(fs.readFileSync(newConfigPath, 'utf8'));\n\n      const compare = (oldObj: any, newObj: any, path: string = ''): void => {\n        const allKeys = new Set([...Object.keys(oldObj || {}), ...Object.keys(newObj || {})]);\n        \n        for (const key of allKeys) {\n          const fullPath = path ? `${path}.${key}` : key;\n          const oldVal = oldObj?.[key];\n          const newVal = newObj?.[key];\n\n          if (typeof oldVal === 'object' && typeof newVal === 'object' && \n              oldVal !== null && newVal !== null && \n              !Array.isArray(oldVal) && !Array.isArray(newVal)) {\n            compare(oldVal, newVal, fullPath);\n          } else if (JSON.stringify(oldVal) !== JSON.stringify(newVal)) {\n            changes.push({\n              field: fullPath,\n              oldValue: oldVal,\n              newValue: newVal,\n            });\n          }\n        }\n      };\n\n      compare(oldConfig, newConfig);\n    } catch (error) {\n      // 忽略错误\n    }\n\n    return changes;\n  }\n}\n"]}

package/dist/core/validators/index.d.ts

@@ -0,0 +1,2 @@
+export { ConfigValidator } from './config-validator';
+export type { ValidationResult } from './config-validator';

package/dist/core/validators/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigValidator = void 0;
+// src/validators/index.ts
+var config_validator_1 = require("./config-validator");
+Object.defineProperty(exports, "ConfigValidator", { enumerable: true, get: function () { return config_validator_1.ConfigValidator; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29yZS92YWxpZGF0b3JzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDBCQUEwQjtBQUMxQix1REFBcUQ7QUFBNUMsbUhBQUEsZUFBZSxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gc3JjL3ZhbGlkYXRvcnMvaW5kZXgudHNcbmV4cG9ydCB7IENvbmZpZ1ZhbGlkYXRvciB9IGZyb20gJy4vY29uZmlnLXZhbGlkYXRvcic7XG5leHBvcnQgdHlwZSB7IFZhbGlkYXRpb25SZXN1bHQgfSBmcm9tICcuL2NvbmZpZy12YWxpZGF0b3InO1xuIl19

package/dist/file-watcher.d.ts

@@ -0,0 +1,37 @@
+import type { HarnessPlugin } from './index.js';
+export interface FileWatcherConfig {
+    watchFiles: string[];
+    debounceMs: number;
+    onFileChange: (filePath: string, newContent: any) => Promise<void>;
+}
+export declare class FileWatcher {
+    private watchPaths;
+    private debounceTimers;
+    private config;
+    private plugin;
+    constructor(plugin: HarnessPlugin, config: FileWatcherConfig);
+    /**
+     * 开始监听文件
+     */
+    start(): void;
+    /**
+     * 监听单个文件
+     */
+    private watchFile;
+    /**
+     * 停止监听单个文件
+     */
+    private unwatchFile;
+    /**
+     * 文件变化处理（带防抖）
+     */
+    private onFileChange;
+    /**
+     * 处理文件变化
+     */
+    private handleFileChange;
+    /**
+     * 停止所有监听
+     */
+    stop(): void;
+}

package/dist/file-watcher.js

@@ -0,0 +1,151 @@
+"use strict";
+// src/file-watcher.ts - 配置文件监听器
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileWatcher = void 0;
+const fs = __importStar(require("fs"));
+class FileWatcher {
+    watchPaths = new Map();
+    debounceTimers = new Map();
+    config;
+    plugin;
+    constructor(plugin, config) {
+        this.plugin = plugin;
+        this.config = config;
+    }
+    /**
+     * 开始监听文件
+     */
+    start() {
+        console.log('👁️ [FileWatcher] 开始监听配置文件...');
+        for (const file of this.config.watchFiles) {
+            this.watchFile(file);
+        }
+        console.log(`👁️ [FileWatcher] 正在监听 ${this.config.watchFiles.length} 个文件`);
+    }
+    /**
+     * 监听单个文件
+     */
+    watchFile(filePath) {
+        // 如果已经在监听，先停止
+        if (this.watchPaths.has(filePath)) {
+            this.unwatchFile(filePath);
+        }
+        try {
+            const watcher = fs.watch(filePath, { persistent: false }, (eventType, filename) => {
+                if (eventType === 'change' || eventType === 'rename') {
+                    console.log(`📝 [FileWatcher] 检测到文件变化：${filePath} (${eventType})`);
+                    this.onFileChange(filePath);
+                }
+            });
+            watcher.on('error', (error) => {
+                console.error(`❌ [FileWatcher] 监听错误 ${filePath}:`, error.message);
+            });
+            this.watchPaths.set(filePath, watcher);
+            console.log(`✅ [FileWatcher] 开始监听：${filePath}`);
+        }
+        catch (error) {
+            console.warn(`⚠️ [FileWatcher] 无法监听文件 ${filePath}: ${error.message}`);
+        }
+    }
+    /**
+     * 停止监听单个文件
+     */
+    unwatchFile(filePath) {
+        const watcher = this.watchPaths.get(filePath);
+        if (watcher) {
+            watcher.close();
+            this.watchPaths.delete(filePath);
+            console.log(`🛑 [FileWatcher] 停止监听：${filePath}`);
+        }
+    }
+    /**
+     * 文件变化处理（带防抖）
+     */
+    async onFileChange(filePath) {
+        // 清除之前的定时器
+        const existingTimer = this.debounceTimers.get(filePath);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+        }
+        // 设置新的防抖定时器
+        const timer = setTimeout(async () => {
+            try {
+                await this.handleFileChange(filePath);
+            }
+            catch (error) {
+                console.error(`❌ [FileWatcher] 处理文件变化失败 ${filePath}:`, error.message);
+            }
+            this.debounceTimers.delete(filePath);
+        }, this.config.debounceMs);
+        this.debounceTimers.set(filePath, timer);
+    }
+    /**
+     * 处理文件变化
+     */
+    async handleFileChange(filePath) {
+        console.log(`🔍 [FileWatcher] 处理文件变化：${filePath}`);
+        // 读取新配置
+        let newConfig;
+        try {
+            const content = fs.readFileSync(filePath, 'utf8');
+            newConfig = JSON.parse(content);
+        }
+        catch (error) {
+            console.error(`❌ [FileWatcher] 读取配置失败：${error.message}`);
+            return;
+        }
+        // 调用插件的配置变更处理
+        await this.config.onFileChange(filePath, newConfig);
+    }
+    /**
+     * 停止所有监听
+     */
+    stop() {
+        console.log('🛑 [FileWatcher] 停止所有文件监听...');
+        for (const [filePath, watcher] of this.watchPaths.entries()) {
+            watcher.close();
+        }
+        this.watchPaths.clear();
+        // 清除所有定时器
+        for (const [filePath, timer] of this.debounceTimers.entries()) {
+            clearTimeout(timer);
+        }
+        this.debounceTimers.clear();
+        console.log('🛑 [FileWatcher] 已停止所有监听');
+    }
+}
+exports.FileWatcher = FileWatcher;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-watcher.js","sourceRoot":"","sources":["../src/file-watcher.ts"],"names":[],"mappings":"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","sourcesContent":["// src/file-watcher.ts - 配置文件监听器\n\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport type { HarnessPlugin } from './index.js';\n\nexport interface FileWatcherConfig {\n  watchFiles: string[];\n  debounceMs: number;\n  onFileChange: (filePath: string, newContent: any) => Promise<void>;\n}\n\nexport class FileWatcher {\n  private watchPaths: Map<string, fs.FSWatcher> = new Map();\n  private debounceTimers: Map<string, NodeJS.Timeout> = new Map();\n  private config: FileWatcherConfig;\n  private plugin: HarnessPlugin;\n\n  constructor(plugin: HarnessPlugin, config: FileWatcherConfig) {\n    this.plugin = plugin;\n    this.config = config;\n  }\n\n  /**\n   * 开始监听文件\n   */\n  start(): void {\n    console.log('👁️ [FileWatcher] 开始监听配置文件...');\n    \n    for (const file of this.config.watchFiles) {\n      this.watchFile(file);\n    }\n    \n    console.log(`👁️ [FileWatcher] 正在监听 ${this.config.watchFiles.length} 个文件`);\n  }\n\n  /**\n   * 监听单个文件\n   */\n  private watchFile(filePath: string): void {\n    // 如果已经在监听，先停止\n    if (this.watchPaths.has(filePath)) {\n      this.unwatchFile(filePath);\n    }\n\n    try {\n      const watcher = fs.watch(filePath, { persistent: false }, (eventType, filename) => {\n        if (eventType === 'change' || eventType === 'rename') {\n          console.log(`📝 [FileWatcher] 检测到文件变化：${filePath} (${eventType})`);\n          this.onFileChange(filePath);\n        }\n      });\n\n      watcher.on('error', (error) => {\n        console.error(`❌ [FileWatcher] 监听错误 ${filePath}:`, error.message);\n      });\n\n      this.watchPaths.set(filePath, watcher);\n      console.log(`✅ [FileWatcher] 开始监听：${filePath}`);\n    } catch (error: any) {\n      console.warn(`⚠️ [FileWatcher] 无法监听文件 ${filePath}: ${error.message}`);\n    }\n  }\n\n  /**\n   * 停止监听单个文件\n   */\n  private unwatchFile(filePath: string): void {\n    const watcher = this.watchPaths.get(filePath);\n    if (watcher) {\n      watcher.close();\n      this.watchPaths.delete(filePath);\n      console.log(`🛑 [FileWatcher] 停止监听：${filePath}`);\n    }\n  }\n\n  /**\n   * 文件变化处理（带防抖）\n   */\n  private async onFileChange(filePath: string): Promise<void> {\n    // 清除之前的定时器\n    const existingTimer = this.debounceTimers.get(filePath);\n    if (existingTimer) {\n      clearTimeout(existingTimer);\n    }\n\n    // 设置新的防抖定时器\n    const timer = setTimeout(async () => {\n      try {\n        await this.handleFileChange(filePath);\n      } catch (error: any) {\n        console.error(`❌ [FileWatcher] 处理文件变化失败 ${filePath}:`, error.message);\n      }\n      this.debounceTimers.delete(filePath);\n    }, this.config.debounceMs);\n\n    this.debounceTimers.set(filePath, timer);\n  }\n\n  /**\n   * 处理文件变化\n   */\n  private async handleFileChange(filePath: string): Promise<void> {\n    console.log(`🔍 [FileWatcher] 处理文件变化：${filePath}`);\n\n    // 读取新配置\n    let newConfig: any;\n    try {\n      const content = fs.readFileSync(filePath, 'utf8');\n      newConfig = JSON.parse(content);\n    } catch (error: any) {\n      console.error(`❌ [FileWatcher] 读取配置失败：${error.message}`);\n      return;\n    }\n\n    // 调用插件的配置变更处理\n    await this.config.onFileChange(filePath, newConfig);\n  }\n\n  /**\n   * 停止所有监听\n   */\n  stop(): void {\n    console.log('🛑 [FileWatcher] 停止所有文件监听...');\n    \n    for (const [filePath, watcher] of this.watchPaths.entries()) {\n      watcher.close();\n    }\n    \n    this.watchPaths.clear();\n    \n    // 清除所有定时器\n    for (const [filePath, timer] of this.debounceTimers.entries()) {\n      clearTimeout(timer);\n    }\n    \n    this.debounceTimers.clear();\n    console.log('🛑 [FileWatcher] 已停止所有监听');\n  }\n}\n"]}

package/dist/index.d.ts

@@ -5,3 +5,66 @@ export interface HarnessPluginConfig {
     protectedFiles: string[];
     logsDir: string;
 }
+export declare class HarnessPlugin {
+    name: string;
+    version: string;
+    private config;
+    private workspacePath;
+    private configValidator;
+    private skillAuditor;
+    private loopDetector;
+    private configLogger;
+    private operationLogger;
+    private traceLogger;
+    constructor(workspacePath: string, config?: Partial<HarnessPluginConfig>);
+    /**
+     * Hook: 配置修改前验证
+     */
+    onConfigChange(newConfig: any, sessionId?: string): Promise<{
+        valid: boolean;
+        errors?: string[];
+    }>;
+    /**
+     * 公开方法：记录配置变更
+     */
+    logConfigChange(entry: {
+        sessionId: string;
+        modifier: string;
+        file: string;
+        reason: string;
+        verified: boolean;
+        gatewayRestarted: boolean;
+        changes: any[];
+    }): void;
+    /**
+     * Hook: Skill 安装前审核
+     */
+    onSkillInstall(skillPath: string, source?: string, sessionId?: string): Promise<{
+        passed: boolean;
+        warnings?: any[];
+    }>;
+    /**
+     * Hook: 文件编辑时循环检测
+     */
+    onFileEdit(filePath: string, sessionId?: string): {
+        allowed: boolean;
+        warning?: string;
+    };
+    /**
+     * Hook: 文件删除前检查
+     */
+    onFileDelete(filePath: string, sessionId?: string): {
+        allowed: boolean;
+        reason?: string;
+    };
+    /**
+     * Hook: 系统命令执行前
+     */
+    onExecCommand(command: string, sessionId?: string): void;
+    /**
+     * 获取插件状态
+     */
+    getStatus(): any;
+}
+export declare function createPlugin(workspacePath: string, config: any): HarnessPlugin;
+export default HarnessPlugin;