@dollhousemcp/mcp-server 1.5.1 → 1.6.0

package/dist/collection/CollectionSeeder.js

@@ -0,0 +1,267 @@
+/**
+ * Collection seeder for anonymous/offline browsing
+ * Provides basic collection data that doesn't require GitHub authentication
+ */
+/**
+ * Basic collection data that can be used without GitHub API access
+ * This provides a minimal set of well-known collection items
+ */
+export class CollectionSeeder {
+    // Cache the seed data as a static property for memory efficiency
+    static cachedSeedData = null;
+    /**
+     * Get seed data for the collection cache
+     * This includes popular/essential items that are commonly requested
+     * Data is cached as a static property to avoid recreation on every call
+     */
+    static getSeedData() {
+        // Return cached data if available
+        if (CollectionSeeder.cachedSeedData) {
+            return CollectionSeeder.cachedSeedData;
+        }
+        // Create and cache the seed data
+        CollectionSeeder.cachedSeedData = [
+            // Popular Personas
+            {
+                name: 'creative-writer.md',
+                path: 'library/personas/creative-writer.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'eli5-explainer.md',
+                path: 'library/personas/eli5-explainer.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'debug-detective.md',
+                path: 'library/personas/debug-detective.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'technical-analyst.md',
+                path: 'library/personas/technical-analyst.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'business-consultant.md',
+                path: 'library/personas/business-consultant.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'security-analyst.md',
+                path: 'library/personas/security-analyst.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            // Popular Skills
+            {
+                name: 'code-review.md',
+                path: 'library/skills/code-review.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'creative-writing.md',
+                path: 'library/skills/creative-writing.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'data-analysis.md',
+                path: 'library/skills/data-analysis.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'research.md',
+                path: 'library/skills/research.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'translation.md',
+                path: 'library/skills/translation.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'threat-modeling.md',
+                path: 'library/skills/threat-modeling.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'penetration-testing.md',
+                path: 'library/skills/penetration-testing.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            // Popular Agents
+            {
+                name: 'code-reviewer.md',
+                path: 'library/agents/code-reviewer.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'research-assistant.md',
+                path: 'library/agents/research-assistant.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'task-manager.md',
+                path: 'library/agents/task-manager.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            // Popular Templates
+            {
+                name: 'code-documentation.md',
+                path: 'library/templates/code-documentation.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'email-professional.md',
+                path: 'library/templates/email-professional.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'meeting-notes.md',
+                path: 'library/templates/meeting-notes.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'project-brief.md',
+                path: 'library/templates/project-brief.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'report-executive.md',
+                path: 'library/templates/report-executive.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'penetration-test-report.md',
+                path: 'library/templates/penetration-test-report.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'security-vulnerability-report.md',
+                path: 'library/templates/security-vulnerability-report.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'threat-assessment-report.md',
+                path: 'library/templates/threat-assessment-report.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            // Popular Ensembles
+            {
+                name: 'business-advisor.md',
+                path: 'library/ensembles/business-advisor.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'creative-studio.md',
+                path: 'library/ensembles/creative-studio.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'development-team.md',
+                path: 'library/ensembles/development-team.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'security-analysis-team.md',
+                path: 'library/ensembles/security-analysis-team.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            // Test Elements for E2E Testing
+            {
+                name: 'safe-roundtrip-tester.md',
+                path: 'library/skills/safe-roundtrip-tester.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'roundtrip-test-skill.md',
+                path: 'library/skills/roundtrip-test-skill.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'test-validator.md',
+                path: 'library/skills/test-validator.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'sample-skill.md',
+                path: 'library/skills/sample-skill.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'test-element.md',
+                path: 'library/agents/test-element.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            },
+            {
+                name: 'testing-framework.md',
+                path: 'library/templates/testing-framework.md',
+                sha: 'seed-data',
+                last_modified: new Date().toISOString()
+            }
+        ];
+        return CollectionSeeder.cachedSeedData;
+    }
+    /**
+     * Get collection statistics from seed data
+     */
+    static getSeedStats() {
+        const seedData = this.getSeedData();
+        const typeCount = new Map();
+        seedData.forEach(item => {
+            // Extract type from path (library/personas/name.md -> personas)
+            const pathParts = item.path.split('/');
+            const type = pathParts[1] || 'unknown';
+            typeCount.set(type, (typeCount.get(type) || 0) + 1);
+        });
+        return {
+            total: seedData.length,
+            byType: Object.fromEntries(typeCount)
+        };
+    }
+    /**
+     * Check if an item is available in seed data
+     */
+    static isItemInSeedData(path) {
+        return this.getSeedData().some(item => item.path === path);
+    }
+    /**
+     * Get seed item by path
+     */
+    static getSeedItem(path) {
+        return this.getSeedData().find(item => item.path === path);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CollectionSeeder.js","sourceRoot":"","sources":["../../src/collection/CollectionSeeder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Collection seeder for anonymous/offline browsing\n * Provides basic collection data that doesn't require GitHub authentication\n */\n\nimport { CollectionItem } from '../cache/CollectionCache.js';\n\n/**\n * Basic collection data that can be used without GitHub API access\n * This provides a minimal set of well-known collection items\n */\nexport class CollectionSeeder {\n  // Cache the seed data as a static property for memory efficiency\n  private static cachedSeedData: CollectionItem[] | null = null;\n  \n  /**\n   * Get seed data for the collection cache\n   * This includes popular/essential items that are commonly requested\n   * Data is cached as a static property to avoid recreation on every call\n   */\n  static getSeedData(): CollectionItem[] {\n    // Return cached data if available\n    if (CollectionSeeder.cachedSeedData) {\n      return CollectionSeeder.cachedSeedData;\n    }\n    \n    // Create and cache the seed data\n    CollectionSeeder.cachedSeedData = [\n      // Popular Personas\n      {\n        name: 'creative-writer.md',\n        path: 'library/personas/creative-writer.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'eli5-explainer.md',\n        path: 'library/personas/eli5-explainer.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'debug-detective.md',\n        path: 'library/personas/debug-detective.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'technical-analyst.md',\n        path: 'library/personas/technical-analyst.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'business-consultant.md',\n        path: 'library/personas/business-consultant.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'security-analyst.md',\n        path: 'library/personas/security-analyst.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      \n      // Popular Skills\n      {\n        name: 'code-review.md',\n        path: 'library/skills/code-review.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'creative-writing.md',\n        path: 'library/skills/creative-writing.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'data-analysis.md',\n        path: 'library/skills/data-analysis.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'research.md',\n        path: 'library/skills/research.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'translation.md',\n        path: 'library/skills/translation.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'threat-modeling.md',\n        path: 'library/skills/threat-modeling.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'penetration-testing.md',\n        path: 'library/skills/penetration-testing.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      \n      // Popular Agents\n      {\n        name: 'code-reviewer.md',\n        path: 'library/agents/code-reviewer.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'research-assistant.md',\n        path: 'library/agents/research-assistant.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'task-manager.md',\n        path: 'library/agents/task-manager.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      \n      // Popular Templates\n      {\n        name: 'code-documentation.md',\n        path: 'library/templates/code-documentation.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'email-professional.md',\n        path: 'library/templates/email-professional.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'meeting-notes.md',\n        path: 'library/templates/meeting-notes.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'project-brief.md',\n        path: 'library/templates/project-brief.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'report-executive.md',\n        path: 'library/templates/report-executive.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'penetration-test-report.md',\n        path: 'library/templates/penetration-test-report.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'security-vulnerability-report.md',\n        path: 'library/templates/security-vulnerability-report.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'threat-assessment-report.md',\n        path: 'library/templates/threat-assessment-report.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      \n      // Popular Ensembles\n      {\n        name: 'business-advisor.md',\n        path: 'library/ensembles/business-advisor.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'creative-studio.md',\n        path: 'library/ensembles/creative-studio.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'development-team.md',\n        path: 'library/ensembles/development-team.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'security-analysis-team.md',\n        path: 'library/ensembles/security-analysis-team.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      \n      // Test Elements for E2E Testing\n      {\n        name: 'safe-roundtrip-tester.md',\n        path: 'library/skills/safe-roundtrip-tester.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'roundtrip-test-skill.md',\n        path: 'library/skills/roundtrip-test-skill.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'test-validator.md',\n        path: 'library/skills/test-validator.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'sample-skill.md',\n        path: 'library/skills/sample-skill.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'test-element.md',\n        path: 'library/agents/test-element.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      },\n      {\n        name: 'testing-framework.md',\n        path: 'library/templates/testing-framework.md',\n        sha: 'seed-data',\n        last_modified: new Date().toISOString()\n      }\n    ];\n    \n    return CollectionSeeder.cachedSeedData;\n  }\n  \n  /**\n   * Get collection statistics from seed data\n   */\n  static getSeedStats() {\n    const seedData = this.getSeedData();\n    const typeCount = new Map<string, number>();\n    \n    seedData.forEach(item => {\n      // Extract type from path (library/personas/name.md -> personas)\n      const pathParts = item.path.split('/');\n      const type = pathParts[1] || 'unknown';\n      typeCount.set(type, (typeCount.get(type) || 0) + 1);\n    });\n    \n    return {\n      total: seedData.length,\n      byType: Object.fromEntries(typeCount)\n    };\n  }\n  \n  /**\n   * Check if an item is available in seed data\n   */\n  static isItemInSeedData(path: string): boolean {\n    return this.getSeedData().some(item => item.path === path);\n  }\n  \n  /**\n   * Get seed item by path\n   */\n  static getSeedItem(path: string): CollectionItem | undefined {\n    return this.getSeedData().find(item => item.path === path);\n  }\n}"]}

package/dist/collection/ElementInstaller.d.ts

@@ -1,6 +1,22 @@
 /**
  * Install AI customization elements from collection
  * Supports all element types: personas, skills, templates, agents, memories, ensembles
+ *
+ * SECURITY FIX (2025-08-12): Fixed critical vulnerability where content was written to disk
+ * BEFORE validation was complete. This could allow malicious content to persist on the
+ * filesystem even when validation failed. The fix implements:
+ *
+ * 1. VALIDATE-BEFORE-WRITE PATTERN: All content validation (ContentValidator.sanitizePersonaContent,
+ *    SecureYamlParser.safeMatter, metadata validation, etc.) is now performed BEFORE any disk operations.
+ *
+ * 2. ATOMIC FILE OPERATIONS: Uses temporary file + atomic rename to prevent partial file corruption
+ *    and ensure complete cleanup on any failure during the write process.
+ *
+ * 3. GUARANTEED CLEANUP: If any part of the write operation fails, temporary files are automatically
+ *    cleaned up, preventing orphaned malicious content on the filesystem.
+ *
+ * The vulnerability existed in installContent() where fs.writeFile() was called after validation
+ * but before final success confirmation, creating a window where malicious content could persist.
  */
 import { GitHubClient } from './GitHubClient.js';
 import { IElementMetadata } from '../types/elements/IElement.js';
@@ -13,6 +29,9 @@ export declare class ElementInstaller {
     /**
      * Install AI customization element from the collection
      * Automatically detects element type from path structure
+     *
+     * SECURITY FIX: Implements validate-before-write pattern with atomic operations
+     * to prevent malicious content persistence on validation failure.
      */
     installContent(inputPath: string): Promise<{
         success: boolean;
@@ -21,6 +40,18 @@ export declare class ElementInstaller {
         elementType?: ElementType;
         filename?: string;
     }>;
+    /**
+     * Atomic file write operation with guaranteed cleanup on failure
+     *
+     * SECURITY FIX: This method ensures that file writes are atomic and any
+     * failures during the write process will not leave partial or corrupted
+     * files on the filesystem. Uses temporary file + rename for atomicity.
+     *
+     * @param destination - Final destination path for the file
+     * @param content - Content to write to the file
+     * @throws Error if write operation fails (with guaranteed cleanup)
+     */
+    private atomicWriteFile;
     /**
      * Get ElementType from string
      */

package/dist/collection/ElementInstaller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ElementInstaller.d.ts","sourceRoot":"","sources":["../../src/collection/ElementInstaller.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAMjE,OAAO,EAAoB,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAEjF,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,OAAO,CAAmE;gBAEtE,YAAY,EAAE,YAAY;IAKtC;;;OAGG;IACG,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAC/C,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;QAC5B,WAAW,CAAC,EAAE,WAAW,CAAC;QAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;IA+FF;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAgBhC;;OAEG;IACH,oBAAoB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,GAAG,MAAM;CAmBrG"}
+{"version":3,"file":"ElementInstaller.d.ts","sourceRoot":"","sources":["../../src/collection/ElementInstaller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAMjE,OAAO,EAAoB,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAEjF,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,OAAO,CAAmE;gBAEtE,YAAY,EAAE,YAAY;IAKtC;;;;;;OAMG;IACG,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAC/C,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;QAC5B,WAAW,CAAC,EAAE,WAAW,CAAC;QAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;IAqGF;;;;;;;;;;OAUG;YACW,eAAe;IA8B7B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAgBhC;;OAEG;IACH,oBAAoB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,GAAG,MAAM;CAmBrG"}

package/dist/collection/ElementInstaller.js

@@ -1,6 +1,22 @@
 /**
  * Install AI customization elements from collection
  * Supports all element types: personas, skills, templates, agents, memories, ensembles
+ *
+ * SECURITY FIX (2025-08-12): Fixed critical vulnerability where content was written to disk
+ * BEFORE validation was complete. This could allow malicious content to persist on the
+ * filesystem even when validation failed. The fix implements:
+ *
+ * 1. VALIDATE-BEFORE-WRITE PATTERN: All content validation (ContentValidator.sanitizePersonaContent,
+ *    SecureYamlParser.safeMatter, metadata validation, etc.) is now performed BEFORE any disk operations.
+ *
+ * 2. ATOMIC FILE OPERATIONS: Uses temporary file + atomic rename to prevent partial file corruption
+ *    and ensure complete cleanup on any failure during the write process.
+ *
+ * 3. GUARANTEED CLEANUP: If any part of the write operation fails, temporary files are automatically
+ *    cleaned up, preventing orphaned malicious content on the filesystem.
+ *
+ * The vulnerability existed in installContent() where fs.writeFile() was called after validation
+ * but before final success confirmation, creating a window where malicious content could persist.
  */
 import * as fs from 'fs/promises';
 import * as path from 'path';
@@ -21,11 +37,14 @@ export class ElementInstaller {
     /**
      * Install AI customization element from the collection
      * Automatically detects element type from path structure
+     *
+     * SECURITY FIX: Implements validate-before-write pattern with atomic operations
+     * to prevent malicious content persistence on validation failure.
      */
     async installContent(inputPath) {
-        // Validate and sanitize the input path
+        // SECURITY: Validate and sanitize the input path first
         const sanitizedPath = validatePath(inputPath);
-        // Detect element type from path structure
+        // SECURITY: Detect element type from path structure and validate format
         // Expected format: library/[element-type]/[category]/[element].md
         const pathParts = sanitizedPath.split('/');
         if (pathParts.length < 3 || pathParts[0] !== 'library') {
@@ -33,26 +52,29 @@ export class ElementInstaller {
         }
         const elementTypeStr = pathParts[1];
         const elementType = this.getElementTypeFromString(elementTypeStr);
-        // Ensure the path ends with .md
+        // SECURITY: Ensure the path ends with .md to prevent arbitrary file types
         if (!sanitizedPath.endsWith('.md')) {
             throw new Error('Invalid file type. Only .md files are allowed.');
         }
+        // STEP 1: FETCH CONTENT INTO MEMORY (NO DISK OPERATIONS YET)
         const url = `${this.baseUrl}/${sanitizedPath}`;
         const data = await this.githubClient.fetchFromGitHub(url);
         if (data.type !== 'file') {
             throw new Error('Path does not point to a file');
         }
-        // Check file size before downloading
+        // SECURITY: Check file size before downloading to prevent DoS attacks
         if (data.size > SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES) {
             throw new Error(`File too large (${data.size} bytes, max ${SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES} bytes)`);
         }
-        // Decode Base64 content
+        // Decode Base64 content into memory only
         const content = Buffer.from(data.content, 'base64').toString('utf-8');
-        // Validate content size after decoding
+        // STEP 2: PERFORM ALL VALIDATION BEFORE ANY DISK OPERATIONS
+        // This is the critical security fix - validate everything in memory first
+        // SECURITY: Validate content size after decoding
         validateContentSize(content, SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES);
-        // Sanitize content for security threats
+        // SECURITY: Sanitize content for security threats (XSS, injection, etc.)
         const sanitizedContent = ContentValidator.sanitizePersonaContent(content);
-        // Use secure YAML parser
+        // SECURITY: Use secure YAML parser to prevent YAML bombs and injection
         let parsed;
         try {
             parsed = SecureYamlParser.safeMatter(sanitizedContent);
@@ -64,22 +86,22 @@ export class ElementInstaller {
             throw error;
         }
         const metadata = parsed.data;
-        // Additional metadata validation for injection attacks
+        // SECURITY: Additional metadata validation for injection attacks
         const metadataValidation = ContentValidator.validateMetadata(metadata);
         if (!metadataValidation.isValid) {
             throw new Error(`Security validation failed: ${metadataValidation.detectedPatterns?.join(', ')}`);
         }
-        // Validate metadata
+        // SECURITY: Validate required metadata fields
         if (!metadata.name || !metadata.description) {
             throw new Error('Invalid content: missing required name or description');
         }
-        // Generate and validate local filename
+        // SECURITY: Generate and validate local filename to prevent path traversal
         const originalFilename = sanitizedPath.split('/').pop() || 'downloaded-element.md';
         const filename = validateFilename(originalFilename);
         // Get appropriate directory for element type
         const elementDir = this.portfolioManager.getElementDir(elementType);
         const localPath = path.join(elementDir, filename);
-        // Check if file already exists
+        // SECURITY: Check if file already exists before any write operations
         try {
             await fs.access(localPath);
             return {
@@ -90,8 +112,10 @@ export class ElementInstaller {
         catch {
             // File doesn't exist, proceed with installation
         }
-        // Write the sanitized file
-        await fs.writeFile(localPath, sanitizedContent, 'utf-8');
+        // STEP 3: ALL VALIDATION COMPLETE - NOW PERFORM ATOMIC WRITE OPERATION
+        // SECURITY FIX: Use atomic write to prevent partial file corruption and
+        // ensure cleanup on any failure during the write process
+        await this.atomicWriteFile(localPath, sanitizedContent);
         return {
             success: true,
             message: `AI customization element installed successfully!`,
@@ -100,6 +124,44 @@ export class ElementInstaller {
             elementType
         };
     }
+    /**
+     * Atomic file write operation with guaranteed cleanup on failure
+     *
+     * SECURITY FIX: This method ensures that file writes are atomic and any
+     * failures during the write process will not leave partial or corrupted
+     * files on the filesystem. Uses temporary file + rename for atomicity.
+     *
+     * @param destination - Final destination path for the file
+     * @param content - Content to write to the file
+     * @throws Error if write operation fails (with guaranteed cleanup)
+     */
+    async atomicWriteFile(destination, content) {
+        // Generate unique temporary file name to avoid collisions
+        const tempFile = `${destination}.tmp.${Date.now()}.${Math.random().toString(36).substring(2)}`;
+        try {
+            // SECURITY: Write to temporary file first
+            // If this fails, no files are left on disk
+            await fs.writeFile(tempFile, content, 'utf-8');
+            // SECURITY: Atomic rename operation
+            // On most filesystems, rename is atomic - the file appears with complete content
+            // or doesn't appear at all. This prevents partial file corruption.
+            await fs.rename(tempFile, destination);
+        }
+        catch (error) {
+            // SECURITY: Guaranteed cleanup of temporary file on ANY failure
+            // This ensures no temporary files are left behind even if the
+            // rename operation fails after successful write
+            try {
+                await fs.unlink(tempFile);
+            }
+            catch (cleanupError) {
+                // Ignore cleanup errors - the file may not exist if writeFile failed
+                // The original error is more important to propagate
+            }
+            // Re-throw the original error to maintain error handling semantics
+            throw error;
+        }
+    }
     /**
      * Get ElementType from string
      */
@@ -137,4 +199,4 @@ export class ElementInstaller {
             `🚀 **Ready to use!**`;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ElementInstaller.js","sourceRoot":"","sources":["../../src/collection/ElementInstaller.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAG7B,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpG,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAEjF,MAAM,OAAO,gBAAgB;IACnB,YAAY,CAAe;IAC3B,gBAAgB,CAAmB;IACnC,OAAO,GAAG,+DAA+D,CAAC;IAElF,YAAY,YAA0B;QACpC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;IACzD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,cAAc,CAAC,SAAiB;QAOpC,uCAAuC;QACvC,MAAM,aAAa,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;QAE9C,0CAA0C;QAC1C,kEAAkE;QAClE,MAAM,SAAS,GAAG,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC3C,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;YACvD,MAAM,IAAI,KAAK,CAAC,0FAA0F,CAAC,CAAC;QAC9G,CAAC;QAED,MAAM,cAAc,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;QACpC,MAAM,WAAW,GAAG,IAAI,CAAC,wBAAwB,CAAC,cAAc,CAAC,CAAC;QAElE,gCAAgC;QAChC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;QACpE,CAAC;QAED,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,OAAO,IAAI,aAAa,EAAE,CAAC;QAC/C,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;QAE1D,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;QACnD,CAAC;QAED,qCAAqC;QACrC,IAAI,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC,sBAAsB,EAAE,CAAC;YACvD,MAAM,IAAI,KAAK,CAAC,mBAAmB,IAAI,CAAC,IAAI,eAAe,eAAe,CAAC,sBAAsB,SAAS,CAAC,CAAC;QAC9G,CAAC;QAED,wBAAwB;QACxB,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAEtE,uCAAuC;QACvC,mBAAmB,CAAC,OAAO,EAAE,eAAe,CAAC,sBAAsB,CAAC,CAAC;QAErE,wCAAwC;QACxC,MAAM,gBAAgB,GAAG,gBAAgB,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;QAE1E,yBAAyB;QACzB,IAAI,MAAM,CAAC;QACX,IAAI,CAAC;YACH,MAAM,GAAG,gBAAgB,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;QACzD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,aAAa,EAAE,CAAC;gBACnC,MAAM,IAAI,KAAK,CAAC,+BAA+B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAClE,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAwB,CAAC;QAEjD,uDAAuD;QACvD,MAAM,kBAAkB,GAAG,gBAAgB,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QACvE,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,+BAA+B,kBAAkB,CAAC,gBAAgB,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACpG,CAAC;QAED,oBAAoB;QACpB,IAAI,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;YAC5C,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;QAC3E,CAAC;QAED,uCAAuC;QACvC,MAAM,gBAAgB,GAAG,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,IAAI,uBAAuB,CAAC;QACnF,MAAM,QAAQ,GAAG,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;QAEpD,6CAA6C;QAC7C,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;QACpE,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QAElD,+BAA+B;QAC/B,IAAI,CAAC;YACH,MAAM,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YAC3B,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,4CAA4C,QAAQ,6CAA6C;aAC3G,CAAC;QACJ,CAAC;QAAC,MAAM,CAAC;YACP,gDAAgD;QAClD,CAAC;QAED,2BAA2B;QAC3B,MAAM,EAAE,CAAC,SAAS,CAAC,SAAS,EAAE,gBAAgB,EAAE,OAAO,CAAC,CAAC;QAEzD,OAAO;YACL,OAAO,EAAE,IAAI;YACb,OAAO,EAAE,kDAAkD;YAC3D,QAAQ;YACR,QAAQ;YACR,WAAW;SACZ,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,wBAAwB,CAAC,OAAe;QAC9C,MAAM,OAAO,GAAgC;YAC3C,UAAU,EAAE,WAAW,CAAC,OAAO;YAC/B,QAAQ,EAAE,WAAW,CAAC,KAAK;YAC3B,WAAW,EAAE,WAAW,CAAC,QAAQ;YACjC,QAAQ,EAAE,WAAW,CAAC,KAAK;SAC5B,CAAC;QAEF,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QACrC,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,yBAAyB,OAAO,kBAAkB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACvG,CAAC;QAED,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,oBAAoB,CAAC,QAA0B,EAAE,QAAgB,EAAE,WAAwB;QACzF,MAAM,UAAU,GAAgC;YAC9C,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,IAAI;YAC3B,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,IAAI;YACzB,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,IAAI;YAC5B,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,IAAI;YACzB,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,IAAI;YAC1B,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,IAAI;SAC7B,CAAC;QAEF,MAAM,KAAK,GAAG,UAAU,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC;QAC9C,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAE5E,OAAO,4DAA4D;YACjE,GAAG,KAAK,MAAM,QAAQ,CAAC,IAAI,MAAM,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI;YACnF,YAAY,QAAQ,IAAI;YACxB,gBAAgB,QAAQ,MAAM;YAC9B,sBAAsB,CAAC;IAC3B,CAAC;CACF","sourcesContent":["/**\n * Install AI customization elements from collection\n * Supports all element types: personas, skills, templates, agents, memories, ensembles\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { GitHubClient } from './GitHubClient.js';\nimport { IElementMetadata } from '../types/elements/IElement.js';\nimport { validatePath, validateFilename, validateContentSize } from '../security/InputValidator.js';\nimport { SECURITY_LIMITS } from '../security/constants.js';\nimport { ContentValidator } from '../security/contentValidator.js';\nimport { SecureYamlParser } from '../security/secureYamlParser.js';\nimport { SecurityError } from '../errors/SecurityError.js';\nimport { PortfolioManager, ElementType } from '../portfolio/PortfolioManager.js';\n\nexport class ElementInstaller {\n  private githubClient: GitHubClient;\n  private portfolioManager: PortfolioManager;\n  private baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';\n  \n  constructor(githubClient: GitHubClient) {\n    this.githubClient = githubClient;\n    this.portfolioManager = PortfolioManager.getInstance();\n  }\n  \n  /**\n   * Install AI customization element from the collection\n   * Automatically detects element type from path structure\n   */\n  async installContent(inputPath: string): Promise<{ \n    success: boolean; \n    message: string;\n    metadata?: IElementMetadata;\n    elementType?: ElementType;\n    filename?: string;\n  }> {\n    // Validate and sanitize the input path\n    const sanitizedPath = validatePath(inputPath);\n    \n    // Detect element type from path structure\n    // Expected format: library/[element-type]/[category]/[element].md\n    const pathParts = sanitizedPath.split('/');\n    if (pathParts.length < 3 || pathParts[0] !== 'library') {\n      throw new Error('Invalid collection path format. Expected: library/[element-type]/[category]/[element].md');\n    }\n    \n    const elementTypeStr = pathParts[1];\n    const elementType = this.getElementTypeFromString(elementTypeStr);\n    \n    // Ensure the path ends with .md\n    if (!sanitizedPath.endsWith('.md')) {\n      throw new Error('Invalid file type. Only .md files are allowed.');\n    }\n    \n    const url = `${this.baseUrl}/${sanitizedPath}`;\n    const data = await this.githubClient.fetchFromGitHub(url);\n    \n    if (data.type !== 'file') {\n      throw new Error('Path does not point to a file');\n    }\n    \n    // Check file size before downloading\n    if (data.size > SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES) {\n      throw new Error(`File too large (${data.size} bytes, max ${SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES} bytes)`);\n    }\n    \n    // Decode Base64 content\n    const content = Buffer.from(data.content, 'base64').toString('utf-8');\n    \n    // Validate content size after decoding\n    validateContentSize(content, SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES);\n    \n    // Sanitize content for security threats\n    const sanitizedContent = ContentValidator.sanitizePersonaContent(content);\n    \n    // Use secure YAML parser\n    let parsed;\n    try {\n      parsed = SecureYamlParser.safeMatter(sanitizedContent);\n    } catch (error) {\n      if (error instanceof SecurityError) {\n        throw new Error(`Security threat in content: ${error.message}`);\n      }\n      throw error;\n    }\n    \n    const metadata = parsed.data as IElementMetadata;\n    \n    // Additional metadata validation for injection attacks\n    const metadataValidation = ContentValidator.validateMetadata(metadata);\n    if (!metadataValidation.isValid) {\n      throw new Error(`Security validation failed: ${metadataValidation.detectedPatterns?.join(', ')}`);\n    }\n    \n    // Validate metadata\n    if (!metadata.name || !metadata.description) {\n      throw new Error('Invalid content: missing required name or description');\n    }\n    \n    // Generate and validate local filename\n    const originalFilename = sanitizedPath.split('/').pop() || 'downloaded-element.md';\n    const filename = validateFilename(originalFilename);\n    \n    // Get appropriate directory for element type\n    const elementDir = this.portfolioManager.getElementDir(elementType);\n    const localPath = path.join(elementDir, filename);\n    \n    // Check if file already exists\n    try {\n      await fs.access(localPath);\n      return {\n        success: false,\n        message: `AI customization element already exists: ${filename}\\n\\nThe element has already been installed.`\n      };\n    } catch {\n      // File doesn't exist, proceed with installation\n    }\n    \n    // Write the sanitized file\n    await fs.writeFile(localPath, sanitizedContent, 'utf-8');\n    \n    return {\n      success: true,\n      message: `AI customization element installed successfully!`,\n      metadata,\n      filename,\n      elementType\n    };\n  }\n  \n  /**\n   * Get ElementType from string\n   */\n  private getElementTypeFromString(typeStr: string): ElementType {\n    const typeMap: Record<string, ElementType> = {\n      'personas': ElementType.PERSONA,\n      'skills': ElementType.SKILL,\n      'templates': ElementType.TEMPLATE,\n      'agents': ElementType.AGENT\n    };\n    \n    const elementType = typeMap[typeStr];\n    if (!elementType) {\n      throw new Error(`Unknown element type: ${typeStr}. Valid types: ${Object.keys(typeMap).join(', ')}`);\n    }\n    \n    return elementType;\n  }\n  \n  /**\n   * Format installation success message\n   */\n  formatInstallSuccess(metadata: IElementMetadata, filename: string, elementType: ElementType): string {\n    const typeEmojis: Record<ElementType, string> = {\n      [ElementType.PERSONA]: '🎭',\n      [ElementType.SKILL]: '🎯',\n      [ElementType.TEMPLATE]: '📄',\n      [ElementType.AGENT]: '🤖',\n      [ElementType.MEMORY]: '🧠',\n      [ElementType.ENSEMBLE]: '🎼'\n    };\n    \n    const emoji = typeEmojis[elementType] || '📦';\n    const typeName = elementType.charAt(0).toUpperCase() + elementType.slice(1);\n    \n    return `✅ **AI Customization Element Installed Successfully!**\\n\\n` +\n      `${emoji} **${metadata.name}** ${metadata.author ? `by ${metadata.author}` : ''}\\n` +\n      `📁 Type: ${typeName}\\n` +\n      `📄 Saved as: ${filename}\\n\\n` +\n      `🚀 **Ready to use!**`;\n  }\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ElementInstaller.js","sourceRoot":"","sources":["../../src/collection/ElementInstaller.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Install AI customization elements from collection\n * Supports all element types: personas, skills, templates, agents, memories, ensembles\n * \n * SECURITY FIX (2025-08-12): Fixed critical vulnerability where content was written to disk\n * BEFORE validation was complete. This could allow malicious content to persist on the\n * filesystem even when validation failed. The fix implements:\n * \n * 1. VALIDATE-BEFORE-WRITE PATTERN: All content validation (ContentValidator.sanitizePersonaContent,\n *    SecureYamlParser.safeMatter, metadata validation, etc.) is now performed BEFORE any disk operations.\n * \n * 2. ATOMIC FILE OPERATIONS: Uses temporary file + atomic rename to prevent partial file corruption\n *    and ensure complete cleanup on any failure during the write process.\n * \n * 3. GUARANTEED CLEANUP: If any part of the write operation fails, temporary files are automatically\n *    cleaned up, preventing orphaned malicious content on the filesystem.\n * \n * The vulnerability existed in installContent() where fs.writeFile() was called after validation\n * but before final success confirmation, creating a window where malicious content could persist.\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { GitHubClient } from './GitHubClient.js';\nimport { IElementMetadata } from '../types/elements/IElement.js';\nimport { validatePath, validateFilename, validateContentSize } from '../security/InputValidator.js';\nimport { SECURITY_LIMITS } from '../security/constants.js';\nimport { ContentValidator } from '../security/contentValidator.js';\nimport { SecureYamlParser } from '../security/secureYamlParser.js';\nimport { SecurityError } from '../errors/SecurityError.js';\nimport { PortfolioManager, ElementType } from '../portfolio/PortfolioManager.js';\n\nexport class ElementInstaller {\n  private githubClient: GitHubClient;\n  private portfolioManager: PortfolioManager;\n  private baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';\n  \n  constructor(githubClient: GitHubClient) {\n    this.githubClient = githubClient;\n    this.portfolioManager = PortfolioManager.getInstance();\n  }\n  \n  /**\n   * Install AI customization element from the collection\n   * Automatically detects element type from path structure\n   * \n   * SECURITY FIX: Implements validate-before-write pattern with atomic operations\n   * to prevent malicious content persistence on validation failure.\n   */\n  async installContent(inputPath: string): Promise<{ \n    success: boolean; \n    message: string;\n    metadata?: IElementMetadata;\n    elementType?: ElementType;\n    filename?: string;\n  }> {\n    // SECURITY: Validate and sanitize the input path first\n    const sanitizedPath = validatePath(inputPath);\n    \n    // SECURITY: Detect element type from path structure and validate format\n    // Expected format: library/[element-type]/[category]/[element].md\n    const pathParts = sanitizedPath.split('/');\n    if (pathParts.length < 3 || pathParts[0] !== 'library') {\n      throw new Error('Invalid collection path format. Expected: library/[element-type]/[category]/[element].md');\n    }\n    \n    const elementTypeStr = pathParts[1];\n    const elementType = this.getElementTypeFromString(elementTypeStr);\n    \n    // SECURITY: Ensure the path ends with .md to prevent arbitrary file types\n    if (!sanitizedPath.endsWith('.md')) {\n      throw new Error('Invalid file type. Only .md files are allowed.');\n    }\n    \n    // STEP 1: FETCH CONTENT INTO MEMORY (NO DISK OPERATIONS YET)\n    const url = `${this.baseUrl}/${sanitizedPath}`;\n    const data = await this.githubClient.fetchFromGitHub(url);\n    \n    if (data.type !== 'file') {\n      throw new Error('Path does not point to a file');\n    }\n    \n    // SECURITY: Check file size before downloading to prevent DoS attacks\n    if (data.size > SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES) {\n      throw new Error(`File too large (${data.size} bytes, max ${SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES} bytes)`);\n    }\n    \n    // Decode Base64 content into memory only\n    const content = Buffer.from(data.content, 'base64').toString('utf-8');\n    \n    // STEP 2: PERFORM ALL VALIDATION BEFORE ANY DISK OPERATIONS\n    // This is the critical security fix - validate everything in memory first\n    \n    // SECURITY: Validate content size after decoding\n    validateContentSize(content, SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES);\n    \n    // SECURITY: Sanitize content for security threats (XSS, injection, etc.)\n    const sanitizedContent = ContentValidator.sanitizePersonaContent(content);\n    \n    // SECURITY: Use secure YAML parser to prevent YAML bombs and injection\n    let parsed;\n    try {\n      parsed = SecureYamlParser.safeMatter(sanitizedContent);\n    } catch (error) {\n      if (error instanceof SecurityError) {\n        throw new Error(`Security threat in content: ${error.message}`);\n      }\n      throw error;\n    }\n    \n    const metadata = parsed.data as IElementMetadata;\n    \n    // SECURITY: Additional metadata validation for injection attacks\n    const metadataValidation = ContentValidator.validateMetadata(metadata);\n    if (!metadataValidation.isValid) {\n      throw new Error(`Security validation failed: ${metadataValidation.detectedPatterns?.join(', ')}`);\n    }\n    \n    // SECURITY: Validate required metadata fields\n    if (!metadata.name || !metadata.description) {\n      throw new Error('Invalid content: missing required name or description');\n    }\n    \n    // SECURITY: Generate and validate local filename to prevent path traversal\n    const originalFilename = sanitizedPath.split('/').pop() || 'downloaded-element.md';\n    const filename = validateFilename(originalFilename);\n    \n    // Get appropriate directory for element type\n    const elementDir = this.portfolioManager.getElementDir(elementType);\n    const localPath = path.join(elementDir, filename);\n    \n    // SECURITY: Check if file already exists before any write operations\n    try {\n      await fs.access(localPath);\n      return {\n        success: false,\n        message: `AI customization element already exists: ${filename}\\n\\nThe element has already been installed.`\n      };\n    } catch {\n      // File doesn't exist, proceed with installation\n    }\n    \n    // STEP 3: ALL VALIDATION COMPLETE - NOW PERFORM ATOMIC WRITE OPERATION\n    // SECURITY FIX: Use atomic write to prevent partial file corruption and\n    // ensure cleanup on any failure during the write process\n    await this.atomicWriteFile(localPath, sanitizedContent);\n    \n    return {\n      success: true,\n      message: `AI customization element installed successfully!`,\n      metadata,\n      filename,\n      elementType\n    };\n  }\n\n  /**\n   * Atomic file write operation with guaranteed cleanup on failure\n   * \n   * SECURITY FIX: This method ensures that file writes are atomic and any\n   * failures during the write process will not leave partial or corrupted\n   * files on the filesystem. Uses temporary file + rename for atomicity.\n   * \n   * @param destination - Final destination path for the file\n   * @param content - Content to write to the file\n   * @throws Error if write operation fails (with guaranteed cleanup)\n   */\n  private async atomicWriteFile(destination: string, content: string): Promise<void> {\n    // Generate unique temporary file name to avoid collisions\n    const tempFile = `${destination}.tmp.${Date.now()}.${Math.random().toString(36).substring(2)}`;\n    \n    try {\n      // SECURITY: Write to temporary file first\n      // If this fails, no files are left on disk\n      await fs.writeFile(tempFile, content, 'utf-8');\n      \n      // SECURITY: Atomic rename operation\n      // On most filesystems, rename is atomic - the file appears with complete content\n      // or doesn't appear at all. This prevents partial file corruption.\n      await fs.rename(tempFile, destination);\n      \n    } catch (error) {\n      // SECURITY: Guaranteed cleanup of temporary file on ANY failure\n      // This ensures no temporary files are left behind even if the\n      // rename operation fails after successful write\n      try {\n        await fs.unlink(tempFile);\n      } catch (cleanupError) {\n        // Ignore cleanup errors - the file may not exist if writeFile failed\n        // The original error is more important to propagate\n      }\n      \n      // Re-throw the original error to maintain error handling semantics\n      throw error;\n    }\n  }\n  \n  /**\n   * Get ElementType from string\n   */\n  private getElementTypeFromString(typeStr: string): ElementType {\n    const typeMap: Record<string, ElementType> = {\n      'personas': ElementType.PERSONA,\n      'skills': ElementType.SKILL,\n      'templates': ElementType.TEMPLATE,\n      'agents': ElementType.AGENT\n    };\n    \n    const elementType = typeMap[typeStr];\n    if (!elementType) {\n      throw new Error(`Unknown element type: ${typeStr}. Valid types: ${Object.keys(typeMap).join(', ')}`);\n    }\n    \n    return elementType;\n  }\n  \n  /**\n   * Format installation success message\n   */\n  formatInstallSuccess(metadata: IElementMetadata, filename: string, elementType: ElementType): string {\n    const typeEmojis: Record<ElementType, string> = {\n      [ElementType.PERSONA]: '🎭',\n      [ElementType.SKILL]: '🎯',\n      [ElementType.TEMPLATE]: '📄',\n      [ElementType.AGENT]: '🤖',\n      [ElementType.MEMORY]: '🧠',\n      [ElementType.ENSEMBLE]: '🎼'\n    };\n    \n    const emoji = typeEmojis[elementType] || '📦';\n    const typeName = elementType.charAt(0).toUpperCase() + elementType.slice(1);\n    \n    return `✅ **AI Customization Element Installed Successfully!**\\n\\n` +\n      `${emoji} **${metadata.name}** ${metadata.author ? `by ${metadata.author}` : ''}\\n` +\n      `📁 Type: ${typeName}\\n` +\n      `📄 Saved as: ${filename}\\n\\n` +\n      `🚀 **Ready to use!**`;\n  }\n}"]}