litmus-cli 1.4.92 → 1.4.94

package/dist/lib/vscode-server-preparation.js

@@ -0,0 +1,78 @@
+import { spawn } from "child_process";
+import { configSetsRemoteCommand } from "./ssh-client.js";
+/** Prepare the exact client build before advertising the laptop launcher as ready.
+ * Uses the workspace's existing proxy; never downloads code to the laptop. Existing
+ * editor installations are left alone, including a concurrent Remote-SSH install.
+ */
+export function vscodePreparationScript(commit) {
+    if (!/^[a-f0-9]{40}$/i.test(commit))
+        throw new Error("Invalid editor commit");
+    return `import json,pathlib,subprocess,tarfile,tempfile,os,fcntl
+commit=${JSON.stringify(commit)}
+home=pathlib.Path.home()
+root=home/".vscode-server"
+root.mkdir(exist_ok=True)
+def valid(p):
+    try:
+        return (p/"bin/code-server").is_file() and (p/"node").is_file() and json.loads((p/"product.json").read_text()).get("commit")==commit
+    except (OSError,ValueError): return False
+with (root/".litmus-prepare.lock").open("a") as lock:
+    fcntl.flock(lock,fcntl.LOCK_EX)
+    destination=root/"cli/servers"/("Stable-"+commit)/"server"
+    if valid(destination):
+        print("ready")
+        raise SystemExit(0)
+    if destination.exists() or destination.is_symlink(): raise SystemExit(1)
+    cache=root/".litmus-cache"
+    cache.mkdir(exist_ok=True)
+    target=cache/commit
+    if not valid(target):
+        if target.exists(): raise SystemExit(1)
+        with tempfile.TemporaryDirectory(prefix="prepare-",dir=cache) as temporary:
+            temporary=pathlib.Path(temporary)
+            archive=temporary/"server.tar.gz"
+            subprocess.run(["curl","-fsSL","--connect-timeout","10","--max-time","75","-o",str(archive),"https://update.code.visualstudio.com/commit:"+commit+"/server-linux-x64/stable"],check=True,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
+            extracted=temporary/"unpacked"
+            extracted.mkdir()
+            with tarfile.open(archive) as tar:
+                tar.extractall(extracted,filter="data")
+            children=list(extracted.iterdir())
+            if len(children)!=1 or not valid(children[0]): raise SystemExit(1)
+            subprocess.run([str(children[0]/"node"),"--version"],check=True,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL,timeout=5)
+            os.rename(children[0],target)
+    destination.parent.mkdir(parents=True,exist_ok=True)
+    try: destination.symlink_to(target)
+    except FileExistsError: pass
+    if not valid(destination): raise SystemExit(1)
+    print("ready")
+`;
+}
+export function prepareVscodeServer(alias, commit, signal) {
+    if (!/^litmus-[a-zA-Z0-9-]+$/.test(alias) || !/^[a-f0-9]{40}$/i.test(commit) || signal.aborted)
+        return Promise.resolve(false);
+    return new Promise(resolve => {
+        const args = ["-o", "BatchMode=yes", "-o", "ConnectTimeout=10", "-o", "PermitLocalCommand=no"];
+        if (configSetsRemoteCommand(alias))
+            args.push("-o", "RemoteCommand=none");
+        args.push(alias, "python3 -");
+        const child = spawn("ssh", args, { stdio: ["pipe", "pipe", "ignore"] });
+        let output = "", settled = false;
+        const done = (ok) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal.removeEventListener("abort", abort);
+            resolve(ok);
+        };
+        const abort = () => { child.kill(); done(false); };
+        const timer = setTimeout(abort, 100000);
+        signal.addEventListener("abort", abort, { once: true });
+        child.stdout.on("data", data => { output = (output + String(data)).slice(-1024); });
+        child.stdin.on("error", () => { });
+        child.once("error", () => done(false));
+        child.once("exit", code => done(code === 0 && output.trim() === "ready"));
+        child.stdin.end(vscodePreparationScript(commit));
+    });
+}
+//# sourceMappingURL=vscode-server-preparation.js.map

