@dollhousemcp/mcp-server 1.3.0

package/dist/test/src/security/fileLockManager.js

@@ -0,0 +1,187 @@
+import { logger } from '../utils/logger.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { randomBytes } from 'crypto';
+/**
+ * FileLockManager - Prevents race conditions in concurrent file operations
+ *
+ * Features:
+ * - Resource-based locking with automatic cleanup
+ * - Configurable timeouts to prevent deadlocks
+ * - Atomic file operations with write-rename pattern
+ * - Lock queueing for concurrent requests
+ * - Comprehensive error handling and logging
+ * - Performance metrics tracking
+ */
+export class FileLockManager {
+    // Map of resource identifiers to their lock promises
+    static locks = new Map();
+    // Lock acquisition metrics for monitoring
+    static metrics = {
+        totalLockRequests: 0,
+        lockWaitTime: new Map(),
+        lockTimeouts: 0,
+        concurrentWaits: 0
+    };
+    // Default timeout for lock operations (10 seconds)
+    static DEFAULT_TIMEOUT_MS = 10000;
+    // Temporary file directory
+    static TEMP_DIR = '.tmp';
+    /**
+     * Execute an operation with exclusive lock on a resource
+     * @param resource - Unique identifier for the resource (e.g., 'persona:name')
+     * @param operation - Async function to execute while holding the lock
+     * @param options - Lock options including timeout
+     * @returns Result of the operation
+     */
+    static async withLock(resource, operation, options = {}) {
+        const startTime = Date.now();
+        this.metrics.totalLockRequests++;
+        logger.debug(`Lock requested for resource: ${resource}`);
+        // Wait for any existing operation on this resource
+        const existingLock = this.locks.get(resource);
+        if (existingLock) {
+            this.metrics.concurrentWaits++;
+            logger.debug(`Waiting for existing lock on: ${resource}`);
+            try {
+                await existingLock;
+            }
+            catch (error) {
+                // Previous operation failed, but we can proceed
+                logger.debug(`Previous operation on ${resource} failed, proceeding`);
+            }
+        }
+        // Create new lock for this operation
+        const timeout = options.timeout || this.DEFAULT_TIMEOUT_MS;
+        const lockPromise = this.executeWithTimeout(operation, timeout, resource);
+        this.locks.set(resource, lockPromise);
+        try {
+            const result = await lockPromise;
+            // Record metrics
+            const waitTime = Date.now() - startTime;
+            if (!this.metrics.lockWaitTime.has(resource)) {
+                this.metrics.lockWaitTime.set(resource, []);
+            }
+            this.metrics.lockWaitTime.get(resource).push(waitTime);
+            logger.debug(`Lock released for resource: ${resource} (${waitTime}ms)`);
+            return result;
+        }
+        finally {
+            // Clean up lock atomically - compare and delete in one operation
+            const currentLock = this.locks.get(resource);
+            if (currentLock === lockPromise) {
+                this.locks.delete(resource);
+                logger.debug(`Lock queue cleaned up for resource: ${resource}`);
+            }
+        }
+    }
+    /**
+     * Execute operation with timeout protection
+     */
+    static async executeWithTimeout(operation, timeoutMs, resource) {
+        let timeoutHandle;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutHandle = setTimeout(() => {
+                this.metrics.lockTimeouts++;
+                reject(new Error(`Lock operation timeout for resource: ${resource}`));
+            }, timeoutMs);
+        });
+        try {
+            const result = await Promise.race([operation(), timeoutPromise]);
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            return result;
+        }
+        catch (error) {
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            throw error;
+        }
+    }
+    /**
+     * Perform atomic file write operation
+     * Writes to temporary file then renames to ensure atomicity
+     */
+    static async atomicWriteFile(filePath, content, options) {
+        const tempPath = await this.getTempFilePath(filePath);
+        const dir = path.dirname(tempPath);
+        try {
+            // Ensure temp directory exists
+            await fs.mkdir(dir, { recursive: true });
+            // Write to temporary file
+            await fs.writeFile(tempPath, content, options);
+            // Atomic rename (on same filesystem)
+            await fs.rename(tempPath, filePath);
+            logger.debug(`Atomic write completed: ${filePath}`);
+        }
+        catch (error) {
+            // Clean up temp file on error
+            try {
+                await fs.unlink(tempPath);
+                logger.debug(`Cleaned up temp file after error: ${tempPath}`);
+            }
+            catch (unlinkError) {
+                // Log cleanup failure but don't throw - original error is more important
+                logger.warn(`Failed to clean up temp file ${tempPath}: ${unlinkError}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Perform atomic file read with lock
+     */
+    static async atomicReadFile(filePath, options) {
+        return this.withLock(`file:${filePath}`, async () => {
+            const content = await fs.readFile(filePath, options);
+            return content.toString();
+        });
+    }
+    /**
+     * Generate temporary file path for atomic operations
+     */
+    static async getTempFilePath(originalPath) {
+        const dir = path.dirname(originalPath);
+        const basename = path.basename(originalPath);
+        const random = randomBytes(8).toString('hex');
+        return path.join(dir, this.TEMP_DIR, `${basename}.${random}.tmp`);
+    }
+    /**
+     * Get lock metrics for monitoring
+     */
+    static getMetrics() {
+        const avgWaitTimes = new Map();
+        for (const [resource, times] of this.metrics.lockWaitTime.entries()) {
+            if (times.length > 0) {
+                const avg = times.reduce((a, b) => a + b, 0) / times.length;
+                avgWaitTimes.set(resource, Math.round(avg));
+            }
+        }
+        return {
+            totalRequests: this.metrics.totalLockRequests,
+            activeLocksCount: this.locks.size,
+            timeouts: this.metrics.lockTimeouts,
+            concurrentWaits: this.metrics.concurrentWaits,
+            avgWaitTimeByResource: Object.fromEntries(avgWaitTimes),
+            activeLocks: Array.from(this.locks.keys())
+        };
+    }
+    /**
+     * Clear all locks (use with caution - mainly for testing)
+     */
+    static clearAllLocks() {
+        this.locks.clear();
+        logger.warn('All file locks cleared - use only for testing/recovery');
+    }
+    /**
+     * Reset metrics
+     */
+    static resetMetrics() {
+        this.metrics = {
+            totalLockRequests: 0,
+            lockWaitTime: new Map(),
+            lockTimeouts: 0,
+            concurrentWaits: 0
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fileLockManager.js","sourceRoot":"","sources":["../../../../src/security/fileLockManager.ts"],"names":[],"mappings":"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","sourcesContent":["import { logger } from '../utils/logger.js';\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { randomBytes } from 'crypto';\n\n/**\n * FileLockManager - Prevents race conditions in concurrent file operations\n * \n * Features:\n * - Resource-based locking with automatic cleanup\n * - Configurable timeouts to prevent deadlocks\n * - Atomic file operations with write-rename pattern\n * - Lock queueing for concurrent requests\n * - Comprehensive error handling and logging\n * - Performance metrics tracking\n */\nexport class FileLockManager {\n  // Map of resource identifiers to their lock promises\n  private static locks = new Map<string, Promise<any>>();\n  \n  // Lock acquisition metrics for monitoring\n  private static metrics = {\n    totalLockRequests: 0,\n    lockWaitTime: new Map<string, number[]>(),\n    lockTimeouts: 0,\n    concurrentWaits: 0\n  };\n\n  // Default timeout for lock operations (10 seconds)\n  private static readonly DEFAULT_TIMEOUT_MS = 10000;\n  \n  // Temporary file directory\n  private static readonly TEMP_DIR = '.tmp';\n\n  /**\n   * Execute an operation with exclusive lock on a resource\n   * @param resource - Unique identifier for the resource (e.g., 'persona:name')\n   * @param operation - Async function to execute while holding the lock\n   * @param options - Lock options including timeout\n   * @returns Result of the operation\n   */\n  static async withLock<T>(\n    resource: string,\n    operation: () => Promise<T>,\n    options: { timeout?: number } = {}\n  ): Promise<T> {\n    const startTime = Date.now();\n    this.metrics.totalLockRequests++;\n    \n    logger.debug(`Lock requested for resource: ${resource}`);\n    \n    // Wait for any existing operation on this resource\n    const existingLock = this.locks.get(resource);\n    if (existingLock) {\n      this.metrics.concurrentWaits++;\n      logger.debug(`Waiting for existing lock on: ${resource}`);\n      \n      try {\n        await existingLock;\n      } catch (error) {\n        // Previous operation failed, but we can proceed\n        logger.debug(`Previous operation on ${resource} failed, proceeding`);\n      }\n    }\n    \n    // Create new lock for this operation\n    const timeout = options.timeout || this.DEFAULT_TIMEOUT_MS;\n    const lockPromise = this.executeWithTimeout(operation, timeout, resource);\n    this.locks.set(resource, lockPromise);\n    \n    try {\n      const result = await lockPromise;\n      \n      // Record metrics\n      const waitTime = Date.now() - startTime;\n      if (!this.metrics.lockWaitTime.has(resource)) {\n        this.metrics.lockWaitTime.set(resource, []);\n      }\n      this.metrics.lockWaitTime.get(resource)!.push(waitTime);\n      \n      logger.debug(`Lock released for resource: ${resource} (${waitTime}ms)`);\n      return result;\n    } finally {\n      // Clean up lock atomically - compare and delete in one operation\n      const currentLock = this.locks.get(resource);\n      if (currentLock === lockPromise) {\n        this.locks.delete(resource);\n        logger.debug(`Lock queue cleaned up for resource: ${resource}`);\n      }\n    }\n  }\n\n  /**\n   * Execute operation with timeout protection\n   */\n  private static async executeWithTimeout<T>(\n    operation: () => Promise<T>,\n    timeoutMs: number,\n    resource: string\n  ): Promise<T> {\n    let timeoutHandle: NodeJS.Timeout | undefined;\n    \n    const timeoutPromise = new Promise<never>((_, reject) => {\n      timeoutHandle = setTimeout(() => {\n        this.metrics.lockTimeouts++;\n        reject(new Error(`Lock operation timeout for resource: ${resource}`));\n      }, timeoutMs);\n    });\n    \n    try {\n      const result = await Promise.race([operation(), timeoutPromise]);\n      if (timeoutHandle) clearTimeout(timeoutHandle);\n      return result;\n    } catch (error) {\n      if (timeoutHandle) clearTimeout(timeoutHandle);\n      throw error;\n    }\n  }\n\n  /**\n   * Perform atomic file write operation\n   * Writes to temporary file then renames to ensure atomicity\n   */\n  static async atomicWriteFile(\n    filePath: string,\n    content: string,\n    options?: { encoding?: BufferEncoding }\n  ): Promise<void> {\n    const tempPath = await this.getTempFilePath(filePath);\n    const dir = path.dirname(tempPath);\n    \n    try {\n      // Ensure temp directory exists\n      await fs.mkdir(dir, { recursive: true });\n      \n      // Write to temporary file\n      await fs.writeFile(tempPath, content, options);\n      \n      // Atomic rename (on same filesystem)\n      await fs.rename(tempPath, filePath);\n      \n      logger.debug(`Atomic write completed: ${filePath}`);\n    } catch (error) {\n      // Clean up temp file on error\n      try {\n        await fs.unlink(tempPath);\n        logger.debug(`Cleaned up temp file after error: ${tempPath}`);\n      } catch (unlinkError) {\n        // Log cleanup failure but don't throw - original error is more important\n        logger.warn(`Failed to clean up temp file ${tempPath}: ${unlinkError}`);\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Perform atomic file read with lock\n   */\n  static async atomicReadFile(\n    filePath: string,\n    options?: { encoding?: BufferEncoding }\n  ): Promise<string> {\n    return this.withLock(`file:${filePath}`, async () => {\n      const content = await fs.readFile(filePath, options);\n      return content.toString();\n    });\n  }\n\n  /**\n   * Generate temporary file path for atomic operations\n   */\n  private static async getTempFilePath(originalPath: string): Promise<string> {\n    const dir = path.dirname(originalPath);\n    const basename = path.basename(originalPath);\n    const random = randomBytes(8).toString('hex');\n    return path.join(dir, this.TEMP_DIR, `${basename}.${random}.tmp`);\n  }\n\n  /**\n   * Get lock metrics for monitoring\n   */\n  static getMetrics() {\n    const avgWaitTimes = new Map<string, number>();\n    for (const [resource, times] of this.metrics.lockWaitTime.entries()) {\n      if (times.length > 0) {\n        const avg = times.reduce((a, b) => a + b, 0) / times.length;\n        avgWaitTimes.set(resource, Math.round(avg));\n      }\n    }\n    \n    return {\n      totalRequests: this.metrics.totalLockRequests,\n      activeLocksCount: this.locks.size,\n      timeouts: this.metrics.lockTimeouts,\n      concurrentWaits: this.metrics.concurrentWaits,\n      avgWaitTimeByResource: Object.fromEntries(avgWaitTimes),\n      activeLocks: Array.from(this.locks.keys())\n    };\n  }\n\n  /**\n   * Clear all locks (use with caution - mainly for testing)\n   */\n  static clearAllLocks(): void {\n    this.locks.clear();\n    logger.warn('All file locks cleared - use only for testing/recovery');\n  }\n\n  /**\n   * Reset metrics\n   */\n  static resetMetrics(): void {\n    this.metrics = {\n      totalLockRequests: 0,\n      lockWaitTime: new Map<string, number[]>(),\n      lockTimeouts: 0,\n      concurrentWaits: 0\n    };\n  }\n}"]}

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

@@ -0,0 +1,12 @@
+/**
+ * Security module exports
+ */
+export * from './constants.js';
+export * from './InputValidator.js';
+export * from './contentValidator.js';
+export * from './securityMonitor.js';
+export * from './commandValidator.js';
+export * from './pathValidator.js';
+export * from './yamlValidator.js';
+export * from './fileLockManager.js';
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * Security module exports
+ */
+export * from './constants.js';
+export * from './InputValidator.js';
+export * from './contentValidator.js';
+export * from './securityMonitor.js';
+export * from './commandValidator.js';
+export * from './pathValidator.js';
+export * from './yamlValidator.js';
+export * from './fileLockManager.js';
+// Export security functionality when ready
+// export * from './RateLimiter.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2VjdXJpdHkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsMkNBQTJDO0FBQzNDLG9DQUFvQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogU2VjdXJpdHkgbW9kdWxlIGV4cG9ydHNcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2NvbnN0YW50cy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL0lucHV0VmFsaWRhdG9yLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vY29udGVudFZhbGlkYXRvci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NlY3VyaXR5TW9uaXRvci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2NvbW1hbmRWYWxpZGF0b3IuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9wYXRoVmFsaWRhdG9yLmpzJztcbmV4cG9ydCAqIGZyb20gJy4veWFtbFZhbGlkYXRvci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2ZpbGVMb2NrTWFuYWdlci5qcyc7XG4vLyBFeHBvcnQgc2VjdXJpdHkgZnVuY3Rpb25hbGl0eSB3aGVuIHJlYWR5XG4vLyBleHBvcnQgKiBmcm9tICcuL1JhdGVMaW1pdGVyLmpzJzsiXX0=

package/dist/test/src/security/pathValidator.d.ts

@@ -0,0 +1,9 @@
+export declare class PathValidator {
+    private static ALLOWED_DIRECTORIES;
+    private static ALLOWED_EXTENSIONS;
+    static initialize(personasDir: string, allowedExtensions?: string[]): void;
+    static validatePersonaPath(userPath: string): Promise<string>;
+    static safeReadFile(filePath: string): Promise<string>;
+    static safeWriteFile(filePath: string, content: string): Promise<void>;
+}
+//# sourceMappingURL=pathValidator.d.ts.map

package/dist/test/src/security/pathValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathValidator.d.ts","sourceRoot":"","sources":["../../../../src/security/pathValidator.ts"],"names":[],"mappings":"AAKA,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAgB;IAClD,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAA2D;IAE5F,MAAM,CAAC,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI;WAc7D,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;WA8DtD,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;WAiB/C,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAmB7E"}

package/dist/test/src/security/pathValidator.js

@@ -0,0 +1,98 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { logger } from '../utils/logger.js';
+import { RegexValidator } from './regexValidator.js';
+export class PathValidator {
+    static ALLOWED_DIRECTORIES = [];
+    static ALLOWED_EXTENSIONS = ['.md', '.markdown', '.txt', '.yml', '.yaml'];
+    static initialize(personasDir, allowedExtensions) {
+        this.ALLOWED_DIRECTORIES = [
+            path.resolve(personasDir),
+            path.resolve('./personas'),
+            path.resolve('./custom-personas'),
+            path.resolve('./backups'),
+            path.resolve(process.env.PERSONAS_DIR || './personas')
+        ];
+        if (allowedExtensions) {
+            this.ALLOWED_EXTENSIONS = allowedExtensions;
+        }
+    }
+    static async validatePersonaPath(userPath) {
+        if (!userPath || typeof userPath !== 'string') {
+            throw new Error('Path must be a non-empty string');
+        }
+        // Remove any null bytes
+        const cleanPath = userPath.replace(/\x00/g, '');
+        // Normalize and resolve path
+        const normalizedPath = path.normalize(cleanPath);
+        const resolvedPath = path.resolve(normalizedPath);
+        // Check for path traversal attempts
+        if (normalizedPath.includes('..') || cleanPath.includes('..')) {
+            logger.warn('Path traversal attempt detected', { userPath });
+            throw new Error('Path traversal detected');
+        }
+        // Check if path is within allowed directories
+        if (this.ALLOWED_DIRECTORIES.length === 0) {
+            // If not initialized, allow paths under current working directory's personas folder
+            const defaultAllowed = [
+                path.resolve('./personas'),
+                path.resolve(process.env.PERSONAS_DIR || './personas')
+            ];
+            const isAllowed = defaultAllowed.some(allowedDir => resolvedPath.startsWith(allowedDir + path.sep) ||
+                resolvedPath === allowedDir);
+            if (!isAllowed) {
+                throw new Error(`Path access denied: ${userPath}`);
+            }
+        }
+        else {
+            const isAllowed = this.ALLOWED_DIRECTORIES.some(allowedDir => resolvedPath.startsWith(allowedDir + path.sep) ||
+                resolvedPath === allowedDir);
+            if (!isAllowed) {
+                throw new Error(`Path access denied: ${userPath}`);
+            }
+        }
+        // Validate filename if it's a file
+        if (path.extname(resolvedPath)) {
+            const filename = path.basename(resolvedPath);
+            const ext = path.extname(filename).toLowerCase();
+            // Check if extension is allowed
+            if (!this.ALLOWED_EXTENSIONS.includes(ext)) {
+                throw new Error(`File extension not allowed: ${ext}. Allowed: ${this.ALLOWED_EXTENSIONS.join(', ')}`);
+            }
+            // Validate filename format (alphanumeric, dash, underscore, dot)
+            if (!RegexValidator.validate(filename, /^[a-zA-Z0-9\-_.]+$/i, { maxLength: 255 })) {
+                throw new Error(`Invalid filename format: ${filename}`);
+            }
+        }
+        return resolvedPath;
+    }
+    static async safeReadFile(filePath) {
+        const validatedPath = await this.validatePersonaPath(filePath);
+        // Check file exists and is not a directory
+        const stats = await fs.stat(validatedPath);
+        if (stats.isDirectory()) {
+            throw new Error('Path is a directory, not a file');
+        }
+        // Size check
+        if (stats.size > 500000) { // 500KB
+            throw new Error('File too large');
+        }
+        return fs.readFile(validatedPath, 'utf-8');
+    }
+    static async safeWriteFile(filePath, content) {
+        const validatedPath = await this.validatePersonaPath(filePath);
+        // Content validation
+        if (content.length > 500000) {
+            throw new Error('Content too large');
+        }
+        // Ensure directory exists before atomic write
+        const dirPath = path.dirname(validatedPath);
+        await fs.mkdir(dirPath, { recursive: true });
+        // Write to temp file first (atomic write)
+        const tempPath = `${validatedPath}.tmp`;
+        await fs.writeFile(tempPath, content, 'utf-8');
+        // Rename to final path (atomic on most filesystems)
+        await fs.rename(tempPath, validatedPath);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pathValidator.js","sourceRoot":"","sources":["../../../../src/security/pathValidator.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'path';\nimport fs from 'fs/promises';\nimport { logger } from '../utils/logger.js';\nimport { RegexValidator } from './regexValidator.js';\n\nexport class PathValidator {\n  private static ALLOWED_DIRECTORIES: string[] = [];\n  private static ALLOWED_EXTENSIONS: string[] = ['.md', '.markdown', '.txt', '.yml', '.yaml'];\n  \n  static initialize(personasDir: string, allowedExtensions?: string[]): void {\n    this.ALLOWED_DIRECTORIES = [\n      path.resolve(personasDir),\n      path.resolve('./personas'),\n      path.resolve('./custom-personas'),\n      path.resolve('./backups'),\n      path.resolve(process.env.PERSONAS_DIR || './personas')\n    ];\n    \n    if (allowedExtensions) {\n      this.ALLOWED_EXTENSIONS = allowedExtensions;\n    }\n  }\n\n  static async validatePersonaPath(userPath: string): Promise<string> {\n    if (!userPath || typeof userPath !== 'string') {\n      throw new Error('Path must be a non-empty string');\n    }\n\n    // Remove any null bytes\n    const cleanPath = userPath.replace(/\\x00/g, '');\n    \n    // Normalize and resolve path\n    const normalizedPath = path.normalize(cleanPath);\n    const resolvedPath = path.resolve(normalizedPath);\n    \n    // Check for path traversal attempts\n    if (normalizedPath.includes('..') || cleanPath.includes('..')) {\n      logger.warn('Path traversal attempt detected', { userPath });\n      throw new Error('Path traversal detected');\n    }\n    \n    // Check if path is within allowed directories\n    if (this.ALLOWED_DIRECTORIES.length === 0) {\n      // If not initialized, allow paths under current working directory's personas folder\n      const defaultAllowed = [\n        path.resolve('./personas'),\n        path.resolve(process.env.PERSONAS_DIR || './personas')\n      ];\n      const isAllowed = defaultAllowed.some(allowedDir => \n        resolvedPath.startsWith(allowedDir + path.sep) || \n        resolvedPath === allowedDir\n      );\n      if (!isAllowed) {\n        throw new Error(`Path access denied: ${userPath}`);\n      }\n    } else {\n      const isAllowed = this.ALLOWED_DIRECTORIES.some(allowedDir => \n        resolvedPath.startsWith(allowedDir + path.sep) || \n        resolvedPath === allowedDir\n      );\n      \n      if (!isAllowed) {\n        throw new Error(`Path access denied: ${userPath}`);\n      }\n    }\n    \n    // Validate filename if it's a file\n    if (path.extname(resolvedPath)) {\n      const filename = path.basename(resolvedPath);\n      const ext = path.extname(filename).toLowerCase();\n      \n      // Check if extension is allowed\n      if (!this.ALLOWED_EXTENSIONS.includes(ext)) {\n        throw new Error(`File extension not allowed: ${ext}. Allowed: ${this.ALLOWED_EXTENSIONS.join(', ')}`);\n      }\n      \n      // Validate filename format (alphanumeric, dash, underscore, dot)\n      if (!RegexValidator.validate(filename, /^[a-zA-Z0-9\\-_.]+$/i, { maxLength: 255 })) {\n        throw new Error(`Invalid filename format: ${filename}`);\n      }\n    }\n    \n    return resolvedPath;\n  }\n\n  static async safeReadFile(filePath: string): Promise<string> {\n    const validatedPath = await this.validatePersonaPath(filePath);\n    \n    // Check file exists and is not a directory\n    const stats = await fs.stat(validatedPath);\n    if (stats.isDirectory()) {\n      throw new Error('Path is a directory, not a file');\n    }\n    \n    // Size check\n    if (stats.size > 500000) { // 500KB\n      throw new Error('File too large');\n    }\n    \n    return fs.readFile(validatedPath, 'utf-8');\n  }\n\n  static async safeWriteFile(filePath: string, content: string): Promise<void> {\n    const validatedPath = await this.validatePersonaPath(filePath);\n    \n    // Content validation\n    if (content.length > 500000) {\n      throw new Error('Content too large');\n    }\n    \n    // Ensure directory exists before atomic write\n    const dirPath = path.dirname(validatedPath);\n    await fs.mkdir(dirPath, { recursive: true });\n    \n    // Write to temp file first (atomic write)\n    const tempPath = `${validatedPath}.tmp`;\n    await fs.writeFile(tempPath, content, 'utf-8');\n    \n    // Rename to final path (atomic on most filesystems)\n    await fs.rename(tempPath, validatedPath);\n  }\n}"]}

package/dist/test/src/security/regexValidator.d.ts

@@ -0,0 +1,59 @@
+/**
+ * RegexValidator - Provides protection against ReDoS attacks
+ *
+ * This module implements safe regex execution by:
+ * 1. Pre-validating content length based on pattern complexity
+ * 2. Analyzing patterns for known ReDoS vulnerabilities
+ * 3. Limiting execution based on calculated risk
+ */
+export interface RegexValidationOptions {
+    /** Maximum content length allowed */
+    maxLength?: number;
+    /** Reject patterns with high ReDoS risk */
+    rejectDangerousPatterns?: boolean;
+    /** Log security events */
+    logEvents?: boolean;
+}
+interface PatternAnalysis {
+    safe: boolean;
+    risks: string[];
+    complexity: 'low' | 'medium' | 'high';
+    maxSafeLength: number;
+}
+export declare class RegexValidator {
+    private static readonly COMPLEXITY_LIMITS;
+    /**
+     * Validates content against a pattern with ReDoS protection
+     *
+     * Protection strategy:
+     * 1. Analyze pattern complexity
+     * 2. Enforce content length limits based on complexity
+     * 3. Reject known dangerous patterns
+     * 4. Execute regex only if safe
+     */
+    static validate(content: string, pattern: RegExp, options?: RegexValidationOptions): boolean;
+    /**
+     * Validates multiple patterns with shared risk assessment
+     */
+    static validateAny(content: string, patterns: RegExp[], options?: RegexValidationOptions): boolean;
+    /**
+     * Validates all patterns must match
+     */
+    static validateAll(content: string, patterns: RegExp[], options?: RegexValidationOptions): boolean;
+    /**
+     * Analyzes a regex pattern for potential ReDoS vulnerabilities
+     *
+     * Detects patterns known to cause exponential backtracking:
+     * - Nested quantifiers: (a+)+, (a*)*
+     * - Alternation with overlap: (a|a)*
+     * - Quantified groups with alternation: (a|b)+
+     * - Catastrophic patterns: (.+)+$
+     */
+    static analyzePattern(pattern: RegExp): PatternAnalysis;
+    /**
+     * Creates a regex pattern with safety analysis
+     */
+    static createSafePattern(pattern: string, flags?: string): RegExp;
+}
+export {};
+//# sourceMappingURL=regexValidator.d.ts.map

package/dist/test/src/security/regexValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regexValidator.d.ts","sourceRoot":"","sources":["../../../../src/security/regexValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,MAAM,WAAW,sBAAsB;IACrC,qCAAqC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,0BAA0B;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,UAAU,eAAe;IACvB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACtC,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,cAAc;IAEzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAIvC;IAEF;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,CACb,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,sBAA2B,GACnC,OAAO;IAiFV;;OAEG;IACH,MAAM,CAAC,WAAW,CAChB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,GAAE,sBAA2B,GACnC,OAAO;IASV;;OAEG;IACH,MAAM,CAAC,WAAW,CAChB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,GAAE,sBAA2B,GACnC,OAAO;IASV;;;;;;;;OAQG;IACH,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe;IA4EvD;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;CAmBlE"}