@dimzxzzx07/file-watcher 1.0.0

package/src/core/WatcherEngine.ts

@@ -0,0 +1,537 @@
+import * as chokidar from 'chokidar';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { EventEmitter } from 'events';
+import { SecurityConfig, FileMetadata, IntegrityViolation } from '../types';
+import { IntegrityValidator } from './IntegrityValidator';
+import { SecurityManager } from './SecurityManager';
+import { BackupManager } from './BackupManager';
+import { Logger } from '../utils/Logger';
+import { ProcessGuard } from '../guards/ProcessGuard';
+
+export class WatcherEngine extends EventEmitter {
+    private watcher: chokidar.FSWatcher | null = null;
+    private readonly config: SecurityConfig;
+    private readonly validator: IntegrityValidator;
+    private readonly securityManager: SecurityManager;
+    private readonly backupManager: BackupManager;
+    private readonly logger: Logger;
+    private readonly processGuard: ProcessGuard;
+    private readonly fileCache: Map<string, FileMetadata>;
+    private readonly watchState: Map<string, boolean>;
+    private isShuttingDown: boolean = false;
+    private scanInterval: NodeJS.Timeout | null = null;
+
+    constructor(config: SecurityConfig) {
+        super();
+        this.config = config;
+        this.fileCache = new Map();
+        this.watchState = new Map();
+        this.logger = Logger.getInstance();
+        this.validator = new IntegrityValidator(config);
+        this.securityManager = SecurityManager.getInstance(config);
+        this.backupManager = new BackupManager(config);
+        this.processGuard = ProcessGuard.getInstance();
+        
+        this.initialize();
+    }
+
+    private async initialize(): Promise<void> {
+        try {
+            await this.verifyEnvironment();
+            await this.initializeDirectories();
+            await this.loadExistingFiles();
+            await this.establishSecureConnection();
+            this.startSelfProtection();
+            
+            this.logger.info('WatcherEngine initialized successfully', {
+                watchDir: this.config.watchDir,
+                integrityLevel: this.config.integrityLevel
+            });
+        } catch (error) {
+            this.logger.error('Failed to initialize WatcherEngine', { error });
+            throw error;
+        }
+    }
+
+    private async verifyEnvironment(): Promise<void> {
+        if (process.version < 'v18.0.0') {
+            throw new Error('Node.js version 18+ required');
+        }
+
+        if (process.execArgv.some(arg => arg.includes('--inspect'))) {
+            this.logger.warning('Debugger detected - running in secure mode');
+            this.securityManager.setDebugMode(true);
+        }
+
+        try {
+            await fs.access(this.config.watchDir, fs.constants.R_OK | fs.constants.W_OK);
+        } catch {
+            throw new Error(`Insufficient permissions for ${this.config.watchDir}`);
+        }
+    }
+
+    private async initializeDirectories(): Promise<void> {
+        const dirs = [
+            this.config.backupDir,
+            this.config.quarantineDir,
+            path.join(this.config.watchDir, '.secure')
+        ];
+
+        for (const dir of dirs) {
+            try {
+                await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+            } catch (error) {
+                this.logger.error(`Failed to create directory: ${dir}`, { error });
+            }
+        }
+    }
+
+    private async loadExistingFiles(): Promise<void> {
+        const files = await this.scanDirectory(this.config.watchDir);
+        
+        for (const file of files) {
+            try {
+                const metadata = await this.validator.generateFileMetadata(file);
+                this.fileCache.set(file, metadata);
+                
+                await this.backupManager.createBackup(file, metadata);
+                
+                const isValid = await this.validator.validateFile(file, metadata);
+                if (!isValid) {
+                    this.handleIntegrityViolation({
+                        id: crypto.randomUUID(),
+                        timestamp: new Date(),
+                        filePath: file,
+                        violationType: 'hash_mismatch',
+                        severity: 'high',
+                        details: { initialValidation: false },
+                        actionTaken: 'alert'
+                    });
+                }
+            } catch (error) {
+                this.logger.error(`Failed to load file: ${file}`, { error });
+            }
+        }
+        
+        this.logger.info(`Loaded ${this.fileCache.size} files into cache`);
+    }
+
+    private async scanDirectory(dir: string): Promise<string[]> {
+        const files: string[] = [];
+        
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                
+                if (this.shouldIgnore(fullPath)) {
+                    continue;
+                }
+                
+                if (entry.isDirectory()) {
+                    files.push(...await this.scanDirectory(fullPath));
+                } else if (entry.isFile()) {
+                    files.push(fullPath);
+                }
+            }
+        } catch (error) {
+            this.logger.error(`Error scanning directory: ${dir}`, { error });
+        }
+        
+        return files;
+    }
+
+    private shouldIgnore(filePath: string): boolean {
+        const ignorePatterns = [
+            /node_modules/,
+            /\.git/,
+            /\.secure/,
+            /\.backup/,
+            /\.quarantine/,
+            /\.DS_Store/,
+            /Thumbs\.db/,
+            /\.tmp$/,
+            /\.temp$/,
+            /\.log$/
+        ];
+        
+        return ignorePatterns.some(pattern => pattern.test(filePath));
+    }
+
+    private async establishSecureConnection(): Promise<void> {
+        const secureChannel = await this.securityManager.createSecureChannel();
+        this.emit('secure:connected', secureChannel);
+    }
+
+    private startSelfProtection(): void {
+        this.processGuard.protectProcess();
+        
+        setInterval(() => {
+            this.securityManager.validateMemoryIntegrity();
+        }, 5000);
+        
+        setInterval(() => {
+            if (this.processGuard.detectDebugger()) {
+                this.emit('security:debugger-detected');
+            }
+        }, 1000);
+    }
+
+    public startWatching(): void {
+        if (this.watcher) {
+            return;
+        }
+
+        const watchOptions: chokidar.WatchOptions = {
+            ignored: (file: string) => this.shouldIgnore(file),
+            persistent: true,
+            ignoreInitial: true,
+            followSymlinks: false,
+            usePolling: true,
+            interval: 100,
+            binaryInterval: 300,
+            awaitWriteFinish: {
+                stabilityThreshold: 200,
+                pollInterval: 50
+            }
+        };
+
+        this.watcher = chokidar.watch(this.config.watchDir, watchOptions);
+
+        this.watcher
+            .on('add', (filePath: string) => this.handleFileAdd(filePath))
+            .on('change', (filePath: string) => this.handleFileChange(filePath))
+            .on('unlink', (filePath: string) => this.handleFileDelete(filePath))
+            .on('error', (error: Error) => this.handleWatcherError(error));
+
+        if (this.config.scanInterval > 0) {
+            this.scanInterval = setInterval(
+                () => this.performSecurityScan(),
+                this.config.scanInterval * 1000
+            );
+        }
+
+        this.logger.info('File watcher started successfully');
+    }
+
+    private async handleFileAdd(filePath: string): Promise<void> {
+        this.logger.info(`New file detected: ${filePath}`);
+        
+        try {
+            if (!this.isAllowedFileType(filePath)) {
+                await this.handleDisallowedFile(filePath);
+                return;
+            }
+
+            const metadata = await this.validator.generateFileMetadata(filePath);
+            
+            const isClean = await this.securityManager.scanFile(filePath);
+            if (!isClean) {
+                await this.handleInfectedFile(filePath);
+                return;
+            }
+
+            await this.backupManager.createBackup(filePath, metadata);
+            
+            this.fileCache.set(filePath, metadata);
+            
+            if (this.config.signatureVerification) {
+                const isValid = await this.validator.verifySignature(filePath, metadata);
+                if (!isValid) {
+                    throw new Error('Invalid file signature');
+                }
+            }
+
+            this.emit('file:added', { filePath, metadata });
+            
+        } catch (error) {
+            this.logger.error(`Error handling new file: ${filePath}`, { error });
+            await this.handleSuspiciousFile(filePath, error);
+        }
+    }
+
+    private async handleFileChange(filePath: string): Promise<void> {
+        this.logger.info(`File modified: ${filePath}`);
+        
+        try {
+            const oldMetadata = this.fileCache.get(filePath);
+            
+            if (!oldMetadata) {
+                await this.handleFileAdd(filePath);
+                return;
+            }
+
+            const newMetadata = await this.validator.generateFileMetadata(filePath);
+            
+            const isAuthorized = await this.securityManager.isAuthorizedChange(
+                filePath,
+                oldMetadata,
+                newMetadata
+            );
+
+            if (!isAuthorized) {
+                throw new Error('Unauthorized file modification');
+            }
+
+            const isValid = await this.validator.validateFile(filePath, newMetadata);
+            
+            if (!isValid) {
+                if (this.config.autoRollback) {
+                    await this.backupManager.rollbackFile(filePath);
+                    this.logger.info(`File rolled back: ${filePath}`);
+                } else {
+                    throw new Error('Integrity check failed');
+                }
+            } else {
+                this.fileCache.set(filePath, newMetadata);
+                
+                await this.backupManager.updateBackup(filePath, newMetadata);
+                
+                this.emit('file:changed', { filePath, oldMetadata, newMetadata });
+            }
+            
+        } catch (error) {
+            this.logger.error(`Error handling file change: ${filePath}`, { error });
+            await this.handleIntegrityViolation({
+                id: crypto.randomUUID(),
+                timestamp: new Date(),
+                filePath,
+                violationType: 'hash_mismatch',
+                severity: 'high',
+                details: { error },
+                actionTaken: this.config.autoRollback ? 'rollback' : 'alert'
+            });
+        }
+    }
+
+    private async handleFileDelete(filePath: string): Promise<void> {
+        this.logger.warning(`File deleted: ${filePath}`);
+        
+        try {
+            const metadata = this.fileCache.get(filePath);
+            
+            if (metadata) {
+                const restored = await this.backupManager.restoreFile(filePath);
+                
+                if (restored) {
+                    this.logger.info(`File restored from backup: ${filePath}`);
+                    
+                    const restoredMetadata = await this.validator.generateFileMetadata(filePath);
+                    this.fileCache.set(filePath, restoredMetadata);
+                    
+                    this.emit('file:restored', { filePath, metadata: restoredMetadata });
+                } else {
+                    this.fileCache.delete(filePath);
+                    this.emit('file:deleted', { filePath, metadata });
+                }
+            }
+            
+        } catch (error) {
+            this.logger.error(`Error handling file deletion: ${filePath}`, { error });
+        }
+    }
+
+    private async handleIntegrityViolation(violation: IntegrityViolation): Promise<void> {
+        this.logger.critical('Integrity violation detected', violation);
+        
+        if (violation.severity === 'critical' || violation.severity === 'high') {
+            await this.quarantineFile(violation.filePath);
+        }
+        
+        this.emit('integrity:violation', violation);
+        
+        switch (violation.severity) {
+            case 'critical':
+                await this.handleCriticalViolation(violation);
+                break;
+            case 'high':
+                await this.handleHighSeverityViolation(violation);
+                break;
+            default:
+                await this.handleLowSeverityViolation(violation);
+        }
+    }
+
+    private async quarantineFile(filePath: string): Promise<void> {
+        try {
+            const quarantinePath = path.join(
+                this.config.quarantineDir,
+                path.basename(filePath) + '.quarantined'
+            );
+            
+            await fs.copyFile(filePath, quarantinePath);
+            
+            await this.securityManager.encryptFile(quarantinePath);
+            
+            this.logger.info(`File quarantined: ${filePath} -> ${quarantinePath}`);
+            
+            if (this.config.integrityLevel === 'paranoid') {
+                await fs.unlink(filePath);
+            }
+            
+        } catch (error) {
+            this.logger.error(`Failed to quarantine file: ${filePath}`, { error });
+        }
+    }
+
+    private async handleCriticalViolation(violation: IntegrityViolation): Promise<void> {
+        this.logger.emergency('Critical security violation - initiating shutdown');
+        
+        this.stopWatching();
+        
+        this.emit('security:critical', violation);
+        
+        await this.performSecureShutdown();
+        
+        process.exit(1);
+    }
+
+    private async handleHighSeverityViolation(violation: IntegrityViolation): Promise<void> {
+        this.watchState.set(violation.filePath, false);
+        
+        if (this.config.autoRollback) {
+            const restored = await this.backupManager.rollbackFile(violation.filePath);
+            if (restored) {
+                this.logger.info(`File rolled back successfully: ${violation.filePath}`);
+                this.watchState.delete(violation.filePath);
+            }
+        }
+        
+        this.emit('security:alert', violation);
+    }
+
+    private async handleLowSeverityViolation(violation: IntegrityViolation): Promise<void> {
+        this.logger.warning('Low severity violation', violation);
+        this.emit('security:warning', violation);
+    }
+
+    private async handleSuspiciousFile(filePath: string, error: any): Promise<void> {
+        this.logger.warning(`Suspicious file detected: ${filePath}`, { error });
+        
+        await this.quarantineFile(filePath);
+        
+        this.emit('file:suspicious', { filePath, error });
+    }
+
+    private async handleInfectedFile(filePath: string): Promise<void> {
+        this.logger.critical(`Infected file detected: ${filePath}`);
+        
+        await this.quarantineFile(filePath);
+        
+        this.emit('security:infected', { filePath });
+    }
+
+    private async handleDisallowedFile(filePath: string): Promise<void> {
+        this.logger.warning(`Disallowed file type: ${filePath}`);
+        
+        if (this.config.integrityLevel === 'paranoid') {
+            await fs.unlink(filePath);
+            this.logger.info(`Disallowed file deleted: ${filePath}`);
+        }
+        
+        this.emit('file:disallowed', { filePath });
+    }
+
+    private isAllowedFileType(filePath: string): boolean {
+        const ext = path.extname(filePath).toLowerCase();
+        return this.config.allowedExtensions.includes(ext);
+    }
+
+    private handleWatcherError(error: Error): void {
+        this.logger.error('Watcher error', { error });
+        this.emit('watcher:error', error);
+    }
+
+    private async performSecurityScan(): Promise<void> {
+        this.logger.debug('Performing security scan...');
+        
+        for (const [filePath, metadata] of this.fileCache.entries()) {
+            try {
+                const isValid = await this.validator.validateFile(filePath, metadata);
+                
+                if (!isValid) {
+                    await this.handleIntegrityViolation({
+                        id: crypto.randomUUID(),
+                        timestamp: new Date(),
+                        filePath,
+                        violationType: 'hash_mismatch',
+                        severity: 'high',
+                        details: { scan: 'periodic' },
+                        actionTaken: 'alert'
+                    });
+                }
+                
+                if (!await this.fileExists(filePath)) {
+                    await this.handleFileDelete(filePath);
+                }
+                
+            } catch (error) {
+                this.logger.error(`Scan error for ${filePath}`, { error });
+            }
+        }
+        
+        const allFiles = await this.scanDirectory(this.config.watchDir);
+        for (const file of allFiles) {
+            if (!this.fileCache.has(file)) {
+                await this.handleFileAdd(file);
+            }
+        }
+        
+        this.logger.debug('Security scan completed');
+    }
+
+    private async fileExists(filePath: string): Promise<boolean> {
+        try {
+            await fs.access(filePath);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    private async performSecureShutdown(): Promise<void> {
+        this.isShuttingDown = true;
+        
+        this.logger.info('Performing secure shutdown...');
+        
+        this.stopWatching();
+        
+        await this.securityManager.encryptSensitiveData();
+        
+        this.fileCache.clear();
+        this.watchState.clear();
+        
+        await this.backupManager.performFinalBackup();
+        
+        this.logger.info('Secure shutdown completed');
+    }
+
+    public stopWatching(): void {
+        if (this.scanInterval) {
+            clearInterval(this.scanInterval);
+            this.scanInterval = null;
+        }
+        
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        
+        this.logger.info('File watcher stopped');
+    }
+
+    public getStatus(): any {
+        return {
+            watching: this.watcher !== null,
+            filesWatched: this.fileCache.size,
+            cacheSize: this.fileCache.size,
+            scanInterval: this.config.scanInterval,
+            integrityLevel: this.config.integrityLevel,
+            uptime: process.uptime(),
+            memoryUsage: process.memoryUsage(),
+            isShuttingDown: this.isShuttingDown
+        };
+    }
+}