@dollhousemcp/mcp-server 1.4.2 → 1.4.4

package/CHANGELOG.md

@@ -5,6 +5,74 @@ All notable changes to DollhouseMCP will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.4] - 2025-08-04
+
+### 🚨 Emergency Hotfix
+- **v1.4.3 was completely broken** - this release fixes critical initialization failures
+- Users on v1.4.3 must upgrade immediately as the server crashes 100% of the time
+
+### Fixed
+- **Initialization order bug**: Migration now runs before directory access
+  - Previously: Portfolio directories were created before migration could fix them
+  - Now: Migration completes before any directory operations
+- **jsdom crash on startup**: Heavy dependencies now load lazily
+  - Previously: UpdateChecker crashed during MCP initialization
+  - Now: jsdom/DOMPurify load only when needed with error handling
+- **Docker compatibility**: Server now handles read-only environments gracefully
+  - Added proper error handling for directory creation failures
+  - Server continues with limited functionality instead of crashing
+
+### Changed
+- Made UpdateManager and PersonaImporter optional during initialization
+- Improved error visibility with console.error for critical failures
+- Better fallback HTML sanitization using entity escaping
+
+## [1.4.3] - 2025-08-04
+
+### 🚨 Critical Fix
+- **Fixed NPM installation crash** caused by directory name mismatch
+  - v1.4.2 installations were completely broken on clean machines
+  - Server would crash silently with no error output
+
+### Changed
+- **BREAKING**: All element directories now use plural names consistently
+  - Portfolio directories: `personas/`, `skills/`, `templates/`, etc.
+  - Data directories: `personas/`, `skills/`, `templates/`, etc.
+  - This aligns with semantic correctness (directories contain multiple items)
+- Simplified DefaultElementProvider implementation
+  - Removed unnecessary mapping layer between directory names
+  - Code is now cleaner and more maintainable
+- Improved error logging for initialization failures
+  - Added console.error output for Claude Desktop visibility
+  - Better debugging information when issues occur
+
+### Added
+- **Automatic migration** for existing v1.4.2 installations
+  - Renames singular directories to plural automatically
+  - Preserves all existing content
+  - Logs migration progress for transparency
+- Comprehensive troubleshooting section in README
+  - Clear instructions for v1.4.2 users
+  - Directory structure documentation
+  - NPM upgrade instructions
+
+### Technical Details
+- ElementType enum values changed from singular to plural
+  - `'persona'` → `'personas'`
+  - `'skill'` → `'skills'`
+  - `'template'` → `'templates'`
+  - `'agent'` → `'agents'`
+  - `'memory'` → `'memories'`
+  - `'ensemble'` → `'ensembles'`
+- Removed `elementMappings` object from DefaultElementProvider
+- Portfolio directories now match data directory names exactly
+
+### Migration Instructions
+If upgrading from v1.4.2:
+1. Update: `npm install -g @dollhousemcp/mcp-server@latest`
+2. The server will automatically migrate your directories on first run
+3. No manual intervention required
+
 ## [1.4.0] - 2025-08-02
 
 ### Changed

package/README.md

@@ -23,7 +23,7 @@ A comprehensive Model Context Protocol (MCP) server that enables dynamic AI pers
 **🏪 Collection**: https://github.com/DollhouseMCP/collection  
 **📦 NPM Package**: https://www.npmjs.com/package/@dollhousemcp/mcp-server  
 **🌍 Website**: https://dollhousemcp.com (planned)  
-**📦 Version**: v1.4.1
+**📦 Version**: v1.4.4
 
 > **⚠️ Breaking Change Notice**: Tool names have changed from "marketplace" to "collection" terminology. Old names still work but are deprecated. See [Migration Guide](docs/MIGRATION_GUIDE_COLLECTION_RENAME.md) for details.
 
@@ -33,6 +33,9 @@ A comprehensive Model Context Protocol (MCP) server that enables dynamic AI pers
 # Install globally
 npm install -g @dollhousemcp/mcp-server
 
+# ⚠️ IMPORTANT: If you have v1.4.2 or v1.4.3, upgrade immediately:
+# npm install -g @dollhousemcp/mcp-server@latest
+
 # Add to Claude Desktop config (see path below for your OS)
 # macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
 # Windows: %APPDATA%\Claude\claude_desktop_config.json  
