@dollhousemcp/mcp-server 1.3.0

package/dist/marketplace/GitHubClient.d.ts

@@ -0,0 +1,22 @@
+/**
+ * GitHub API client for marketplace integration
+ */
+import { APICache } from '../cache/APICache.js';
+export declare class GitHubClient {
+    private apiCache;
+    private rateLimitTracker;
+    constructor(apiCache: APICache, rateLimitTracker: Map<string, number[]>);
+    /**
+     * Check rate limit for API calls
+     */
+    private checkRateLimit;
+    /**
+     * Fetch data from GitHub API with caching and rate limiting
+     */
+    fetchFromGitHub(url: string, requireAuth?: boolean): Promise<any>;
+    /**
+     * Validate token permissions for marketplace operations
+     */
+    validateMarketplacePermissions(): Promise<void>;
+}
+//# sourceMappingURL=GitHubClient.d.ts.map

package/dist/marketplace/GitHubClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GitHubClient.d.ts","sourceRoot":"","sources":["../../src/marketplace/GitHubClient.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAKhD,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,gBAAgB,CAAwB;gBAEpC,QAAQ,EAAE,QAAQ,EAAE,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAKvE;;OAEG;IACH,OAAO,CAAC,cAAc;IAetB;;OAEG;IACG,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,GAAE,OAAe,GAAG,OAAO,CAAC,GAAG,CAAC;IAyF9E;;OAEG;IACG,8BAA8B,IAAI,OAAO,CAAC,IAAI,CAAC;CAOtD"}

package/dist/marketplace/GitHubClient.js

@@ -0,0 +1,112 @@
+/**
+ * GitHub API client for marketplace 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 marketplace operations
+     */
+    async validateMarketplacePermissions() {
+        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/marketplace/GitHubClient.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * GitHub API client for marketplace 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 marketplace operations\n   */\n  async validateMarketplacePermissions(): Promise<void> {\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/marketplace/MarketplaceBrowser.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"MarketplaceBrowser.d.ts","sourceRoot":"","sources":["../../src/marketplace/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,iBAAiB,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;IA2C5H;;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/marketplace/MarketplaceBrowser.js

@@ -0,0 +1,115 @@
+/**
+ * Browse marketplace personas from GitHub
+ */
+export class MarketplaceBrowser {
+    githubClient;
+    baseUrl = 'https://api.github.com/repos/DollhouseMCP/collection/contents';
+    constructor(githubClient) {
+        this.githubClient = githubClient;
+    }
+    /**
+     * Browse marketplace content by section and category
+     * @param section - Top level section: library, showcase, or catalog
+     * @param category - Optional category within the section
+     */
+    async browseMarketplace(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 marketplace 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 marketplace browse results
+     */
+    formatBrowseResults(items, categories, section, category, personaIndicator = '') {
+        const textParts = [`${personaIndicator}🏪 **DollhouseMCP Marketplace**\n\n`];
+        // Show top-level sections if no section specified
+        if (!section && categories.length > 0) {
+            textParts.push(`**📚 Marketplace 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_marketplace "${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_marketplace "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_marketplace ${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_marketplace_content "${fullPath}"\`\n\n`);
+            });
+        }
+        return textParts.join('');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MarketplaceBrowser.js","sourceRoot":"","sources":["../../src/marketplace/MarketplaceBrowser.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Browse marketplace personas 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 marketplace 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 browseMarketplace(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 marketplace 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 marketplace browse results\n   */\n  formatBrowseResults(items: any[], categories: any[], section?: string, category?: string, personaIndicator: string = ''): string {\n    const textParts = [`${personaIndicator}🏪 **DollhouseMCP Marketplace**\\n\\n`];\n    \n    // Show top-level sections if no section specified\n    if (!section && categories.length > 0) {\n      textParts.push(`**📚 Marketplace 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_marketplace \"${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_marketplace \"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_marketplace ${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_marketplace_content \"${fullPath}\"\\`\\n\\n`\n        );\n      });\n    }\n    \n    return textParts.join('');\n  }\n}"]}

package/dist/marketplace/MarketplaceSearch.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"MarketplaceSearch.d.ts","sourceRoot":"","sources":["../../src/marketplace/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,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IAYtD;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CAiCxF"}

package/dist/marketplace/MarketplaceSearch.js

@@ -0,0 +1,48 @@
+/**
+ * Search for personas in the marketplace
+ */
+export class MarketplaceSearch {
+    githubClient;
+    searchBaseUrl = 'https://api.github.com/search/code';
+    constructor(githubClient) {
+        this.githubClient = githubClient;
+    }
+    /**
+     * Search marketplace for content matching query
+     */
+    async searchMarketplace(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/marketplace/PersonaDetails.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Get persona details from marketplace
+ */
+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 marketplace content
+     */
+    getMarketplaceContent(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/marketplace/PersonaDetails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaDetails.d.ts","sourceRoot":"","sources":["../../src/marketplace/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,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,eAAe,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAwClG;;OAEG;IACH,oBAAoB,CAAC,QAAQ,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CA0BtH"}

package/dist/marketplace/PersonaDetails.js

@@ -0,0 +1,71 @@
+/**
+ * Get persona details from marketplace
+ */
+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 marketplace content
+     */
+    async getMarketplaceContent(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}🎭 **Marketplace 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/marketplace/PersonaInstaller.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Install content from marketplace
+ */
+import { GitHubClient } from './GitHubClient.js';
+import { PersonaMetadata } from '../types/persona.js';
+export declare class PersonaInstaller {
+    private githubClient;
+    private personasDir;
+    private baseUrl;
+    constructor(githubClient: GitHubClient, personasDir: string);
+    /**
+     * Install content from the marketplace
+     */
+    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/marketplace/PersonaInstaller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaInstaller.d.ts","sourceRoot":"","sources":["../../src/marketplace/PersonaInstaller.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAOtD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,OAAO,CAAmE;gBAEtE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM;IAK3D;;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"}