filemayor 2.0.0

package/core/watcher.js

@@ -0,0 +1,478 @@
+#!/usr/bin/env node
+
+/**
+ * ═══════════════════════════════════════════════════════════════════
+ * FILEMAYOR CORE — WATCHER
+ * Real-time file system watcher with rules engine, event logging,
+ * auto-organize on file drop, and daemon mode for servers.
+ * ═══════════════════════════════════════════════════════════════════
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { EventEmitter } = require('events');
+const { categorize } = require('./categories');
+const { organize } = require('./organizer');
+const { validatePath, isDirSafe, isFileSafe } = require('./security');
+const { formatBytes } = require('./scanner');
+
+// ─── Watch Rules Engine ───────────────────────────────────────────
+
+/**
+ * @typedef {Object} WatchRule
+ * @property {string} match - Glob pattern (e.g. "*.pdf")
+ * @property {string} action - Action: move, copy, delete, log, organize
+ * @property {string} [dest] - Destination directory (for move/copy)
+ * @property {string} [naming] - Naming convention to apply
+ * @property {boolean} [enabled] - Whether this rule is active
+ */
+
+/**
+ * Check if a filename matches a glob-like pattern
+ * @param {string} pattern - Glob pattern
+ * @param {string} filename - Filename to test
+ * @returns {boolean}
+ */
+function matchRule(pattern, filename) {
+    // Support extension patterns: "*.pdf", "*.{jpg,png,gif}"
+    if (pattern.startsWith('*.')) {
+        const extPart = pattern.slice(1); // ".pdf" or ".{jpg,png,gif}"
+
+        if (extPart.startsWith('.{') && extPart.endsWith('}')) {
+            const exts = extPart.slice(2, -1).split(',').map(e => `.${e.trim()}`);
+            const fileExt = path.extname(filename).toLowerCase();
+            return exts.includes(fileExt);
+        }
+
+        return path.extname(filename).toLowerCase() === extPart.toLowerCase();
+    }
+
+    // Support category patterns: "@documents", "@images"
+    if (pattern.startsWith('@')) {
+        const category = pattern.slice(1).toLowerCase();
+        const ext = path.extname(filename).toLowerCase();
+        return categorize(ext) === category;
+    }
+
+    // Simple wildcard
+    const regex = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    return new RegExp(`^${regex}$`, 'i').test(filename);
+}
+
+// ─── Watcher Class ────────────────────────────────────────────────
+
+class FileWatcher extends EventEmitter {
+    constructor(options = {}) {
+        super();
+
+        this.options = {
+            directories: options.directories || [],
+            rules: options.rules || [],
+            debounceMs: options.debounceMs || 500,
+            recursive: options.recursive !== false,
+            ignoreHidden: options.ignoreHidden !== false,
+            logPath: options.logPath || null,
+            maxLogEntries: options.maxLogEntries || 10000,
+            autoOrganize: options.autoOrganize || false,
+            organizeOptions: options.organizeOptions || {},
+        };
+
+        this._watchers = new Map();
+        this._debounceTimers = new Map();
+        this._running = false;
+        this._eventLog = [];
+        this._stats = {
+            eventsProcessed: 0,
+            filesActioned: 0,
+            errors: 0,
+            startTime: null,
+            uptime: 0
+        };
+    }
+
+    /**
+     * Start watching configured directories
+     */
+    start() {
+        if (this._running) {
+            this.emit('warn', 'Watcher is already running');
+            return;
+        }
+
+        if (this.options.directories.length === 0) {
+            throw new Error('No directories configured to watch');
+        }
+
+        this._running = true;
+        this._stats.startTime = Date.now();
+
+        for (const dir of this.options.directories) {
+            this._watchDirectory(dir);
+        }
+
+        this.emit('started', {
+            directories: this.options.directories,
+            rules: this.options.rules.length,
+            timestamp: new Date().toISOString()
+        });
+
+        // Load log from disk if path specified
+        if (this.options.logPath) {
+            this._loadLog();
+        }
+    }
+
+    /**
+     * Stop all watchers
+     */
+    stop() {
+        this._running = false;
+
+        for (const [dir, watcher] of this._watchers) {
+            watcher.close();
+            this.emit('unwatched', { directory: dir });
+        }
+        this._watchers.clear();
+
+        // Clear debounce timers
+        for (const timer of this._debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this._debounceTimers.clear();
+
+        // Save log to disk
+        if (this.options.logPath) {
+            this._saveLog();
+        }
+
+        this._stats.uptime = Date.now() - this._stats.startTime;
+
+        this.emit('stopped', {
+            stats: { ...this._stats },
+            timestamp: new Date().toISOString()
+        });
+    }
+
+    /**
+     * Add a directory to watch
+     * @param {string} dir - Directory path
+     */
+    addDirectory(dir) {
+        const validation = validatePath(dir);
+        if (!validation.valid) {
+            throw new Error(`Invalid path: ${validation.error}`);
+        }
+        if (!this.options.directories.includes(validation.resolved)) {
+            this.options.directories.push(validation.resolved);
+        }
+        if (this._running) {
+            this._watchDirectory(validation.resolved);
+        }
+    }
+
+    /**
+     * Remove a watched directory
+     * @param {string} dir - Directory path
+     */
+    removeDirectory(dir) {
+        const resolved = path.resolve(dir);
+        const watcher = this._watchers.get(resolved);
+        if (watcher) {
+            watcher.close();
+            this._watchers.delete(resolved);
+        }
+        this.options.directories = this.options.directories.filter(d => d !== resolved);
+    }
+
+    /**
+     * Add a rule
+     * @param {WatchRule} rule
+     */
+    addRule(rule) {
+        this.options.rules.push(rule);
+        this.emit('rule-added', rule);
+    }
+
+    /**
+     * Get current statistics
+     */
+    getStats() {
+        return {
+            ...this._stats,
+            uptime: this._running ? Date.now() - this._stats.startTime : this._stats.uptime,
+            watchedDirs: this._watchers.size,
+            rules: this.options.rules.length,
+            logEntries: this._eventLog.length,
+            running: this._running
+        };
+    }
+
+    /**
+     * Get event log
+     * @param {number} limit - Max entries to return
+     */
+    getLog(limit = 100) {
+        return this._eventLog.slice(-limit);
+    }
+
+    /**
+     * Internal: set up fs.watch on a directory
+     */
+    _watchDirectory(dirPath) {
+        const resolved = path.resolve(dirPath);
+
+        // Validate
+        const safeCheck = isDirSafe(resolved);
+        if (!safeCheck.safe) {
+            this.emit('error', { directory: resolved, error: safeCheck.reason });
+            return;
+        }
+
+        // Check directory exists
+        try {
+            if (!fs.statSync(resolved).isDirectory()) {
+                this.emit('error', { directory: resolved, error: 'Not a directory' });
+                return;
+            }
+        } catch (err) {
+            this.emit('error', { directory: resolved, error: err.message });
+            return;
+        }
+
+        // Already watching?
+        if (this._watchers.has(resolved)) return;
+
+        try {
+            const watcher = fs.watch(resolved, {
+                recursive: this.options.recursive,
+                persistent: true
+            }, (eventType, filename) => {
+                if (!filename) return;
+                this._handleEvent(eventType, filename, resolved);
+            });
+
+            watcher.on('error', (err) => {
+                this.emit('error', { directory: resolved, error: err.message });
+                this._watchers.delete(resolved);
+            });
+
+            this._watchers.set(resolved, watcher);
+
+            this.emit('watching', {
+                directory: resolved,
+                recursive: this.options.recursive,
+                timestamp: new Date().toISOString()
+            });
+        } catch (err) {
+            this.emit('error', { directory: resolved, error: err.message });
+        }
+    }
+
+    /**
+     * Internal: handle a file system event with debouncing
+     */
+    _handleEvent(eventType, filename, watchDir) {
+        if (this.options.ignoreHidden && filename.startsWith('.')) return;
+
+        const fullPath = path.join(watchDir, filename);
+        const debounceKey = fullPath;
+
+        // Debounce rapid events on the same file
+        if (this._debounceTimers.has(debounceKey)) {
+            clearTimeout(this._debounceTimers.get(debounceKey));
+        }
+
+        this._debounceTimers.set(debounceKey, setTimeout(() => {
+            this._debounceTimers.delete(debounceKey);
+            this._processEvent(eventType, filename, fullPath, watchDir);
+        }, this.options.debounceMs));
+    }
+
+    /**
+     * Internal: process a debounced event
+     */
+    _processEvent(eventType, filename, fullPath, watchDir) {
+        this._stats.eventsProcessed++;
+
+        // Check if file still exists (it might have been a delete event)
+        let exists = false;
+        let stats = null;
+        try {
+            stats = fs.statSync(fullPath);
+            exists = true;
+        } catch { /* file was deleted or moved */ }
+
+        const event = {
+            type: eventType,
+            filename,
+            path: fullPath,
+            watchDir,
+            exists,
+            size: stats ? stats.size : 0,
+            sizeHuman: stats ? formatBytes(stats.size) : '0 B',
+            category: exists ? categorize(path.extname(filename).toLowerCase()) : null,
+            timestamp: new Date().toISOString()
+        };
+
+        // Log the event
+        this._logEvent(event);
+
+        // Emit raw event
+        this.emit('change', event);
+
+        // Only process rules for new/changed files
+        if (!exists || !stats.isFile()) return;
+
+        // Check rules
+        for (const rule of this.options.rules) {
+            if (rule.enabled === false) continue;
+            if (!matchRule(rule.match, filename)) continue;
+
+            this.emit('rule-matched', { rule, event });
+            this._executeRule(rule, event);
+            break; // First match wins
+        }
+
+        // Auto-organize if enabled
+        if (this.options.autoOrganize && eventType === 'rename') {
+            // A new file appeared — organize the directory
+            try {
+                organize(watchDir, {
+                    dryRun: false,
+                    ...this.options.organizeOptions
+                });
+                this.emit('auto-organized', { directory: watchDir, trigger: filename });
+            } catch (err) {
+                this.emit('error', { action: 'auto-organize', error: err.message });
+            }
+        }
+    }
+
+    /**
+     * Execute a matched rule
+     */
+    _executeRule(rule, event) {
+        const safeCheck = isFileSafe(event.path);
+        if (!safeCheck.safe) {
+            this.emit('rule-skipped', {
+                rule,
+                event,
+                reason: safeCheck.reason
+            });
+            return;
+        }
+
+        try {
+            switch (rule.action) {
+                case 'move':
+                    if (!rule.dest) break;
+                    const destDir = path.resolve(rule.dest);
+                    fs.mkdirSync(destDir, { recursive: true });
+                    const destPath = path.join(destDir, event.filename);
+                    fs.renameSync(event.path, destPath);
+                    this._stats.filesActioned++;
+                    this.emit('action', {
+                        action: 'move',
+                        source: event.path,
+                        destination: destPath,
+                        rule
+                    });
+                    break;
+
+                case 'copy':
+                    if (!rule.dest) break;
+                    const copyDestDir = path.resolve(rule.dest);
+                    fs.mkdirSync(copyDestDir, { recursive: true });
+                    const copyDest = path.join(copyDestDir, event.filename);
+                    fs.copyFileSync(event.path, copyDest);
+                    this._stats.filesActioned++;
+                    this.emit('action', {
+                        action: 'copy',
+                        source: event.path,
+                        destination: copyDest,
+                        rule
+                    });
+                    break;
+
+                case 'delete':
+                    fs.unlinkSync(event.path);
+                    this._stats.filesActioned++;
+                    this.emit('action', {
+                        action: 'delete',
+                        source: event.path,
+                        rule
+                    });
+                    break;
+
+                case 'log':
+                    this.emit('action', {
+                        action: 'log',
+                        source: event.path,
+                        message: `Matched rule: ${rule.match}`,
+                        rule
+                    });
+                    break;
+            }
+        } catch (err) {
+            this._stats.errors++;
+            this.emit('error', {
+                action: rule.action,
+                path: event.path,
+                error: err.message,
+                rule
+            });
+        }
+    }
+
+    /**
+     * Log an event to memory and optionally disk
+     */
+    _logEvent(event) {
+        this._eventLog.push(event);
+
+        // Trim log if too large
+        if (this._eventLog.length > this.options.maxLogEntries) {
+            this._eventLog = this._eventLog.slice(-this.options.maxLogEntries);
+        }
+    }
+
+    /**
+     * Save event log to disk
+     */
+    _saveLog() {
+        if (!this.options.logPath) return;
+        try {
+            fs.writeFileSync(
+                this.options.logPath,
+                JSON.stringify(this._eventLog, null, 2),
+                'utf8'
+            );
+        } catch (err) {
+            this.emit('error', { action: 'save-log', error: err.message });
+        }
+    }
+
+    /**
+     * Load event log from disk
+     */
+    _loadLog() {
+        if (!this.options.logPath) return;
+        try {
+            if (fs.existsSync(this.options.logPath)) {
+                this._eventLog = JSON.parse(
+                    fs.readFileSync(this.options.logPath, 'utf8')
+                );
+            }
+        } catch { /* start fresh */ }
+    }
+}
+
+module.exports = {
+    FileWatcher,
+    matchRule
+};