@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.
311 lines • 43.9 kB
JavaScript
import * as path from 'node:path';
import { watch, accessSync, mkdirSync, readdirSync, statSync } from 'node:fs';
import { logger } from '../utils/logger.js';
class PollingWatcher {
interval;
constructor(interval) {
this.interval = interval;
}
close() {
clearInterval(this.interval);
}
// Match the fs.FSWatcher shape well enough for internal use.
on(_event, _listener) {
return this;
}
}
/**
* Type guard to check if an error is a Node.js system error with an error code
*/
function isNodeError(error) {
return error instanceof Error && 'code' in error;
}
/**
* Thin wrapper over fs.watch that fan-outs change events to interested managers.
*
* This service is managed as a singleton by the DI container.
* Inject it via constructor injection rather than using a static getInstance() method.
*/
export class FileWatchService {
watchers = new Map();
debounceTimers = new Map();
/**
* Watch a directory for changes. If the directory doesn't exist, it will be created.
*
* @param dirPath - Path to directory to watch
* @param handler - Callback function invoked when files change
* @returns Cleanup function to stop watching
*
* @remarks
* This method ensures the directory exists before setting up the watcher.
* fs.watch throws ENOENT if the directory doesn't exist, so we create it
* with recursive:true to handle test scenarios and edge cases gracefully.
*
* File watching is optional functionality. If fs.watch() fails due to permission
* restrictions or platform limitations, a no-op cleanup function is returned and
* the application continues without file watching for that directory.
*/
watchDirectory(dirPath, handler) {
const absoluteDir = path.resolve(dirPath);
const existing = this.watchers.get(absoluteDir);
if (existing) {
existing.handlers.add(handler);
return () => this.detachHandler(absoluteDir, handler);
}
// Ensure directory exists before watching
// fs.watch throws ENOENT if directory doesn't exist, so we create it first
try {
accessSync(absoluteDir);
}
catch (_error) {
// Directory doesn't exist - create it
try {
mkdirSync(absoluteDir, { recursive: true });
logger.debug('Created directory for watching', { directory: absoluteDir });
}
catch (mkdirError) {
// Failed to create directory - log and return no-op cleanup
logger.warn('Failed to create directory for watching - watcher will not be set up', {
directory: absoluteDir,
error: mkdirError instanceof Error ? mkdirError.message : String(mkdirError)
});
// Return a no-op cleanup function since watcher was not created
return () => { };
}
}
const handlers = new Set([handler]);
const startPollingWatcher = (reason) => {
const snapshot = () => {
const next = new Map();
for (const entry of readdirSync(absoluteDir, { withFileTypes: true })) {
if (!entry.isFile()) {
continue;
}
try {
const stats = statSync(path.join(absoluteDir, entry.name));
next.set(entry.name, stats.mtimeMs);
}
catch {
// Ignore races (file removed between readdir and stat, etc.)
}
}
return next;
};
let previous;
try {
previous = snapshot();
}
catch (pollSetupError) {
logger.warn('Failed to initialize polling directory watcher', {
directory: absoluteDir,
phase: reason?.phase,
originalError: reason?.error instanceof Error ? reason.error.message : reason?.error,
error: pollSetupError instanceof Error ? pollSetupError.message : String(pollSetupError),
});
return undefined;
}
// Adaptive polling interval: scale with directory size to prevent
// scan-overlaps on large portfolios (Issue #1687).
// Base: 2s, +2ms per file, capped at 10s.
const baseIntervalMs = 2000;
const perFileMs = 2;
const maxIntervalMs = 10_000;
const adaptiveInterval = Math.min(baseIntervalMs + previous.size * perFileMs, maxIntervalMs);
// Guard: skip poll if a previous scan is still being processed
let scanInProgress = false;
// Debounce: batch changed files and notify handlers once per cycle
const interval = setInterval(() => {
if (scanInProgress)
return;
scanInProgress = true;
try {
let next;
try {
next = snapshot();
}
catch {
return;
}
// Collect all changed files before notifying handlers
const changedFiles = [];
for (const [filename, mtimeMs] of next) {
const priorMtime = previous.get(filename);
if (priorMtime === undefined || priorMtime !== mtimeMs) {
changedFiles.push(filename);
}
}
// Deletions
for (const filename of previous.keys()) {
if (!next.has(filename)) {
changedFiles.push(filename);
}
}
// Notify handlers once per changed file (deduplicated)
if (changedFiles.length > 0) {
const uniqueChanges = [...new Set(changedFiles)];
for (const filename of uniqueChanges) {
for (const h of handlers) {
try {
h(filename);
}
catch (error) {
logger.warn('FileWatchService polling handler failed', {
directory: absoluteDir,
error: error instanceof Error ? error.message : error
});
}
}
}
}
previous = next;
}
finally {
scanInProgress = false;
}
}, adaptiveInterval);
logger.warn('Falling back to polling directory watcher', {
directory: absoluteDir,
phase: reason?.phase,
originalError: reason?.error instanceof Error ? reason.error.message : reason?.error,
code: reason?.error && isNodeError(reason.error) ? reason.error.code : undefined
});
return new PollingWatcher(interval);
};
// Try to set up file watcher - may fail due to permission restrictions or platform limitations
let watcher;
try {
// Debounce fs.watch events — coalesce rapid-fire notifications into
// a single handler call per file within a 500ms window (Issue #1687).
const pendingChanges = new Set();
watcher = watch(absoluteDir, { recursive: false }, (_eventType, filename) => {
if (!filename) {
return;
}
pendingChanges.add(filename.toString());
const existingTimer = this.debounceTimers.get(absoluteDir);
if (existingTimer)
clearTimeout(existingTimer);
this.debounceTimers.set(absoluteDir, setTimeout(() => {
this.debounceTimers.delete(absoluteDir);
const files = [...pendingChanges];
pendingChanges.clear();
for (const relative of files) {
for (const h of handlers) {
try {
h(relative);
}
catch (error) {
logger.warn('FileWatchService handler failed', {
directory: absoluteDir,
error: error instanceof Error ? error.message : error
});
}
}
}
}, 500));
});
}
catch (watchError) {
// File watching failed - fall back to polling (or no-op if polling also fails).
// Common on platforms with watch limits (EMFILE/ENOSPC) or restricted permissions.
logger.warn('Failed to set up file watcher', {
directory: absoluteDir,
error: watchError instanceof Error ? watchError.message : String(watchError),
code: isNodeError(watchError) ? watchError.code : undefined
});
const pollingWatcher = startPollingWatcher({ error: watchError, phase: 'setup' });
if (!pollingWatcher) {
// Return a no-op cleanup function since watcher was not created
return () => { };
}
this.watchers.set(absoluteDir, { watcher: pollingWatcher, handlers });
return () => this.detachHandler(absoluteDir, handler);
}
// Handle error events from the watcher (required for Windows)
// On Windows, fs.watch emits error events for permission issues (EPERM)
// Without this handler, Node.js throws "Unhandled 'error' event"
let earlyWatchError;
watcher.on('error', (error) => {
// If the watcher errors immediately (before we store it), record and handle after setup.
if (!this.watchers.has(absoluteDir)) {
earlyWatchError = error;
watcher.close();
return;
}
logger.warn('File watcher error - closing watcher', {
directory: absoluteDir,
error: error instanceof Error ? error.message : String(error),
code: isNodeError(error) ? error.code : undefined
});
// Close the watcher as recommended in Node.js documentation.
// If the watcher is failing (e.g., EMFILE/ENOSPC), fall back to polling so the app can still react.
const current = this.watchers.get(absoluteDir);
const isCurrentWatcher = current?.watcher === watcher;
watcher.close();
if (isCurrentWatcher) {
const pollingWatcher = startPollingWatcher({ error, phase: 'runtime' });
if (pollingWatcher) {
this.watchers.set(absoluteDir, { watcher: pollingWatcher, handlers });
}
else {
this.watchers.delete(absoluteDir);
}
}
});
this.watchers.set(absoluteDir, { watcher, handlers });
logger.debug('Started directory watcher', { directory: absoluteDir });
if (earlyWatchError) {
logger.warn('File watcher error during initialization - switching to polling', {
directory: absoluteDir,
error: earlyWatchError instanceof Error ? earlyWatchError.message : String(earlyWatchError),
code: isNodeError(earlyWatchError) ? earlyWatchError.code : undefined
});
const pollingWatcher = startPollingWatcher({ error: earlyWatchError, phase: 'runtime' });
if (pollingWatcher) {
this.watchers.set(absoluteDir, { watcher: pollingWatcher, handlers });
}
else {
this.watchers.delete(absoluteDir);
}
}
return () => this.detachHandler(absoluteDir, handler);
}
detachHandler(dir, handler) {
const entry = this.watchers.get(dir);
if (!entry) {
return;
}
entry.handlers.delete(handler);
if (entry.handlers.size === 0) {
entry.watcher.close();
this.watchers.delete(dir);
logger.debug('Stopped directory watcher', { directory: dir });
}
}
/**
* Dispose of all file watchers. Called during graceful shutdown.
* This method is invoked by the DI container's dispose() method.
*/
dispose() {
// Clear all pending debounce timers to prevent post-dispose handler calls
for (const [, timer] of this.debounceTimers) {
clearTimeout(timer);
}
this.debounceTimers.clear();
for (const [dir, entry] of this.watchers) {
try {
entry.watcher.close();
logger.debug('Closed directory watcher during dispose', { directory: dir });
}
catch (error) {
logger.warn('Error closing watcher during dispose', {
directory: dir,
error: error instanceof Error ? error.message : String(error)
});
}
}
this.watchers.clear();
logger.debug('FileWatchService disposed', { watchersClosed: this.watchers.size === 0 });
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FileWatchService.js","sourceRoot":"","sources":["../../src/services/FileWatchService.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'node:path';\nimport { watch, FSWatcher, accessSync, mkdirSync, readdirSync, statSync } from 'node:fs';\nimport { logger } from '../utils/logger.js';\n\nexport type FileChangeHandler = (relativePath: string) => void;\n\ninterface WatchEntry {\n  watcher: FSWatcher | PollingWatcher;\n  handlers: Set<FileChangeHandler>;\n}\n\nclass PollingWatcher {\n  private readonly interval: NodeJS.Timeout;\n\n  constructor(interval: NodeJS.Timeout) {\n    this.interval = interval;\n  }\n\n  close(): void {\n    clearInterval(this.interval);\n  }\n\n  // Match the fs.FSWatcher shape well enough for internal use.\n  on(_event: string, _listener: (...args: unknown[]) => void): this {\n    return this;\n  }\n}\n\n/**\n * Type guard to check if an error is a Node.js system error with an error code\n */\nfunction isNodeError(error: unknown): error is NodeJS.ErrnoException {\n  return error instanceof Error && 'code' in error;\n}\n\n/**\n * Thin wrapper over fs.watch that fan-outs change events to interested managers.\n *\n * This service is managed as a singleton by the DI container.\n * Inject it via constructor injection rather than using a static getInstance() method.\n */\nexport class FileWatchService {\n  private readonly watchers = new Map<string, WatchEntry>();\n  private readonly debounceTimers = new Map<string, ReturnType<typeof setTimeout>>();\n\n  /**\n   * Watch a directory for changes. If the directory doesn't exist, it will be created.\n   *\n   * @param dirPath - Path to directory to watch\n   * @param handler - Callback function invoked when files change\n   * @returns Cleanup function to stop watching\n   *\n   * @remarks\n   * This method ensures the directory exists before setting up the watcher.\n   * fs.watch throws ENOENT if the directory doesn't exist, so we create it\n   * with recursive:true to handle test scenarios and edge cases gracefully.\n   *\n   * File watching is optional functionality. If fs.watch() fails due to permission\n   * restrictions or platform limitations, a no-op cleanup function is returned and\n   * the application continues without file watching for that directory.\n   */\n  watchDirectory(dirPath: string, handler: FileChangeHandler): () => void {\n    const absoluteDir = path.resolve(dirPath);\n    const existing = this.watchers.get(absoluteDir);\n\n    if (existing) {\n      existing.handlers.add(handler);\n      return () => this.detachHandler(absoluteDir, handler);\n    }\n\n    // Ensure directory exists before watching\n    // fs.watch throws ENOENT if directory doesn't exist, so we create it first\n    try {\n      accessSync(absoluteDir);\n    } catch (_error) {\n      // Directory doesn't exist - create it\n      try {\n        mkdirSync(absoluteDir, { recursive: true });\n        logger.debug('Created directory for watching', { directory: absoluteDir });\n      } catch (mkdirError) {\n        // Failed to create directory - log and return no-op cleanup\n        logger.warn('Failed to create directory for watching - watcher will not be set up', {\n          directory: absoluteDir,\n          error: mkdirError instanceof Error ? mkdirError.message : String(mkdirError)\n        });\n        // Return a no-op cleanup function since watcher was not created\n        return () => {};\n      }\n    }\n\n    const handlers = new Set<FileChangeHandler>([handler]);\n\n    const startPollingWatcher = (reason: { error: unknown; phase: 'setup' | 'runtime' } | undefined): PollingWatcher | undefined => {\n      const snapshot = (): Map<string, number> => {\n        const next = new Map<string, number>();\n        for (const entry of readdirSync(absoluteDir, { withFileTypes: true })) {\n          if (!entry.isFile()) {\n            continue;\n          }\n          try {\n            const stats = statSync(path.join(absoluteDir, entry.name));\n            next.set(entry.name, stats.mtimeMs);\n          } catch {\n            // Ignore races (file removed between readdir and stat, etc.)\n          }\n        }\n        return next;\n      };\n\n      let previous: Map<string, number>;\n      try {\n        previous = snapshot();\n      } catch (pollSetupError) {\n        logger.warn('Failed to initialize polling directory watcher', {\n          directory: absoluteDir,\n          phase: reason?.phase,\n          originalError: reason?.error instanceof Error ? reason.error.message : reason?.error,\n          error: pollSetupError instanceof Error ? pollSetupError.message : String(pollSetupError),\n        });\n        return undefined;\n      }\n\n      // Adaptive polling interval: scale with directory size to prevent\n      // scan-overlaps on large portfolios (Issue #1687).\n      // Base: 2s, +2ms per file, capped at 10s.\n      const baseIntervalMs = 2000;\n      const perFileMs = 2;\n      const maxIntervalMs = 10_000;\n      const adaptiveInterval = Math.min(\n        baseIntervalMs + previous.size * perFileMs,\n        maxIntervalMs,\n      );\n\n      // Guard: skip poll if a previous scan is still being processed\n      let scanInProgress = false;\n\n      // Debounce: batch changed files and notify handlers once per cycle\n      const interval = setInterval(() => {\n        if (scanInProgress) return;\n        scanInProgress = true;\n\n        try {\n          let next: Map<string, number>;\n          try {\n            next = snapshot();\n          } catch {\n            return;\n          }\n\n          // Collect all changed files before notifying handlers\n          const changedFiles: string[] = [];\n\n          for (const [filename, mtimeMs] of next) {\n            const priorMtime = previous.get(filename);\n            if (priorMtime === undefined || priorMtime !== mtimeMs) {\n              changedFiles.push(filename);\n            }\n          }\n\n          // Deletions\n          for (const filename of previous.keys()) {\n            if (!next.has(filename)) {\n              changedFiles.push(filename);\n            }\n          }\n\n          // Notify handlers once per changed file (deduplicated)\n          if (changedFiles.length > 0) {\n            const uniqueChanges = [...new Set(changedFiles)];\n            for (const filename of uniqueChanges) {\n              for (const h of handlers) {\n                try {\n                  h(filename);\n                } catch (error) {\n                  logger.warn('FileWatchService polling handler failed', {\n                    directory: absoluteDir,\n                    error: error instanceof Error ? error.message : error\n                  });\n                }\n              }\n            }\n          }\n\n          previous = next;\n        } finally {\n          scanInProgress = false;\n        }\n      }, adaptiveInterval);\n\n      logger.warn('Falling back to polling directory watcher', {\n        directory: absoluteDir,\n        phase: reason?.phase,\n        originalError: reason?.error instanceof Error ? reason.error.message : reason?.error,\n        code: reason?.error && isNodeError(reason.error) ? reason.error.code : undefined\n      });\n\n      return new PollingWatcher(interval);\n    };\n\n    // Try to set up file watcher - may fail due to permission restrictions or platform limitations\n    let watcher: FSWatcher | PollingWatcher | undefined;\n    try {\n      // Debounce fs.watch events — coalesce rapid-fire notifications into\n      // a single handler call per file within a 500ms window (Issue #1687).\n      const pendingChanges = new Set<string>();\n\n      watcher = watch(absoluteDir, { recursive: false }, (_eventType, filename) => {\n        if (!filename) {\n          return;\n        }\n        pendingChanges.add(filename.toString());\n\n        const existingTimer = this.debounceTimers.get(absoluteDir);\n        if (existingTimer) clearTimeout(existingTimer);\n        this.debounceTimers.set(absoluteDir, setTimeout(() => {\n          this.debounceTimers.delete(absoluteDir);\n          const files = [...pendingChanges];\n          pendingChanges.clear();\n          for (const relative of files) {\n            for (const h of handlers) {\n              try {\n                h(relative);\n              } catch (error) {\n                logger.warn('FileWatchService handler failed', {\n                  directory: absoluteDir,\n                  error: error instanceof Error ? error.message : error\n                });\n              }\n            }\n          }\n        }, 500));\n      });\n    } catch (watchError) {\n      // File watching failed - fall back to polling (or no-op if polling also fails).\n      // Common on platforms with watch limits (EMFILE/ENOSPC) or restricted permissions.\n      logger.warn('Failed to set up file watcher', {\n        directory: absoluteDir,\n        error: watchError instanceof Error ? watchError.message : String(watchError),\n        code: isNodeError(watchError) ? watchError.code : undefined\n      });\n\n      const pollingWatcher = startPollingWatcher({ error: watchError, phase: 'setup' });\n      if (!pollingWatcher) {\n        // Return a no-op cleanup function since watcher was not created\n        return () => {};\n      }\n\n      this.watchers.set(absoluteDir, { watcher: pollingWatcher, handlers });\n      return () => this.detachHandler(absoluteDir, handler);\n    }\n\n    // Handle error events from the watcher (required for Windows)\n    // On Windows, fs.watch emits error events for permission issues (EPERM)\n    // Without this handler, Node.js throws \"Unhandled 'error' event\"\n    let earlyWatchError: unknown | undefined;\n    watcher.on('error', (error) => {\n      // If the watcher errors immediately (before we store it), record and handle after setup.\n      if (!this.watchers.has(absoluteDir)) {\n        earlyWatchError = error;\n        watcher.close();\n        return;\n      }\n\n      logger.warn('File watcher error - closing watcher', {\n        directory: absoluteDir,\n        error: error instanceof Error ? error.message : String(error),\n        code: isNodeError(error) ? error.code : undefined\n      });\n\n      // Close the watcher as recommended in Node.js documentation.\n      // If the watcher is failing (e.g., EMFILE/ENOSPC), fall back to polling so the app can still react.\n      const current = this.watchers.get(absoluteDir);\n      const isCurrentWatcher = current?.watcher === watcher;\n\n      watcher.close();\n\n      if (isCurrentWatcher) {\n        const pollingWatcher = startPollingWatcher({ error, phase: 'runtime' });\n        if (pollingWatcher) {\n          this.watchers.set(absoluteDir, { watcher: pollingWatcher, handlers });\n        } else {\n          this.watchers.delete(absoluteDir);\n        }\n      }\n    });\n\n    this.watchers.set(absoluteDir, { watcher, handlers });\n    logger.debug('Started directory watcher', { directory: absoluteDir });\n\n    if (earlyWatchError) {\n      logger.warn('File watcher error during initialization - switching to polling', {\n        directory: absoluteDir,\n        error: earlyWatchError instanceof Error ? earlyWatchError.message : String(earlyWatchError),\n        code: isNodeError(earlyWatchError) ? earlyWatchError.code : undefined\n      });\n      const pollingWatcher = startPollingWatcher({ error: earlyWatchError, phase: 'runtime' });\n      if (pollingWatcher) {\n        this.watchers.set(absoluteDir, { watcher: pollingWatcher, handlers });\n      } else {\n        this.watchers.delete(absoluteDir);\n      }\n    }\n\n    return () => this.detachHandler(absoluteDir, handler);\n  }\n\n  private detachHandler(dir: string, handler: FileChangeHandler): void {\n    const entry = this.watchers.get(dir);\n    if (!entry) {\n      return;\n    }\n    entry.handlers.delete(handler);\n    if (entry.handlers.size === 0) {\n      entry.watcher.close();\n      this.watchers.delete(dir);\n      logger.debug('Stopped directory watcher', { directory: dir });\n    }\n  }\n\n  /**\n   * Dispose of all file watchers. Called during graceful shutdown.\n   * This method is invoked by the DI container's dispose() method.\n   */\n  dispose(): void {\n    // Clear all pending debounce timers to prevent post-dispose handler calls\n    for (const [, timer] of this.debounceTimers) {\n      clearTimeout(timer);\n    }\n    this.debounceTimers.clear();\n\n    for (const [dir, entry] of this.watchers) {\n      try {\n        entry.watcher.close();\n        logger.debug('Closed directory watcher during dispose', { directory: dir });\n      } catch (error) {\n        logger.warn('Error closing watcher during dispose', {\n          directory: dir,\n          error: error instanceof Error ? error.message : String(error)\n        });\n      }\n    }\n    this.watchers.clear();\n    logger.debug('FileWatchService disposed', { watchersClosed: this.watchers.size === 0 });\n  }\n}\n"]}