package/dist/lib/vscode-server-preparation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vscode-server-preparation.js","sourceRoot":"","sources":["../../src/lib/vscode-server-preparation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AACrC,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAA;AAEzD;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CAAC,MAAc;IACpD,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAA;IAC7E,OAAO;SACA,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqC9B,CAAA;AACD,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,KAAa,EAAE,MAAc,EAAE,MAAmB;IACpF,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO;QAAE,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC7H,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;QAC3B,MAAM,IAAI,GAAG,CAAC,IAAI,EAAE,eAAe,EAAE,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,uBAAuB,CAAC,CAAA;QAC9F,IAAI,uBAAuB,CAAC,KAAK,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,oBAAoB,CAAC,CAAA;QACzE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,CAAA;QAC7B,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,EAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAC,CAAC,CAAA;QACrE,IAAI,MAAM,GAAG,EAAE,EAAE,OAAO,GAAG,KAAK,CAAA;QAChC,MAAM,IAAI,GAAG,CAAC,EAAW,EAAE,EAAE;YAC3B,IAAI,OAAO;gBAAE,OAAM;YACnB,OAAO,GAAG,IAAI,CAAA;YACd,YAAY,CAAC,KAAK,CAAC,CAAA;YACnB,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;YAC1C,OAAO,CAAC,EAAE,CAAC,CAAA;QACb,CAAC,CAAA;QACD,MAAM,KAAK,GAAG,GAAG,EAAE,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA,CAAC,CAAC,CAAA;QACjD,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,EAAE,MAAO,CAAC,CAAA;QACxC,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,IAAI,EAAC,CAAC,CAAA;QACrD,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAA,CAAC,CAAC,CAAC,CAAA;QAClF,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,GAAE,CAAC,CAAC,CAAA;QACjC,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QACtC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,MAAM,CAAC,IAAI,EAAE,KAAK,OAAO,CAAC,CAAC,CAAA;QACzE,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAAA;IAClD,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/dist/lib/watcher.js

@@ -25,7 +25,7 @@ import { execSync, execFile } from "child_process";
 import dns from "dns";
 import https from "https";
 import http from "http";
-import { watch as chokidarWatch } from "chokidar";
+import { startFileMonitor, fileMonitorPolicy } from "./file-monitor.js";
 import { getEffectiveDeadline, writeConfig, validateRebuiltTimes, computeTimeSync } from "./config.js";
 import { CLI_VERSION } from "./version.js";
 import { armDeadlinePoll, createAutoSubmitController } from "./deadline.js";
@@ -40,7 +40,7 @@ import { readActivityLogTail } from "./activity-tail.js";
 import { setupAiTracking } from "../commands/init.js";
 import { writeShadowChainCursor, readShadowChainCursor, writeShadowTrackerFile, writeShadowReviveInfo, readShadowConfigById, findShadowConfigForDir, deleteShadowForAssessment, writeRepairFile, removeRepairFile, REPAIR_FILE_NAME, } from "./shadow.js";
 import { createKeepAliveGuard } from "./keepalive.js";
-import { WATCHER_READY_GRACE_MS } from "./tracker.js";
+import { WATCHER_READY_GRACE_MS, WATCHER_BOOT_TIMEOUT_MS } from "./tracker.js";
 import { getProcessListAsync, probeUnfilteredTasklist, getConnections, extractConnection, resolvePidNames } from "./platform.js";
 import { detectTools, refineClaudeTool } from "./detection.js";
 import { decideNudge, loadNudgeState, saveNudgeState, scanAssessmentCapture, writeAiNoticeFile, removeAiNoticeFile, nudgeNotificationCopy, isCliNoticeArtifact, AI_NOTICE_FILE_NAME, } from "./capture-nudge.js";
@@ -79,7 +79,7 @@ process.on("unhandledRejection", (reason) => {
 });
 let [, , projectDir, activityLogPath, cliBinPath, noncePath] = process.argv;
 process.stderr.write(`[watcher] starting: projectDir=${projectDir} log=${activityLogPath}\n`);
