@dollhousemcp/mcp-server 1.3.0

package/dist/test/src/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/test/src/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/test/src/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/test/src/marketplace/MarketplaceBrowser.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Browse marketplace personas from GitHub
+ */
+import { GitHubClient } from './GitHubClient.js';
+export declare class MarketplaceBrowser {
+    private githubClient;
+    private baseUrl;
+    constructor(githubClient: GitHubClient);
+    /**
+     * Browse marketplace personas by category
+     */
+    browseMarketplace(category?: string): Promise<{
+        items: any[];
+        categories: any[];
+    }>;
+    /**
+     * Format marketplace browse results
+     */
+    formatBrowseResults(items: any[], categories: any[], category?: string, personaIndicator?: string): string;
+}
+//# sourceMappingURL=MarketplaceBrowser.d.ts.map

package/dist/test/src/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,CAA0E;gBAE7E,YAAY,EAAE,YAAY;IAItC;;OAEG;IACG,iBAAiB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,GAAG,EAAE,CAAC;QAAC,UAAU,EAAE,GAAG,EAAE,CAAA;KAAE,CAAC;IAexF;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CAyB/G"}

package/dist/test/src/marketplace/MarketplaceBrowser.js

@@ -0,0 +1,45 @@
+/**
+ * Browse marketplace personas from GitHub
+ */
+export class MarketplaceBrowser {
+    githubClient;
+    baseUrl = 'https://api.github.com/repos/DollhouseMCP/personas/contents/personas';
+    constructor(githubClient) {
+        this.githubClient = githubClient;
+    }
+    /**
+     * Browse marketplace personas by category
+     */
+    async browseMarketplace(category) {
+        const url = category ? `${this.baseUrl}/${category}` : this.baseUrl;
+        const data = await this.githubClient.fetchFromGitHub(url);
+        if (!Array.isArray(data)) {
+            throw new Error('Invalid marketplace response. Expected directory listing.');
+        }
+        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, category, personaIndicator = '') {
+        const textParts = [`${personaIndicator}🏪 **DollhouseMCP Marketplace**\n\n`];
+        if (!category) {
+            textParts.push(`**📁 Categories (${categories.length}):**\n`);
+            categories.forEach((cat) => {
+                textParts.push(`   📂 **${cat.name}** - Browse with: \`browse_marketplace "${cat.name}"\`\n`);
+            });
+            textParts.push('\n');
+        }
+        if (items.length > 0) {
+            textParts.push(`**🎭 Personas in ${category || 'root'} (${items.length}):**\n`);
+            items.forEach((item) => {
+                const path = category ? `${category}/${item.name}` : item.name;
+                textParts.push(`   ▫️ **${item.name}**\n`, `      📥 Install: \`install_persona "${path}"\`\n`, `      👁️ Details: \`get_marketplace_persona "${path}"\`\n\n`);
+            });
+        }
+        return textParts.join('');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/src/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 personas 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/test/src/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;CAmBxF"}

package/dist/test/src/marketplace/MarketplaceSearch.js

@@ -0,0 +1,36 @@
+/**
+ * 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 personas matching query
+     */
+    async searchMarketplace(query) {
+        const searchUrl = `${this.searchBaseUrl}?q=${encodeURIComponent(query)}+repo:DollhouseMCP/personas+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 personas found for query: "${query}"`;
+        }
+        const textParts = [`${personaIndicator}🔍 **Search Results for "${query}"** (${items.length} found)\n\n`];
+        items.forEach((item) => {
+            const path = item.path.replace('personas/', '');
+            textParts.push(`   🎭 **${item.name}**\n`, `      📂 Path: ${path}\n`, `      📥 Install: \`install_persona "${path}"\`\n`, `      👁️ Details: \`get_marketplace_persona "${path}"\`\n\n`);
+        });
+        return textParts.join('');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/src/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 a marketplace persona
+     */
+    getMarketplacePersona(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/test/src/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,CAA0E;gBAE7E,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/test/src/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/personas/contents/personas';
+    constructor(githubClient) {
+        this.githubClient = githubClient;
+    }
+    /**
+     * Get detailed information about a marketplace persona
+     */
+    async getMarketplacePersona(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 persona 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 persona contains potentially malicious content`);
+        }
+        return {
+            metadata,
+            content: parsed.content
+        };
+    }
+    /**
+     * Format persona details for display
+     */
+    formatPersonaDetails(metadata, content, path, personaIndicator = '') {
+        const textParts = [
+            `${personaIndicator}🎭 **Marketplace Persona: ${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_persona "${path}"\`\n\n`, `**📄 Full Content:**\n\`\`\`\n${content}\n\`\`\``);
+        return textParts.join('');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/src/marketplace/PersonaInstaller.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Install personas 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 a persona from the marketplace
+     */
+    installPersona(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/test/src/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,CAA0E;gBAE7E,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"}

package/dist/test/src/marketplace/PersonaInstaller.js

@@ -0,0 +1,100 @@
+/**
+ * Install personas from marketplace
+ */
+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';
+export class PersonaInstaller {
+    githubClient;
+    personasDir;
+    baseUrl = 'https://api.github.com/repos/DollhouseMCP/personas/contents/personas';
+    constructor(githubClient, personasDir) {
+        this.githubClient = githubClient;
+        this.personasDir = personasDir;
+    }
+    /**
+     * Install a persona from the marketplace
+     */
+    async installPersona(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 persona: ${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 persona: 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: `Persona 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: `Persona installed successfully!`,
+            metadata,
+            filename
+        };
+    }
+    /**
+     * Format installation success message
+     */
+    formatInstallSuccess(metadata, filename, totalPersonas, personaIndicator = '') {
+        return `${personaIndicator}✅ **Persona 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/marketplace/PersonaInstaller.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Install personas from marketplace\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';\n\nexport class PersonaInstaller {\n  private githubClient: GitHubClient;\n  private personasDir: string;\n  private baseUrl = 'https://api.github.com/repos/DollhouseMCP/personas/contents/personas';\n  \n  constructor(githubClient: GitHubClient, personasDir: string) {\n    this.githubClient = githubClient;\n    this.personasDir = personasDir;\n  }\n  \n  /**\n   * Install a persona from the marketplace\n   */\n  async installPersona(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 persona: ${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 persona: 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: `Persona 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: `Persona 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}✅ **Persona 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}"]}

package/dist/test/src/marketplace/PersonaSubmitter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Submit personas to the marketplace
+ */
+import { Persona } from '../types/persona.js';
+export declare class PersonaSubmitter {
+    /**
+     * Generate GitHub issue for persona submission
+     */
+    generateSubmissionIssue(persona: Persona): {
+        issueTitle: string;
+        issueBody: string;
+        githubIssueUrl: string;
+    };
+    /**
+     * Format submission response
+     */
+    formatSubmissionResponse(persona: Persona, githubIssueUrl: string, personaIndicator?: string): string;
+}
+//# sourceMappingURL=PersonaSubmitter.d.ts.map

package/dist/test/src/marketplace/PersonaSubmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaSubmitter.d.ts","sourceRoot":"","sources":["../../../../src/marketplace/PersonaSubmitter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,qBAAa,gBAAgB;IAC3B;;OAEG;IACH,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG;QACzC,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,cAAc,EAAE,MAAM,CAAA;KACvB;IAqCD;;OAEG;IACH,wBAAwB,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;CAW1G"}