@hddz/plugin-harness 0.1.19 → 0.2.1

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
 // src/index.ts - Harness Plugin 主入口
 Object.defineProperty(exports, "__esModule", { value: true });
-const harness_1 = require("@hddz/harness");
+exports.HarnessPlugin = void 0;
+exports.createPlugin = createPlugin;
+const core_1 = require("./core");
 const DEFAULT_CONFIG = {
     autoValidateConfig: true,
     autoAuditSkill: true,
@@ -14,119 +16,177 @@ const DEFAULT_CONFIG = {
         'MEMORY.md',
         'openclaw.json',
     ],
-    logsDir: 'workspace/logs/harness',
+    logsDir: 'logs/harness', // 相对 workspace 的路径
 };
-const harnessPlugin = {
-    id: 'harness',
-    name: 'Harness Engineering',
-    description: 'Constraints, feedback loops, and control systems for AI agents',
-    kind: 'engineering',
-    configSchema: {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-            autoValidateConfig: { type: 'boolean', default: true },
-            autoAuditSkill: { type: 'boolean', default: true },
-            loopDetectionEnabled: { type: 'boolean', default: true },
-            protectedFiles: { type: 'array', items: { type: 'string' } },
-            logsDir: { type: 'string', default: 'workspace/logs/harness' },
-        },
-    },
-    register(api) {
-        const workspacePath = api.workspacePath || process.cwd();
-        const config = { ...DEFAULT_CONFIG, ...api.config };
+class HarnessPlugin {
+    name = 'harness';
+    version = '0.1.0';
+    config;
+    workspacePath;
+    configValidator;
+    skillAuditor;
+    loopDetector;
+    configLogger;
+    operationLogger;
+    traceLogger;
+    constructor(workspacePath, config = {}) {
+        this.workspacePath = workspacePath;
+        this.config = { ...DEFAULT_CONFIG, ...config };
         // 初始化工具
-        const configValidator = new harness_1.ConfigValidator(workspacePath);
-        const skillAuditor = new harness_1.SkillAuditor(workspacePath);
-        const loopDetector = new harness_1.LoopDetector(workspacePath, { limit: 5, windowMs: 300000 });
-        const configLogger = new harness_1.ConfigLogger(workspacePath);
-        const operationLogger = new harness_1.OperationLogger(workspacePath);
-        const traceLogger = new harness_1.TraceLogger(workspacePath);
-        api.logger.info('[Harness] 插件已加载，工作空间:', workspacePath);
-        // Hook: 配置修改前验证
-        if (config.autoValidateConfig) {
-            api.onConfigChange?.(async (newConfig, sessionId) => {
-                api.logger.info('🔍 [Harness] 验证配置变更...');
-                const result = configValidator.validateContent(newConfig);
-                if (!result.valid) {
-                    api.logger.error('❌ [Harness] 配置验证失败:');
-                    result.errors.forEach((e) => api.logger.error(`   - ${e}`));
-                    configLogger.log({
-                        sessionId: sessionId || 'unknown',
-                        modifier: 'AI Agent',
-                        file: 'openclaw.json',
-                        changes: [],
-                        reason: '配置修改（验证失败）',
-                        verified: false,
-                        gatewayRestarted: false,
-                    });
-                    throw new Error(`配置验证失败：${result.errors.join(', ')}`);
-                }
-                configLogger.log({
-                    sessionId: sessionId || 'unknown',
-                    modifier: 'AI Agent',
-                    file: 'openclaw.json',
-                    changes: [],
-                    reason: '配置修改',
-                    verified: true,
-                    gatewayRestarted: true,
-                });
-                api.logger.info('✅ [Harness] 配置验证通过');
-            });
-        }
-        // Hook: Skill 安装前审核
-        if (config.autoAuditSkill) {
-            api.onSkillInstall?.(async (skillPath) => {
-                api.logger.info('🔍 [Harness] 审核 Skill:', skillPath);
-                const auditResult = await skillAuditor.audit(skillPath, 'local');
-                if (!auditResult.passed) {
-                    api.logger.error('❌ [Harness] Skill 审核失败:');
-                    auditResult.warnings.forEach((w) => api.logger.error(`   - ${w.message}`));
-                    throw new Error(`Skill 审核失败：${auditResult.warnings.map((w) => w.message).join(', ')}`);
-                }
-                api.logger.info('✅ [Harness] Skill 审核通过');
-            });
+        this.configValidator = new core_1.ConfigValidator(workspacePath);
+        this.skillAuditor = new core_1.SkillAuditor(workspacePath);
+        this.loopDetector = new core_1.LoopDetector(workspacePath);
+        this.configLogger = new core_1.ConfigLogger(workspacePath);
+        this.operationLogger = new core_1.OperationLogger(workspacePath);
+        this.traceLogger = new core_1.TraceLogger(workspacePath);
+    }
+    /**
+     * Hook: 配置修改前验证
+     */
+    async onConfigChange(newConfig, sessionId) {
+        if (!this.config.autoValidateConfig) {
+            return { valid: true };
         }
-        // Hook: 文件编辑时循环检测
-        if (config.loopDetectionEnabled) {
-            api.onFileEdit?.(async (filePath, content) => {
-                const warning = loopDetector.onFileEdit(filePath);
-                if (warning) {
-                    api.logger.warn('⚠️ [Harness] 检测到频繁编辑:');
-                    api.logger.warn(`   文件：${filePath}`);
-                    api.logger.warn(`   警告：${warning}`);
-                    throw new Error(`检测到循环编辑：${warning}`);
-                }
+        console.log('🔍 [Harness] 验证配置变更...');
+        const result = this.configValidator.validateContent(newConfig);
+        if (!result.valid) {
+            console.error('❌ [Harness] 配置验证失败:');
+            result.errors.forEach(e => console.error(`   - ${e}`));
+            // 记录配置变更失败
+            this.configLogger.log({
+                sessionId: sessionId || 'unknown',
+                modifier: 'AI Agent',
+                file: 'openclaw.json',
+                reason: '配置修改（验证失败）',
+                verified: false,
+                gatewayRestarted: false,
+                changes: [],
             });
+            return { valid: false, errors: result.errors };
         }
-        // Hook: 文件删除前检查保护文件
-        api.onFileDelete?.(async (filePath) => {
-            const fileName = filePath.split('/').pop() || filePath;
-            if (config.protectedFiles.includes(fileName)) {
-                api.logger.error(`❌ [Harness] 阻止删除保护文件：${filePath}`);
-                throw new Error(`不允许删除保护文件：${fileName}`);
-            }
+        console.log('✅ [Harness] 配置验证通过');
+        // 记录配置变更成功
+        this.configLogger.log({
+            sessionId: sessionId || 'unknown',
+            modifier: 'AI Agent',
+            file: 'openclaw.json',
+            reason: '配置修改',
+            verified: true,
+            gatewayRestarted: true,
+            changes: [],
         });
-        // Hook: 命令执行审计
-        api.onExecCommand?.(async (command, options) => {
-            operationLogger.log({
-                sessionId: options?.sessionId || 'unknown',
+        return { valid: true };
+    }
+    /**
+     * 公开方法：记录配置变更
+     */
+    logConfigChange(entry) {
+        this.configLogger.log(entry);
+    }
+    /**
+     * Hook: Skill 安装前审核
+     */
+    async onSkillInstall(skillPath, source, sessionId) {
+        if (!this.config.autoAuditSkill) {
+            return { passed: true };
+        }
+        console.log(`🔍 [Harness] 审核 Skill: ${skillPath}`);
+        const result = await this.skillAuditor.audit(skillPath, source || 'unknown');
+        if (!result.passed) {
+            console.error(`❌ [Harness] Skill 审核未通过：${result.riskLevel}`);
+            result.warnings.forEach(w => console.error(`   - ${w.message}`));
+            return { passed: false, warnings: result.warnings };
+        }
+        console.log(`✅ [Harness] Skill 审核通过：${result.riskLevel}`);
+        return { passed: true };
+    }
+    /**
+     * Hook: 文件编辑时循环检测
+     */
+    onFileEdit(filePath, sessionId) {
+        if (!this.config.loopDetectionEnabled) {
+            return { allowed: true };
+        }
+        const relativePath = filePath.split('/').pop() || filePath;
+        // 检查是否是保护文件
+        if (this.config.protectedFiles.some(f => filePath.endsWith(f))) {
+            console.warn(`⚠️ [Harness] 保护文件被修改：${filePath}`);
+            // 记录保护文件修改
+            this.operationLogger.log({
+                sessionId: sessionId || 'unknown',
                 modifier: 'AI Agent',
-                type: 'system_command',
-                description: `执行命令：${command}`,
-                command,
+                type: 'file_edit',
+                description: `保护文件修改：${filePath}`,
+                file: filePath,
                 result: 'success',
             });
-            traceLogger.log({
-                sessionId: options?.sessionId || 'unknown',
-                type: 'tool_call',
-                data: { tool: 'exec', command },
+        }
+        // 循环检测
+        const warning = this.loopDetector.onFileEdit(filePath);
+        if (warning) {
+            console.warn(`⚠️ [Harness] 循环编辑警告：${warning}`);
+            return { allowed: true, warning }; // 允许但警告
+        }
+        return { allowed: true };
+    }
+    /**
+     * Hook: 文件删除前检查
+     */
+    onFileDelete(filePath, sessionId) {
+        const relativePath = filePath.split('/').pop() || filePath;
+        // 检查是否是保护文件
+        if (this.config.protectedFiles.some(f => filePath.endsWith(f))) {
+            console.error(`🚨 [Harness] 禁止删除保护文件：${filePath}`);
+            this.operationLogger.log({
+                sessionId: sessionId || 'unknown',
+                modifier: 'AI Agent',
+                type: 'file_delete',
+                description: `尝试删除保护文件：${filePath}`,
+                file: filePath,
+                result: 'error',
             });
+            return { allowed: false, reason: '保护文件禁止删除' };
+        }
+        this.operationLogger.log({
+            sessionId: sessionId || 'unknown',
+            modifier: 'AI Agent',
+            type: 'file_delete',
+            description: `删除文件：${filePath}`,
+            file: filePath,
+            result: 'success',
         });
-        api.logger.info('✅ [Harness] 所有 Hook 已注册');
-    },
-};
-// CommonJS 导出（OpenClaw 期望的格式）
-// @ts-ignore
-module.exports = harnessPlugin;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["// src/index.ts - Harness Plugin 主入口\n\nimport { ConfigValidator, SkillAuditor, LoopDetector, ConfigLogger, OperationLogger, TraceLogger } from '@hddz/harness';\n\nexport interface HarnessPluginConfig {\n  autoValidateConfig: boolean;\n  autoAuditSkill: boolean;\n  loopDetectionEnabled: boolean;\n  protectedFiles: string[];\n  logsDir: string;\n}\n\nconst DEFAULT_CONFIG: HarnessPluginConfig = {\n  autoValidateConfig: true,\n  autoAuditSkill: true,\n  loopDetectionEnabled: true,\n  protectedFiles: [\n    'SOUL.md',\n    'USER.md',\n    'AGENTS.md',\n    'TOOLS.md',\n    'MEMORY.md',\n    'openclaw.json',\n  ],\n  logsDir: 'workspace/logs/harness',\n};\n\nconst harnessPlugin = {\n  id: 'harness',\n  name: 'Harness Engineering',\n  description: 'Constraints, feedback loops, and control systems for AI agents',\n  kind: 'engineering',\n  configSchema: {\n    type: 'object' as const,\n    additionalProperties: false,\n    properties: {\n      autoValidateConfig: { type: 'boolean' as const, default: true },\n      autoAuditSkill: { type: 'boolean' as const, default: true },\n      loopDetectionEnabled: { type: 'boolean' as const, default: true },\n      protectedFiles: { type: 'array' as const, items: { type: 'string' as const } },\n      logsDir: { type: 'string' as const, default: 'workspace/logs/harness' },\n    },\n  },\n  register(api: any) {\n    const workspacePath = api.workspacePath || process.cwd();\n    const config: HarnessPluginConfig = { ...DEFAULT_CONFIG, ...api.config };\n    \n    // 初始化工具\n    const configValidator = new ConfigValidator(workspacePath);\n    const skillAuditor = new SkillAuditor(workspacePath);\n    const loopDetector = new LoopDetector(workspacePath, { limit: 5, windowMs: 300000 });\n    const configLogger = new ConfigLogger(workspacePath);\n    const operationLogger = new OperationLogger(workspacePath);\n    const traceLogger = new TraceLogger(workspacePath);\n\n    api.logger.info('[Harness] 插件已加载，工作空间:', workspacePath);\n\n    // Hook: 配置修改前验证\n    if (config.autoValidateConfig) {\n      api.onConfigChange?.(async (newConfig: any, sessionId?: string) => {\n        api.logger.info('🔍 [Harness] 验证配置变更...');\n        \n        const result = configValidator.validateContent(newConfig);\n        \n        if (!result.valid) {\n          api.logger.error('❌ [Harness] 配置验证失败:');\n          result.errors.forEach((e: string) => api.logger.error(`   - ${e}`));\n          \n          configLogger.log({\n            sessionId: sessionId || 'unknown',\n            modifier: 'AI Agent',\n            file: 'openclaw.json',\n            changes: [],\n            reason: '配置修改（验证失败）',\n            verified: false,\n            gatewayRestarted: false,\n          });\n          \n          throw new Error(`配置验证失败：${result.errors.join(', ')}`);\n        }\n        \n        configLogger.log({\n          sessionId: sessionId || 'unknown',\n          modifier: 'AI Agent',\n          file: 'openclaw.json',\n          changes: [],\n          reason: '配置修改',\n          verified: true,\n          gatewayRestarted: true,\n        });\n        \n        api.logger.info('✅ [Harness] 配置验证通过');\n      });\n    }\n\n    // Hook: Skill 安装前审核\n    if (config.autoAuditSkill) {\n      api.onSkillInstall?.(async (skillPath: string) => {\n        api.logger.info('🔍 [Harness] 审核 Skill:', skillPath);\n        \n        const auditResult = await skillAuditor.audit(skillPath, 'local');\n        \n        if (!auditResult.passed) {\n          api.logger.error('❌ [Harness] Skill 审核失败:');\n          auditResult.warnings.forEach((w: any) => api.logger.error(`   - ${w.message}`));\n          throw new Error(`Skill 审核失败：${auditResult.warnings.map((w: any) => w.message).join(', ')}`);\n        }\n        \n        api.logger.info('✅ [Harness] Skill 审核通过');\n      });\n    }\n\n    // Hook: 文件编辑时循环检测\n    if (config.loopDetectionEnabled) {\n      api.onFileEdit?.(async (filePath: string, content: string) => {\n        const warning = loopDetector.onFileEdit(filePath);\n        \n        if (warning) {\n          api.logger.warn('⚠️ [Harness] 检测到频繁编辑:');\n          api.logger.warn(`   文件：${filePath}`);\n          api.logger.warn(`   警告：${warning}`);\n          throw new Error(`检测到循环编辑：${warning}`);\n        }\n      });\n    }\n\n    // Hook: 文件删除前检查保护文件\n    api.onFileDelete?.(async (filePath: string) => {\n      const fileName = filePath.split('/').pop() || filePath;\n      \n      if (config.protectedFiles.includes(fileName)) {\n        api.logger.error(`❌ [Harness] 阻止删除保护文件：${filePath}`);\n        throw new Error(`不允许删除保护文件：${fileName}`);\n      }\n    });\n\n    // Hook: 命令执行审计\n    api.onExecCommand?.(async (command: string, options?: any) => {\n      operationLogger.log({\n        sessionId: options?.sessionId || 'unknown',\n        modifier: 'AI Agent',\n        type: 'system_command',\n        description: `执行命令：${command}`,\n        command,\n        result: 'success',\n      });\n      \n      traceLogger.log({\n        sessionId: options?.sessionId || 'unknown',\n        type: 'tool_call',\n        data: { tool: 'exec', command },\n      });\n    });\n\n    api.logger.info('✅ [Harness] 所有 Hook 已注册');\n  },\n};\n\n// CommonJS 导出（OpenClaw 期望的格式）\n// @ts-ignore\nmodule.exports = harnessPlugin;\n"]}
+        return { allowed: true };
+    }
+    /**
+     * Hook: 系统命令执行前
+     */
+    onExecCommand(command, sessionId) {
+        this.operationLogger.log({
+            sessionId: sessionId || 'unknown',
+            modifier: 'AI Agent',
+            type: 'system_command',
+            description: `执行命令：${command}`,
+            command,
+            result: 'pending',
+        });
+    }
+    /**
+     * 获取插件状态
+     */
+    getStatus() {
+        return {
+            name: this.name,
+            version: this.version,
+            enabled: true,
+            config: this.config,
+            loopStats: this.loopDetector.getStats(),
+        };
+    }
+}
+exports.HarnessPlugin = HarnessPlugin;
+// OpenClaw 插件工厂函数
+function createPlugin(workspacePath, config) {
+    return new HarnessPlugin(workspacePath, config);
+}
+exports.default = HarnessPlugin;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["// src/index.ts - Harness Plugin 主入口\n\nimport { ConfigValidator, SkillAuditor, LoopDetector, ConfigLogger, OperationLogger, TraceLogger } from './core';\n\nexport interface HarnessPluginConfig {\n  autoValidateConfig: boolean;\n  autoAuditSkill: boolean;\n  loopDetectionEnabled: boolean;\n  protectedFiles: string[];\n  logsDir: string;\n}\n\nconst DEFAULT_CONFIG: HarnessPluginConfig = {\n  autoValidateConfig: true,\n  autoAuditSkill: true,\n  loopDetectionEnabled: true,\n  protectedFiles: [\n    'SOUL.md',\n    'USER.md',\n    'AGENTS.md',\n    'TOOLS.md',\n    'MEMORY.md',\n    'openclaw.json',\n  ],\n  logsDir: 'logs/harness',  // 相对 workspace 的路径\n};\n\nexport class HarnessPlugin {\n  name = 'harness';\n  version = '0.1.0';\n  \n  private config: HarnessPluginConfig;\n  private workspacePath: string;\n  private configValidator: ConfigValidator;\n  private skillAuditor: SkillAuditor;\n  private loopDetector: LoopDetector;\n  private configLogger: ConfigLogger;\n  private operationLogger: OperationLogger;\n  private traceLogger: TraceLogger;\n\n  constructor(workspacePath: string, config: Partial<HarnessPluginConfig> = {}) {\n    this.workspacePath = workspacePath;\n    this.config = { ...DEFAULT_CONFIG, ...config };\n    \n    // 初始化工具\n    this.configValidator = new ConfigValidator(workspacePath);\n    this.skillAuditor = new SkillAuditor(workspacePath);\n    this.loopDetector = new LoopDetector(workspacePath);\n    this.configLogger = new ConfigLogger(workspacePath);\n    this.operationLogger = new OperationLogger(workspacePath);\n    this.traceLogger = new TraceLogger(workspacePath);\n  }\n\n  /**\n   * Hook: 配置修改前验证\n   */\n  async onConfigChange(newConfig: any, sessionId?: string): Promise<{ valid: boolean; errors?: string[] }> {\n    if (!this.config.autoValidateConfig) {\n      return { valid: true };\n    }\n\n    console.log('🔍 [Harness] 验证配置变更...');\n    \n    const result = this.configValidator.validateContent(newConfig);\n    \n    if (!result.valid) {\n      console.error('❌ [Harness] 配置验证失败:');\n      result.errors.forEach(e => console.error(`   - ${e}`));\n      \n      // 记录配置变更失败\n      this.configLogger.log({\n        sessionId: sessionId || 'unknown',\n        modifier: 'AI Agent',\n        file: 'openclaw.json',\n        reason: '配置修改（验证失败）',\n        verified: false,\n        gatewayRestarted: false,\n        changes: [],\n      });\n      \n      return { valid: false, errors: result.errors };\n    }\n    \n    console.log('✅ [Harness] 配置验证通过');\n    \n    // 记录配置变更成功\n    this.configLogger.log({\n      sessionId: sessionId || 'unknown',\n      modifier: 'AI Agent',\n      file: 'openclaw.json',\n      reason: '配置修改',\n      verified: true,\n      gatewayRestarted: true,\n      changes: [],\n    });\n    \n    return { valid: true };\n  }\n\n  /**\n   * 公开方法：记录配置变更\n   */\n  logConfigChange(entry: {\n    sessionId: string;\n    modifier: string;\n    file: string;\n    reason: string;\n    verified: boolean;\n    gatewayRestarted: boolean;\n    changes: any[];\n  }) {\n    this.configLogger.log(entry);\n  }\n\n  /**\n   * Hook: Skill 安装前审核\n   */\n  async onSkillInstall(skillPath: string, source?: string, sessionId?: string): Promise<{ passed: boolean; warnings?: any[] }> {\n    if (!this.config.autoAuditSkill) {\n      return { passed: true };\n    }\n\n    console.log(`🔍 [Harness] 审核 Skill: ${skillPath}`);\n    \n    const result = await this.skillAuditor.audit(skillPath, source || 'unknown');\n    \n    if (!result.passed) {\n      console.error(`❌ [Harness] Skill 审核未通过：${result.riskLevel}`);\n      result.warnings.forEach(w => console.error(`   - ${w.message}`));\n      \n      return { passed: false, warnings: result.warnings };\n    }\n    \n    console.log(`✅ [Harness] Skill 审核通过：${result.riskLevel}`);\n    return { passed: true };\n  }\n\n  /**\n   * Hook: 文件编辑时循环检测\n   */\n  onFileEdit(filePath: string, sessionId?: string): { allowed: boolean; warning?: string } {\n    if (!this.config.loopDetectionEnabled) {\n      return { allowed: true };\n    }\n\n    const relativePath = filePath.split('/').pop() || filePath;\n    \n    // 检查是否是保护文件\n    if (this.config.protectedFiles.some(f => filePath.endsWith(f))) {\n      console.warn(`⚠️ [Harness] 保护文件被修改：${filePath}`);\n      // 记录保护文件修改\n      this.operationLogger.log({\n        sessionId: sessionId || 'unknown',\n        modifier: 'AI Agent',\n        type: 'file_edit',\n        description: `保护文件修改：${filePath}`,\n        file: filePath,\n        result: 'success',\n      });\n    }\n    \n    // 循环检测\n    const warning = this.loopDetector.onFileEdit(filePath);\n    \n    if (warning) {\n      console.warn(`⚠️ [Harness] 循环编辑警告：${warning}`);\n      return { allowed: true, warning }; // 允许但警告\n    }\n    \n    return { allowed: true };\n  }\n\n  /**\n   * Hook: 文件删除前检查\n   */\n  onFileDelete(filePath: string, sessionId?: string): { allowed: boolean; reason?: string } {\n    const relativePath = filePath.split('/').pop() || filePath;\n    \n    // 检查是否是保护文件\n    if (this.config.protectedFiles.some(f => filePath.endsWith(f))) {\n      console.error(`🚨 [Harness] 禁止删除保护文件：${filePath}`);\n      \n      this.operationLogger.log({\n        sessionId: sessionId || 'unknown',\n        modifier: 'AI Agent',\n        type: 'file_delete',\n        description: `尝试删除保护文件：${filePath}`,\n        file: filePath,\n        result: 'error',\n      });\n      \n      return { allowed: false, reason: '保护文件禁止删除' };\n    }\n    \n    this.operationLogger.log({\n      sessionId: sessionId || 'unknown',\n      modifier: 'AI Agent',\n      type: 'file_delete',\n      description: `删除文件：${filePath}`,\n      file: filePath,\n      result: 'success',\n    });\n    \n    return { allowed: true };\n  }\n\n  /**\n   * Hook: 系统命令执行前\n   */\n  onExecCommand(command: string, sessionId?: string): void {\n    this.operationLogger.log({\n      sessionId: sessionId || 'unknown',\n      modifier: 'AI Agent',\n      type: 'system_command',\n      description: `执行命令：${command}`,\n      command,\n      result: 'pending',\n    });\n  }\n\n  /**\n   * 获取插件状态\n   */\n  getStatus(): any {\n    return {\n      name: this.name,\n      version: this.version,\n      enabled: true,\n      config: this.config,\n      loopStats: this.loopDetector.getStats(),\n    };\n  }\n}\n\n// OpenClaw 插件工厂函数\nexport function createPlugin(workspacePath: string, config: any): HarnessPlugin {\n  return new HarnessPlugin(workspacePath, config);\n}\n\nexport default HarnessPlugin;\n"]}

package/dist/src/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/src/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/src/index.d.ts

@@ -0,0 +1,70 @@
+export interface HarnessPluginConfig {
+    autoValidateConfig: boolean;
+    autoAuditSkill: boolean;
+    loopDetectionEnabled: boolean;
+    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;