@dollhousemcp/mcp-server 1.3.0

package/dist/test/src/security/audit/rules/SecurityRules.js

@@ -0,0 +1,244 @@
+/**
+ * Security Rules - Defines security patterns and checks
+ * Based on OWASP Top 10, CWE Top 25, and DollhouseMCP-specific security requirements
+ */
+export class SecurityRules {
+    /**
+     * OWASP Top 10 security rules
+     */
+    getOWASPRules() {
+        return [
+            {
+                id: 'OWASP-A01-001',
+                name: 'Hardcoded Secrets',
+                description: 'Potential hardcoded secret or API key detected',
+                severity: 'critical',
+                category: 'code',
+                pattern: /(?:api[_-]?key|secret|password|token|private[_-]?key)\s*[:=]\s*["'][a-zA-Z0-9+/=_-]{10,}["']/gi,
+                remediation: 'Use environment variables or secure key management services instead of hardcoding secrets',
+                references: ['https://owasp.org/Top10/A01_2021-Broken_Access_Control/'],
+                tags: ['high-confidence']
+            },
+            {
+                id: 'OWASP-A03-001',
+                name: 'SQL Injection',
+                description: 'Potential SQL injection vulnerability',
+                severity: 'critical',
+                category: 'code',
+                pattern: /(?:query|execute)\s*\(\s*['"`].*\$\{[^}]+\}.*['"`]|['"`].*\+\s*[a-zA-Z_]\w*\s*\+.*['"`]\s*\)/g,
+                remediation: 'Use parameterized queries or prepared statements',
+                references: ['https://owasp.org/Top10/A03_2021-Injection/']
+            },
+            {
+                id: 'OWASP-A03-002',
+                name: 'Command Injection',
+                description: 'Potential command injection vulnerability',
+                severity: 'critical',
+                category: 'code',
+                pattern: /(?:exec|spawn|execSync|spawnSync)\s*\([^)]*(?:\$\{[^}]+\}|\+\s*[a-zA-Z_]\w*)/g,
+                remediation: 'Validate and sanitize all user input before using in system commands',
+                references: ['https://owasp.org/Top10/A03_2021-Injection/']
+            },
+            {
+                id: 'OWASP-A03-003',
+                name: 'Path Traversal',
+                description: 'Potential path traversal vulnerability',
+                severity: 'high',
+                category: 'code',
+                pattern: /(?:readFile|writeFile|readdir|mkdir|rm|unlink)[^(]*\([^)]*(?:\.\.[/\\].*\+|\+.*\.\.[/\\])/g,
+                remediation: 'Validate and sanitize file paths, use path.resolve() and check against allowed directories',
+                references: ['https://owasp.org/Top10/A03_2021-Injection/']
+            },
+            {
+                id: 'OWASP-A03-004',
+                name: 'XSS - Direct HTML Injection',
+                description: 'Potential XSS vulnerability through direct HTML injection',
+                severity: 'high',
+                category: 'code',
+                pattern: /innerHTML\s*=\s*[^'"`]*\$\{|dangerouslySetInnerHTML/g,
+                remediation: 'Use textContent or proper HTML escaping functions',
+                references: ['https://owasp.org/Top10/A03_2021-Injection/']
+            },
+            {
+                id: 'OWASP-A05-001',
+                name: 'Insecure Configuration',
+                description: 'Security-sensitive configuration detected',
+                severity: 'medium',
+                category: 'code',
+                pattern: /(?:NODE_TLS_REJECT_UNAUTHORIZED|strictSSL|rejectUnauthorized)\s*[:=]\s*(?:false|0|["']false["']|["']0["'])/gi,
+                remediation: 'Enable SSL/TLS certificate validation in production',
+                references: ['https://owasp.org/Top10/A05_2021-Security_Misconfiguration/']
+            },
+            {
+                id: 'OWASP-A07-001',
+                name: 'Weak Authentication',
+                description: 'Potential weak authentication mechanism',
+                severity: 'high',
+                category: 'code',
+                pattern: /(?:md5|sha1)\s*\(/gi,
+                remediation: 'Use strong hashing algorithms like bcrypt, scrypt, or Argon2 for passwords',
+                references: ['https://owasp.org/Top10/A07_2021-Identification_and_Authentication_Failures/']
+            }
+        ];
+    }
+    /**
+     * CWE Top 25 security rules
+     */
+    getCWERules() {
+        return [
+            {
+                id: 'CWE-79-001',
+                name: 'Reflected XSS',
+                description: 'User input reflected without encoding',
+                severity: 'high',
+                category: 'code',
+                pattern: /res\.(?:send|write|end)\s*\([^)]*(?:req\.(?:query|params|body)|request\.)/g,
+                remediation: 'Encode all user input before reflecting in responses',
+                references: ['https://cwe.mitre.org/data/definitions/79.html']
+            },
+            {
+                id: 'CWE-89-001',
+                name: 'SQL String Concatenation',
+                description: 'SQL query built using string concatenation',
+                severity: 'critical',
+                category: 'code',
+                pattern: /["'`].*(?:SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER).*["'`]\s*\+\s*\w+/gi,
+                remediation: 'Use parameterized queries instead of string concatenation',
+                references: ['https://cwe.mitre.org/data/definitions/89.html']
+            },
+            {
+                id: 'CWE-22-001',
+                name: 'Path Manipulation',
+                description: 'File path constructed from user input',
+                severity: 'high',
+                category: 'code',
+                pattern: /path\.join\s*\([^)]*(?:req\.|request\.|params|query|body)/g,
+                remediation: 'Validate paths against a whitelist and use path.resolve()',
+                references: ['https://cwe.mitre.org/data/definitions/22.html']
+            },
+            {
+                id: 'CWE-798-001',
+                name: 'Hardcoded Credentials',
+                description: 'Credentials hardcoded in source',
+                severity: 'critical',
+                category: 'code',
+                pattern: /(?:username|user|login)\s*[:=]\s*["'][^"']+["'].*(?:password|pass|pwd)\s*[:=]\s*["'][^"']+["']/gi,
+                remediation: 'Store credentials in environment variables or secure vaults',
+                references: ['https://cwe.mitre.org/data/definitions/798.html']
+            }
+        ];
+    }
+    /**
+     * DollhouseMCP-specific security rules
+     */
+    getDollhouseMCPRules() {
+        return [
+            {
+                id: 'DMCP-SEC-001',
+                name: 'Unsafe Persona Loading',
+                description: 'Persona loaded without validation',
+                severity: 'high',
+                category: 'custom',
+                pattern: /loadPersona\s*\([^)]*\)\s*(?!.*validate)/g,
+                remediation: 'Always validate personas before loading using PersonaValidator',
+                references: ['DollhouseMCP Security Guidelines']
+            },
+            {
+                id: 'DMCP-SEC-002',
+                name: 'Token Validation Bypass',
+                description: 'Token used without validation',
+                severity: 'critical',
+                category: 'custom',
+                pattern: /(?:getToken|useToken|token\.use)\s*\([^)]*\)(?!.*(?:validate|verify|check))/gi,
+                remediation: 'Always validate tokens using TokenManager.validateToken()',
+                references: ['DollhouseMCP Security Guidelines']
+            },
+            {
+                id: 'DMCP-SEC-003',
+                name: 'Rate Limiting Missing',
+                description: 'API endpoint without rate limiting',
+                severity: 'medium',
+                category: 'custom',
+                check: (content, context) => {
+                    const findings = [];
+                    // Check for MCP tool handlers without rate limiting
+                    const toolPattern = /name:\s*["']([^"']+)["'].*handle:/gs;
+                    const hasRateLimit = /rateLimiter|checkRateLimit|tokenBucket/i.test(content);
+                    if (toolPattern.test(content) && !hasRateLimit) {
+                        findings.push({
+                            ruleId: 'DMCP-SEC-003',
+                            severity: 'medium',
+                            message: 'MCP tool handler without rate limiting',
+                            remediation: 'Add rate limiting to prevent abuse',
+                            confidence: 'high'
+                        });
+                    }
+                    return findings;
+                },
+                remediation: 'Implement rate limiting for all MCP tools',
+                references: ['Issue #174 - Rate Limiting Implementation']
+            },
+            {
+                id: 'DMCP-SEC-004',
+                name: 'Unicode Validation Missing',
+                description: 'User input processed without Unicode normalization',
+                severity: 'medium',
+                category: 'custom',
+                check: (content, context) => {
+                    const findings = [];
+                    // Check for user input processing without Unicode validation
+                    const inputPattern = /(?:req\.|request\.|params|query|body|content)/;
+                    const hasUnicodeCheck = /UnicodeValidator|normalizeUnicode/i.test(content);
+                    if (inputPattern.test(content) && !hasUnicodeCheck) {
+                        findings.push({
+                            ruleId: 'DMCP-SEC-004',
+                            severity: 'medium',
+                            message: 'User input processed without Unicode normalization',
+                            remediation: 'Use UnicodeValidator.normalize() on all user input',
+                            confidence: 'medium'
+                        });
+                    }
+                    return findings;
+                },
+                remediation: 'Apply Unicode normalization to prevent bypass attacks',
+                references: ['Issue #162 - Unicode Normalization']
+            },
+            {
+                id: 'DMCP-SEC-005',
+                name: 'Unvalidated YAML Content',
+                description: 'YAML content parsed without security validation',
+                severity: 'high',
+                category: 'custom',
+                pattern: /yaml\.load\s*\(|parse\s*\([^)]*\.ya?ml/gi,
+                remediation: 'Use SecureYamlParser for all YAML parsing',
+                references: ['DollhouseMCP Security Guidelines']
+            },
+            {
+                id: 'DMCP-SEC-006',
+                name: 'Security Event Not Logged',
+                description: 'Security-relevant operation without logging',
+                severity: 'low',
+                category: 'custom',
+                check: (content, context) => {
+                    const findings = [];
+                    // Check for security operations without logging
+                    const securityOps = /(?:authenticate|authorize|validate|sanitize|encrypt|decrypt)/i;
+                    const hasLogging = /SecurityMonitor\.log|logSecurityEvent/i.test(content);
+                    if (securityOps.test(content) && !hasLogging) {
+                        findings.push({
+                            ruleId: 'DMCP-SEC-006',
+                            severity: 'low',
+                            message: 'Security operation without audit logging',
+                            remediation: 'Add SecurityMonitor.logSecurityEvent() for audit trail',
+                            confidence: 'medium'
+                        });
+                    }
+                    return findings;
+                },
+                remediation: 'Log all security-relevant operations for audit trail',
+                references: ['DollhouseMCP Security Guidelines']
+            }
+        ];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SecurityRules.js","sourceRoot":"","sources":["../../../../../../src/security/audit/rules/SecurityRules.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Security Rules - Defines security patterns and checks\n * Based on OWASP Top 10, CWE Top 25, and DollhouseMCP-specific security requirements\n */\n\nimport type { SecurityRule, SecurityFinding } from '../types.js';\n\nexport class SecurityRules {\n  /**\n   * OWASP Top 10 security rules\n   */\n  getOWASPRules(): SecurityRule[] {\n    return [\n      {\n        id: 'OWASP-A01-001',\n        name: 'Hardcoded Secrets',\n        description: 'Potential hardcoded secret or API key detected',\n        severity: 'critical',\n        category: 'code',\n        pattern: /(?:api[_-]?key|secret|password|token|private[_-]?key)\\s*[:=]\\s*[\"'][a-zA-Z0-9+/=_-]{10,}[\"']/gi,\n        remediation: 'Use environment variables or secure key management services instead of hardcoding secrets',\n        references: ['https://owasp.org/Top10/A01_2021-Broken_Access_Control/'],\n        tags: ['high-confidence']\n      },\n      {\n        id: 'OWASP-A03-001',\n        name: 'SQL Injection',\n        description: 'Potential SQL injection vulnerability',\n        severity: 'critical',\n        category: 'code',\n        pattern: /(?:query|execute)\\s*\\(\\s*['\"`].*\\$\\{[^}]+\\}.*['\"`]|['\"`].*\\+\\s*[a-zA-Z_]\\w*\\s*\\+.*['\"`]\\s*\\)/g,\n        remediation: 'Use parameterized queries or prepared statements',\n        references: ['https://owasp.org/Top10/A03_2021-Injection/']\n      },\n      {\n        id: 'OWASP-A03-002',\n        name: 'Command Injection',\n        description: 'Potential command injection vulnerability',\n        severity: 'critical',\n        category: 'code',\n        pattern: /(?:exec|spawn|execSync|spawnSync)\\s*\\([^)]*(?:\\$\\{[^}]+\\}|\\+\\s*[a-zA-Z_]\\w*)/g,\n        remediation: 'Validate and sanitize all user input before using in system commands',\n        references: ['https://owasp.org/Top10/A03_2021-Injection/']\n      },\n      {\n        id: 'OWASP-A03-003',\n        name: 'Path Traversal',\n        description: 'Potential path traversal vulnerability',\n        severity: 'high',\n        category: 'code',\n        pattern: /(?:readFile|writeFile|readdir|mkdir|rm|unlink)[^(]*\\([^)]*(?:\\.\\.[/\\\\].*\\+|\\+.*\\.\\.[/\\\\])/g,\n        remediation: 'Validate and sanitize file paths, use path.resolve() and check against allowed directories',\n        references: ['https://owasp.org/Top10/A03_2021-Injection/']\n      },\n      {\n        id: 'OWASP-A03-004',\n        name: 'XSS - Direct HTML Injection',\n        description: 'Potential XSS vulnerability through direct HTML injection',\n        severity: 'high',\n        category: 'code',\n        pattern: /innerHTML\\s*=\\s*[^'\"`]*\\$\\{|dangerouslySetInnerHTML/g,\n        remediation: 'Use textContent or proper HTML escaping functions',\n        references: ['https://owasp.org/Top10/A03_2021-Injection/']\n      },\n      {\n        id: 'OWASP-A05-001',\n        name: 'Insecure Configuration',\n        description: 'Security-sensitive configuration detected',\n        severity: 'medium',\n        category: 'code',\n        pattern: /(?:NODE_TLS_REJECT_UNAUTHORIZED|strictSSL|rejectUnauthorized)\\s*[:=]\\s*(?:false|0|[\"']false[\"']|[\"']0[\"'])/gi,\n        remediation: 'Enable SSL/TLS certificate validation in production',\n        references: ['https://owasp.org/Top10/A05_2021-Security_Misconfiguration/']\n      },\n      {\n        id: 'OWASP-A07-001',\n        name: 'Weak Authentication',\n        description: 'Potential weak authentication mechanism',\n        severity: 'high',\n        category: 'code',\n        pattern: /(?:md5|sha1)\\s*\\(/gi,\n        remediation: 'Use strong hashing algorithms like bcrypt, scrypt, or Argon2 for passwords',\n        references: ['https://owasp.org/Top10/A07_2021-Identification_and_Authentication_Failures/']\n      }\n    ];\n  }\n\n  /**\n   * CWE Top 25 security rules\n   */\n  getCWERules(): SecurityRule[] {\n    return [\n      {\n        id: 'CWE-79-001',\n        name: 'Reflected XSS',\n        description: 'User input reflected without encoding',\n        severity: 'high',\n        category: 'code',\n        pattern: /res\\.(?:send|write|end)\\s*\\([^)]*(?:req\\.(?:query|params|body)|request\\.)/g,\n        remediation: 'Encode all user input before reflecting in responses',\n        references: ['https://cwe.mitre.org/data/definitions/79.html']\n      },\n      {\n        id: 'CWE-89-001',\n        name: 'SQL String Concatenation',\n        description: 'SQL query built using string concatenation',\n        severity: 'critical',\n        category: 'code',\n        pattern: /[\"'`].*(?:SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER).*[\"'`]\\s*\\+\\s*\\w+/gi,\n        remediation: 'Use parameterized queries instead of string concatenation',\n        references: ['https://cwe.mitre.org/data/definitions/89.html']\n      },\n      {\n        id: 'CWE-22-001',\n        name: 'Path Manipulation',\n        description: 'File path constructed from user input',\n        severity: 'high',\n        category: 'code',\n        pattern: /path\\.join\\s*\\([^)]*(?:req\\.|request\\.|params|query|body)/g,\n        remediation: 'Validate paths against a whitelist and use path.resolve()',\n        references: ['https://cwe.mitre.org/data/definitions/22.html']\n      },\n      {\n        id: 'CWE-798-001',\n        name: 'Hardcoded Credentials',\n        description: 'Credentials hardcoded in source',\n        severity: 'critical',\n        category: 'code',\n        pattern: /(?:username|user|login)\\s*[:=]\\s*[\"'][^\"']+[\"'].*(?:password|pass|pwd)\\s*[:=]\\s*[\"'][^\"']+[\"']/gi,\n        remediation: 'Store credentials in environment variables or secure vaults',\n        references: ['https://cwe.mitre.org/data/definitions/798.html']\n      }\n    ];\n  }\n\n  /**\n   * DollhouseMCP-specific security rules\n   */\n  getDollhouseMCPRules(): SecurityRule[] {\n    return [\n      {\n        id: 'DMCP-SEC-001',\n        name: 'Unsafe Persona Loading',\n        description: 'Persona loaded without validation',\n        severity: 'high',\n        category: 'custom',\n        pattern: /loadPersona\\s*\\([^)]*\\)\\s*(?!.*validate)/g,\n        remediation: 'Always validate personas before loading using PersonaValidator',\n        references: ['DollhouseMCP Security Guidelines']\n      },\n      {\n        id: 'DMCP-SEC-002',\n        name: 'Token Validation Bypass',\n        description: 'Token used without validation',\n        severity: 'critical',\n        category: 'custom',\n        pattern: /(?:getToken|useToken|token\\.use)\\s*\\([^)]*\\)(?!.*(?:validate|verify|check))/gi,\n        remediation: 'Always validate tokens using TokenManager.validateToken()',\n        references: ['DollhouseMCP Security Guidelines']\n      },\n      {\n        id: 'DMCP-SEC-003',\n        name: 'Rate Limiting Missing',\n        description: 'API endpoint without rate limiting',\n        severity: 'medium',\n        category: 'custom',\n        check: (content, context) => {\n          const findings: SecurityFinding[] = [];\n          // Check for MCP tool handlers without rate limiting\n          const toolPattern = /name:\\s*[\"']([^\"']+)[\"'].*handle:/gs;\n          const hasRateLimit = /rateLimiter|checkRateLimit|tokenBucket/i.test(content);\n          \n          if (toolPattern.test(content) && !hasRateLimit) {\n            findings.push({\n              ruleId: 'DMCP-SEC-003',\n              severity: 'medium' as const,\n              message: 'MCP tool handler without rate limiting',\n              remediation: 'Add rate limiting to prevent abuse',\n              confidence: 'high' as const\n            });\n          }\n          \n          return findings;\n        },\n        remediation: 'Implement rate limiting for all MCP tools',\n        references: ['Issue #174 - Rate Limiting Implementation']\n      },\n      {\n        id: 'DMCP-SEC-004',\n        name: 'Unicode Validation Missing',\n        description: 'User input processed without Unicode normalization',\n        severity: 'medium',\n        category: 'custom',\n        check: (content, context) => {\n          const findings: SecurityFinding[] = [];\n          // Check for user input processing without Unicode validation\n          const inputPattern = /(?:req\\.|request\\.|params|query|body|content)/;\n          const hasUnicodeCheck = /UnicodeValidator|normalizeUnicode/i.test(content);\n          \n          if (inputPattern.test(content) && !hasUnicodeCheck) {\n            findings.push({\n              ruleId: 'DMCP-SEC-004',\n              severity: 'medium' as const,\n              message: 'User input processed without Unicode normalization',\n              remediation: 'Use UnicodeValidator.normalize() on all user input',\n              confidence: 'medium' as const\n            });\n          }\n          \n          return findings;\n        },\n        remediation: 'Apply Unicode normalization to prevent bypass attacks',\n        references: ['Issue #162 - Unicode Normalization']\n      },\n      {\n        id: 'DMCP-SEC-005',\n        name: 'Unvalidated YAML Content',\n        description: 'YAML content parsed without security validation',\n        severity: 'high',\n        category: 'custom',\n        pattern: /yaml\\.load\\s*\\(|parse\\s*\\([^)]*\\.ya?ml/gi,\n        remediation: 'Use SecureYamlParser for all YAML parsing',\n        references: ['DollhouseMCP Security Guidelines']\n      },\n      {\n        id: 'DMCP-SEC-006',\n        name: 'Security Event Not Logged',\n        description: 'Security-relevant operation without logging',\n        severity: 'low',\n        category: 'custom',\n        check: (content, context) => {\n          const findings: SecurityFinding[] = [];\n          // Check for security operations without logging\n          const securityOps = /(?:authenticate|authorize|validate|sanitize|encrypt|decrypt)/i;\n          const hasLogging = /SecurityMonitor\\.log|logSecurityEvent/i.test(content);\n          \n          if (securityOps.test(content) && !hasLogging) {\n            findings.push({\n              ruleId: 'DMCP-SEC-006',\n              severity: 'low' as const,\n              message: 'Security operation without audit logging',\n              remediation: 'Add SecurityMonitor.logSecurityEvent() for audit trail',\n              confidence: 'medium' as const\n            });\n          }\n          \n          return findings;\n        },\n        remediation: 'Log all security-relevant operations for audit trail',\n        references: ['DollhouseMCP Security Guidelines']\n      }\n    ];\n  }\n}"]}

package/dist/test/src/security/audit/scanners/CodeScanner.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Code Scanner - Static code analysis for security vulnerabilities
+ * Detects common security issues in source code
+ */
+import type { SecurityScanner, SecurityFinding, ScanContext } from '../types.js';
+interface CodeScannerConfig {
+    enabled: boolean;
+    rules: string[];
+    exclude?: string[];
+}
+export declare class CodeScanner implements SecurityScanner {
+    name: string;
+    private config;
+    private rules;
+    constructor(config: CodeScannerConfig);
+    /**
+     * Load security rules based on configuration
+     */
+    private loadRules;
+    /**
+     * Scan files for security vulnerabilities
+     */
+    scan(context: ScanContext): Promise<SecurityFinding[]>;
+    /**
+     * Get list of files to scan
+     */
+    private getFilesToScan;
+    /**
+     * Scan a single file for vulnerabilities
+     */
+    private scanFile;
+    /**
+     * Find pattern matches in content
+     */
+    private findPatternMatches;
+    /**
+     * Convert string index to line and column
+     */
+    private getLineAndColumn;
+    /**
+     * Calculate confidence level for a finding
+     */
+    private calculateConfidence;
+    isEnabled(): boolean;
+}
+export {};
+//# sourceMappingURL=CodeScanner.d.ts.map

package/dist/test/src/security/audit/scanners/CodeScanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodeScanner.d.ts","sourceRoot":"","sources":["../../../../../../src/security/audit/scanners/CodeScanner.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,WAAW,EAAgB,MAAM,aAAa,CAAC;AAM/F,UAAU,iBAAiB;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,qBAAa,WAAY,YAAW,eAAe;IACjD,IAAI,SAAiB;IACrB,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,KAAK,CAAsB;gBAEvB,MAAM,EAAE,iBAAiB;IAKrC;;OAEG;IACH,OAAO,CAAC,SAAS;IAqBjB;;OAEG;IACG,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAkB5D;;OAEG;YACW,cAAc;IAiB5B;;OAEG;YACW,QAAQ;IAkDtB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA4B1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAQxB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAwB3B,SAAS,IAAI,OAAO;CAGrB"}

package/dist/test/src/security/audit/scanners/CodeScanner.js

@@ -0,0 +1,174 @@
+/**
+ * Code Scanner - Static code analysis for security vulnerabilities
+ * Detects common security issues in source code
+ */
+import { SecurityRules } from '../rules/SecurityRules.js';
+import fs from 'fs/promises';
+import path from 'path';
+import { glob } from 'glob';
+export class CodeScanner {
+    name = 'CodeScanner';
+    config;
+    rules = [];
+    constructor(config) {
+        this.config = config;
+        this.loadRules();
+    }
+    /**
+     * Load security rules based on configuration
+     */
+    loadRules() {
+        const ruleLoader = new SecurityRules();
+        for (const ruleSet of this.config.rules) {
+            switch (ruleSet) {
+                case 'OWASP-Top-10':
+                    this.rules.push(...ruleLoader.getOWASPRules());
+                    break;
+                case 'CWE-Top-25':
+                    this.rules.push(...ruleLoader.getCWERules());
+                    break;
+                case 'DollhouseMCP-Security':
+                    this.rules.push(...ruleLoader.getDollhouseMCPRules());
+                    break;
+                default:
+                    // Custom rule sets can be added here
+                    break;
+            }
+        }
+    }
+    /**
+     * Scan files for security vulnerabilities
+     */
+    async scan(context) {
+        const findings = [];
+        const files = await this.getFilesToScan(context.projectRoot);
+        for (const file of files) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                const fileFindings = await this.scanFile(file, content, context);
+                findings.push(...fileFindings);
+            }
+            catch (error) {
+                // Skip files that can't be read
+                continue;
+            }
+        }
+        return findings;
+    }
+    /**
+     * Get list of files to scan
+     */
+    async getFilesToScan(projectRoot) {
+        const patterns = ['**/*.ts', '**/*.js', '**/*.jsx', '**/*.tsx', '**/*.json', '**/*.yml', '**/*.yaml'];
+        const ignore = this.config.exclude || ['node_modules/**', 'dist/**', 'coverage/**'];
+        const files = [];
+        for (const pattern of patterns) {
+            const matches = await glob(pattern, {
+                cwd: projectRoot,
+                ignore,
+                absolute: true
+            });
+            files.push(...matches);
+        }
+        return files;
+    }
+    /**
+     * Scan a single file for vulnerabilities
+     */
+    async scanFile(filePath, content, context) {
+        const findings = [];
+        const lines = content.split('\n');
+        const fileContext = {
+            ...context,
+            fileType: path.extname(filePath),
+            isTest: filePath.includes('test') || filePath.includes('spec')
+        };
+        for (const rule of this.rules) {
+            // Skip test-specific rules in non-test files
+            if (rule.tags?.includes('test-only') && !fileContext.isTest) {
+                continue;
+            }
+            // Pattern-based detection
+            if (rule.pattern) {
+                const matches = this.findPatternMatches(content, lines, rule);
+                for (const match of matches) {
+                    findings.push({
+                        ruleId: rule.id,
+                        severity: rule.severity,
+                        message: `${rule.name}: ${match.message}`,
+                        file: filePath,
+                        line: match.line,
+                        column: match.column,
+                        code: match.code,
+                        remediation: rule.remediation,
+                        confidence: this.calculateConfidence(match, rule, fileContext)
+                    });
+                }
+            }
+            // Custom check function
+            if (rule.check) {
+                const customFindings = rule.check(content, fileContext);
+                findings.push(...customFindings.map(f => ({
+                    ...f,
+                    file: filePath
+                })));
+            }
+        }
+        return findings;
+    }
+    /**
+     * Find pattern matches in content
+     */
+    findPatternMatches(content, lines, rule) {
+        const matches = [];
+        if (!rule.pattern)
+            return matches;
+        // Reset regex state
+        rule.pattern.lastIndex = 0;
+        let match;
+        while ((match = rule.pattern.exec(content)) !== null) {
+            const position = this.getLineAndColumn(content, match.index);
+            const code = lines[position.line - 1]?.trim() || '';
+            matches.push({
+                line: position.line,
+                column: position.column,
+                code: code.substring(0, 100), // Limit code snippet length
+                message: rule.description
+            });
+        }
+        return matches;
+    }
+    /**
+     * Convert string index to line and column
+     */
+    getLineAndColumn(content, index) {
+        const lines = content.substring(0, index).split('\n');
+        return {
+            line: lines.length,
+            column: lines[lines.length - 1].length + 1
+        };
+    }
+    /**
+     * Calculate confidence level for a finding
+     */
+    calculateConfidence(match, rule, context) {
+        // High confidence for exact pattern matches
+        if (rule.tags?.includes('high-confidence')) {
+            return 'high';
+        }
+        // Low confidence in test files
+        if (context.isTest) {
+            return 'low';
+        }
+        // Check for common false positive indicators
+        const code = match.code.toLowerCase();
+        if (code.includes('example') || code.includes('test') || code.includes('demo')) {
+            return 'low';
+        }
+        return 'medium';
+    }
+    isEnabled() {
+        return this.config.enabled;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CodeScanner.js","sourceRoot":"","sources":["../../../../../../src/security/audit/scanners/CodeScanner.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Code Scanner - Static code analysis for security vulnerabilities\n * Detects common security issues in source code\n */\n\nimport type { SecurityScanner, SecurityFinding, ScanContext, SecurityRule } from '../types.js';\nimport { SecurityRules } from '../rules/SecurityRules.js';\nimport fs from 'fs/promises';\nimport path from 'path';\nimport { glob } from 'glob';\n\ninterface CodeScannerConfig {\n  enabled: boolean;\n  rules: string[];\n  exclude?: string[];\n}\n\nexport class CodeScanner implements SecurityScanner {\n  name = 'CodeScanner';\n  private config: CodeScannerConfig;\n  private rules: SecurityRule[] = [];\n\n  constructor(config: CodeScannerConfig) {\n    this.config = config;\n    this.loadRules();\n  }\n\n  /**\n   * Load security rules based on configuration\n   */\n  private loadRules(): void {\n    const ruleLoader = new SecurityRules();\n    \n    for (const ruleSet of this.config.rules) {\n      switch (ruleSet) {\n        case 'OWASP-Top-10':\n          this.rules.push(...ruleLoader.getOWASPRules());\n          break;\n        case 'CWE-Top-25':\n          this.rules.push(...ruleLoader.getCWERules());\n          break;\n        case 'DollhouseMCP-Security':\n          this.rules.push(...ruleLoader.getDollhouseMCPRules());\n          break;\n        default:\n          // Custom rule sets can be added here\n          break;\n      }\n    }\n  }\n\n  /**\n   * Scan files for security vulnerabilities\n   */\n  async scan(context: ScanContext): Promise<SecurityFinding[]> {\n    const findings: SecurityFinding[] = [];\n    const files = await this.getFilesToScan(context.projectRoot);\n\n    for (const file of files) {\n      try {\n        const content = await fs.readFile(file, 'utf-8');\n        const fileFindings = await this.scanFile(file, content, context);\n        findings.push(...fileFindings);\n      } catch (error) {\n        // Skip files that can't be read\n        continue;\n      }\n    }\n\n    return findings;\n  }\n\n  /**\n   * Get list of files to scan\n   */\n  private async getFilesToScan(projectRoot: string): Promise<string[]> {\n    const patterns = ['**/*.ts', '**/*.js', '**/*.jsx', '**/*.tsx', '**/*.json', '**/*.yml', '**/*.yaml'];\n    const ignore = this.config.exclude || ['node_modules/**', 'dist/**', 'coverage/**'];\n    \n    const files: string[] = [];\n    for (const pattern of patterns) {\n      const matches = await glob(pattern, {\n        cwd: projectRoot,\n        ignore,\n        absolute: true\n      });\n      files.push(...matches);\n    }\n    \n    return files;\n  }\n\n  /**\n   * Scan a single file for vulnerabilities\n   */\n  private async scanFile(\n    filePath: string, \n    content: string, \n    context: ScanContext\n  ): Promise<SecurityFinding[]> {\n    const findings: SecurityFinding[] = [];\n    const lines = content.split('\\n');\n    const fileContext = {\n      ...context,\n      fileType: path.extname(filePath),\n      isTest: filePath.includes('test') || filePath.includes('spec')\n    };\n\n    for (const rule of this.rules) {\n      // Skip test-specific rules in non-test files\n      if (rule.tags?.includes('test-only') && !fileContext.isTest) {\n        continue;\n      }\n\n      // Pattern-based detection\n      if (rule.pattern) {\n        const matches = this.findPatternMatches(content, lines, rule);\n        for (const match of matches) {\n          findings.push({\n            ruleId: rule.id,\n            severity: rule.severity,\n            message: `${rule.name}: ${match.message}`,\n            file: filePath,\n            line: match.line,\n            column: match.column,\n            code: match.code,\n            remediation: rule.remediation,\n            confidence: this.calculateConfidence(match, rule, fileContext)\n          });\n        }\n      }\n\n      // Custom check function\n      if (rule.check) {\n        const customFindings = rule.check(content, fileContext);\n        findings.push(...customFindings.map(f => ({\n          ...f,\n          file: filePath\n        })));\n      }\n    }\n\n    return findings;\n  }\n\n  /**\n   * Find pattern matches in content\n   */\n  private findPatternMatches(\n    content: string, \n    lines: string[], \n    rule: SecurityRule\n  ): Array<{line: number; column: number; code: string; message: string}> {\n    const matches: Array<{line: number; column: number; code: string; message: string}> = [];\n    \n    if (!rule.pattern) return matches;\n\n    // Reset regex state\n    rule.pattern.lastIndex = 0;\n    \n    let match;\n    while ((match = rule.pattern.exec(content)) !== null) {\n      const position = this.getLineAndColumn(content, match.index);\n      const code = lines[position.line - 1]?.trim() || '';\n      \n      matches.push({\n        line: position.line,\n        column: position.column,\n        code: code.substring(0, 100), // Limit code snippet length\n        message: rule.description\n      });\n    }\n\n    return matches;\n  }\n\n  /**\n   * Convert string index to line and column\n   */\n  private getLineAndColumn(content: string, index: number): {line: number; column: number} {\n    const lines = content.substring(0, index).split('\\n');\n    return {\n      line: lines.length,\n      column: lines[lines.length - 1].length + 1\n    };\n  }\n\n  /**\n   * Calculate confidence level for a finding\n   */\n  private calculateConfidence(\n    match: any, \n    rule: SecurityRule, \n    context: ScanContext\n  ): 'low' | 'medium' | 'high' {\n    // High confidence for exact pattern matches\n    if (rule.tags?.includes('high-confidence')) {\n      return 'high';\n    }\n\n    // Low confidence in test files\n    if (context.isTest) {\n      return 'low';\n    }\n\n    // Check for common false positive indicators\n    const code = match.code.toLowerCase();\n    if (code.includes('example') || code.includes('test') || code.includes('demo')) {\n      return 'low';\n    }\n\n    return 'medium';\n  }\n\n  isEnabled(): boolean {\n    return this.config.enabled;\n  }\n}"]}

package/dist/test/src/security/audit/scanners/ConfigurationScanner.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Configuration Scanner - Scans configuration files for security issues
+ * Placeholder implementation - to be completed
+ */
+import type { SecurityScanner, SecurityFinding, ScanContext } from '../types.js';
+export declare class ConfigurationScanner implements SecurityScanner {
+    name: string;
+    private config;
+    constructor(config: any);
+    scan(context: ScanContext): Promise<SecurityFinding[]>;
+    isEnabled(): boolean;
+}
+//# sourceMappingURL=ConfigurationScanner.d.ts.map

package/dist/test/src/security/audit/scanners/ConfigurationScanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigurationScanner.d.ts","sourceRoot":"","sources":["../../../../../../src/security/audit/scanners/ConfigurationScanner.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAEjF,qBAAa,oBAAqB,YAAW,eAAe;IAC1D,IAAI,SAA0B;IAC9B,OAAO,CAAC,MAAM,CAAM;gBAER,MAAM,EAAE,GAAG;IAIjB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAQ5D,SAAS,IAAI,OAAO;CAGrB"}

package/dist/test/src/security/audit/scanners/ConfigurationScanner.js

@@ -0,0 +1,22 @@
+/**
+ * Configuration Scanner - Scans configuration files for security issues
+ * Placeholder implementation - to be completed
+ */
+export class ConfigurationScanner {
+    name = 'ConfigurationScanner';
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async scan(context) {
+        // TODO: Implement configuration scanning
+        // - Check for insecure defaults
+        // - Validate security headers
+        // - Check authentication settings
+        return [];
+    }
+    isEnabled() {
+        return this.config.enabled;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29uZmlndXJhdGlvblNjYW5uZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvc2VjdXJpdHkvYXVkaXQvc2Nhbm5lcnMvQ29uZmlndXJhdGlvblNjYW5uZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBSUgsTUFBTSxPQUFPLG9CQUFvQjtJQUMvQixJQUFJLEdBQUcsc0JBQXNCLENBQUM7SUFDdEIsTUFBTSxDQUFNO0lBRXBCLFlBQVksTUFBVztRQUNyQixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztJQUN2QixDQUFDO0lBRUQsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFvQjtRQUM3Qix5Q0FBeUM7UUFDekMsZ0NBQWdDO1FBQ2hDLDhCQUE4QjtRQUM5QixrQ0FBa0M7UUFDbEMsT0FBTyxFQUFFLENBQUM7SUFDWixDQUFDO0lBRUQsU0FBUztRQUNQLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUM7SUFDN0IsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb25maWd1cmF0aW9uIFNjYW5uZXIgLSBTY2FucyBjb25maWd1cmF0aW9uIGZpbGVzIGZvciBzZWN1cml0eSBpc3N1ZXNcbiAqIFBsYWNlaG9sZGVyIGltcGxlbWVudGF0aW9uIC0gdG8gYmUgY29tcGxldGVkXG4gKi9cblxuaW1wb3J0IHR5cGUgeyBTZWN1cml0eVNjYW5uZXIsIFNlY3VyaXR5RmluZGluZywgU2NhbkNvbnRleHQgfSBmcm9tICcuLi90eXBlcy5qcyc7XG5cbmV4cG9ydCBjbGFzcyBDb25maWd1cmF0aW9uU2Nhbm5lciBpbXBsZW1lbnRzIFNlY3VyaXR5U2Nhbm5lciB7XG4gIG5hbWUgPSAnQ29uZmlndXJhdGlvblNjYW5uZXInO1xuICBwcml2YXRlIGNvbmZpZzogYW55O1xuXG4gIGNvbnN0cnVjdG9yKGNvbmZpZzogYW55KSB7XG4gICAgdGhpcy5jb25maWcgPSBjb25maWc7XG4gIH1cblxuICBhc3luYyBzY2FuKGNvbnRleHQ6IFNjYW5Db250ZXh0KTogUHJvbWlzZTxTZWN1cml0eUZpbmRpbmdbXT4ge1xuICAgIC8vIFRPRE86IEltcGxlbWVudCBjb25maWd1cmF0aW9uIHNjYW5uaW5nXG4gICAgLy8gLSBDaGVjayBmb3IgaW5zZWN1cmUgZGVmYXVsdHNcbiAgICAvLyAtIFZhbGlkYXRlIHNlY3VyaXR5IGhlYWRlcnNcbiAgICAvLyAtIENoZWNrIGF1dGhlbnRpY2F0aW9uIHNldHRpbmdzXG4gICAgcmV0dXJuIFtdO1xuICB9XG5cbiAgaXNFbmFibGVkKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLmNvbmZpZy5lbmFibGVkO1xuICB9XG59Il19

package/dist/test/src/security/audit/scanners/DependencyScanner.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Dependency Scanner - Scans for vulnerabilities in dependencies
+ * Placeholder implementation - to be completed
+ */
+import type { SecurityScanner, SecurityFinding, ScanContext } from '../types.js';
+export declare class DependencyScanner implements SecurityScanner {
+    name: string;
+    private config;
+    constructor(config: any);
+    scan(context: ScanContext): Promise<SecurityFinding[]>;
+    isEnabled(): boolean;
+}
+//# sourceMappingURL=DependencyScanner.d.ts.map

package/dist/test/src/security/audit/scanners/DependencyScanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DependencyScanner.d.ts","sourceRoot":"","sources":["../../../../../../src/security/audit/scanners/DependencyScanner.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAEjF,qBAAa,iBAAkB,YAAW,eAAe;IACvD,IAAI,SAAuB;IAC3B,OAAO,CAAC,MAAM,CAAM;gBAER,MAAM,EAAE,GAAG;IAIjB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAQ5D,SAAS,IAAI,OAAO;CAGrB"}

package/dist/test/src/security/audit/scanners/DependencyScanner.js

@@ -0,0 +1,22 @@
+/**
+ * Dependency Scanner - Scans for vulnerabilities in dependencies
+ * Placeholder implementation - to be completed
+ */
+export class DependencyScanner {
+    name = 'DependencyScanner';
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async scan(context) {
+        // TODO: Implement dependency scanning
+        // - Run npm audit
+        // - Check GitHub Advisory Database
+        // - Validate licenses
+        return [];
+    }
+    isEnabled() {
+        return this.config.enabled;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVwZW5kZW5jeVNjYW5uZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvc2VjdXJpdHkvYXVkaXQvc2Nhbm5lcnMvRGVwZW5kZW5jeVNjYW5uZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBSUgsTUFBTSxPQUFPLGlCQUFpQjtJQUM1QixJQUFJLEdBQUcsbUJBQW1CLENBQUM7SUFDbkIsTUFBTSxDQUFNO0lBRXBCLFlBQVksTUFBVztRQUNyQixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztJQUN2QixDQUFDO0lBRUQsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFvQjtRQUM3QixzQ0FBc0M7UUFDdEMsa0JBQWtCO1FBQ2xCLG1DQUFtQztRQUNuQyxzQkFBc0I7UUFDdEIsT0FBTyxFQUFFLENBQUM7SUFDWixDQUFDO0lBRUQsU0FBUztRQUNQLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUM7SUFDN0IsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBEZXBlbmRlbmN5IFNjYW5uZXIgLSBTY2FucyBmb3IgdnVsbmVyYWJpbGl0aWVzIGluIGRlcGVuZGVuY2llc1xuICogUGxhY2Vob2xkZXIgaW1wbGVtZW50YXRpb24gLSB0byBiZSBjb21wbGV0ZWRcbiAqL1xuXG5pbXBvcnQgdHlwZSB7IFNlY3VyaXR5U2Nhbm5lciwgU2VjdXJpdHlGaW5kaW5nLCBTY2FuQ29udGV4dCB9IGZyb20gJy4uL3R5cGVzLmpzJztcblxuZXhwb3J0IGNsYXNzIERlcGVuZGVuY3lTY2FubmVyIGltcGxlbWVudHMgU2VjdXJpdHlTY2FubmVyIHtcbiAgbmFtZSA9ICdEZXBlbmRlbmN5U2Nhbm5lcic7XG4gIHByaXZhdGUgY29uZmlnOiBhbnk7XG5cbiAgY29uc3RydWN0b3IoY29uZmlnOiBhbnkpIHtcbiAgICB0aGlzLmNvbmZpZyA9IGNvbmZpZztcbiAgfVxuXG4gIGFzeW5jIHNjYW4oY29udGV4dDogU2NhbkNvbnRleHQpOiBQcm9taXNlPFNlY3VyaXR5RmluZGluZ1tdPiB7XG4gICAgLy8gVE9ETzogSW1wbGVtZW50IGRlcGVuZGVuY3kgc2Nhbm5pbmdcbiAgICAvLyAtIFJ1biBucG0gYXVkaXRcbiAgICAvLyAtIENoZWNrIEdpdEh1YiBBZHZpc29yeSBEYXRhYmFzZVxuICAgIC8vIC0gVmFsaWRhdGUgbGljZW5zZXNcbiAgICByZXR1cm4gW107XG4gIH1cblxuICBpc0VuYWJsZWQoKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuY29uZmlnLmVuYWJsZWQ7XG4gIH1cbn0iXX0=