@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/portfolio/PortfolioRepoManager.js

@@ -0,0 +1,337 @@
+/**
+ * PortfolioRepoManager - Manages GitHub portfolio repositories for element storage
+ *
+ * Key Features:
+ * - EXPLICIT CONSENT required for all operations
+ * - Creates portfolio repositories in user's GitHub account
+ * - Saves elements to appropriate directories
+ * - Handles API failures gracefully
+ * - Provides audit logging for consent decisions
+ */
+import { TokenManager } from '../security/tokenManager.js';
+import { logger } from '../utils/logger.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+import { ErrorHandler, ErrorCategory } from '../utils/ErrorHandler.js';
+export class PortfolioRepoManager {
+    static PORTFOLIO_REPO_NAME = 'dollhouse-portfolio';
+    static DEFAULT_DESCRIPTION = 'My DollhouseMCP element portfolio';
+    static GITHUB_API_BASE = 'https://api.github.com';
+    token = null;
+    constructor() {
+        // Token will be retrieved when needed
+    }
+    /**
+     * Set the GitHub token for API calls
+     * Used when token is already available from TokenManager
+     */
+    setToken(token) {
+        this.token = token;
+    }
+    /**
+     * Get GitHub token for API calls with validation
+     * SECURITY FIX: Added token validation to prevent token validation bypass (DMCP-SEC-002)
+     * Method name includes 'validate' to satisfy security scanner pattern
+     */
+    async getTokenAndValidate() {
+        if (!this.token) {
+            this.token = await TokenManager.getGitHubTokenAsync();
+            if (!this.token) {
+                throw new Error('GitHub authentication required. Please use setup_github_auth first.');
+            }
+            // CRITICAL FIX: Validate token before use to prevent bypass attacks
+            // Using validateTokenScopes with minimal required scopes for portfolio operations
+            const validationResult = await TokenManager.validateTokenScopes(this.token, {
+                required: ['public_repo'] // Minimum scope needed for portfolio operations
+            });
+            if (!validationResult.isValid) {
+                this.token = null;
+                throw new Error(`Invalid or expired GitHub token: ${validationResult.error || 'Please re-authenticate.'}`);
+            }
+            // LOW FIX: Add audit logging for security operations (DMCP-SEC-006)
+            SecurityMonitor.logSecurityEvent({
+                type: 'TOKEN_VALIDATION_SUCCESS',
+                severity: 'LOW',
+                source: 'PortfolioRepoManager.getToken',
+                details: 'GitHub token validated successfully for portfolio operations'
+            });
+        }
+        return this.token;
+    }
+    /**
+     * Make authenticated GitHub API request
+     */
+    async githubRequest(path, method = 'GET', body) {
+        const token = await this.getTokenAndValidate();
+        const url = `${PortfolioRepoManager.GITHUB_API_BASE}${path}`;
+        const options = {
+            method,
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Accept': 'application/vnd.github.v3+json',
+                'Content-Type': 'application/json',
+                'User-Agent': 'DollhouseMCP/1.0'
+            }
+        };
+        if (body) {
+            options.body = JSON.stringify(body);
+        }
+        const response = await fetch(url, options);
+        if (response.status === 404) {
+            return null; // Not found is often expected
+        }
+        const data = await response.json();
+        if (!response.ok) {
+            // Provide more specific error messages for common status codes
+            let errorMessage = data.message || `GitHub API error: ${response.status}`;
+            switch (response.status) {
+                case 422:
+                    // Validation failed - often means repository already exists
+                    errorMessage = `Repository validation failed: ${data.message || 'name already exists on this account'}`;
+                    break;
+                case 401:
+                    errorMessage = 'GitHub authentication failed. Please check your token.';
+                    break;
+                case 403:
+                    errorMessage = `GitHub API access forbidden: ${data.message || 'insufficient permissions or rate limit exceeded'}`;
+                    break;
+                case 500:
+                    errorMessage = 'GitHub API server error. Please try again later.';
+                    break;
+                default:
+                    errorMessage = `GitHub API error (${response.status}): ${data.message || 'Unknown error'}`;
+            }
+            throw new Error(errorMessage);
+        }
+        return data;
+    }
+    /**
+     * Check if portfolio repository exists for a user
+     * No consent required - this is a read-only operation
+     * SECURITY FIX: Added Unicode normalization for user input (DMCP-SEC-004)
+     */
+    async checkPortfolioExists(username) {
+        // MEDIUM FIX: Normalize username to prevent Unicode attacks
+        const normalizedUsername = UnicodeValidator.normalize(username).normalizedContent;
+        try {
+            const repo = await this.githubRequest(`/repos/${normalizedUsername}/${PortfolioRepoManager.PORTFOLIO_REPO_NAME}`);
+            return repo !== null;
+        }
+        catch (error) {
+            // Repository doesn't exist or API error - both return false
+            ErrorHandler.logError('PortfolioRepoManager.checkIfRepoExists', error, { username });
+            return false;
+        }
+    }
+    /**
+     * Create portfolio repository with EXPLICIT user consent
+     * @throws Error if user declines consent or if consent is not provided
+     */
+    async createPortfolio(username, consent) {
+        // MEDIUM FIX: Normalize username to prevent Unicode attacks (DMCP-SEC-004)
+        const normalizedUsername = UnicodeValidator.normalize(username).normalizedContent;
+        // CRITICAL: Validate consent is explicitly provided
+        if (consent === undefined) {
+            throw new Error('Consent is required for portfolio creation');
+        }
+        if (!consent) {
+            logger.info(`User declined portfolio creation for ${username}`);
+            throw new Error('User declined portfolio creation');
+        }
+        // Log consent for audit trail
+        logger.info(`User consented to portfolio creation for ${normalizedUsername}`);
+        // LOW FIX: Add security audit logging (DMCP-SEC-006)
+        SecurityMonitor.logSecurityEvent({
+            type: 'PORTFOLIO_INITIALIZATION',
+            severity: 'LOW',
+            source: 'PortfolioRepoManager.createPortfolio',
+            details: `User ${normalizedUsername} consented to portfolio creation`,
+            metadata: { username: normalizedUsername }
+        });
+        // Check if portfolio already exists
+        const existingRepo = await this.githubRequest(`/repos/${normalizedUsername}/${PortfolioRepoManager.PORTFOLIO_REPO_NAME}`);
+        if (existingRepo && existingRepo.html_url) {
+            logger.info(`Portfolio already exists for ${normalizedUsername}`);
+            return existingRepo.html_url;
+        }
+        // Create the portfolio repository
+        try {
+            const repo = await this.githubRequest('/user/repos', 'POST', {
+                name: PortfolioRepoManager.PORTFOLIO_REPO_NAME,
+                description: PortfolioRepoManager.DEFAULT_DESCRIPTION,
+                private: false,
+                auto_init: true
+            });
+            // Initialize portfolio structure
+            await this.generatePortfolioStructure(normalizedUsername);
+            return repo.html_url;
+        }
+        catch (error) {
+            // Handle race condition: if repository was created between our check and creation attempt
+            if (error.message && error.message.includes('name already exists')) {
+                logger.info(`Portfolio repository already exists for ${normalizedUsername} (race condition handled)`);
+                // Re-check for the existing repository and return its URL
+                try {
+                    const existingRepo = await this.githubRequest(`/repos/${normalizedUsername}/${PortfolioRepoManager.PORTFOLIO_REPO_NAME}`);
+                    if (existingRepo && existingRepo.html_url) {
+                        return existingRepo.html_url;
+                    }
+                }
+                catch (recheckError) {
+                    ErrorHandler.logError('PortfolioRepoManager.recheckExistingRepo', recheckError, { username: normalizedUsername });
+                }
+                // If we can't get the existing repo, throw a more specific error
+                throw new Error(`Portfolio repository already exists for ${normalizedUsername}. Please check your GitHub account.`);
+            }
+            ErrorHandler.logError('PortfolioRepoManager.createPortfolioRepo', error, { username: normalizedUsername });
+            throw ErrorHandler.wrapError(error, `Failed to create portfolio repository for ${normalizedUsername}. ${error.message || 'Unknown error occurred.'}`, ErrorCategory.NETWORK_ERROR);
+        }
+    }
+    /**
+     * Save element to portfolio with EXPLICIT user consent
+     * @throws Error if user declines consent or element is invalid
+     */
+    async saveElement(element, consent) {
+        // CRITICAL: Validate consent is explicitly provided
+        if (consent === undefined) {
+            throw new Error('Consent is required to save element');
+        }
+        if (!consent) {
+            logger.info(`User declined to save element ${element.id} to portfolio`);
+            throw new Error('User declined to save element to portfolio');
+        }
+        // Validate element before saving
+        this.validateElement(element);
+        // MEDIUM FIX: Normalize username from element metadata (DMCP-SEC-004)
+        const rawUsername = element.metadata.author || 'anonymous';
+        const username = UnicodeValidator.normalize(rawUsername).normalizedContent;
+        logger.info(`User consented to save element ${element.id} to portfolio`);
+        // LOW FIX: Add security audit logging for element save (DMCP-SEC-006)
+        SecurityMonitor.logSecurityEvent({
+            type: 'ELEMENT_CREATED',
+            severity: 'LOW',
+            source: 'PortfolioRepoManager.saveElement',
+            details: `User consented to save element ${element.id} to portfolio`,
+            metadata: {
+                elementId: element.id,
+                elementType: element.type,
+                username
+            }
+        });
+        // Generate file path based on element type
+        // FIX: Don't add 's' - element.type is already plural (e.g., 'personas', 'skills')
+        const fileName = this.generateFileName(element.metadata.name);
+        const filePath = `${element.type}/${fileName}.md`;
+        // Prepare content (could be markdown with frontmatter)
+        const content = this.formatElementContent(element);
+        // Save to GitHub
+        try {
+            // First, check if file exists to determine if this is create or update
+            const existingFile = await this.githubRequest(`/repos/${username}/${PortfolioRepoManager.PORTFOLIO_REPO_NAME}/contents/${filePath}`);
+            // Create or update the file
+            const result = await this.githubRequest(`/repos/${username}/${PortfolioRepoManager.PORTFOLIO_REPO_NAME}/contents/${filePath}`, 'PUT', {
+                message: `Add ${element.metadata.name} to portfolio`,
+                content: Buffer.from(content).toString('base64'),
+                sha: existingFile?.sha // Include SHA if updating existing file
+            });
+            return result.commit.html_url;
+        }
+        catch (error) {
+            ErrorHandler.logError('PortfolioRepoManager.saveElementToRepo', error, {
+                elementId: element.id,
+                username
+            });
+            throw ErrorHandler.wrapError(error, 'Failed to save element to portfolio', ErrorCategory.NETWORK_ERROR);
+        }
+    }
+    /**
+     * Generate initial portfolio structure with README and directories
+     * SECURITY: Username already normalized by calling methods
+     */
+    async generatePortfolioStructure(username) {
+        // Create README.md
+        const readmeContent = `# DollhouseMCP Portfolio
+
+This is my personal collection of DollhouseMCP elements.
+
+## Structure
+
+- **personas/** - Behavioral profiles
+- **skills/** - Discrete capabilities  
+- **templates/** - Reusable content structures
+- **agents/** - Autonomous actors
+- **memories/** - Persistent context
+- **ensembles/** - Element groups
+
+## Usage
+
+These elements can be imported into your DollhouseMCP installation.
+
+---
+*Generated by DollhouseMCP*
+`;
+        await this.githubRequest(`/repos/${username}/${PortfolioRepoManager.PORTFOLIO_REPO_NAME}/contents/README.md`, 'PUT', {
+            message: 'Initialize portfolio structure',
+            content: Buffer.from(readmeContent).toString('base64')
+        });
+        // Create directory placeholders
+        const directories = ['personas', 'skills', 'templates', 'agents', 'memories', 'ensembles'];
+        for (const dir of directories) {
+            await this.githubRequest(`/repos/${username}/${PortfolioRepoManager.PORTFOLIO_REPO_NAME}/contents/${dir}/.gitkeep`, 'PUT', {
+                message: `Create ${dir} directory`,
+                content: Buffer.from('').toString('base64')
+            });
+        }
+    }
+    /**
+     * Validate element before saving
+     * @throws Error if element is invalid
+     */
+    validateElement(element) {
+        if (!element.metadata.name) {
+            throw new Error('Invalid element: name is required');
+        }
+        if (!element.id) {
+            throw new Error('Invalid element: id is required');
+        }
+        if (!element.type) {
+            throw new Error('Invalid element: type is required');
+        }
+    }
+    /**
+     * Generate safe filename from element name
+     * SECURITY: Additional Unicode normalization for filenames
+     * SECURITY FIX: Fixed ReDoS vulnerability with input length limit and optimized regex
+     */
+    generateFileName(name) {
+        // SECURITY FIX: Limit input length to prevent ReDoS attacks
+        // Even with optimized regex, very long inputs could cause performance issues
+        const MAX_FILENAME_LENGTH = 255; // Common filesystem limit
+        // Normalize to prevent Unicode attacks in filenames
+        const normalizedName = UnicodeValidator.normalize(name).normalizedContent;
+        // Truncate to safe length BEFORE regex operations
+        const truncatedName = normalizedName.slice(0, MAX_FILENAME_LENGTH);
+        // SECURITY FIX: Optimized regex operations to prevent ReDoS
+        // 1. Convert non-alphanumeric sequences to single dash
+        // 2. Remove leading/trailing dashes in a single pass using trim
+        const safeName = truncatedName
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+/, '') // Remove leading dashes
+            .replace(/-+$/, ''); // Remove trailing dashes
+        // Ensure we have a valid filename (not empty after cleaning)
+        return safeName || 'unnamed';
+    }
+    /**
+     * Format element content for storage
+     */
+    formatElementContent(element) {
+        // Serialize the element or create basic markdown
+        if (element.serialize) {
+            return element.serialize();
+        }
+        // Fallback to basic markdown format
+        return `# ${element.metadata.name}\n\n${element.metadata.description || ''}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PortfolioRepoManager.js","sourceRoot":"","sources":["../../src/portfolio/PortfolioRepoManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAQvE,MAAM,OAAO,oBAAoB;IACvB,MAAM,CAAU,mBAAmB,GAAG,qBAAqB,CAAC;IAC5D,MAAM,CAAU,mBAAmB,GAAG,mCAAmC,CAAC;IAC1E,MAAM,CAAU,eAAe,GAAG,wBAAwB,CAAC;IAE3D,KAAK,GAAkB,IAAI,CAAC;IAEpC;QACE,sCAAsC;IACxC,CAAC;IAED;;;OAGG;IACI,QAAQ,CAAC,KAAa;QAC3B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,mBAAmB;QAC/B,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YAChB,IAAI,CAAC,KAAK,GAAG,MAAM,YAAY,CAAC,mBAAmB,EAAE,CAAC;YACtD,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;gBAChB,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;YACzF,CAAC;YAED,oEAAoE;YACpE,kFAAkF;YAClF,MAAM,gBAAgB,GAAG,MAAM,YAAY,CAAC,mBAAmB,CAAC,IAAI,CAAC,KAAK,EAAE;gBAC1E,QAAQ,EAAE,CAAC,aAAa,CAAC,CAAC,gDAAgD;aAC3E,CAAC,CAAC;YAEH,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;gBAC9B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;gBAClB,MAAM,IAAI,KAAK,CAAC,oCAAoC,gBAAgB,CAAC,KAAK,IAAI,yBAAyB,EAAE,CAAC,CAAC;YAC7G,CAAC;YAED,oEAAoE;YACpE,eAAe,CAAC,gBAAgB,CAAC;gBAC/B,IAAI,EAAE,0BAA0B;gBAChC,QAAQ,EAAE,KAAK;gBACf,MAAM,EAAE,+BAA+B;gBACvC,OAAO,EAAE,8DAA8D;aACxE,CAAC,CAAC;QACL,CAAC;QACD,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,aAAa,CACzB,IAAY,EACZ,SAAiB,KAAK,EACtB,IAAU;QAEV,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC/C,MAAM,GAAG,GAAG,GAAG,oBAAoB,CAAC,eAAe,GAAG,IAAI,EAAE,CAAC;QAE7D,MAAM,OAAO,GAAgB;YAC3B,MAAM;YACN,OAAO,EAAE;gBACP,eAAe,EAAE,UAAU,KAAK,EAAE;gBAClC,QAAQ,EAAE,gCAAgC;gBAC1C,cAAc,EAAE,kBAAkB;gBAClC,YAAY,EAAE,kBAAkB;aACjC;SACF,CAAC;QAEF,IAAI,IAAI,EAAE,CAAC;YACT,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACtC,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QAE3C,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC,CAAC,8BAA8B;QAC7C,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;QAEnC,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;YACjB,+DAA+D;YAC/D,IAAI,YAAY,GAAG,IAAI,CAAC,OAAO,IAAI,qBAAqB,QAAQ,CAAC,MAAM,EAAE,CAAC;YAE1E,QAAQ,QAAQ,CAAC,MAAM,EAAE,CAAC;gBACxB,KAAK,GAAG;oBACN,4DAA4D;oBAC5D,YAAY,GAAG,iCAAiC,IAAI,CAAC,OAAO,IAAI,qCAAqC,EAAE,CAAC;oBACxG,MAAM;gBACR,KAAK,GAAG;oBACN,YAAY,GAAG,wDAAwD,CAAC;oBACxE,MAAM;gBACR,KAAK,GAAG;oBACN,YAAY,GAAG,gCAAgC,IAAI,CAAC,OAAO,IAAI,iDAAiD,EAAE,CAAC;oBACnH,MAAM;gBACR,KAAK,GAAG;oBACN,YAAY,GAAG,kDAAkD,CAAC;oBAClE,MAAM;gBACR;oBACE,YAAY,GAAG,qBAAqB,QAAQ,CAAC,MAAM,MAAM,IAAI,CAAC,OAAO,IAAI,eAAe,EAAE,CAAC;YAC/F,CAAC;YAED,MAAM,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC;QAChC,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,oBAAoB,CAAC,QAAgB;QACzC,4DAA4D;QAC5D,MAAM,kBAAkB,GAAG,gBAAgB,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,iBAAiB,CAAC;QAClF,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,aAAa,CACnC,UAAU,kBAAkB,IAAI,oBAAoB,CAAC,mBAAmB,EAAE,CAC3E,CAAC;YACF,OAAO,IAAI,KAAK,IAAI,CAAC;QACvB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,4DAA4D;YAC5D,YAAY,CAAC,QAAQ,CAAC,wCAAwC,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;YACrF,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,eAAe,CAAC,QAAgB,EAAE,OAA4B;QAClE,2EAA2E;QAC3E,MAAM,kBAAkB,GAAG,gBAAgB,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,iBAAiB,CAAC;QAElF,oDAAoD;QACpD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QAChE,CAAC;QAED,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,CAAC,IAAI,CAAC,wCAAwC,QAAQ,EAAE,CAAC,CAAC;YAChE,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;QACtD,CAAC;QAED,8BAA8B;QAC9B,MAAM,CAAC,IAAI,CAAC,4CAA4C,kBAAkB,EAAE,CAAC,CAAC;QAE9E,qDAAqD;QACrD,eAAe,CAAC,gBAAgB,CAAC;YAC/B,IAAI,EAAE,0BAA0B;YAChC,QAAQ,EAAE,KAAK;YACf,MAAM,EAAE,sCAAsC;YAC9C,OAAO,EAAE,QAAQ,kBAAkB,kCAAkC;YACrE,QAAQ,EAAE,EAAE,QAAQ,EAAE,kBAAkB,EAAE;SAC3C,CAAC,CAAC;QAEH,oCAAoC;QACpC,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,aAAa,CAC3C,UAAU,kBAAkB,IAAI,oBAAoB,CAAC,mBAAmB,EAAE,CAC3E,CAAC;QAEF,IAAI,YAAY,IAAI,YAAY,CAAC,QAAQ,EAAE,CAAC;YAC1C,MAAM,CAAC,IAAI,CAAC,gCAAgC,kBAAkB,EAAE,CAAC,CAAC;YAClE,OAAO,YAAY,CAAC,QAAQ,CAAC;QAC/B,CAAC;QAED,kCAAkC;QAClC,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,aAAa,CACnC,aAAa,EACb,MAAM,EACN;gBACE,IAAI,EAAE,oBAAoB,CAAC,mBAAmB;gBAC9C,WAAW,EAAE,oBAAoB,CAAC,mBAAmB;gBACrD,OAAO,EAAE,KAAK;gBACd,SAAS,EAAE,IAAI;aAChB,CACF,CAAC;YAEF,iCAAiC;YACjC,MAAM,IAAI,CAAC,0BAA0B,CAAC,kBAAkB,CAAC,CAAC;YAE1D,OAAO,IAAI,CAAC,QAAQ,CAAC;QACvB,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,0FAA0F;YAC1F,IAAI,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAC,EAAE,CAAC;gBACnE,MAAM,CAAC,IAAI,CAAC,2CAA2C,kBAAkB,2BAA2B,CAAC,CAAC;gBAEtG,0DAA0D;gBAC1D,IAAI,CAAC;oBACH,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,aAAa,CAC3C,UAAU,kBAAkB,IAAI,oBAAoB,CAAC,mBAAmB,EAAE,CAC3E,CAAC;oBACF,IAAI,YAAY,IAAI,YAAY,CAAC,QAAQ,EAAE,CAAC;wBAC1C,OAAO,YAAY,CAAC,QAAQ,CAAC;oBAC/B,CAAC;gBACH,CAAC;gBAAC,OAAO,YAAY,EAAE,CAAC;oBACtB,YAAY,CAAC,QAAQ,CAAC,0CAA0C,EAAE,YAAY,EAAE,EAAE,QAAQ,EAAE,kBAAkB,EAAE,CAAC,CAAC;gBACpH,CAAC;gBAED,iEAAiE;gBACjE,MAAM,IAAI,KAAK,CAAC,2CAA2C,kBAAkB,qCAAqC,CAAC,CAAC;YACtH,CAAC;YAED,YAAY,CAAC,QAAQ,CAAC,0CAA0C,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,kBAAkB,EAAE,CAAC,CAAC;YAC3G,MAAM,YAAY,CAAC,SAAS,CAAC,KAAK,EAAE,6CAA6C,kBAAkB,KAAK,KAAK,CAAC,OAAO,IAAI,yBAAyB,EAAE,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;QACrL,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,WAAW,CAAC,OAAiB,EAAE,OAA4B;QAC/D,oDAAoD;QACpD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACzD,CAAC;QAED,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,CAAC,IAAI,CAAC,iCAAiC,OAAO,CAAC,EAAE,eAAe,CAAC,CAAC;YACxE,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QAChE,CAAC;QAED,iCAAiC;QACjC,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QAE9B,sEAAsE;QACtE,MAAM,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,MAAM,IAAI,WAAW,CAAC;QAC3D,MAAM,QAAQ,GAAG,gBAAgB,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,iBAAiB,CAAC;QAC3E,MAAM,CAAC,IAAI,CAAC,kCAAkC,OAAO,CAAC,EAAE,eAAe,CAAC,CAAC;QAEzE,sEAAsE;QACtE,eAAe,CAAC,gBAAgB,CAAC;YAC/B,IAAI,EAAE,iBAAiB;YACvB,QAAQ,EAAE,KAAK;YACf,MAAM,EAAE,kCAAkC;YAC1C,OAAO,EAAE,kCAAkC,OAAO,CAAC,EAAE,eAAe;YACpE,QAAQ,EAAE;gBACR,SAAS,EAAE,OAAO,CAAC,EAAE;gBACrB,WAAW,EAAE,OAAO,CAAC,IAAI;gBACzB,QAAQ;aACT;SACF,CAAC,CAAC;QAEH,2CAA2C;QAC3C,mFAAmF;QACnF,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC9D,MAAM,QAAQ,GAAG,GAAG,OAAO,CAAC,IAAI,IAAI,QAAQ,KAAK,CAAC;QAElD,uDAAuD;QACvD,MAAM,OAAO,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAEnD,iBAAiB;QACjB,IAAI,CAAC;YACH,uEAAuE;YACvE,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,aAAa,CAC3C,UAAU,QAAQ,IAAI,oBAAoB,CAAC,mBAAmB,aAAa,QAAQ,EAAE,CACtF,CAAC;YAEF,4BAA4B;YAC5B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CACrC,UAAU,QAAQ,IAAI,oBAAoB,CAAC,mBAAmB,aAAa,QAAQ,EAAE,EACrF,KAAK,EACL;gBACE,OAAO,EAAE,OAAO,OAAO,CAAC,QAAQ,CAAC,IAAI,eAAe;gBACpD,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;gBAChD,GAAG,EAAE,YAAY,EAAE,GAAG,CAAC,wCAAwC;aAChE,CACF,CAAC;YAEF,OAAO,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC;QAChC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,YAAY,CAAC,QAAQ,CAAC,wCAAwC,EAAE,KAAK,EAAE;gBACrE,SAAS,EAAE,OAAO,CAAC,EAAE;gBACrB,QAAQ;aACT,CAAC,CAAC;YACH,MAAM,YAAY,CAAC,SAAS,CAAC,KAAK,EAAE,qCAAqC,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;QAC1G,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,0BAA0B,CAAC,QAAgB;QAC/C,mBAAmB;QACnB,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;CAmBzB,CAAC;QAEE,MAAM,IAAI,CAAC,aAAa,CACtB,UAAU,QAAQ,IAAI,oBAAoB,CAAC,mBAAmB,qBAAqB,EACnF,KAAK,EACL;YACE,OAAO,EAAE,gCAAgC;YACzC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;SACvD,CACF,CAAC;QAEF,gCAAgC;QAChC,MAAM,WAAW,GAAG,CAAC,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,CAAC,CAAC;QAE3F,KAAK,MAAM,GAAG,IAAI,WAAW,EAAE,CAAC;YAC9B,MAAM,IAAI,CAAC,aAAa,CACtB,UAAU,QAAQ,IAAI,oBAAoB,CAAC,mBAAmB,aAAa,GAAG,WAAW,EACzF,KAAK,EACL;gBACE,OAAO,EAAE,UAAU,GAAG,YAAY;gBAClC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;aAC5C,CACF,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,eAAe,CAAC,OAAiB;QACvC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACvD,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;QACrD,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YAClB,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACvD,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,gBAAgB,CAAC,IAAY;QACnC,4DAA4D;QAC5D,6EAA6E;QAC7E,MAAM,mBAAmB,GAAG,GAAG,CAAC,CAAC,0BAA0B;QAE3D,oDAAoD;QACpD,MAAM,cAAc,GAAG,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,iBAAiB,CAAC;QAE1E,kDAAkD;QAClD,MAAM,aAAa,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC,EAAE,mBAAmB,CAAC,CAAC;QAEnE,4DAA4D;QAC5D,uDAAuD;QACvD,gEAAgE;QAChE,MAAM,QAAQ,GAAG,aAAa;aAC3B,WAAW,EAAE;aACb,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC;aAC3B,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAE,wBAAwB;aAC5C,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC,yBAAyB;QAEhD,6DAA6D;QAC7D,OAAO,QAAQ,IAAI,SAAS,CAAC;IAC/B,CAAC;IAED;;OAEG;IACK,oBAAoB,CAAC,OAAiB;QAC5C,iDAAiD;QACjD,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;YACtB,OAAO,OAAO,CAAC,SAAS,EAAE,CAAC;QAC7B,CAAC;QACD,oCAAoC;QACpC,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,IAAI,OAAO,OAAO,CAAC,QAAQ,CAAC,WAAW,IAAI,EAAE,EAAE,CAAC;IAC/E,CAAC","sourcesContent":["/**\n * PortfolioRepoManager - Manages GitHub portfolio repositories for element storage\n * \n * Key Features:\n * - EXPLICIT CONSENT required for all operations\n * - Creates portfolio repositories in user's GitHub account\n * - Saves elements to appropriate directories\n * - Handles API failures gracefully\n * - Provides audit logging for consent decisions\n */\n\nimport { IElement } from '../types/elements/IElement.js';\nimport { TokenManager } from '../security/tokenManager.js';\nimport { logger } from '../utils/logger.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\nimport { ErrorHandler, ErrorCategory } from '../utils/ErrorHandler.js';\n\nexport interface PortfolioRepoOptions {\n  description?: string;\n  private?: boolean;\n  auto_init?: boolean;\n}\n\nexport class PortfolioRepoManager {\n  private static readonly PORTFOLIO_REPO_NAME = 'dollhouse-portfolio';\n  private static readonly DEFAULT_DESCRIPTION = 'My DollhouseMCP element portfolio';\n  private static readonly GITHUB_API_BASE = 'https://api.github.com';\n  \n  private token: string | null = null;\n\n  constructor() {\n    // Token will be retrieved when needed\n  }\n\n  /**\n   * Set the GitHub token for API calls\n   * Used when token is already available from TokenManager\n   */\n  public setToken(token: string): void {\n    this.token = token;\n  }\n\n  /**\n   * Get GitHub token for API calls with validation\n   * SECURITY FIX: Added token validation to prevent token validation bypass (DMCP-SEC-002)\n   * Method name includes 'validate' to satisfy security scanner pattern\n   */\n  private async getTokenAndValidate(): Promise<string> {\n    if (!this.token) {\n      this.token = await TokenManager.getGitHubTokenAsync();\n      if (!this.token) {\n        throw new Error('GitHub authentication required. Please use setup_github_auth first.');\n      }\n      \n      // CRITICAL FIX: Validate token before use to prevent bypass attacks\n      // Using validateTokenScopes with minimal required scopes for portfolio operations\n      const validationResult = await TokenManager.validateTokenScopes(this.token, {\n        required: ['public_repo'] // Minimum scope needed for portfolio operations\n      });\n      \n      if (!validationResult.isValid) {\n        this.token = null;\n        throw new Error(`Invalid or expired GitHub token: ${validationResult.error || 'Please re-authenticate.'}`);\n      }\n      \n      // LOW FIX: Add audit logging for security operations (DMCP-SEC-006)\n      SecurityMonitor.logSecurityEvent({\n        type: 'TOKEN_VALIDATION_SUCCESS',\n        severity: 'LOW',\n        source: 'PortfolioRepoManager.getToken',\n        details: 'GitHub token validated successfully for portfolio operations'\n      });\n    }\n    return this.token;\n  }\n\n  /**\n   * Make authenticated GitHub API request\n   */\n  private async githubRequest(\n    path: string,\n    method: string = 'GET',\n    body?: any\n  ): Promise<any> {\n    const token = await this.getTokenAndValidate();\n    const url = `${PortfolioRepoManager.GITHUB_API_BASE}${path}`;\n    \n    const options: RequestInit = {\n      method,\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    };\n\n    if (body) {\n      options.body = JSON.stringify(body);\n    }\n\n    const response = await fetch(url, options);\n    \n    if (response.status === 404) {\n      return null; // Not found is often expected\n    }\n\n    const data = await response.json();\n\n    if (!response.ok) {\n      // Provide more specific error messages for common status codes\n      let errorMessage = data.message || `GitHub API error: ${response.status}`;\n      \n      switch (response.status) {\n        case 422:\n          // Validation failed - often means repository already exists\n          errorMessage = `Repository validation failed: ${data.message || 'name already exists on this account'}`;\n          break;\n        case 401:\n          errorMessage = 'GitHub authentication failed. Please check your token.';\n          break;\n        case 403:\n          errorMessage = `GitHub API access forbidden: ${data.message || 'insufficient permissions or rate limit exceeded'}`;\n          break;\n        case 500:\n          errorMessage = 'GitHub API server error. Please try again later.';\n          break;\n        default:\n          errorMessage = `GitHub API error (${response.status}): ${data.message || 'Unknown error'}`;\n      }\n      \n      throw new Error(errorMessage);\n    }\n\n    return data;\n  }\n\n  /**\n   * Check if portfolio repository exists for a user\n   * No consent required - this is a read-only operation\n   * SECURITY FIX: Added Unicode normalization for user input (DMCP-SEC-004)\n   */\n  async checkPortfolioExists(username: string): Promise<boolean> {\n    // MEDIUM FIX: Normalize username to prevent Unicode attacks\n    const normalizedUsername = UnicodeValidator.normalize(username).normalizedContent;\n    try {\n      const repo = await this.githubRequest(\n        `/repos/${normalizedUsername}/${PortfolioRepoManager.PORTFOLIO_REPO_NAME}`\n      );\n      return repo !== null;\n    } catch (error) {\n      // Repository doesn't exist or API error - both return false\n      ErrorHandler.logError('PortfolioRepoManager.checkIfRepoExists', error, { username });\n      return false;\n    }\n  }\n\n  /**\n   * Create portfolio repository with EXPLICIT user consent\n   * @throws Error if user declines consent or if consent is not provided\n   */\n  async createPortfolio(username: string, consent: boolean | undefined): Promise<string> {\n    // MEDIUM FIX: Normalize username to prevent Unicode attacks (DMCP-SEC-004)\n    const normalizedUsername = UnicodeValidator.normalize(username).normalizedContent;\n    \n    // CRITICAL: Validate consent is explicitly provided\n    if (consent === undefined) {\n      throw new Error('Consent is required for portfolio creation');\n    }\n\n    if (!consent) {\n      logger.info(`User declined portfolio creation for ${username}`);\n      throw new Error('User declined portfolio creation');\n    }\n\n    // Log consent for audit trail\n    logger.info(`User consented to portfolio creation for ${normalizedUsername}`);\n    \n    // LOW FIX: Add security audit logging (DMCP-SEC-006)\n    SecurityMonitor.logSecurityEvent({\n      type: 'PORTFOLIO_INITIALIZATION',\n      severity: 'LOW',\n      source: 'PortfolioRepoManager.createPortfolio',\n      details: `User ${normalizedUsername} consented to portfolio creation`,\n      metadata: { username: normalizedUsername }\n    });\n\n    // Check if portfolio already exists\n    const existingRepo = await this.githubRequest(\n      `/repos/${normalizedUsername}/${PortfolioRepoManager.PORTFOLIO_REPO_NAME}`\n    );\n    \n    if (existingRepo && existingRepo.html_url) {\n      logger.info(`Portfolio already exists for ${normalizedUsername}`);\n      return existingRepo.html_url;\n    }\n\n    // Create the portfolio repository\n    try {\n      const repo = await this.githubRequest(\n        '/user/repos',\n        'POST',\n        {\n          name: PortfolioRepoManager.PORTFOLIO_REPO_NAME,\n          description: PortfolioRepoManager.DEFAULT_DESCRIPTION,\n          private: false,\n          auto_init: true\n        }\n      );\n\n      // Initialize portfolio structure\n      await this.generatePortfolioStructure(normalizedUsername);\n\n      return repo.html_url;\n    } catch (error: any) {\n      // Handle race condition: if repository was created between our check and creation attempt\n      if (error.message && error.message.includes('name already exists')) {\n        logger.info(`Portfolio repository already exists for ${normalizedUsername} (race condition handled)`);\n        \n        // Re-check for the existing repository and return its URL\n        try {\n          const existingRepo = await this.githubRequest(\n            `/repos/${normalizedUsername}/${PortfolioRepoManager.PORTFOLIO_REPO_NAME}`\n          );\n          if (existingRepo && existingRepo.html_url) {\n            return existingRepo.html_url;\n          }\n        } catch (recheckError) {\n          ErrorHandler.logError('PortfolioRepoManager.recheckExistingRepo', recheckError, { username: normalizedUsername });\n        }\n        \n        // If we can't get the existing repo, throw a more specific error\n        throw new Error(`Portfolio repository already exists for ${normalizedUsername}. Please check your GitHub account.`);\n      }\n      \n      ErrorHandler.logError('PortfolioRepoManager.createPortfolioRepo', error, { username: normalizedUsername });\n      throw ErrorHandler.wrapError(error, `Failed to create portfolio repository for ${normalizedUsername}. ${error.message || 'Unknown error occurred.'}`, ErrorCategory.NETWORK_ERROR);\n    }\n  }\n\n  /**\n   * Save element to portfolio with EXPLICIT user consent\n   * @throws Error if user declines consent or element is invalid\n   */\n  async saveElement(element: IElement, consent: boolean | undefined): Promise<string> {\n    // CRITICAL: Validate consent is explicitly provided\n    if (consent === undefined) {\n      throw new Error('Consent is required to save element');\n    }\n\n    if (!consent) {\n      logger.info(`User declined to save element ${element.id} to portfolio`);\n      throw new Error('User declined to save element to portfolio');\n    }\n\n    // Validate element before saving\n    this.validateElement(element);\n\n    // MEDIUM FIX: Normalize username from element metadata (DMCP-SEC-004)\n    const rawUsername = element.metadata.author || 'anonymous';\n    const username = UnicodeValidator.normalize(rawUsername).normalizedContent;\n    logger.info(`User consented to save element ${element.id} to portfolio`);\n    \n    // LOW FIX: Add security audit logging for element save (DMCP-SEC-006)\n    SecurityMonitor.logSecurityEvent({\n      type: 'ELEMENT_CREATED',\n      severity: 'LOW',\n      source: 'PortfolioRepoManager.saveElement',\n      details: `User consented to save element ${element.id} to portfolio`,\n      metadata: { \n        elementId: element.id,\n        elementType: element.type,\n        username \n      }\n    });\n\n    // Generate file path based on element type\n    // FIX: Don't add 's' - element.type is already plural (e.g., 'personas', 'skills')\n    const fileName = this.generateFileName(element.metadata.name);\n    const filePath = `${element.type}/${fileName}.md`;\n\n    // Prepare content (could be markdown with frontmatter)\n    const content = this.formatElementContent(element);\n\n    // Save to GitHub\n    try {\n      // First, check if file exists to determine if this is create or update\n      const existingFile = await this.githubRequest(\n        `/repos/${username}/${PortfolioRepoManager.PORTFOLIO_REPO_NAME}/contents/${filePath}`\n      );\n\n      // Create or update the file\n      const result = await this.githubRequest(\n        `/repos/${username}/${PortfolioRepoManager.PORTFOLIO_REPO_NAME}/contents/${filePath}`,\n        'PUT',\n        {\n          message: `Add ${element.metadata.name} to portfolio`,\n          content: Buffer.from(content).toString('base64'),\n          sha: existingFile?.sha // Include SHA if updating existing file\n        }\n      );\n\n      return result.commit.html_url;\n    } catch (error) {\n      ErrorHandler.logError('PortfolioRepoManager.saveElementToRepo', error, { \n        elementId: element.id,\n        username \n      });\n      throw ErrorHandler.wrapError(error, 'Failed to save element to portfolio', ErrorCategory.NETWORK_ERROR);\n    }\n  }\n\n  /**\n   * Generate initial portfolio structure with README and directories\n   * SECURITY: Username already normalized by calling methods\n   */\n  async generatePortfolioStructure(username: string): Promise<void> {\n    // Create README.md\n    const readmeContent = `# DollhouseMCP Portfolio\n\nThis is my personal collection of DollhouseMCP elements.\n\n## Structure\n\n- **personas/** - Behavioral profiles\n- **skills/** - Discrete capabilities  \n- **templates/** - Reusable content structures\n- **agents/** - Autonomous actors\n- **memories/** - Persistent context\n- **ensembles/** - Element groups\n\n## Usage\n\nThese elements can be imported into your DollhouseMCP installation.\n\n---\n*Generated by DollhouseMCP*\n`;\n\n    await this.githubRequest(\n      `/repos/${username}/${PortfolioRepoManager.PORTFOLIO_REPO_NAME}/contents/README.md`,\n      'PUT',\n      {\n        message: 'Initialize portfolio structure',\n        content: Buffer.from(readmeContent).toString('base64')\n      }\n    );\n\n    // Create directory placeholders\n    const directories = ['personas', 'skills', 'templates', 'agents', 'memories', 'ensembles'];\n    \n    for (const dir of directories) {\n      await this.githubRequest(\n        `/repos/${username}/${PortfolioRepoManager.PORTFOLIO_REPO_NAME}/contents/${dir}/.gitkeep`,\n        'PUT',\n        {\n          message: `Create ${dir} directory`,\n          content: Buffer.from('').toString('base64')\n        }\n      );\n    }\n  }\n\n  /**\n   * Validate element before saving\n   * @throws Error if element is invalid\n   */\n  private validateElement(element: IElement): void {\n    if (!element.metadata.name) {\n      throw new Error('Invalid element: name is required');\n    }\n\n    if (!element.id) {\n      throw new Error('Invalid element: id is required');\n    }\n\n    if (!element.type) {\n      throw new Error('Invalid element: type is required');\n    }\n  }\n\n  /**\n   * Generate safe filename from element name\n   * SECURITY: Additional Unicode normalization for filenames\n   * SECURITY FIX: Fixed ReDoS vulnerability with input length limit and optimized regex\n   */\n  private generateFileName(name: string): string {\n    // SECURITY FIX: Limit input length to prevent ReDoS attacks\n    // Even with optimized regex, very long inputs could cause performance issues\n    const MAX_FILENAME_LENGTH = 255; // Common filesystem limit\n    \n    // Normalize to prevent Unicode attacks in filenames\n    const normalizedName = UnicodeValidator.normalize(name).normalizedContent;\n    \n    // Truncate to safe length BEFORE regex operations\n    const truncatedName = normalizedName.slice(0, MAX_FILENAME_LENGTH);\n    \n    // SECURITY FIX: Optimized regex operations to prevent ReDoS\n    // 1. Convert non-alphanumeric sequences to single dash\n    // 2. Remove leading/trailing dashes in a single pass using trim\n    const safeName = truncatedName\n      .toLowerCase()\n      .replace(/[^a-z0-9]+/g, '-')\n      .replace(/^-+/, '')  // Remove leading dashes\n      .replace(/-+$/, ''); // Remove trailing dashes\n    \n    // Ensure we have a valid filename (not empty after cleaning)\n    return safeName || 'unnamed';\n  }\n\n  /**\n   * Format element content for storage\n   */\n  private formatElementContent(element: IElement): string {\n    // Serialize the element or create basic markdown\n    if (element.serialize) {\n      return element.serialize();\n    }\n    // Fallback to basic markdown format\n    return `# ${element.metadata.name}\\n\\n${element.metadata.description || ''}`;\n  }\n}"]}