@dimzxzzx07/file-watcher 1.0.0

package/src/utils/Logger.ts

@@ -0,0 +1,279 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+export enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARNING = 2,
+    ERROR = 3,
+    CRITICAL = 4,
+    EMERGENCY = 5
+}
+
+export class Logger {
+    private static instance: Logger;
+    private readonly logDir: string;
+    private readonly logFile: string;
+    private readonly errorLogFile: string;
+    private readonly securityLogFile: string;
+    private currentLogLevel: LogLevel = LogLevel.INFO;
+    private readonly maxLogSize: number = 10 * 1024 * 1024;
+    private readonly maxLogFiles: number = 5;
+    private logQueue: string[] = [];
+    private isWriting: boolean = false;
+
+    private constructor() {
+        this.logDir = path.join(process.cwd(), 'logs');
+        this.logFile = path.join(this.logDir, 'app.log');
+        this.errorLogFile = path.join(this.logDir, 'error.log');
+        this.securityLogFile = path.join(this.logDir, 'security.log');
+        
+        this.initializeLogging();
+        this.startLogProcessor();
+    }
+
+    public static getInstance(): Logger {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+
+    private async initializeLogging(): Promise<void> {
+        try {
+            await fs.mkdir(this.logDir, { recursive: true, mode: 0o700 });
+            
+            await this.initializeLogFile(this.logFile);
+            await this.initializeLogFile(this.errorLogFile);
+            await this.initializeLogFile(this.securityLogFile);
+            
+        } catch (error) {
+            console.error('Failed to initialize logging:', error);
+        }
+    }
+
+    private async initializeLogFile(filePath: string): Promise<void> {
+        try {
+            const exists = await this.fileExists(filePath);
+            if (!exists) {
+                const header = `# Log file created at ${new Date().toISOString()}\n`;
+                await fs.writeFile(filePath, header);
+            }
+        } catch (error) {
+            console.error(`Failed to initialize log file: ${filePath}`, error);
+        }
+    }
+
+    private startLogProcessor(): void {
+        setInterval(() => {
+            this.processLogQueue();
+        }, 1000);
+    }
+
+    private async processLogQueue(): Promise<void> {
+        if (this.isWriting || this.logQueue.length === 0) {
+            return;
+        }
+
+        this.isWriting = true;
+
+        try {
+            const entries = [...this.logQueue];
+            this.logQueue = [];
+
+            for (const entry of entries) {
+                await this.writeLog(entry);
+            }
+
+            await this.rotateLogIfNeeded(this.logFile);
+            await this.rotateLogIfNeeded(this.errorLogFile);
+            await this.rotateLogIfNeeded(this.securityLogFile);
+            
+        } catch (error) {
+            console.error('Failed to process log queue:', error);
+        } finally {
+            this.isWriting = false;
+        }
+    }
+
+    private async writeLog(entry: string): Promise<void> {
+        try {
+            let logFile = this.logFile;
+            
+            if (entry.includes('"level":"ERROR"') || entry.includes('"level":"CRITICAL"')) {
+                logFile = this.errorLogFile;
+            } else if (entry.includes('"level":"WARNING"')) {
+                logFile = this.securityLogFile;
+            }
+
+            await fs.appendFile(logFile, entry + '\n');
+            
+        } catch (error) {
+            console.error('Failed to write log:', error);
+        }
+    }
+
+    private async rotateLogIfNeeded(logFile: string): Promise<void> {
+        try {
+            const stats = await fs.stat(logFile);
+            
+            if (stats.size > this.maxLogSize) {
+                await this.rotateLog(logFile);
+            }
+        } catch {
+        }
+    }
+
+    private async rotateLog(logFile: string): Promise<void> {
+        for (let i = this.maxLogFiles - 1; i > 0; i--) {
+            const oldFile = `${logFile}.${i}`;
+            const newFile = `${logFile}.${i + 1}`;
+            
+            try {
+                await fs.rename(oldFile, newFile);
+            } catch {
+            }
+        }
+
+        await fs.rename(logFile, `${logFile}.1`);
+        await this.initializeLogFile(logFile);
+    }
+
+    private formatLogEntry(level: LogLevel, message: string, metadata?: any): string {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level: LogLevel[level],
+            pid: process.pid,
+            message,
+            metadata: metadata || {}
+        };
+
+        return JSON.stringify(entry);
+    }
+
+    private queueLog(level: LogLevel, message: string, metadata?: any): void {
+        const entry = this.formatLogEntry(level, message, metadata);
+        this.logQueue.push(entry);
+
+        if (process.env.NODE_ENV === 'development') {
+            const consoleMethod = this.getConsoleMethod(level);
+            console[consoleMethod](`[${LogLevel[level]}] ${message}`, metadata || '');
+        }
+    }
+
+    private getConsoleMethod(level: LogLevel): 'log' | 'info' | 'warn' | 'error' {
+        switch (level) {
+            case LogLevel.DEBUG:
+            case LogLevel.INFO:
+                return 'log';
+            case LogLevel.WARNING:
+                return 'warn';
+            case LogLevel.ERROR:
+            case LogLevel.CRITICAL:
+            case LogLevel.EMERGENCY:
+                return 'error';
+            default:
+                return 'log';
+        }
+    }
+
+    public debug(message: string, metadata?: any): void {
+        if (this.currentLogLevel <= LogLevel.DEBUG) {
+            this.queueLog(LogLevel.DEBUG, message, metadata);
+        }
+    }
+
+    public info(message: string, metadata?: any): void {
+        if (this.currentLogLevel <= LogLevel.INFO) {
+            this.queueLog(LogLevel.INFO, message, metadata);
+        }
+    }
+
+    public warning(message: string, metadata?: any): void {
+        if (this.currentLogLevel <= LogLevel.WARNING) {
+            this.queueLog(LogLevel.WARNING, message, metadata);
+        }
+    }
+
+    public error(message: string, metadata?: any): void {
+        if (this.currentLogLevel <= LogLevel.ERROR) {
+            this.queueLog(LogLevel.ERROR, message, metadata);
+        }
+    }
+
+    public critical(message: string, metadata?: any): void {
+        if (this.currentLogLevel <= LogLevel.CRITICAL) {
+            this.queueLog(LogLevel.CRITICAL, message, metadata);
+        }
+    }
+
+    public emergency(message: string, metadata?: any): void {
+        if (this.currentLogLevel <= LogLevel.EMERGENCY) {
+            this.queueLog(LogLevel.EMERGENCY, message, metadata);
+        }
+    }
+
+    public setLogLevel(level: LogLevel): void {
+        this.currentLogLevel = level;
+        this.info(`Log level changed to ${LogLevel[level]}`);
+    }
+
+    public async getLogs(level?: LogLevel, limit: number = 100): Promise<string[]> {
+        try {
+            const content = await fs.readFile(this.logFile, 'utf8');
+            const lines = content.split('\n').filter(line => line.trim());
+            
+            if (level !== undefined) {
+                const levelName = LogLevel[level];
+                return lines
+                    .filter(line => line.includes(`"level":"${levelName}"`))
+                    .slice(-limit);
+            }
+            
+            return lines.slice(-limit);
+        } catch {
+            return [];
+        }
+    }
+
+    public async getSecurityLogs(limit: number = 100): Promise<string[]> {
+        try {
+            const content = await fs.readFile(this.securityLogFile, 'utf8');
+            return content.split('\n').filter(line => line.trim()).slice(-limit);
+        } catch {
+            return [];
+        }
+    }
+
+    public async clearLogs(): Promise<void> {
+        try {
+            await fs.writeFile(this.logFile, '');
+            await fs.writeFile(this.errorLogFile, '');
+            await fs.writeFile(this.securityLogFile, '');
+            
+            this.info('Logs cleared');
+        } catch (error) {
+            console.error('Failed to clear logs:', error);
+        }
+    }
+
+    private async fileExists(filePath: string): Promise<boolean> {
+        try {
+            await fs.access(filePath);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    public getStatus(): any {
+        return {
+            logLevel: LogLevel[this.currentLogLevel],
+            logDir: this.logDir,
+            queueSize: this.logQueue.length,
+            isWriting: this.isWriting,
+            maxLogSize: this.maxLogSize,
+            maxLogFiles: this.maxLogFiles
+        };
+    }
+}

package/src/utils/Validator.ts

@@ -0,0 +1,248 @@
+import * as crypto from 'crypto';
+import * as path from 'path';
+import { SecurityConfig } from '../types';
+import { Logger } from './Logger';
+
+export class Validator {
+    private static instance: Validator;
+    private readonly logger: Logger;
+    private readonly config: SecurityConfig;
+
+    private constructor(config: SecurityConfig) {
+        this.logger = Logger.getInstance();
+        this.config = config;
+    }
+
+    public static getInstance(config?: SecurityConfig): Validator {
+        if (!Validator.instance && config) {
+            Validator.instance = new Validator(config);
+        }
+        return Validator.instance;
+    }
+
+    public validateFilePath(filePath: string): boolean {
+        try {
+            const normalized = path.normalize(filePath);
+            
+            if (normalized.includes('..')) {
+                this.logger.warning('Path traversal detected', { filePath });
+                return false;
+            }
+
+            if (filePath.includes('\0')) {
+                this.logger.warning('Null byte in path', { filePath });
+                return false;
+            }
+
+            if (/[\x00-\x1F\x7F]/.test(filePath)) {
+                this.logger.warning('Control characters in path', { filePath });
+                return false;
+            }
+
+            const suspiciousPatterns = [
+                /^\./,
+                /^\/etc/,
+                /^\/var/,
+                /^\/proc/,
+                /^\/dev/,
+                /^\/sys/,
+                /^\/boot/,
+                /^\/root/,
+                /^\/bin/,
+                /^\/sbin/,
+                /^\/usr/,
+                /^\/lib/
+            ];
+
+            for (const pattern of suspiciousPatterns) {
+                if (pattern.test(filePath)) {
+                    this.logger.warning('Suspicious path pattern', { filePath, pattern });
+                    return false;
+                }
+            }
+
+            return true;
+        } catch (error) {
+            this.logger.error('Path validation error', { error, filePath });
+            return false;
+        }
+    }
+
+    public validateFileName(fileName: string): boolean {
+        if (fileName.length === 0 || fileName.length > 255) {
+            return false;
+        }
+
+        const invalidChars = /[<>:"/\\|?*\x00-\x1F]/g;
+        if (invalidChars.test(fileName)) {
+            return false;
+        }
+
+        const reservedNames = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i;
+        if (reservedNames.test(fileName)) {
+            return false;
+        }
+
+        if (fileName.startsWith('.') && !fileName.startsWith('.')) {
+            return false;
+        }
+
+        if (/[\u200B-\u200D\uFEFF]/.test(fileName)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public validateFileExtension(extension: string): boolean {
+        const ext = extension.toLowerCase();
+        
+        if (this.config.allowedExtensions.length > 0) {
+            return this.config.allowedExtensions.includes(ext);
+        }
+
+        const dangerousExtensions = [
+            '.exe', '.dll', '.so', '.dylib', '.bin',
+            '.sh', '.bash', '.cmd', '.bat', '.ps1',
+            '.vbs', '.js', '.jar', '.class', '.py',
+            '.rb', '.pl', '.php', '.asp', '.aspx',
+            '.jsp', '.cgi', '.swf', '.apk', '.app',
+            '.deb', '.rpm', '.msi'
+        ];
+
+        return !dangerousExtensions.includes(ext);
+    }
+
+    public validateFileSize(size: number): boolean {
+        if (size <= 0) {
+            return false;
+        }
+
+        if (size > this.config.maxFileSize) {
+            this.logger.warning('File too large', { size, max: this.config.maxFileSize });
+            return false;
+        }
+
+        return true;
+    }
+
+    public validateHash(hash: string, algorithm: string = 'sha512'): boolean {
+        const hashLengths: Record<string, number> = {
+            md5: 32,
+            sha1: 40,
+            sha256: 64,
+            sha384: 96,
+            sha512: 128
+        };
+
+        const expectedLength = hashLengths[algorithm];
+        if (!expectedLength) {
+            return false;
+        }
+
+        if (hash.length !== expectedLength) {
+            return false;
+        }
+
+        return /^[0-9a-f]+$/i.test(hash);
+    }
+
+    public validateEmail(email: string): boolean {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(email);
+    }
+
+    public validateUrl(url: string): boolean {
+        try {
+            new URL(url);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    public validateIpAddress(ip: string): boolean {
+        const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+        const ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
+        
+        return ipv4Regex.test(ip) || ipv6Regex.test(ip);
+    }
+
+    public validatePort(port: number): boolean {
+        return port > 0 && port < 65536;
+    }
+
+    public validateTimestamp(timestamp: number): boolean {
+        const now = Date.now();
+        const oneYearAgo = now - 365 * 24 * 60 * 60 * 1000;
+        const oneYearFromNow = now + 365 * 24 * 60 * 60 * 1000;
+        
+        return timestamp > oneYearAgo && timestamp < oneYearFromNow;
+    }
+
+    public validatePermission(mode: number): boolean {
+        return mode >= 0 && mode <= 0o777;
+    }
+
+    public validateJson(json: string): boolean {
+        try {
+            JSON.parse(json);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    public validateBase64(str: string): boolean {
+        try {
+            const encoded = Buffer.from(str, 'base64').toString('base64');
+            return encoded === str;
+        } catch {
+            return false;
+        }
+    }
+
+    public validateHex(str: string): boolean {
+        return /^[0-9a-fA-F]+$/.test(str);
+    }
+
+    public validateAscii(str: string): boolean {
+        return /^[\x00-\x7F]*$/.test(str);
+    }
+
+    public validateUtf8(buffer: Buffer): boolean {
+        try {
+            buffer.toString('utf8');
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    public validateChecksum(data: Buffer, checksum: string): boolean {
+        const hash = crypto.createHash('sha256')
+            .update(data)
+            .digest('hex');
+            
+        return hash === checksum;
+    }
+
+    public validateConfig(config: any): boolean {
+        const requiredFields = [
+            'watchDir',
+            'hashAlgorithm',
+            'backupDir',
+            'maxFileSize',
+            'scanInterval'
+        ];
+
+        for (const field of requiredFields) {
+            if (!(field in config)) {
+                this.logger.error(`Missing required config field: ${field}`);
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

package/tests/setup.ts

@@ -0,0 +1,80 @@
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { Logger } from '../src/utils/Logger';
+jest.setTimeout(30000);
+jest.mock('../src/utils/Logger', () => {
+    return {
+        Logger: {
+            getInstance: jest.fn().mockReturnValue({
+                debug: jest.fn(),
+                info: jest.fn(),
+                warning: jest.fn(),
+                error: jest.fn(),
+                critical: jest.fn(),
+                emergency: jest.fn(),
+                setLogLevel: jest.fn(),
+                getLogs: jest.fn().mockResolvedValue([]),
+                getSecurityLogs: jest.fn().mockResolvedValue([]),
+                clearLogs: jest.fn().mockResolvedValue(undefined),
+                getStatus: jest.fn().mockReturnValue({})
+            })
+        },
+        LogLevel: {
+            DEBUG: 0,
+            INFO: 1,
+            WARNING: 2,
+            ERROR: 3,
+            CRITICAL: 4,
+            EMERGENCY: 5
+        }
+    };
+});
+
+const testDir = path.join(__dirname, 'temp');
+
+beforeAll(async () => {
+    try {
+        await fs.mkdir(testDir, { recursive: true });
+    } catch (error) {
+        console.error('Failed to create test directory:', error);
+    }
+});
+
+afterAll(async () => {
+    try {
+        await fs.rm(testDir, { recursive: true, force: true });
+    } catch (error) {
+        console.error('Failed to remove test directory:', error);
+    }
+});
+
+global.createTestFile = async (filename: string, content: string = 'test') => {
+    const filePath = path.join(testDir, filename);
+    await fs.writeFile(filePath, content);
+    return filePath;
+};
+
+global.createTestDirectory = async (dirname: string) => {
+    const dirPath = path.join(testDir, dirname);
+    await fs.mkdir(dirPath, { recursive: true });
+    return dirPath;
+};
+
+global.cleanupTestFiles = async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+    await fs.mkdir(testDir, { recursive: true });
+};
+
+declare global {
+    function createTestFile(filename: string, content?: string): Promise<string>;
+    function createTestDirectory(dirname: string): Promise<string>;
+    function cleanupTestFiles(): Promise<void>;
+    
+    namespace NodeJS {
+        interface Global {
+            createTestFile: typeof createTestFile;
+            createTestDirectory: typeof createTestDirectory;
+            cleanupTestFiles: typeof cleanupTestFiles;
+        }
+    }
+}

package/tsconfig.json

@@ -0,0 +1,42 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "inlineSources": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "removeComments": false,
+    "preserveConstEnums": true,
+    "stripInternal": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests", "**/*.test.ts"]
+}