688 lines
26 KiB
TypeScript
688 lines
26 KiB
TypeScript
import * as fs from 'fs';
|
|
import * as path from 'path';
|
|
import * as smartrx from '@push.rocks/smartrx';
|
|
import type { IWatcher, IWatcherOptions, IWatchEvent, TWatchEventType } from './interfaces.js';
|
|
|
|
/**
|
|
* Node.js/Bun file watcher using native fs.watch API
|
|
*/
|
|
export class NodeWatcher implements IWatcher {
|
|
private watchers: Map<string, fs.FSWatcher> = new Map();
|
|
private watchedFiles: Set<string> = new Set();
|
|
private _isWatching = false;
|
|
|
|
// Debounce: pending emits per file path
|
|
// Fix 2: Track event sequence instead of just last event type
|
|
// This prevents losing intermediate events (add→change→delete should not lose add)
|
|
private pendingEmits: Map<string, {
|
|
timeout: NodeJS.Timeout;
|
|
events: Array<'rename' | 'change'>;
|
|
}> = new Map();
|
|
|
|
// Restart tracking
|
|
private restartDelays: Map<string, number> = new Map();
|
|
private restartAttempts: Map<string, number> = new Map();
|
|
private healthCheckInterval: NodeJS.Timeout | null = null;
|
|
|
|
// Inode tracking - detect when directories are replaced (atomic saves, etc.)
|
|
// fs.watch watches the inode, not the path. If inode changes, we need to restart.
|
|
private watchedInodes: Map<string, bigint> = new Map();
|
|
|
|
// File inode tracking - detect when individual files are deleted and recreated
|
|
// This is critical: editors delete+recreate files, fs.watch watches OLD inode!
|
|
// See: https://github.com/paulmillr/chokidar/issues/972
|
|
private fileInodes: Map<string, bigint> = new Map();
|
|
|
|
// Abort controllers for pending restart delays - prevents orphan watchers on stop()
|
|
private restartAbortControllers: Map<string, AbortController> = new Map();
|
|
|
|
// Prevent concurrent restarts for the same path (health check + error can race)
|
|
private restartingPaths: Set<string> = new Set();
|
|
|
|
// Initial scan state - events are deferred until scan completes to avoid race conditions
|
|
// Without this, events can arrive before watchedFiles is populated, causing inconsistent state
|
|
private initialScanComplete: boolean = false;
|
|
private deferredEvents: Array<{basePath: string; filename: string; eventType: string}> = [];
|
|
|
|
// Configuration constants
|
|
private static readonly MAX_RETRIES = 3;
|
|
private static readonly INITIAL_RESTART_DELAY = 1000;
|
|
private static readonly MAX_RESTART_DELAY = 30000;
|
|
private static readonly HEALTH_CHECK_INTERVAL = 30000;
|
|
|
|
public readonly events$ = new smartrx.rxjs.Subject<IWatchEvent>();
|
|
|
|
constructor(private options: IWatcherOptions) {}
|
|
|
|
/**
|
|
* Safely emit an event, catching any subscriber errors
|
|
*/
|
|
private safeEmit(event: IWatchEvent): void {
|
|
try {
|
|
this.events$.next(event);
|
|
} catch (error) {
|
|
console.error('[smartwatch] Subscriber threw error (isolated):', error);
|
|
// Don't let subscriber errors kill the watcher
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Restart a watcher after an error with exponential backoff
|
|
* Includes guards against:
|
|
* - Dual restart race condition (health check + error handler calling simultaneously)
|
|
* - Orphan watchers when stop() is called during restart delay
|
|
*/
|
|
private async restartWatcher(basePath: string, error: Error): Promise<void> {
|
|
// Guard: Prevent concurrent restarts for the same path
|
|
if (this.restartingPaths.has(basePath)) {
|
|
console.log(`[smartwatch] Restart already in progress for ${basePath}, skipping`);
|
|
return;
|
|
}
|
|
this.restartingPaths.add(basePath);
|
|
|
|
try {
|
|
const attempts = (this.restartAttempts.get(basePath) || 0) + 1;
|
|
this.restartAttempts.set(basePath, attempts);
|
|
|
|
console.log(`[smartwatch] Watcher error for ${basePath}: ${error.message}`);
|
|
console.log(`[smartwatch] Restart attempt ${attempts}/${NodeWatcher.MAX_RETRIES}`);
|
|
|
|
if (attempts > NodeWatcher.MAX_RETRIES) {
|
|
console.error(`[smartwatch] Max retries exceeded for ${basePath}, giving up`);
|
|
this.safeEmit({
|
|
type: 'error',
|
|
path: basePath,
|
|
error: new Error(`Max restart retries (${NodeWatcher.MAX_RETRIES}) exceeded`)
|
|
});
|
|
return;
|
|
}
|
|
|
|
// Close failed watcher
|
|
const oldWatcher = this.watchers.get(basePath);
|
|
if (oldWatcher) {
|
|
try {
|
|
oldWatcher.close();
|
|
} catch {
|
|
// Ignore close errors
|
|
}
|
|
this.watchers.delete(basePath);
|
|
}
|
|
|
|
// Exponential backoff with AbortController (so stop() can cancel)
|
|
const delay = this.restartDelays.get(basePath) || NodeWatcher.INITIAL_RESTART_DELAY;
|
|
console.log(`[smartwatch] Waiting ${delay}ms before restart...`);
|
|
|
|
const abortController = new AbortController();
|
|
this.restartAbortControllers.set(basePath, abortController);
|
|
|
|
try {
|
|
await new Promise<void>((resolve, reject) => {
|
|
const timeout = setTimeout(resolve, delay);
|
|
abortController.signal.addEventListener('abort', () => {
|
|
clearTimeout(timeout);
|
|
reject(new Error('Restart aborted by stop()'));
|
|
});
|
|
});
|
|
} catch (abortError) {
|
|
console.log(`[smartwatch] Restart aborted for ${basePath}`);
|
|
return; // stop() was called, don't continue
|
|
} finally {
|
|
this.restartAbortControllers.delete(basePath);
|
|
}
|
|
|
|
// Double-check we're still watching after the delay
|
|
if (!this._isWatching) {
|
|
console.log(`[smartwatch] Watcher stopped during restart delay, aborting`);
|
|
return;
|
|
}
|
|
|
|
this.restartDelays.set(basePath, Math.min(delay * 2, NodeWatcher.MAX_RESTART_DELAY));
|
|
|
|
try {
|
|
await this.watchPath(basePath, 0);
|
|
console.log(`[smartwatch] Successfully restarted watcher for ${basePath}`);
|
|
this.restartDelays.set(basePath, NodeWatcher.INITIAL_RESTART_DELAY);
|
|
this.restartAttempts.set(basePath, 0);
|
|
} catch (restartError) {
|
|
console.error(`[smartwatch] Restart failed for ${basePath}:`, restartError);
|
|
// Clear restartingPaths before recursive call
|
|
this.restartingPaths.delete(basePath);
|
|
this.restartWatcher(basePath, restartError as Error); // Recursive retry
|
|
return; // Don't delete from restartingPaths again in finally
|
|
}
|
|
} finally {
|
|
this.restartingPaths.delete(basePath);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Start periodic health checks to detect silent failures
|
|
* Checks for:
|
|
* 1. Path no longer exists
|
|
* 2. Inode changed (directory was replaced - fs.watch watches inode, not path!)
|
|
*/
|
|
private startHealthCheck(): void {
|
|
console.log('[smartwatch] Starting health check (every 30s)');
|
|
this.healthCheckInterval = setInterval(async () => {
|
|
console.log(`[smartwatch] Health check: ${this.watchers.size} watchers active`);
|
|
for (const [basePath] of this.watchers) {
|
|
try {
|
|
const stats = await fs.promises.stat(basePath);
|
|
const currentInode = stats.ino;
|
|
const previousInode = this.watchedInodes.get(basePath);
|
|
|
|
if (!stats) {
|
|
console.error(`[smartwatch] Health check failed: ${basePath} no longer exists`);
|
|
this.safeEmit({
|
|
type: 'error',
|
|
path: basePath,
|
|
error: new Error('Watched path no longer exists')
|
|
});
|
|
this.restartWatcher(basePath, new Error('Watched path disappeared'));
|
|
} else if (previousInode !== undefined && BigInt(currentInode) !== previousInode) {
|
|
// CRITICAL: Inode changed! fs.watch is now watching a stale inode.
|
|
// This happens when the directory is replaced (atomic operations, git checkout, etc.)
|
|
console.warn(`[smartwatch] Inode changed for ${basePath}: ${previousInode} -> ${currentInode}`);
|
|
console.warn('[smartwatch] fs.watch watches inode, not path - restarting watcher');
|
|
this.restartWatcher(basePath, new Error('Inode changed - directory was replaced'));
|
|
}
|
|
} catch (error: any) {
|
|
if (error.code === 'ENOENT') {
|
|
console.error(`[smartwatch] Health check failed: ${basePath} no longer exists`);
|
|
this.restartWatcher(basePath, new Error('Watched path disappeared'));
|
|
} else if (error.code === 'ENOSPC') {
|
|
// inotify watch limit exceeded - critical system issue
|
|
console.error(`[smartwatch] ENOSPC: inotify watch limit exceeded!`);
|
|
console.error('[smartwatch] Fix: echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p');
|
|
this.safeEmit({ type: 'error', path: basePath, error });
|
|
} else {
|
|
console.error(`[smartwatch] Health check error for ${basePath}:`, error);
|
|
}
|
|
}
|
|
}
|
|
}, NodeWatcher.HEALTH_CHECK_INTERVAL);
|
|
}
|
|
|
|
/**
|
|
* Stop health check interval
|
|
*/
|
|
private stopHealthCheck(): void {
|
|
if (this.healthCheckInterval) {
|
|
clearInterval(this.healthCheckInterval);
|
|
this.healthCheckInterval = null;
|
|
console.log('[smartwatch] Stopped health check');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if a file is a temporary file created by editors
|
|
*/
|
|
private isTemporaryFile(filePath: string): boolean {
|
|
const basename = path.basename(filePath);
|
|
// Editor temp files: *.tmp.*, *.swp, *.swx, *~, .#*
|
|
if (basename.includes('.tmp.')) return true;
|
|
if (basename.endsWith('.swp') || basename.endsWith('.swx')) return true;
|
|
if (basename.endsWith('~')) return true;
|
|
if (basename.startsWith('.#')) return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Extract the real file path from a temporary file path
|
|
* Used to detect atomic writes where only the temp file event is emitted
|
|
*
|
|
* Patterns:
|
|
* - Claude Code: file.ts.tmp.PID.TIMESTAMP -> file.ts
|
|
* - Vim swap: .file.ts.swp -> file.ts (but we don't handle this case)
|
|
*/
|
|
private getTempFileTarget(tempFilePath: string): string | null {
|
|
const basename = path.basename(tempFilePath);
|
|
|
|
// Claude Code pattern: file.ts.tmp.PID.TIMESTAMP
|
|
// Match: anything.tmp.digits.digits
|
|
const claudeMatch = basename.match(/^(.+)\.tmp\.\d+\.\d+$/);
|
|
if (claudeMatch) {
|
|
const realBasename = claudeMatch[1];
|
|
return path.join(path.dirname(tempFilePath), realBasename);
|
|
}
|
|
|
|
// Generic .tmp. pattern: file.ts.tmp.something -> file.ts
|
|
const tmpMatch = basename.match(/^(.+)\.tmp\.[^.]+$/);
|
|
if (tmpMatch) {
|
|
const realBasename = tmpMatch[1];
|
|
return path.join(path.dirname(tempFilePath), realBasename);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
get isWatching(): boolean {
|
|
return this._isWatching;
|
|
}
|
|
|
|
async start(): Promise<void> {
|
|
if (this._isWatching) {
|
|
return;
|
|
}
|
|
|
|
console.log(`[smartwatch] Starting watcher for ${this.options.basePaths.length} base path(s)...`);
|
|
|
|
try {
|
|
// Reset initial scan state
|
|
this.initialScanComplete = false;
|
|
this.deferredEvents = [];
|
|
|
|
// Start watching each base path
|
|
// NOTE: Events may arrive immediately but will be deferred until scan completes
|
|
for (const basePath of this.options.basePaths) {
|
|
await this.watchPath(basePath, 0);
|
|
}
|
|
|
|
this._isWatching = true;
|
|
|
|
// Start health check monitoring
|
|
this.startHealthCheck();
|
|
|
|
// Perform initial scan to emit 'add' events for existing files
|
|
// This populates watchedFiles and fileInodes BEFORE we process events
|
|
for (const basePath of this.options.basePaths) {
|
|
await this.scanDirectory(basePath, 0);
|
|
}
|
|
|
|
// Mark scan complete and process any events that arrived during scan
|
|
this.initialScanComplete = true;
|
|
if (this.deferredEvents.length > 0) {
|
|
console.log(`[smartwatch] Processing ${this.deferredEvents.length} deferred events from initial scan window`);
|
|
for (const event of this.deferredEvents) {
|
|
this.handleFsEvent(event.basePath, event.filename, event.eventType);
|
|
}
|
|
this.deferredEvents = [];
|
|
}
|
|
|
|
// Emit ready event
|
|
this.safeEmit({ type: 'ready', path: '' });
|
|
console.log(`[smartwatch] Watcher started with ${this.watchers.size} active watcher(s)`);
|
|
} catch (error: any) {
|
|
console.error('[smartwatch] Failed to start watcher:', error);
|
|
this.safeEmit({ type: 'error', path: '', error });
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async stop(): Promise<void> {
|
|
console.log('[smartwatch] Stopping watcher...');
|
|
|
|
// Fix 4: Cancel pending debounced emits FIRST (before flag changes)
|
|
// This prevents handleFsEvent from creating new pendingEmits during shutdown
|
|
for (const pending of this.pendingEmits.values()) {
|
|
clearTimeout(pending.timeout);
|
|
}
|
|
this.pendingEmits.clear();
|
|
|
|
// NOW set the flag - handleFsEvent will return early after this
|
|
this._isWatching = false;
|
|
|
|
// Stop health check monitoring
|
|
this.stopHealthCheck();
|
|
|
|
// Abort all pending restart delays (prevents orphan watchers)
|
|
for (const [path, controller] of this.restartAbortControllers) {
|
|
console.log(`[smartwatch] Aborting pending restart for: ${path}`);
|
|
controller.abort();
|
|
}
|
|
this.restartAbortControllers.clear();
|
|
|
|
// Close all watchers
|
|
for (const [watchPath, watcher] of this.watchers) {
|
|
console.log(`[smartwatch] Closing watcher for: ${watchPath}`);
|
|
watcher.close();
|
|
}
|
|
this.watchers.clear();
|
|
this.watchedFiles.clear();
|
|
|
|
// Clear all tracking state
|
|
this.restartDelays.clear();
|
|
this.restartAttempts.clear();
|
|
this.watchedInodes.clear();
|
|
this.fileInodes.clear();
|
|
this.restartingPaths.clear();
|
|
|
|
// Fix 5: Reset initial scan state
|
|
this.initialScanComplete = false;
|
|
this.deferredEvents = [];
|
|
|
|
console.log('[smartwatch] Watcher stopped');
|
|
}
|
|
|
|
/**
|
|
* Start watching a path (file or directory)
|
|
*/
|
|
private async watchPath(watchPath: string, depth: number): Promise<void> {
|
|
if (depth > this.options.depth) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const stats = await this.statSafe(watchPath);
|
|
if (!stats) {
|
|
return;
|
|
}
|
|
|
|
if (stats.isDirectory()) {
|
|
// Store inode for health check - fs.watch watches inode, not path!
|
|
// If inode changes (directory replaced), watcher becomes stale
|
|
this.watchedInodes.set(watchPath, BigInt(stats.ino));
|
|
|
|
// Watch the directory with recursive option (Node.js 20+ supports this on all platforms)
|
|
const watcher = fs.watch(
|
|
watchPath,
|
|
{ recursive: true, persistent: true },
|
|
(eventType, filename) => {
|
|
if (filename) {
|
|
this.handleFsEvent(watchPath, filename, eventType);
|
|
}
|
|
}
|
|
);
|
|
|
|
watcher.on('error', (error: NodeJS.ErrnoException) => {
|
|
console.error(`[smartwatch] FSWatcher error event on ${watchPath}:`, error);
|
|
|
|
// Detect inotify watch limit exceeded - common cause of "stops working"
|
|
if (error.code === 'ENOSPC') {
|
|
console.error('[smartwatch] CRITICAL: inotify watch limit exceeded!');
|
|
console.error('[smartwatch] Fix with: echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p');
|
|
}
|
|
|
|
this.safeEmit({ type: 'error', path: watchPath, error });
|
|
if (this._isWatching) {
|
|
this.restartWatcher(watchPath, error);
|
|
}
|
|
});
|
|
|
|
// Handle 'close' event - fs.watch can close without error
|
|
watcher.on('close', () => {
|
|
// Only log/restart if we didn't intentionally stop
|
|
if (this._isWatching) {
|
|
console.warn(`[smartwatch] FSWatcher closed unexpectedly for ${watchPath}`);
|
|
this.restartWatcher(watchPath, new Error('Watcher closed unexpectedly'));
|
|
}
|
|
});
|
|
|
|
this.watchers.set(watchPath, watcher);
|
|
console.log(`[smartwatch] Started watching: ${watchPath}`);
|
|
}
|
|
} catch (error: any) {
|
|
console.error(`[smartwatch] Failed to watch path ${watchPath}:`, error);
|
|
this.safeEmit({ type: 'error', path: watchPath, error });
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handle raw fs.watch events - debounce and normalize them
|
|
*/
|
|
private handleFsEvent(
|
|
basePath: string,
|
|
filename: string,
|
|
eventType: 'rename' | 'change' | string
|
|
): void {
|
|
// Fix 3: Guard against post-stop events (events queued before watcher closed)
|
|
if (!this._isWatching) {
|
|
return;
|
|
}
|
|
|
|
// Fix 1: Defer events until initial scan completes
|
|
// This prevents race conditions where events arrive before watchedFiles is populated
|
|
if (!this.initialScanComplete) {
|
|
this.deferredEvents.push({ basePath, filename, eventType });
|
|
return;
|
|
}
|
|
|
|
const fullPath = path.join(basePath, filename);
|
|
|
|
// Handle temporary files from atomic writes (Claude Code, editors, etc.)
|
|
// Pattern: editor writes to file.tmp.xxx then renames to file
|
|
// Problem: fs.watch on Linux may ONLY emit event for the temp file, not the target!
|
|
// Solution: When we see a temp file event, also check the corresponding real file
|
|
if (this.isTemporaryFile(fullPath)) {
|
|
console.log(`[smartwatch] Detected temp file event: ${filename}`);
|
|
|
|
// Extract the real file path from the temp file path
|
|
// Pattern: file.ts.tmp.PID.TIMESTAMP -> file.ts
|
|
const realFilePath = this.getTempFileTarget(fullPath);
|
|
if (realFilePath) {
|
|
console.log(`[smartwatch] Checking corresponding real file: ${realFilePath}`);
|
|
// Queue an event for the REAL file - this is the actual file that changed
|
|
// Use a short delay to let the rename complete
|
|
setTimeout(() => {
|
|
if (this._isWatching) {
|
|
this.handleFsEvent(basePath, path.relative(basePath, realFilePath), 'change');
|
|
}
|
|
}, 50);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Fix 2: Track event sequence in debounce instead of collapsing to last event
|
|
// This ensures we don't lose intermediate events (e.g., add→change→delete)
|
|
const existing = this.pendingEmits.get(fullPath);
|
|
if (existing) {
|
|
// Cancel existing timeout but KEEP the event sequence
|
|
clearTimeout(existing.timeout);
|
|
// Add this event to the sequence
|
|
existing.events.push(eventType as 'rename' | 'change');
|
|
// Reschedule the emit with the accumulated events
|
|
existing.timeout = setTimeout(() => {
|
|
const pending = this.pendingEmits.get(fullPath);
|
|
if (pending) {
|
|
this.pendingEmits.delete(fullPath);
|
|
this.emitFileEvent(fullPath, pending.events);
|
|
}
|
|
}, this.options.debounceMs);
|
|
} else {
|
|
// First event for this file - create new sequence
|
|
const timeout = setTimeout(() => {
|
|
const pending = this.pendingEmits.get(fullPath);
|
|
if (pending) {
|
|
this.pendingEmits.delete(fullPath);
|
|
this.emitFileEvent(fullPath, pending.events);
|
|
}
|
|
}, this.options.debounceMs);
|
|
|
|
this.pendingEmits.set(fullPath, {
|
|
timeout,
|
|
events: [eventType as 'rename' | 'change']
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Emit the actual file event after debounce
|
|
*
|
|
* Fix 2: Now receives event sequence instead of single event type
|
|
* This allows intelligent processing of rapid event sequences:
|
|
* - add→change→delete: File was created and deleted rapidly
|
|
* - rename→rename: File was deleted and recreated (or vice versa)
|
|
*
|
|
* Also handles file inode tracking to detect delete+recreate scenarios:
|
|
* - fs.watch watches the inode, not the path
|
|
* - When editors delete+recreate files, the inode changes
|
|
* - Without inode tracking, events for the new file would be missed
|
|
* - See: https://github.com/paulmillr/chokidar/issues/972
|
|
*/
|
|
private async emitFileEvent(
|
|
fullPath: string,
|
|
eventSequence: Array<'rename' | 'change'>
|
|
): Promise<void> {
|
|
try {
|
|
const stats = await this.statSafe(fullPath);
|
|
const wasWatched = this.watchedFiles.has(fullPath);
|
|
const previousInode = this.fileInodes.get(fullPath);
|
|
|
|
// Analyze event sequence to understand what happened
|
|
const hasRename = eventSequence.includes('rename');
|
|
const hasChange = eventSequence.includes('change');
|
|
const renameCount = eventSequence.filter(e => e === 'rename').length;
|
|
|
|
// Log sequence for debugging complex scenarios
|
|
if (eventSequence.length > 1) {
|
|
console.log(`[smartwatch] Processing event sequence for ${fullPath}: [${eventSequence.join(', ')}]`);
|
|
}
|
|
|
|
if (stats) {
|
|
// File EXISTS now
|
|
const currentInode = BigInt(stats.ino);
|
|
const inodeChanged = previousInode !== undefined && previousInode !== currentInode;
|
|
|
|
if (stats.isDirectory()) {
|
|
if (!wasWatched) {
|
|
this.watchedFiles.add(fullPath);
|
|
this.safeEmit({ type: 'addDir', path: fullPath, stats });
|
|
}
|
|
// Directories don't track inodes at file level
|
|
} else {
|
|
// Update tracking
|
|
this.fileInodes.set(fullPath, currentInode);
|
|
this.watchedFiles.add(fullPath);
|
|
|
|
if (!wasWatched) {
|
|
// File wasn't tracked before - this is an add
|
|
// Even if there were multiple events, the end result is a new file
|
|
this.safeEmit({ type: 'add', path: fullPath, stats });
|
|
} else if (inodeChanged) {
|
|
// File was recreated with different inode (delete+recreate)
|
|
console.log(`[smartwatch] File inode changed (delete+recreate): ${fullPath}`);
|
|
console.log(`[smartwatch] Previous inode: ${previousInode}, current: ${currentInode}`);
|
|
// Multiple rename events with inode change = delete+recreate pattern
|
|
// Emit unlink for the old file, then add for the new one
|
|
if (renameCount >= 2) {
|
|
this.safeEmit({ type: 'unlink', path: fullPath });
|
|
this.safeEmit({ type: 'add', path: fullPath, stats });
|
|
} else {
|
|
// Single rename with inode change = atomic save (emit as change)
|
|
this.safeEmit({ type: 'change', path: fullPath, stats });
|
|
}
|
|
} else if (hasChange || hasRename) {
|
|
// File exists, was tracked, inode same - content changed
|
|
this.safeEmit({ type: 'change', path: fullPath, stats });
|
|
}
|
|
}
|
|
} else {
|
|
// File does NOT exist now - it was deleted
|
|
const wasDir = this.isKnownDirectory(fullPath);
|
|
|
|
if (wasWatched) {
|
|
// File was tracked and is now gone
|
|
this.watchedFiles.delete(fullPath);
|
|
this.fileInodes.delete(fullPath);
|
|
|
|
// If there were multiple events, file may have been created then deleted
|
|
if (renameCount >= 2 && !wasDir) {
|
|
// add→delete sequence - emit both events
|
|
console.log(`[smartwatch] File created and deleted rapidly: ${fullPath}`);
|
|
this.safeEmit({ type: 'add', path: fullPath });
|
|
this.safeEmit({ type: 'unlink', path: fullPath });
|
|
} else {
|
|
this.safeEmit({
|
|
type: wasDir ? 'unlinkDir' : 'unlink',
|
|
path: fullPath
|
|
});
|
|
}
|
|
} else {
|
|
// File wasn't tracked - but events occurred for it
|
|
this.fileInodes.delete(fullPath);
|
|
|
|
if (renameCount >= 2) {
|
|
// Multiple rename events for untracked file that doesn't exist
|
|
// Likely: created → deleted rapidly
|
|
console.log(`[smartwatch] Untracked file created and deleted: ${fullPath}`);
|
|
this.safeEmit({ type: 'add', path: fullPath });
|
|
this.safeEmit({ type: 'unlink', path: fullPath });
|
|
} else if (hasRename) {
|
|
// Single event for file that doesn't exist and wasn't tracked
|
|
console.log(`[smartwatch] Untracked file deleted: ${fullPath}`);
|
|
this.safeEmit({ type: 'unlink', path: fullPath });
|
|
}
|
|
// If only 'change' events for non-existent untracked file, ignore
|
|
}
|
|
}
|
|
} catch (error: any) {
|
|
this.safeEmit({ type: 'error', path: fullPath, error });
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Scan directory and emit 'add' events for existing files
|
|
*/
|
|
private async scanDirectory(dirPath: string, depth: number): Promise<void> {
|
|
if (depth > this.options.depth) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
|
|
|
|
for (const entry of entries) {
|
|
const fullPath = path.join(dirPath, entry.name);
|
|
|
|
// Skip temp files during initial scan too
|
|
if (this.isTemporaryFile(fullPath)) {
|
|
continue;
|
|
}
|
|
|
|
const stats = await this.statSafe(fullPath);
|
|
|
|
if (!stats) {
|
|
continue;
|
|
}
|
|
|
|
if (entry.isDirectory()) {
|
|
this.watchedFiles.add(fullPath);
|
|
this.safeEmit({ type: 'addDir', path: fullPath, stats });
|
|
await this.scanDirectory(fullPath, depth + 1);
|
|
} else if (entry.isFile()) {
|
|
this.watchedFiles.add(fullPath);
|
|
// Track file inode for delete+recreate detection
|
|
this.fileInodes.set(fullPath, BigInt(stats.ino));
|
|
this.safeEmit({ type: 'add', path: fullPath, stats });
|
|
}
|
|
}
|
|
} catch (error: any) {
|
|
if (error.code !== 'ENOENT' && error.code !== 'EACCES') {
|
|
this.safeEmit({ type: 'error', path: dirPath, error });
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Safely stat a path, returning null if it doesn't exist
|
|
*/
|
|
private async statSafe(filePath: string): Promise<fs.Stats | null> {
|
|
try {
|
|
return await (this.options.followSymlinks
|
|
? fs.promises.stat(filePath)
|
|
: fs.promises.lstat(filePath));
|
|
} catch (error: any) {
|
|
// Only silently return null for expected "file doesn't exist" errors
|
|
if (error.code === 'ENOENT' || error.code === 'ENOTDIR') {
|
|
return null;
|
|
}
|
|
// Log other errors (permission, I/O) but still return null
|
|
console.warn(`[smartwatch] statSafe warning for ${filePath}: ${error.code} - ${error.message}`);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if a path was known to be a directory (for proper unlink event type)
|
|
*/
|
|
private isKnownDirectory(filePath: string): boolean {
|
|
// Check if any watched files are children of this path
|
|
for (const watched of this.watchedFiles) {
|
|
if (watched.startsWith(filePath + path.sep)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|