@dollhousemcp/mcp-server 1.3.0

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

@@ -0,0 +1,502 @@
+/**
+ * Persona sharing functionality via URLs
+ */
+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';
+export class PersonaSharer {
+    githubClient;
+    currentUser;
+    exporter;
+    githubRateLimiter;
+    constructor(githubClient, currentUser) {
+        this.githubClient = githubClient;
+        this.currentUser = currentUser;
+        this.exporter = new PersonaExporter(currentUser);
+        // GitHub API rate limit: 60 requests per hour for unauthenticated
+        // 5000 per hour for authenticated - use TokenManager to check
+        const hasValidToken = TokenManager.getGitHubToken() !== null;
+        this.githubRateLimiter = new RateLimiter({
+            maxRequests: hasValidToken ? 100 : 30, // Conservative limits
+            windowMs: 60 * 60 * 1000, // 1 hour
+            minDelayMs: 1000 // Minimum 1 second between requests
+        });
+    }
+    /**
+     * Share a persona via GitHub Gist
+     */
+    async sharePersona(persona, expiryDays = 7) {
+        try {
+            // Validate gist permissions if token is available
+            const token = TokenManager.getGitHubToken();
+            let hasValidToken = false;
+            if (token) {
+                try {
+                    const validation = await TokenManager.ensureTokenPermissions('gist');
+                    if (!validation.isValid) {
+                        const safeMessage = TokenManager.createSafeErrorMessage(validation.error || 'Unknown validation error', token);
+                        logger.warn('GitHub token lacks gist permissions, falling back to base64 URL', { error: safeMessage });
+                        // Continue to fallback instead of failing
+                    }
+                    else {
+                        hasValidToken = true;
+                    }
+                }
+                catch (error) {
+                    // Handle rate limiting or other security errors gracefully
+                    if (error instanceof SecurityError && error.code === 'RATE_LIMIT_EXCEEDED') {
+                        logger.warn('Token validation rate limited, falling back to base64 URL', {
+                            error: 'Rate limit exceeded for token validation'
+                        });
+                    }
+                    else if (error instanceof Error) {
+                        const safeMessage = TokenManager.createSafeErrorMessage(error.message, token);
+                        logger.warn('Token validation failed, falling back to base64 URL', { error: safeMessage });
+                    }
+                    // Continue to fallback instead of failing
+                }
+            }
+            // Export persona to structured format
+            const exportData = this.exporter.exportPersona(persona);
+            // Add sharing metadata
+            const shareData = {
+                ...exportData,
+                sharedAt: new Date().toISOString(),
+                sharedBy: this.currentUser || 'anonymous',
+                expiresAt: new Date(Date.now() + expiryDays * 24 * 60 * 60 * 1000).toISOString(),
+                shareVersion: '1.0.0'
+            };
+            // Create GitHub Gist if token has proper permissions
+            if (hasValidToken) {
+                const gistResult = await this.createGist(persona.metadata.name, shareData);
+                if (gistResult.success) {
+                    return {
+                        success: true,
+                        url: gistResult.url,
+                        gistId: gistResult.gistId,
+                        expiresAt: shareData.expiresAt,
+                        message: this.formatShareSuccess(gistResult.url, shareData.expiresAt)
+                    };
+                }
+            }
+            // Fallback to base64 URL if Gist fails or no token
+            return this.createBase64Url(shareData);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const safeMessage = TokenManager.createSafeErrorMessage(errorMessage);
+            logger.error('Share error', { error: safeMessage });
+            return {
+                success: false,
+                message: `Failed to share persona: ${safeMessage}`
+            };
+        }
+    }
+    /**
+     * Import a persona from a share URL
+     */
+    async importFromUrl(url) {
+        try {
+            // Validate URL first
+            if (!this.validateShareUrl(url)) {
+                return {
+                    success: false,
+                    message: 'Invalid or unsafe URL provided'
+                };
+            }
+            // Check if it's a GitHub Gist URL
+            const gistId = this.extractGistId(url);
+            if (gistId) {
+                return await this.importFromGist(gistId);
+            }
+            // Check if it's a base64 URL
+            if (url.includes('#dollhouse-persona=')) {
+                return this.importFromBase64Url(url);
+            }
+            // Validate URL for security
+            if (!this.validateShareUrl(url)) {
+                throw new Error('Invalid or potentially malicious URL');
+            }
+            // Try direct fetch with timeout
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 5000); // 5 second timeout
+            try {
+                const response = await fetch(url, {
+                    signal: controller.signal,
+                    headers: {
+                        'User-Agent': 'DollhouseMCP/1.0',
+                        'Accept': 'application/json'
+                    }
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    throw new Error(`Request failed with status ${response.status}`);
+                }
+                // Validate Content-Type header
+                const contentType = response.headers.get('content-type');
+                if (!contentType || !contentType.toLowerCase().includes('application/json')) {
+                    throw new Error('Invalid response type: expected JSON');
+                }
+                // 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');
+                }
+                const data = await response.json();
+                return {
+                    success: true,
+                    data,
+                    message: 'Successfully retrieved persona data'
+                };
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        }
+        catch (error) {
+            logger.error('Import from URL error', error);
+            return {
+                success: false,
+                message: `Failed to import from URL: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Create a GitHub Gist
+     */
+    async createGist(personaName, data) {
+        try {
+            // Use TokenManager for secure token handling
+            const token = TokenManager.getGitHubToken();
+            if (!token) {
+                logger.info('No valid GitHub token available for Gist creation');
+                return { success: false };
+            }
+            // Check rate limit
+            const rateLimitStatus = this.githubRateLimiter.checkLimit();
+            if (!rateLimitStatus.allowed) {
+                logger.warn(`GitHub API rate limit exceeded. Retry after ${rateLimitStatus.retryAfterMs}ms`);
+                return { success: false };
+            }
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
+            try {
+                const response = await fetch('https://api.github.com/gists', {
+                    method: 'POST',
+                    signal: controller.signal,
+                    headers: {
+                        'Authorization': `Bearer ${token}`,
+                        'Accept': 'application/vnd.github.v3+json',
+                        'Content-Type': 'application/json',
+                        'User-Agent': 'DollhouseMCP/1.0'
+                    },
+                    body: JSON.stringify({
+                        description: `DollhouseMCP Persona: ${personaName}`,
+                        public: false, // Private gist for security
+                        files: {
+                            'persona.json': {
+                                content: JSON.stringify(data, null, 2)
+                            }
+                        }
+                    })
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    throw new Error(`GitHub API error: ${response.status}`);
+                }
+                // Validate Content-Type for GitHub API response
+                const contentType = response.headers.get('content-type');
+                if (!contentType || !contentType.toLowerCase().includes('application/json')) {
+                    throw new Error('Invalid GitHub API response type');
+                }
+                const gist = await response.json();
+                // Consume the rate limit token after successful request
+                this.githubRateLimiter.consumeToken();
+                return {
+                    success: true,
+                    url: gist.html_url,
+                    gistId: gist.id
+                };
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const safeMessage = TokenManager.createSafeErrorMessage(errorMessage);
+            logger.error('Gist creation error', { error: safeMessage });
+            return { success: false };
+        }
+    }
+    /**
+     * Create a base64 URL (fallback)
+     */
+    createBase64Url(data) {
+        const base64 = this.exporter.toBase64(data);
+        const url = `https://dollhousemcp.com/import#dollhouse-persona=${base64}`;
+        return {
+            success: true,
+            url,
+            expiresAt: data.expiresAt,
+            message: this.formatShareSuccess(url, data.expiresAt)
+        };
+    }
+    /**
+     * Import from GitHub Gist
+     */
+    async importFromGist(gistId) {
+        try {
+            // 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`);
+            }
+            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');
+            }
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout for API
+            try {
+                const response = await fetch(gistUrl, {
+                    signal: controller.signal,
+                    headers: {
+                        'Accept': 'application/vnd.github.v3+json',
+                        'User-Agent': 'DollhouseMCP/1.0'
+                    }
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch gist: ${response.status}`);
+                }
+                // Validate Content-Type for GitHub API response
+                const contentType = response.headers.get('content-type');
+                if (!contentType || !contentType.toLowerCase().includes('application/json')) {
+                    throw new Error('Invalid GitHub API response type');
+                }
+                const gist = await response.json();
+                const personaFile = gist.files['persona.json'];
+                if (!personaFile) {
+                    throw new Error('No persona data found in gist');
+                }
+                const data = JSON.parse(personaFile.content);
+                // Check expiry
+                if (data.expiresAt && new Date(data.expiresAt) < new Date()) {
+                    return {
+                        success: false,
+                        message: 'This share link has expired'
+                    };
+                }
+                // Consume the rate limit token after successful request
+                this.githubRateLimiter.consumeToken();
+                return {
+                    success: true,
+                    data,
+                    message: 'Successfully retrieved persona from GitHub'
+                };
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        }
+        catch (error) {
+            logger.error('Gist import error', error);
+            return {
+                success: false,
+                message: `Failed to import from gist: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Validate URL for security (prevent SSRF attacks)
+     */
+    validateShareUrl(url) {
+        try {
+            // 1. URL length check to prevent DoS
+            if (url.length > 2048) {
+                logger.warn('URL exceeds maximum length', { urlLength: url.length });
+                return false;
+            }
+            const parsed = new URL(url);
+            // 2. Protocol check - only allow http/https
+            if (!['https:', 'http:'].includes(parsed.protocol)) {
+                logger.warn('Invalid protocol in URL', { protocol: parsed.protocol });
+                return false;
+            }
+            // 3. Port restrictions - block non-standard ports that could be internal services
+            const port = parsed.port || (parsed.protocol === 'https:' ? '443' : '80');
+            const allowedPorts = ['80', '443', '8080', '8443'];
+            if (!allowedPorts.includes(port)) {
+                logger.warn('Blocked non-standard port', { port });
+                return false;
+            }
+            // 4. Hostname validation
+            const hostname = parsed.hostname.toLowerCase();
+            // Block various localhost representations
+            const blockedHostnames = [
+                'localhost',
+                'localhost.localdomain',
+                '0.0.0.0',
+                '0',
+                '0x0',
+                '0x00000000',
+                '[::1]',
+                '[::ffff:127.0.0.1]',
+                '[0000:0000:0000:0000:0000:0000:0000:0001]'
+            ];
+            if (blockedHostnames.includes(hostname)) {
+                logger.warn('Blocked localhost hostname', { hostname });
+                return false;
+            }
+            // Block private IP ranges with comprehensive patterns
+            const privateIpPatterns = [
+                /^127\./, // Loopback
+                /^10\./, // Private class A
+                /^192\.168\./, // Private class C
+                /^172\.(1[6-9]|2[0-9]|3[0-1])\./, // Private class B
+                /^169\.254\./, // Link-local
+                /^fc00:/i, // IPv6 private
+                /^fe80:/i, // IPv6 link-local
+                /^::1$/, // IPv6 loopback
+                /^::ffff:0?:?0?:?0?:?0?$/i, // IPv6 mapped IPv4
+                /^100\.6[4-9]\./, // Carrier-grade NAT
+                /^100\.[7-9][0-9]\./, // Carrier-grade NAT
+                /^100\.1[0-2][0-9]\./, // Carrier-grade NAT
+                /^0\./, // Reserved
+                /^255\.255\.255\.255$/ // Broadcast
+            ];
+            if (privateIpPatterns.some(pattern => pattern.test(hostname))) {
+                logger.warn('Blocked private IP range', { hostname });
+                return false;
+            }
+            // Block cloud metadata endpoints
+            const metadataEndpoints = [
+                '169.254.169.254', // AWS/GCP/Azure
+                'metadata.google.internal',
+                'metadata.azure.com',
+                '100.100.100.200' // Alibaba Cloud
+            ];
+            if (metadataEndpoints.includes(hostname)) {
+                logger.warn('Blocked cloud metadata endpoint', { hostname });
+                return false;
+            }
+            // Block numeric IP representations that could bypass checks
+            if (/^\d+$/.test(hostname)) {
+                // Convert decimal to IP and check
+                const num = parseInt(hostname, 10);
+                if (num <= 0xFFFFFFFF) {
+                    const ip = `${(num >>> 24) & 0xFF}.${(num >>> 16) & 0xFF}.${(num >>> 8) & 0xFF}.${num & 0xFF}`;
+                    logger.warn('Blocked numeric IP representation', { hostname, resolvedIp: ip });
+                    return false;
+                }
+            }
+            // Block hex IP representations
+            if (/^0x[0-9a-f]+$/i.test(hostname)) {
+                logger.warn('Blocked hex IP representation', { hostname });
+                return false;
+            }
+            // Validate domain format (basic check)
+            // Allow GitHub domains and common share platforms
+            const trustedDomains = [
+                'github.com',
+                'gist.github.com',
+                'api.github.com',
+                'raw.githubusercontent.com',
+                'dollhousemcp.com'
+            ];
+            // Check if it's a trusted domain
+            const isTrustedDomain = trustedDomains.some(domain => hostname === domain || hostname.endsWith(`.${domain}`));
+            if (!isTrustedDomain) {
+                // For non-trusted domains, apply stricter validation
+                // Must be a valid domain format, not just an IP
+                const domainPattern = /^([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,}$/i;
+                const ipv4Pattern = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+                const ipv6Pattern = /^\[?([0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}\]?$/i;
+                if (ipv4Pattern.test(hostname) || ipv6Pattern.test(hostname)) {
+                    logger.warn('Direct IP access not allowed for untrusted sources', { hostname });
+                    return false;
+                }
+                if (!domainPattern.test(hostname)) {
+                    logger.warn('Invalid domain format', { hostname });
+                    return false;
+                }
+            }
+            logger.debug('URL validation passed', {
+                hostname,
+                protocol: parsed.protocol,
+                isTrusted: isTrustedDomain
+            });
+            return true;
+        }
+        catch (error) {
+            logger.warn('URL validation error', { error: error instanceof Error ? error.message : 'Unknown error' });
+            return false;
+        }
+    }
+    /**
+     * Import from base64 URL
+     */
+    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');
+            }
+            const base64 = match[1];
+            const json = Buffer.from(base64, 'base64').toString('utf-8');
+            const data = JSON.parse(json);
+            // Check expiry
+            if (data.expiresAt && new Date(data.expiresAt) < new Date()) {
+                return {
+                    success: false,
+                    message: 'This share link has expired'
+                };
+            }
+            return {
+                success: true,
+                data,
+                message: 'Successfully decoded persona data'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to decode share URL: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Extract Gist ID from GitHub URL
+     */
+    extractGistId(url) {
+        const match = url.match(/gist\.github\.com\/[^\/]+\/([a-f0-9]+)/);
+        return match ? match[1] : null;
+    }
+    /**
+     * Format share success message
+     */
+    formatShareSuccess(url, expiresAt) {
+        const expiryDate = new Date(expiresAt);
+        const daysUntilExpiry = Math.ceil((expiryDate.getTime() - Date.now()) / (24 * 60 * 60 * 1000));
+        return `✅ Successfully created share link!
+
+🔗 Share URL:
+${url}
+
+⏱️ Expires: ${expiryDate.toLocaleDateString()} (${daysUntilExpiry} days)
+
+📋 To share this persona:
+1. Copy the URL above
+2. Share it with others
+3. They can import using: import_from_url "${url}"
+
+🔒 Privacy: This link is private and will expire automatically.`;
+    }
+}
+//# 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}"]}

package/dist/test/src/persona/export-import/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Export all export/import/sharing modules
+ */
+export { PersonaExporter } from './PersonaExporter.js';
+export { PersonaImporter } from './PersonaImporter.js';
+export { PersonaSharer } from './PersonaSharer.js';
+export type { ExportedPersona, ExportBundle } from './PersonaExporter.js';
+export type { ImportResult } from './PersonaImporter.js';
+export type { ShareResult } from './PersonaSharer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/test/src/persona/export-import/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/persona/export-import/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAC1E,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/test/src/persona/export-import/index.js

@@ -0,0 +1,7 @@
+/**
+ * Export all export/import/sharing modules
+ */
+export { PersonaExporter } from './PersonaExporter.js';
+export { PersonaImporter } from './PersonaImporter.js';
+export { PersonaSharer } from './PersonaSharer.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcGVyc29uYS9leHBvcnQtaW1wb3J0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN2RCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4cG9ydCBhbGwgZXhwb3J0L2ltcG9ydC9zaGFyaW5nIG1vZHVsZXNcbiAqL1xuXG5leHBvcnQgeyBQZXJzb25hRXhwb3J0ZXIgfSBmcm9tICcuL1BlcnNvbmFFeHBvcnRlci5qcyc7XG5leHBvcnQgeyBQZXJzb25hSW1wb3J0ZXIgfSBmcm9tICcuL1BlcnNvbmFJbXBvcnRlci5qcyc7XG5leHBvcnQgeyBQZXJzb25hU2hhcmVyIH0gZnJvbSAnLi9QZXJzb25hU2hhcmVyLmpzJztcblxuZXhwb3J0IHR5cGUgeyBFeHBvcnRlZFBlcnNvbmEsIEV4cG9ydEJ1bmRsZSB9IGZyb20gJy4vUGVyc29uYUV4cG9ydGVyLmpzJztcbmV4cG9ydCB0eXBlIHsgSW1wb3J0UmVzdWx0IH0gZnJvbSAnLi9QZXJzb25hSW1wb3J0ZXIuanMnO1xuZXhwb3J0IHR5cGUgeyBTaGFyZVJlc3VsdCB9IGZyb20gJy4vUGVyc29uYVNoYXJlci5qcyc7Il19

package/dist/test/src/persona/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Persona module exports
+ */
+export * from './PersonaManager.js';
+export * from './PersonaLoader.js';
+export * from './PersonaValidator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/test/src/persona/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/persona/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC"}

package/dist/test/src/persona/index.js

@@ -0,0 +1,7 @@
+/**
+ * Persona module exports
+ */
+export * from './PersonaManager.js';
+export * from './PersonaLoader.js';
+export * from './PersonaValidator.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcGVyc29uYS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBQZXJzb25hIG1vZHVsZSBleHBvcnRzXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9QZXJzb25hTWFuYWdlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL1BlcnNvbmFMb2FkZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9QZXJzb25hVmFsaWRhdG9yLmpzJzsiXX0=