@dollhousemcp/mcp-server 1.3.0

package/dist/test/test/__tests__/integration/helpers/file-utils.js

@@ -0,0 +1,83 @@
+/**
+ * File system utilities for integration tests
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import matter from 'gray-matter';
+import { createPersonaFileContent } from './test-fixtures.js';
+/**
+ * Create a test persona file
+ */
+export async function createTestPersonaFile(personasDir, persona) {
+    const filePath = path.join(personasDir, persona.filename);
+    const content = createPersonaFileContent(persona);
+    await fs.writeFile(filePath, content, 'utf-8');
+    return filePath;
+}
+/**
+ * Create multiple test persona files
+ */
+export async function createTestPersonaFiles(personasDir, personas) {
+    return Promise.all(personas.map(persona => createTestPersonaFile(personasDir, persona)));
+}
+/**
+ * Clean a directory
+ */
+export async function cleanDirectory(dir) {
+    try {
+        const files = await fs.readdir(dir);
+        await Promise.all(files.map(file => fs.unlink(path.join(dir, file))));
+    }
+    catch (error) {
+        // Directory might not exist or be empty
+    }
+}
+/**
+ * Check if a file exists
+ */
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Read a persona file and parse it
+ */
+export async function readPersonaFile(filePath) {
+    const content = await fs.readFile(filePath, 'utf-8');
+    const parsed = matter(content);
+    return {
+        metadata: parsed.data,
+        content: parsed.content.trim()
+    };
+}
+/**
+ * Wait for a file to exist (useful for async operations)
+ */
+export async function waitForFile(filePath, timeout = 5000) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+        if (await fileExists(filePath)) {
+            return;
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    throw new Error(`File ${filePath} did not appear within ${timeout}ms`);
+}
+/**
+ * Create a temporary directory for a test
+ */
+export async function createTempDir(prefix) {
+    const baseDir = process.env.TEST_BASE_DIR;
+    if (!baseDir) {
+        throw new Error('TEST_BASE_DIR environment variable is not set. Ensure the test setup has run properly.');
+    }
+    const tempDir = path.join(baseDir, `${prefix}-${Date.now()}`);
+    await fs.mkdir(tempDir, { recursive: true });
+    return tempDir;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/test/__tests__/integration/helpers/test-fixtures.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Test fixtures for integration tests
+ */
+import { Persona } from '../../../../src/types/persona.js';
+export declare const TEST_PERSONAS: {
+    creative: Persona;
+    technical: Persona;
+};
+export declare const MOCK_GITHUB_RESPONSES: {
+    collectionContents: {
+        creative: {
+            name: string;
+            path: string;
+            type: string;
+            size: number;
+            sha: string;
+        }[];
+    };
+    personaFile: {
+        content: string;
+        encoding: string;
+    };
+};
+export declare function createTestPersona(overrides?: Partial<Persona>): Persona;
+export declare function createPersonaFileContent(persona: Persona): string;
+//# sourceMappingURL=test-fixtures.d.ts.map

package/dist/test/test/__tests__/integration/helpers/test-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-fixtures.d.ts","sourceRoot":"","sources":["../../../../../../test/__tests__/integration/helpers/test-fixtures.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAmB,MAAM,kCAAkC,CAAC;AAE5E,eAAO,MAAM,aAAa;cAenB,OAAO;eAgBP,OAAO;CACb,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;CAgCjC,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,SAAS,GAAE,OAAO,CAAC,OAAO,CAAM,GAAG,OAAO,CAU3E;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAgBjE"}

package/dist/test/test/__tests__/integration/helpers/test-fixtures.js

@@ -0,0 +1,95 @@
+/**
+ * Test fixtures for integration tests
+ */
+export const TEST_PERSONAS = {
+    creative: {
+        metadata: {
+            name: 'Creative Writer',
+            description: 'A creative writing assistant',
+            category: 'creative',
+            version: '1.0',
+            author: 'test-user',
+            unique_id: 'creative-writer_20250101-120000_test-user',
+            triggers: ['creative', 'writing', 'story'],
+            created_date: '2025-01-01T12:00:00Z'
+        },
+        content: 'You are a creative writing assistant focused on storytelling and narrative development. Help users craft compelling stories, develop characters, and create engaging narratives.',
+        filename: 'creative-writer.md',
+        unique_id: 'creative-writer_20250101-120000_test-user'
+    },
+    technical: {
+        metadata: {
+            name: 'Technical Assistant',
+            description: 'A technical documentation helper',
+            category: 'professional',
+            version: '1.0',
+            author: 'test-user',
+            unique_id: 'technical-assistant_20250101-120000_test-user',
+            triggers: ['technical', 'documentation', 'api'],
+            created_date: '2025-01-01T12:00:00Z'
+        },
+        content: 'You are a technical documentation assistant specializing in API documentation, code comments, and technical writing. Help users create clear, comprehensive technical documentation.',
+        filename: 'technical-assistant.md',
+        unique_id: 'technical-assistant_20250101-120000_test-user'
+    }
+};
+export const MOCK_GITHUB_RESPONSES = {
+    collectionContents: {
+        creative: [
+            {
+                name: 'storyteller.md',
+                path: 'creative/storyteller.md',
+                type: 'file',
+                size: 1234,
+                sha: 'abc123'
+            },
+            {
+                name: 'poet.md',
+                path: 'creative/poet.md',
+                type: 'file',
+                size: 567,
+                sha: 'def456'
+            }
+        ]
+    },
+    personaFile: {
+        content: Buffer.from(`---
+name: Storyteller
+description: Master storyteller for engaging narratives
+category: creative
+author: collection
+version: 1.0
+---
+
+You are a master storyteller.`).toString('base64'),
+        encoding: 'base64'
+    }
+};
+export function createTestPersona(overrides = {}) {
+    const base = { ...TEST_PERSONAS.creative };
+    return {
+        ...base,
+        ...overrides,
+        metadata: {
+            ...base.metadata,
+            ...(overrides.metadata || {})
+        }
+    };
+}
+export function createPersonaFileContent(persona) {
+    const frontmatter = Object.entries(persona.metadata)
+        .filter(([key]) => key !== 'unique_id') // Don't include in file
+        .map(([key, value]) => {
+        if (Array.isArray(value)) {
+            return `${key}: [${value.join(', ')}]`;
+        }
+        return `${key}: ${value}`;
+    })
+        .join('\n');
+    return `---
+${frontmatter}
+---
+
+${persona.content}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/test/__tests__/integration/helpers/test-server.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Test helper for integration tests
+ */
+import { PersonaManager } from '../../../../src/persona/PersonaManager.js';
+import { GitHubClient } from '../../../../src/collection/GitHubClient.js';
+import { APICache } from '../../../../src/cache/APICache.js';
+export interface TestServerOptions {
+    personasDir?: string;
+    mockGitHub?: boolean;
+}
+export declare class TestServer {
+    personaManager: PersonaManager;
+    githubClient: GitHubClient;
+    apiCache: APICache;
+    rateLimitTracker: Map<string, number[]>;
+    constructor(options?: TestServerOptions);
+    /**
+     * Initialize the server and load personas
+     */
+    initialize(): Promise<void>;
+    /**
+     * Clean up resources
+     */
+    cleanup(): Promise<void>;
+}
+//# sourceMappingURL=test-server.d.ts.map

package/dist/test/test/__tests__/integration/helpers/test-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-server.d.ts","sourceRoot":"","sources":["../../../../../../test/__tests__/integration/helpers/test-server.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAC1E,OAAO,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AAG7D,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,qBAAa,UAAU;IACd,cAAc,EAAE,cAAc,CAAC;IAC/B,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,QAAQ,CAAC;IACnB,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;gBAEnC,OAAO,GAAE,iBAAsB;IAmB3C;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK/B"}

package/dist/test/test/__tests__/integration/helpers/test-server.js

@@ -0,0 +1,41 @@
+/**
+ * Test helper for integration tests
+ */
+import { PersonaManager } from '../../../../src/persona/PersonaManager.js';
+import { GitHubClient } from '../../../../src/collection/GitHubClient.js';
+import { APICache } from '../../../../src/cache/APICache.js';
+import { DEFAULT_INDICATOR_CONFIG } from '../../../../src/config/indicator-config.js';
+export class TestServer {
+    personaManager;
+    githubClient;
+    apiCache;
+    rateLimitTracker;
+    constructor(options = {}) {
+        const personasDir = options.personasDir || process.env.TEST_PERSONAS_DIR;
+        if (!personasDir) {
+            throw new Error('TEST_PERSONAS_DIR environment variable is not set. ' +
+                'Please ensure the integration test setup has run properly.');
+        }
+        // Create core components
+        this.personaManager = new PersonaManager(personasDir, DEFAULT_INDICATOR_CONFIG);
+        this.apiCache = new APICache();
+        this.rateLimitTracker = new Map();
+        // Create GitHub client
+        this.githubClient = new GitHubClient(this.apiCache, this.rateLimitTracker);
+    }
+    /**
+     * Initialize the server and load personas
+     */
+    async initialize() {
+        await this.personaManager.initialize();
+    }
+    /**
+     * Clean up resources
+     */
+    async cleanup() {
+        // Any cleanup needed
+        this.apiCache.clear();
+        this.rateLimitTracker.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/test/__tests__/integration/setup.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Global setup for integration tests
+ */
+export declare const TEST_BASE_DIR: string;
+export declare const TEST_PERSONAS_DIR: string;
+export declare const TEST_CACHE_DIR: string;
+export default function globalSetup(): Promise<void>;
+//# sourceMappingURL=setup.d.ts.map

package/dist/test/test/__tests__/integration/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../../test/__tests__/integration/setup.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,eAAO,MAAM,aAAa,QAAwC,CAAC;AACnE,eAAO,MAAM,iBAAiB,QAAuC,CAAC;AACtE,eAAO,MAAM,cAAc,QAAoC,CAAC;AAEhE,wBAA8B,WAAW,kBAuBxC"}

package/dist/test/test/__tests__/integration/setup.js

@@ -0,0 +1,31 @@
+/**
+ * Global setup for integration tests
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// Test directories
+export const TEST_BASE_DIR = path.join(process.cwd(), '.test-tmp');
+export const TEST_PERSONAS_DIR = path.join(TEST_BASE_DIR, 'personas');
+export const TEST_CACHE_DIR = path.join(TEST_BASE_DIR, 'cache');
+export default async function globalSetup() {
+    console.log('\n🔧 Setting up integration test environment...\n');
+    // Clean up any existing test directories
+    try {
+        await fs.rm(TEST_BASE_DIR, { recursive: true, force: true });
+    }
+    catch (error) {
+        // Directory might not exist, that's fine
+    }
+    // Create fresh test directories
+    await fs.mkdir(TEST_BASE_DIR, { recursive: true });
+    await fs.mkdir(TEST_PERSONAS_DIR, { recursive: true });
+    await fs.mkdir(TEST_CACHE_DIR, { recursive: true });
+    // Set environment variables for tests
+    process.env.TEST_MODE = 'integration';
+    process.env.TEST_BASE_DIR = TEST_BASE_DIR;
+    process.env.TEST_PERSONAS_DIR = TEST_PERSONAS_DIR;
+    process.env.TEST_CACHE_DIR = TEST_CACHE_DIR;
+    console.log(`✅ Test directories created at: ${TEST_BASE_DIR}`);
+    console.log('✅ Integration test environment ready\n');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/test/__tests__/integration/teardown.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Global teardown for integration tests
+ */
+export default function globalTeardown(): Promise<void>;
+//# sourceMappingURL=teardown.d.ts.map

package/dist/test/test/__tests__/integration/teardown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"teardown.d.ts","sourceRoot":"","sources":["../../../../../test/__tests__/integration/teardown.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,wBAA8B,cAAc,kBAgB3C"}

package/dist/test/test/__tests__/integration/teardown.js

@@ -0,0 +1,23 @@
+/**
+ * Global teardown for integration tests
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+const TEST_BASE_DIR = path.join(process.cwd(), '.test-tmp');
+export default async function globalTeardown() {
+    console.log('\n🧹 Cleaning up integration test environment...\n');
+    // Clean up test directories
+    try {
+        await fs.rm(TEST_BASE_DIR, { recursive: true, force: true });
+        console.log('✅ Test directories cleaned up\n');
+    }
+    catch (error) {
+        console.error('⚠️  Failed to clean up test directories:', error);
+    }
+    // Clear test environment variables
+    delete process.env.TEST_MODE;
+    delete process.env.TEST_BASE_DIR;
+    delete process.env.TEST_PERSONAS_DIR;
+    delete process.env.TEST_CACHE_DIR;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,34 @@
+/**
+ * Rapid Security Testing for CI/CD
+ * Focuses on critical vulnerabilities that can be tested quickly
+ */
+export interface SecurityTestResult {
+    test: string;
+    passed: boolean;
+    severity: 'CRITICAL' | 'HIGH' | 'MEDIUM';
+    error?: string;
+    duration: number;
+}
+export declare class RapidSecurityTesting {
+    private results;
+    private server;
+    constructor();
+    /**
+     * Run critical security tests only
+     * Target: < 30 seconds total runtime
+     */
+    runCriticalTests(): Promise<SecurityTestResult[]>;
+    /**
+     * Generate security report
+     */
+    generateReport(): string;
+    private testCommandInjection;
+    private testPathTraversal;
+    private testYamlDeserialization;
+    private testTokenExposure;
+}
+/**
+ * Pre-commit hook integration
+ */
+export declare function preCommitSecurityCheck(): Promise<boolean>;
+//# sourceMappingURL=RapidSecurityTesting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RapidSecurityTesting.d.ts","sourceRoot":"","sources":["../../../../../../test/__tests__/security/framework/RapidSecurityTesting.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,MAAM,CAAqB;;IAMnC;;;OAGG;IACG,gBAAgB,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAYvD;;OAEG;IACH,cAAc,IAAI,MAAM;YA4BV,oBAAoB;YA2CpB,iBAAiB;YAyCjB,uBAAuB;YA2CvB,iBAAiB;CA2ChC;AAED;;GAEG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,OAAO,CAAC,CAiB/D"}