fix: handle non-regular files in dev watcher to prevent crashes

The dev file watcher crashes when Unix socket files (e.g. from overmind
or pm2) exist in the project root. chokidar v4 calls fs.watch() on
these files, which fails on macOS with errno -102 (UNKNOWN).

- Extract watcher ignore logic into an exported `isIgnoredByWatcher`
  function for testability
- Run cheap path-based checks before the fs.statSync call to avoid
  unnecessary syscalls on already-ignored paths
- Filter non-regular files (sockets, pipes, etc.) via fs.statSync
- Add an error handler on the watcher so unexpected errors log a
  warning instead of crashing the process

Fixes: https://github.com/RomanBaiocco/react-router-sock-repro
Related: paulmillr/chokidar#1391

Author: RomanBaiocco

.changeset/fix-dev-socket-file-crash.md

@@ -0,0 +1,5 @@
+---
+"@react-router/dev": patch
+---
+
+Fix `react-router dev` crash when Unix socket files exist in the project root

packages/react-router-dev/__tests__/watcher-ignored-test.ts

@@ -0,0 +1,70 @@
+import path from "node:path";
+import fs from "node:fs";
+import net from "node:net";
+import os from "node:os";
+
+import { isIgnoredByWatcher } from "../config/config";
+
+describe("isIgnoredByWatcher", () => {
+  let tmpDir: string;
+  let root: string;
+  let appDirectory: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "rr-watcher-test-"));
+    root = tmpDir;
+    appDirectory = path.join(root, "app");
+    fs.mkdirSync(appDirectory, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("does not ignore regular files at root level", () => {
+    let filePath = path.join(root, "react-router.config.ts");
+    fs.writeFileSync(filePath, "");
+    expect(isIgnoredByWatcher(filePath, { root, appDirectory })).toBe(false);
+  });
+
+  it("does not ignore the root directory itself", () => {
+    expect(isIgnoredByWatcher(root, { root, appDirectory })).toBe(false);
+  });
+
+  it("does not ignore files inside app directory", () => {
+    let filePath = path.join(appDirectory, "root.tsx");
+    fs.writeFileSync(filePath, "");
+    expect(isIgnoredByWatcher(filePath, { root, appDirectory })).toBe(false);
+  });
+
+  it("ignores files in subdirectories outside the app directory", () => {
+    let subDir = path.join(root, "node_modules", "some-package");
+    fs.mkdirSync(subDir, { recursive: true });
+    let filePath = path.join(subDir, "index.js");
+    fs.writeFileSync(filePath, "");
+    expect(isIgnoredByWatcher(filePath, { root, appDirectory })).toBe(true);
+  });
+
+  it("ignores Unix socket files at the root level", (done) => {
+    let socketPath = path.join(root, "overmind.sock");
+    let server = net.createServer();
+
+    server.listen(socketPath, () => {
+      expect(isIgnoredByWatcher(socketPath, { root, appDirectory })).toBe(
+        true,
+      );
+      server.close(done);
+    });
+  });
+
+  it("ignores paths that cannot be stat'd", () => {
+    let nonexistent = path.join(root, "ghost.sock");
+    // File doesn't exist — statSync with throwIfNoEntry: false returns
+    // undefined, so this should fall through to `return false`. But if
+    // statSync throws for another reason, the catch block returns true.
+    // Here we just verify it doesn't throw.
+    expect(() =>
+      isIgnoredByWatcher(nonexistent, { root, appDirectory }),
+    ).not.toThrow();
+  });
+});

packages/react-router-dev/config/config.ts

@@ -818,17 +818,14 @@ export async function createConfigLoader({
       if (!fsWatcher) {
         fsWatcher = chokidar.watch([root, appDirectory], {
           ignoreInitial: true,
-          ignored: (path) => {
-            let dirname = Path.dirname(path);
-
-            return (
-              !dirname.startsWith(appDirectory) &&
-              // Ensure we're only watching files outside of the app directory
-              // that are at the root level, not nested in subdirectories
-              path !== root && // Watch the root directory itself
-              dirname !== root // Watch files at the root level
-            );
-          },
+          ignored: (path) =>
+            isIgnoredByWatcher(path, { root, appDirectory }),
+        });
+
+        fsWatcher.on("error", (error: unknown) => {
+          let message =
+            error instanceof Error ? error.message : String(error);
+          console.warn(colors.yellow(`File watcher error: ${message}`));
         });
 
         fsWatcher.on("all", async (...args) => {
@@ -1166,3 +1163,32 @@ function isEntryFileDependency(
 
   return false;
 }
+
+export function isIgnoredByWatcher(
+  path: string,
+  { root, appDirectory }: { root: string; appDirectory: string },
+): boolean {
+  let dirname = Path.dirname(path);
+
+  let ignoredByPath =
+    !dirname.startsWith(appDirectory) &&
+    path !== root &&
+    dirname !== root;
+
+  if (ignoredByPath) {
+    return true;
+  }
+
+  // Filter out non-regular files (sockets, pipes, etc.) that
+  // crash fs.watch() on macOS with errno -102
+  try {
+    let stat = fs.statSync(path, { throwIfNoEntry: false });
+    if (stat && !stat.isFile() && !stat.isDirectory()) {
+      return true;
+    }
+  } catch {
+    return true;
+  }
+
+  return false;
+}