@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
776 lines • 108 kB
JavaScript
/**
* 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 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 { 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;
fileLockManager;
fileOperations;
constructor(options) {
this.defaultTimeout = options?.defaultTimeout || 30000; // 30 seconds
this.defaultMaxSize = options?.defaultMaxSize || SECURITY_LIMITS.MAX_FILE_SIZE;
this.tempDir = options?.tempDir || '.tmp';
this.fileLockManager = options?.fileLockManager ?? undefined;
this.fileOperations = options?.fileOperations ?? undefined;
// 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)
const fileExists = await this.fileOperations.exists(validatedPath);
if (fileExists) {
throw DownloadError.filesystemError(`File already exists: ${destinationPath}`);
}
// 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: 'SecureDownloader',
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: 'SecureDownloader',
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;
// Track write stream for cleanup (declared outside try for catch block access)
let writeStream;
let writeStreamClosed = false;
// 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 this.fileOperations.createDirectory(path.dirname(tempPath));
// Create write stream to temporary file
writeStream = createWriteStream(tempPath);
// Track whether write stream has been closed for cleanup
writeStream.on('close', () => {
writeStreamClosed = true;
});
// 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
await Promise.all([
pump(),
pipeline(validationStream, writeStream)
]);
// Clear timeout
if (timeoutHandle) {
clearTimeout(timeoutHandle);
timeoutHandle = undefined;
}
// SECURITY: Atomic rename to final destination
await this.fileOperations.renameFile(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: 'SecureDownloader',
details: `Streamed ${downloadedSize} bytes from ${url} to ${destinationPath}`,
metadata: {
url,
destinationPath,
contentLength: downloadedSize,
duration
}
});
}
catch (error) {
// SECURITY: Ensure write stream is closed before cleanup to release file handle
// This is critical on macOS where unlink can fail or leave stale directory entries
// if the file handle is still open
if (writeStream && !writeStreamClosed) {
await new Promise((resolve) => {
writeStream.destroy();
writeStream.once('close', () => resolve());
// Safety timeout in case close event never fires
setTimeout(() => resolve(), 100);
});
}
// SECURITY: Guaranteed cleanup of temporary file
try {
await this.fileOperations.deleteFile(tempPath, undefined, { source: 'SecureDownloader.downloadStream' });
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: 'SecureDownloader',
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: 'SecureDownloader',
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 {
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 && Number.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 FileOperationsService
*/
async atomicWriteFile(filePath, content) {
// Ensure directory exists
await this.fileOperations.createDirectory(path.dirname(filePath));
// Use FileOperationsService's atomic write
await this.fileOperations.writeFile(filePath, content, {
source: 'SecureDownloader.atomicWriteFile',
atomic: true
});
}
/**
* Direct file write (non-atomic, for when atomic is disabled)
*/
async directWriteFile(filePath, content) {
// Ensure directory exists
await this.fileOperations.createDirectory(path.dirname(filePath));
// Direct write
await this.fileOperations.writeFile(filePath, content, {
source: 'SecureDownloader.directWriteFile',
atomic: false
});
}
/**
* 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 this.fileOperations.createDirectory(tempDir);
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: 'SecureDownloader',
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: 'SecureDownloader',
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: 'SecureDownloader',
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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