-process.stderr.write(`[watcher] node ${process.version}, platform=${process.platform}, arch=${process.arch}\n`);
+process.stderr.write(`[watcher] node ${process.version}, platform=${process.platform}, arch=${process.arch}, kernel=${os.release()}\n`);
 // Touch the nonce file on startup so tracker.ts can distinguish "our watcher
 // is alive" from "a recycled PID happens to match an old tracker.pid".
 // Heartbeat updates the mtime; tracker.ts compares against NONCE_MAX_AGE_MS.
@@ -166,15 +166,28 @@ function claimantIsAlive(owner) {
 // reclaim from it just like a corpse. The env override exists for tests only.
 // The default is tracker.ts's, so it cannot fall below init's boot wait (ENG-3194).
 let readyFilePath = path.join(path.dirname(activityLogPath), "tracker.ready");
+let fileCaptureVerified = false;
+let chainStartTimer;
 const READY_GRACE_MS = Number(process.env.LITMUS_WATCHER_READY_GRACE_MS) || WATCHER_READY_GRACE_MS;
 function markReady() {
+    if (!fileCaptureVerified)
+        return false;
     try {
         fs.writeFileSync(readyFilePath, String(process.pid), "utf8");
+        // A successor may take time to verify files. Its incumbent keeps writing
+        // until this stamp appears, so the handoff delay starts NOW, not at spawn.
+        if (!chainStartTimer && preChainBuffer !== null && !chainAbandoned) {
+            chainStartTimer = setTimeout(startChain, CHAIN_START_DELAY_MS);
+        }
+        return true;
     }
     catch (err) {
-        // Non-fatal: we keep watching either way. Worst case another watcher
-        // eventually reclaims the pid file from us; the project stays tracked.
         process.stderr.write(`[watcher] could not write ready marker: ${err}\n`);
+        // Without the stamp an incumbent cannot yield and chain writes cannot
+        // start. Flush the unchained startup buffer and retire, rather than hold
+        // the rest of the session in memory forever.
+        shutdown({ preserveSentinel: true });
+        return false;
     }
 }
 function claimantIsReady(owner) {
@@ -519,6 +532,18 @@ const IGNORED = [
 const noticeOwnership = new Map();
 isCliNoticeArtifact(projectDir, AI_NOTICE_FILE_NAME, noticeOwnership);
 isCliNoticeArtifact(projectDir, REPAIR_FILE_NAME, noticeOwnership);
+const AI_ARTIFACT_PATTERNS = [
+    { tool: "cursor", paths: [".cursorrules", ".cursorignore"] },
+    { tool: "windsurf", paths: [".windsurfrules"] },
+    { tool: "aider", paths: [".aider.chat.history.md", ".aider.input.history", ".aider.tags.cache"] },
+    { tool: "continue", paths: [".continue"] },
+    { tool: "codeium", paths: [".codeium"] },
+    { tool: "tabnine", paths: [".tabnine"] },
+    { tool: "codex", paths: ["codex.md", ".codex"] },
+];
+function isAiArtifactPath(relative) {
+    return AI_ARTIFACT_PATTERNS.some(({ paths }) => paths.some(p => relative === p || relative.startsWith(p + "/") || relative.startsWith(p + "\\")));
+}
 function shouldIgnore(relPath) {
     return isCliNoticeArtifact(projectDir, relPath, noticeOwnership) || IGNORED.some((re) => re.test(relPath));
 }
@@ -607,7 +632,6 @@ function startChain() {
     for (const event of queued)
         writeChained(event);
 }
-setTimeout(startChain, CHAIN_START_DELAY_MS);
 /**
  * Shutdown inside the chain-start window: the incumbent may still own the
  * chain tail, so snapshotting it here would recreate the fork the deferral
@@ -712,63 +736,54 @@ function handleFileEvent(eventType, filename) {
     }, 500));
 }
 let fileWatcher;
+let fileWatchingReady;
 function startFileWatching() {
-    if (process.platform === "win32") {
-        // Node's fs.watch(dir, { recursive: true }) on Windows uses
-        // ReadDirectoryChangesW. On windows-2025-vs2026 runners with Node 24 this
-        // path calls __fastfail() from native code after watcher init completes,
-        // aborting the process with exit code 0xC0000409 and bypassing every
-        // JS-level exit hook (uncaughtException, beforeExit, exit). Confirmed by
-        // an isolation test that gated fs.watch behind an env var and showed the
-        // watcher healthy on the same runner. Until either Node or libuv fixes
-        // the recursive watch on Windows 2025, use chokidar's polling mode here.
-        try {
-            const watcher = chokidarWatch(projectDir, {
-                ignoreInitial: true,
-                followSymlinks: false,
-                usePolling: true,
-                interval: 500,
-                binaryInterval: 1000,
-                ignored: (p) => {
-                    const rel = path.relative(projectDir, p);
-                    // Don't ignore the root dir itself, or chokidar reports nothing.
-                    if (!rel)
-                        return false;
-                    return shouldIgnore(rel);
+    fileCaptureVerified = false;
+    const startedAt = Date.now();
+    const { polling } = fileMonitorPolicy();
+    const modes = polling ? [true] : [false, true];
+    fileWatchingReady = (async () => {
+        for (let attempt = 0; attempt < modes.length; attempt++) {
+            let failure;
+            process.stderr.write(`[watcher] file watcher starting (${modes[attempt] ? "polling" : "native"}, filtered discovery)\n`);
+            const monitor = startFileMonitor({
+                directory: projectDir,
+                ignored: shouldIgnore,
+                observed: isAiArtifactPath,
+                onEvent: handleFileEvent,
+                polling: modes[attempt],
+                timeoutMs: Math.floor((WATCHER_BOOT_TIMEOUT_MS - 1000) / modes.length),
+                onError: (error) => {
+                    failure = error;
+                    fileCaptureVerified = false;
+                    process.stderr.write(`[watcher] file capture unavailable: ${error.message}\n`);
+                    try {
+                        if (fs.readFileSync(readyFilePath, "utf8").trim() === String(process.pid))
+                            fs.unlinkSync(readyFilePath);
+                    }
+                    catch { /* no ready marker */ }
                 },
             });