@@ -268,9 +271,9 @@ Add DollhouseMCP to your Claude Desktop configuration:
 **🔄 After configuration:**
 1. Save the file
 2. Restart Claude Desktop completely
-3. All 30 DollhouseMCP tools will be available
+3. All 46 DollhouseMCP tools will be available
 
-## 🛠️ Available Tools (30 Total)
+## 🛠️ Available Tools (46 Total)
 
 ### Portfolio Element Management (NEW!)
 - **`list_elements`** - List all elements of a specific type
@@ -748,7 +751,7 @@ DollhouseMCP/
 ├── scripts/                      # Management and utility scripts
 ├── Dockerfile                    # Multi-stage Docker build
 ├── docker-compose.yml           # Production and development configs
-├── package.json                 # Project config (dollhousemcp v1.4.1)
+├── package.json                 # Project config (dollhousemcp v1.4.2)
 ├── tsconfig.json                # TypeScript configuration
 ├── jest.config.cjs              # Jest test configuration
 ├── setup.sh                     # Automated installation script
@@ -898,11 +901,33 @@ export DEBUG="dollhousemcp:*"                  # Debug logging (optional)
 
 ## 🔧 Troubleshooting
 
+### ⚠️ NPM Installation Issues (v1.4.2)
+
+If the MCP server crashes on startup after NPM installation:
+1. Check your version: `npm list -g @dollhousemcp/mcp-server`
+2. If you have v1.4.2, upgrade immediately: `npm install -g @dollhousemcp/mcp-server@latest`
+3. Clear your portfolio and let it regenerate: `rm -rf ~/.dollhouse/portfolio`
+
+**Note**: v1.4.2 had a critical bug that prevented proper initialization. v1.4.3 attempted to fix this but introduced new crashes. Both issues are fixed in v1.4.4.
+
+### Directory Structure (v1.4.3+)
+
+As of v1.4.3, all element directories use plural names:
+- `~/.dollhouse/portfolio/personas/` (was `persona/` in v1.4.2)
+- `~/.dollhouse/portfolio/skills/` (was `skill/` in v1.4.2)
+- `~/.dollhouse/portfolio/templates/` (was `template/` in v1.4.2)
+- `~/.dollhouse/portfolio/agents/` (was `agent/` in v1.4.2)
+- `~/.dollhouse/portfolio/memories/` (was `memory/` in v1.4.2)
+- `~/.dollhouse/portfolio/ensembles/` (was `ensemble/` in v1.4.2)
+
+If you upgraded from v1.4.2, the server will automatically migrate your directories.
+
 ### Common Issues
 
 | Issue | Solution |
 |-------|----------|
-| **Personas not loading** | Check `personas/` directory exists and has read permissions |
+| **v1.4.2 or v1.4.3 installation broken** | Upgrade to v1.4.4+ immediately |
+| **Personas not loading** | Check `~/.dollhouse/portfolio/personas/` directory exists |
 | **Server won't start** | Run `npm run rebuild` to clean and rebuild |
 | **Collection not working** | Check internet connection and GitHub API access |
 | **User identity not saving** | Set `DOLLHOUSE_USER` environment variable before starting Claude |
@@ -1129,7 +1154,25 @@ This project is licensed under the **AGPL-3.0** License with Platform Stability
 
 ## 🏷️ Version History
 
-### v1.4.1 - August 2, 2025 (Current)
+### v1.4.4 - August 4, 2025 (Current)
+**Emergency Hotfix**:
+- 🚨 **Fixed v1.4.3 total failure** - initialization crashes fixed
+- 🔧 **Fixed jsdom crash** - heavy dependencies now load lazily
+- 🐳 **Fixed Docker compatibility** - handles read-only environments
+
+### v1.4.3 - August 4, 2025
+**Directory Structure Fix**:
+- 🚨 **Fixed NPM installation failure** but introduced new crashes
+
+### v1.4.2 - August 4, 2025
+**Critical NPM Installation Fix**:
+- 🚨 **Fixed NPM installation failure** where empty portfolios caused server crashes
+- 📦 **DefaultElementProvider** automatically populates default content on first run
+- 🔍 **Smart path detection** searches multiple NPM/Git installation locations
+- 💬 **Helpful error messages** guide new users when portfolios are empty
+- 🔒 **Security hardened** with audit logging and file integrity verification
+
+### v1.4.1 - August 2, 2025
 **NPM Installation Support**:
 - 📦 **Install MCP servers from npm packages** with full cross-platform support
 - 🔄 **Atomic operations** with transaction-based rollback on failure

