@bli-cockpit/cli 0.2.23 → 0.2.25

package/dist/autostart-self-heal.js

@@ -0,0 +1,55 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { autostartStatus, installAutostartAgent, } from "./autostart.js";
+export const AUTOSTART_REPAIR_THROTTLE_MARKER = ".last-autostart-repair";
+const AUTOSTART_REPAIR_MIN_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const DETAIL_MAX_CHARS = 300;
+export async function runAutostartSelfHeal(paths, options) {
+    const platform = options.platform ?? process.platform;
+    if (platform !== "win32")
+        return null;
+    if (options.repoRoots.length === 0)
+        return null;
+    const status = await autostartStatus({
+        homeDir: options.homeDir,
+        repoRoot: options.repoRoots[0],
+        repoRoots: options.repoRoots,
+        dashboardUrl: options.dashboardUrl,
+        exec: options.exec,
+        platform,
+    });
+    // Healthy is the steady state and stays silent; absent means the operator
+    // (or onboarding) owns the decision, not this tick.
+    if (status.status !== "not_loaded")
+        return null;
+    // Attempts are throttled like the self-update's (marker mtime, written for
+    // the attempt not the outcome) so a persistently failing repair cannot spawn
+    // a registration every 15 minutes. The status probe above still runs every
+    // tick — it is one schtasks query.
+    const now = options.now ?? new Date();
+    const marker = path.join(paths.state_dir, AUTOSTART_REPAIR_THROTTLE_MARKER);
+    const lastAttempt = await fs.stat(marker).catch(() => null);
+    if (lastAttempt &&
+        now.getTime() - lastAttempt.mtimeMs < AUTOSTART_REPAIR_MIN_INTERVAL_MS) {
+        return { status: "skipped", reason: "repair_throttled_recent_attempt" };
+    }
+    await fs.mkdir(paths.state_dir, { recursive: true }).catch(() => undefined);
+    await fs.writeFile(marker, now.toISOString()).catch(() => undefined);
+    const problem = (status.message ?? "task not loaded").slice(0, DETAIL_MAX_CHARS);
+    const repaired = await installAutostartAgent({
+        homeDir: options.homeDir,
+        repoRoot: options.repoRoots[0],
+        repoRoots: options.repoRoots,
+        dashboardUrl: options.dashboardUrl,
+        exec: options.exec,
+        platform,
+    });
+    if (repaired.loaded) {
+        return { status: "ok", reason: "autostart_repaired", detail: problem };
+    }
+    return {
+        status: "fail",
+        reason: "autostart_repair_failed",
+        detail: (repaired.message ?? problem).slice(0, DETAIL_MAX_CHARS),
+    };
+}

package/dist/commands/local.js

@@ -22,6 +22,7 @@ import { runAttributedWorktreeSync, matchesLiveSyncWorktree, } from "./session-s
 import { COLLECTION_ROOT_REQUIRED, missingCollectionRootMessage, normalizeRootsDetailed, resolveOnboardingRoots, rootRejectionExplanation, } from "../onboarding-roots.js";
 import { rawEvidenceGcSummary, runRawEvidenceLocalGc, } from "../raw-evidence-gc.js";
 import { envWithNodeRuntimeOnPath, runScheduledSelfUpdate, } from "../scheduled-self-update.js";
+import { runAutostartSelfHeal, } from "../autostart-self-heal.js";
 import { enqueueInstallEventEntry, readPendingInstallEventEntries, recordInstallEventAttemptFailure, removeInstallEventEntry, } from "../spool/install-event-outbox.js";
 import { createCapturedExecRunner, createInteractiveExecRunner, } from "../process-runner.js";
 import { normalizeCollectionRoots } from "../root-normalization.js";
@@ -2172,6 +2173,7 @@ async function runSync(command, io) {
         // BLI-2601: self-update runs only after collection's own outcome above is
         // already decided and reported, win or lose. See the function doc.
         await runScheduledSelfUpdateAfterSync(command, io, dashboardUrl, minCliVersion ?? minCliVersionAtStart);
+        await runAutostartSelfHealAfterSync(command, io, dashboardUrl);
         return result.exitCode;
     }
     catch (error) {
@@ -2191,9 +2193,59 @@ async function runSync(command, io) {
             io,
         });
         await runScheduledSelfUpdateAfterSync(command, io, dashboardUrl, minCliVersion ?? minCliVersionAtStart);