-            fileWatcher = watcher;
-            watcher.on("add", (p) => handleFileEvent("rename", path.relative(projectDir, p)));
-            watcher.on("change", (p) => handleFileEvent("change", path.relative(projectDir, p)));
-            watcher.on("unlink", (p) => handleFileEvent("rename", path.relative(projectDir, p)));
-            watcher.on("error", (err) => {
-                process.stderr.write(`[watcher] chokidar error: ${err}\n`);
-            });
-            process.stderr.write("[watcher] file watcher started (chokidar polling)\n");
-        }
-        catch (err) {
-            process.stderr.write(`[watcher] chokidar setup failed: ${err.message} (heartbeat + git tracking still active)\n`);
-        }
-    }
-    else {
-        try {
-            const watcher = fs.watch(projectDir, { recursive: true }, (eventType, filename) => {
-                if (!filename)
-                    return;
-                handleFileEvent(eventType, filename);
-            });
-            fileWatcher = watcher;
-            watcher.on("error", (err) => {
-                process.stderr.write(`[watcher] fs.watch error: ${err}\n`);
-            });
-            process.stderr.write("[watcher] file watcher started\n");
-        }
-        catch (err) {
-            // fs.watch with recursive: true is not supported on Linux < Node 22.
-            // Continue without file watching — heartbeats and git commit polling still work.
-            process.stderr.write(`[watcher] file watching unavailable: ${err.message} (heartbeat + git tracking still active)\n`);
+            fileWatcher = monitor;
+            try {
+                await monitor.ready;
+                if (failure)
+                    throw failure;
+                if (fileWatcher !== monitor || shuttingDown)
+                    throw new Error("File watcher replaced or stopped during verification");
+                fileCaptureVerified = true;
+                process.stderr.write(`[watcher] file capture verified in ${Date.now() - startedAt}ms\n`);
+                return;
+            }
+            catch (error) {
+                await monitor.close();
+                if (shuttingDown || fileWatcher !== monitor || attempt === modes.length - 1)
+                    throw error;
+                process.stderr.write("[watcher] native file probe failed; retrying with polling\n");
+            }
         }
-    }
+    })();
+    void fileWatchingReady.catch(() => { });
 }
 startFileWatching();
 // ── Config presence check ────────────────────────────────────────