package/dist/collection/MarketplaceBrowser.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Browse collection content from GitHub
+ */
+import { GitHubClient } from './GitHubClient.js';
+export declare class MarketplaceBrowser {
+    private githubClient;
+    private baseUrl;
+    constructor(githubClient: GitHubClient);
+    /**
+     * Browse collection content by section and category
+     * @param section - Top level section: library, showcase, or catalog
+     * @param category - Optional category within the section
+     */
+    browseCollection(section?: string, category?: string): Promise<{
+        items: any[];
+        categories: any[];
+        sections?: any[];
+    }>;
+    /**
+     * Format collection browse results
+     */
+    formatBrowseResults(items: any[], categories: any[], section?: string, category?: string, personaIndicator?: string): string;
+}
+//# sourceMappingURL=MarketplaceBrowser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MarketplaceBrowser.d.ts","sourceRoot":"","sources":["../../src/collection/MarketplaceBrowser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,OAAO,CAAmE;gBAEtE,YAAY,EAAE,YAAY;IAItC;;;;OAIG;IACG,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,GAAG,EAAE,CAAC;QAAC,UAAU,EAAE,GAAG,EAAE,CAAC;QAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAA;KAAE,CAAC;IA2C3H;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CA8EjI"}

package/dist/collection/MarketplaceBrowser.js

