@dollhousemcp/mcp-server 1.4.0 → 1.4.2

package/dist/portfolio/DefaultElementProvider.d.ts

@@ -0,0 +1,78 @@
+/**
+ * DefaultElementProvider - Populates portfolio with default elements from bundled data
+ *
+ * This class handles copying default personas, skills, templates, and other elements
+ * from the NPM package or Git repository to the user's portfolio on first run.
+ * It ensures users have example content to work with immediately after installation.
+ */
+export declare const FILE_CONSTANTS: {
+    readonly ELEMENT_EXTENSION: ".md";
+    readonly YAML_EXTENSION: ".yaml";
+    readonly YML_EXTENSION: ".yml";
+    readonly JSON_EXTENSION: ".json";
+    readonly MAX_FILE_SIZE: number;
+    readonly CHECKSUM_ALGORITHM: "sha256";
+    readonly FILE_PERMISSIONS: 420;
+    readonly CHUNK_SIZE: number;
+};
+export interface DefaultElementProviderConfig {
+    /** Custom data directory paths to search (checked before default paths) */
+    customDataPaths?: string[];
+    /** Whether to use default search paths after custom paths */
+    useDefaultPaths?: boolean;
+}
+export declare class DefaultElementProvider {
+    private readonly __dirname;
+    private static cachedDataDir;
+    private static populateInProgress;
+    private readonly config;
+    constructor(config?: DefaultElementProviderConfig);
+    /**
+     * Search paths for bundled data directory
+     * Ordered by priority - custom paths first, then development/git, then NPM locations
+     */
+    private get dataSearchPaths();
+    /**
+     * Find the bundled data directory by checking each search path
+     * Uses Promise.allSettled for better performance and caches the result
+     */
+    private findDataDirectory;
+    /**
+     * Helper to check if a directory exists
+     */
+    private directoryExists;
+    /**
+     * Copy all files from source directory to destination directory
+     * Skips files that already exist to preserve user modifications
+     */
+    private copyElementFiles;
+    /**
+     * Copy a file with integrity verification
+     * Ensures the file was copied correctly by comparing sizes
+     */
+    /**
+     * Calculate checksum of a file for integrity verification
+     * @param filePath Path to the file
+     * @returns Hex-encoded checksum
+     */
+    private calculateChecksum;
+    /**
+     * Copy file with integrity verification and retry logic
+     * @param sourcePath Source file path
+     * @param destPath Destination file path
+     * @throws Error if copy fails after all retry attempts
+     */
+    private copyFileWithVerification;
+    /**
+     * Populate the portfolio with default elements from bundled data
+     * This is called during portfolio initialization for new installations
+     * Protected against concurrent calls to prevent race conditions
+     */
+    populateDefaults(portfolioBaseDir: string): Promise<void>;
+    /**
+     * Perform the actual population of default elements
+     * @param portfolioBaseDir Base directory of the portfolio
+     */
+    private performPopulation;
+}
+//# sourceMappingURL=DefaultElementProvider.d.ts.map

package/dist/portfolio/DefaultElementProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultElementProvider.d.ts","sourceRoot":"","sources":["../../src/portfolio/DefaultElementProvider.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAYH,eAAO,MAAM,cAAc;;;;;;;;;CASjB,CAAC;AAOX,MAAM,WAAW,4BAA4B;IAC3C,2EAA2E;IAC3E,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,6DAA6D;IAC7D,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,MAAM,CAAC,aAAa,CAAuB;IACnD,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAyC;IAC1E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+B;gBAE1C,MAAM,CAAC,EAAE,4BAA4B;IASjD;;;OAGG;IACH,OAAO,KAAK,eAAe,GAmC1B;IAED;;;OAGG;YACW,iBAAiB;IAyC/B;;OAEG;YACW,eAAe;IAS7B;;;OAGG;YACW,gBAAgB;IAmG9B;;;OAGG;IACH;;;;OAIG;YACW,iBAAiB;IAuB/B;;;;;OAKG;YACW,wBAAwB;IA8EtC;;;;OAIG;IACU,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBtE;;;OAGG;YACW,iBAAiB;CAwFhC"}

package/dist/portfolio/DefaultElementProvider.js

