@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/persona/export-import/PersonaSharer.js

@@ -1,11 +1,26 @@
 /**
  * Persona sharing functionality via URLs
+ *
+ * SECURITY FIX IMPLEMENTED (Defense-in-Depth Validation):
+ * 1. CRITICAL: Added validate-before-return pattern in all import methods
+ * 2. HIGH: Content security validation using ContentValidator before data return
+ * 3. MEDIUM: Size validation to prevent memory exhaustion attacks
+ * 4. MEDIUM: Structure validation to prevent malformed data processing
+ * 5. DEFENSE-IN-DEPTH: Multiple validation layers before PersonaImporter processing
+ *
+ * This provides defense-in-depth security by validating content at the earliest
+ * possible point before any data is returned to calling code or file operations.
  */
 import { PersonaExporter } from './PersonaExporter.js';
 import { TokenManager } from '../../security/tokenManager.js';
 import { SecurityError } from '../../security/errors.js';
 import { logger } from '../../utils/logger.js';
-import { RateLimiter } from '../../update/RateLimiter.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+import { ErrorHandler, ErrorCategory } from '../../utils/ErrorHandler.js';
+import { ValidationErrorCodes, NetworkErrorCodes } from '../../utils/errorCodes.js';
+import { RateLimiter } from '../../utils/RateLimiter.js';
+import { ContentValidator } from '../../security/contentValidator.js';
+import { validateContentSize } from '../../security/InputValidator.js';
 export class PersonaSharer {
     githubClient;
     currentUser;
@@ -96,6 +111,7 @@ export class PersonaSharer {
     }
     /**
      * Import a persona from a share URL
+     * SECURITY FIX: Validate ALL content before returning any data
      */
     async importFromUrl(url) {
         try {
@@ -113,11 +129,11 @@ export class PersonaSharer {
             }
             // Check if it's a base64 URL
             if (url.includes('#dollhouse-persona=')) {
-                return this.importFromBase64Url(url);
+                return await this.importFromBase64Url(url);
             }
             // Validate URL for security
             if (!this.validateShareUrl(url)) {
-                throw new Error('Invalid or potentially malicious URL');
+                throw ErrorHandler.createError('Invalid or potentially malicious URL', ErrorCategory.VALIDATION_ERROR, ValidationErrorCodes.INVALID_URL);
             }
             // Try direct fetch with timeout
             const controller = new AbortController();
@@ -132,20 +148,26 @@ export class PersonaSharer {
                 });
                 clearTimeout(timeoutId);
                 if (!response.ok) {
-                    throw new Error(`Request failed with status ${response.status}`);
+                    throw ErrorHandler.createError(`Request failed with status ${response.status}`, ErrorCategory.NETWORK_ERROR, NetworkErrorCodes.REQUEST_FAILED);
                 }
-                // Validate Content-Type header
+                // ENHANCED SECURITY FIX: Comprehensive Content-Type validation
                 const contentType = response.headers.get('content-type');
-                if (!contentType || !contentType.toLowerCase().includes('application/json')) {
-                    throw new Error('Invalid response type: expected JSON');
+                const contentTypeValidation = this.validateContentType(contentType, 'application/json');
+                if (!contentTypeValidation.isValid) {
+                    throw ErrorHandler.createError(`Invalid response type: ${contentTypeValidation.error}`, ErrorCategory.NETWORK_ERROR, NetworkErrorCodes.INVALID_RESPONSE);
                 }
                 // Check response size to prevent memory exhaustion
                 const contentLength = response.headers.get('content-length');
                 const maxSize = 5 * 1024 * 1024; // 5MB max
                 if (contentLength && parseInt(contentLength) > maxSize) {
-                    throw new Error('Response too large');
+                    throw ErrorHandler.createError('Response too large', ErrorCategory.VALIDATION_ERROR, NetworkErrorCodes.RESPONSE_TOO_LARGE);
                 }
                 const data = await response.json();
+                // SECURITY FIX: Validate content before returning
+                const dataValidation = await this.validatePersonaData(data);
+                if (!dataValidation.isValid) {
+                    throw new SecurityError(`Content validation failed: ${dataValidation.error}`);
+                }
                 return {
                     success: true,
                     data,
@@ -205,12 +227,13 @@ export class PersonaSharer {
                 });
                 clearTimeout(timeoutId);
                 if (!response.ok) {
-                    throw new Error(`GitHub API error: ${response.status}`);
+                    throw ErrorHandler.createError(`GitHub API error: ${response.status}`, ErrorCategory.NETWORK_ERROR, NetworkErrorCodes.API_ERROR);
                 }
-                // Validate Content-Type for GitHub API response
+                // ENHANCED SECURITY FIX: Comprehensive Content-Type validation for GitHub API
                 const contentType = response.headers.get('content-type');
-                if (!contentType || !contentType.toLowerCase().includes('application/json')) {
-                    throw new Error('Invalid GitHub API response type');
+                const gistContentTypeValidation = this.validateContentType(contentType, 'application/json');
+                if (!gistContentTypeValidation.isValid) {
+                    throw ErrorHandler.createError(`Invalid GitHub API response type: ${gistContentTypeValidation.error}`, ErrorCategory.NETWORK_ERROR, NetworkErrorCodes.INVALID_RESPONSE);
                 }
                 const gist = await response.json();
                 // Consume the rate limit token after successful request
@@ -253,12 +276,12 @@ export class PersonaSharer {
             // Check rate limit
             const rateLimitStatus = this.githubRateLimiter.checkLimit();
             if (!rateLimitStatus.allowed) {
-                throw new Error(`GitHub API rate limit exceeded. Please try again in ${Math.ceil(rateLimitStatus.retryAfterMs / 1000)} seconds`);
+                throw ErrorHandler.createError(`GitHub API rate limit exceeded. Please try again in ${Math.ceil(rateLimitStatus.retryAfterMs / 1000)} seconds`, ErrorCategory.NETWORK_ERROR, NetworkErrorCodes.RATE_LIMIT_EXCEEDED);
             }
             const gistUrl = `https://api.github.com/gists/${gistId}`;
             // Validate URL (should always pass for GitHub API)
             if (!this.validateShareUrl(gistUrl)) {
-                throw new Error('Invalid GitHub API URL');
+                throw ErrorHandler.createError('Invalid GitHub API URL', ErrorCategory.VALIDATION_ERROR, ValidationErrorCodes.INVALID_URL);
             }
             const controller = new AbortController();
             const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout for API
@@ -272,17 +295,18 @@ export class PersonaSharer {
                 });
                 clearTimeout(timeoutId);
                 if (!response.ok) {
-                    throw new Error(`Failed to fetch gist: ${response.status}`);
+                    throw ErrorHandler.createError(`Failed to fetch gist: ${response.status}`, ErrorCategory.NETWORK_ERROR, NetworkErrorCodes.FETCH_FAILED);
                 }
-                // Validate Content-Type for GitHub API response
+                // ENHANCED SECURITY FIX: Comprehensive Content-Type validation for GitHub API
                 const contentType = response.headers.get('content-type');
-                if (!contentType || !contentType.toLowerCase().includes('application/json')) {
-                    throw new Error('Invalid GitHub API response type');
+                const gistContentTypeValidation = this.validateContentType(contentType, 'application/json');
+                if (!gistContentTypeValidation.isValid) {
+                    throw ErrorHandler.createError(`Invalid GitHub API response type: ${gistContentTypeValidation.error}`, ErrorCategory.NETWORK_ERROR, NetworkErrorCodes.INVALID_RESPONSE);
                 }
                 const gist = await response.json();
                 const personaFile = gist.files['persona.json'];
                 if (!personaFile) {
-                    throw new Error('No persona data found in gist');
+                    throw ErrorHandler.createError('No persona data found in gist', ErrorCategory.VALIDATION_ERROR, ValidationErrorCodes.INVALID_INPUT);
                 }
                 const data = JSON.parse(personaFile.content);
                 // Check expiry
@@ -292,6 +316,11 @@ export class PersonaSharer {
                         message: 'This share link has expired'
                     };
                 }
+                // SECURITY FIX: Validate content before returning
+                const gistDataValidation = await this.validatePersonaData(data);
+                if (!gistDataValidation.isValid) {
+                    throw new SecurityError(`Content validation failed: ${gistDataValidation.error}`);
+                }
                 // Consume the rate limit token after successful request
                 this.githubRateLimiter.consumeToken();
                 return {
@@ -441,12 +470,12 @@ export class PersonaSharer {
     /**
      * Import from base64 URL
      */
-    importFromBase64Url(url) {
+    async importFromBase64Url(url) {
         try {
             // Limit base64 length to prevent ReDoS attacks (10KB max for base64 encoded data)
             const match = url.match(/#dollhouse-persona=([A-Za-z0-9+/=]{1,10000})$/);
             if (!match) {
-                throw new Error('Invalid share URL format');
+                throw ErrorHandler.createError('Invalid share URL format', ErrorCategory.VALIDATION_ERROR, ValidationErrorCodes.INVALID_FORMAT);
             }
             const base64 = match[1];
             const json = Buffer.from(base64, 'base64').toString('utf-8');
@@ -458,6 +487,11 @@ export class PersonaSharer {
                     message: 'This share link has expired'
                 };
             }
+            // SECURITY FIX: Validate content before returning
+            const base64DataValidation = await this.validatePersonaData(data);
+            if (!base64DataValidation.isValid) {
+                throw new SecurityError(`Content validation failed: ${base64DataValidation.error}`);
+            }
             return {
                 success: true,
                 data,
@@ -498,5 +532,147 @@ ${url}
 
 🔒 Privacy: This link is private and will expire automatically.`;
     }
+    /**
+     * SECURITY FIX: Validate persona data before any processing
+     * This provides defense-in-depth validation before content reaches file operations
+     */
+    async validatePersonaData(data) {
+        try {
+            // Basic structure validation
+            if (!data || typeof data !== 'object') {
+                return { isValid: false, error: 'Invalid data structure' };
+            }
+            // Validate required fields for persona data
+            if (data.metadata && (!data.metadata.name || !data.metadata.description)) {
+                return { isValid: false, error: 'Missing required persona metadata' };
+            }
+            // Validate content if present
+            if (data.content) {
+                // Size validation
+                try {
+                    validateContentSize(data.content, 100 * 1024); // 100KB limit
+                }
+                catch (error) {
+                    return { isValid: false, error: `Content size validation failed: ${error instanceof Error ? error.message : 'Unknown error'}` };
+                }
+                // Content security validation
+                const contentValidation = ContentValidator.validateAndSanitize(data.content);
+                if (!contentValidation.isValid && contentValidation.severity === 'critical') {
+                    return {
+                        isValid: false,
+                        error: `Critical security threat detected: ${contentValidation.detectedPatterns?.join(', ')}`
+                    };
+                }
+            }
+            // Validate bundle structure if it's a bundle
+            if (data.personas && Array.isArray(data.personas)) {
+                for (const persona of data.personas) {
+                    const personaValidation = await this.validatePersonaData(persona);
+                    if (!personaValidation.isValid) {
+                        return { isValid: false, error: `Bundle validation failed: ${personaValidation.error}` };
+                    }
+                }
+            }
+            return { isValid: true };
+        }
+        catch (error) {
+            return {
+                isValid: false,
+                error: `Validation error: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+    /**
+     * ENHANCED SECURITY FIX: Comprehensive Content-Type validation
+     * Strengthens MIME type validation with comprehensive security checks
+     */
+    validateContentType(contentType, expectedType) {
+        // Check if Content-Type header exists
+        if (!contentType) {
+            return {
+                isValid: false,
+                error: 'Missing Content-Type header'
+            };
+        }
+        // Normalize and sanitize the content type
+        const normalizedContentType = contentType.toLowerCase().trim();
+        const normalizedExpectedType = expectedType.toLowerCase().trim();
+        // Validate Content-Type format (basic MIME type structure)
+        const mimeTypePattern = /^[a-z0-9][a-z0-9!#$&\-\^_]*\/[a-z0-9][a-z0-9!#$&\-\^_]*(?:\s*;.*)?$/;
+        if (!mimeTypePattern.test(normalizedContentType)) {
+            return {
+                isValid: false,
+                error: `Malformed Content-Type header: ${contentType}`
+            };
+        }
+        // Extract main MIME type (before any parameters like charset)
+        const mainType = normalizedContentType.split(';')[0].trim();
+        // Security check: Block dangerous MIME types that could bypass validation
+        const dangerousMimeTypes = [
+            'text/html', // Could contain XSS
+            'text/javascript', // Could contain malicious scripts
+            'application/javascript', // Could contain malicious scripts
+            'text/xml', // Could contain XXE attacks
+            'application/xml', // Could contain XXE attacks
+            'image/svg+xml', // Could contain XSS in SVG
+            'multipart/form-data', // Unexpected for API responses
+            'application/x-www-form-urlencoded' // Unexpected for API responses
+        ];
+        if (dangerousMimeTypes.includes(mainType)) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'CONTENT_INJECTION_ATTEMPT',
+                severity: 'HIGH',
+                source: 'persona_sharer',
+                details: `Dangerous Content-Type detected: ${contentType}`,
+                metadata: { contentType, expectedType }
+            });
+            return {
+                isValid: false,
+                error: `Dangerous Content-Type not allowed: ${mainType}`
+            };
+        }
+        // Check if the main type matches expected type
+        if (!mainType.includes(normalizedExpectedType)) {
+            return {
+                isValid: false,
+                error: `Content-Type mismatch: expected ${expectedType}, got ${mainType}`
+            };
+        }
+        // Additional validation for JSON responses
+        if (normalizedExpectedType === 'application/json') {
+            // Accept various JSON-compatible MIME types
+            const acceptableJsonTypes = [
+                'application/json',
+                'application/vnd.api+json',
+                'application/vnd.github.v3+json',
+                'text/json' // Some APIs use this (though not standard)
+            ];
+            const isAcceptableJson = acceptableJsonTypes.some(type => mainType === type);
+            if (!isAcceptableJson) {
+                return {
+                    isValid: false,
+                    error: `Unsupported JSON Content-Type: ${mainType}`
+                };
+            }
+            // Validate charset parameter if present
+            const charsetMatch = normalizedContentType.match(/charset=([^;\s]+)/);
+            if (charsetMatch) {
+                const charset = charsetMatch[1].toLowerCase();
+                const supportedCharsets = ['utf-8', 'utf8', 'ascii', 'iso-8859-1'];
+                if (!supportedCharsets.includes(charset)) {
+                    return {
+                        isValid: false,
+                        error: `Unsupported charset: ${charset}`
+                    };
+                }
+            }
+        }
+        // Log successful validation for monitoring
+        logger.debug('Content-Type validation passed', {
+            contentType: mainType,
+            expectedType: normalizedExpectedType
+        });
+        return { isValid: true };
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PersonaSharer.js","sourceRoot":"","sources":["../../../src/persona/export-import/PersonaSharer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Persona sharing functionality via URLs\n */\n\nimport { Persona } from '../../types/persona.js';\nimport { PersonaExporter, ExportedPersona } from './PersonaExporter.js';\nimport { GitHubClient } from '../../collection/GitHubClient.js';\nimport { TokenManager } from '../../security/tokenManager.js';\nimport { SecurityError } from '../../security/errors.js';\nimport { logger } from '../../utils/logger.js';\nimport { RateLimiter } from '../../update/RateLimiter.js';\n\nexport interface ShareResult {\n  success: boolean;\n  url?: string;\n  gistId?: string;\n  expiresAt?: string;\n  message: string;\n}\n\nexport class PersonaSharer {\n  private exporter: PersonaExporter;\n  private githubRateLimiter: RateLimiter;\n  \n  constructor(\n    private githubClient: GitHubClient,\n    private currentUser: string | null\n  ) {\n    this.exporter = new PersonaExporter(currentUser);\n    \n    // GitHub API rate limit: 60 requests per hour for unauthenticated\n    // 5000 per hour for authenticated - use TokenManager to check\n    const hasValidToken = TokenManager.getGitHubToken() !== null;\n    this.githubRateLimiter = new RateLimiter({\n      maxRequests: hasValidToken ? 100 : 30, // Conservative limits\n      windowMs: 60 * 60 * 1000, // 1 hour\n      minDelayMs: 1000 // Minimum 1 second between requests\n    });\n  }\n\n  /**\n   * Share a persona via GitHub Gist\n   */\n  async sharePersona(persona: Persona, expiryDays: number = 7): Promise<ShareResult> {\n    try {\n      // Validate gist permissions if token is available\n      const token = TokenManager.getGitHubToken();\n      let hasValidToken = false;\n      \n      if (token) {\n        try {\n          const validation = await TokenManager.ensureTokenPermissions('gist');\n          if (!validation.isValid) {\n            const safeMessage = TokenManager.createSafeErrorMessage(validation.error || 'Unknown validation error', token);\n            logger.warn('GitHub token lacks gist permissions, falling back to base64 URL', { error: safeMessage });\n            // Continue to fallback instead of failing\n          } else {\n            hasValidToken = true;\n          }\n        } catch (error) {\n          // Handle rate limiting or other security errors gracefully\n          if (error instanceof SecurityError && error.code === 'RATE_LIMIT_EXCEEDED') {\n            logger.warn('Token validation rate limited, falling back to base64 URL', { \n              error: 'Rate limit exceeded for token validation' \n            });\n          } else if (error instanceof Error) {\n            const safeMessage = TokenManager.createSafeErrorMessage(error.message, token);\n            logger.warn('Token validation failed, falling back to base64 URL', { error: safeMessage });\n          }\n          // Continue to fallback instead of failing\n        }\n      }\n\n      // Export persona to structured format\n      const exportData = this.exporter.exportPersona(persona);\n      \n      // Add sharing metadata\n      const shareData = {\n        ...exportData,\n        sharedAt: new Date().toISOString(),\n        sharedBy: this.currentUser || 'anonymous',\n        expiresAt: new Date(Date.now() + expiryDays * 24 * 60 * 60 * 1000).toISOString(),\n        shareVersion: '1.0.0'\n      };\n\n      // Create GitHub Gist if token has proper permissions\n      if (hasValidToken) {\n        const gistResult = await this.createGist(persona.metadata.name, shareData);\n        \n        if (gistResult.success) {\n          return {\n            success: true,\n            url: gistResult.url!,\n            gistId: gistResult.gistId,\n            expiresAt: shareData.expiresAt,\n            message: this.formatShareSuccess(gistResult.url!, shareData.expiresAt)\n          };\n        }\n      }\n\n      // Fallback to base64 URL if Gist fails or no token\n      return this.createBase64Url(shareData);\n\n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      const safeMessage = TokenManager.createSafeErrorMessage(errorMessage);\n      logger.error('Share error', { error: safeMessage });\n      \n      return {\n        success: false,\n        message: `Failed to share persona: ${safeMessage}`\n      };\n    }\n  }\n\n  /**\n   * Import a persona from a share URL\n   */\n  async importFromUrl(url: string): Promise<{ success: boolean; data?: any; message: string }> {\n    try {\n      // Validate URL first\n      if (!this.validateShareUrl(url)) {\n        return {\n          success: false,\n          message: 'Invalid or unsafe URL provided'\n        };\n      }\n      // Check if it's a GitHub Gist URL\n      const gistId = this.extractGistId(url);\n      if (gistId) {\n        return await this.importFromGist(gistId);\n      }\n\n      // Check if it's a base64 URL\n      if (url.includes('#dollhouse-persona=')) {\n        return this.importFromBase64Url(url);\n      }\n\n      // Validate URL for security\n      if (!this.validateShareUrl(url)) {\n        throw new Error('Invalid or potentially malicious URL');\n      }\n\n      // Try direct fetch with timeout\n      const controller = new AbortController();\n      const timeoutId = setTimeout(() => controller.abort(), 5000); // 5 second timeout\n      \n      try {\n        const response = await fetch(url, {\n          signal: controller.signal,\n          headers: {\n            'User-Agent': 'DollhouseMCP/1.0',\n            'Accept': 'application/json'\n          }\n        });\n        \n        clearTimeout(timeoutId);\n        \n        if (!response.ok) {\n          throw new Error(`Request failed with status ${response.status}`);\n        }\n\n        // Validate Content-Type header\n        const contentType = response.headers.get('content-type');\n        if (!contentType || !contentType.toLowerCase().includes('application/json')) {\n          throw new Error('Invalid response type: expected JSON');\n        }\n\n        // Check response size to prevent memory exhaustion\n        const contentLength = response.headers.get('content-length');\n        const maxSize = 5 * 1024 * 1024; // 5MB max\n        if (contentLength && parseInt(contentLength) > maxSize) {\n          throw new Error('Response too large');\n        }\n\n        const data = await response.json();\n        return {\n          success: true,\n          data,\n          message: 'Successfully retrieved persona data'\n        };\n      } finally {\n        clearTimeout(timeoutId);\n      }\n\n    } catch (error) {\n      logger.error('Import from URL error', error);\n      return {\n        success: false,\n        message: `Failed to import from URL: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n\n  /**\n   * Create a GitHub Gist\n   */\n  private async createGist(personaName: string, data: any): Promise<{ success: boolean; url?: string; gistId?: string }> {\n    try {\n      // Use TokenManager for secure token handling\n      const token = TokenManager.getGitHubToken();\n      if (!token) {\n        logger.info('No valid GitHub token available for Gist creation');\n        return { success: false };\n      }\n      \n      // Check rate limit\n      const rateLimitStatus = this.githubRateLimiter.checkLimit();\n      if (!rateLimitStatus.allowed) {\n        logger.warn(`GitHub API rate limit exceeded. Retry after ${rateLimitStatus.retryAfterMs}ms`);\n        return { success: false };\n      }\n\n      const controller = new AbortController();\n      const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout\n      \n      try {\n        const response = await fetch('https://api.github.com/gists', {\n          method: 'POST',\n          signal: controller.signal,\n        headers: {\n          'Authorization': `Bearer ${token}`,\n          'Accept': 'application/vnd.github.v3+json',\n          'Content-Type': 'application/json',\n          'User-Agent': 'DollhouseMCP/1.0'\n        },\n        body: JSON.stringify({\n          description: `DollhouseMCP Persona: ${personaName}`,\n          public: false, // Private gist for security\n          files: {\n            'persona.json': {\n              content: JSON.stringify(data, null, 2)\n            }\n          }\n        })\n        });\n        \n        clearTimeout(timeoutId);\n\n        if (!response.ok) {\n          throw new Error(`GitHub API error: ${response.status}`);\n        }\n\n        // Validate Content-Type for GitHub API response\n        const contentType = response.headers.get('content-type');\n        if (!contentType || !contentType.toLowerCase().includes('application/json')) {\n          throw new Error('Invalid GitHub API response type');\n        }\n\n        const gist = await response.json();\n        \n        // Consume the rate limit token after successful request\n        this.githubRateLimiter.consumeToken();\n        \n        return {\n          success: true,\n          url: gist.html_url,\n          gistId: gist.id\n        };\n      } finally {\n        clearTimeout(timeoutId);\n      }\n\n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      const safeMessage = TokenManager.createSafeErrorMessage(errorMessage);\n      logger.error('Gist creation error', { error: safeMessage });\n      return { success: false };\n    }\n  }\n\n  /**\n   * Create a base64 URL (fallback)\n   */\n  private createBase64Url(data: any): ShareResult {\n    const base64 = this.exporter.toBase64(data);\n    const url = `https://dollhousemcp.com/import#dollhouse-persona=${base64}`;\n    \n    return {\n      success: true,\n      url,\n      expiresAt: data.expiresAt,\n      message: this.formatShareSuccess(url, data.expiresAt)\n    };\n  }\n\n  /**\n   * Import from GitHub Gist\n   */\n  private async importFromGist(gistId: string): Promise<{ success: boolean; data?: any; message: string }> {\n    try {\n      // Check rate limit\n      const rateLimitStatus = this.githubRateLimiter.checkLimit();\n      if (!rateLimitStatus.allowed) {\n        throw new Error(`GitHub API rate limit exceeded. Please try again in ${Math.ceil(rateLimitStatus.retryAfterMs! / 1000)} seconds`);\n      }\n      \n      const gistUrl = `https://api.github.com/gists/${gistId}`;\n      \n      // Validate URL (should always pass for GitHub API)\n      if (!this.validateShareUrl(gistUrl)) {\n        throw new Error('Invalid GitHub API URL');\n      }\n      \n      const controller = new AbortController();\n      const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout for API\n      \n      try {\n        const response = await fetch(gistUrl, {\n          signal: controller.signal,\n          headers: {\n            'Accept': 'application/vnd.github.v3+json',\n            'User-Agent': 'DollhouseMCP/1.0'\n          }\n        });\n        \n        clearTimeout(timeoutId);\n\n        if (!response.ok) {\n          throw new Error(`Failed to fetch gist: ${response.status}`);\n        }\n\n        // Validate Content-Type for GitHub API response\n        const contentType = response.headers.get('content-type');\n        if (!contentType || !contentType.toLowerCase().includes('application/json')) {\n          throw new Error('Invalid GitHub API response type');\n        }\n\n        const gist = await response.json();\n        const personaFile = gist.files['persona.json'];\n        \n        if (!personaFile) {\n          throw new Error('No persona data found in gist');\n        }\n\n        const data = JSON.parse(personaFile.content);\n        \n        // Check expiry\n        if (data.expiresAt && new Date(data.expiresAt) < new Date()) {\n          return {\n            success: false,\n            message: 'This share link has expired'\n          };\n        }\n\n        // Consume the rate limit token after successful request\n        this.githubRateLimiter.consumeToken();\n        \n        return {\n          success: true,\n          data,\n          message: 'Successfully retrieved persona from GitHub'\n        };\n      } finally {\n        clearTimeout(timeoutId);\n      }\n\n    } catch (error) {\n      logger.error('Gist import error', error);\n      return {\n        success: false,\n        message: `Failed to import from gist: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n\n  /**\n   * Validate URL for security (prevent SSRF attacks)\n   */\n  private validateShareUrl(url: string): boolean {\n    try {\n      // 1. URL length check to prevent DoS\n      if (url.length > 2048) {\n        logger.warn('URL exceeds maximum length', { urlLength: url.length });\n        return false;\n      }\n\n      const parsed = new URL(url);\n      \n      // 2. Protocol check - only allow http/https\n      if (!['https:', 'http:'].includes(parsed.protocol)) {\n        logger.warn('Invalid protocol in URL', { protocol: parsed.protocol });\n        return false;\n      }\n      \n      // 3. Port restrictions - block non-standard ports that could be internal services\n      const port = parsed.port || (parsed.protocol === 'https:' ? '443' : '80');\n      const allowedPorts = ['80', '443', '8080', '8443'];\n      if (!allowedPorts.includes(port)) {\n        logger.warn('Blocked non-standard port', { port });\n        return false;\n      }\n      \n      // 4. Hostname validation\n      const hostname = parsed.hostname.toLowerCase();\n      \n      // Block various localhost representations\n      const blockedHostnames = [\n        'localhost', \n        'localhost.localdomain',\n        '0.0.0.0',\n        '0',\n        '0x0',\n        '0x00000000',\n        '[::1]',\n        '[::ffff:127.0.0.1]',\n        '[0000:0000:0000:0000:0000:0000:0000:0001]'\n      ];\n      \n      if (blockedHostnames.includes(hostname)) {\n        logger.warn('Blocked localhost hostname', { hostname });\n        return false;\n      }\n      \n      // Block private IP ranges with comprehensive patterns\n      const privateIpPatterns = [\n        /^127\\./,                                    // Loopback\n        /^10\\./,                                     // Private class A\n        /^192\\.168\\./,                               // Private class C\n        /^172\\.(1[6-9]|2[0-9]|3[0-1])\\./,          // Private class B\n        /^169\\.254\\./,                               // Link-local\n        /^fc00:/i,                                   // IPv6 private\n        /^fe80:/i,                                   // IPv6 link-local\n        /^::1$/,                                     // IPv6 loopback\n        /^::ffff:0?:?0?:?0?:?0?$/i,                // IPv6 mapped IPv4\n        /^100\\.6[4-9]\\./,                           // Carrier-grade NAT\n        /^100\\.[7-9][0-9]\\./,                       // Carrier-grade NAT\n        /^100\\.1[0-2][0-9]\\./,                      // Carrier-grade NAT\n        /^0\\./,                                      // Reserved\n        /^255\\.255\\.255\\.255$/                      // Broadcast\n      ];\n      \n      if (privateIpPatterns.some(pattern => pattern.test(hostname))) {\n        logger.warn('Blocked private IP range', { hostname });\n        return false;\n      }\n      \n      // Block cloud metadata endpoints\n      const metadataEndpoints = [\n        '169.254.169.254',     // AWS/GCP/Azure\n        'metadata.google.internal',\n        'metadata.azure.com',\n        '100.100.100.200'      // Alibaba Cloud\n      ];\n      \n      if (metadataEndpoints.includes(hostname)) {\n        logger.warn('Blocked cloud metadata endpoint', { hostname });\n        return false;\n      }\n      \n      // Block numeric IP representations that could bypass checks\n      if (/^\\d+$/.test(hostname)) {\n        // Convert decimal to IP and check\n        const num = parseInt(hostname, 10);\n        if (num <= 0xFFFFFFFF) {\n          const ip = `${(num >>> 24) & 0xFF}.${(num >>> 16) & 0xFF}.${(num >>> 8) & 0xFF}.${num & 0xFF}`;\n          logger.warn('Blocked numeric IP representation', { hostname, resolvedIp: ip });\n          return false;\n        }\n      }\n      \n      // Block hex IP representations\n      if (/^0x[0-9a-f]+$/i.test(hostname)) {\n        logger.warn('Blocked hex IP representation', { hostname });\n        return false;\n      }\n      \n      // Validate domain format (basic check)\n      // Allow GitHub domains and common share platforms\n      const trustedDomains = [\n        'github.com',\n        'gist.github.com', \n        'api.github.com',\n        'raw.githubusercontent.com',\n        'dollhousemcp.com'\n      ];\n      \n      // Check if it's a trusted domain\n      const isTrustedDomain = trustedDomains.some(domain => \n        hostname === domain || hostname.endsWith(`.${domain}`)\n      );\n      \n      if (!isTrustedDomain) {\n        // For non-trusted domains, apply stricter validation\n        // Must be a valid domain format, not just an IP\n        const domainPattern = /^([a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,}$/i;\n        const ipv4Pattern = /^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$/;\n        const ipv6Pattern = /^\\[?([0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}\\]?$/i;\n        \n        if (ipv4Pattern.test(hostname) || ipv6Pattern.test(hostname)) {\n          logger.warn('Direct IP access not allowed for untrusted sources', { hostname });\n          return false;\n        }\n        \n        if (!domainPattern.test(hostname)) {\n          logger.warn('Invalid domain format', { hostname });\n          return false;\n        }\n      }\n      \n      logger.debug('URL validation passed', { \n        hostname, \n        protocol: parsed.protocol,\n        isTrusted: isTrustedDomain \n      });\n      \n      return true;\n    } catch (error) {\n      logger.warn('URL validation error', { error: error instanceof Error ? error.message : 'Unknown error' });\n      return false;\n    }\n  }\n\n  /**\n   * Import from base64 URL\n   */\n  private importFromBase64Url(url: string): { success: boolean; data?: any; message: string } {\n    try {\n      // Limit base64 length to prevent ReDoS attacks (10KB max for base64 encoded data)\n      const match = url.match(/#dollhouse-persona=([A-Za-z0-9+/=]{1,10000})$/);\n      if (!match) {\n        throw new Error('Invalid share URL format');\n      }\n\n      const base64 = match[1];\n      const json = Buffer.from(base64, 'base64').toString('utf-8');\n      const data = JSON.parse(json);\n\n      // Check expiry\n      if (data.expiresAt && new Date(data.expiresAt) < new Date()) {\n        return {\n          success: false,\n          message: 'This share link has expired'\n        };\n      }\n\n      return {\n        success: true,\n        data,\n        message: 'Successfully decoded persona data'\n      };\n\n    } catch (error) {\n      return {\n        success: false,\n        message: `Failed to decode share URL: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n\n  /**\n   * Extract Gist ID from GitHub URL\n   */\n  private extractGistId(url: string): string | null {\n    const match = url.match(/gist\\.github\\.com\\/[^\\/]+\\/([a-f0-9]+)/);\n    return match ? match[1] : null;\n  }\n\n  /**\n   * Format share success message\n   */\n  private formatShareSuccess(url: string, expiresAt: string): string {\n    const expiryDate = new Date(expiresAt);\n    const daysUntilExpiry = Math.ceil((expiryDate.getTime() - Date.now()) / (24 * 60 * 60 * 1000));\n\n    return `✅ Successfully created share link!\n\n🔗 Share URL:\n${url}\n\n⏱️ Expires: ${expiryDate.toLocaleDateString()} (${daysUntilExpiry} days)\n\n📋 To share this persona:\n1. Copy the URL above\n2. Share it with others\n3. They can import using: import_from_url \"${url}\"\n\n🔒 Privacy: This link is private and will expire automatically.`;\n  }\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PersonaSharer.js","sourceRoot":"","sources":["../../../src/persona/export-import/PersonaSharer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Persona sharing functionality via URLs\n * \n * SECURITY FIX IMPLEMENTED (Defense-in-Depth Validation):\n * 1. CRITICAL: Added validate-before-return pattern in all import methods\n * 2. HIGH: Content security validation using ContentValidator before data return\n * 3. MEDIUM: Size validation to prevent memory exhaustion attacks\n * 4. MEDIUM: Structure validation to prevent malformed data processing\n * 5. DEFENSE-IN-DEPTH: Multiple validation layers before PersonaImporter processing\n * \n * This provides defense-in-depth security by validating content at the earliest\n * possible point before any data is returned to calling code or file operations.\n */\n\nimport { Persona } from '../../types/persona.js';\nimport { PersonaExporter, ExportedPersona } from './PersonaExporter.js';\nimport { GitHubClient } from '../../collection/GitHubClient.js';\nimport { TokenManager } from '../../security/tokenManager.js';\nimport { SecurityError } from '../../security/errors.js';\nimport { logger } from '../../utils/logger.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { ErrorHandler, ErrorCategory } from '../../utils/ErrorHandler.js';\nimport { ValidationErrorCodes, NetworkErrorCodes } from '../../utils/errorCodes.js';\nimport { RateLimiter } from '../../utils/RateLimiter.js';\nimport { ContentValidator } from '../../security/contentValidator.js';\nimport { validateContentSize } from '../../security/InputValidator.js';\n\nexport interface ShareResult {\n  success: boolean;\n  url?: string;\n  gistId?: string;\n  expiresAt?: string;\n  message: string;\n}\n\nexport class PersonaSharer {\n  private exporter: PersonaExporter;\n  private githubRateLimiter: RateLimiter;\n  \n  constructor(\n    private githubClient: GitHubClient,\n    private currentUser: string | null\n  ) {\n    this.exporter = new PersonaExporter(currentUser);\n    \n    // GitHub API rate limit: 60 requests per hour for unauthenticated\n    // 5000 per hour for authenticated - use TokenManager to check\n    const hasValidToken = TokenManager.getGitHubToken() !== null;\n    this.githubRateLimiter = new RateLimiter({\n      maxRequests: hasValidToken ? 100 : 30, // Conservative limits\n      windowMs: 60 * 60 * 1000, // 1 hour\n      minDelayMs: 1000 // Minimum 1 second between requests\n    });\n  }\n\n  /**\n   * Share a persona via GitHub Gist\n   */\n  async sharePersona(persona: Persona, expiryDays: number = 7): Promise<ShareResult> {\n    try {\n      // Validate gist permissions if token is available\n      const token = TokenManager.getGitHubToken();\n      let hasValidToken = false;\n      \n      if (token) {\n        try {\n          const validation = await TokenManager.ensureTokenPermissions('gist');\n          if (!validation.isValid) {\n            const safeMessage = TokenManager.createSafeErrorMessage(validation.error || 'Unknown validation error', token);\n            logger.warn('GitHub token lacks gist permissions, falling back to base64 URL', { error: safeMessage });\n            // Continue to fallback instead of failing\n          } else {\n            hasValidToken = true;\n          }\n        } catch (error) {\n          // Handle rate limiting or other security errors gracefully\n          if (error instanceof SecurityError && error.code === 'RATE_LIMIT_EXCEEDED') {\n            logger.warn('Token validation rate limited, falling back to base64 URL', { \n              error: 'Rate limit exceeded for token validation' \n            });\n          } else if (error instanceof Error) {\n            const safeMessage = TokenManager.createSafeErrorMessage(error.message, token);\n            logger.warn('Token validation failed, falling back to base64 URL', { error: safeMessage });\n          }\n          // Continue to fallback instead of failing\n        }\n      }\n\n      // Export persona to structured format\n      const exportData = this.exporter.exportPersona(persona);\n      \n      // Add sharing metadata\n      const shareData = {\n        ...exportData,\n        sharedAt: new Date().toISOString(),\n        sharedBy: this.currentUser || 'anonymous',\n        expiresAt: new Date(Date.now() + expiryDays * 24 * 60 * 60 * 1000).toISOString(),\n        shareVersion: '1.0.0'\n      };\n\n      // Create GitHub Gist if token has proper permissions\n      if (hasValidToken) {\n        const gistResult = await this.createGist(persona.metadata.name, shareData);\n        \n        if (gistResult.success) {\n          return {\n            success: true,\n            url: gistResult.url!,\n            gistId: gistResult.gistId,\n            expiresAt: shareData.expiresAt,\n            message: this.formatShareSuccess(gistResult.url!, shareData.expiresAt)\n          };\n        }\n      }\n\n      // Fallback to base64 URL if Gist fails or no token\n      return this.createBase64Url(shareData);\n\n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      const safeMessage = TokenManager.createSafeErrorMessage(errorMessage);\n      logger.error('Share error', { error: safeMessage });\n      \n      return {\n        success: false,\n        message: `Failed to share persona: ${safeMessage}`\n      };\n    }\n  }\n\n  /**\n   * Import a persona from a share URL\n   * SECURITY FIX: Validate ALL content before returning any data\n   */\n  async importFromUrl(url: string): Promise<{ success: boolean; data?: any; message: string }> {\n    try {\n      // Validate URL first\n      if (!this.validateShareUrl(url)) {\n        return {\n          success: false,\n          message: 'Invalid or unsafe URL provided'\n        };\n      }\n      // Check if it's a GitHub Gist URL\n      const gistId = this.extractGistId(url);\n      if (gistId) {\n        return await this.importFromGist(gistId);\n      }\n\n      // Check if it's a base64 URL\n      if (url.includes('#dollhouse-persona=')) {\n        return await this.importFromBase64Url(url);\n      }\n\n      // Validate URL for security\n      if (!this.validateShareUrl(url)) {\n        throw ErrorHandler.createError('Invalid or potentially malicious URL', ErrorCategory.VALIDATION_ERROR, ValidationErrorCodes.INVALID_URL);\n      }\n\n      // Try direct fetch with timeout\n      const controller = new AbortController();\n      const timeoutId = setTimeout(() => controller.abort(), 5000); // 5 second timeout\n      \n      try {\n        const response = await fetch(url, {\n          signal: controller.signal,\n          headers: {\n            'User-Agent': 'DollhouseMCP/1.0',\n            'Accept': 'application/json'\n          }\n        });\n        \n        clearTimeout(timeoutId);\n        \n        if (!response.ok) {\n          throw ErrorHandler.createError(`Request failed with status ${response.status}`, ErrorCategory.NETWORK_ERROR, NetworkErrorCodes.REQUEST_FAILED);\n        }\n\n        // ENHANCED SECURITY FIX: Comprehensive Content-Type validation\n        const contentType = response.headers.get('content-type');\n        const contentTypeValidation = this.validateContentType(contentType, 'application/json');\n        if (!contentTypeValidation.isValid) {\n          throw ErrorHandler.createError(\n            `Invalid response type: ${contentTypeValidation.error}`, \n            ErrorCategory.NETWORK_ERROR, \n            NetworkErrorCodes.INVALID_RESPONSE\n          );\n        }\n\n        // Check response size to prevent memory exhaustion\n        const contentLength = response.headers.get('content-length');\n        const maxSize = 5 * 1024 * 1024; // 5MB max\n        if (contentLength && parseInt(contentLength) > maxSize) {\n          throw ErrorHandler.createError('Response too large', ErrorCategory.VALIDATION_ERROR, NetworkErrorCodes.RESPONSE_TOO_LARGE);\n        }\n\n        const data = await response.json();\n        \n        // SECURITY FIX: Validate content before returning\n        const dataValidation = await this.validatePersonaData(data);\n        if (!dataValidation.isValid) {\n          throw new SecurityError(`Content validation failed: ${dataValidation.error}`);\n        }\n        \n        return {\n          success: true,\n          data,\n          message: 'Successfully retrieved persona data'\n        };\n      } finally {\n        clearTimeout(timeoutId);\n      }\n\n    } catch (error) {\n      logger.error('Import from URL error', error);\n      return {\n        success: false,\n        message: `Failed to import from URL: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n\n  /**\n   * Create a GitHub Gist\n   */\n  private async createGist(personaName: string, data: any): Promise<{ success: boolean; url?: string; gistId?: string }> {\n    try {\n      // Use TokenManager for secure token handling\n      const token = TokenManager.getGitHubToken();\n      if (!token) {\n        logger.info('No valid GitHub token available for Gist creation');\n        return { success: false };\n      }\n      \n      // Check rate limit\n      const rateLimitStatus = this.githubRateLimiter.checkLimit();\n      if (!rateLimitStatus.allowed) {\n        logger.warn(`GitHub API rate limit exceeded. Retry after ${rateLimitStatus.retryAfterMs}ms`);\n        return { success: false };\n      }\n\n      const controller = new AbortController();\n      const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout\n      \n      try {\n        const response = await fetch('https://api.github.com/gists', {\n          method: 'POST',\n          signal: controller.signal,\n        headers: {\n          'Authorization': `Bearer ${token}`,\n          'Accept': 'application/vnd.github.v3+json',\n          'Content-Type': 'application/json',\n          'User-Agent': 'DollhouseMCP/1.0'\n        },\n        body: JSON.stringify({\n          description: `DollhouseMCP Persona: ${personaName}`,\n          public: false, // Private gist for security\n          files: {\n            'persona.json': {\n              content: JSON.stringify(data, null, 2)\n            }\n          }\n        })\n        });\n        \n        clearTimeout(timeoutId);\n\n        if (!response.ok) {\n          throw ErrorHandler.createError(`GitHub API error: ${response.status}`, ErrorCategory.NETWORK_ERROR, NetworkErrorCodes.API_ERROR);\n        }\n\n        // ENHANCED SECURITY FIX: Comprehensive Content-Type validation for GitHub API\n        const contentType = response.headers.get('content-type');\n        const gistContentTypeValidation = this.validateContentType(contentType, 'application/json');\n        if (!gistContentTypeValidation.isValid) {\n          throw ErrorHandler.createError(\n            `Invalid GitHub API response type: ${gistContentTypeValidation.error}`, \n            ErrorCategory.NETWORK_ERROR, \n            NetworkErrorCodes.INVALID_RESPONSE\n          );\n        }\n\n        const gist = await response.json();\n        \n        // Consume the rate limit token after successful request\n        this.githubRateLimiter.consumeToken();\n        \n        return {\n          success: true,\n          url: gist.html_url,\n          gistId: gist.id\n        };\n      } finally {\n        clearTimeout(timeoutId);\n      }\n\n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      const safeMessage = TokenManager.createSafeErrorMessage(errorMessage);\n      logger.error('Gist creation error', { error: safeMessage });\n      return { success: false };\n    }\n  }\n\n  /**\n   * Create a base64 URL (fallback)\n   */\n  private createBase64Url(data: any): ShareResult {\n    const base64 = this.exporter.toBase64(data);\n    const url = `https://dollhousemcp.com/import#dollhouse-persona=${base64}`;\n    \n    return {\n      success: true,\n      url,\n      expiresAt: data.expiresAt,\n      message: this.formatShareSuccess(url, data.expiresAt)\n    };\n  }\n\n  /**\n   * Import from GitHub Gist\n   */\n  private async importFromGist(gistId: string): Promise<{ success: boolean; data?: any; message: string }> {\n    try {\n      // Check rate limit\n      const rateLimitStatus = this.githubRateLimiter.checkLimit();\n      if (!rateLimitStatus.allowed) {\n        throw ErrorHandler.createError(`GitHub API rate limit exceeded. Please try again in ${Math.ceil(rateLimitStatus.retryAfterMs! / 1000)} seconds`, ErrorCategory.NETWORK_ERROR, NetworkErrorCodes.RATE_LIMIT_EXCEEDED);\n      }\n      \n      const gistUrl = `https://api.github.com/gists/${gistId}`;\n      \n      // Validate URL (should always pass for GitHub API)\n      if (!this.validateShareUrl(gistUrl)) {\n        throw ErrorHandler.createError('Invalid GitHub API URL', ErrorCategory.VALIDATION_ERROR, ValidationErrorCodes.INVALID_URL);\n      }\n      \n      const controller = new AbortController();\n      const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout for API\n      \n      try {\n        const response = await fetch(gistUrl, {\n          signal: controller.signal,\n          headers: {\n            'Accept': 'application/vnd.github.v3+json',\n            'User-Agent': 'DollhouseMCP/1.0'\n          }\n        });\n        \n        clearTimeout(timeoutId);\n\n        if (!response.ok) {\n          throw ErrorHandler.createError(`Failed to fetch gist: ${response.status}`, ErrorCategory.NETWORK_ERROR, NetworkErrorCodes.FETCH_FAILED);\n        }\n\n        // ENHANCED SECURITY FIX: Comprehensive Content-Type validation for GitHub API\n        const contentType = response.headers.get('content-type');\n        const gistContentTypeValidation = this.validateContentType(contentType, 'application/json');\n        if (!gistContentTypeValidation.isValid) {\n          throw ErrorHandler.createError(\n            `Invalid GitHub API response type: ${gistContentTypeValidation.error}`, \n            ErrorCategory.NETWORK_ERROR, \n            NetworkErrorCodes.INVALID_RESPONSE\n          );\n        }\n\n        const gist = await response.json();\n        const personaFile = gist.files['persona.json'];\n        \n        if (!personaFile) {\n          throw ErrorHandler.createError('No persona data found in gist', ErrorCategory.VALIDATION_ERROR, ValidationErrorCodes.INVALID_INPUT);\n        }\n\n        const data = JSON.parse(personaFile.content);\n        \n        // Check expiry\n        if (data.expiresAt && new Date(data.expiresAt) < new Date()) {\n          return {\n            success: false,\n            message: 'This share link has expired'\n          };\n        }\n\n        // SECURITY FIX: Validate content before returning\n        const gistDataValidation = await this.validatePersonaData(data);\n        if (!gistDataValidation.isValid) {\n          throw new SecurityError(`Content validation failed: ${gistDataValidation.error}`);\n        }\n\n        // Consume the rate limit token after successful request\n        this.githubRateLimiter.consumeToken();\n        \n        return {\n          success: true,\n          data,\n          message: 'Successfully retrieved persona from GitHub'\n        };\n      } finally {\n        clearTimeout(timeoutId);\n      }\n\n    } catch (error) {\n      logger.error('Gist import error', error);\n      return {\n        success: false,\n        message: `Failed to import from gist: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n\n  /**\n   * Validate URL for security (prevent SSRF attacks)\n   */\n  private validateShareUrl(url: string): boolean {\n    try {\n      // 1. URL length check to prevent DoS\n      if (url.length > 2048) {\n        logger.warn('URL exceeds maximum length', { urlLength: url.length });\n        return false;\n      }\n\n      const parsed = new URL(url);\n      \n      // 2. Protocol check - only allow http/https\n      if (!['https:', 'http:'].includes(parsed.protocol)) {\n        logger.warn('Invalid protocol in URL', { protocol: parsed.protocol });\n        return false;\n      }\n      \n      // 3. Port restrictions - block non-standard ports that could be internal services\n      const port = parsed.port || (parsed.protocol === 'https:' ? '443' : '80');\n      const allowedPorts = ['80', '443', '8080', '8443'];\n      if (!allowedPorts.includes(port)) {\n        logger.warn('Blocked non-standard port', { port });\n        return false;\n      }\n      \n      // 4. Hostname validation\n      const hostname = parsed.hostname.toLowerCase();\n      \n      // Block various localhost representations\n      const blockedHostnames = [\n        'localhost', \n        'localhost.localdomain',\n        '0.0.0.0',\n        '0',\n        '0x0',\n        '0x00000000',\n        '[::1]',\n        '[::ffff:127.0.0.1]',\n        '[0000:0000:0000:0000:0000:0000:0000:0001]'\n      ];\n      \n      if (blockedHostnames.includes(hostname)) {\n        logger.warn('Blocked localhost hostname', { hostname });\n        return false;\n      }\n      \n      // Block private IP ranges with comprehensive patterns\n      const privateIpPatterns = [\n        /^127\\./,                                    // Loopback\n        /^10\\./,                                     // Private class A\n        /^192\\.168\\./,                               // Private class C\n        /^172\\.(1[6-9]|2[0-9]|3[0-1])\\./,          // Private class B\n        /^169\\.254\\./,                               // Link-local\n        /^fc00:/i,                                   // IPv6 private\n        /^fe80:/i,                                   // IPv6 link-local\n        /^::1$/,                                     // IPv6 loopback\n        /^::ffff:0?:?0?:?0?:?0?$/i,                // IPv6 mapped IPv4\n        /^100\\.6[4-9]\\./,                           // Carrier-grade NAT\n        /^100\\.[7-9][0-9]\\./,                       // Carrier-grade NAT\n        /^100\\.1[0-2][0-9]\\./,                      // Carrier-grade NAT\n        /^0\\./,                                      // Reserved\n        /^255\\.255\\.255\\.255$/                      // Broadcast\n      ];\n      \n      if (privateIpPatterns.some(pattern => pattern.test(hostname))) {\n        logger.warn('Blocked private IP range', { hostname });\n        return false;\n      }\n      \n      // Block cloud metadata endpoints\n      const metadataEndpoints = [\n        '169.254.169.254',     // AWS/GCP/Azure\n        'metadata.google.internal',\n        'metadata.azure.com',\n        '100.100.100.200'      // Alibaba Cloud\n      ];\n      \n      if (metadataEndpoints.includes(hostname)) {\n        logger.warn('Blocked cloud metadata endpoint', { hostname });\n        return false;\n      }\n      \n      // Block numeric IP representations that could bypass checks\n      if (/^\\d+$/.test(hostname)) {\n        // Convert decimal to IP and check\n        const num = parseInt(hostname, 10);\n        if (num <= 0xFFFFFFFF) {\n          const ip = `${(num >>> 24) & 0xFF}.${(num >>> 16) & 0xFF}.${(num >>> 8) & 0xFF}.${num & 0xFF}`;\n          logger.warn('Blocked numeric IP representation', { hostname, resolvedIp: ip });\n          return false;\n        }\n      }\n      \n      // Block hex IP representations\n      if (/^0x[0-9a-f]+$/i.test(hostname)) {\n        logger.warn('Blocked hex IP representation', { hostname });\n        return false;\n      }\n      \n      // Validate domain format (basic check)\n      // Allow GitHub domains and common share platforms\n      const trustedDomains = [\n        'github.com',\n        'gist.github.com', \n        'api.github.com',\n        'raw.githubusercontent.com',\n        'dollhousemcp.com'\n      ];\n      \n      // Check if it's a trusted domain\n      const isTrustedDomain = trustedDomains.some(domain => \n        hostname === domain || hostname.endsWith(`.${domain}`)\n      );\n      \n      if (!isTrustedDomain) {\n        // For non-trusted domains, apply stricter validation\n        // Must be a valid domain format, not just an IP\n        const domainPattern = /^([a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,}$/i;\n        const ipv4Pattern = /^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$/;\n        const ipv6Pattern = /^\\[?([0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}\\]?$/i;\n        \n        if (ipv4Pattern.test(hostname) || ipv6Pattern.test(hostname)) {\n          logger.warn('Direct IP access not allowed for untrusted sources', { hostname });\n          return false;\n        }\n        \n        if (!domainPattern.test(hostname)) {\n          logger.warn('Invalid domain format', { hostname });\n          return false;\n        }\n      }\n      \n      logger.debug('URL validation passed', { \n        hostname, \n        protocol: parsed.protocol,\n        isTrusted: isTrustedDomain \n      });\n      \n      return true;\n    } catch (error) {\n      logger.warn('URL validation error', { error: error instanceof Error ? error.message : 'Unknown error' });\n      return false;\n    }\n  }\n\n  /**\n   * Import from base64 URL\n   */\n  private async importFromBase64Url(url: string): Promise<{ success: boolean; data?: any; message: string }> {\n    try {\n      // Limit base64 length to prevent ReDoS attacks (10KB max for base64 encoded data)\n      const match = url.match(/#dollhouse-persona=([A-Za-z0-9+/=]{1,10000})$/);\n      if (!match) {\n        throw ErrorHandler.createError('Invalid share URL format', ErrorCategory.VALIDATION_ERROR, ValidationErrorCodes.INVALID_FORMAT);\n      }\n\n      const base64 = match[1];\n      const json = Buffer.from(base64, 'base64').toString('utf-8');\n      const data = JSON.parse(json);\n\n      // Check expiry\n      if (data.expiresAt && new Date(data.expiresAt) < new Date()) {\n        return {\n          success: false,\n          message: 'This share link has expired'\n        };\n      }\n\n      // SECURITY FIX: Validate content before returning\n      const base64DataValidation = await this.validatePersonaData(data);\n      if (!base64DataValidation.isValid) {\n        throw new SecurityError(`Content validation failed: ${base64DataValidation.error}`);\n      }\n\n      return {\n        success: true,\n        data,\n        message: 'Successfully decoded persona data'\n      };\n\n    } catch (error) {\n      return {\n        success: false,\n        message: `Failed to decode share URL: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n\n  /**\n   * Extract Gist ID from GitHub URL\n   */\n  private extractGistId(url: string): string | null {\n    const match = url.match(/gist\\.github\\.com\\/[^\\/]+\\/([a-f0-9]+)/);\n    return match ? match[1] : null;\n  }\n\n  /**\n   * Format share success message\n   */\n  private formatShareSuccess(url: string, expiresAt: string): string {\n    const expiryDate = new Date(expiresAt);\n    const daysUntilExpiry = Math.ceil((expiryDate.getTime() - Date.now()) / (24 * 60 * 60 * 1000));\n\n    return `✅ Successfully created share link!\n\n🔗 Share URL:\n${url}\n\n⏱️ Expires: ${expiryDate.toLocaleDateString()} (${daysUntilExpiry} days)\n\n📋 To share this persona:\n1. Copy the URL above\n2. Share it with others\n3. They can import using: import_from_url \"${url}\"\n\n🔒 Privacy: This link is private and will expire automatically.`;\n  }\n\n  /**\n   * SECURITY FIX: Validate persona data before any processing\n   * This provides defense-in-depth validation before content reaches file operations\n   */\n  private async validatePersonaData(data: any): Promise<{ isValid: boolean; error?: string }> {\n    try {\n      // Basic structure validation\n      if (!data || typeof data !== 'object') {\n        return { isValid: false, error: 'Invalid data structure' };\n      }\n\n      // Validate required fields for persona data\n      if (data.metadata && (!data.metadata.name || !data.metadata.description)) {\n        return { isValid: false, error: 'Missing required persona metadata' };\n      }\n\n      // Validate content if present\n      if (data.content) {\n        // Size validation\n        try {\n          validateContentSize(data.content, 100 * 1024); // 100KB limit\n        } catch (error) {\n          return { isValid: false, error: `Content size validation failed: ${error instanceof Error ? error.message : 'Unknown error'}` };\n        }\n\n        // Content security validation\n        const contentValidation = ContentValidator.validateAndSanitize(data.content);\n        if (!contentValidation.isValid && contentValidation.severity === 'critical') {\n          return { \n            isValid: false, \n            error: `Critical security threat detected: ${contentValidation.detectedPatterns?.join(', ')}` \n          };\n        }\n      }\n\n      // Validate bundle structure if it's a bundle\n      if (data.personas && Array.isArray(data.personas)) {\n        for (const persona of data.personas) {\n          const personaValidation = await this.validatePersonaData(persona);\n          if (!personaValidation.isValid) {\n            return { isValid: false, error: `Bundle validation failed: ${personaValidation.error}` };\n          }\n        }\n      }\n\n      return { isValid: true };\n    } catch (error) {\n      return { \n        isValid: false, \n        error: `Validation error: ${error instanceof Error ? error.message : 'Unknown error'}` \n      };\n    }\n  }\n\n  /**\n   * ENHANCED SECURITY FIX: Comprehensive Content-Type validation\n   * Strengthens MIME type validation with comprehensive security checks\n   */\n  private validateContentType(\n    contentType: string | null, \n    expectedType: string\n  ): { isValid: boolean; error?: string } {\n    // Check if Content-Type header exists\n    if (!contentType) {\n      return { \n        isValid: false, \n        error: 'Missing Content-Type header' \n      };\n    }\n\n    // Normalize and sanitize the content type\n    const normalizedContentType = contentType.toLowerCase().trim();\n    const normalizedExpectedType = expectedType.toLowerCase().trim();\n\n    // Validate Content-Type format (basic MIME type structure)\n    const mimeTypePattern = /^[a-z0-9][a-z0-9!#$&\\-\\^_]*\\/[a-z0-9][a-z0-9!#$&\\-\\^_]*(?:\\s*;.*)?$/;\n    if (!mimeTypePattern.test(normalizedContentType)) {\n      return { \n        isValid: false, \n        error: `Malformed Content-Type header: ${contentType}` \n      };\n    }\n\n    // Extract main MIME type (before any parameters like charset)\n    const mainType = normalizedContentType.split(';')[0].trim();\n    \n    // Security check: Block dangerous MIME types that could bypass validation\n    const dangerousMimeTypes = [\n      'text/html',           // Could contain XSS\n      'text/javascript',     // Could contain malicious scripts\n      'application/javascript', // Could contain malicious scripts\n      'text/xml',            // Could contain XXE attacks\n      'application/xml',     // Could contain XXE attacks\n      'image/svg+xml',       // Could contain XSS in SVG\n      'multipart/form-data', // Unexpected for API responses\n      'application/x-www-form-urlencoded' // Unexpected for API responses\n    ];\n\n    if (dangerousMimeTypes.includes(mainType)) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'CONTENT_INJECTION_ATTEMPT',\n        severity: 'HIGH',\n        source: 'persona_sharer',\n        details: `Dangerous Content-Type detected: ${contentType}`,\n        metadata: { contentType, expectedType }\n      });\n      return { \n        isValid: false, \n        error: `Dangerous Content-Type not allowed: ${mainType}` \n      };\n    }\n\n    // Check if the main type matches expected type\n    if (!mainType.includes(normalizedExpectedType)) {\n      return { \n        isValid: false, \n        error: `Content-Type mismatch: expected ${expectedType}, got ${mainType}` \n      };\n    }\n\n    // Additional validation for JSON responses\n    if (normalizedExpectedType === 'application/json') {\n      // Accept various JSON-compatible MIME types\n      const acceptableJsonTypes = [\n        'application/json',\n        'application/vnd.api+json',\n        'application/vnd.github.v3+json',\n        'text/json' // Some APIs use this (though not standard)\n      ];\n      \n      const isAcceptableJson = acceptableJsonTypes.some(type => mainType === type);\n      if (!isAcceptableJson) {\n        return { \n          isValid: false, \n          error: `Unsupported JSON Content-Type: ${mainType}` \n        };\n      }\n\n      // Validate charset parameter if present\n      const charsetMatch = normalizedContentType.match(/charset=([^;\\s]+)/);\n      if (charsetMatch) {\n        const charset = charsetMatch[1].toLowerCase();\n        const supportedCharsets = ['utf-8', 'utf8', 'ascii', 'iso-8859-1'];\n        if (!supportedCharsets.includes(charset)) {\n          return { \n            isValid: false, \n            error: `Unsupported charset: ${charset}` \n          };\n        }\n      }\n    }\n\n    // Log successful validation for monitoring\n    logger.debug('Content-Type validation passed', { \n      contentType: mainType, \n      expectedType: normalizedExpectedType \n    });\n\n    return { isValid: true };\n  }\n}"]}