@cueloop/daemon 0.1.0-alpha.106 → 0.1.0-alpha.107

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.106",
+  "version": "0.1.0-alpha.107",
   "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -44,8 +44,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/extension-api": "0.1.0-alpha.106",
-    "@cueloop/schema": "0.1.0-alpha.106",
+    "@cueloop/extension-api": "0.1.0-alpha.107",
+    "@cueloop/schema": "0.1.0-alpha.107",
     "@pierre/diffs": "^1.5.2",
     "effect": "^4.0.4",
     "smol-toml": "^1.9.1",

package/src/diff-watcher.test.ts

@@ -117,3 +117,49 @@ test("replacing a watch during reconciliation stops the old directory traversal"
     fs.rmSync(repo, { recursive: true, force: true });
   }
 });
+
+/** A watch listener as the runtime calls it: Bun on Linux can pass an undefined filename. */
+type RuntimeWatchListener = (event: fs.WatchEventType, filename: string | null | undefined) => void;
+
+test("a change without a filename still refreshes and watches a new directory", async () => {
+  const repo = fs.mkdtempSync(join(tmpdir(), "cueloop-watch-unnamed-"));
+  const watch = fs.watch;
+  const listeners = new Map<string, RuntimeWatchListener>();
+  let refreshes = 0;
+  const startup = Promise.withResolvers<void>();
+  const change = Promise.withResolvers<void>();
+  const watcher = new DiffWatcher(() => {
+    refreshes++;
+
+    if (refreshes === 1) startup.resolve();
+    else change.resolve();
+  });
+  // SAFETY: DiffWatcher always calls the string-filename, three-argument watch overload; the
+  // listener is typed as the runtime calls it, which may pass an undefined filename.
+  const spy = spyOn(fs, "watch").mockImplementation(((
+    path: fs.PathLike,
+    options: fs.WatchOptions,
+    listener: RuntimeWatchListener,
+  ) => {
+    listeners.set(String(path), listener);
+
+    return watch(path, options, () => {});
+  }) as typeof fs.watch);
+
+  try {
+    watcher.trackDiffRepo(repo, "session");
+    await startup.promise;
+    const onRootChange = listeners.get(repo);
+
+    expect(onRootChange).toBeDefined();
+    fs.mkdirSync(join(repo, "fresh"));
+    expect(() => onRootChange?.("rename", undefined)).not.toThrow();
+    await change.promise;
+    expect(refreshes).toBe(2);
+    expect(listeners.has(join(repo, "fresh"))).toBe(true);
+  } finally {
+    watcher.close();
+    spy.mockRestore();
+    fs.rmSync(repo, { recursive: true, force: true });
+  }
+});

package/src/diff-watcher.ts

@@ -65,7 +65,7 @@ function spawnGit(args: string[], cwd: string): { exitCode: number; stdout: Buff
 }
 
 /** The git-metadata filenames whose change means `git diff HEAD` moved: a checkout, a commit, or a reset. */
-function isRefChange(filename: string): boolean {
+function isRefChange(filename: string | null): boolean {
   return filename === "HEAD" || filename === "packed-refs";
 }
 
@@ -198,9 +198,12 @@ export class DiffWatcher {
     if (ALWAYS_IGNORED_DIRS.has(basename(dir)) || repoWatch.ignored.has(dir)) return true;
 
     const opened = this.watchInto(repoWatch.handles, dir, { recursive: false }, (filename) => {
-      this.scheduleRepoRefresh(repoRoot);
       // a newly created subdirectory needs its own watch (a recursive watch got this for free)
-      this.extendWatch(repoRoot, join(dir, filename));
+      if (filename !== null) this.extendWatch(repoRoot, join(dir, filename));
+      // no name for the change: rescan the tree on the next refresh so a new directory is not missed
+      else repoWatch.reconcilePending = true;
+
+      this.scheduleRepoRefresh(repoRoot);
     });
 
     if (!opened) return false;
@@ -278,17 +281,18 @@ export class DiffWatcher {
    * Open one watcher and add it to `handles`; returns whether it opened. A
    * watcher error (the path is deleted mid-review) is swallowed - hot-reload is
    * best-effort and must never take down the daemon. The inherited EventEmitter
-   * `on` is absent from Bun's FSWatcher type.
+   * `on` is absent from Bun's FSWatcher type. The platform may omit the changed
+   * name (Bun on Linux passes undefined, Node passes null); `onFile` then gets null.
    */
   private watchInto(
     handles: FSWatcher[],
     path: string,
     options: { recursive: boolean },
-    onFile: (filename: string) => void,
+    onFile: (filename: string | null) => void,
   ): boolean {
     try {
       const handle = watch(path, options, (_event, filename) => {
-        if (filename !== null) onFile(filename.toString());
+        onFile(filename == null ? null : filename.toString());
       });
 
       handle.on("error", () => {});