@@ -0,0 +1,115 @@
+/**
+ * Browse collection content from GitHub
+ */
+export class MarketplaceBrowser {
+    githubClient;
+    baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';
+    constructor(githubClient) {
+        this.githubClient = githubClient;
+    }
+    /**
+     * Browse collection content by section and category
+     * @param section - Top level section: library, showcase, or catalog
+     * @param category - Optional category within the section
+     */
+    async browseCollection(section, category) {
+        let url = this.baseUrl;
+        // If no section provided, show top-level sections
+        if (!section) {
+            const data = await this.githubClient.fetchFromGitHub(url);
+            if (!Array.isArray(data)) {
+                throw new Error('Invalid collection response. Expected directory listing.');
+            }
+            // Filter to only show content directories
+            const sections = data.filter((item) => item.type === 'dir' && ['library', 'showcase', 'catalog'].includes(item.name));
+            return { items: [], categories: [], sections };
+        }
+        // Browse within a section
+        url = category
+            ? `${this.baseUrl}/${section}/${category}`
+            : `${this.baseUrl}/${section}`;
+        const data = await this.githubClient.fetchFromGitHub(url);
+        if (!Array.isArray(data)) {
+            throw new Error('Invalid marketplace response. Expected directory listing.');
+        }
+        // In the library section, we have content type directories
+        if (section === 'library' && !category) {
+            const contentTypes = data.filter((item) => item.type === 'dir' && ['personas', 'skills', 'agents', 'prompts', 'templates', 'tools', 'ensembles'].includes(item.name));
+            return { items: [], categories: contentTypes };
+        }
+        const items = data.filter((item) => item.type === 'file' && item.name.endsWith('.md'));
+        const categories = data.filter((item) => item.type === 'dir');
+        return { items, categories };
+    }
+    /**
+     * Format collection browse results
+     */
+    formatBrowseResults(items, categories, section, category, personaIndicator = '') {
+        const textParts = [`${personaIndicator}🏪 **DollhouseMCP Collection**\n\n`];
+        // Show top-level sections if no section specified
+        if (!section && categories.length > 0) {
+            textParts.push(`**📚 Collection Sections (${categories.length}):**\n`);
+            categories.forEach((sec) => {
+                const sectionIcons = {
+                    'library': '📖',
+                    'showcase': '⭐',
+                    'catalog': '💎'
+                };
+                const icon = sectionIcons[sec.name] || '📁';
+                const descriptions = {
+                    'library': 'Free community content',
+                    'showcase': 'Featured high-quality content',
+                    'catalog': 'Premium content (coming soon)'
+                };
+                textParts.push(`   ${icon} **${sec.name}** - ${descriptions[sec.name] || 'Content collection'}\n`, `      Browse: \`browse_collection "${sec.name}"\`\n\n`);
+            });
+            return textParts.join('');
+        }
+        // Show content types within library section
+        if (section === 'library' && !category && categories.length > 0) {
+            textParts.push(`**📖 Library Content Types (${categories.length}):**\n`);
+            categories.forEach((cat) => {
+                const typeIcons = {
+                    'personas': '🎭',
+                    'skills': '🛠️',
+                    'agents': '🤖',
+                    'prompts': '💬',
+                    'templates': '📄',
+                    'tools': '🔧',
+                    'ensembles': '🎼'
+                };
+                const icon = typeIcons[cat.name] || '📁';
+                textParts.push(`   ${icon} **${cat.name}** - Browse: \`browse_collection "library" "${cat.name}"\`\n`);
+            });
+            textParts.push('\n');
+        }
+        else if (categories.length > 0) {
+            textParts.push(`**📁 Categories in ${section}${category ? `/${category}` : ''} (${categories.length}):**\n`);
+            categories.forEach((cat) => {
+                const browsePath = category ? `"${section}" "${category}/${cat.name}"` : `"${section}" "${cat.name}"`;
+                textParts.push(`   📂 **${cat.name}** - Browse: \`browse_collection ${browsePath}\`\n`);
+            });
+            textParts.push('\n');
+        }
+        if (items.length > 0) {
+            const contentType = category?.split('/').pop() || 'content';
+            const contentIcons = {
+                'personas': '🎭',
+                'skills': '🛠️',
+                'agents': '🤖',
+                'prompts': '💬',
+                'templates': '📄',
+                'tools': '🔧',
+                'ensembles': '🎼'
+            };
+            const icon = contentIcons[contentType] || '📄';
+            textParts.push(`**${icon} ${contentType.charAt(0).toUpperCase() + contentType.slice(1)} in ${section}${category ? `/${category}` : ''} (${items.length}):**\n`);
+            items.forEach((item) => {
+                const fullPath = section + (category ? `/${category}` : '') + `/${item.name}`;
+                textParts.push(`   ▫️ **${item.name.replace('.md', '')}**\n`, `      📥 Install: \`install_content "${fullPath}"\`\n`, `      👁️ Details: \`get_collection_content "${fullPath}"\`\n\n`);
+            });
+        }
+        return textParts.join('');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MarketplaceBrowser.js","sourceRoot":"","sources":["../../src/collection/MarketplaceBrowser.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Browse collection content from GitHub\n */\n\nimport { GitHubClient } from './GitHubClient.js';\n\nexport class MarketplaceBrowser {\n  private githubClient: GitHubClient;\n  private baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';\n  \n  constructor(githubClient: GitHubClient) {\n    this.githubClient = githubClient;\n  }\n  \n  /**\n   * Browse collection content by section and category\n   * @param section - Top level section: library, showcase, or catalog\n   * @param category - Optional category within the section\n   */\n  async browseCollection(section?: string, category?: string): Promise<{ items: any[], categories: any[], sections?: any[] }> {\n    let url = this.baseUrl;\n    \n    // If no section provided, show top-level sections\n    if (!section) {\n      const data = await this.githubClient.fetchFromGitHub(url);\n      if (!Array.isArray(data)) {\n        throw new Error('Invalid collection response. Expected directory listing.');\n      }\n      \n      // Filter to only show content directories\n      const sections = data.filter((item: any) => \n        item.type === 'dir' && ['library', 'showcase', 'catalog'].includes(item.name)\n      );\n      \n      return { items: [], categories: [], sections };\n    }\n    \n    // Browse within a section\n    url = category \n      ? `${this.baseUrl}/${section}/${category}` \n      : `${this.baseUrl}/${section}`;\n    \n    const data = await this.githubClient.fetchFromGitHub(url);\n    \n    if (!Array.isArray(data)) {\n      throw new Error('Invalid marketplace response. Expected directory listing.');\n    }\n    \n    // In the library section, we have content type directories\n    if (section === 'library' && !category) {\n      const contentTypes = data.filter((item: any) => \n        item.type === 'dir' && ['personas', 'skills', 'agents', 'prompts', 'templates', 'tools', 'ensembles'].includes(item.name)\n      );\n      return { items: [], categories: contentTypes };\n    }\n    \n    const items = data.filter((item: any) => item.type === 'file' && item.name.endsWith('.md'));\n    const categories = data.filter((item: any) => item.type === 'dir');\n    \n    return { items, categories };\n  }\n  \n  /**\n   * Format collection browse results\n   */\n  formatBrowseResults(items: any[], categories: any[], section?: string, category?: string, personaIndicator: string = ''): string {\n    const textParts = [`${personaIndicator}🏪 **DollhouseMCP Collection**\\n\\n`];\n    \n    // Show top-level sections if no section specified\n    if (!section && categories.length > 0) {\n      textParts.push(`**📚 Collection Sections (${categories.length}):**\\n`);\n      categories.forEach((sec: any) => {\n        const sectionIcons: { [key: string]: string } = {\n          'library': '📖',\n          'showcase': '⭐',\n          'catalog': '💎'\n        };\n        const icon = sectionIcons[sec.name] || '📁';\n        const descriptions: { [key: string]: string } = {\n          'library': 'Free community content',\n          'showcase': 'Featured high-quality content',\n          'catalog': 'Premium content (coming soon)'\n        };\n        textParts.push(\n          `   ${icon} **${sec.name}** - ${descriptions[sec.name] || 'Content collection'}\\n`,\n          `      Browse: \\`browse_collection \"${sec.name}\"\\`\\n\\n`\n        );\n      });\n      return textParts.join('');\n    }\n    \n    // Show content types within library section\n    if (section === 'library' && !category && categories.length > 0) {\n      textParts.push(`**📖 Library Content Types (${categories.length}):**\\n`);\n      categories.forEach((cat: any) => {\n        const typeIcons: { [key: string]: string } = {\n          'personas': '🎭',\n          'skills': '🛠️',\n          'agents': '🤖',\n          'prompts': '💬',\n          'templates': '📄',\n          'tools': '🔧',\n          'ensembles': '🎼'\n        };\n        const icon = typeIcons[cat.name] || '📁';\n        textParts.push(`   ${icon} **${cat.name}** - Browse: \\`browse_collection \"library\" \"${cat.name}\"\\`\\n`);\n      });\n      textParts.push('\\n');\n    } else if (categories.length > 0) {\n      textParts.push(`**📁 Categories in ${section}${category ? `/${category}` : ''} (${categories.length}):**\\n`);\n      categories.forEach((cat: any) => {\n        const browsePath = category ? `\"${section}\" \"${category}/${cat.name}\"` : `\"${section}\" \"${cat.name}\"`;\n        textParts.push(`   📂 **${cat.name}** - Browse: \\`browse_collection ${browsePath}\\`\\n`);\n      });\n      textParts.push('\\n');\n    }\n    \n    if (items.length > 0) {\n      const contentType = category?.split('/').pop() || 'content';\n      const contentIcons: { [key: string]: string } = {\n        'personas': '🎭',\n        'skills': '🛠️',\n        'agents': '🤖',\n        'prompts': '💬',\n        'templates': '📄',\n        'tools': '🔧',\n        'ensembles': '🎼'\n      };\n      const icon = contentIcons[contentType] || '📄';\n      \n      textParts.push(`**${icon} ${contentType.charAt(0).toUpperCase() + contentType.slice(1)} in ${section}${category ? `/${category}` : ''} (${items.length}):**\\n`);\n      items.forEach((item: any) => {\n        const fullPath = section + (category ? `/${category}` : '') + `/${item.name}`;\n        textParts.push(\n          `   ▫️ **${item.name.replace('.md', '')}**\\n`,\n          `      📥 Install: \\`install_content \"${fullPath}\"\\`\\n`,\n          `      👁️ Details: \\`get_collection_content \"${fullPath}\"\\`\\n\\n`\n        );\n      });\n    }\n    \n    return textParts.join('');\n  }\n}"]}

package/dist/collection/MarketplaceSearch.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Search for content in the collection
+ */
+import { GitHubClient } from './GitHubClient.js';
+export declare class MarketplaceSearch {
+    private githubClient;
+    private searchBaseUrl;
+    constructor(githubClient: GitHubClient);
+    /**
+     * Search collection for content matching query
+     */
+    searchCollection(query: string): Promise<any[]>;
+    /**
+     * Format search results
+     */
+    formatSearchResults(items: any[], query: string, personaIndicator?: string): string;
+}
+//# sourceMappingURL=MarketplaceSearch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MarketplaceSearch.d.ts","sourceRoot":"","sources":["../../src/collection/MarketplaceSearch.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,aAAa,CAAwC;gBAEjD,YAAY,EAAE,YAAY;IAItC;;OAEG;IACG,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IAYrD;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CAiCxF"}

package/dist/collection/MarketplaceSearch.js

@@ -0,0 +1,48 @@
+/**
+ * Search for content in the collection
+ */
+export class MarketplaceSearch {
+    githubClient;
+    searchBaseUrl = 'https://api.github.com/search/code';
+    constructor(githubClient) {
+        this.githubClient = githubClient;
+    }
+    /**
+     * Search collection for content matching query
+     */
+    async searchCollection(query) {
+        const searchUrl = `${this.searchBaseUrl}?q=${encodeURIComponent(query)}+repo:DollhouseMCP/collection+path:library+extension:md`;
+        const data = await this.githubClient.fetchFromGitHub(searchUrl);
+        if (!data.items) {
+            return [];
+        }
+        return data.items;
+    }
+    /**
+     * Format search results
+     */
+    formatSearchResults(items, query, personaIndicator = '') {
+        if (items.length === 0) {
+            return `${personaIndicator}🔍 No content found for query: "${query}"`;
+        }
+        const textParts = [`${personaIndicator}🔍 **Search Results for "${query}"** (${items.length} found)\n\n`];
+        items.forEach((item) => {
+            // Extract content type from path (library/personas/creative/writer.md -> personas)
+            const pathParts = item.path.split('/');
+            const contentType = pathParts[1] || 'content';
+            const contentIcons = {
+                'personas': '🎭',
+                'skills': '🛠️',
+                'agents': '🤖',
+                'prompts': '💬',
+                'templates': '📄',
+                'tools': '🔧',
+                'ensembles': '🎼'
+            };
+            const icon = contentIcons[contentType] || '📄';
+            textParts.push(`   ${icon} **${item.name.replace('.md', '')}**\n`, `      📂 Path: ${item.path}\n`, `      📥 Install: \`install_content "${item.path}"\`\n`, `      👁️ Details: \`get_marketplace_content "${item.path}"\`\n\n`);
+        });
+        return textParts.join('');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/collection/PersonaInstaller.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Install content from collection
+ */
+import { GitHubClient } from './GitHubClient.js';
+import { PersonaMetadata } from '../types/persona.js';
+export declare class PersonaInstaller {
+    private githubClient;
+    private personasDir;
+    private portfolioManager;
+    private baseUrl;
+    constructor(githubClient: GitHubClient, personasDir?: string);
+    /**
+     * Install content from the collection
+     */
+    installContent(inputPath: string): Promise<{
+        success: boolean;
+        message: string;
+        metadata?: PersonaMetadata;
+        filename?: string;
+    }>;
+    /**
+     * Format installation success message
+     */
+    formatInstallSuccess(metadata: PersonaMetadata, filename: string, totalPersonas: number, personaIndicator?: string): string;
+}
+//# sourceMappingURL=PersonaInstaller.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaInstaller.d.ts","sourceRoot":"","sources":["../../src/collection/PersonaInstaller.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAQtD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,OAAO,CAAmE;gBAEtE,YAAY,EAAE,YAAY,EAAE,WAAW,CAAC,EAAE,MAAM;IAM5D;;OAEG;IACG,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAC/C,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,eAAe,CAAC;QAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;IAiFF;;OAEG;IACH,oBAAoB,CAAC,QAAQ,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CAOhI"}

package/dist/collection/PersonaInstaller.js

@@ -0,0 +1,103 @@
+/**
+ * Install content from collection
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { validatePath, validateFilename, validateContentSize } from '../security/InputValidator.js';
+import { SECURITY_LIMITS } from '../security/constants.js';
+import { ContentValidator } from '../security/contentValidator.js';
+import { SecureYamlParser } from '../security/secureYamlParser.js';
+import { SecurityError } from '../errors/SecurityError.js';
+import { PortfolioManager, ElementType } from '../portfolio/PortfolioManager.js';
+export class PersonaInstaller {
+    githubClient;
+    personasDir;
+    portfolioManager;
+    baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';
+    constructor(githubClient, personasDir) {
+        this.githubClient = githubClient;
+        this.portfolioManager = PortfolioManager.getInstance();
+        this.personasDir = personasDir || this.portfolioManager.getElementDir(ElementType.PERSONA);
+    }
+    /**
+     * Install content from the collection
+     */
+    async installContent(inputPath) {
+        // Validate and sanitize the input path
+        const sanitizedPath = validatePath(inputPath);
+        // Ensure the path ends with .md
+        if (!sanitizedPath.endsWith('.md')) {
+            throw new Error('Invalid file type. Only .md files are allowed.');
+        }
+        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
+        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
+        const content = Buffer.from(data.content, 'base64').toString('utf-8');
+        // Validate content size after decoding
+        validateContentSize(content, SECURITY_LIMITS.MAX_PERSONA_SIZE_BYTES);
+        // Sanitize content for security threats
+        const sanitizedContent = ContentValidator.sanitizePersonaContent(content);
+        // Use secure YAML parser
+        let parsed;
+        try {
+            parsed = SecureYamlParser.safeMatter(sanitizedContent);
+        }
+        catch (error) {
+            if (error instanceof SecurityError) {
+                throw new Error(`Security threat in content: ${error.message}`);
+            }
+            throw error;
+        }
+        const metadata = parsed.data;
+        // 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
+        if (!metadata.name || !metadata.description) {
+            throw new Error('Invalid content: missing required name or description');
+        }
+        // Generate and validate local filename
+        const originalFilename = sanitizedPath.split('/').pop() || 'downloaded-persona.md';
+        const filename = validateFilename(originalFilename);
+        const localPath = path.join(this.personasDir, filename);
+        // Check if file already exists
+        try {
+            await fs.access(localPath);
+            return {
+                success: false,
+                message: `Content already exists: ${filename}\n\nUse \`reload_personas\` to refresh if you've updated it manually.`
+            };
+        }
+        catch {
+            // File doesn't exist, proceed with installation
+        }
+        // Write the sanitized file
+        await fs.writeFile(localPath, sanitizedContent, 'utf-8');
+        return {
+            success: true,
+            message: `Content installed successfully!`,
+            metadata,
+            filename
+        };
+    }
+    /**
+     * Format installation success message
+     */
+    formatInstallSuccess(metadata, filename, totalPersonas, personaIndicator = '') {
+        return `${personaIndicator}✅ **Content Installed Successfully!**\n\n` +
+            `🎭 **${metadata.name}** by ${metadata.author}\n` +
+            `📁 Saved as: ${filename}\n` +
+            `📊 Total personas: ${totalPersonas}\n\n` +
+            `🎯 **Ready to use:** \`activate_persona "${metadata.name}"\``;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PersonaInstaller.js","sourceRoot":"","sources":["../../src/collection/PersonaInstaller.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Install content from collection\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport matter from 'gray-matter';\nimport { GitHubClient } from './GitHubClient.js';\nimport { PersonaMetadata } from '../types/persona.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 PersonaInstaller {\n  private githubClient: GitHubClient;\n  private personasDir: string;\n  private portfolioManager: PortfolioManager;\n  private baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';\n  \n  constructor(githubClient: GitHubClient, personasDir?: string) {\n    this.githubClient = githubClient;\n    this.portfolioManager = PortfolioManager.getInstance();\n    this.personasDir = personasDir || this.portfolioManager.getElementDir(ElementType.PERSONA);\n  }\n  \n  /**\n   * Install content from the collection\n   */\n  async installContent(inputPath: string): Promise<{ \n    success: boolean; \n    message: string;\n    metadata?: PersonaMetadata;\n    filename?: string;\n  }> {\n    // Validate and sanitize the input path\n    const sanitizedPath = validatePath(inputPath);\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 PersonaMetadata;\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-persona.md';\n    const filename = validateFilename(originalFilename);\n    const localPath = path.join(this.personasDir, filename);\n    \n    // Check if file already exists\n    try {\n      await fs.access(localPath);\n      return {\n        success: false,\n        message: `Content already exists: ${filename}\\n\\nUse \\`reload_personas\\` to refresh if you've updated it manually.`\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: `Content installed successfully!`,\n      metadata,\n      filename\n    };\n  }\n  \n  /**\n   * Format installation success message\n   */\n  formatInstallSuccess(metadata: PersonaMetadata, filename: string, totalPersonas: number, personaIndicator: string = ''): string {\n    return `${personaIndicator}✅ **Content Installed Successfully!**\\n\\n` +\n      `🎭 **${metadata.name}** by ${metadata.author}\\n` +\n      `📁 Saved as: ${filename}\\n` +\n      `📊 Total personas: ${totalPersonas}\\n\\n` +\n      `🎯 **Ready to use:** \\`activate_persona \"${metadata.name}\"\\``;\n  }\n}"]}