@bli-cockpit/cli 0.2.26 → 0.2.27

package/dist/autostart.js

@@ -226,6 +226,22 @@ async function installWindowsTask(options) {
         "-File",
         registrationPath,
     ]);
+    // BLI-2996: before this, a nonzero exit here (schtasks rejected the
+    // registration script, or Set-ScheduledTask threw) skipped straight to the
+    // return with `verified: null` and never logged anything — the doctor row
+    // said "needs repair" every run with no way to tell "the rewrite itself
+    // never ran" apart from "it ran and Windows still disagrees" (BLI-2996,
+    // Brandon's machine: same silent non-convergence under two different
+    // validator messages across CLI versions). Metadata only: exit code and
+    // whether the process produced any output, never the stderr/stdout text
+    // (it can carry the state directory or a workspace path).
+    if (created.code !== 0) {
+        console.error("[autostart] windows task repair rewrite failed", JSON.stringify({
+            task_name: WINDOWS_AUTOSTART_TASK_NAME,
+            exit_code: created.code,
+            had_output: Boolean(created.stderr.trim() || created.stdout.trim()),
+        }));
+    }
     const verified = created.code === 0
         ? await windowsTaskStatus({
             ...options,
@@ -238,6 +254,14 @@ async function installWindowsTask(options) {
         })
         : null;
     const loaded = verified?.status === "loaded";
+    // windowsTaskStatus() above already logs the needs-repair case (with the
+    // problem list) when the rewrite ran but the read-back still disagrees; log
+    // the converged branch here too, tagged as a repair outcome and by name, so
+    // "did the rewrite actually fix it this run" never depends on inferring it
+    // from a routine status log emitted for an unrelated reason.
+    if (created.code === 0 && loaded) {
+        console.error("[autostart] windows task repair converged", JSON.stringify({ task_name: WINDOWS_AUTOSTART_TASK_NAME }));
+    }
     return {
         status: "installed",
         label: AUTOSTART_LABEL,
@@ -549,10 +573,17 @@ function windowsTaskRegistrationProblems(taskXml, expected) {
         .replace(/<Exec(?:\s[^>]*)?>[\s\S]*?<\/Exec>/giu, "")
         .trim();
     const exactExecBlock = execBlocks.length === 1 && actionRemainder === "" ? execBlocks[0] : "";
-    const command = exactExecBlock
+    // Strip a wrapping quote pair defensively: every real capture we have shows
+    // Task Scheduler storing <Command> unquoted, but the writer builds the /TR
+    // executable segment with the same \"-escaped quoting it uses for the
+    // launcher argument (BLI-2598), and there is no verified capture proving
+    // schtasks' own TR-splitting heuristic always discards those quotes rather
+    // than leaving them as literal text (BLI-2996 canary-gated gap). A stray
+    // pair of quotes should never be the reason a correctly-registered task
+    // reads as broken.
+    const command = stripSurroundingQuotes(exactExecBlock
         ?.match(/<Command>\s*([^<]*?)\s*<\/Command>/iu)?.[1]
-        ?.trim() ??
-        "";
+        ?.trim() ?? "");
     const actionArguments = exactExecBlock
         .match(/<Arguments>\s*([^<]*?)\s*<\/Arguments>/iu)?.[1]
         ?.trim() ?? "";
@@ -654,16 +685,35 @@ function windowsWScriptPath(env = process.env) {
  * DESKTOP-G2UO1GK (CLI 0.2.13, 2026-08-12), where the stored value differed
  * from the expected one only by those quotes (BLI-2541).
  *
- * Compare the flags exactly, because those are ours, and compare the launcher
- * as a path, because that is what Windows normalizes. Each failure returns its
- * own reason so a repair message says which half is wrong rather than
- * "arguments differ".
+ * BLI-2996: that lesson was only ever applied to the pre-BLI-2677 `-File`
+ * action. The wscript launcher pair (`//B "<launcher>"`) has NO verified
+ * real-Windows capture — `windowlessWindowsTaskXml()` in autostart.test.ts is
+ * SYNTHETIC, built by hand-editing the one real capture we have rather than
+ * exported from a machine actually running this action. A repair that rewrites
+ * the task correctly but is judged against a guessed shape can fail forever
+ * without ever being wrong (Brandon's machine: same non-convergence under two
+ * different validator messages across two CLI versions, neither of which ever
+ * repaired anything). So this comparison is deliberately structural, not
+ * positional: tokenize the way CommandLineToArgvW groups quoted/unquoted
+ * arguments, then check flag-token-then-path-token semantically (a real path
+ * comparison, case- and quote-insensitive) instead of demanding the exact
+ * byte layout we happened to send. Whatever the wscript action's real
+ * normalization turns out to be once a canary captures it, this only fails on
+ * an actual different flag or different script — not on Windows' own
+ * reformatting.
  */
 function windowsActionArgumentProblem(actionArguments, expectedFlags, expectedLauncherPath) {
-    if (!actionArguments.startsWith(expectedFlags)) {
+    const tokens = splitWindowsArgumentTokens(actionArguments);
+    if (tokens.length === 0) {
+        return "task action names no sync launcher to run";
+    }
+    if ((tokens[0] ?? "").toUpperCase() !== expectedFlags.toUpperCase()) {
         return "task action does not run the launcher with the expected batch-mode flag";
     }
-    const launcherArgument = unquoteWindowsArgument(actionArguments.slice(expectedFlags.length));
+    if (tokens.length > 2) {
+        return "task action passes unexpected extra arguments to the sync launcher";
+    }
+    const launcherArgument = tokens[1];
     if (!launcherArgument) {
         return "task action names no sync launcher to run";
     }
@@ -672,10 +722,46 @@ function windowsActionArgumentProblem(actionArguments, expectedFlags, expectedLa
     }
     return null;
 }
-function unquoteWindowsArgument(value) {
-    const trimmed = value.trim();
-    const quoted = trimmed.match(/^"([\s\S]*)"$/u) ?? trimmed.match(/^'([\s\S]*)'$/u);
-    return (quoted?.[1] ?? trimmed).trim();
+/**
+ * Quote-aware whitespace tokenizer for an already-XML-decoded `<Arguments>`
+ * value: a `"..."` run is one token (quotes stripped, whitespace inside kept),
+ * everything else splits on whitespace. Windows paths never contain a quote
+ * character, so this does not need CommandLineToArgvW's backslash-escaping
+ * rules — only its quoting rule — to tell "one argument with a space in it"
+ * apart from "two arguments".
+ */
+function splitWindowsArgumentTokens(value) {
+    const tokens = [];
+    let current = "";
+    let inQuotes = false;
+    let hasToken = false;
+    for (const char of value) {
+        if (char === '"') {
+            inQuotes = !inQuotes;
+            hasToken = true;
+            continue;
+        }
+        if (!inQuotes && /\s/u.test(char)) {
+            if (hasToken) {
+                tokens.push(current);
+                current = "";
+                hasToken = false;
+            }
+            continue;
+        }
+        current += char;
+        hasToken = true;
+    }
+    if (hasToken)
+        tokens.push(current);
+    return tokens;
+}
+/** Removes one wrapping pair of double quotes, if present. Used only to
+ * normalize before a path comparison — never to reconstruct a shell-safe
+ * value. */
+function stripSurroundingQuotes(value) {
+    const match = value.match(/^"([\s\S]*)"$/u);
+    return match ? match[1] : value;
 }
 function sameWindowsPath(left, right) {
     if (!left || !right)

package/dist/commands/public-root.js

@@ -15,7 +15,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.26");
+    writeLine(io?.stdout ?? process.stdout, "0.2.27");
     return 0;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.26",
+  "version": "0.2.27",
   "private": false,
   "type": "module",
   "bin": {