merge: TUI preferences watcher baseline/watch/reconcile handshake (C1 bug)

Author: ualtinok

packages/plugin/src/shared/tui-preferences.test.ts

@@ -1,9 +1,11 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { parse } from "comment-json";
 import {
+    __resetTuiPreferencesWatchTestHooks,
+    __setTuiPreferencesWatchTestHooks,
     computeEffectiveOrder,
     DEFAULT_PREFS,
     DEFAULT_SLOT_ORDER,
@@ -13,6 +15,7 @@ import {
     readTuiPreferencesFile,
     resolveMagicContextPrefs,
     TUI_PREFS_FILE_ENV,
+    watchTuiPreferences,
 } from "./tui-preferences";
 
 let dir: string;
@@ -28,6 +31,7 @@ beforeEach(async () => {
 });
 
 afterEach(async () => {
+    __resetTuiPreferencesWatchTestHooks();
     for (const key of ENV_KEYS) {
         if (savedEnv[key] === undefined) delete process.env[key];
         else process.env[key] = savedEnv[key];
@@ -79,6 +83,52 @@ describe("readTuiPreferencesFile (tolerant)", () => {
     });
 });
 
+describe("watchTuiPreferences", () => {
+    test("notifies when the initial read resolves after an atomic replacement", async () => {
+        const previous = `{"magic-context":{"sections":{"memory":true}}}\n`;
+        const next = `{"magic-context":{"sections":{"memory":false}}}\n`;
+        await writeFile(file, previous, "utf8");
+
+        let resolveInitialRead!: (text: string) => void;
+        const pendingInitialRead = new Promise<string>((resolve) => {
+            resolveInitialRead = resolve;
+        });
+        let emitWatchEvent!: (event: string, filename: string | null) => void;
+        let readCount = 0;
+        __setTuiPreferencesWatchTestHooks({
+            readFile: () => {
+                readCount += 1;
+                return readCount === 1 ? pendingInitialRead : Promise.resolve(next);
+            },
+            watch: (_directory, listener) => {
+                emitWatchEvent = listener;
+                return { close() {} };
+            },
+        });
+
+        const observed = new Promise<{ memory: boolean }>((resolve) => {
+            const stop = watchTuiPreferences(() => {
+                void readTuiPreferencesFile().then((root) => {
+                    stop();
+                    resolve({ memory: resolveMagicContextPrefs(root).sections.memory });
+                });
+            });
+        });
+
+        const replacement = `${file}.external.tmp`;
+        await writeFile(replacement, next, "utf8");
+        await rename(replacement, file);
+        emitWatchEvent("rename", basename(file));
+        resolveInitialRead(next);
+
+        const result = await Promise.race([
+            observed,
+            new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), 300)),
+        ]);
+        expect(result).toEqual({ memory: false });
+    });
+});
+
 describe("resolveMagicContextPrefs (per-key validation)", () => {
     test("missing key → full defaults clone", () => {
         expect(resolveMagicContextPrefs({})).toEqual(DEFAULT_PREFS);

packages/plugin/src/shared/tui-preferences.ts

@@ -250,6 +250,28 @@ export function queueTuiPreferenceUpdate(
 
 const WATCH_DEBOUNCE_MS = 150;
 
+type WatchReadFile = (file: string) => Promise<string>;
+type WatchDirectory = (
+    directory: string,
+    listener: (event: string, filename: string | null) => void,
+) => { close(): void };
+
+let watchReadFile: WatchReadFile = (file) => readFile(file, "utf8");
+let watchDirectory: WatchDirectory = (directory, listener) => watch(directory, listener);
+
+export function __setTuiPreferencesWatchTestHooks(hooks: {
+    readFile?: WatchReadFile;
+    watch?: WatchDirectory;
+}): void {
+    watchReadFile = hooks.readFile ?? ((file) => readFile(file, "utf8"));
+    watchDirectory = hooks.watch ?? ((directory, listener) => watch(directory, listener));
+}
+
+export function __resetTuiPreferencesWatchTestHooks(): void {
+    watchReadFile = (file) => readFile(file, "utf8");
+    watchDirectory = (directory, listener) => watch(directory, listener);
+}
+
 // Watches the DIRECTORY, not the file: editors and our own atomic writes replace
 // the file via rename, which kills file-level watchers.
 //
@@ -266,33 +288,36 @@ export function watchTuiPreferences(onChange: () => void): () => void {
     const name = basename(file);
     let timer: ReturnType<typeof setTimeout> | null = null;
     let lastSeen: string | null = null;
-    // Seed asynchronously; a real change before the seed resolves still wins
-    // because the debounce re-reads fresh and compares against `lastSeen` (null
-    // → does not match → fires).
-    void readFile(file, "utf8")
-        .then((text) => {
-            if (lastSeen === null) lastSeen = text;
-        })
-        .catch(() => {});
     try {
-        const watcher = watch(dirname(file), (_event, filename) => {
+        lastSeen = readFileSync(file, "utf8");
+    } catch {
+        // A missing or temporarily unreadable baseline is retried after registration.
+    }
+    const reconcile = (): void => {
+        void watchReadFile(file)
+            .catch(() => null)
+            .then((text) => {
+                if (text === null || text === lastSeen) return;
+                lastSeen = text;
+                onChange();
+            });
+    };
+    try {
+        const watcher = watchDirectory(dirname(file), (_event, filename) => {
             const isOurs =
                 filename === name ||
                 (filename?.startsWith(`${name}.`) && filename.endsWith(".tmp"));
             if (filename != null && !isOurs) return;
             if (timer) clearTimeout(timer);
             timer = setTimeout(() => {
                 timer = null;
-                void readFile(file, "utf8")
-                    .catch(() => null)
-                    .then((text) => {
-                        if (text === null) return;
-                        if (text === lastSeen) return;
-                        lastSeen = text;
-                        onChange();
-                    });
+                reconcile();
             }, WATCH_DEBOUNCE_MS);
         });
+        // Reconcile after registration: a change between the baseline read and
+        // watcher installation is observed here, while later changes schedule
+        // the same reconciliation path through the watcher callback above.
+        reconcile();
         return () => {
             if (timer) clearTimeout(timer);
             watcher.close();