@dollhousemcp/mcp-server/dist/persona/export-import/PersonaSharer.js

DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.

/**
 * 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 Err