@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/utils/SecureDownloader.js

@@ -0,0 +1,759 @@
+/**
+ * SecureDownloader - Reusable utility for safe content downloads
+ *
+ * Implements the validate-before-write pattern with comprehensive security features:
+ * - Content validation hooks (customizable validators)
+ * - Atomic file operations with temp files
+ * - Guaranteed cleanup on failure
+ * - Memory-efficient streaming for large files
+ * - Size limits to prevent DoS attacks
+ * - Path validation to prevent traversal
+ * - Timeout handling for network operations
+ * - Content type validation
+ *
+ * Usage Examples:
+ *
+ * // Basic download with validation
+ * const downloader = new SecureDownloader();
+ * await downloader.downloadToFile(
+ *   'https://example.com/file.md',
+ *   './downloads/file.md',
+ *   {
+ *     validator: async (content) => ({
+ *       isValid: !content.includes('malicious'),
+ *       errorMessage: content.includes('malicious') ? 'Malicious content detected' : undefined
+ *     }),
+ *     maxSize: 1024 * 1024, // 1MB limit
+ *     timeout: 30000 // 30 second timeout
+ *   }
+ * );
+ *
+ * // Download to memory with validation
+ * const content = await downloader.downloadToMemory(
+ *   'https://example.com/data.json',
+ *   {
+ *     validator: async (content) => {
+ *       try {
+ *         JSON.parse(content);
+ *         return { isValid: true };
+ *       } catch {
+ *         return { isValid: false, errorMessage: 'Invalid JSON format' };
+ *       }
+ *     }
+ *   }
+ * );
+ *
+ * // Streaming download for large files
+ * await downloader.downloadStream(
+ *   'https://example.com/large-file.zip',
+ *   './downloads/large-file.zip',
+ *   {
+ *     streamValidator: (chunk) => !chunk.includes(Buffer.from('VIRUS')),
+ *     maxSize: 100 * 1024 * 1024, // 100MB limit
+ *     timeout: 300000 // 5 minute timeout
+ *   }
+ * );
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { randomBytes, createHash } from 'crypto';
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+import { createWriteStream } from 'fs';
+import { SecurityError } from '../errors/SecurityError.js';
+import { SECURITY_LIMITS } from '../security/constants.js';
+import { ContentValidator as SecurityContentValidator } from '../security/contentValidator.js';
+import { PathValidator } from '../security/pathValidator.js';
+import { FileLockManager } from '../security/fileLockManager.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { RateLimiter } from './RateLimiter.js';
+import { logger } from './logger.js';
+/**
+ * Custom error types for different failure scenarios
+ */
+export class DownloadError extends Error {
+    code;
+    originalError;
+    constructor(message, code, originalError) {
+        super(message);
+        this.code = code;
+        this.originalError = originalError;
+        this.name = 'DownloadError';
+    }
+    static networkError(message, originalError) {
+        return new DownloadError(message, 'NETWORK_ERROR', originalError);
+    }
+    static validationError(message) {
+        return new DownloadError(message, 'VALIDATION_ERROR');
+    }
+    static securityError(message) {
+        return new DownloadError(message, 'SECURITY_ERROR');
+    }
+    static timeoutError(message) {
+        return new DownloadError(message, 'TIMEOUT_ERROR');
+    }
+    static filesystemError(message, originalError) {
+        return new DownloadError(message, 'FILESYSTEM_ERROR', originalError);
+    }
+}
+/**
+ * SecureDownloader - Implements validate-before-write pattern for safe downloads
+ *
+ * Key Security Features:
+ * 1. VALIDATE-BEFORE-WRITE: All content validation occurs before any disk operations
+ * 2. ATOMIC OPERATIONS: Uses temporary files with atomic rename to prevent corruption
+ * 3. GUARANTEED CLEANUP: Automatic cleanup of temporary files on any failure
+ * 4. SIZE LIMITS: Prevents DoS attacks through large file downloads
+ * 5. PATH VALIDATION: Prevents directory traversal attacks
+ * 6. TIMEOUT PROTECTION: Prevents hanging network operations
+ * 7. CONTENT VALIDATION: Extensible validation system for different content types
+ */
+export class SecureDownloader {
+    defaultTimeout;
+    defaultMaxSize;
+    tempDir;
+    globalRateLimiter;
+    urlRateLimiters;
+    constructor(options) {
+        this.defaultTimeout = options?.defaultTimeout || 30000; // 30 seconds
+        this.defaultMaxSize = options?.defaultMaxSize || SECURITY_LIMITS.MAX_FILE_SIZE;
+        this.tempDir = options?.tempDir || '.tmp';
+        // Initialize rate limiters
+        const rateLimitConfig = options?.rateLimitOptions || {};
+        this.globalRateLimiter = new RateLimiter({
+            maxRequests: rateLimitConfig.maxGlobalRequests || 100, // 100 downloads per hour globally
+            windowMs: rateLimitConfig.windowMs || 60 * 60 * 1000, // 1 hour
+            minDelayMs: 1000 // Minimum 1 second between requests
+        });
+        this.urlRateLimiters = new Map();
+    }
+    /**
+     * Download content to a file with validation
+     *
+     * SECURITY: Implements validate-before-write pattern:
+     * 1. Download content to memory
+     * 2. Validate all content
+     * 3. Only then write to disk atomically
+     *
+     * @param url - URL to download from
+     * @param destinationPath - Local file path to save to
+     * @param options - Download and validation options
+     */
+    async downloadToFile(url, destinationPath, options = {}) {
+        const startTime = Date.now();
+        logger.debug(`Starting secure download from ${url} to ${destinationPath}`);
+        try {
+            // SECURITY: Validate URL and destination path first
+            this.validateUrl(url);
+            const validatedPath = await this.validateDestinationPath(destinationPath);
+            // SECURITY: Check if file already exists (prevent accidental overwrites)
+            try {
+                await fs.access(validatedPath);
+                throw DownloadError.filesystemError(`File already exists: ${destinationPath}`);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error; // Re-throw if it's not a "file not found" error
+                }
+                // File doesn't exist, proceed with download
+            }
+            // STEP 1: Check rate limits before download
+            await this.checkRateLimit(url);
+            // STEP 2: Download content to memory (no disk operations yet)
+            const content = await this.downloadToMemory(url, options);
+            // STEP 3: Validate checksum if provided
+            if (options.expectedChecksum) {
+                await this.validateChecksum(content, options.expectedChecksum);
+            }
+            // STEP 4: All validation is complete, now write atomically
+            const useAtomic = options.atomic !== false; // Default to true
+            if (useAtomic) {
+                await this.atomicWriteFile(validatedPath, content);
+            }
+            else {
+                await this.directWriteFile(validatedPath, content);
+            }
+            const duration = Date.now() - startTime;
+            logger.info(`Secure download completed: ${destinationPath} (${content.length} bytes, ${duration}ms)`);
+            // Log successful download for security monitoring
+            SecurityMonitor.logSecurityEvent({
+                type: 'FILE_COPIED',
+                severity: 'LOW',
+                source: 'secure_downloader',
+                details: `Downloaded ${content.length} bytes from ${url} to ${destinationPath}`,
+                metadata: {
+                    url,
+                    destinationPath,
+                    contentLength: content.length,
+                    duration
+                }
+            });
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            logger.error(`Secure download failed: ${error instanceof Error ? error.message : String(error)}`);
+            // Log failed download for security monitoring
+            SecurityMonitor.logSecurityEvent({
+                type: 'PATH_TRAVERSAL_ATTEMPT',
+                severity: 'MEDIUM',
+                source: 'secure_downloader',
+                details: `Download failed: ${error instanceof Error ? error.message : String(error)}`,
+                metadata: {
+                    url,
+                    destinationPath,
+                    duration,
+                    errorType: error instanceof DownloadError ? error.code : 'UNKNOWN'
+                }
+            });
+            throw error;
+        }
+    }
+    /**
+     * Download content to memory with validation
+     *
+     * @param url - URL to download from
+     * @param options - Download and validation options
+     * @returns Validated content as string
+     */
+    async downloadToMemory(url, options = {}) {
+        const timeout = options.timeout || this.defaultTimeout;
+        const maxSize = options.maxSize || this.defaultMaxSize;
+        logger.debug(`Downloading content from ${url} (max: ${maxSize} bytes, timeout: ${timeout}ms)`);
+        try {
+            // SECURITY: Validate URL format
+            this.validateUrl(url);
+            // STEP 1: Check rate limits before download
+            await this.checkRateLimit(url);
+            // STEP 2: Fetch content with size and timeout protection
+            const content = await this.fetchWithLimits(url, maxSize, timeout, options.headers);
+            // STEP 3: Validate content type if specified
+            if (options.expectedContentType) {
+                await this.validateContentType(content, options.expectedContentType);
+            }
+            // STEP 4: Validate checksum if provided
+            if (options.expectedChecksum) {
+                await this.validateChecksum(content, options.expectedChecksum);
+            }
+            // STEP 5: Run built-in security validation
+            const securityResult = SecurityContentValidator.validateAndSanitize(content);
+            if (!securityResult.isValid && securityResult.severity === 'critical') {
+                throw DownloadError.securityError(`Critical security threat detected: ${securityResult.detectedPatterns?.join(', ')}`);
+            }
+            // STEP 6: Run custom validator if provided
+            if (options.validator) {
+                logger.debug('Running custom content validation');
+                const validationResult = await options.validator(content);
+                if (!validationResult.isValid) {
+                    throw DownloadError.validationError(validationResult.errorMessage || 'Content validation failed');
+                }
+            }
+            logger.debug(`Content validation passed (${content.length} bytes)`);
+            return securityResult.sanitizedContent || content;
+        }
+        catch (error) {
+            if (error instanceof DownloadError) {
+                throw error;
+            }
+            throw DownloadError.networkError(`Failed to download content from ${url}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Download large files using streaming with chunk-level validation
+     *
+     * @param url - URL to download from
+     * @param destinationPath - Local file path to save to
+     * @param options - Streaming download options
+     */
+    async downloadStream(url, destinationPath, options = {}) {
+        const startTime = Date.now();
+        const maxSize = options.maxSize || this.defaultMaxSize;
+        const timeout = options.timeout || this.defaultTimeout;
+        logger.debug(`Starting streaming download from ${url} to ${destinationPath}`);
+        try {
+            // SECURITY: Check rate limits before download
+            await this.checkRateLimit(url);
+            // SECURITY: Validate URL and destination path
+            this.validateUrl(url);
+            const validatedPath = await this.validateDestinationPath(destinationPath);
+            // Generate temporary file path for atomic operation
+            const tempPath = await this.getTempFilePath(validatedPath);
+            let downloadedSize = 0;
+            let timeoutHandle;
+            // Create abort controller for timeout handling
+            const abortController = new AbortController();
+            timeoutHandle = setTimeout(() => {
+                abortController.abort();
+            }, timeout);
+            try {
+                // SECURITY: Fetch with abort signal for timeout
+                const response = await fetch(url, {
+                    signal: abortController.signal,
+                    headers: options.headers
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                if (!response.body) {
+                    throw new Error('Response body is null');
+                }
+                // Ensure temp directory exists
+                await fs.mkdir(path.dirname(tempPath), { recursive: true });
+                // Create write stream to temporary file
+                const writeStream = createWriteStream(tempPath);
+                // Create a transform stream for validation and size checking
+                const validationStream = new Readable({
+                    async read() {
+                        // This stream will be fed by the pipeline
+                    }
+                });
+                // Set up chunk validation and size checking
+                const reader = response.body.getReader();
+                const pump = async () => {
+                    try {
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done)
+                                break;
+                            // SECURITY: Check size limit
+                            downloadedSize += value.length;
+                            if (downloadedSize > maxSize) {
+                                throw DownloadError.securityError(`File size exceeds limit: ${downloadedSize} > ${maxSize} bytes`);
+                            }
+                            // SECURITY: Run chunk validator if provided
+                            if (options.streamValidator && !options.streamValidator(value)) {
+                                throw DownloadError.validationError('Chunk validation failed');
+                            }
+                            validationStream.push(value);
+                        }
+                        validationStream.push(null); // End stream
+                    }
+                    catch (error) {
+                        validationStream.destroy(error instanceof Error ? error : new Error(String(error)));
+                    }
+                };
+                // Start the pump and pipeline concurrently
+                const [pumpResult] = await Promise.all([
+                    pump(),
+                    pipeline(validationStream, writeStream)
+                ]);
+                // Clear timeout
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                    timeoutHandle = undefined;
+                }
+                // SECURITY: Atomic rename to final destination
+                await fs.rename(tempPath, validatedPath);
+                const duration = Date.now() - startTime;
+                logger.info(`Streaming download completed: ${destinationPath} (${downloadedSize} bytes, ${duration}ms)`);
+                // Log successful streaming download
+                SecurityMonitor.logSecurityEvent({
+                    type: 'FILE_COPIED',
+                    severity: 'LOW',
+                    source: 'secure_downloader',
+                    details: `Streamed ${downloadedSize} bytes from ${url} to ${destinationPath}`,
+                    metadata: {
+                        url,
+                        destinationPath,
+                        contentLength: downloadedSize,
+                        duration
+                    }
+                });
+            }
+            catch (error) {
+                // SECURITY: Guaranteed cleanup of temporary file
+                try {
+                    await fs.unlink(tempPath);
+                    logger.debug(`Cleaned up temp file: ${tempPath}`);
+                }
+                catch (cleanupError) {
+                    logger.warn(`Failed to clean up temp file ${tempPath}: ${cleanupError}`);
+                }
+                throw error;
+            }
+            finally {
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+            }
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            logger.error(`Streaming download failed: ${error instanceof Error ? error.message : String(error)}`);
+            // Log failed streaming download
+            SecurityMonitor.logSecurityEvent({
+                type: 'PATH_TRAVERSAL_ATTEMPT',
+                severity: 'MEDIUM',
+                source: 'secure_downloader',
+                details: `Streaming download failed: ${error instanceof Error ? error.message : String(error)}`,
+                metadata: {
+                    url,
+                    destinationPath,
+                    duration,
+                    errorType: error instanceof DownloadError ? error.code : 'UNKNOWN'
+                }
+            });
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw DownloadError.timeoutError(`Download timed out after ${timeout}ms`);
+            }
+            if (error instanceof DownloadError) {
+                throw error;
+            }
+            throw DownloadError.networkError(`Streaming download failed: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Validate URL format and security with Unicode normalization
+     */
+    validateUrl(url) {
+        if (!url || typeof url !== 'string') {
+            throw DownloadError.validationError('URL must be a non-empty string');
+        }
+        // SECURITY FIX: DMCP-SEC-004 - Unicode normalization on user input
+        const unicodeValidation = UnicodeValidator.normalize(url);
+        const normalizedUrl = unicodeValidation.normalizedContent;
+        if (!unicodeValidation.isValid) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'UNICODE_VALIDATION_ERROR',
+                severity: 'MEDIUM',
+                source: 'secure_downloader',
+                details: `URL contains suspicious Unicode patterns: ${unicodeValidation.detectedIssues?.join(', ')}`,
+                metadata: { originalUrl: url, normalizedUrl }
+            });
+        }
+        // Use normalized URL for further validation
+        url = normalizedUrl;
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(url);
+        }
+        catch (error) {
+            throw DownloadError.validationError(`Invalid URL format: ${url}`);
+        }
+        // SECURITY: Only allow HTTPS and HTTP protocols
+        if (!['https:', 'http:'].includes(parsedUrl.protocol)) {
+            throw DownloadError.securityError(`Unsupported protocol: ${parsedUrl.protocol}. Only HTTP/HTTPS allowed.`);
+        }
+        // SECURITY: Prevent requests to localhost/private networks
+        const hostname = parsedUrl.hostname.toLowerCase();
+        if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '::1') {
+            throw DownloadError.securityError('Downloads from localhost are not allowed');
+        }
+        // SECURITY: Check for private IP ranges (basic protection)
+        if (hostname.startsWith('192.168.') || hostname.startsWith('10.') || hostname.startsWith('172.')) {
+            throw DownloadError.securityError('Downloads from private IP ranges are not allowed');
+        }
+    }
+    /**
+     * Validate destination path for security
+     */
+    async validateDestinationPath(filePath) {
+        try {
+            // Use existing PathValidator for comprehensive path validation
+            return await PathValidator.validatePersonaPath(filePath);
+        }
+        catch (error) {
+            throw DownloadError.securityError(`Invalid destination path: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Fetch content with size and timeout limits
+     */
+    async fetchWithLimits(url, maxSize, timeout, headers) {
+        const abortController = new AbortController();
+        const timeoutHandle = setTimeout(() => abortController.abort(), timeout);
+        try {
+            const response = await fetch(url, {
+                signal: abortController.signal,
+                headers: {
+                    'User-Agent': 'DollhouseMCP-SecureDownloader/1.0',
+                    ...headers
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            // SECURITY: Check Content-Length header if available
+            const contentLength = response.headers.get('content-length');
+            if (contentLength && parseInt(contentLength, 10) > maxSize) {
+                throw DownloadError.securityError(`Content size ${contentLength} exceeds limit of ${maxSize} bytes`);
+            }
+            // Read content with size checking
+            const chunks = [];
+            let totalSize = 0;
+            if (!response.body) {
+                throw new Error('Response body is null');
+            }
+            const reader = response.body.getReader();
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    totalSize += value.length;
+                    if (totalSize > maxSize) {
+                        throw DownloadError.securityError(`Content size ${totalSize} exceeds limit of ${maxSize} bytes`);
+                    }
+                    chunks.push(value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            // Combine chunks and decode
+            const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+            const combined = new Uint8Array(totalLength);
+            let offset = 0;
+            for (const chunk of chunks) {
+                combined.set(chunk, offset);
+                offset += chunk.length;
+            }
+            return new TextDecoder('utf-8').decode(combined);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw DownloadError.timeoutError(`Request timed out after ${timeout}ms`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutHandle);
+        }
+    }
+    /**
+     * Validate content type if specified
+     */
+    async validateContentType(content, expectedType) {
+        // Basic content type validation based on content analysis
+        switch (expectedType.toLowerCase()) {
+            case 'json':
+                try {
+                    JSON.parse(content);
+                }
+                catch {
+                    throw DownloadError.validationError('Content is not valid JSON');
+                }
+                break;
+            case 'yaml':
+            case 'yml':
+                // Use existing YAML validation
+                if (!SecurityContentValidator.validateYamlContent(content)) {
+                    throw DownloadError.validationError('Content is not valid YAML');
+                }
+                break;
+            case 'markdown':
+            case 'md':
+                // Basic markdown validation (check for frontmatter format)
+                if (content.startsWith('---')) {
+                    const frontmatterEnd = content.indexOf('\n---\n', 3);
+                    if (frontmatterEnd === -1) {
+                        throw DownloadError.validationError('Invalid markdown frontmatter format');
+                    }
+                }
+                break;
+            default:
+                logger.debug(`No specific validation for content type: ${expectedType}`);
+        }
+    }
+    /**
+     * Atomic file write using FileLockManager
+     */
+    async atomicWriteFile(filePath, content) {
+        const resource = `download:${filePath}`;
+        await FileLockManager.withLock(resource, async () => {
+            // Ensure directory exists
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            // Use FileLockManager's atomic write
+            await FileLockManager.atomicWriteFile(filePath, content, { encoding: 'utf-8' });
+        });
+    }
+    /**
+     * Direct file write (non-atomic, for when atomic is disabled)
+     */
+    async directWriteFile(filePath, content) {
+        // Ensure directory exists
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        // Direct write
+        await fs.writeFile(filePath, content, 'utf-8');
+    }
+    /**
+     * Generate temporary file path for atomic operations
+     */
+    async getTempFilePath(originalPath) {
+        const dir = path.dirname(originalPath);
+        const basename = path.basename(originalPath);
+        const random = randomBytes(8).toString('hex');
+        const tempDir = path.join(dir, this.tempDir);
+        // Ensure temp directory exists
+        await fs.mkdir(tempDir, { recursive: true });
+        return path.join(tempDir, `${basename}.${random}.tmp`);
+    }
+    /**
+     * Check rate limits for downloads
+     */
+    async checkRateLimit(url) {
+        // Check global rate limit
+        const globalStatus = this.globalRateLimiter.checkLimit();
+        if (!globalStatus.allowed) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'RATE_LIMIT_EXCEEDED',
+                severity: 'MEDIUM',
+                source: 'secure_downloader',
+                details: `Global download rate limit exceeded. Retry after ${globalStatus.retryAfterMs}ms`,
+                metadata: { url, retryAfterMs: globalStatus.retryAfterMs }
+            });
+            throw DownloadError.securityError(`Download rate limit exceeded. Please retry after ${Math.ceil(globalStatus.retryAfterMs / 1000)} seconds`);
+        }
+        // Check per-URL rate limit
+        const parsedUrl = new URL(url);
+        const urlKey = `${parsedUrl.hostname}:${parsedUrl.port || (parsedUrl.protocol === 'https:' ? '443' : '80')}`;
+        if (!this.urlRateLimiters.has(urlKey)) {
+            this.urlRateLimiters.set(urlKey, new RateLimiter({
+                maxRequests: 10, // 10 requests per hour per URL
+                windowMs: 60 * 60 * 1000,
+                minDelayMs: 5000 // 5 second minimum delay between requests to same URL
+            }));
+        }
+        const urlLimiter = this.urlRateLimiters.get(urlKey);
+        const urlStatus = urlLimiter.checkLimit();
+        if (!urlStatus.allowed) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'RATE_LIMIT_EXCEEDED',
+                severity: 'MEDIUM',
+                source: 'secure_downloader',
+                details: `Per-URL download rate limit exceeded for ${urlKey}. Retry after ${urlStatus.retryAfterMs}ms`,
+                metadata: { url, urlKey, retryAfterMs: urlStatus.retryAfterMs }
+            });
+            throw DownloadError.securityError(`Too many requests to ${urlKey}. Please retry after ${Math.ceil(urlStatus.retryAfterMs / 1000)} seconds`);
+        }
+        // Consume rate limit tokens
+        this.globalRateLimiter.consumeToken();
+        urlLimiter.consumeToken();
+    }
+    /**
+     * Validate content checksum for integrity verification
+     */
+    async validateChecksum(content, expectedChecksum) {
+        const normalizedExpected = expectedChecksum.toLowerCase().trim();
+        // Validate checksum format (SHA-256 should be 64 hex characters)
+        if (!/^[a-f0-9]{64}$/.test(normalizedExpected)) {
+            throw DownloadError.validationError('Invalid checksum format. Expected SHA-256 (64 hex characters)');
+        }
+        const contentBuffer = Buffer.from(content, 'utf-8');
+        const actualChecksum = createHash('sha256').update(contentBuffer).digest('hex');
+        if (actualChecksum !== normalizedExpected) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'CONTENT_INJECTION_ATTEMPT',
+                severity: 'HIGH',
+                source: 'secure_downloader',
+                details: `Checksum mismatch detected - possible content tampering`,
+                metadata: {
+                    expectedChecksum: normalizedExpected,
+                    actualChecksum,
+                    contentLength: content.length
+                }
+            });
+            throw DownloadError.securityError(`Content checksum verification failed. Expected: ${normalizedExpected}, Got: ${actualChecksum}`);
+        }
+        logger.debug(`Checksum validation passed: ${actualChecksum}`);
+    }
+    /**
+     * Create a content validator that combines multiple validators
+     */
+    static combineValidators(...validators) {
+        return async (content) => {
+            for (const validator of validators) {
+                const result = await validator(content);
+                if (!result.isValid) {
+                    return result;
+                }
+            }
+            return { isValid: true };
+        };
+    }
+    /**
+     * Create a content validator for JSON content
+     */
+    static jsonValidator() {
+        return async (content) => {
+            try {
+                JSON.parse(content);
+                return { isValid: true };
+            }
+            catch (error) {
+                return {
+                    isValid: false,
+                    errorMessage: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
+                    severity: 'medium'
+                };
+            }
+        };
+    }
+    /**
+     * Create a content validator for YAML content
+     */
+    static yamlValidator() {
+        return async (content) => {
+            const isValid = SecurityContentValidator.validateYamlContent(content);
+            return {
+                isValid,
+                errorMessage: isValid ? undefined : 'Invalid or malicious YAML content',
+                severity: isValid ? 'low' : 'high'
+            };
+        };
+    }
+    /**
+     * Create a content validator for markdown content
+     */
+    static markdownValidator() {
+        return async (content) => {
+            try {
+                // Use existing persona content sanitization for markdown
+                SecurityContentValidator.sanitizePersonaContent(content);
+                return { isValid: true };
+            }
+            catch (error) {
+                return {
+                    isValid: false,
+                    errorMessage: `Invalid markdown: ${error instanceof Error ? error.message : String(error)}`,
+                    severity: error instanceof SecurityError ? 'critical' : 'medium'
+                };
+            }
+        };
+    }
+    /**
+     * Create a content validator with size limits
+     */
+    static sizeValidator(maxSize) {
+        return async (content) => {
+            const size = Buffer.byteLength(content, 'utf-8');
+            if (size > maxSize) {
+                return {
+                    isValid: false,
+                    errorMessage: `Content size ${size} exceeds limit of ${maxSize} bytes`,
+                    severity: 'high'
+                };
+            }
+            return { isValid: true };
+        };
+    }
+    /**
+     * Create a content validator that checks for forbidden patterns
+     */
+    static patternValidator(forbiddenPatterns, errorMessage = 'Forbidden pattern detected') {
+        return async (content) => {
+            for (const pattern of forbiddenPatterns) {
+                if (pattern.test(content)) {
+                    return {
+                        isValid: false,
+                        errorMessage,
+                        severity: 'high',
+                        metadata: { pattern: pattern.source }
+                    };
+                }
+            }
+            return { isValid: true };
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SecureDownloader.js","sourceRoot":"","sources":["../../src/utils/SecureDownloader.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SecureDownloader - Reusable utility for safe content downloads\n * \n * Implements the validate-before-write pattern with comprehensive security features:\n * - Content validation hooks (customizable validators)\n * - Atomic file operations with temp files\n * - Guaranteed cleanup on failure\n * - Memory-efficient streaming for large files\n * - Size limits to prevent DoS attacks\n * - Path validation to prevent traversal\n * - Timeout handling for network operations\n * - Content type validation\n * \n * Usage Examples:\n * \n * // Basic download with validation\n * const downloader = new SecureDownloader();\n * await downloader.downloadToFile(\n *   'https://example.com/file.md',\n *   './downloads/file.md',\n *   {\n *     validator: async (content) => ({\n *       isValid: !content.includes('malicious'),\n *       errorMessage: content.includes('malicious') ? 'Malicious content detected' : undefined\n *     }),\n *     maxSize: 1024 * 1024, // 1MB limit\n *     timeout: 30000 // 30 second timeout\n *   }\n * );\n * \n * // Download to memory with validation\n * const content = await downloader.downloadToMemory(\n *   'https://example.com/data.json',\n *   {\n *     validator: async (content) => {\n *       try {\n *         JSON.parse(content);\n *         return { isValid: true };\n *       } catch {\n *         return { isValid: false, errorMessage: 'Invalid JSON format' };\n *       }\n *     }\n *   }\n * );\n * \n * // Streaming download for large files\n * await downloader.downloadStream(\n *   'https://example.com/large-file.zip',\n *   './downloads/large-file.zip',\n *   {\n *     streamValidator: (chunk) => !chunk.includes(Buffer.from('VIRUS')),\n *     maxSize: 100 * 1024 * 1024, // 100MB limit\n *     timeout: 300000 // 5 minute timeout\n *   }\n * );\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { randomBytes, createHash } from 'crypto';\nimport { Readable } from 'stream';\nimport { pipeline } from 'stream/promises';\nimport { createWriteStream } from 'fs';\n\nimport { SecurityError } from '../errors/SecurityError.js';\nimport { SECURITY_LIMITS } from '../security/constants.js';\nimport { ContentValidator as SecurityContentValidator } from '../security/contentValidator.js';\nimport { PathValidator } from '../security/pathValidator.js';\nimport { FileLockManager } from '../security/fileLockManager.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { RateLimiter } from './RateLimiter.js';\nimport { logger } from './logger.js';\n\n/**\n * Result of content validation\n */\nexport interface ValidationResult {\n  /** Whether the content is valid and safe */\n  isValid: boolean;\n  /** Error message if validation failed */\n  errorMessage?: string;\n  /** Severity of any detected issues */\n  severity?: 'low' | 'medium' | 'high' | 'critical';\n  /** Additional metadata about validation */\n  metadata?: Record<string, any>;\n}\n\n/**\n * Content validator function type\n */\nexport type ContentValidatorFunction = (content: string) => Promise<ValidationResult>;\n\n/**\n * Stream chunk validator function type\n */\nexport type StreamValidator = (chunk: Uint8Array) => boolean;\n\n/**\n * Options for download operations\n */\nexport interface DownloadOptions {\n  /** Custom content validator function */\n  validator?: ContentValidatorFunction;\n  /** Maximum file size in bytes (default: SECURITY_LIMITS.MAX_FILE_SIZE) */\n  maxSize?: number;\n  /** Network timeout in milliseconds (default: 30000) */\n  timeout?: number;\n  /** Whether to use atomic file operations (default: true) */\n  atomic?: boolean;\n  /** Expected content type (for validation) */\n  expectedContentType?: string;\n  /** Custom HTTP headers */\n  headers?: Record<string, string>;\n  /** Expected SHA-256 checksum for integrity validation */\n  expectedChecksum?: string;\n}\n\n/**\n * Options for streaming downloads\n */\nexport interface StreamDownloadOptions {\n  /** Chunk-level validator for streaming validation */\n  streamValidator?: StreamValidator;\n  /** Maximum file size in bytes (default: SECURITY_LIMITS.MAX_FILE_SIZE) */\n  maxSize?: number;\n  /** Network timeout in milliseconds (default: 30000) */\n  timeout?: number;\n  /** Custom HTTP headers */\n  headers?: Record<string, string>;\n}\n\n/**\n * Custom error types for different failure scenarios\n */\nexport class DownloadError extends Error {\n  constructor(\n    message: string,\n    public readonly code: string,\n    public readonly originalError?: Error\n  ) {\n    super(message);\n    this.name = 'DownloadError';\n  }\n\n  static networkError(message: string, originalError?: Error): DownloadError {\n    return new DownloadError(message, 'NETWORK_ERROR', originalError);\n  }\n\n  static validationError(message: string): DownloadError {\n    return new DownloadError(message, 'VALIDATION_ERROR');\n  }\n\n  static securityError(message: string): DownloadError {\n    return new DownloadError(message, 'SECURITY_ERROR');\n  }\n\n  static timeoutError(message: string): DownloadError {\n    return new DownloadError(message, 'TIMEOUT_ERROR');\n  }\n\n  static filesystemError(message: string, originalError?: Error): DownloadError {\n    return new DownloadError(message, 'FILESYSTEM_ERROR', originalError);\n  }\n}\n\n/**\n * SecureDownloader - Implements validate-before-write pattern for safe downloads\n * \n * Key Security Features:\n * 1. VALIDATE-BEFORE-WRITE: All content validation occurs before any disk operations\n * 2. ATOMIC OPERATIONS: Uses temporary files with atomic rename to prevent corruption\n * 3. GUARANTEED CLEANUP: Automatic cleanup of temporary files on any failure\n * 4. SIZE LIMITS: Prevents DoS attacks through large file downloads\n * 5. PATH VALIDATION: Prevents directory traversal attacks\n * 6. TIMEOUT PROTECTION: Prevents hanging network operations\n * 7. CONTENT VALIDATION: Extensible validation system for different content types\n */\nexport class SecureDownloader {\n  private readonly defaultTimeout: number;\n  private readonly defaultMaxSize: number;\n  private readonly tempDir: string;\n  private readonly globalRateLimiter: RateLimiter;\n  private readonly urlRateLimiters: Map<string, RateLimiter>;\n\n  constructor(options?: {\n    defaultTimeout?: number;\n    defaultMaxSize?: number;\n    tempDir?: string;\n    rateLimitOptions?: {\n      maxRequestsPerUrl?: number;\n      maxGlobalRequests?: number;\n      windowMs?: number;\n    };\n  }) {\n    this.defaultTimeout = options?.defaultTimeout || 30000; // 30 seconds\n    this.defaultMaxSize = options?.defaultMaxSize || SECURITY_LIMITS.MAX_FILE_SIZE;\n    this.tempDir = options?.tempDir || '.tmp';\n    \n    // Initialize rate limiters\n    const rateLimitConfig = options?.rateLimitOptions || {};\n    this.globalRateLimiter = new RateLimiter({\n      maxRequests: rateLimitConfig.maxGlobalRequests || 100, // 100 downloads per hour globally\n      windowMs: rateLimitConfig.windowMs || 60 * 60 * 1000, // 1 hour\n      minDelayMs: 1000 // Minimum 1 second between requests\n    });\n    this.urlRateLimiters = new Map();\n  }\n\n  /**\n   * Download content to a file with validation\n   * \n   * SECURITY: Implements validate-before-write pattern:\n   * 1. Download content to memory\n   * 2. Validate all content\n   * 3. Only then write to disk atomically\n   * \n   * @param url - URL to download from\n   * @param destinationPath - Local file path to save to\n   * @param options - Download and validation options\n   */\n  async downloadToFile(\n    url: string,\n    destinationPath: string,\n    options: DownloadOptions = {}\n  ): Promise<void> {\n    const startTime = Date.now();\n    logger.debug(`Starting secure download from ${url} to ${destinationPath}`);\n\n    try {\n      // SECURITY: Validate URL and destination path first\n      this.validateUrl(url);\n      const validatedPath = await this.validateDestinationPath(destinationPath);\n\n      // SECURITY: Check if file already exists (prevent accidental overwrites)\n      try {\n        await fs.access(validatedPath);\n        throw DownloadError.filesystemError(`File already exists: ${destinationPath}`);\n      } catch (error) {\n        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {\n          throw error; // Re-throw if it's not a \"file not found\" error\n        }\n        // File doesn't exist, proceed with download\n      }\n\n      // STEP 1: Check rate limits before download\n      await this.checkRateLimit(url);\n\n      // STEP 2: Download content to memory (no disk operations yet)\n      const content = await this.downloadToMemory(url, options);\n\n      // STEP 3: Validate checksum if provided\n      if (options.expectedChecksum) {\n        await this.validateChecksum(content, options.expectedChecksum);\n      }\n\n      // STEP 4: All validation is complete, now write atomically\n      const useAtomic = options.atomic !== false; // Default to true\n      if (useAtomic) {\n        await this.atomicWriteFile(validatedPath, content);\n      } else {\n        await this.directWriteFile(validatedPath, content);\n      }\n\n      const duration = Date.now() - startTime;\n      logger.info(`Secure download completed: ${destinationPath} (${content.length} bytes, ${duration}ms)`);\n\n      // Log successful download for security monitoring\n      SecurityMonitor.logSecurityEvent({\n        type: 'FILE_COPIED',\n        severity: 'LOW',\n        source: 'secure_downloader',\n        details: `Downloaded ${content.length} bytes from ${url} to ${destinationPath}`,\n        metadata: {\n          url,\n          destinationPath,\n          contentLength: content.length,\n          duration\n        }\n      });\n\n    } catch (error) {\n      const duration = Date.now() - startTime;\n      logger.error(`Secure download failed: ${error instanceof Error ? error.message : String(error)}`);\n\n      // Log failed download for security monitoring\n      SecurityMonitor.logSecurityEvent({\n        type: 'PATH_TRAVERSAL_ATTEMPT',\n        severity: 'MEDIUM',\n        source: 'secure_downloader',\n        details: `Download failed: ${error instanceof Error ? error.message : String(error)}`,\n        metadata: {\n          url,\n          destinationPath,\n          duration,\n          errorType: error instanceof DownloadError ? error.code : 'UNKNOWN'\n        }\n      });\n\n      throw error;\n    }\n  }\n\n  /**\n   * Download content to memory with validation\n   * \n   * @param url - URL to download from\n   * @param options - Download and validation options\n   * @returns Validated content as string\n   */\n  async downloadToMemory(\n    url: string,\n    options: DownloadOptions = {}\n  ): Promise<string> {\n    const timeout = options.timeout || this.defaultTimeout;\n    const maxSize = options.maxSize || this.defaultMaxSize;\n\n    logger.debug(`Downloading content from ${url} (max: ${maxSize} bytes, timeout: ${timeout}ms)`);\n\n    try {\n      // SECURITY: Validate URL format\n      this.validateUrl(url);\n\n      // STEP 1: Check rate limits before download\n      await this.checkRateLimit(url);\n\n      // STEP 2: Fetch content with size and timeout protection\n      const content = await this.fetchWithLimits(url, maxSize, timeout, options.headers);\n\n      // STEP 3: Validate content type if specified\n      if (options.expectedContentType) {\n        await this.validateContentType(content, options.expectedContentType);\n      }\n\n      // STEP 4: Validate checksum if provided\n      if (options.expectedChecksum) {\n        await this.validateChecksum(content, options.expectedChecksum);\n      }\n\n      // STEP 5: Run built-in security validation\n      const securityResult = SecurityContentValidator.validateAndSanitize(content);\n      if (!securityResult.isValid && securityResult.severity === 'critical') {\n        throw DownloadError.securityError(\n          `Critical security threat detected: ${securityResult.detectedPatterns?.join(', ')}`\n        );\n      }\n\n      // STEP 6: Run custom validator if provided\n      if (options.validator) {\n        logger.debug('Running custom content validation');\n        const validationResult = await options.validator(content);\n        if (!validationResult.isValid) {\n          throw DownloadError.validationError(\n            validationResult.errorMessage || 'Content validation failed'\n          );\n        }\n      }\n\n      logger.debug(`Content validation passed (${content.length} bytes)`);\n      return securityResult.sanitizedContent || content;\n\n    } catch (error) {\n      if (error instanceof DownloadError) {\n        throw error;\n      }\n      throw DownloadError.networkError(\n        `Failed to download content from ${url}: ${error instanceof Error ? error.message : String(error)}`,\n        error instanceof Error ? error : undefined\n      );\n    }\n  }\n\n  /**\n   * Download large files using streaming with chunk-level validation\n   * \n   * @param url - URL to download from\n   * @param destinationPath - Local file path to save to\n   * @param options - Streaming download options\n   */\n  async downloadStream(\n    url: string,\n    destinationPath: string,\n    options: StreamDownloadOptions = {}\n  ): Promise<void> {\n    const startTime = Date.now();\n    const maxSize = options.maxSize || this.defaultMaxSize;\n    const timeout = options.timeout || this.defaultTimeout;\n\n    logger.debug(`Starting streaming download from ${url} to ${destinationPath}`);\n\n    try {\n      // SECURITY: Check rate limits before download\n      await this.checkRateLimit(url);\n\n      // SECURITY: Validate URL and destination path\n      this.validateUrl(url);\n      const validatedPath = await this.validateDestinationPath(destinationPath);\n\n      // Generate temporary file path for atomic operation\n      const tempPath = await this.getTempFilePath(validatedPath);\n\n      let downloadedSize = 0;\n      let timeoutHandle: NodeJS.Timeout | undefined;\n\n      // Create abort controller for timeout handling\n      const abortController = new AbortController();\n      timeoutHandle = setTimeout(() => {\n        abortController.abort();\n      }, timeout);\n\n      try {\n        // SECURITY: Fetch with abort signal for timeout\n        const response = await fetch(url, {\n          signal: abortController.signal,\n          headers: options.headers\n        });\n\n        if (!response.ok) {\n          throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n        }\n\n        if (!response.body) {\n          throw new Error('Response body is null');\n        }\n\n        // Ensure temp directory exists\n        await fs.mkdir(path.dirname(tempPath), { recursive: true });\n\n        // Create write stream to temporary file\n        const writeStream = createWriteStream(tempPath);\n\n        // Create a transform stream for validation and size checking\n        const validationStream = new Readable({\n          async read() {\n            // This stream will be fed by the pipeline\n          }\n        });\n\n        // Set up chunk validation and size checking\n        const reader = response.body.getReader();\n        const pump = async () => {\n          try {\n            while (true) {\n              const { done, value } = await reader.read();\n              if (done) break;\n\n              // SECURITY: Check size limit\n              downloadedSize += value.length;\n              if (downloadedSize > maxSize) {\n                throw DownloadError.securityError(\n                  `File size exceeds limit: ${downloadedSize} > ${maxSize} bytes`\n                );\n              }\n\n              // SECURITY: Run chunk validator if provided\n              if (options.streamValidator && !options.streamValidator(value)) {\n                throw DownloadError.validationError('Chunk validation failed');\n              }\n\n              validationStream.push(value);\n            }\n            validationStream.push(null); // End stream\n          } catch (error) {\n            validationStream.destroy(error instanceof Error ? error : new Error(String(error)));\n          }\n        };\n\n        // Start the pump and pipeline concurrently\n        const [pumpResult] = await Promise.all([\n          pump(),\n          pipeline(validationStream, writeStream)\n        ]);\n\n        // Clear timeout\n        if (timeoutHandle) {\n          clearTimeout(timeoutHandle);\n          timeoutHandle = undefined;\n        }\n\n        // SECURITY: Atomic rename to final destination\n        await fs.rename(tempPath, validatedPath);\n\n        const duration = Date.now() - startTime;\n        logger.info(`Streaming download completed: ${destinationPath} (${downloadedSize} bytes, ${duration}ms)`);\n\n        // Log successful streaming download\n        SecurityMonitor.logSecurityEvent({\n          type: 'FILE_COPIED',\n          severity: 'LOW',\n          source: 'secure_downloader',\n          details: `Streamed ${downloadedSize} bytes from ${url} to ${destinationPath}`,\n          metadata: {\n            url,\n            destinationPath,\n            contentLength: downloadedSize,\n            duration\n          }\n        });\n\n      } catch (error) {\n        // SECURITY: Guaranteed cleanup of temporary file\n        try {\n          await fs.unlink(tempPath);\n          logger.debug(`Cleaned up temp file: ${tempPath}`);\n        } catch (cleanupError) {\n          logger.warn(`Failed to clean up temp file ${tempPath}: ${cleanupError}`);\n        }\n        throw error;\n      } finally {\n        if (timeoutHandle) {\n          clearTimeout(timeoutHandle);\n        }\n      }\n\n    } catch (error) {\n      const duration = Date.now() - startTime;\n      logger.error(`Streaming download failed: ${error instanceof Error ? error.message : String(error)}`);\n\n      // Log failed streaming download\n      SecurityMonitor.logSecurityEvent({\n        type: 'PATH_TRAVERSAL_ATTEMPT',\n        severity: 'MEDIUM',\n        source: 'secure_downloader',\n        details: `Streaming download failed: ${error instanceof Error ? error.message : String(error)}`,\n        metadata: {\n          url,\n          destinationPath,\n          duration,\n          errorType: error instanceof DownloadError ? error.code : 'UNKNOWN'\n        }\n      });\n\n      if (error instanceof Error && error.name === 'AbortError') {\n        throw DownloadError.timeoutError(`Download timed out after ${timeout}ms`);\n      }\n\n      if (error instanceof DownloadError) {\n        throw error;\n      }\n\n      throw DownloadError.networkError(\n        `Streaming download failed: ${error instanceof Error ? error.message : String(error)}`,\n        error instanceof Error ? error : undefined\n      );\n    }\n  }\n\n  /**\n   * Validate URL format and security with Unicode normalization\n   */\n  private validateUrl(url: string): void {\n    if (!url || typeof url !== 'string') {\n      throw DownloadError.validationError('URL must be a non-empty string');\n    }\n\n    // SECURITY FIX: DMCP-SEC-004 - Unicode normalization on user input\n    const unicodeValidation = UnicodeValidator.normalize(url);\n    const normalizedUrl = unicodeValidation.normalizedContent;\n    \n    if (!unicodeValidation.isValid) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'UNICODE_VALIDATION_ERROR',\n        severity: 'MEDIUM',\n        source: 'secure_downloader',\n        details: `URL contains suspicious Unicode patterns: ${unicodeValidation.detectedIssues?.join(', ')}`,\n        metadata: { originalUrl: url, normalizedUrl }\n      });\n    }\n    \n    // Use normalized URL for further validation\n    url = normalizedUrl;\n\n    let parsedUrl: URL;\n    try {\n      parsedUrl = new URL(url);\n    } catch (error) {\n      throw DownloadError.validationError(`Invalid URL format: ${url}`);\n    }\n\n    // SECURITY: Only allow HTTPS and HTTP protocols\n    if (!['https:', 'http:'].includes(parsedUrl.protocol)) {\n      throw DownloadError.securityError(`Unsupported protocol: ${parsedUrl.protocol}. Only HTTP/HTTPS allowed.`);\n    }\n\n    // SECURITY: Prevent requests to localhost/private networks\n    const hostname = parsedUrl.hostname.toLowerCase();\n    if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '::1') {\n      throw DownloadError.securityError('Downloads from localhost are not allowed');\n    }\n\n    // SECURITY: Check for private IP ranges (basic protection)\n    if (hostname.startsWith('192.168.') || hostname.startsWith('10.') || hostname.startsWith('172.')) {\n      throw DownloadError.securityError('Downloads from private IP ranges are not allowed');\n    }\n  }\n\n  /**\n   * Validate destination path for security\n   */\n  private async validateDestinationPath(filePath: string): Promise<string> {\n    try {\n      // Use existing PathValidator for comprehensive path validation\n      return await PathValidator.validatePersonaPath(filePath);\n    } catch (error) {\n      throw DownloadError.securityError(\n        `Invalid destination path: ${error instanceof Error ? error.message : String(error)}`\n      );\n    }\n  }\n\n  /**\n   * Fetch content with size and timeout limits\n   */\n  private async fetchWithLimits(\n    url: string,\n    maxSize: number,\n    timeout: number,\n    headers?: Record<string, string>\n  ): Promise<string> {\n    const abortController = new AbortController();\n    const timeoutHandle = setTimeout(() => abortController.abort(), timeout);\n\n    try {\n      const response = await fetch(url, {\n        signal: abortController.signal,\n        headers: {\n          'User-Agent': 'DollhouseMCP-SecureDownloader/1.0',\n          ...headers\n        }\n      });\n\n      if (!response.ok) {\n        throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n      }\n\n      // SECURITY: Check Content-Length header if available\n      const contentLength = response.headers.get('content-length');\n      if (contentLength && parseInt(contentLength, 10) > maxSize) {\n        throw DownloadError.securityError(\n          `Content size ${contentLength} exceeds limit of ${maxSize} bytes`\n        );\n      }\n\n      // Read content with size checking\n      const chunks: Uint8Array[] = [];\n      let totalSize = 0;\n\n      if (!response.body) {\n        throw new Error('Response body is null');\n      }\n\n      const reader = response.body.getReader();\n      try {\n        while (true) {\n          const { done, value } = await reader.read();\n          if (done) break;\n\n          totalSize += value.length;\n          if (totalSize > maxSize) {\n            throw DownloadError.securityError(\n              `Content size ${totalSize} exceeds limit of ${maxSize} bytes`\n            );\n          }\n\n          chunks.push(value);\n        }\n      } finally {\n        reader.releaseLock();\n      }\n\n      // Combine chunks and decode\n      const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);\n      const combined = new Uint8Array(totalLength);\n      let offset = 0;\n      for (const chunk of chunks) {\n        combined.set(chunk, offset);\n        offset += chunk.length;\n      }\n\n      return new TextDecoder('utf-8').decode(combined);\n\n    } catch (error) {\n      if (error instanceof Error && error.name === 'AbortError') {\n        throw DownloadError.timeoutError(`Request timed out after ${timeout}ms`);\n      }\n      throw error;\n    } finally {\n      clearTimeout(timeoutHandle);\n    }\n  }\n\n  /**\n   * Validate content type if specified\n   */\n  private async validateContentType(content: string, expectedType: string): Promise<void> {\n    // Basic content type validation based on content analysis\n    switch (expectedType.toLowerCase()) {\n      case 'json':\n        try {\n          JSON.parse(content);\n        } catch {\n          throw DownloadError.validationError('Content is not valid JSON');\n        }\n        break;\n      case 'yaml':\n      case 'yml':\n        // Use existing YAML validation\n        if (!SecurityContentValidator.validateYamlContent(content)) {\n          throw DownloadError.validationError('Content is not valid YAML');\n        }\n        break;\n      case 'markdown':\n      case 'md':\n        // Basic markdown validation (check for frontmatter format)\n        if (content.startsWith('---')) {\n          const frontmatterEnd = content.indexOf('\\n---\\n', 3);\n          if (frontmatterEnd === -1) {\n            throw DownloadError.validationError('Invalid markdown frontmatter format');\n          }\n        }\n        break;\n      default:\n        logger.debug(`No specific validation for content type: ${expectedType}`);\n    }\n  }\n\n  /**\n   * Atomic file write using FileLockManager\n   */\n  private async atomicWriteFile(filePath: string, content: string): Promise<void> {\n    const resource = `download:${filePath}`;\n    \n    await FileLockManager.withLock(resource, async () => {\n      // Ensure directory exists\n      await fs.mkdir(path.dirname(filePath), { recursive: true });\n      \n      // Use FileLockManager's atomic write\n      await FileLockManager.atomicWriteFile(filePath, content, { encoding: 'utf-8' });\n    });\n  }\n\n  /**\n   * Direct file write (non-atomic, for when atomic is disabled)\n   */\n  private async directWriteFile(filePath: string, content: string): Promise<void> {\n    // Ensure directory exists\n    await fs.mkdir(path.dirname(filePath), { recursive: true });\n    \n    // Direct write\n    await fs.writeFile(filePath, content, 'utf-8');\n  }\n\n  /**\n   * Generate temporary file path for atomic operations\n   */\n  private 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    const tempDir = path.join(dir, this.tempDir);\n    \n    // Ensure temp directory exists\n    await fs.mkdir(tempDir, { recursive: true });\n    \n    return path.join(tempDir, `${basename}.${random}.tmp`);\n  }\n\n  /**\n   * Check rate limits for downloads\n   */\n  private async checkRateLimit(url: string): Promise<void> {\n    // Check global rate limit\n    const globalStatus = this.globalRateLimiter.checkLimit();\n    if (!globalStatus.allowed) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'RATE_LIMIT_EXCEEDED',\n        severity: 'MEDIUM',\n        source: 'secure_downloader',\n        details: `Global download rate limit exceeded. Retry after ${globalStatus.retryAfterMs}ms`,\n        metadata: { url, retryAfterMs: globalStatus.retryAfterMs }\n      });\n      throw DownloadError.securityError(\n        `Download rate limit exceeded. Please retry after ${Math.ceil(globalStatus.retryAfterMs! / 1000)} seconds`\n      );\n    }\n\n    // Check per-URL rate limit\n    const parsedUrl = new URL(url);\n    const urlKey = `${parsedUrl.hostname}:${parsedUrl.port || (parsedUrl.protocol === 'https:' ? '443' : '80')}`;\n    \n    if (!this.urlRateLimiters.has(urlKey)) {\n      this.urlRateLimiters.set(urlKey, new RateLimiter({\n        maxRequests: 10, // 10 requests per hour per URL\n        windowMs: 60 * 60 * 1000,\n        minDelayMs: 5000 // 5 second minimum delay between requests to same URL\n      }));\n    }\n    \n    const urlLimiter = this.urlRateLimiters.get(urlKey)!;\n    const urlStatus = urlLimiter.checkLimit();\n    if (!urlStatus.allowed) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'RATE_LIMIT_EXCEEDED',\n        severity: 'MEDIUM',\n        source: 'secure_downloader',\n        details: `Per-URL download rate limit exceeded for ${urlKey}. Retry after ${urlStatus.retryAfterMs}ms`,\n        metadata: { url, urlKey, retryAfterMs: urlStatus.retryAfterMs }\n      });\n      throw DownloadError.securityError(\n        `Too many requests to ${urlKey}. Please retry after ${Math.ceil(urlStatus.retryAfterMs! / 1000)} seconds`\n      );\n    }\n\n    // Consume rate limit tokens\n    this.globalRateLimiter.consumeToken();\n    urlLimiter.consumeToken();\n  }\n\n  /**\n   * Validate content checksum for integrity verification\n   */\n  private async validateChecksum(content: string, expectedChecksum: string): Promise<void> {\n    const normalizedExpected = expectedChecksum.toLowerCase().trim();\n    \n    // Validate checksum format (SHA-256 should be 64 hex characters)\n    if (!/^[a-f0-9]{64}$/.test(normalizedExpected)) {\n      throw DownloadError.validationError('Invalid checksum format. Expected SHA-256 (64 hex characters)');\n    }\n\n    const contentBuffer = Buffer.from(content, 'utf-8');\n    const actualChecksum = createHash('sha256').update(contentBuffer).digest('hex');\n    \n    if (actualChecksum !== normalizedExpected) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'CONTENT_INJECTION_ATTEMPT',\n        severity: 'HIGH',\n        source: 'secure_downloader',\n        details: `Checksum mismatch detected - possible content tampering`,\n        metadata: { \n          expectedChecksum: normalizedExpected,\n          actualChecksum,\n          contentLength: content.length\n        }\n      });\n      throw DownloadError.securityError(\n        `Content checksum verification failed. Expected: ${normalizedExpected}, Got: ${actualChecksum}`\n      );\n    }\n\n    logger.debug(`Checksum validation passed: ${actualChecksum}`);\n  }\n\n  /**\n   * Create a content validator that combines multiple validators\n   */\n  static combineValidators(...validators: ContentValidatorFunction[]): ContentValidatorFunction {\n    return async (content: string): Promise<ValidationResult> => {\n      for (const validator of validators) {\n        const result = await validator(content);\n        if (!result.isValid) {\n          return result;\n        }\n      }\n      return { isValid: true };\n    };\n  }\n\n  /**\n   * Create a content validator for JSON content\n   */\n  static jsonValidator(): ContentValidatorFunction {\n    return async (content: string): Promise<ValidationResult> => {\n      try {\n        JSON.parse(content);\n        return { isValid: true };\n      } catch (error) {\n        return {\n          isValid: false,\n          errorMessage: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`,\n          severity: 'medium'\n        };\n      }\n    };\n  }\n\n  /**\n   * Create a content validator for YAML content\n   */\n  static yamlValidator(): ContentValidatorFunction {\n    return async (content: string): Promise<ValidationResult> => {\n      const isValid = SecurityContentValidator.validateYamlContent(content);\n      return {\n        isValid,\n        errorMessage: isValid ? undefined : 'Invalid or malicious YAML content',\n        severity: isValid ? 'low' : 'high'\n      };\n    };\n  }\n\n  /**\n   * Create a content validator for markdown content\n   */\n  static markdownValidator(): ContentValidatorFunction {\n    return async (content: string): Promise<ValidationResult> => {\n      try {\n        // Use existing persona content sanitization for markdown\n        SecurityContentValidator.sanitizePersonaContent(content);\n        return { isValid: true };\n      } catch (error) {\n        return {\n          isValid: false,\n          errorMessage: `Invalid markdown: ${error instanceof Error ? error.message : String(error)}`,\n          severity: error instanceof SecurityError ? 'critical' : 'medium'\n        };\n      }\n    };\n  }\n\n  /**\n   * Create a content validator with size limits\n   */\n  static sizeValidator(maxSize: number): ContentValidatorFunction {\n    return async (content: string): Promise<ValidationResult> => {\n      const size = Buffer.byteLength(content, 'utf-8');\n      if (size > maxSize) {\n        return {\n          isValid: false,\n          errorMessage: `Content size ${size} exceeds limit of ${maxSize} bytes`,\n          severity: 'high'\n        };\n      }\n      return { isValid: true };\n    };\n  }\n\n  /**\n   * Create a content validator that checks for forbidden patterns\n   */\n  static patternValidator(\n    forbiddenPatterns: RegExp[],\n    errorMessage: string = 'Forbidden pattern detected'\n  ): ContentValidatorFunction {\n    return async (content: string): Promise<ValidationResult> => {\n      for (const pattern of forbiddenPatterns) {\n        if (pattern.test(content)) {\n          return {\n            isValid: false,\n            errorMessage,\n            severity: 'high',\n            metadata: { pattern: pattern.source }\n          };\n        }\n      }\n      return { isValid: true };\n    };\n  }\n}"]}