@dollhousemcp/mcp-server 1.3.0

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

@@ -0,0 +1,363 @@
+/**
+ * Persona sharing functionality via URLs
+ */
+import { PersonaExporter } from './PersonaExporter.js';
+import { TokenManager } from '../../security/tokenManager.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();
+            if (token) {
+                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
+                }
+            }
+            // 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 (token) {
+                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(`Failed to fetch: ${response.statusText}`);
+                }
+                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) {
+                    const errorMsg = `GitHub API error: ${response.status} ${response.statusText}`;
+                    throw new Error(errorMsg);
+                }
+                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.statusText}`);
+                }
+                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 {
+            const parsed = new URL(url);
+            // Only allow http/https protocols
+            if (!['https:', 'http:'].includes(parsed.protocol)) {
+                return false;
+            }
+            // Prevent SSRF attacks - block local/private networks
+            const hostname = parsed.hostname.toLowerCase();
+            if (hostname === 'localhost' ||
+                hostname.startsWith('127.') ||
+                hostname.startsWith('10.') ||
+                hostname.startsWith('192.168.') ||
+                hostname.startsWith('172.') ||
+                hostname.startsWith('169.254.') ||
+                hostname === '0.0.0.0' ||
+                hostname.includes(':')) { // IPv6 localhost
+                return false;
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Import from base64 URL
+     */
+    importFromBase64Url(url) {
+        try {
+            const match = url.match(/#dollhouse-persona=([A-Za-z0-9+/=]+)$/);
+            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 '../../marketplace/GitHubClient.js';\nimport { TokenManager } from '../../security/tokenManager.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      if (token) {\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        }\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 (token) {\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(`Failed to fetch: ${response.statusText}`);\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          const errorMsg = `GitHub API error: ${response.status} ${response.statusText}`;\n          throw new Error(errorMsg);\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.statusText}`);\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      const parsed = new URL(url);\n      \n      // Only allow http/https protocols\n      if (!['https:', 'http:'].includes(parsed.protocol)) {\n        return false;\n      }\n      \n      // Prevent SSRF attacks - block local/private networks\n      const hostname = parsed.hostname.toLowerCase();\n      if (hostname === 'localhost' || \n          hostname.startsWith('127.') ||\n          hostname.startsWith('10.') ||\n          hostname.startsWith('192.168.') ||\n          hostname.startsWith('172.') ||\n          hostname.startsWith('169.254.') ||\n          hostname === '0.0.0.0' ||\n          hostname.includes(':')) { // IPv6 localhost\n        return false;\n      }\n      \n      return true;\n    } catch {\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      const match = url.match(/#dollhouse-persona=([A-Za-z0-9+/=]+)$/);\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/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/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/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcGVyc29uYS9leHBvcnQtaW1wb3J0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN2RCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4cG9ydCBhbGwgZXhwb3J0L2ltcG9ydC9zaGFyaW5nIG1vZHVsZXNcbiAqL1xuXG5leHBvcnQgeyBQZXJzb25hRXhwb3J0ZXIgfSBmcm9tICcuL1BlcnNvbmFFeHBvcnRlci5qcyc7XG5leHBvcnQgeyBQZXJzb25hSW1wb3J0ZXIgfSBmcm9tICcuL1BlcnNvbmFJbXBvcnRlci5qcyc7XG5leHBvcnQgeyBQZXJzb25hU2hhcmVyIH0gZnJvbSAnLi9QZXJzb25hU2hhcmVyLmpzJztcblxuZXhwb3J0IHR5cGUgeyBFeHBvcnRlZFBlcnNvbmEsIEV4cG9ydEJ1bmRsZSB9IGZyb20gJy4vUGVyc29uYUV4cG9ydGVyLmpzJztcbmV4cG9ydCB0eXBlIHsgSW1wb3J0UmVzdWx0IH0gZnJvbSAnLi9QZXJzb25hSW1wb3J0ZXIuanMnO1xuZXhwb3J0IHR5cGUgeyBTaGFyZVJlc3VsdCB9IGZyb20gJy4vUGVyc29uYVNoYXJlci5qcyc7Il19

package/dist/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/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/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcGVyc29uYS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBQZXJzb25hIG1vZHVsZSBleHBvcnRzXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9QZXJzb25hTWFuYWdlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL1BlcnNvbmFMb2FkZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9QZXJzb25hVmFsaWRhdG9yLmpzJzsiXX0=

package/dist/src/security/InputValidator.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Input validation and sanitization functions
+ */
+/**
+ * Enhanced input validation for MCP tools
+ */
+export declare class MCPInputValidator {
+    /**
+     * Validate a persona identifier (name or filename)
+     */
+    static validatePersonaIdentifier(identifier: string): string;
+    /**
+     * Validate search query for marketplace
+     */
+    static validateSearchQuery(query: string): string;
+    /**
+     * Validate marketplace path
+     */
+    static validateMarketplacePath(path: string): string;
+    /**
+     * Validate URL for import operations
+     */
+    static validateImportUrl(url: string): string;
+    /**
+     * Validate expiry days for sharing
+     */
+    static validateExpiryDays(days: number): number;
+    /**
+     * Validate boolean confirmation parameters
+     */
+    static validateConfirmation(confirm: boolean, operationName: string): boolean;
+    /**
+     * Validate field name for edit operations
+     */
+    static validateEditField(field: string): string;
+    /**
+     * Check if hostname is a private IP address (IPv4 and IPv6)
+     */
+    private static isPrivateIP;
+    /**
+     * Check for encoded private IP addresses that could bypass basic detection
+     */
+    private static isEncodedPrivateIP;
+}
+/**
+ * Validate and sanitize a filename
+ */
+export declare function validateFilename(filename: string): string;
+/**
+ * Validate and sanitize a path
+ */
+export declare function validatePath(inputPath: string, baseDir?: string): string;
+/**
+ * Validate and sanitize a username
+ */
+export declare function validateUsername(username: string): string;
+/**
+ * Validate a category
+ */
+export declare function validateCategory(category: string): string;
+/**
+ * Validate content size
+ */
+export declare function validateContentSize(content: string, maxSize?: number): void;
+/**
+ * General input sanitization
+ */
+export declare function sanitizeInput(input: string, maxLength?: number): string;
+//# sourceMappingURL=InputValidator.d.ts.map

package/dist/src/security/InputValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputValidator.d.ts","sourceRoot":"","sources":["../../../src/security/InputValidator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH;;GAEG;AACH,qBAAa,iBAAiB;IAC5B;;OAEG;IACH,MAAM,CAAC,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAkB5D;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IA4BjD;;OAEG;IACH,MAAM,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAgDpD;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IA8D7C;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAgB/C;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO;IAY7E;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAkB/C;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,WAAW;IAgD1B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;CA+BlC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAiBzD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAwCxE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAUzD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAgBzD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAA2C,GAAG,IAAI,CAS/G;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,GAAE,MAAa,GAAG,MAAM,CAa7E"}