+        await runAutostartSelfHealAfterSync(command, io, dashboardUrl);
         throw error;
     }
 }
+/**
+ * BLI-2721: after the tick's collection and self-update are done and
+ * reported, repair a broken/legacy autostart registration in place (Windows
+ * only — see autostart-self-heal.ts for why macOS is excluded). Every error
+ * path is swallowed like the self-update's: heal outcomes are their own
+ * receipts, never a sync failure.
+ */
+async function runAutostartSelfHealAfterSync(command, io, dashboardUrl) {
+    let result;
+    try {
+        const rawExec = io.exec;
+        if (!rawExec)
+            return;
+        const spawnEnv = envWithNodeRuntimeOnPath(io.env ?? process.env);
+        const exec = (cmd, args, options) => rawExec(cmd, args, { ...options, env: options?.env ?? spawnEnv });
+        result = await runAutostartSelfHeal(getCollectorRuntimePaths(command.homeDir), {
+            homeDir: command.homeDir,
+            repoRoots: await resolveAutostartRoots(command.homeDir, undefined),
+            dashboardUrl: command.dashboardUrl,
+            exec,
+        });
+    }
+    catch (error) {
+        result = {
+            status: "fail",
+            reason: "autostart_self_heal_threw",
+            detail: redactedSyncErrorDetail(error),
+        };
+    }
+    // Steady state (healthy, absent, non-Windows, no roots) and the daily
+    // throttle are silent; an actual repair attempt reports either way.
+    if (!result || result.reason === "repair_throttled_recent_attempt")
+        return;
+    await reportInstallEventsBestEffort({
+        homeDir: command.homeDir,
+        dashboardUrl,
+        command: "sync",
+        events: [
+            {
+                step: "autostart_repair",
+                status: result.status,
+                ...(result.status === "ok" ? {} : { error_code: result.reason }),
+                ...(result.detail ? { error_detail: result.detail } : {}),
+            },
+        ],
+        json: command.json,
+        io,
+    });
+}
 /**
  * BLI-2601: the fleet keeps itself current on npm `latest` without anyone
  * re-running `npm i -g @bli-cockpit/cli` by hand after day 0. This always
@@ -2478,6 +2530,31 @@ async function runSyncLocked(command, io) {
             writeLine(io.stdout, rawEvidenceGcSummary(gc));
         return syncResult(run);
     }
+    // Zero worktrees is a legitimate steady state, not a failure: an approved
+    // root can hold no git repos, and sessions upload independently of
+    // worktrees (session-first, BLI-2581). This used to throw "Sync produced no
+    // result", which painted ~90 false-red sync_failed receipts per day on one
+    // fleet machine with a single empty root and taught people to ignore
+    // sync_failed (BLI-2722). A genuinely broken run still fails via run.ok.
+    if (run.outcomes.length === 0) {
+        const runStatus = attributedSyncRunStatus(run);
+        const gc = run.ok ? await runSyncRawEvidenceGc(command, io) : null;
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify({
+                mode: "no_worktrees",
+                status: runStatus,
+                collection_complete: run.ok,
+                codex_sessions: run.summary,
+                raw_evidence_gc: gc,
+            }, null, 2));
+            return syncResult(run);
+        }
+        writeLine(run.ok ? io.stdout : io.stderr, `Cockpit sync ${runStatus}: no git worktrees under this root; session scan ran.`);
+        writeAgentSessionSummary(io, run.summary);
+        if (gc && !gc.skipped)
+            writeLine(io.stdout, rawEvidenceGcSummary(gc));
+        return syncResult(run);
+    }
     const result = run.outcomes[0]?.sync;
     if (!result) {
         throw new Error("Sync produced no result for the repo worktree.");

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.23");
+    writeLine(io?.stdout ?? process.stdout, "0.2.25");
     return 0;
   }
 

package/package.json

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