@@ -0,0 +1,398 @@
+/**
+ * DefaultElementProvider - Populates portfolio with default elements from bundled data
+ *
+ * This class handles copying default personas, skills, templates, and other elements
+ * from the NPM package or Git repository to the user's portfolio on first run.
+ * It ensures users have example content to work with immediately after installation.
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { createHash } from 'crypto';
+import { logger } from '../utils/logger.js';
+import { ElementType } from './types.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+// File operation constants
+export const FILE_CONSTANTS = {
+    ELEMENT_EXTENSION: '.md',
+    YAML_EXTENSION: '.yaml',
+    YML_EXTENSION: '.yml',
+    JSON_EXTENSION: '.json',
+    MAX_FILE_SIZE: 10 * 1024 * 1024, // 10MB max file size for safety
+    CHECKSUM_ALGORITHM: 'sha256',
+    FILE_PERMISSIONS: 0o644,
+    CHUNK_SIZE: 64 * 1024 // 64KB chunks for reading large files
+};
+// Internal constants
+const DATA_DIR_CACHE_KEY = 'dollhouse_data_dir';
+const COPY_RETRY_ATTEMPTS = 3;
+const COPY_RETRY_DELAY = 100; // ms
+export class DefaultElementProvider {
+    __dirname;
+    static cachedDataDir = null;
+    static populateInProgress = new Map();
+    config;
+    constructor(config) {
+        const __filename = fileURLToPath(import.meta.url);
+        this.__dirname = path.dirname(__filename);
+        this.config = {
+            useDefaultPaths: true,
+            ...config
+        };
+    }
+    /**
+     * Search paths for bundled data directory
+     * Ordered by priority - custom paths first, then development/git, then NPM locations
+     */
+    get dataSearchPaths() {
+        const paths = [];
+        // Add custom paths first (highest priority)
+        if (this.config.customDataPaths) {
+            paths.push(...this.config.customDataPaths);
+        }
+        // Add default paths if enabled
+        if (this.config.useDefaultPaths !== false) {
+            paths.push(
+            // Development/Git installation (relative to this file)
+            path.join(this.__dirname, '../../data'), path.join(this.__dirname, '../../../data'), 
+            // NPM installations - macOS Homebrew
+            '/opt/homebrew/lib/node_modules/@dollhousemcp/mcp-server/data', 
+            // NPM installations - standard Unix/Linux
+            '/usr/local/lib/node_modules/@dollhousemcp/mcp-server/data', '/usr/lib/node_modules/@dollhousemcp/mcp-server/data', 
+            // NPM installations - Windows
+            'C:\\Program Files\\nodejs\\node_modules\\@dollhousemcp\\mcp-server\\data', 'C:\\Program Files (x86)\\nodejs\\node_modules\\@dollhousemcp\\mcp-server\\data', 
+            // NPM installations - Windows with nvm
+            path.join(process.env.APPDATA || '', 'npm', 'node_modules', '@dollhousemcp', 'mcp-server', 'data'), 
+            // Current working directory (last resort)
+            path.join(process.cwd(), 'data'));
+        }
+        return paths;
+    }
+    /**
+     * Find the bundled data directory by checking each search path
+     * Uses Promise.allSettled for better performance and caches the result
+     */
+    async findDataDirectory() {
+        // Return cached value if available
+        if (DefaultElementProvider.cachedDataDir !== null) {
+            return DefaultElementProvider.cachedDataDir;
+        }
+        // Check all paths in parallel for better performance
+        const checkPromises = this.dataSearchPaths.map(async (searchPath) => {
+            try {
+                const stats = await fs.stat(searchPath);
+                if (stats.isDirectory()) {
+                    // Verify it contains expected subdirectories
+                    const hasPersonas = await this.directoryExists(path.join(searchPath, 'personas'));
+                    const hasSkills = await this.directoryExists(path.join(searchPath, 'skills'));
+                    if (hasPersonas || hasSkills) {
+                        return searchPath;
+                    }
+                }
+            }
+            catch (error) {
+                // Directory doesn't exist or can't be accessed
+                return null;
+            }
+            return null;
+        });
+        const results = await Promise.allSettled(checkPromises);
+        // Find the first successful result
+        for (const result of results) {
+            if (result.status === 'fulfilled' && result.value !== null) {
+                logger.info(`[DefaultElementProvider] Found data directory at: ${result.value}`);
+                // Cache the result
+                DefaultElementProvider.cachedDataDir = result.value;
+                return result.value;
+            }
+        }
+        logger.warn('[DefaultElementProvider] No bundled data directory found in any search path');
+        return null;
+    }
+    /**
+     * Helper to check if a directory exists
+     */
+    async directoryExists(dirPath) {
+        try {
+            const stats = await fs.stat(dirPath);
+            return stats.isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Copy all files from source directory to destination directory
+     * Skips files that already exist to preserve user modifications
+     */
+    async copyElementFiles(sourceDir, destDir, elementType) {
+        let copiedCount = 0;
+        try {
+            // Ensure destination directory exists
+            await fs.mkdir(destDir, { recursive: true });
+            // Read source directory
+            const files = await fs.readdir(sourceDir);
+            for (const file of files) {
+                // Only copy markdown files
+                if (!file.endsWith(FILE_CONSTANTS.ELEMENT_EXTENSION)) {
+                    continue;
+                }
+                // Normalize filename for security
+                const normalizedFile = UnicodeValidator.normalize(file);
+                if (!normalizedFile.isValid) {
+                    logger.warn(`[DefaultElementProvider] Skipping file with invalid Unicode: ${file}`);
+                    continue;
+                }
+                const sourcePath = path.join(sourceDir, normalizedFile.normalizedContent);
+                const destPath = path.join(destDir, normalizedFile.normalizedContent);
+                try {
+                    // Check if destination file already exists
+                    await fs.access(destPath);
+                    logger.debug(`[DefaultElementProvider] Skipping existing file: ${normalizedFile.normalizedContent}`);
+                    continue;
+                }
+                catch {
+                    // File doesn't exist, proceed with copy
+                }
+                try {
+                    // Validate source file before copying
+                    const sourceStats = await fs.stat(sourcePath);
+                    // Check file size limit
+                    if (sourceStats.size > FILE_CONSTANTS.MAX_FILE_SIZE) {
+                        logger.warn(`[DefaultElementProvider] Skipping oversized file ${normalizedFile.normalizedContent}: ` +
+                            `${sourceStats.size} bytes (max: ${FILE_CONSTANTS.MAX_FILE_SIZE} bytes)`, {
+                            file: normalizedFile.normalizedContent,
+                            size: sourceStats.size,
+                            maxSize: FILE_CONSTANTS.MAX_FILE_SIZE,
+                            elementType
+                        });
+                        continue;
+                    }
+                    // Copy the file with verification
+                    await this.copyFileWithVerification(sourcePath, destPath);
+                    copiedCount++;
+                    logger.debug(`[DefaultElementProvider] Copied ${elementType}: ${normalizedFile.normalizedContent}`);
+                    // Log security event for each file copied
+                    SecurityMonitor.logSecurityEvent({
+                        type: 'FILE_COPIED',
+                        severity: 'LOW',
+                        source: 'DefaultElementProvider.copyElementFiles',
+                        details: `Copied default ${elementType} file: ${normalizedFile.normalizedContent}`,
+                        metadata: {
+                            sourcePath,
+                            destPath,
+                            elementType,
+                            fileSize: (await fs.stat(destPath)).size
+                        }
+                    });
+                }
+                catch (error) {
+                    const err = error;
+                    logger.error(`[DefaultElementProvider] Failed to copy ${normalizedFile.normalizedContent}`, {
+                        error: err.message,
+                        stack: err.stack,
+                        sourcePath,
+                        destPath,
+                        elementType
+                    });
+                    // Continue with other files instead of failing completely
+                }
+            }
+            if (copiedCount > 0) {
+                logger.info(`[DefaultElementProvider] Copied ${copiedCount} ${elementType} file(s)`);
+            }
+        }
+        catch (error) {
+            logger.error(`[DefaultElementProvider] Error copying ${elementType} files:`, error);
+        }
+        return copiedCount;
+    }
+    /**
+     * Copy a file with integrity verification
+     * Ensures the file was copied correctly by comparing sizes
+     */
+    /**
+     * Calculate checksum of a file for integrity verification
+     * @param filePath Path to the file
+     * @returns Hex-encoded checksum
+     */
+    async calculateChecksum(filePath) {
+        const hash = createHash(FILE_CONSTANTS.CHECKSUM_ALGORITHM);
+        const stream = await fs.open(filePath, 'r');
+        try {
+            const buffer = Buffer.alloc(FILE_CONSTANTS.CHUNK_SIZE);
+            let bytesRead;
+            do {
+                const result = await stream.read(buffer, 0, FILE_CONSTANTS.CHUNK_SIZE);
+                bytesRead = result.bytesRead;
+                if (bytesRead > 0) {
+                    hash.update(buffer.subarray(0, bytesRead));
+                }
+            } while (bytesRead > 0);
+            return hash.digest('hex');
+        }
+        finally {
+            await stream.close();
+        }
+    }
+    /**
+     * Copy file with integrity verification and retry logic
+     * @param sourcePath Source file path
+     * @param destPath Destination file path
+     * @throws Error if copy fails after all retry attempts
+     */
+    async copyFileWithVerification(sourcePath, destPath) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= COPY_RETRY_ATTEMPTS; attempt++) {
+            try {
+                // Copy the file
+                await fs.copyFile(sourcePath, destPath);
+                // Verify size matches
+                const [sourceStats, destStats] = await Promise.all([
+                    fs.stat(sourcePath),
+                    fs.stat(destPath)
+                ]);
+                if (sourceStats.size !== destStats.size) {
+                    throw new Error(`Size mismatch after copy - source: ${sourceStats.size} bytes, ` +
+                        `destination: ${destStats.size} bytes`);
+                }
+                // Verify checksum matches for complete integrity
+                const [sourceChecksum, destChecksum] = await Promise.all([
+                    this.calculateChecksum(sourcePath),
+                    this.calculateChecksum(destPath)
+                ]);
+                if (sourceChecksum !== destChecksum) {
+                    throw new Error(`Checksum mismatch after copy - source: ${sourceChecksum}, ` +
+                        `destination: ${destChecksum}`);
+                }
+                // Set proper permissions
+                try {
+                    await fs.chmod(destPath, FILE_CONSTANTS.FILE_PERMISSIONS);
+                }
+                catch (error) {
+                    logger.debug(`[DefaultElementProvider] Could not set permissions on ${destPath}: ${error}`, { sourcePath, destPath, attempt });
+                }
+                // Success - file copied and verified
+                logger.debug(`[DefaultElementProvider] Successfully copied and verified: ${path.basename(sourcePath)}`, { size: sourceStats.size, checksum: sourceChecksum.substring(0, 8) });
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                // Clean up failed copy
+                try {
+                    await fs.unlink(destPath);
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+                if (attempt < COPY_RETRY_ATTEMPTS) {
+                    logger.debug(`[DefaultElementProvider] Copy attempt ${attempt} failed, retrying...`, { error: lastError.message, sourcePath, destPath });
+                    await new Promise(resolve => setTimeout(resolve, COPY_RETRY_DELAY * attempt));
+                }
+            }
+        }
+        // All attempts failed
+        throw new Error(`Failed to copy ${path.basename(sourcePath)} after ${COPY_RETRY_ATTEMPTS} attempts: ` +
+            `${lastError?.message || 'Unknown error'}`);
+    }
+    /**
+     * Populate the portfolio with default elements from bundled data
+     * This is called during portfolio initialization for new installations
+     * Protected against concurrent calls to prevent race conditions
+     */
+    async populateDefaults(portfolioBaseDir) {
+        // Check if population is already in progress for this portfolio
+        const existingPopulation = DefaultElementProvider.populateInProgress.get(portfolioBaseDir);
+        if (existingPopulation) {
+            logger.debug('[DefaultElementProvider] Population already in progress for portfolio, waiting...', { portfolioBaseDir });
+            return existingPopulation;
+        }
+        // Create new population promise
+        const populationPromise = this.performPopulation(portfolioBaseDir)
+            .finally(() => {
+            // Clean up when done
+            DefaultElementProvider.populateInProgress.delete(portfolioBaseDir);
+        });
+        DefaultElementProvider.populateInProgress.set(portfolioBaseDir, populationPromise);
+        return populationPromise;
+    }
+    /**
+     * Perform the actual population of default elements
+     * @param portfolioBaseDir Base directory of the portfolio
+     */
+    async performPopulation(portfolioBaseDir) {
+        logger.info('[DefaultElementProvider] Starting default element population', { portfolioBaseDir });
+        // Log security event for portfolio initialization
+        SecurityMonitor.logSecurityEvent({
+            type: 'PORTFOLIO_INITIALIZATION',
+            severity: 'LOW',
+            source: 'DefaultElementProvider.performPopulation',
+            details: `Starting default element population for portfolio: ${portfolioBaseDir}`
+        });
+        // Find the bundled data directory
+        const dataDir = await this.findDataDirectory();
+        if (!dataDir) {
+            logger.warn('[DefaultElementProvider] No bundled data directory found - portfolio will start empty', {
+                searchPaths: this.dataSearchPaths.slice(0, 3), // Log first few paths for debugging
+                cwd: process.cwd(),
+                dirname: this.__dirname
+            });
+            return;
+        }
+        // Track total files copied
+        let totalCopied = 0;
+        const copiedCounts = {};
+        // Map of data subdirectory names (plural) to portfolio directory names (singular)
+        const elementMappings = {
+            'personas': ElementType.PERSONA,
+            'skills': ElementType.SKILL,
+            'templates': ElementType.TEMPLATE,
+            'agents': ElementType.AGENT,
+            'memories': ElementType.MEMORY,
+            'ensembles': ElementType.ENSEMBLE
+        };
+        // Copy each element type
+        for (const [dataSubdir, elementType] of Object.entries(elementMappings)) {
+            const sourceDir = path.join(dataDir, dataSubdir);
+            const destDir = path.join(portfolioBaseDir, elementType);
+            try {
+                // Check if source directory exists
+                await fs.access(sourceDir);
+                const copiedCount = await this.copyElementFiles(sourceDir, destDir, dataSubdir);
+                copiedCounts[dataSubdir] = copiedCount;
+                totalCopied += copiedCount;
+            }
+            catch (error) {
+                // Source directory doesn't exist, skip
+                logger.debug(`[DefaultElementProvider] No ${dataSubdir} directory in bundled data`);
+            }
+        }
+        if (totalCopied > 0) {
+            logger.info(`[DefaultElementProvider] Successfully populated portfolio with ${totalCopied} default element(s)`, {
+                portfolioBaseDir,
+                dataDir,
+                breakdown: Object.entries(elementMappings).reduce((acc, [dataDir, elementType]) => {
+                    acc[elementType] = copiedCounts[dataDir] || 0;
+                    return acc;
+                }, {})
+            });
+            // Log security event for successful population
+            SecurityMonitor.logSecurityEvent({
+                type: 'PORTFOLIO_POPULATED',
+                severity: 'LOW',
+                source: 'DefaultElementProvider.performPopulation',
+                details: `Successfully populated portfolio with ${totalCopied} default elements`,
+                metadata: {
+                    portfolioBaseDir,
+                    dataDir,
+                    copiedCounts
+                }
+            });
+        }
+        else {
+            logger.info('[DefaultElementProvider] No new elements to copy - portfolio may already have content');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DefaultElementProvider.js","sourceRoot":"","sources":["../../src/portfolio/DefaultElementProvider.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * DefaultElementProvider - Populates portfolio with default elements from bundled data\n * \n * This class handles copying default personas, skills, templates, and other elements\n * from the NPM package or Git repository to the user's portfolio on first run.\n * It ensures users have example content to work with immediately after installation.\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { fileURLToPath } from 'url';\nimport { createHash } from 'crypto';\nimport { logger } from '../utils/logger.js';\nimport { ElementType } from './types.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\n\n// File operation constants\nexport const FILE_CONSTANTS = {\n  ELEMENT_EXTENSION: '.md',\n  YAML_EXTENSION: '.yaml',\n  YML_EXTENSION: '.yml',\n  JSON_EXTENSION: '.json',\n  MAX_FILE_SIZE: 10 * 1024 * 1024, // 10MB max file size for safety\n  CHECKSUM_ALGORITHM: 'sha256',\n  FILE_PERMISSIONS: 0o644,\n  CHUNK_SIZE: 64 * 1024 // 64KB chunks for reading large files\n} as const;\n\n// Internal constants\nconst DATA_DIR_CACHE_KEY = 'dollhouse_data_dir';\nconst COPY_RETRY_ATTEMPTS = 3;\nconst COPY_RETRY_DELAY = 100; // ms\n\nexport interface DefaultElementProviderConfig {\n  /** Custom data directory paths to search (checked before default paths) */\n  customDataPaths?: string[];\n  /** Whether to use default search paths after custom paths */\n  useDefaultPaths?: boolean;\n}\n\nexport class DefaultElementProvider {\n  private readonly __dirname: string;\n  private static cachedDataDir: string | null = null;\n  private static populateInProgress: Map<string, Promise<void>> = new Map();\n  private readonly config: DefaultElementProviderConfig;\n  \n  constructor(config?: DefaultElementProviderConfig) {\n    const __filename = fileURLToPath(import.meta.url);\n    this.__dirname = path.dirname(__filename);\n    this.config = {\n      useDefaultPaths: true,\n      ...config\n    };\n  }\n  \n  /**\n   * Search paths for bundled data directory\n   * Ordered by priority - custom paths first, then development/git, then NPM locations\n   */\n  private get dataSearchPaths(): string[] {\n    const paths: string[] = [];\n    \n    // Add custom paths first (highest priority)\n    if (this.config.customDataPaths) {\n      paths.push(...this.config.customDataPaths);\n    }\n    \n    // Add default paths if enabled\n    if (this.config.useDefaultPaths !== false) {\n      paths.push(\n        // Development/Git installation (relative to this file)\n        path.join(this.__dirname, '../../data'),\n        path.join(this.__dirname, '../../../data'),\n        \n        // NPM installations - macOS Homebrew\n        '/opt/homebrew/lib/node_modules/@dollhousemcp/mcp-server/data',\n        \n        // NPM installations - standard Unix/Linux\n        '/usr/local/lib/node_modules/@dollhousemcp/mcp-server/data',\n        '/usr/lib/node_modules/@dollhousemcp/mcp-server/data',\n        \n        // NPM installations - Windows\n        'C:\\\\Program Files\\\\nodejs\\\\node_modules\\\\@dollhousemcp\\\\mcp-server\\\\data',\n        'C:\\\\Program Files (x86)\\\\nodejs\\\\node_modules\\\\@dollhousemcp\\\\mcp-server\\\\data',\n        \n        // NPM installations - Windows with nvm\n        path.join(process.env.APPDATA || '', 'npm', 'node_modules', '@dollhousemcp', 'mcp-server', 'data'),\n        \n        // Current working directory (last resort)\n        path.join(process.cwd(), 'data')\n      );\n    }\n    \n    return paths;\n  }\n  \n  /**\n   * Find the bundled data directory by checking each search path\n   * Uses Promise.allSettled for better performance and caches the result\n   */\n  private async findDataDirectory(): Promise<string | null> {\n    // Return cached value if available\n    if (DefaultElementProvider.cachedDataDir !== null) {\n      return DefaultElementProvider.cachedDataDir;\n    }\n    \n    // Check all paths in parallel for better performance\n    const checkPromises = this.dataSearchPaths.map(async (searchPath) => {\n      try {\n        const stats = await fs.stat(searchPath);\n        if (stats.isDirectory()) {\n          // Verify it contains expected subdirectories\n          const hasPersonas = await this.directoryExists(path.join(searchPath, 'personas'));\n          const hasSkills = await this.directoryExists(path.join(searchPath, 'skills'));\n          if (hasPersonas || hasSkills) {\n            return searchPath;\n          }\n        }\n      } catch (error) {\n        // Directory doesn't exist or can't be accessed\n        return null;\n      }\n      return null;\n    });\n    \n    const results = await Promise.allSettled(checkPromises);\n    \n    // Find the first successful result\n    for (const result of results) {\n      if (result.status === 'fulfilled' && result.value !== null) {\n        logger.info(`[DefaultElementProvider] Found data directory at: ${result.value}`);\n        // Cache the result\n        DefaultElementProvider.cachedDataDir = result.value;\n        return result.value;\n      }\n    }\n    \n    logger.warn('[DefaultElementProvider] No bundled data directory found in any search path');\n    return null;\n  }\n  \n  /**\n   * Helper to check if a directory exists\n   */\n  private async directoryExists(dirPath: string): Promise<boolean> {\n    try {\n      const stats = await fs.stat(dirPath);\n      return stats.isDirectory();\n    } catch {\n      return false;\n    }\n  }\n  \n  /**\n   * Copy all files from source directory to destination directory\n   * Skips files that already exist to preserve user modifications\n   */\n  private async copyElementFiles(sourceDir: string, destDir: string, elementType: string): Promise<number> {\n    let copiedCount = 0;\n    \n    try {\n      // Ensure destination directory exists\n      await fs.mkdir(destDir, { recursive: true });\n      \n      // Read source directory\n      const files = await fs.readdir(sourceDir);\n      \n      for (const file of files) {\n        // Only copy markdown files\n        if (!file.endsWith(FILE_CONSTANTS.ELEMENT_EXTENSION)) {\n          continue;\n        }\n        \n        // Normalize filename for security\n        const normalizedFile = UnicodeValidator.normalize(file);\n        if (!normalizedFile.isValid) {\n          logger.warn(`[DefaultElementProvider] Skipping file with invalid Unicode: ${file}`);\n          continue;\n        }\n        \n        const sourcePath = path.join(sourceDir, normalizedFile.normalizedContent);\n        const destPath = path.join(destDir, normalizedFile.normalizedContent);\n        \n        try {\n          // Check if destination file already exists\n          await fs.access(destPath);\n          logger.debug(`[DefaultElementProvider] Skipping existing file: ${normalizedFile.normalizedContent}`);\n          continue;\n        } catch {\n          // File doesn't exist, proceed with copy\n        }\n        \n        try {\n          // Validate source file before copying\n          const sourceStats = await fs.stat(sourcePath);\n          \n          // Check file size limit\n          if (sourceStats.size > FILE_CONSTANTS.MAX_FILE_SIZE) {\n            logger.warn(\n              `[DefaultElementProvider] Skipping oversized file ${normalizedFile.normalizedContent}: ` +\n              `${sourceStats.size} bytes (max: ${FILE_CONSTANTS.MAX_FILE_SIZE} bytes)`,\n              { \n                file: normalizedFile.normalizedContent, \n                size: sourceStats.size,\n                maxSize: FILE_CONSTANTS.MAX_FILE_SIZE,\n                elementType \n              }\n            );\n            continue;\n          }\n          \n          // Copy the file with verification\n          await this.copyFileWithVerification(sourcePath, destPath);\n          copiedCount++;\n          logger.debug(`[DefaultElementProvider] Copied ${elementType}: ${normalizedFile.normalizedContent}`);\n          \n          // Log security event for each file copied\n          SecurityMonitor.logSecurityEvent({\n            type: 'FILE_COPIED',\n            severity: 'LOW',\n            source: 'DefaultElementProvider.copyElementFiles',\n            details: `Copied default ${elementType} file: ${normalizedFile.normalizedContent}`,\n            metadata: {\n              sourcePath,\n              destPath,\n              elementType,\n              fileSize: (await fs.stat(destPath)).size\n            }\n          });\n        } catch (error) {\n          const err = error as Error;\n          logger.error(\n            `[DefaultElementProvider] Failed to copy ${normalizedFile.normalizedContent}`,\n            { \n              error: err.message,\n              stack: err.stack,\n              sourcePath,\n              destPath,\n              elementType\n            }\n          );\n          // Continue with other files instead of failing completely\n        }\n      }\n      \n      if (copiedCount > 0) {\n        logger.info(`[DefaultElementProvider] Copied ${copiedCount} ${elementType} file(s)`);\n      }\n      \n    } catch (error) {\n      logger.error(`[DefaultElementProvider] Error copying ${elementType} files:`, error);\n    }\n    \n    return copiedCount;\n  }\n  \n  /**\n   * Copy a file with integrity verification\n   * Ensures the file was copied correctly by comparing sizes\n   */\n  /**\n   * Calculate checksum of a file for integrity verification\n   * @param filePath Path to the file\n   * @returns Hex-encoded checksum\n   */\n  private async calculateChecksum(filePath: string): Promise<string> {\n    const hash = createHash(FILE_CONSTANTS.CHECKSUM_ALGORITHM);\n    const stream = await fs.open(filePath, 'r');\n    \n    try {\n      const buffer = Buffer.alloc(FILE_CONSTANTS.CHUNK_SIZE);\n      let bytesRead: number;\n      \n      do {\n        const result = await stream.read(buffer, 0, FILE_CONSTANTS.CHUNK_SIZE);\n        bytesRead = result.bytesRead;\n        \n        if (bytesRead > 0) {\n          hash.update(buffer.subarray(0, bytesRead));\n        }\n      } while (bytesRead > 0);\n      \n      return hash.digest('hex');\n    } finally {\n      await stream.close();\n    }\n  }\n\n  /**\n   * Copy file with integrity verification and retry logic\n   * @param sourcePath Source file path\n   * @param destPath Destination file path\n   * @throws Error if copy fails after all retry attempts\n   */\n  private async copyFileWithVerification(sourcePath: string, destPath: string): Promise<void> {\n    let lastError: Error | null = null;\n    \n    for (let attempt = 1; attempt <= COPY_RETRY_ATTEMPTS; attempt++) {\n      try {\n        // Copy the file\n        await fs.copyFile(sourcePath, destPath);\n        \n        // Verify size matches\n        const [sourceStats, destStats] = await Promise.all([\n          fs.stat(sourcePath),\n          fs.stat(destPath)\n        ]);\n        \n        if (sourceStats.size !== destStats.size) {\n          throw new Error(\n            `Size mismatch after copy - source: ${sourceStats.size} bytes, ` +\n            `destination: ${destStats.size} bytes`\n          );\n        }\n        \n        // Verify checksum matches for complete integrity\n        const [sourceChecksum, destChecksum] = await Promise.all([\n          this.calculateChecksum(sourcePath),\n          this.calculateChecksum(destPath)\n        ]);\n        \n        if (sourceChecksum !== destChecksum) {\n          throw new Error(\n            `Checksum mismatch after copy - source: ${sourceChecksum}, ` +\n            `destination: ${destChecksum}`\n          );\n        }\n        \n        // Set proper permissions\n        try {\n          await fs.chmod(destPath, FILE_CONSTANTS.FILE_PERMISSIONS);\n        } catch (error) {\n          logger.debug(\n            `[DefaultElementProvider] Could not set permissions on ${destPath}: ${error}`,\n            { sourcePath, destPath, attempt }\n          );\n        }\n        \n        // Success - file copied and verified\n        logger.debug(\n          `[DefaultElementProvider] Successfully copied and verified: ${path.basename(sourcePath)}`,\n          { size: sourceStats.size, checksum: sourceChecksum.substring(0, 8) }\n        );\n        return;\n        \n      } catch (error) {\n        lastError = error as Error;\n        \n        // Clean up failed copy\n        try {\n          await fs.unlink(destPath);\n        } catch {\n          // Ignore cleanup errors\n        }\n        \n        if (attempt < COPY_RETRY_ATTEMPTS) {\n          logger.debug(\n            `[DefaultElementProvider] Copy attempt ${attempt} failed, retrying...`,\n            { error: lastError.message, sourcePath, destPath }\n          );\n          await new Promise(resolve => setTimeout(resolve, COPY_RETRY_DELAY * attempt));\n        }\n      }\n    }\n    \n    // All attempts failed\n    throw new Error(\n      `Failed to copy ${path.basename(sourcePath)} after ${COPY_RETRY_ATTEMPTS} attempts: ` +\n      `${lastError?.message || 'Unknown error'}`\n    );\n  }\n  \n  /**\n   * Populate the portfolio with default elements from bundled data\n   * This is called during portfolio initialization for new installations\n   * Protected against concurrent calls to prevent race conditions\n   */\n  public async populateDefaults(portfolioBaseDir: string): Promise<void> {\n    // Check if population is already in progress for this portfolio\n    const existingPopulation = DefaultElementProvider.populateInProgress.get(portfolioBaseDir);\n    if (existingPopulation) {\n      logger.debug(\n        '[DefaultElementProvider] Population already in progress for portfolio, waiting...',\n        { portfolioBaseDir }\n      );\n      return existingPopulation;\n    }\n    \n    // Create new population promise\n    const populationPromise = this.performPopulation(portfolioBaseDir)\n      .finally(() => {\n        // Clean up when done\n        DefaultElementProvider.populateInProgress.delete(portfolioBaseDir);\n      });\n    \n    DefaultElementProvider.populateInProgress.set(portfolioBaseDir, populationPromise);\n    return populationPromise;\n  }\n  \n  /**\n   * Perform the actual population of default elements\n   * @param portfolioBaseDir Base directory of the portfolio\n   */\n  private async performPopulation(portfolioBaseDir: string): Promise<void> {\n    logger.info(\n      '[DefaultElementProvider] Starting default element population',\n      { portfolioBaseDir }\n    );\n    \n    // Log security event for portfolio initialization\n    SecurityMonitor.logSecurityEvent({\n      type: 'PORTFOLIO_INITIALIZATION',\n      severity: 'LOW',\n      source: 'DefaultElementProvider.performPopulation',\n      details: `Starting default element population for portfolio: ${portfolioBaseDir}`\n    });\n    \n    // Find the bundled data directory\n    const dataDir = await this.findDataDirectory();\n    if (!dataDir) {\n      logger.warn(\n        '[DefaultElementProvider] No bundled data directory found - portfolio will start empty',\n        { \n          searchPaths: this.dataSearchPaths.slice(0, 3), // Log first few paths for debugging\n          cwd: process.cwd(),\n          dirname: this.__dirname\n        }\n      );\n      return;\n    }\n    \n    // Track total files copied\n    let totalCopied = 0;\n    const copiedCounts: Record<string, number> = {};\n    \n    // Map of data subdirectory names (plural) to portfolio directory names (singular)\n    const elementMappings: Record<string, ElementType> = {\n      'personas': ElementType.PERSONA,\n      'skills': ElementType.SKILL,\n      'templates': ElementType.TEMPLATE,\n      'agents': ElementType.AGENT,\n      'memories': ElementType.MEMORY,\n      'ensembles': ElementType.ENSEMBLE\n    };\n    \n    // Copy each element type\n    for (const [dataSubdir, elementType] of Object.entries(elementMappings)) {\n      const sourceDir = path.join(dataDir, dataSubdir);\n      const destDir = path.join(portfolioBaseDir, elementType);\n      \n      try {\n        // Check if source directory exists\n        await fs.access(sourceDir);\n        const copiedCount = await this.copyElementFiles(sourceDir, destDir, dataSubdir);\n        copiedCounts[dataSubdir] = copiedCount;\n        totalCopied += copiedCount;\n      } catch (error) {\n        // Source directory doesn't exist, skip\n        logger.debug(`[DefaultElementProvider] No ${dataSubdir} directory in bundled data`);\n      }\n    }\n    \n    if (totalCopied > 0) {\n      logger.info(\n        `[DefaultElementProvider] Successfully populated portfolio with ${totalCopied} default element(s)`,\n        {\n          portfolioBaseDir,\n          dataDir,\n          breakdown: Object.entries(elementMappings).reduce((acc, [dataDir, elementType]) => {\n            acc[elementType] = copiedCounts[dataDir] || 0;\n            return acc;\n          }, {} as Record<string, number>)\n        }\n      );\n      \n      // Log security event for successful population\n      SecurityMonitor.logSecurityEvent({\n        type: 'PORTFOLIO_POPULATED',\n        severity: 'LOW',\n        source: 'DefaultElementProvider.performPopulation',\n        details: `Successfully populated portfolio with ${totalCopied} default elements`,\n        metadata: {\n          portfolioBaseDir,\n          dataDir,\n          copiedCounts\n        }\n      });\n    } else {\n      logger.info('[DefaultElementProvider] No new elements to copy - portfolio may already have content');\n    }\n  }\n}"]}

package/dist/portfolio/PortfolioManager.d.ts

@@ -7,6 +7,8 @@ export type { PortfolioConfig };
 export declare class PortfolioManager {
     private static instance;
     private static instanceLock;
+    private static initializationLock;
+    private static initializationPromise;
     private baseDir;
     private constructor();
     static getInstance(config?: PortfolioConfig): PortfolioManager;
@@ -20,8 +22,13 @@ export declare class PortfolioManager {
     getElementDir(type: ElementType): string;
     /**
      * Initialize the portfolio directory structure
+     * Uses locking to prevent race conditions during concurrent initialization
      */
     initialize(): Promise<void>;
+    /**
+     * Perform the actual initialization - should only be called once
+     */
+    private performInitialization;
     /**
      * Check if portfolio directory exists
      */

package/dist/portfolio/PortfolioManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PortfolioManager.d.ts","sourceRoot":"","sources":["../../src/portfolio/PortfolioManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAG1D,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAmB;IAC1C,OAAO,CAAC,MAAM,CAAC,YAAY,CAAS;IACpC,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO;WA4BO,WAAW,CAAC,MAAM,CAAC,EAAE,eAAe,GAAG,gBAAgB;IAiBrE;;OAEG;IACI,UAAU,IAAI,MAAM;IAI3B;;OAEG;IACI,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;IAI/C;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAoBxC;;OAEG;IACU,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;IASvC;;OAEG;IACU,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IA4C/D;;OAEG;IACI,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IA0ClE;;OAEG;IACU,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IASjF;;OAEG;IACI,oBAAoB,IAAI,MAAM;IAIrC;;OAEG;IACU,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;IAUlD;;OAEG;IACU,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;CAUnE"}
+{"version":3,"file":"PortfolioManager.d.ts","sourceRoot":"","sources":["../../src/portfolio/PortfolioManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAO1D,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAmB;IAC1C,OAAO,CAAC,MAAM,CAAC,YAAY,CAAS;IACpC,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAS;IAC1C,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAA8B;IAClE,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO;WA4BO,WAAW,CAAC,MAAM,CAAC,EAAE,eAAe,GAAG,gBAAgB;IAiBrE;;OAEG;IACI,UAAU,IAAI,MAAM;IAI3B;;OAEG;IACI,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;IAI/C;;;OAGG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAuBxC;;OAEG;YACW,qBAAqB;IAgCnC;;OAEG;IACU,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;IASvC;;OAEG;IACU,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IA4C/D;;OAEG;IACI,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IA0ClE;;OAEG;IACU,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IASjF;;OAEG;IACI,oBAAoB,IAAI,MAAM;IAIrC;;OAEG;IACU,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;IAUlD;;OAEG;IACU,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;CAUnE"}