@speedkit/cli 4.20.4 → 4.20.5

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [4.20.5](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.20.4...v4.20.5) (2026-08-10)
+
+
+### Bug Fixes
+
+* **onboarding:** keep watching a config file after git replaces it ([ef2571a](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/ef2571a5fa07862382c338096e3311c107f20a74))
+
 ## [4.20.4](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.20.3...v4.20.4) (2026-08-10)
 
 

package/README.md

@@ -21,7 +21,7 @@ $ npm install -g @speedkit/cli
 $ sk COMMAND
 running command...
 $ sk (--version)
-@speedkit/cli/4.20.4 linux-x64 node-v22.23.2
+@speedkit/cli/4.20.5 linux-x64 node-v22.23.2
 $ sk --help [COMMAND]
 USAGE
   $ sk COMMAND

package/dist/services/integration-api/spec/file-watch.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/integration-api/spec/file-watch.spec.js

@@ -0,0 +1,81 @@
+import { expect } from "chai";
+import { describe, it, afterEach } from "mocha";
+import { mkdtempSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+// via the model barrel, not struct/file.js directly: the struct modules form an
+// import cycle that only resolves in this order.
+import { File } from "../integration-api-model.js";
+// chokidar needs a real filesystem, so these run against a temp dir rather than memfs.
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** Wait until the change callback has fired at least `count` times. */
+async function waitForCalls(getCalls, count, timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (getCalls() >= count)
+            return;
+        await delay(50);
+    }
+}
+describe("File onChange", function () {
+    // real filesystem events plus chokidar's write-finish debounce
+    this.timeout(20000);
+    let dir;
+    let controller;
+    afterEach(() => {
+        controller?.abort();
+        controller = undefined;
+        if (dir) {
+            rmSync(dir, { recursive: true, force: true });
+            dir = undefined;
+        }
+    });
+    it("keeps reporting edits after the file is replaced instead of written in place", async () => {
+        dir = mkdtempSync(join(tmpdir(), "sk-file-watch-"));
+        const path = join(dir, "config_documentHandler.js");
+        writeFileSync(path, "v0");
+        const file = new File("config_documentHandler", path, "v0");
+        controller = new AbortController();
+        let calls = 0;
+        file.onChange(async () => {
+            calls += 1;
+        }, { signal: controller.signal });
+        await delay(700); // let the watcher attach
+        writeFileSync(path, "v1");
+        await waitForCalls(() => calls, 1);
+        expect(calls, "an in-place write is reported").to.be.at.least(1);
+        // git checkout / reset / rebase / stash / pull replace the file rather than
+        // writing into it. A single-file watch stops firing for good at this point.
+        const callsBeforeReplace = calls;
+        unlinkSync(path);
+        writeFileSync(path, "v2");
+        await waitForCalls(() => calls, callsBeforeReplace + 1);
+        expect(calls, "the replacement itself is reported").to.be.at.least(callsBeforeReplace + 1);
+        // The regression: every edit after the replacement used to be dropped, so
+        // onboarding kept serving the previous build until it was restarted.
+        const callsAfterReplace = calls;
+        writeFileSync(path, "v3");
+        await waitForCalls(() => calls, callsAfterReplace + 1);
+        expect(calls, "an edit after the replacement is still reported").to.be.at.least(callsAfterReplace + 1);
+    });
+    it("ignores changes to sibling files in the same directory", async () => {
+        dir = mkdtempSync(join(tmpdir(), "sk-file-watch-"));
+        const path = join(dir, "config_documentHandler.js");
+        const sibling = join(dir, "config_SpeedKit.js");
+        writeFileSync(path, "v0");
+        writeFileSync(sibling, "other");
+        const file = new File("config_documentHandler", path, "v0");
+        controller = new AbortController();
+        let calls = 0;
+        file.onChange(async () => {
+            calls += 1;
+        }, { signal: controller.signal });
+        await delay(700);
+        writeFileSync(sibling, "other-changed");
+        await delay(900);
+        expect(calls, "a sibling write is not reported").to.equal(0);
+        writeFileSync(path, "v1");
+        await waitForCalls(() => calls, 1);
+        expect(calls, "the watched file is still reported").to.be.at.least(1);
+    });
+});

package/dist/services/integration-api/struct/file.js

@@ -1,4 +1,5 @@
 import { readFile, unlink, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
 import { watch as chokidarWatch } from "chokidar";
 import { FILE_TYPE, } from "../integration-api-model.js";
 export class File {
@@ -47,15 +48,26 @@ export class File {
         if (signal?.aborted) {
             return;
         }
-        // chokidar over node's fs.watch: handles atomic write-then-rename
-        // (Claude Code, VS Code's atomicSave, vim writebackup, …) which fs.watch
-        // misses because inotify is inode-bound and the new file gets a new inode.
-        const watcher = chokidarWatch(this.path, {
+        // Watch the containing directory, not the file: a single-file watch stops
+        // firing for good once the file is *replaced* rather than written in place,
+        // which is what git does on checkout/reset/rebase/stash/pull. The replace
+        // itself still arrives, so the breakage is silent — every later edit is
+        // dropped, no rebuild and no cache clear run, and onboarding keeps serving
+        // the previous build until it is restarted.
+        // depth 0 keeps this to the directory's own entries, and chokidar's atomic
+        // option still folds write-then-rename (Claude Code, VS Code atomicSave,
+        // vim writebackup, …) into a single change event.
+        const target = resolve(this.path);
+        const watcher = chokidarWatch(dirname(target), {
             ignoreInitial: true,
             atomic: true,
+            depth: 0,
             awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 },
         });
-        const handle = async () => {
+        const handle = async (changedPath) => {
+            if (resolve(changedPath) !== target) {
+                return;
+            }
             const content = await readFile(this.path, "utf-8");
             if (content === this.content) {
                 return;

package/oclif.manifest.json

@@ -1001,5 +1001,5 @@
       ]
     }
   },
-  "version": "4.20.4"
+  "version": "4.20.5"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@speedkit/cli",
   "description": "Speed Kit CLI",
-  "version": "4.20.4",
+  "version": "4.20.5",
   "author": {
     "name": "Baqend.com",
     "email": "info@baqend.com"