@hddz/plugin-harness 0.1.19 → 0.2.1

package/dist/core/auditors/skill-auditor.js

@@ -0,0 +1,488 @@
+"use strict";
+// src/auditors/skill-auditor.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.SkillAuditor = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+class SkillAuditor {
+    workspacePath;
+    constructor(workspacePath) {
+        this.workspacePath = workspacePath;
+    }
+    /**
+     * 审核 Skill
+     */
+    async audit(skillPath, source = 'unknown') {
+        const warnings = [];
+        const recommendations = [];
+        // 获取元数据
+        const metadata = await this.getSkillMetadata(skillPath);
+        // 1. 检查来源
+        const sourceWarning = this.checkSource(source);
+        if (sourceWarning)
+            warnings.push(sourceWarning);
+        // 2. 检查 SKILL.md
+        if (!metadata.hasSkillMd) {
+            warnings.push({
+                type: 'permission',
+                severity: 'high',
+                message: '缺少 SKILL.md 文件，无法确认权限声明',
+            });
+        }
+        else {
+            // 检查权限声明
+            const permissionWarning = this.checkPermissions(metadata.declaredPermissions);
+            if (permissionWarning)
+                warnings.push(permissionWarning);
+        }
+        // 3. 扫描危险代码
+        const codeWarnings = await this.scanDangerousCode(skillPath);
+        warnings.push(...codeWarnings);
+        // 4. 检查依赖
+        if (metadata.hasPackageJson) {
+            const depWarnings = await this.checkDependencies(skillPath, metadata.dependencies);
+            warnings.push(...depWarnings);
+        }
+        // 5. 检查脚本目录
+        if (metadata.hasScripts) {
+            const scriptWarnings = await this.scanScripts(skillPath);
+            warnings.push(...scriptWarnings);
+        }
+        // 计算风险等级
+        const riskLevel = this.calculateRiskLevel(warnings);
+        const passed = riskLevel !== 'CRITICAL' && riskLevel !== 'HIGH';
+        // 生成建议
+        if (!passed) {
+            recommendations.push('⚠️ 建议人工审核后再决定是否安装');
+        }
+        if (metadata.dependencies.length > 10) {
+            recommendations.push(`📦 依赖较多（${metadata.dependencies.length} 个），建议检查是否有不必要的依赖`);
+        }
+        if (!metadata.hasSkillMd) {
+            recommendations.push('📝 要求作者添加 SKILL.md 权限声明');
+        }
+        return {
+            skillName: path.basename(skillPath),
+            skillPath,
+            source,
+            riskLevel,
+            passed,
+            warnings,
+            recommendations,
+            metadata,
+        };
+    }
+    /**
+     * 检查来源
+     */
+    checkSource(source) {
+        const trustedSources = [
+            'clawhub',
+            'official',
+            'github.com/openclaw',
+            'github.com/clawd',
+        ];
+        const unknownSources = ['unknown', '', undefined];
+        if (unknownSources.includes(source)) {
+            return {
+                type: 'other',
+                severity: 'medium',
+                message: `来源未知：${source}`,
+            };
+        }
+        if (trustedSources.some(s => source.toLowerCase().includes(s))) {
+            return null; // 可信来源，无警告
+        }
+        return {
+            type: 'other',
+            severity: 'low',
+            message: `来源：${source}（非官方来源）`,
+        };
+    }
+    /**
+     * 检查权限声明
+     */
+    checkPermissions(permissions) {
+        const dangerousPermissions = [
+            'exec',
+            'system',
+            'fullFileSystem',
+            'network',
+            'externalApi',
+        ];
+        const hasDangerous = permissions.some(p => dangerousPermissions.some(dp => p.toLowerCase().includes(dp)));
+        if (hasDangerous) {
+            return {
+                type: 'permission',
+                severity: 'medium',
+                message: `声明了危险权限：${permissions.filter(p => dangerousPermissions.some(dp => p.toLowerCase().includes(dp))).join(', ')}`,
+            };
+        }
+        if (permissions.length === 0) {
+            return {
+                type: 'permission',
+                severity: 'low',
+                message: '未声明任何权限（可能不需要权限，也可能未声明）',
+            };
+        }
+        return null;
+    }
+    /**
+     * 扫描危险代码
+     */
+    async scanDangerousCode(skillPath) {
+        const warnings = [];
+        const dangerousPatterns = [
+            {
+                pattern: /exec\s*\(/g,
+                name: 'exec()',
+                severity: 'high',
+                message: '发现系统命令执行',
+            },
+            {
+                pattern: /eval\s*\(/g,
+                name: 'eval()',
+                severity: 'critical',
+                message: '发现代码执行（eval）',
+            },
+            {
+                pattern: /child_process/g,
+                name: 'child_process',
+                severity: 'high',
+                message: '使用 Node.js 子进程模块',
+            },
+            {
+                pattern: /spawn\s*\(/g,
+                name: 'spawn()',
+                severity: 'high',
+                message: '发现进程生成',
+            },
+            {
+                pattern: /fs\.writeFile/g,
+                name: 'fs.writeFile',
+                severity: 'medium',
+                message: '发现文件写入操作',
+            },
+            {
+                pattern: /fs\.unlink/g,
+                name: 'fs.unlink',
+                severity: 'medium',
+                message: '发现文件删除操作',
+            },
+            {
+                pattern: /fetch\s*\(/g,
+                name: 'fetch()',
+                severity: 'medium',
+                message: '发现网络请求',
+            },
+            {
+                pattern: /axios\./g,
+                name: 'axios',
+                severity: 'medium',
+                message: '使用 axios 进行网络请求',
+            },
+            {
+                pattern: /https?:\/\/[^\s'"]+/g,
+                name: 'hardcoded_url',
+                severity: 'low',
+                message: '发现硬编码 URL',
+            },
+            {
+                pattern: /process\.env/g,
+                name: 'process.env',
+                severity: 'low',
+                message: '访问环境变量',
+            },
+        ];
+        const filesToScan = await this.getJsFiles(skillPath);
+        for (const file of filesToScan) {
+            try {
+                const content = await fs.readFile(file, 'utf8');
+                const lines = content.split('\n');
+                for (const { pattern, name, severity, message } of dangerousPatterns) {
+                    pattern.lastIndex = 0; // 重置正则状态
+                    let match;
+                    while ((match = pattern.exec(content)) !== null) {
+                        // 计算行号
+                        const beforeMatch = content.substring(0, match.index);
+                        const lineNumber = beforeMatch.split('\n').length;
+                        // 跳过注释中的匹配
+                        const line = lines[lineNumber - 1];
+                        if (line.trim().startsWith('//') || line.trim().startsWith('*')) {
+                            continue;
+                        }
+                        warnings.push({
+                            type: 'dangerous_code',
+                            severity,
+                            message: `${message}: ${name}`,
+                            file: path.relative(skillPath, file),
+                            line: lineNumber,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                // 忽略读取错误
+            }
+        }
+        return warnings;
+    }
+    /**
+     * 扫描脚本文件
+     */
+    async scanScripts(skillPath) {
+        const warnings = [];
+        const scriptsDir = path.join(skillPath, 'scripts');
+        if (!await fs.pathExists(scriptsDir)) {
+            return warnings;
+        }
+        const scriptFiles = await fs.readdir(scriptsDir);
+        for (const script of scriptFiles) {
+            const scriptPath = path.join(scriptsDir, script);
+            // 检查 shell 脚本
+            if (script.endsWith('.sh')) {
+                const content = await fs.readFile(scriptPath, 'utf8');
+                const dangerousCommands = [
+                    { pattern: /rm\s+-rf/g, message: '发现危险命令：rm -rf' },
+                    { pattern: /curl.*\|\s*bash/g, message: '发现管道执行：curl | bash' },
+                    { pattern: /wget.*\|\s*bash/g, message: '发现管道执行：wget | bash' },
+                    { pattern: /sudo/g, message: '使用 sudo 提权' },
+                    { pattern: /chmod\s+777/g, message: '设置文件权限为 777' },
+                ];
+                for (const { pattern, message } of dangerousCommands) {
+                    if (pattern.test(content)) {
+                        warnings.push({
+                            type: 'dangerous_code',
+                            severity: 'high',
+                            message,
+                            file: `scripts/${script}`,
+                        });
+                    }
+                }
+            }
+        }
+        return warnings;
+    }
+    /**
+     * 检查依赖
+     */
+    async checkDependencies(skillPath, dependencies) {
+        const warnings = [];
+        // 检查依赖数量
+        if (dependencies.length > 20) {
+            warnings.push({
+                type: 'dependency',
+                severity: 'low',
+                message: `依赖过多（${dependencies.length} 个），可能增加攻击面`,
+            });
+        }
+        // 尝试运行 npm audit
+        try {
+            const auditOutput = (0, child_process_1.execSync)('npm audit --json', {
+                cwd: skillPath,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                encoding: 'utf8',
+            });
+            const audit = JSON.parse(auditOutput);
+            const vulnerabilities = audit.metadata?.vulnerabilities;
+            if (vulnerabilities && vulnerabilities.total > 0) {
+                warnings.push({
+                    type: 'dependency',
+                    severity: vulnerabilities.critical > 0 || vulnerabilities.high > 0 ? 'high' : 'medium',
+                    message: `发现 ${vulnerabilities.total} 个依赖漏洞（${vulnerabilities.critical} 严重，${vulnerabilities.high} 高）`,
+                });
+            }
+        }
+        catch (error) {
+            // npm audit 可能失败，忽略
+        }
+        return warnings;
+    }
+    /**
+     * 获取 Skill 元数据
+     */
+    async getSkillMetadata(skillPath) {
+        const metadata = {
+            hasSkillMd: false,
+            hasScripts: false,
+            hasPackageJson: false,
+            declaredPermissions: [],
+            dependencies: [],
+            devDependencies: [],
+        };
+        // 检查 SKILL.md
+        const skillMdPath = path.join(skillPath, 'SKILL.md');
+        if (await fs.pathExists(skillMdPath)) {
+            metadata.hasSkillMd = true;
+            const content = await fs.readFile(skillMdPath, 'utf8');
+            // 提取权限声明（假设格式为 "Permissions: exec, network"）
+            const permissionMatch = content.match(/Permissions?:\s*([^\n]+)/i);
+            if (permissionMatch) {
+                metadata.declaredPermissions = permissionMatch[1]
+                    .split(',')
+                    .map(p => p.trim())
+                    .filter(p => p);
+            }
+        }
+        // 检查 scripts 目录
+        const scriptsDir = path.join(skillPath, 'scripts');
+        metadata.hasScripts = await fs.pathExists(scriptsDir);
+        // 检查 package.json
+        const packageJsonPath = path.join(skillPath, 'package.json');
+        if (await fs.pathExists(packageJsonPath)) {
+            metadata.hasPackageJson = true;
+            try {
+                const pkg = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+                metadata.dependencies = Object.keys(pkg.dependencies || {});
+                metadata.devDependencies = Object.keys(pkg.devDependencies || {});
+            }
+            catch (error) {
+                // 忽略解析错误
+            }
+        }
+        // 获取最后修改时间
+        try {
+            const stats = await fs.stat(skillPath);
+            metadata.lastModified = stats.mtime;
+        }
+        catch (error) {
+            // 忽略
+        }
+        return metadata;
+    }
+    /**
+     * 获取所有 JS 文件
+     */
+    async getJsFiles(dir) {
+        const files = [];
+        async function scan(currentDir) {
+            const entries = await fs.readdir(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    // 跳过 node_modules
+                    if (entry.name === 'node_modules' || entry.name === 'dist') {
+                        continue;
+                    }
+                    await scan(fullPath);
+                }
+                else if (entry.isFile() && (entry.name.endsWith('.js') || entry.name.endsWith('.ts'))) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        await scan(dir);
+        return files;
+    }
+    /**
+     * 计算风险等级
+     */
+    calculateRiskLevel(warnings) {
+        const criticalCount = warnings.filter(w => w.severity === 'critical').length;
+        const highCount = warnings.filter(w => w.severity === 'high').length;
+        const mediumCount = warnings.filter(w => w.severity === 'medium').length;
+        if (criticalCount > 0)
+            return 'CRITICAL';
+        if (highCount > 2)
+            return 'HIGH';
+        if (highCount > 0 || mediumCount > 3)
+            return 'MEDIUM';
+        return 'LOW';
+    }
+    /**
+     * 生成审计报告
+     */
+    generateReport(result) {
+        const lines = [];
+        lines.push(`# Skill 安全审计报告`);
+        lines.push('');
+        lines.push(`## 基本信息`);
+        lines.push(`- **Skill 名称**: ${result.skillName}`);
+        lines.push(`- **路径**: ${result.skillPath}`);
+        lines.push(`- **来源**: ${result.source}`);
+        lines.push(`- **风险等级**: ${this.getRiskEmoji(result.riskLevel)} ${result.riskLevel}`);
+        lines.push(`- **审核结果**: ${result.passed ? '✅ 通过' : '❌ 未通过'}`);
+        lines.push('');
+        if (result.warnings.length > 0) {
+            lines.push(`## 警告（${result.warnings.length} 个）`);
+            lines.push('');
+            for (const warning of result.warnings) {
+                lines.push(`- ${this.getSeverityEmoji(warning.severity)} **[${warning.type}]** ${warning.message}`);
+                if (warning.file) {
+                    lines.push(`  - 文件：\`${warning.file}\`${warning.line ? ` 第 ${warning.line} 行` : ''}`);
+                }
+            }
+            lines.push('');
+        }
+        if (result.recommendations.length > 0) {
+            lines.push(`## 建议`);
+            lines.push('');
+            for (const rec of result.recommendations) {
+                lines.push(`- ${rec}`);
+            }
+            lines.push('');
+        }
+        lines.push(`## 元数据`);
+        lines.push(`- 有 SKILL.md: ${result.metadata.hasSkillMd ? '✅' : '❌'}`);
+        lines.push(`- 有 scripts 目录：${result.metadata.hasScripts ? '✅' : '❌'}`);
+        lines.push(`- 有 package.json: ${result.metadata.hasPackageJson ? '✅' : '❌'}`);
+        lines.push(`- 声明权限：${result.metadata.declaredPermissions.join(', ') || '无'}`);
+        lines.push(`- 依赖数量：${result.metadata.dependencies.length}`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    getRiskEmoji(level) {
+        const emojis = {
+            LOW: '🟢',
+            MEDIUM: '🟡',
+            HIGH: '🟠',
+            CRITICAL: '🔴',
+        };
+        return emojis[level] || '⚪';
+    }
+    getSeverityEmoji(severity) {
+        const emojis = {
+            low: 'ℹ️',
+            medium: '⚠️',
+            high: '🚨',
+            critical: '💀',
+        };
+        return emojis[severity] || '⚪';
+    }
+}
+exports.SkillAuditor = SkillAuditor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skill-auditor.js","sourceRoot":"","sources":["../../../src/core/auditors/skill-auditor.ts"],"names":[],"mappings":"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","sourcesContent":["// src/auditors/skill-auditor.ts\n\nimport * as fs from 'fs-extra';\nimport * as path from 'path';\nimport { execSync } from 'child_process';\n\nexport interface SkillAuditResult {\n  skillName: string;\n  skillPath: string;\n  source: string;\n  riskLevel: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';\n  passed: boolean;\n  warnings: Warning[];\n  recommendations: string[];\n  metadata: SkillMetadata;\n}\n\nexport interface Warning {\n  type: 'dangerous_code' | 'permission' | 'dependency' | 'network' | 'other';\n  severity: 'low' | 'medium' | 'high' | 'critical';\n  message: string;\n  file?: string;\n  line?: number;\n}\n\nexport interface SkillMetadata {\n  hasSkillMd: boolean;\n  hasScripts: boolean;\n  hasPackageJson: boolean;\n  declaredPermissions: string[];\n  dependencies: string[];\n  devDependencies: string[];\n  lastModified?: Date;\n}\n\nexport class SkillAuditor {\n  private workspacePath: string;\n\n  constructor(workspacePath: string) {\n    this.workspacePath = workspacePath;\n  }\n\n  /**\n   * 审核 Skill\n   */\n  async audit(skillPath: string, source: string = 'unknown'): Promise<SkillAuditResult> {\n    const warnings: Warning[] = [];\n    const recommendations: string[] = [];\n\n    // 获取元数据\n    const metadata = await this.getSkillMetadata(skillPath);\n\n    // 1. 检查来源\n    const sourceWarning = this.checkSource(source);\n    if (sourceWarning) warnings.push(sourceWarning);\n\n    // 2. 检查 SKILL.md\n    if (!metadata.hasSkillMd) {\n      warnings.push({\n        type: 'permission',\n        severity: 'high',\n        message: '缺少 SKILL.md 文件，无法确认权限声明',\n      });\n    } else {\n      // 检查权限声明\n      const permissionWarning = this.checkPermissions(metadata.declaredPermissions);\n      if (permissionWarning) warnings.push(permissionWarning);\n    }\n\n    // 3. 扫描危险代码\n    const codeWarnings = await this.scanDangerousCode(skillPath);\n    warnings.push(...codeWarnings);\n\n    // 4. 检查依赖\n    if (metadata.hasPackageJson) {\n      const depWarnings = await this.checkDependencies(skillPath, metadata.dependencies);\n      warnings.push(...depWarnings);\n    }\n\n    // 5. 检查脚本目录\n    if (metadata.hasScripts) {\n      const scriptWarnings = await this.scanScripts(skillPath);\n      warnings.push(...scriptWarnings);\n    }\n\n    // 计算风险等级\n    const riskLevel = this.calculateRiskLevel(warnings);\n    const passed = riskLevel !== 'CRITICAL' && riskLevel !== 'HIGH';\n\n    // 生成建议\n    if (!passed) {\n      recommendations.push('⚠️ 建议人工审核后再决定是否安装');\n    }\n    if (metadata.dependencies.length > 10) {\n      recommendations.push(`📦 依赖较多（${metadata.dependencies.length} 个），建议检查是否有不必要的依赖`);\n    }\n    if (!metadata.hasSkillMd) {\n      recommendations.push('📝 要求作者添加 SKILL.md 权限声明');\n    }\n\n    return {\n      skillName: path.basename(skillPath),\n      skillPath,\n      source,\n      riskLevel,\n      passed,\n      warnings,\n      recommendations,\n      metadata,\n    };\n  }\n\n  /**\n   * 检查来源\n   */\n  private checkSource(source: string): Warning | null {\n    const trustedSources = [\n      'clawhub',\n      'official',\n      'github.com/openclaw',\n      'github.com/clawd',\n    ];\n\n    const unknownSources = ['unknown', '', undefined];\n\n    if (unknownSources.includes(source)) {\n      return {\n        type: 'other',\n        severity: 'medium',\n        message: `来源未知：${source}`,\n      };\n    }\n\n    if (trustedSources.some(s => source.toLowerCase().includes(s))) {\n      return null; // 可信来源，无警告\n    }\n\n    return {\n      type: 'other',\n      severity: 'low',\n      message: `来源：${source}（非官方来源）`,\n    };\n  }\n\n  /**\n   * 检查权限声明\n   */\n  private checkPermissions(permissions: string[]): Warning | null {\n    const dangerousPermissions = [\n      'exec',\n      'system',\n      'fullFileSystem',\n      'network',\n      'externalApi',\n    ];\n\n    const hasDangerous = permissions.some(p =>\n      dangerousPermissions.some(dp => p.toLowerCase().includes(dp))\n    );\n\n    if (hasDangerous) {\n      return {\n        type: 'permission',\n        severity: 'medium',\n        message: `声明了危险权限：${permissions.filter(p => dangerousPermissions.some(dp => p.toLowerCase().includes(dp))).join(', ')}`,\n      };\n    }\n\n    if (permissions.length === 0) {\n      return {\n        type: 'permission',\n        severity: 'low',\n        message: '未声明任何权限（可能不需要权限，也可能未声明）',\n      };\n    }\n\n    return null;\n  }\n\n  /**\n   * 扫描危险代码\n   */\n  private async scanDangerousCode(skillPath: string): Promise<Warning[]> {\n    const warnings: Warning[] = [];\n\n    const dangerousPatterns = [\n      {\n        pattern: /exec\\s*\\(/g,\n        name: 'exec()',\n        severity: 'high' as const,\n        message: '发现系统命令执行',\n      },\n      {\n        pattern: /eval\\s*\\(/g,\n        name: 'eval()',\n        severity: 'critical' as const,\n        message: '发现代码执行（eval）',\n      },\n      {\n        pattern: /child_process/g,\n        name: 'child_process',\n        severity: 'high' as const,\n        message: '使用 Node.js 子进程模块',\n      },\n      {\n        pattern: /spawn\\s*\\(/g,\n        name: 'spawn()',\n        severity: 'high' as const,\n        message: '发现进程生成',\n      },\n      {\n        pattern: /fs\\.writeFile/g,\n        name: 'fs.writeFile',\n        severity: 'medium' as const,\n        message: '发现文件写入操作',\n      },\n      {\n        pattern: /fs\\.unlink/g,\n        name: 'fs.unlink',\n        severity: 'medium' as const,\n        message: '发现文件删除操作',\n      },\n      {\n        pattern: /fetch\\s*\\(/g,\n        name: 'fetch()',\n        severity: 'medium' as const,\n        message: '发现网络请求',\n      },\n      {\n        pattern: /axios\\./g,\n        name: 'axios',\n        severity: 'medium' as const,\n        message: '使用 axios 进行网络请求',\n      },\n      {\n        pattern: /https?:\\/\\/[^\\s'\"]+/g,\n        name: 'hardcoded_url',\n        severity: 'low' as const,\n        message: '发现硬编码 URL',\n      },\n      {\n        pattern: /process\\.env/g,\n        name: 'process.env',\n        severity: 'low' as const,\n        message: '访问环境变量',\n      },\n    ];\n\n    const filesToScan = await this.getJsFiles(skillPath);\n\n    for (const file of filesToScan) {\n      try {\n        const content = await fs.readFile(file, 'utf8');\n        const lines = content.split('\\n');\n\n        for (const { pattern, name, severity, message } of dangerousPatterns) {\n          pattern.lastIndex = 0; // 重置正则状态\n          let match;\n          while ((match = pattern.exec(content)) !== null) {\n            // 计算行号\n            const beforeMatch = content.substring(0, match.index);\n            const lineNumber = beforeMatch.split('\\n').length;\n\n            // 跳过注释中的匹配\n            const line = lines[lineNumber - 1];\n            if (line.trim().startsWith('//') || line.trim().startsWith('*')) {\n              continue;\n            }\n\n            warnings.push({\n              type: 'dangerous_code',\n              severity,\n              message: `${message}: ${name}`,\n              file: path.relative(skillPath, file),\n              line: lineNumber,\n            });\n          }\n        }\n      } catch (error) {\n        // 忽略读取错误\n      }\n    }\n\n    return warnings;\n  }\n\n  /**\n   * 扫描脚本文件\n   */\n  private async scanScripts(skillPath: string): Promise<Warning[]> {\n    const warnings: Warning[] = [];\n    const scriptsDir = path.join(skillPath, 'scripts');\n\n    if (!await fs.pathExists(scriptsDir)) {\n      return warnings;\n    }\n\n    const scriptFiles = await fs.readdir(scriptsDir);\n\n    for (const script of scriptFiles) {\n      const scriptPath = path.join(scriptsDir, script);\n\n      // 检查 shell 脚本\n      if (script.endsWith('.sh')) {\n        const content = await fs.readFile(scriptPath, 'utf8');\n\n        const dangerousCommands = [\n          { pattern: /rm\\s+-rf/g, message: '发现危险命令：rm -rf' },\n          { pattern: /curl.*\\|\\s*bash/g, message: '发现管道执行：curl | bash' },\n          { pattern: /wget.*\\|\\s*bash/g, message: '发现管道执行：wget | bash' },\n          { pattern: /sudo/g, message: '使用 sudo 提权' },\n          { pattern: /chmod\\s+777/g, message: '设置文件权限为 777' },\n        ];\n\n        for (const { pattern, message } of dangerousCommands) {\n          if (pattern.test(content)) {\n            warnings.push({\n              type: 'dangerous_code',\n              severity: 'high',\n              message,\n              file: `scripts/${script}`,\n            });\n          }\n        }\n      }\n    }\n\n    return warnings;\n  }\n\n  /**\n   * 检查依赖\n   */\n  private async checkDependencies(skillPath: string, dependencies: string[]): Promise<Warning[]> {\n    const warnings: Warning[] = [];\n\n    // 检查依赖数量\n    if (dependencies.length > 20) {\n      warnings.push({\n        type: 'dependency',\n        severity: 'low',\n        message: `依赖过多（${dependencies.length} 个），可能增加攻击面`,\n      });\n    }\n\n    // 尝试运行 npm audit\n    try {\n      const auditOutput = execSync('npm audit --json', {\n        cwd: skillPath,\n        stdio: ['pipe', 'pipe', 'pipe'],\n        encoding: 'utf8',\n      });\n\n      const audit = JSON.parse(auditOutput);\n      const vulnerabilities = audit.metadata?.vulnerabilities;\n\n      if (vulnerabilities && vulnerabilities.total > 0) {\n        warnings.push({\n          type: 'dependency',\n          severity: vulnerabilities.critical > 0 || vulnerabilities.high > 0 ? 'high' : 'medium',\n          message: `发现 ${vulnerabilities.total} 个依赖漏洞（${vulnerabilities.critical} 严重，${vulnerabilities.high} 高）`,\n        });\n      }\n    } catch (error) {\n      // npm audit 可能失败，忽略\n    }\n\n    return warnings;\n  }\n\n  /**\n   * 获取 Skill 元数据\n   */\n  private async getSkillMetadata(skillPath: string): Promise<SkillMetadata> {\n    const metadata: SkillMetadata = {\n      hasSkillMd: false,\n      hasScripts: false,\n      hasPackageJson: false,\n      declaredPermissions: [],\n      dependencies: [],\n      devDependencies: [],\n    };\n\n    // 检查 SKILL.md\n    const skillMdPath = path.join(skillPath, 'SKILL.md');\n    if (await fs.pathExists(skillMdPath)) {\n      metadata.hasSkillMd = true;\n      const content = await fs.readFile(skillMdPath, 'utf8');\n\n      // 提取权限声明（假设格式为 \"Permissions: exec, network\"）\n      const permissionMatch = content.match(/Permissions?:\\s*([^\\n]+)/i);\n      if (permissionMatch) {\n        metadata.declaredPermissions = permissionMatch[1]\n          .split(',')\n          .map(p => p.trim())\n          .filter(p => p);\n      }\n    }\n\n    // 检查 scripts 目录\n    const scriptsDir = path.join(skillPath, 'scripts');\n    metadata.hasScripts = await fs.pathExists(scriptsDir);\n\n    // 检查 package.json\n    const packageJsonPath = path.join(skillPath, 'package.json');\n    if (await fs.pathExists(packageJsonPath)) {\n      metadata.hasPackageJson = true;\n      try {\n        const pkg = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));\n        metadata.dependencies = Object.keys(pkg.dependencies || {});\n        metadata.devDependencies = Object.keys(pkg.devDependencies || {});\n      } catch (error) {\n        // 忽略解析错误\n      }\n    }\n\n    // 获取最后修改时间\n    try {\n      const stats = await fs.stat(skillPath);\n      metadata.lastModified = stats.mtime;\n    } catch (error) {\n      // 忽略\n    }\n\n    return metadata;\n  }\n\n  /**\n   * 获取所有 JS 文件\n   */\n  private async getJsFiles(dir: string): Promise<string[]> {\n    const files: string[] = [];\n\n    async function scan(currentDir: string) {\n      const entries = await fs.readdir(currentDir, { withFileTypes: true });\n\n      for (const entry of entries) {\n        const fullPath = path.join(currentDir, entry.name);\n\n        if (entry.isDirectory()) {\n          // 跳过 node_modules\n          if (entry.name === 'node_modules' || entry.name === 'dist') {\n            continue;\n          }\n          await scan(fullPath);\n        } else if (entry.isFile() && (entry.name.endsWith('.js') || entry.name.endsWith('.ts'))) {\n          files.push(fullPath);\n        }\n      }\n    }\n\n    await scan(dir);\n    return files;\n  }\n\n  /**\n   * 计算风险等级\n   */\n  private calculateRiskLevel(warnings: Warning[]): 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL' {\n    const criticalCount = warnings.filter(w => w.severity === 'critical').length;\n    const highCount = warnings.filter(w => w.severity === 'high').length;\n    const mediumCount = warnings.filter(w => w.severity === 'medium').length;\n\n    if (criticalCount > 0) return 'CRITICAL';\n    if (highCount > 2) return 'HIGH';\n    if (highCount > 0 || mediumCount > 3) return 'MEDIUM';\n    return 'LOW';\n  }\n\n  /**\n   * 生成审计报告\n   */\n  generateReport(result: SkillAuditResult): string {\n    const lines: string[] = [];\n\n    lines.push(`# Skill 安全审计报告`);\n    lines.push('');\n    lines.push(`## 基本信息`);\n    lines.push(`- **Skill 名称**: ${result.skillName}`);\n    lines.push(`- **路径**: ${result.skillPath}`);\n    lines.push(`- **来源**: ${result.source}`);\n    lines.push(`- **风险等级**: ${this.getRiskEmoji(result.riskLevel)} ${result.riskLevel}`);\n    lines.push(`- **审核结果**: ${result.passed ? '✅ 通过' : '❌ 未通过'}`);\n    lines.push('');\n\n    if (result.warnings.length > 0) {\n      lines.push(`## 警告（${result.warnings.length} 个）`);\n      lines.push('');\n      for (const warning of result.warnings) {\n        lines.push(`- ${this.getSeverityEmoji(warning.severity)} **[${warning.type}]** ${warning.message}`);\n        if (warning.file) {\n          lines.push(`  - 文件：\\`${warning.file}\\`${warning.line ? ` 第 ${warning.line} 行` : ''}`);\n        }\n      }\n      lines.push('');\n    }\n\n    if (result.recommendations.length > 0) {\n      lines.push(`## 建议`);\n      lines.push('');\n      for (const rec of result.recommendations) {\n        lines.push(`- ${rec}`);\n      }\n      lines.push('');\n    }\n\n    lines.push(`## 元数据`);\n    lines.push(`- 有 SKILL.md: ${result.metadata.hasSkillMd ? '✅' : '❌'}`);\n    lines.push(`- 有 scripts 目录：${result.metadata.hasScripts ? '✅' : '❌'}`);\n    lines.push(`- 有 package.json: ${result.metadata.hasPackageJson ? '✅' : '❌'}`);\n    lines.push(`- 声明权限：${result.metadata.declaredPermissions.join(', ') || '无'}`);\n    lines.push(`- 依赖数量：${result.metadata.dependencies.length}`);\n    lines.push('');\n\n    return lines.join('\\n');\n  }\n\n  private getRiskEmoji(level: string): string {\n    const emojis: Record<string, string> = {\n      LOW: '🟢',\n      MEDIUM: '🟡',\n      HIGH: '🟠',\n      CRITICAL: '🔴',\n    };\n    return emojis[level] || '⚪';\n  }\n\n  private getSeverityEmoji(severity: string): string {\n    const emojis: Record<string, string> = {\n      low: 'ℹ️',\n      medium: '⚠️',\n      high: '🚨',\n      critical: '💀',\n    };\n    return emojis[severity] || '⚪';\n  }\n}\n"]}

package/dist/core/index.d.ts

@@ -0,0 +1,22 @@
+export * from './middleware';
+export * from './validators';
+export * from './loggers';
+export * from './utils';
+export * from './auditors';
+import { LoopDetector } from './middleware/loop-detector';
+import { TraceLogger } from './middleware/trace-logger';
+import { ContextInjector } from './middleware/context-injector';
+import { ConfigValidator } from './validators/config-validator';
+import { ConfigLogger } from './loggers/config-logger';
+import { OperationLogger } from './loggers/operation-logger';
+export interface Harness {
+    loopDetector: LoopDetector;
+    traceLogger: TraceLogger;
+    contextInjector: ContextInjector;
+    configValidator: ConfigValidator;
+    configLogger: ConfigLogger;
+    operationLogger: OperationLogger;
+}
+export declare function createHarness(workspacePath: string): Harness;
+export declare function createConfigValidator(): ConfigValidator;
+export default createHarness;

package/dist/core/index.js

@@ -0,0 +1,47 @@
+"use strict";
+// src/index.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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHarness = createHarness;
+exports.createConfigValidator = createConfigValidator;
+__exportStar(require("./middleware"), exports);
+__exportStar(require("./validators"), exports);
+__exportStar(require("./loggers"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./auditors"), exports);
+// 便捷工厂函数
+const loop_detector_1 = require("./middleware/loop-detector");
+const trace_logger_1 = require("./middleware/trace-logger");
+const context_injector_1 = require("./middleware/context-injector");
+const config_validator_1 = require("./validators/config-validator");
+const config_logger_1 = require("./loggers/config-logger");
+const operation_logger_1 = require("./loggers/operation-logger");
+function createHarness(workspacePath) {
+    return {
+        loopDetector: new loop_detector_1.LoopDetector(workspacePath),
+        traceLogger: new trace_logger_1.TraceLogger(workspacePath),
+        contextInjector: new context_injector_1.ContextInjector(workspacePath),
+        configValidator: new config_validator_1.ConfigValidator(workspacePath),
+        configLogger: new config_logger_1.ConfigLogger(workspacePath),
+        operationLogger: new operation_logger_1.OperationLogger(workspacePath),
+    };
+}
+// 便捷导出（用于包装层）
+function createConfigValidator() {
+    return new config_validator_1.ConfigValidator(process.cwd());
+}
+exports.default = createHarness;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/core/loggers/config-logger.d.ts

@@ -0,0 +1,25 @@
+export interface ConfigChange {
+    timestamp: string;
+    modifier: string;
+    file: string;
+    changes: Array<{
+        field: string;
+        oldValue: any;
+        newValue: any;
+    }>;
+    reason: string;
+    verified: boolean;
+    gatewayRestarted: boolean;
+    sessionId?: string;
+}
+export declare class ConfigLogger {
+    private workspacePath;
+    private logFilePath;
+    constructor(workspacePath: string);
+    log(change: Omit<ConfigChange, 'timestamp'>): void;
+    private formatEntry;
+    private truncateValue;
+    getRecentChanges(limit?: number): ConfigChange[];
+    private parseEntry;
+    exportToJson(outputPath: string): void;
+}