@hddz/plugin-harness 0.1.13 → 0.1.14

package/dist/index.d.ts

@@ -5,8 +5,39 @@ export interface HarnessPluginConfig {
     protectedFiles: string[];
     logsDir: string;
 }
-export default function (api: any): {
+declare const harnessPlugin: {
+    id: string;
     name: string;
-    version: string;
-    config: HarnessPluginConfig;
+    description: string;
+    kind: string;
+    configSchema: {
+        type: "object";
+        additionalProperties: boolean;
+        properties: {
+            autoValidateConfig: {
+                type: "boolean";
+                default: boolean;
+            };
+            autoAuditSkill: {
+                type: "boolean";
+                default: boolean;
+            };
+            loopDetectionEnabled: {
+                type: "boolean";
+                default: boolean;
+            };
+            protectedFiles: {
+                type: "array";
+                items: {
+                    type: "string";
+                };
+            };
+            logsDir: {
+                type: "string";
+                default: string;
+            };
+        };
+    };
+    register(api: any): void;
 };
+export default harnessPlugin;

package/dist/index.js

@@ -1,7 +1,6 @@
 "use strict";
 // src/index.ts - Harness Plugin 主入口
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
 const harness_1 = require("@hddz/harness");
 const DEFAULT_CONFIG = {
     autoValidateConfig: true,
@@ -15,105 +14,117 @@ const DEFAULT_CONFIG = {
         'MEMORY.md',
         'openclaw.json',
     ],
-    logsDir: 'logs/harness',
+    logsDir: 'workspace/logs/harness',
 };
-// OpenClaw 插件入口函数
-function default_1(api) {
-    const workspacePath = api.workspacePath || process.cwd();
-    const config = { ...DEFAULT_CONFIG, ...api.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.log('[Harness] 插件已加载，工作空间:', workspacePath);
-    // Hook: 配置修改前验证
-    if (config.autoValidateConfig) {
-        api.onConfigChange?.(async (newConfig, sessionId) => {
-            api.log('🔍 [Harness] 验证配置变更...');
-            const result = configValidator.validateContent(newConfig);
-            if (!result.valid) {
-                api.log('❌ [Harness] 配置验证失败:');
-                result.errors.forEach((e) => api.log(`   - ${e}`));
+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 };
+        // 初始化工具
+        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.log('[Harness] 插件已加载，工作空间:', workspacePath);
+        // Hook: 配置修改前验证
+        if (config.autoValidateConfig) {
+            api.onConfigChange?.(async (newConfig, sessionId) => {
+                api.log('🔍 [Harness] 验证配置变更...');
+                const result = configValidator.validateContent(newConfig);
+                if (!result.valid) {
+                    api.log('❌ [Harness] 配置验证失败:');
+                    result.errors.forEach((e) => api.log(`   - ${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: false,
-                    gatewayRestarted: false,
+                    reason: '配置修改',
+                    verified: true,
+                    gatewayRestarted: true,
                 });
-                throw new Error(`配置验证失败：${result.errors.join(', ')}`);
-            }
-            configLogger.log({
-                sessionId: sessionId || 'unknown',
-                modifier: 'AI Agent',
-                file: 'openclaw.json',
-                changes: [],
-                reason: '配置修改',
-                verified: true,
-                gatewayRestarted: true,
+                api.log('✅ [Harness] 配置验证通过');
+            });
+        }
+        // Hook: Skill 安装前审核
+        if (config.autoAuditSkill) {
+            api.onSkillInstall?.(async (skillPath) => {
+                api.log('🔍 [Harness] 审核 Skill:', skillPath);
+                const auditResult = await skillAuditor.audit(skillPath, 'local');
+                if (!auditResult.passed) {
+                    api.log('❌ [Harness] Skill 审核失败:');
+                    auditResult.warnings.forEach((w) => api.log(`   - ${w.message}`));
+                    throw new Error(`Skill 审核失败：${auditResult.warnings.map((w) => w.message).join(', ')}`);
+                }
+                api.log('✅ [Harness] Skill 审核通过');
+            });
+        }
+        // Hook: 文件编辑时循环检测
+        if (config.loopDetectionEnabled) {
+            api.onFileEdit?.(async (filePath, content) => {
+                const warning = loopDetector.onFileEdit(filePath);
+                if (warning) {
+                    api.log('⚠️ [Harness] 检测到频繁编辑:');
+                    api.log(`   文件：${filePath}`);
+                    api.log(`   警告：${warning}`);
+                    throw new Error(`检测到循环编辑：${warning}`);
+                }
             });
-            api.log('✅ [Harness] 配置验证通过');
-        });
-    }
-    // Hook: Skill 安装前审核
-    if (config.autoAuditSkill) {
-        api.onSkillInstall?.(async (skillPath) => {
-            api.log('🔍 [Harness] 审核 Skill:', skillPath);
-            const auditResult = await skillAuditor.audit(skillPath, 'local');
-            if (!auditResult.passed) {
-                api.log('❌ [Harness] Skill 审核失败:');
-                auditResult.warnings.forEach((w) => api.log(`   - ${w.message}`));
-                throw new Error(`Skill 审核失败：${auditResult.warnings.map((w) => w.message).join(', ')}`);
-            }
-            api.log('✅ [Harness] Skill 审核通过');
-        });
-    }
-    // Hook: 文件编辑时循环检测
-    if (config.loopDetectionEnabled) {
-        api.onFileEdit?.(async (filePath, content) => {
-            const warning = loopDetector.onFileEdit(filePath);
-            if (warning) {
-                api.log('⚠️ [Harness] 检测到频繁编辑:');
-                api.log(`   文件：${filePath}`);
-                api.log(`   警告：${warning}`);
-                throw new Error(`检测到循环编辑：${warning}`);
-            }
-        });
-    }
-    // Hook: 文件删除前检查保护文件
-    api.onFileDelete?.(async (filePath) => {
-        const fileName = filePath.split('/').pop() || filePath;
-        if (config.protectedFiles.includes(fileName)) {
-            api.log(`❌ [Harness] 阻止删除保护文件：${filePath}`);
-            throw new Error(`不允许删除保护文件：${fileName}`);
         }
-    });
-    // Hook: 命令执行审计
-    api.onExecCommand?.(async (command, options) => {
-        operationLogger.log({
-            sessionId: options?.sessionId || 'unknown',
-            modifier: 'AI Agent',
-            type: 'system_command',
-            description: `执行命令：${command}`,
-            command,
-            result: 'success',
+        // Hook: 文件删除前检查保护文件
+        api.onFileDelete?.(async (filePath) => {
+            const fileName = filePath.split('/').pop() || filePath;
+            if (config.protectedFiles.includes(fileName)) {
+                api.log(`❌ [Harness] 阻止删除保护文件：${filePath}`);
+                throw new Error(`不允许删除保护文件：${fileName}`);
+            }
         });
-        traceLogger.log({
-            sessionId: options?.sessionId || 'unknown',
-            type: 'tool_call',
-            data: { tool: 'exec', command },
+        // Hook: 命令执行审计
+        api.onExecCommand?.(async (command, options) => {
+            operationLogger.log({
+                sessionId: options?.sessionId || 'unknown',
+                modifier: 'AI Agent',
+                type: 'system_command',
+                description: `执行命令：${command}`,
+                command,
+                result: 'success',
+            });
+            traceLogger.log({
+                sessionId: options?.sessionId || 'unknown',
+                type: 'tool_call',
+                data: { tool: 'exec', command },
+            });
         });
-    });
-    api.log('✅ [Harness] 所有 Hook 已注册');
-    return {
-        name: 'harness',
-        version: '0.1.13',
-        config,
-    };
-}
-//# 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: 'logs/harness',\n};\n\n// OpenClaw 插件入口函数\nexport default function(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.log('[Harness] 插件已加载，工作空间:', workspacePath);\n\n  // Hook: 配置修改前验证\n  if (config.autoValidateConfig) {\n    api.onConfigChange?.(async (newConfig: any, sessionId?: string) => {\n      api.log('🔍 [Harness] 验证配置变更...');\n      \n      const result = configValidator.validateContent(newConfig);\n      \n      if (!result.valid) {\n        api.log('❌ [Harness] 配置验证失败:');\n        result.errors.forEach((e: string) => api.log(`   - ${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.log('✅ [Harness] 配置验证通过');\n    });\n  }\n\n  // Hook: Skill 安装前审核\n  if (config.autoAuditSkill) {\n    api.onSkillInstall?.(async (skillPath: string) => {\n      api.log('🔍 [Harness] 审核 Skill:', skillPath);\n      \n      const auditResult = await skillAuditor.audit(skillPath, 'local');\n      \n      if (!auditResult.passed) {\n        api.log('❌ [Harness] Skill 审核失败:');\n        auditResult.warnings.forEach((w: any) => api.log(`   - ${w.message}`));\n        throw new Error(`Skill 审核失败：${auditResult.warnings.map((w: any) => w.message).join(', ')}`);\n      }\n      \n      api.log('✅ [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.log('⚠️ [Harness] 检测到频繁编辑:');\n        api.log(`   文件：${filePath}`);\n        api.log(`   警告：${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.log(`❌ [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.log('✅ [Harness] 所有 Hook 已注册');\n  \n  return {\n    name: 'harness',\n    version: '0.1.13',\n    config,\n  };\n}\n"]}
+        api.log('✅ [Harness] 所有 Hook 已注册');
+    },
+};
+exports.default = harnessPlugin;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,oCAAoC;;AAEpC,2CAAwH;AAUxH,MAAM,cAAc,GAAwB;IAC1C,kBAAkB,EAAE,IAAI;IACxB,cAAc,EAAE,IAAI;IACpB,oBAAoB,EAAE,IAAI;IAC1B,cAAc,EAAE;QACd,SAAS;QACT,SAAS;QACT,WAAW;QACX,UAAU;QACV,WAAW;QACX,eAAe;KAChB;IACD,OAAO,EAAE,wBAAwB;CAClC,CAAC;AAEF,MAAM,aAAa,GAAG;IACpB,EAAE,EAAE,SAAS;IACb,IAAI,EAAE,qBAAqB;IAC3B,WAAW,EAAE,gEAAgE;IAC7E,IAAI,EAAE,aAAa;IACnB,YAAY,EAAE;QACZ,IAAI,EAAE,QAAiB;QACvB,oBAAoB,EAAE,KAAK;QAC3B,UAAU,EAAE;YACV,kBAAkB,EAAE,EAAE,IAAI,EAAE,SAAkB,EAAE,OAAO,EAAE,IAAI,EAAE;YAC/D,cAAc,EAAE,EAAE,IAAI,EAAE,SAAkB,EAAE,OAAO,EAAE,IAAI,EAAE;YAC3D,oBAAoB,EAAE,EAAE,IAAI,EAAE,SAAkB,EAAE,OAAO,EAAE,IAAI,EAAE;YACjE,cAAc,EAAE,EAAE,IAAI,EAAE,OAAgB,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAiB,EAAE,EAAE;YAC9E,OAAO,EAAE,EAAE,IAAI,EAAE,QAAiB,EAAE,OAAO,EAAE,wBAAwB,EAAE;SACxE;KACF;IACD,QAAQ,CAAC,GAAQ;QACf,MAAM,aAAa,GAAG,GAAG,CAAC,aAAa,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;QACzD,MAAM,MAAM,GAAwB,EAAE,GAAG,cAAc,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC;QAEzE,QAAQ;QACR,MAAM,eAAe,GAAG,IAAI,yBAAe,CAAC,aAAa,CAAC,CAAC;QAC3D,MAAM,YAAY,GAAG,IAAI,sBAAY,CAAC,aAAa,CAAC,CAAC;QACrD,MAAM,YAAY,GAAG,IAAI,sBAAY,CAAC,aAAa,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;QACrF,MAAM,YAAY,GAAG,IAAI,sBAAY,CAAC,aAAa,CAAC,CAAC;QACrD,MAAM,eAAe,GAAG,IAAI,yBAAe,CAAC,aAAa,CAAC,CAAC;QAC3D,MAAM,WAAW,GAAG,IAAI,qBAAW,CAAC,aAAa,CAAC,CAAC;QAEnD,GAAG,CAAC,GAAG,CAAC,uBAAuB,EAAE,aAAa,CAAC,CAAC;QAEhD,gBAAgB;QAChB,IAAI,MAAM,CAAC,kBAAkB,EAAE,CAAC;YAC9B,GAAG,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,SAAc,EAAE,SAAkB,EAAE,EAAE;gBAChE,GAAG,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;gBAElC,MAAM,MAAM,GAAG,eAAe,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;gBAE1D,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;oBAClB,GAAG,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;oBAC/B,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;oBAE3D,YAAY,CAAC,GAAG,CAAC;wBACf,SAAS,EAAE,SAAS,IAAI,SAAS;wBACjC,QAAQ,EAAE,UAAU;wBACpB,IAAI,EAAE,eAAe;wBACrB,OAAO,EAAE,EAAE;wBACX,MAAM,EAAE,YAAY;wBACpB,QAAQ,EAAE,KAAK;wBACf,gBAAgB,EAAE,KAAK;qBACxB,CAAC,CAAC;oBAEH,MAAM,IAAI,KAAK,CAAC,UAAU,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBACxD,CAAC;gBAED,YAAY,CAAC,GAAG,CAAC;oBACf,SAAS,EAAE,SAAS,IAAI,SAAS;oBACjC,QAAQ,EAAE,UAAU;oBACpB,IAAI,EAAE,eAAe;oBACrB,OAAO,EAAE,EAAE;oBACX,MAAM,EAAE,MAAM;oBACd,QAAQ,EAAE,IAAI;oBACd,gBAAgB,EAAE,IAAI;iBACvB,CAAC,CAAC;gBAEH,GAAG,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;YAChC,CAAC,CAAC,CAAC;QACL,CAAC;QAED,oBAAoB;QACpB,IAAI,MAAM,CAAC,cAAc,EAAE,CAAC;YAC1B,GAAG,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,SAAiB,EAAE,EAAE;gBAC/C,GAAG,CAAC,GAAG,CAAC,wBAAwB,EAAE,SAAS,CAAC,CAAC;gBAE7C,MAAM,WAAW,GAAG,MAAM,YAAY,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;gBAEjE,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC;oBACxB,GAAG,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;oBACnC,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;oBACvE,MAAM,IAAI,KAAK,CAAC,cAAc,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBAC9F,CAAC;gBAED,GAAG,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;YACpC,CAAC,CAAC,CAAC;QACL,CAAC;QAED,kBAAkB;QAClB,IAAI,MAAM,CAAC,oBAAoB,EAAE,CAAC;YAChC,GAAG,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,QAAgB,EAAE,OAAe,EAAE,EAAE;gBAC3D,MAAM,OAAO,GAAG,YAAY,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;gBAElD,IAAI,OAAO,EAAE,CAAC;oBACZ,GAAG,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC;oBACjC,GAAG,CAAC,GAAG,CAAC,SAAS,QAAQ,EAAE,CAAC,CAAC;oBAC7B,GAAG,CAAC,GAAG,CAAC,SAAS,OAAO,EAAE,CAAC,CAAC;oBAC5B,MAAM,IAAI,KAAK,CAAC,WAAW,OAAO,EAAE,CAAC,CAAC;gBACxC,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;QAED,oBAAoB;QACpB,GAAG,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,QAAgB,EAAE,EAAE;YAC5C,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,IAAI,QAAQ,CAAC;YAEvD,IAAI,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC7C,GAAG,CAAC,GAAG,CAAC,wBAAwB,QAAQ,EAAE,CAAC,CAAC;gBAC5C,MAAM,IAAI,KAAK,CAAC,aAAa,QAAQ,EAAE,CAAC,CAAC;YAC3C,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,eAAe;QACf,GAAG,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,OAAe,EAAE,OAAa,EAAE,EAAE;YAC3D,eAAe,CAAC,GAAG,CAAC;gBAClB,SAAS,EAAE,OAAO,EAAE,SAAS,IAAI,SAAS;gBAC1C,QAAQ,EAAE,UAAU;gBACpB,IAAI,EAAE,gBAAgB;gBACtB,WAAW,EAAE,QAAQ,OAAO,EAAE;gBAC9B,OAAO;gBACP,MAAM,EAAE,SAAS;aAClB,CAAC,CAAC;YAEH,WAAW,CAAC,GAAG,CAAC;gBACd,SAAS,EAAE,OAAO,EAAE,SAAS,IAAI,SAAS;gBAC1C,IAAI,EAAE,WAAW;gBACjB,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;aAChC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,GAAG,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;IACrC,CAAC;CACF,CAAC;AAEF,kBAAe,aAAa,CAAC","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.log('[Harness] 插件已加载，工作空间:', workspacePath);\n\n    // Hook: 配置修改前验证\n    if (config.autoValidateConfig) {\n      api.onConfigChange?.(async (newConfig: any, sessionId?: string) => {\n        api.log('🔍 [Harness] 验证配置变更...');\n        \n        const result = configValidator.validateContent(newConfig);\n        \n        if (!result.valid) {\n          api.log('❌ [Harness] 配置验证失败:');\n          result.errors.forEach((e: string) => api.log(`   - ${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.log('✅ [Harness] 配置验证通过');\n      });\n    }\n\n    // Hook: Skill 安装前审核\n    if (config.autoAuditSkill) {\n      api.onSkillInstall?.(async (skillPath: string) => {\n        api.log('🔍 [Harness] 审核 Skill:', skillPath);\n        \n        const auditResult = await skillAuditor.audit(skillPath, 'local');\n        \n        if (!auditResult.passed) {\n          api.log('❌ [Harness] Skill 审核失败:');\n          auditResult.warnings.forEach((w: any) => api.log(`   - ${w.message}`));\n          throw new Error(`Skill 审核失败：${auditResult.warnings.map((w: any) => w.message).join(', ')}`);\n        }\n        \n        api.log('✅ [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.log('⚠️ [Harness] 检测到频繁编辑:');\n          api.log(`   文件：${filePath}`);\n          api.log(`   警告：${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.log(`❌ [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.log('✅ [Harness] 所有 Hook 已注册');\n  },\n};\n\nexport default harnessPlugin;\n"]}

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "harness",
   "name": "Harness Engineering",
   "description": "Constraints, feedback loops, and control systems for AI agents",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "kind": "engineering",
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hddz/plugin-harness",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Harness Engineering plugin for OpenClaw - constraints, feedback loops, and control systems for AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",