@jxsuite/server 2.2.2 → 2.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/server",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "description": "Jx development server with live reload, server-side proxy, and studio integration",
   "license": "MIT",
   "repository": {

package/src/refactor/watcher.ts

@@ -9,6 +9,7 @@
 import { watch as chokidarWatch } from "chokidar";
 import { coalesceFsEvents, toFsEvent } from "./fs-events.ts";
 import { invalidateReferenceCache } from "./find-refs.ts";
+import { createWatchIgnore } from "../watch-policy.ts";
 import type { FsEventPayload } from "./fs-events.ts";
 
 const IGNORE_SEGMENTS = ["node_modules", ".git", "dist", ".jx", ".direnv", ".devenv"];
@@ -36,9 +37,14 @@ export function createFsWatcher(
   let timer: ReturnType<typeof setTimeout> | null = null;
 
   const watcher = chokidarWatch(root, {
+    /* Left on deliberately: a symlink inside a project is project content, and its events belong
+       in the sidebar. It is the link pointing OUT of the root that walks the watcher off into the
+       rest of the filesystem, and createWatchIgnore drops exactly those — along with the sockets
+       and device nodes fs.watch answers with ENXIO. */
+    followSymlinks: true,
     ignoreInitial: true,
     ignorePermissionErrors: true,
-    ignored: (path) => isIgnored(path),
+    ignored: createWatchIgnore(root, isIgnored),
   });
 
   watcher.on("all", (eventType, changedPath) => {
@@ -61,6 +67,15 @@ export function createFsWatcher(
     }, debounceMs);
   });
 
+  /* An `error` with no listener is not logged by an EventEmitter, it is THROWN — which is how a
+     directory holding a few unix sockets took the whole launcher down rather than losing a few
+     watches. The filter above means these should now be rare; the listener means they are never
+     fatal when they are not. */
+  watcher.on("error", (err) => {
+    const error = err as NodeJS.ErrnoException;
+    console.error(`[fs-watch] ${error.message ?? String(error)}`);
+  });
+
   return {
     close: async () => {
       if (timer) {

package/src/watch-policy.ts

@@ -0,0 +1,79 @@
+/**
+ * Watch-policy.ts — the entry filter both filesystem watchers hand to chokidar.
+ *
+ * A watcher is pointed at a directory a **user** chose, and a user's directory holds things that
+ * are not project content and that `fs.watch` does not merely decline to watch:
+ *
+ * - **Unix sockets, FIFOs and device nodes** answer `fs.watch` with `ENXIO`, which chokidar turns
+ *   into an `error` event — one per entry, and fatal to a watcher with no `error` listener.
+ * - **A symlink out of the tree** is followed by default, so one link can turn a project watcher into
+ *   a walk of the whole filesystem. `~/.wine/dosdevices/z:` points at `/`, and that is exactly what
+ *   it did.
+ *
+ * Both were reached at once by a launcher that adopted `$HOME` as a project root. That defect is
+ * fixed where it was made (`packages/desktop/src/chromium/index.ts`), but a watcher must survive
+ * being pointed at an ordinary directory rather than depend on never being pointed at one — so the
+ * rules live here, stated once, because `watch.ts` (dev server) and `refactor/watcher.ts` (desktop
+ * session) both need them and neither owns the other.
+ *
+ * Symlinks are contained rather than banned: a link resolving back inside the root is project
+ * content (a workspace member, a shared assets directory) and keeps its events. Only one leaving
+ * the root — or dangling, which is what `find -xtype l -delete` leaves behind in a nix bundle — is
+ * dropped.
+ *
+ * @docs framework/build/dev-server
+ */
+
+import { realpathSync } from "node:fs";
+import { resolve, sep } from "node:path";
+import type { Stats } from "node:fs";
+
+/** Is `candidate` the base directory itself, or somewhere beneath it? */
+function isInside(base: string, candidate: string): boolean {
+  return candidate === base || candidate.startsWith(base.endsWith(sep) ? base : base + sep);
+}
+
+/**
+ * Resolve `root` through any symlinks so containment is judged against real paths on both sides. An
+ * unresolvable root is not this function's error to raise — chokidar reports it — so the lexical
+ * path stands in and every symlink under it then reads as "outside".
+ */
+function realBase(root: string): string {
+  try {
+    return realpathSync(root);
+  } catch {
+    return resolve(root);
+  }
+}
+
+/**
+ * Build the `ignored` predicate for a watcher rooted at `root`, composing the caller's own
+ * path-name rule (`node_modules`, `dist`, …) with the entry-kind rules above.
+ *
+ * Chokidar calls this with the entry's `lstat` during its directory walk and without stats before
+ * it has them; a stats-less call can only be judged by name, so it is.
+ */
+export function createWatchIgnore(
+  root: string,
+  isIgnoredPath: (path: string) => boolean,
+): (path: string, stats?: Stats) => boolean {
+  let base: string | null = null;
+  return (path: string, stats?: Stats): boolean => {
+    if (isIgnoredPath(path)) {
+      return true;
+    }
+    if (!stats) {
+      return false;
+    }
+    if (stats.isSymbolicLink()) {
+      base ??= realBase(root);
+      try {
+        return !isInside(base, realpathSync(path));
+      } catch {
+        return true;
+      }
+    }
+    // Anything that is not a directory or a regular file is a socket, a FIFO or a device node.
+    return !stats.isDirectory() && !stats.isFile();
+  };
+}

package/src/watch.ts

@@ -4,6 +4,7 @@ import { watch as chokidarWatch } from "chokidar";
 import { relative } from "node:path";
 import { rebuild } from "./build.ts";
 import { coalesceFsEvents, toFsEvent } from "./refactor/fs-events.ts";
+import { createWatchIgnore } from "./watch-policy.ts";
 import { invalidateReferenceCache } from "./refactor/find-refs.ts";
 import type { BuildEntry } from "./types.ts";
 import type { FsEventPayload } from "./refactor/fs-events.ts";
@@ -201,9 +202,12 @@ export function createWatcher(
       pollInterval: 10,
       stabilityThreshold: debounceMs,
     },
+    /* See watch-policy.ts: `ignore` is a name rule and cannot see that an entry is a unix socket
+       (ENXIO from fs.watch) or a symlink pointing out of the project (a walk of the filesystem). */
+    followSymlinks: true,
     ignoreInitial: true,
     ignorePermissionErrors: true,
-    ignored: (watchedPath) => shouldIgnore(watchedPath, ignore),
+    ignored: createWatchIgnore(root, (watchedPath) => shouldIgnore(watchedPath, ignore)),
   });
 
   watcher.on("all", (eventType, changedPath) => {