@@ -1274,15 +1289,6 @@ async function detectEnvironment() {
 setTimeout(() => { void detectEnvironment(); }, 0);
 setInterval(() => { void detectEnvironment(); }, 10 * 60 * 1000); // Every 10 minutes
 // ── AI artifact file detection ──────────────────────────────────
-const AI_ARTIFACT_PATTERNS = [
-    { tool: "cursor", paths: [".cursorrules", ".cursorignore"] },
-    { tool: "windsurf", paths: [".windsurfrules"] },
-    { tool: "aider", paths: [".aider.chat.history.md", ".aider.input.history", ".aider.tags.cache"] },
-    { tool: "continue", paths: [".continue"] },
-    { tool: "codeium", paths: [".codeium"] },
-    { tool: "tabnine", paths: [".tabnine"] },
-    { tool: "codex", paths: ["codex.md", ".codex"] },
-];
 const seenArtifacts = new Set();
 function checkArtifact(relPath) {
     if (seenArtifacts.has(relPath))
@@ -1538,8 +1544,13 @@ function reportProjectRootProblem() {
             readyFilePath = path.join(path.dirname(activityLogPath), "tracker.ready");
             watchedConfigPath = path.join(projectDir, ".litmus", "config.json");
             shutdownFile = path.join(projectDir, ".litmus", "shutdown");
-            void Promise.resolve(fileWatcher?.close()).then(() => { if (!shuttingDown)
-                startFileWatching(); }).catch(() => {
+            void Promise.resolve(fileWatcher?.close()).then(() => {
+                if (!shuttingDown) {
+                    startFileWatching();
+                    void fileWatchingReady.then(() => { if (!shuttingDown)
+                        markReady(); }, () => { });
+                }
+            }).catch(() => {
                 process.stderr.write("[watcher] file watcher could not restart after folder move\n");
             });
             addActiveAssessment(projectDir);
@@ -1758,7 +1769,7 @@ if (cliBinPath && litmusConfig) {
 // ── Graceful shutdown ────────────────────────────────────────────
 let shuttingDown = false;
 let shutdownFile = path.join(projectDir, ".litmus", "shutdown");
-function shutdown() {
+function shutdown(options = {}) {
     if (shuttingDown)
         return;
     shuttingDown = true;
@@ -1772,10 +1783,12 @@ function shutdown() {
     // them unchained instead; a fork is structurally impossible that way.
     abandonChainAndDrain();
     // Clean up sentinel file if it exists
-    try {
-        fs.unlinkSync(shutdownFile);
+    if (!options.preserveSentinel) {
+        try {
+            fs.unlinkSync(shutdownFile);
+        }
+        catch { /* may not exist */ }
     }
-    catch { /* may not exist */ }
     // Drop our readiness stamp so it can't outlive us and vouch for whatever
     // process later recycles our pid (see claimantIsReady). Only ours — a
     // successor's stamp is not ours to remove.
@@ -1806,7 +1819,7 @@ process.on("SIGINT", shutdown);
 const sentinelPoll = setInterval(() => {
     if (fs.existsSync(shutdownFile)) {
         process.stderr.write("[watcher] shutdown sentinel detected\n");
-        shutdown();
+        shutdown({ preserveSentinel: !fileCaptureVerified });
         return;
     }
     // Recurring half of the singleton claim — see the note beside
@@ -1819,6 +1832,14 @@ const sentinelPoll = setInterval(() => {
 sentinelPoll.unref(); // Don't keep process alive just for this
 // Everything is running — publish readiness so an incumbent knows this
 // process is a working watcher, not a wedged claimant (see markReady).
-markReady();
-process.stderr.write("[watcher] all monitors started\n");
+void fileWatchingReady.then(() => {
+    if (shuttingDown)
+        return;
+    if (markReady())
+        process.stderr.write("[watcher] all monitors started; file capture verified\n");
+}, (error) => {
+    process.stderr.write(`[watcher] startup incomplete: ${error instanceof Error ? error.message : error} (retiring unverified watcher)\n`);
+    // A failed replacement must not consume a stop requested for its incumbent.
+    shutdown({ preserveSentinel: true });
+});
 //# sourceMappingURL=watcher.js.map