@bli-cockpit/cli 0.2.68 → 0.2.69

package/dist/autostart-darwin-plist.js

@@ -81,8 +81,22 @@ export async function writeDarwinAutostartPlist(options) {
  */
 export async function darwinAgentProblems(options, settings) {
     const homeDir = options.homeDir ?? os.homedir();
-    const nodeExecutable = (await schedulerNodeExecutable(options, "darwin")).path;
     const plist = await readFile(plistPathFor(homeDir), "utf8").catch(() => "");
+    if (!plist)
+        return ["plist could not be read"];
+    // A caller that named no roots gave us nothing to compare against:
+    // `resolveAutostartSettings` fills `work_dirs` from `process.cwd()`, so the
+    // comparison below would reject a perfectly good plist for naming a
+    // workspace nobody asked us to expect (BLI-3793 — that is how the setup
+    // receipt printed `autostart_not_loaded` beside a green doctor row). The
+    // Windows arm has refused this comparison since it was written
+    // (`syncScriptProblem`); macOS refuses it now too. Whether launchd HAS the
+    // agent is still answered — by `launchctl list`, in the sibling module.
+    if (!options.repoRoots || options.repoRoots.length === 0) {
+        console.error("[autostart] registration not compared against expectations", JSON.stringify({ reason: "no_roots_supplied", label: AUTOSTART_LABEL }));
+        return [];
+    }
+    const nodeExecutable = (await schedulerNodeExecutable(options, "darwin")).path;
     return darwinAgentRegistrationProblems(plist, {
         discoveryArgs: await savedDiscoveryLimitArgs(homeDir),
         workDirs: settings.work_dirs,

package/dist/commands/autostart-reading.js

@@ -0,0 +1,173 @@
+import { autostartStatus, registeredRuntimePathProblems, } from "../autostart.js";
+import { redactedHealthDetail } from "../health-detail.js";
+import { getCollectorRuntimePaths, readLocalCollectorConfig, } from "../local-state.js";
+import { normalizeCollectionRoots } from "../root-normalization.js";
+/**
+ * "Is background collection actually registered and running on this host?" —
+ * asked ONCE, here (BLI-3793).
+ *
+ * Two surfaces print that answer: doctor's `autostart-alive` row and the setup
+ * receipt's `collector autostart` word. Until this module they asked the same
+ * function DIFFERENTLY, and so printed opposite answers in one run:
+ *
+ *   ✅ autostart-alive      background sync is running
+ *   collector autostart ✗ (autostart_not_loaded) — Run `cockpit autostart install`.
+ *
+ * The doctor row handed `autostartStatus` the machine's saved collection
+ * roots; the receipt handed it `{homeDir, exec}` and nothing else. With no
+ * roots, `resolveAutostartSettings` fills `work_dirs` from `process.cwd()`,
+ * the launchd read-back compares the plist against a registration nobody ever
+ * asked for, the comparison fails, and a perfectly loaded agent reads
+ * `not_loaded`. The receipt therefore said "✓" only when the operator happened
+ * to be standing in their own collection root. Proven on the reference Mac:
+ * the same plist read `loaded` with roots passed and `not_loaded` without,
+ * flipping back to `loaded` when the process chdir'd into the saved root.
+ *
+ * So: one reader, one state, ONE reason label. `autostartDoctorRow` and
+ * `autostartSetupPiece` below only choose words for a state this file already
+ * decided — they never re-ask the host. Both host families go through the same
+ * `autostartStatus` front door, so the Windows probe keeps its own
+ * implementation behind this same contract.
+ */
+const TAG = "[autostart reading]";
+/**
+ * The machine's approved collection roots as the SCHEDULER should have them:
+ * an explicit `--workspace` when one was given, otherwise what the config on
+ * this host saved. Honours `homeDir` so a `--home` run reads the same machine
+ * its receipt reads.
+ */
+export async function autostartRegistrationRoots(homeDir, repoRoot) {
+    if (repoRoot)
+        return [repoRoot];
+    const config = await readLocalCollectorConfig(getCollectorRuntimePaths(homeDir)).catch(() => null);
+    return normalizeCollectionRoots(config?.default_repo_paths ?? []);
+}
+/** The ONE read of the host's scheduler. Never throws; an unaskable host is
+ * `unreadable` with a reason, never "absent" (BLI-2541: never report a state
+ * you did not observe). */
+export async function readAutostartRegistration(options) {
+    const exec = options.exec;
+    if (!exec) {
+        return {
+            state: "unreadable",
+            reason: "autostart_runner_unavailable",
+            message: "the operating-system scheduler could not be asked: no process runner on this run",
+            roots: [],
+        };
+    }
+    const roots = await autostartRegistrationRoots(options.homeDir, options.repoRoot).catch(() => []);
+    const result = await autostartStatus({
+        exec,
+        repoRoots: roots,
+        ...(roots[0] ? { repoRoot: roots[0] } : {}),
+        ...(options.homeDir ? { homeDir: options.homeDir } : {}),
+        ...(options.dashboardUrl ? { dashboardUrl: options.dashboardUrl } : {}),
+        ...(options.platform ? { platform: options.platform } : {}),
+    }).catch((error) => {
+        console.error(`${TAG} scheduler probe threw`, JSON.stringify({
+            reason: "autostart_probe_failed",
+            error_name: error instanceof Error ? error.name : typeof error,
+        }));
+        return null;
+    });
+    const reading = await stateFor(result, roots, options);
+    console.error(`${TAG} read back`, JSON.stringify({
+        reason: reading.reason,
+        state: reading.state,
+        root_count: reading.roots.length,
+        platform: options.platform ?? process.platform,
+    }));
+    return reading;
+}
+async function stateFor(result, roots, options) {
+    if (!result) {
+        return {
+            state: "unreadable",
+            reason: "autostart_probe_failed",
+            message: "the operating-system scheduler could not be read this run",
+            roots,
+        };
+    }
+    const detail = result.message
+        ? { detail: redactedHealthDetail(result.message) }
+        : {};
+    if (result.status === "unsupported") {
+        return {
+            state: "unsupported",
+            reason: "platform_unsupported",
+            message: result.message ?? "autostart is not supported on this host",
+            roots,
+        };
+    }
+    if (result.status === "absent" || result.status === "uninstalled") {
+        return {
+            state: "absent",
+            reason: "autostart_absent",
+            message: "background sync is not installed on this machine",
+            roots,
+            ...detail,
+        };
+    }
+    if (result.status === "not_loaded") {
+        return {
+            state: "not_loaded",
+            reason: "autostart_not_loaded",
+            message: "background sync is not running",
+            roots,
+            ...detail,
+        };
+    }
+    // BLI-3553: "loaded" only means the scheduler accepted the registration. It
+    // says nothing about whether the binary that registration names still exists
+    // — and `brew upgrade node` deletes exactly that. Ask the filesystem about
+    // the paths the PLATFORM holds, not the ones this process runs under.
+    const missing = options.exec
+        ? await registeredRuntimePathProblems({
+            exec: options.exec,
+            ...(options.homeDir ? { homeDir: options.homeDir } : {}),
+            ...(options.platform ? { platform: options.platform } : {}),
+        }).catch(() => [])
+        : [];
+    if (missing.length > 0) {
+        return {
+            state: "runtime_path_missing",
+            reason: "autostart_runtime_path_missing",
+            message: `background sync is registered but cannot run: ${missing.join("; ")}`,
+            roots,
+        };
+    }
+    return {
+        state: "loaded",
+        reason: "autostart_loaded",
+        message: "background sync is running",
+        roots,
+    };
+}
+/**
+ * The setup receipt's `collector autostart` word (BLI-3731).
+ *
+ * `ok` only when the host says it is registered AND loaded AND the runtime it
+ * names still exists. A plist nobody loaded runs nothing, which is exactly the
+ * failure that looks fine from the outside.
+ */
+export function autostartSetupPiece(reading) {
+    switch (reading.state) {
+        case "loaded":
+            return { status: "ok", reason: reading.reason };
+        case "unsupported":
+            return { status: "skipped", reason: reading.reason };
+        case "unreadable":
+            return { status: "unknown", reason: reading.reason };
+        default:
+            return { status: "missing", reason: reading.reason };
+    }
+}
+/** Doctor's `autostart-alive` row status for the same reading. The `code` a
+ * caller pairs with this is `reading.reason` — there is no second vocabulary. */
+export function autostartDoctorStatus(reading) {
+    if (reading.state === "loaded")
+        return "ok";
+    if (reading.state === "unsupported")
+        return "skipped";
+    return "needs_fix";
+}

package/dist/commands/doctor-registration.js

@@ -1,6 +1,6 @@
-import { autostartStatus, installAutostartAgent, registeredRuntimePathProblems, } from "../autostart.js";
+import { installAutostartAgent } from "../autostart.js";
 import { fail, needsFix, ok, skipped } from "./doctor-report.js";
-import { doctorRoots, savedRoots } from "./doctor-access.js";
+import { autostartDoctorStatus, autostartRegistrationRoots, readAutostartRegistration, } from "./autostart-reading.js";
 import { installMemoryIntegration, inspectMemoryIntegration, } from "./memory-install.js";
 /**
  * The `autostart-alive` and `memory-registered` check family: registrations
@@ -8,44 +8,40 @@ import { installMemoryIntegration, inspectMemoryIntegration, } from "./memory-in
  * background sync scheduler and BLI Memory's MCP/hook wiring. Both fixes
  * write host configuration only; neither installs software.
  */
+/**
+ * The row and the setup receipt's `collector autostart` word are the SAME
+ * reading now (BLI-3793) — `autostart-reading.ts` asks the host once and hands
+ * back one state and one reason label. This function only chooses the row
+ * status for it; it does not decide anything about the machine.
+ */
 export async function checkAutostartState(context) {
-    const exec = context.io.exec;
-    if (!exec) {
-        return needsFix("autostart-alive", "runner_unavailable", "autostart runner unavailable; would refresh autostart");
-    }
-    const roots = await doctorRoots(context);
-    const result = await autostartStatus({
-        repoRoot: roots[0],
-        repoRoots: roots,
+    const reading = await readAutostartRegistration({
+        exec: context.io.exec,
+        homeDir: context.command.homeDir,
         dashboardUrl: context.command.dashboardUrl,
-        exec,
+        repoRoot: context.command.repoRoot,
     });
-    if (result.status === "loaded") {
-        // BLI-3553: "loaded" only means the scheduler accepted the registration.
-        // It says nothing about whether the binary that registration names still
-        // exists — and `brew upgrade node` deletes exactly that. Ask the
-        // filesystem about the paths the PLATFORM holds, not the ones this process
-        // happens to be running under.
-        const missing = await registeredRuntimePathProblems({ exec });
-        if (missing.length > 0) {
-            return needsFix("autostart-alive", "runtime_path_missing", `background sync is registered but cannot run: ${missing.join("; ")}`);
-        }
-        return ok("autostart-alive", "already_installed", "background sync is running");
-    }
-    if (result.status === "unsupported") {
-        return skipped("autostart-alive", "unsupported", result.message ?? "unsupported");
+    const status = autostartDoctorStatus(reading);
+    if (status === "ok")
+        return ok("autostart-alive", reading.reason, reading.message);
+    if (status === "skipped") {
+        return skipped("autostart-alive", reading.reason, reading.message);
     }
-    return needsFix("autostart-alive", result.status === "not_loaded" ? "not_loaded" : "absent", "background sync is not running");
+    return needsFix("autostart-alive", reading.reason, reading.message);
 }
 export async function fixAutostartState(context) {
     const exec = context.io.exec;
     if (!exec) {
         return fail("autostart-alive", "runner_unavailable", "autostart runner unavailable");
     }
-    const roots = await savedRoots();
+    // The same roots the CHECK read against, resolved by the same function — a
+    // fix that registers a different boundary than the check inspected would
+    // leave the row red forever (BLI-3793).
+    const roots = await autostartRegistrationRoots(context.command.homeDir, context.command.repoRoot);
     const result = await installAutostartAgent({
-        repoRoot: context.command.repoRoot ?? roots[0],
-        repoRoots: context.command.repoRoot ? [context.command.repoRoot] : roots,
+        ...(roots[0] ? { repoRoot: roots[0] } : {}),
+        repoRoots: roots,
+        ...(context.command.homeDir ? { homeDir: context.command.homeDir } : {}),
         dashboardUrl: context.command.dashboardUrl,
         exec,
     });

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

package/dist/commands/setup-receipt.js

@@ -15,8 +15,13 @@
  *                        in, so the session file is the evidence — there is no
  *                        second thing to ask.
  *   device               that same session, still unexpired.
- *   collector.autostart  `autostartStatus`, which asks launchd or Task
- *                        Scheduler what it actually has registered.
+ *   collector.autostart  `readAutostartRegistration`, which asks launchd or
+ *                        Task Scheduler what it actually has registered. That
+ *                        reader is SHARED with doctor's `autostart-alive` row
+ *                        (BLI-3793) — this module used to ask the scheduler
+ *                        itself, without the machine's saved roots, and so
+ *                        printed `autostart_not_loaded` under a doctor row
+ *                        that said the same agent was running.
  *
  * The five AGENT-HOST words in the printed block are NOT computed here. They
  * are BLI-3729's `MemoryInstallReceipt`, already read back off
@@ -36,7 +41,7 @@
 import os from "node:os";
 import { SETUP_RECEIPT_SCHEMA_VERSION, setupReceiptGaps, setupReceiptLine, } from "@bli-cockpit/telemetry-core";
 import { readHeartbeatMemoryReceipt } from "./heartbeat.js";
-import { autostartStatus } from "../autostart.js";
+import { autostartSetupPiece, readAutostartRegistration, } from "./autostart-reading.js";
 import { readLocalSessionReference } from "../local-state.js";
 import { getCollectorRuntimePaths } from "../local-state-paths.js";
 import { readJsonFile, writeJsonFile } from "../local-state-files.js";
@@ -63,14 +68,19 @@ export async function buildSetupReceipt(io, options = {}) {
     });
     const autostart = await probes.autostart().catch((error) => {
         console.error(`${TAG} scheduler could not be read`, JSON.stringify({ reason: "autostart_probe_failed", error_name: errorName(error) }));
-        return { status: "unreadable" };
+        return {
+            state: "unreadable",
+            reason: "autostart_probe_failed",
+            message: "the operating-system scheduler could not be read this run",
+            roots: [],
+        };
     });
     const receipt = {
         schema_version: SETUP_RECEIPT_SCHEMA_VERSION,
         checked_at: checkedAt,
         browser: browserPiece(session),
         device: devicePiece(session),
-        collector: { autostart: autostartPiece(autostart) },
+        collector: { autostart: autostartSetupPiece(autostart) },
     };
     const gaps = setupReceiptGaps(receipt, memory);
     console.error(`${TAG} read back`, JSON.stringify({
@@ -97,19 +107,16 @@ function withDefaultProbes(io, homeDir, options) {
                 };
             }),
         autostart: options.probes?.autostart ??
-            (async () => {
-                // The scheduler can only be READ through a process runner; a machine
-                // whose io carries none is unknown, never "absent" (BLI-2541: never
-                // report a state you did not observe).
-                const exec = io.exec;
-                if (!exec)
-                    return { status: "unreadable", message: "runner_unavailable" };
-                const result = await autostartStatus({ homeDir, exec });
-                return {
-                    status: result.status,
-                    ...(result.message ? { message: result.message } : {}),
-                };
-            }),
+            // The one shared reader. It handles the no-process-runner host itself
+            // (`unreadable`, never "absent" — BLI-2541: never report a state you did
+            // not observe) and it hands the scheduler this machine's saved roots,
+            // which is what stopped this word from contradicting doctor's row
+            // (BLI-3793).
+            (async () => readAutostartRegistration({
+                exec: io.exec,
+                homeDir,
+                ...(options.dashboardUrl ? { dashboardUrl: options.dashboardUrl } : {}),
+            })),
     };
 }
 /**
@@ -139,32 +146,6 @@ function devicePiece(session) {
     }
     return { status: "missing", reason: `session_${session.state}` };
 }
-/**
- * The scheduler is `ok` only when the host says it is registered AND loaded.
- * `installed` on macOS means the plist is on disk; `loaded` means launchd has
- * it. A plist nobody loaded runs nothing, which is exactly the failure that
- * looks fine from the outside.
- */
-function autostartPiece(result) {
-    if (result.status === "loaded" || result.status === "installed") {
-        return { status: "ok", reason: `autostart_${result.status}` };
-    }
-    if (result.status === "not_loaded") {
-        return { status: "missing", reason: "autostart_not_loaded" };
-    }
-    if (result.status === "absent" || result.status === "uninstalled") {
-        return { status: "missing", reason: "autostart_absent" };
-    }
-    if (result.status === "unsupported") {
-        return { status: "skipped", reason: "platform_unsupported" };
-    }
-    return { status: "unknown", reason: normalizeReason(result.status) };
-}
-/** Reason labels are `[a-z0-9_:.-]` by schema; anything else becomes one word. */
-function normalizeReason(value) {
-    const cleaned = value.trim().toLowerCase().replace(/[^a-z0-9_:.-]+/gu, "_");
-    return cleaned.slice(0, 120) || "unlabelled";
-}
 function errorName(error) {
     return error instanceof Error ? error.name : typeof error;
 }

package/package.json

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