@cueloop/daemon 0.1.0-alpha.95 → 0.1.0-alpha.96

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.95",
+  "version": "0.1.0-alpha.96",
   "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -39,10 +39,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/extension-api": "0.1.0-alpha.95",
-    "@cueloop/schema": "0.1.0-alpha.95",
+    "@cueloop/extension-api": "0.1.0-alpha.96",
+    "@cueloop/schema": "0.1.0-alpha.96",
     "@pierre/diffs": "^1.4.1",
-    "effect": "^4.0.0-rc.116",
+    "effect": "^4.0.0-rc.117",
     "smol-toml": "^1.8.0",
     "valibot": "^1.5.0"
   },

package/src/diff-watcher.test.ts

@@ -0,0 +1,117 @@
+import { expect, mock, spyOn, test } from "bun:test";
+import * as fs from "node:fs";
+import * as promises from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DiffWatcher } from "./diff-watcher";
+
+const directoryReads: {
+  readdir: (path: fs.PathLike, options: { withFileTypes: true }) => Promise<fs.Dirent[]>;
+} = promises;
+
+test("startup reconciliation watches a directory whose creation event was missed", async () => {
+  const repo = fs.mkdtempSync(join(tmpdir(), "cueloop-watch-startup-"));
+  const watch = fs.watch;
+  const listeners = new Map<string, fs.WatchListener<string>>();
+  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.
+  const spy = spyOn(fs, "watch").mockImplementation(((
+    path: fs.PathLike,
+    options: fs.WatchOptions,
+    listener: fs.WatchListener<string>,
+  ) => {
+    listeners.set(String(path), listener);
+
+    return watch(path, options, () => {});
+  }) as typeof fs.watch);
+
+  try {
+    watcher.trackDiffRepo(repo, "session");
+    fs.mkdirSync(join(repo, "nested"));
+    await startup.promise;
+    expect(refreshes).toBe(1);
+    const onDirectoryChange = listeners.get(join(repo, "nested"));
+
+    expect(onDirectoryChange).toBeDefined();
+    fs.writeFileSync(join(repo, "nested", "inside.ts"), "export const inside = 1;\n");
+    onDirectoryChange?.("change", "inside.ts");
+    await change.promise;
+    expect(refreshes).toBe(2);
+  } finally {
+    watcher.close();
+    spy.mockRestore();
+    fs.rmSync(repo, { recursive: true, force: true });
+  }
+});
+
+test("closing during startup reconciliation cancels the pending refresh", async () => {
+  const repo = fs.mkdtempSync(join(tmpdir(), "cueloop-watch-close-"));
+  const scanStarted = Promise.withResolvers<void>();
+  const scanFinished = Promise.withResolvers<fs.Dirent[]>();
+  const refresh = mock(() => {});
+  const watcher = new DiffWatcher(refresh);
+  const spy = spyOn(directoryReads, "readdir").mockImplementation(() => {
+    scanStarted.resolve();
+
+    return scanFinished.promise;
+  });
+
+  try {
+    watcher.trackDiffRepo(repo, "session");
+    await scanStarted.promise;
+    watcher.close();
+    scanFinished.resolve([]);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(refresh).not.toHaveBeenCalled();
+  } finally {
+    scanFinished.resolve([]);
+    watcher.close();
+    spy.mockRestore();
+    fs.rmSync(repo, { recursive: true, force: true });
+  }
+});
+
+test("replacing a watch during reconciliation stops the old directory traversal", async () => {
+  const repo = fs.mkdtempSync(join(tmpdir(), "cueloop-watch-replace-"));
+  const first = join(repo, "a");
+  const next = join(repo, "b");
+
+  fs.mkdirSync(first);
+  fs.mkdirSync(next);
+  const scanStarted = Promise.withResolvers<void>();
+  const scanFinished = Promise.withResolvers<fs.Dirent[]>();
+  const scanned: string[] = [];
+  const watcher = new DiffWatcher(() => {});
+  const spy = spyOn(directoryReads, "readdir").mockImplementation((path) => {
+    scanned.push(String(path));
+    if (path === first) {
+      scanStarted.resolve();
+
+      return scanFinished.promise;
+    }
+
+    return Promise.resolve(fs.readdirSync(path, { withFileTypes: true }));
+  });
+
+  try {
+    watcher.trackDiffRepo(repo, "old");
+    await scanStarted.promise;
+    watcher.untrackDiffRepo(repo, "old");
+    watcher.trackDiffRepo(repo, "replacement");
+    scanFinished.resolve([]);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(scanned).not.toContain(next);
+  } finally {
+    scanFinished.resolve([]);
+    watcher.close();
+    spy.mockRestore();
+    fs.rmSync(repo, { recursive: true, force: true });
+  }
+});

package/src/diff-watcher.ts

@@ -10,6 +10,7 @@
  */
 
 import { watch, readdirSync, statSync, type Dirent, type FSWatcher } from "node:fs";
+import { readdir } from "node:fs/promises";
 import { basename, isAbsolute, join } from "node:path";
 
 /** Debounce window: a save or a checkout writes many files in a burst; collapse them into one re-capture. */
@@ -99,6 +100,7 @@ interface RepoWatch {
   ignored: Set<string>;
   /** Directories already watched, so a runtime-created dir is not watched twice. */
   watchedDirs: Set<string>;
+  reconcilePending: boolean;
   debounce: ReturnType<typeof setTimeout> | null;
 }
 
@@ -130,6 +132,7 @@ export class DiffWatcher {
       jjPoll: null,
       ignored: ignoredDirectories(repoRoot),
       watchedDirs: new Set(),
+      reconcilePending: true,
       debounce: null,
     };
 
@@ -229,6 +232,32 @@ export class DiffWatcher {
     this.watchTree(repoRoot, path);
   }
 
+  /** Directory creation events can be lost while the platform activates a watch. */
+  private async reconcileWatchTree(repoRoot: string, dir: string): Promise<void> {
+    const repoWatch = this.repoWatches.get(repoRoot);
+
+    if (!repoWatch) return;
+    if (!repoWatch.watchedDirs.has(dir)) {
+      this.extendWatch(repoRoot, dir);
+
+      return;
+    }
+    let entries: Dirent[];
+
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    if (this.repoWatches.get(repoRoot) !== repoWatch) return;
+    for (const entry of entries) {
+      if (this.repoWatches.get(repoRoot) !== repoWatch) return;
+      if (entry.isDirectory() && !entry.isSymbolicLink())
+        // eslint-disable-next-line no-await-in-loop
+        await this.reconcileWatchTree(repoRoot, join(dir, entry.name));
+    }
+  }
+
   /**
    * 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
@@ -278,8 +307,13 @@ export class DiffWatcher {
 
     if (!repoWatch) return;
     if (repoWatch.debounce !== null) clearTimeout(repoWatch.debounce);
-    repoWatch.debounce = setTimeout(() => {
+    repoWatch.debounce = setTimeout(async () => {
       repoWatch.debounce = null;
+      if (repoWatch.reconcilePending) {
+        repoWatch.reconcilePending = false;
+        await this.reconcileWatchTree(repoRoot, repoRoot);
+      }
+      if (this.repoWatches.get(repoRoot) !== repoWatch) return;
       this.onRepoChange(repoRoot);
     }, DIFF_REFRESH_DEBOUNCE_MS);
   }