@teambit/watcher 1.0.831 → 1.0.833

package/dist/index.d.ts

@@ -2,5 +2,7 @@ import { WatcherAspect } from './watcher.aspect';
 export type { WatchOptions } from './watcher';
 export { CheckTypes } from './check-types';
 export type { WatcherMain } from './watcher.main.runtime';
+export { WatcherDaemon, WatcherClient, getOrCreateWatcherConnection } from './watcher-daemon';
+export type { WatcherEvent, WatcherError, WatcherHeartbeat, WatcherReady, WatcherMessage } from './watcher-daemon';
 export default WatcherAspect;
 export { WatcherAspect };

package/dist/index.js

@@ -15,7 +15,25 @@ Object.defineProperty(exports, "WatcherAspect", {
     return _watcher().WatcherAspect;
   }
 });
+Object.defineProperty(exports, "WatcherClient", {
+  enumerable: true,
+  get: function () {
+    return _watcherDaemon().WatcherClient;
+  }
+});
+Object.defineProperty(exports, "WatcherDaemon", {
+  enumerable: true,
+  get: function () {
+    return _watcherDaemon().WatcherDaemon;
+  }
+});
 exports.default = void 0;
+Object.defineProperty(exports, "getOrCreateWatcherConnection", {
+  enumerable: true,
+  get: function () {
+    return _watcherDaemon().getOrCreateWatcherConnection;
+  }
+});
 function _watcher() {
   const data = require("./watcher.aspect");
   _watcher = function () {
@@ -30,6 +48,13 @@ function _checkTypes() {
   };
   return data;
 }
+function _watcherDaemon() {
+  const data = require("./watcher-daemon");
+  _watcherDaemon = function () {
+    return data;
+  };
+  return data;
+}
 var _default = exports.default = _watcher().WatcherAspect;
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_watcher","data","require","_checkTypes","_default","exports","default","WatcherAspect"],"sources":["index.ts"],"sourcesContent":["import { WatcherAspect } from './watcher.aspect';\n\nexport type { WatchOptions } from './watcher';\nexport { CheckTypes } from './check-types';\nexport type { WatcherMain } from './watcher.main.runtime';\nexport default WatcherAspect;\nexport { WatcherAspect };\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA,SAAAA,SAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,QAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAGA,SAAAE,YAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,WAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA2C,IAAAG,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAE5BC,wBAAa","ignoreList":[]}
+{"version":3,"names":["_watcher","data","require","_checkTypes","_watcherDaemon","_default","exports","default","WatcherAspect"],"sources":["index.ts"],"sourcesContent":["import { WatcherAspect } from './watcher.aspect';\n\nexport type { WatchOptions } from './watcher';\nexport { CheckTypes } from './check-types';\nexport type { WatcherMain } from './watcher.main.runtime';\nexport { WatcherDaemon, WatcherClient, getOrCreateWatcherConnection } from './watcher-daemon';\nexport type { WatcherEvent, WatcherError, WatcherHeartbeat, WatcherReady, WatcherMessage } from './watcher-daemon';\nexport default WatcherAspect;\nexport { WatcherAspect };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAAA,SAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,QAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAGA,SAAAE,YAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,WAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAG,eAAA;EAAA,MAAAH,IAAA,GAAAC,OAAA;EAAAE,cAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA8F,IAAAI,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAE/EC,wBAAa","ignoreList":[]}

package/dist/watcher-daemon.d.ts

@@ -0,0 +1,156 @@
+import type { Event } from '@parcel/watcher';
+import type { Logger } from '@teambit/logger';
+export type WatcherEvent = {
+    type: 'events';
+    events: Event[];
+};
+export type WatcherError = {
+    type: 'error';
+    message: string;
+    isDropError?: boolean;
+};
+export type WatcherHeartbeat = {
+    type: 'heartbeat';
+    timestamp: number;
+};
+export type WatcherReady = {
+    type: 'ready';
+};
+export type WatcherMessage = WatcherEvent | WatcherError | WatcherHeartbeat | WatcherReady;
+/**
+ * WatcherDaemon is the server-side of the shared watcher infrastructure.
+ * It runs a Unix domain socket server and broadcasts file system events to all connected clients.
+ *
+ * Only ONE daemon can run per workspace. The daemon is responsible for:
+ * 1. Subscribing to Parcel Watcher for file system events
+ * 2. Broadcasting events to all connected clients
+ * 3. Sending heartbeats to clients so they know the daemon is alive
+ * 4. Cleaning up resources on shutdown
+ */
+export declare class WatcherDaemon {
+    private scopePath;
+    private logger;
+    private server;
+    private clients;
+    private heartbeatInterval;
+    private isShuttingDown;
+    constructor(scopePath: string, logger: Logger);
+    get socketPath(): string;
+    get lockPath(): string;
+    /**
+     * Check if a daemon is already running for this workspace
+     */
+    static isRunning(scopePath: string, logger?: Logger): Promise<boolean>;
+    /**
+     * Try to connect to an existing daemon socket
+     */
+    private static tryConnect;
+    /**
+     * Start the daemon server
+     */
+    start(): Promise<void>;
+    /**
+     * Handle a new client connection
+     */
+    private handleConnection;
+    /**
+     * Broadcast events to all connected clients
+     */
+    broadcast(message: WatcherMessage): void;
+    /**
+     * Send message to a specific client
+     */
+    private sendToClient;
+    /**
+     * Broadcast file system events from Parcel watcher
+     */
+    broadcastEvents(events: Event[]): void;
+    /**
+     * Broadcast an error to all clients
+     */
+    broadcastError(message: string, isDropError?: boolean): void;
+    /**
+     * Start sending heartbeats to clients
+     */
+    private startHeartbeat;
+    /**
+     * Get the number of connected clients
+     */
+    get clientCount(): number;
+    /**
+     * Stop the daemon and cleanup
+     */
+    stop(): Promise<void>;
+}
+/**
+ * WatcherClient connects to an existing WatcherDaemon to receive file system events.
+ *
+ * Usage:
+ * ```typescript
+ * const client = new WatcherClient(scopePath, logger);
+ * await client.connect();
+ * client.onEvents((events) => { ... });
+ * client.onError((err) => { ... });
+ * ```
+ */
+export declare class WatcherClient {
+    private scopePath;
+    private logger;
+    private socket;
+    private eventsHandler;
+    private errorHandler;
+    private readyHandler;
+    private disconnectHandler;
+    private buffer;
+    private isConnected;
+    constructor(scopePath: string, logger: Logger);
+    get socketPath(): string;
+    /**
+     * Connect to the daemon
+     */
+    connect(): Promise<void>;
+    /**
+     * Handle incoming data from the daemon
+     */
+    private handleData;
+    /**
+     * Handle a parsed message from the daemon
+     */
+    private handleMessage;
+    /**
+     * Register handler for file system events
+     */
+    onEvents(handler: (events: Event[]) => void): void;
+    /**
+     * Register handler for errors
+     */
+    onError(handler: (error: WatcherError) => void): void;
+    /**
+     * Register handler for ready signal
+     */
+    onReady(handler: () => void): void;
+    /**
+     * Register handler for disconnection
+     */
+    onDisconnect(handler: () => void): void;
+    /**
+     * Check if connected to daemon
+     */
+    get connected(): boolean;
+    /**
+     * Disconnect from the daemon
+     */
+    disconnect(): void;
+}
+/**
+ * Get or create a watcher connection for the given workspace.
+ * Returns either a daemon (if we're the first) or a client (if daemon exists).
+ *
+ * Uses retry with random jitter to handle race conditions when multiple processes
+ * try to become the daemon simultaneously.
+ */
+export declare function getOrCreateWatcherConnection(scopePath: string, logger: Logger, retryCount?: number): Promise<{
+    isDaemon: boolean;
+    daemon?: WatcherDaemon;
+    client?: WatcherClient;
+}>;

package/dist/watcher-daemon.js

@@ -0,0 +1,498 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WatcherDaemon = exports.WatcherClient = void 0;
+exports.getOrCreateWatcherConnection = getOrCreateWatcherConnection;
+function _net() {
+  const data = _interopRequireDefault(require("net"));
+  _net = function () {
+    return data;
+  };
+  return data;
+}
+function _fsExtra() {
+  const data = _interopRequireDefault(require("fs-extra"));
+  _fsExtra = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+const SOCKET_FILENAME = 'watcher.sock';
+const LOCK_FILENAME = 'watcher.lock';
+const HEARTBEAT_INTERVAL_MS = 5000;
+const CONNECTION_TIMEOUT_MS = 3000;
+/**
+ * WatcherDaemon is the server-side of the shared watcher infrastructure.
+ * It runs a Unix domain socket server and broadcasts file system events to all connected clients.
+ *
+ * Only ONE daemon can run per workspace. The daemon is responsible for:
+ * 1. Subscribing to Parcel Watcher for file system events
+ * 2. Broadcasting events to all connected clients
+ * 3. Sending heartbeats to clients so they know the daemon is alive
+ * 4. Cleaning up resources on shutdown
+ */
+class WatcherDaemon {
+  constructor(scopePath, logger) {
+    this.scopePath = scopePath;
+    this.logger = logger;
+    _defineProperty(this, "server", null);
+    _defineProperty(this, "clients", new Set());
+    _defineProperty(this, "heartbeatInterval", null);
+    _defineProperty(this, "isShuttingDown", false);
+  }
+  get socketPath() {
+    return _path().default.join(this.scopePath, SOCKET_FILENAME);
+  }
+  get lockPath() {
+    return _path().default.join(this.scopePath, LOCK_FILENAME);
+  }
+
+  /**
+   * Check if a daemon is already running for this workspace
+   */
+  static async isRunning(scopePath, logger) {
+    const lockPath = _path().default.join(scopePath, LOCK_FILENAME);
+    const socketPath = _path().default.join(scopePath, SOCKET_FILENAME);
+
+    // Check if lock file exists
+    if (!(await _fsExtra().default.pathExists(lockPath))) {
+      return false;
+    }
+
+    // Check if the PID in lock file is still alive
+    try {
+      const lockContent = await _fsExtra().default.readFile(lockPath, 'utf8');
+      let pid;
+      try {
+        ({
+          pid
+        } = JSON.parse(lockContent));
+      } catch (parseErr) {
+        // Malformed JSON in lock file - treat as stale and clean up
+        logger?.debug(`Malformed lock file, cleaning up: ${parseErr.message}`);
+        await _fsExtra().default.remove(lockPath);
+        await _fsExtra().default.remove(socketPath);
+        return false;
+      }
+
+      // Check if process is running
+      try {
+        process.kill(pid, 0); // Signal 0 doesn't kill, just checks if process exists
+      } catch {
+        // Process doesn't exist, clean up stale lock
+        await _fsExtra().default.remove(lockPath);
+        await _fsExtra().default.remove(socketPath);
+        return false;
+      }
+
+      // Process exists, try to connect to verify it's actually the daemon
+      const canConnect = await WatcherDaemon.tryConnect(socketPath);
+      if (!canConnect) {
+        // Lock file exists but socket doesn't respond - stale lock
+        await _fsExtra().default.remove(lockPath);
+        await _fsExtra().default.remove(socketPath);
+        return false;
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Try to connect to an existing daemon socket
+   */
+  static tryConnect(socketPath) {
+    return new Promise(resolve => {
+      const socket = _net().default.createConnection(socketPath);
+      const timeout = setTimeout(() => {
+        socket.destroy();
+        resolve(false);
+      }, CONNECTION_TIMEOUT_MS);
+      socket.on('connect', () => {
+        clearTimeout(timeout);
+        socket.destroy();
+        resolve(true);
+      });
+      socket.on('error', () => {
+        clearTimeout(timeout);
+        socket.destroy();
+        resolve(false);
+      });
+    });
+  }
+
+  /**
+   * Start the daemon server
+   */
+  async start() {
+    // Remove any stale socket file
+    await _fsExtra().default.remove(this.socketPath);
+
+    // Create lock file with our PID
+    await _fsExtra().default.outputFile(this.lockPath, JSON.stringify({
+      pid: process.pid,
+      startTime: Date.now()
+    }));
+
+    // Create Unix domain socket server
+    this.server = _net().default.createServer(socket => this.handleConnection(socket));
+    return new Promise((resolve, reject) => {
+      if (!this.server) {
+        reject(new Error('Server not initialized'));
+        return;
+      }
+      this.server.on('error', err => {
+        this.logger.error(`Watcher daemon server error: ${err.message}`);
+        reject(err);
+      });
+      this.server.listen(this.socketPath, () => {
+        this.logger.debug(`Watcher daemon started on ${this.socketPath}`);
+        this.startHeartbeat();
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Handle a new client connection
+   */
+  handleConnection(socket) {
+    this.clients.add(socket);
+    this.logger.debug(`Watcher daemon: client connected (${this.clients.size} total)`);
+
+    // Send ready message to new client
+    this.sendToClient(socket, {
+      type: 'ready'
+    });
+    socket.on('close', () => {
+      this.clients.delete(socket);
+      this.logger.debug(`Watcher daemon: client disconnected (${this.clients.size} total)`);
+    });
+    socket.on('error', err => {
+      this.logger.debug(`Watcher daemon: client error - ${err.message}`);
+      this.clients.delete(socket);
+    });
+  }
+
+  /**
+   * Broadcast events to all connected clients
+   */
+  broadcast(message) {
+    const data = JSON.stringify(message) + '\n';
+    for (const client of this.clients) {
+      try {
+        client.write(data);
+      } catch (err) {
+        this.logger.debug(`Failed to send to client: ${err.message}`);
+        this.clients.delete(client);
+      }
+    }
+  }
+
+  /**
+   * Send message to a specific client
+   */
+  sendToClient(socket, message) {
+    try {
+      socket.write(JSON.stringify(message) + '\n');
+    } catch (err) {
+      this.logger.debug(`Failed to send to client: ${err.message}`);
+    }
+  }
+
+  /**
+   * Broadcast file system events from Parcel watcher
+   */
+  broadcastEvents(events) {
+    this.broadcast({
+      type: 'events',
+      events
+    });
+  }
+
+  /**
+   * Broadcast an error to all clients
+   */
+  broadcastError(message, isDropError = false) {
+    this.broadcast({
+      type: 'error',
+      message,
+      isDropError
+    });
+  }
+
+  /**
+   * Start sending heartbeats to clients
+   */
+  startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      this.broadcast({
+        type: 'heartbeat',
+        timestamp: Date.now()
+      });
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+
+  /**
+   * Get the number of connected clients
+   */
+  get clientCount() {
+    return this.clients.size;
+  }
+
+  /**
+   * Stop the daemon and cleanup
+   */
+  async stop() {
+    if (this.isShuttingDown) {
+      return;
+    }
+    this.isShuttingDown = true;
+    this.logger.debug('Watcher daemon stopping...');
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+
+    // Close all client connections
+    for (const client of this.clients) {
+      client.destroy();
+    }
+    this.clients.clear();
+
+    // Close server
+    if (this.server) {
+      await new Promise(resolve => {
+        this.server.close(() => resolve());
+      });
+      this.server = null;
+    }
+
+    // Remove lock and socket files
+    await _fsExtra().default.remove(this.lockPath);
+    await _fsExtra().default.remove(this.socketPath);
+    this.logger.debug('Watcher daemon stopped');
+  }
+}
+
+/**
+ * WatcherClient connects to an existing WatcherDaemon to receive file system events.
+ *
+ * Usage:
+ * ```typescript
+ * const client = new WatcherClient(scopePath, logger);
+ * await client.connect();
+ * client.onEvents((events) => { ... });
+ * client.onError((err) => { ... });
+ * ```
+ */
+exports.WatcherDaemon = WatcherDaemon;
+class WatcherClient {
+  constructor(scopePath, logger) {
+    this.scopePath = scopePath;
+    this.logger = logger;
+    _defineProperty(this, "socket", null);
+    _defineProperty(this, "eventsHandler", null);
+    _defineProperty(this, "errorHandler", null);
+    _defineProperty(this, "readyHandler", null);
+    _defineProperty(this, "disconnectHandler", null);
+    _defineProperty(this, "buffer", '');
+    _defineProperty(this, "isConnected", false);
+  }
+  get socketPath() {
+    return _path().default.join(this.scopePath, SOCKET_FILENAME);
+  }
+
+  /**
+   * Connect to the daemon
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      this.socket = _net().default.createConnection(this.socketPath);
+      const timeout = setTimeout(() => {
+        this.socket?.destroy();
+        reject(new Error('Connection timeout'));
+      }, CONNECTION_TIMEOUT_MS);
+      this.socket.on('connect', () => {
+        clearTimeout(timeout);
+        this.isConnected = true;
+        this.logger.debug('Watcher client connected to daemon');
+        resolve();
+      });
+      this.socket.on('data', data => {
+        this.handleData(data);
+      });
+      this.socket.on('close', () => {
+        this.isConnected = false;
+        this.logger.debug('Watcher client disconnected from daemon');
+        this.disconnectHandler?.();
+      });
+      this.socket.on('error', err => {
+        clearTimeout(timeout);
+        this.socket?.destroy();
+        this.isConnected = false;
+        this.logger.debug(`Watcher client error: ${err.message}`);
+        reject(err);
+      });
+    });
+  }
+
+  /**
+   * Handle incoming data from the daemon
+   */
+  handleData(data) {
+    this.buffer += data.toString('utf8');
+
+    // Process complete messages (newline-delimited JSON)
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || ''; // Keep incomplete line in buffer
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const message = JSON.parse(line);
+        this.handleMessage(message);
+      } catch (err) {
+        this.logger.debug(`Failed to parse message: ${err.message}`);
+      }
+    }
+  }
+
+  /**
+   * Handle a parsed message from the daemon
+   */
+  handleMessage(message) {
+    switch (message.type) {
+      case 'events':
+        this.eventsHandler?.(message.events);
+        break;
+      case 'error':
+        this.errorHandler?.(message);
+        break;
+      case 'ready':
+        this.readyHandler?.();
+        break;
+      case 'heartbeat':
+        // Heartbeats serve to keep the TCP connection alive and allow the OS to detect
+        // a dead daemon faster. The client doesn't need to actively monitor them since
+        // the socket 'close' event will fire when the daemon dies.
+        break;
+    }
+  }
+
+  /**
+   * Register handler for file system events
+   */
+  onEvents(handler) {
+    this.eventsHandler = handler;
+  }
+
+  /**
+   * Register handler for errors
+   */
+  onError(handler) {
+    this.errorHandler = handler;
+  }
+
+  /**
+   * Register handler for ready signal
+   */
+  onReady(handler) {
+    this.readyHandler = handler;
+  }
+
+  /**
+   * Register handler for disconnection
+   */
+  onDisconnect(handler) {
+    this.disconnectHandler = handler;
+  }
+
+  /**
+   * Check if connected to daemon
+   */
+  get connected() {
+    return this.isConnected;
+  }
+
+  /**
+   * Disconnect from the daemon
+   */
+  disconnect() {
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = null;
+    }
+    this.isConnected = false;
+  }
+}
+
+/**
+ * Get or create a watcher connection for the given workspace.
+ * Returns either a daemon (if we're the first) or a client (if daemon exists).
+ *
+ * Uses retry with random jitter to handle race conditions when multiple processes
+ * try to become the daemon simultaneously.
+ */
+exports.WatcherClient = WatcherClient;
+async function getOrCreateWatcherConnection(scopePath, logger, retryCount = 0) {
+  const MAX_RETRIES = 3;
+
+  // Check if daemon is already running
+  const isRunning = await WatcherDaemon.isRunning(scopePath, logger);
+  if (isRunning) {
+    // Connect as client
+    const client = new WatcherClient(scopePath, logger);
+    try {
+      await client.connect();
+      return {
+        isDaemon: false,
+        client
+      };
+    } catch (err) {
+      // Connection failed - daemon might have just died, retry
+      if (retryCount < MAX_RETRIES) {
+        // Add random jitter (100-500ms) to reduce thundering herd
+        const jitter = 100 + Math.random() * 400;
+        await new Promise(resolve => setTimeout(resolve, jitter));
+        return getOrCreateWatcherConnection(scopePath, logger, retryCount + 1);
+      }
+      throw err;
+    }
+  }
+
+  // Try to become the daemon
+  const daemon = new WatcherDaemon(scopePath, logger);
+  try {
+    await daemon.start();
+    return {
+      isDaemon: true,
+      daemon
+    };
+  } catch (err) {
+    // Failed to start daemon - another process might have beaten us, retry as client
+    if (retryCount < MAX_RETRIES) {
+      // Add random jitter to reduce thundering herd
+      const jitter = 100 + Math.random() * 400;
+      await new Promise(resolve => setTimeout(resolve, jitter));
+      return getOrCreateWatcherConnection(scopePath, logger, retryCount + 1);
+    }
+    throw err;
+  }
+}
+
+//# sourceMappingURL=watcher-daemon.js.map