@dollhousemcp/mcp-server 1.3.0

package/dist/collection/GitHubClient.js

@@ -0,0 +1,114 @@
+/**
+ * GitHub API client for collection integration
+ */
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+import { SECURITY_LIMITS } from '../security/constants.js';
+import { TokenManager } from '../security/tokenManager.js';
+export class GitHubClient {
+    apiCache;
+    rateLimitTracker;
+    constructor(apiCache, rateLimitTracker) {
+        this.apiCache = apiCache;
+        this.rateLimitTracker = rateLimitTracker;
+    }
+    /**
+     * Check rate limit for API calls
+     */
+    checkRateLimit(key = 'default') {
+        const now = Date.now();
+        const requests = this.rateLimitTracker.get(key) || [];
+        // Remove requests outside the window
+        const validRequests = requests.filter(time => now - time < SECURITY_LIMITS.RATE_LIMIT_WINDOW_MS);
+        if (validRequests.length >= SECURITY_LIMITS.RATE_LIMIT_REQUESTS) {
+            throw new Error(`Rate limit exceeded. Max ${SECURITY_LIMITS.RATE_LIMIT_REQUESTS} requests per minute.`);
+        }
+        validRequests.push(now);
+        this.rateLimitTracker.set(key, validRequests);
+    }
+    /**
+     * Fetch data from GitHub API with caching and rate limiting
+     */
+    async fetchFromGitHub(url, requireAuth = false) {
+        try {
+            // Check rate limit
+            this.checkRateLimit('github_api');
+            // Check cache first
+            const cached = this.apiCache.get(url);
+            if (cached) {
+                return cached;
+            }
+            // Add GitHub token if available for higher rate limits
+            const headers = {
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'DollhouseMCP/1.0'
+            };
+            // Use TokenManager for secure token handling
+            const token = TokenManager.getGitHubToken();
+            if (token) {
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+            else if (requireAuth) {
+                throw new Error('GitHub authentication required but no valid token available. Please set GITHUB_TOKEN environment variable.');
+            }
+            // Create fetch with timeout
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
+            const response = await fetch(url, {
+                headers,
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                if (response.status === 403) {
+                    const errorMsg = token
+                        ? 'GitHub API rate limit exceeded or token lacks required permissions.'
+                        : 'GitHub API rate limit exceeded. Consider setting GITHUB_TOKEN environment variable.';
+                    throw new Error(errorMsg);
+                }
+                if (response.status === 401) {
+                    throw new Error('GitHub API authentication failed. Please check your GITHUB_TOKEN.');
+                }
+                throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            // Cache the successful response
+            this.apiCache.set(url, data);
+            return data;
+        }
+        catch (error) {
+            // Use TokenManager for safe error handling
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const safeMessage = TokenManager.createSafeErrorMessage(errorMessage);
+            const errorDetails = {
+                originalMessage: safeMessage,
+                url
+            };
+            // Preserve stack trace and error type information
+            if (error instanceof Error) {
+                errorDetails.errorType = error.constructor.name;
+                errorDetails.stack = error.stack;
+                // Special handling for common error types
+                if (error.name === 'AbortError') {
+                    errorDetails.timeout = true;
+                }
+            }
+            const mcpError = new McpError(ErrorCode.InternalError, `Failed to fetch from GitHub: ${safeMessage}`, errorDetails);
+            // Also preserve original error for debugging
+            mcpError.cause = error;
+            throw mcpError;
+        }
+    }
+    /**
+     * Validate token permissions for collection operations
+     */
+    async validateCollectionPermissions() {
+        // NOTE: Using 'marketplace' scope for backward compatibility with TokenManager.
+        // This is an internal implementation detail that doesn't affect functionality. (PR #280)
+        const validation = await TokenManager.ensureTokenPermissions('marketplace');
+        if (!validation.isValid) {
+            const safeMessage = TokenManager.createSafeErrorMessage(validation.error || 'Unknown validation error');
+            throw new Error(`GitHub token validation failed: ${safeMessage}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GitHubClient.js","sourceRoot":"","sources":["../../src/collection/GitHubClient.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * GitHub API client for collection integration\n */\n\nimport { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';\nimport { APICache } from '../cache/APICache.js';\nimport { SECURITY_LIMITS } from '../security/constants.js';\nimport { TokenManager, TokenScopes } from '../security/tokenManager.js';\nimport { logger } from '../utils/logger.js';\n\nexport class GitHubClient {\n  private apiCache: APICache;\n  private rateLimitTracker: Map<string, number[]>;\n  \n  constructor(apiCache: APICache, rateLimitTracker: Map<string, number[]>) {\n    this.apiCache = apiCache;\n    this.rateLimitTracker = rateLimitTracker;\n  }\n  \n  /**\n   * Check rate limit for API calls\n   */\n  private checkRateLimit(key: string = 'default'): void {\n    const now = Date.now();\n    const requests = this.rateLimitTracker.get(key) || [];\n    \n    // Remove requests outside the window\n    const validRequests = requests.filter(time => now - time < SECURITY_LIMITS.RATE_LIMIT_WINDOW_MS);\n    \n    if (validRequests.length >= SECURITY_LIMITS.RATE_LIMIT_REQUESTS) {\n      throw new Error(`Rate limit exceeded. Max ${SECURITY_LIMITS.RATE_LIMIT_REQUESTS} requests per minute.`);\n    }\n    \n    validRequests.push(now);\n    this.rateLimitTracker.set(key, validRequests);\n  }\n  \n  /**\n   * Fetch data from GitHub API with caching and rate limiting\n   */\n  async fetchFromGitHub(url: string, requireAuth: boolean = false): Promise<any> {\n    try {\n      // Check rate limit\n      this.checkRateLimit('github_api');\n      \n      // Check cache first\n      const cached = this.apiCache.get(url);\n      if (cached) {\n        return cached;\n      }\n      \n      // Add GitHub token if available for higher rate limits\n      const headers: Record<string, string> = {\n        'Accept': 'application/vnd.github.v3+json',\n        'User-Agent': 'DollhouseMCP/1.0'\n      };\n      \n      // Use TokenManager for secure token handling\n      const token = TokenManager.getGitHubToken();\n      if (token) {\n        headers['Authorization'] = `Bearer ${token}`;\n      } else if (requireAuth) {\n        throw new Error('GitHub authentication required but no valid token available. Please set GITHUB_TOKEN environment variable.');\n      }\n      \n      // Create fetch with timeout\n      const controller = new AbortController();\n      const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout\n      \n      const response = await fetch(url, {\n        headers,\n        signal: controller.signal\n      });\n      \n      clearTimeout(timeoutId);\n      \n      if (!response.ok) {\n        if (response.status === 403) {\n          const errorMsg = token \n            ? 'GitHub API rate limit exceeded or token lacks required permissions.'\n            : 'GitHub API rate limit exceeded. Consider setting GITHUB_TOKEN environment variable.';\n          throw new Error(errorMsg);\n        }\n        if (response.status === 401) {\n          throw new Error('GitHub API authentication failed. Please check your GITHUB_TOKEN.');\n        }\n        throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);\n      }\n      \n      const data = await response.json();\n      \n      // Cache the successful response\n      this.apiCache.set(url, data);\n      \n      return data;\n    } catch (error) {\n      // Use TokenManager for safe error handling\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      const safeMessage = TokenManager.createSafeErrorMessage(errorMessage);\n      \n      const errorDetails: any = {\n        originalMessage: safeMessage,\n        url\n      };\n      \n      // Preserve stack trace and error type information\n      if (error instanceof Error) {\n        errorDetails.errorType = error.constructor.name;\n        errorDetails.stack = error.stack;\n        \n        // Special handling for common error types\n        if (error.name === 'AbortError') {\n          errorDetails.timeout = true;\n        }\n      }\n      \n      const mcpError = new McpError(\n        ErrorCode.InternalError,\n        `Failed to fetch from GitHub: ${safeMessage}`,\n        errorDetails\n      );\n      \n      // Also preserve original error for debugging\n      (mcpError as any).cause = error;\n      \n      throw mcpError;\n    }\n  }\n\n  /**\n   * Validate token permissions for collection operations\n   */\n  async validateCollectionPermissions(): Promise<void> {\n    // NOTE: Using 'marketplace' scope for backward compatibility with TokenManager.\n    // This is an internal implementation detail that doesn't affect functionality. (PR #280)\n    const validation = await TokenManager.ensureTokenPermissions('marketplace');\n    if (!validation.isValid) {\n      const safeMessage = TokenManager.createSafeErrorMessage(validation.error || 'Unknown validation error');\n      throw new Error(`GitHub token validation failed: ${safeMessage}`);\n    }\n  }\n}"]}

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/PersonaDetails.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Get content details from collection
+ */
+import { GitHubClient } from './GitHubClient.js';
+import { PersonaMetadata } from '../types/persona.js';
+export declare class PersonaDetails {
+    private githubClient;
+    private baseUrl;
+    constructor(githubClient: GitHubClient);
+    /**
+     * Get detailed information about collection content
+     */
+    getCollectionContent(path: string): Promise<{
+        metadata: PersonaMetadata;
+        content: string;
+    }>;
+    /**
+     * Format persona details for display
+     */
+    formatPersonaDetails(metadata: PersonaMetadata, content: string, path: string, personaIndicator?: string): string;
+}
+//# sourceMappingURL=PersonaDetails.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaDetails.d.ts","sourceRoot":"","sources":["../../src/collection/PersonaDetails.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAKtD,qBAAa,cAAc;IACzB,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,OAAO,CAAmE;gBAEtE,YAAY,EAAE,YAAY;IAItC;;OAEG;IACG,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,eAAe,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAwCjG;;OAEG;IACH,oBAAoB,CAAC,QAAQ,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CA0BtH"}

package/dist/collection/PersonaDetails.js

@@ -0,0 +1,71 @@
+/**
+ * Get content details from collection
+ */
+import { ContentValidator } from '../security/contentValidator.js';
+import { SecureYamlParser } from '../security/secureYamlParser.js';
+import { SecurityError } from '../errors/SecurityError.js';
+export class PersonaDetails {
+    githubClient;
+    baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';
+    constructor(githubClient) {
+        this.githubClient = githubClient;
+    }
+    /**
+     * Get detailed information about collection content
+     */
+    async getCollectionContent(path) {
+        const url = `${this.baseUrl}/${path}`;
+        const data = await this.githubClient.fetchFromGitHub(url);
+        if (data.type !== 'file') {
+            throw new Error('Path does not point to a file');
+        }
+        // Decode Base64 content
+        const content = Buffer.from(data.content, 'base64').toString('utf-8');
+        // Sanitize content for display (this is view-only, not installation)
+        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 warning: This content contains potentially malicious content - ${error.message}`);
+            }
+            throw error;
+        }
+        const metadata = parsed.data;
+        // Additional validation for display
+        const metadataValidation = ContentValidator.validateMetadata(metadata);
+        if (!metadataValidation.isValid && metadataValidation.severity === 'critical') {
+            throw new Error(`Security warning: This content contains potentially malicious content`);
+        }
+        return {
+            metadata,
+            content: parsed.content
+        };
+    }
+    /**
+     * Format persona details for display
+     */
+    formatPersonaDetails(metadata, content, path, personaIndicator = '') {
+        const textParts = [
+            `${personaIndicator}🎭 **Collection Content: ${metadata.name}**\n\n`,
+            `**📋 Details:**\n`,
+            `   🆔 ID: ${metadata.unique_id || 'Not specified'}\n`,
+            `   👤 Author: ${metadata.author || 'Unknown'}\n`,
+            `   📁 Category: ${metadata.category || 'General'}\n`,
+            `   🔖 Price: ${metadata.price || 'Free'}\n`,
+            `   📊 Version: ${metadata.version || '1.0'}\n`,
+            `   🔞 Age Rating: ${metadata.age_rating || 'All'}\n`,
+            `   ${metadata.ai_generated ? '🤖 AI Generated' : '👤 Human Created'}\n\n`,
+            `**📝 Description:**\n${metadata.description}\n\n`
+        ];
+        if (metadata.triggers && metadata.triggers.length > 0) {
+            textParts.push(`**🔗 Triggers:** ${metadata.triggers.join(', ')}\n\n`);
+        }
+        textParts.push(`**📥 Installation:**\n`, `Use: \`install_content "${path}"\`\n\n`, `**📄 Full Content:**\n\`\`\`\n${content}\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"}