@bli-cockpit/cli 0.2.67 → 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/cal.js

@@ -0,0 +1,364 @@
+/**
+ * `cockpit cal` — the calendars a person attached, from a terminal
+ * (BLI-3709).
+ *
+ * Ten verbs over `/api/cal/**`, the same doors the browser will use when the
+ * UI lands. Every one of those routes already accepts the collector device
+ * token (`resolveCaller({ allowDeviceToken: true })`), so this command is a
+ * terminal in front of an existing door and adds no authority of its own.
+ *
+ * The CLI is the FIRST surface for this wave, deliberately (AGENTS.md, "CLI is
+ * king"): "when is standup" is a question with a one-line answer, and every
+ * bug fixed here is fixed for the browser and MCP halves that share the doors.
+ *
+ * TWO RULES WORTH KNOWING BEFORE READING THE CODE:
+ *
+ * - **The secret address never touches argv.** `add-ical` reads it from STDIN
+ *   and there is no flag that would take it (`local-args-tower-cal.ts` says
+ *   why in full). It is the one credential this surface handles.
+ * - **The zone is always sent.** Every read passes `--tz`, or this machine's
+ *   own zone from `Intl`, because a window computed server-side would be
+ *   computed in UTC and "today" would end at 5pm in Vancouver.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
+import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
+const TAG = "[cal cli]";
+const READ_DEADLINE_MS = 30_000;
+const WRITE_DEADLINE_MS = 60_000;
+/** A first read of a crowded calendar can take a while. */
+const SYNC_DEADLINE_MS = 120_000;
+const URL_MAX_CHARS = 2_000;
+export async function runCal(command, io) {
+    const door = await openAgentDoor("cal", command, io);
+    switch (command.action) {
+        case "today":
+        case "week":
+        case "next":
+            return window(command, door);
+        case "find":
+            return find(command, door);
+        case "calendars":
+            return listCalendars(door);
+        case "add-ical":
+            return addIcal(command, door);
+        case "create":
+            return create(command, door);
+        case "share":
+            return share(command, door);
+        case "detach":
+            return detach(command, door);
+        case "sync":
+            return sync(command, door);
+    }
+}
+/**
+ * This machine's own zone, which is what a person means by "today" unless they
+ * say otherwise. `Intl` knows it; there is nothing to configure and nothing to
+ * get out of step with the operating system.
+ */
+export function localTimeZone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+    }
+    catch {
+        return "UTC";
+    }
+}
+function windowQuery(command) {
+    const query = new URLSearchParams({ tz: command.timeZone ?? localTimeZone() });
+    if (command.calendarId)
+        query.set("calendar_id", command.calendarId);
+    if (command.limit !== undefined)
+        query.set("limit", String(command.limit));
+    if (command.includeDeselected)
+        query.set("all", "1");
+    if (command.offset !== undefined)
+        query.set("offset", String(command.offset));
+    if (command.hours !== undefined)
+        query.set("hours", String(command.hours));
+    if (command.from)
+        query.set("from", command.from);
+    if (command.to)
+        query.set("to", command.to);
+    return query;
+}
+async function window(command, door) {
+    // `--from`/`--to` beat a named window, on any of the three verbs: somebody
+    // who named two dates meant them.
+    const path = command.from && command.to ? "events" : command.action;
+    const answer = await askAgentDoor(door, {
+        path: `/api/cal/${path}?${windowQuery(command).toString()}`,
+        method: "GET",
+        label: `cal ${command.action}`,
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const body = answer.body;
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, ...body });
+    const zone = body.window?.time_zone ?? localTimeZone();
+    const events = body.events ?? [];
+    if (events.length === 0) {
+        writeLine(door.io.stdout, (body.calendars ?? []).length === 0
+            ? "No calendars attached yet. `cockpit cal add-ical` for a personal one, or connect Google in the browser."
+            : `Nothing on ${describeWindow(body, zone)}.`);
+        return 0;
+    }
+    writeLine(door.io.stdout, describeWindow(body, zone));
+    writeLine(door.io.stdout, "");
+    let day = "";
+    for (const event of events) {
+        const eventDay = dayLabel(event.starts_at, zone);
+        if (eventDay !== day) {
+            if (day !== "")
+                writeLine(door.io.stdout, "");
+            writeLine(door.io.stdout, eventDay);
+            day = eventDay;
+        }
+        writeLine(door.io.stdout, eventLine(event, zone));
+    }
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, `${events.length} event(s) across ${(body.calendars ?? []).length} calendar(s)${body.truncated ? " — more than fitted in one page" : ""}.`);
+    // Never silent about a series this Tower could not expand.
+    for (const note of body.notes ?? []) {
+        writeLine(door.io.stdout, `Note: "${note.title}" repeats on a rule Tower does not expand (${note.detail.join(", ")}), so only its first occurrence is shown.`);
+    }
+    return 0;
+}
+function describeWindow(body, zone) {
+    if (!body.window)
+        return "That window";
+    const from = dayLabel(body.window.from, zone);
+    const to = dayLabel(new Date(new Date(body.window.to).getTime() - 1).toISOString(), zone);
+    if (body.window.label === "next")
+        return `Next, from now (${zone})`;
+    return from === to ? `${from} (${zone})` : `${from} to ${to} (${zone})`;
+}
+function eventLine(event, zone) {
+    const when = event.all_day ? "all day" : `${clock(event.starts_at, zone)}–${clock(event.ends_at, zone)}`;
+    const marks = `${event.recurring ? "↻" : " "}${event.status === "tentative" ? "?" : " "}`;
+    const where = event.location ? `  @ ${event.location.slice(0, 40)}` : "";
+    const who = event.attendee_count > 0 ? `  (${event.attendee_count})` : "";
+    return `${marks} ${when.padEnd(13)}  ${event.title.slice(0, 52).padEnd(52)}${where}${who}`;
+}
+/** `Mon 7 Sep`, in the reader's zone. */
+function dayLabel(instant, zone) {
+    try {
+        return new Intl.DateTimeFormat("en-GB", {
+            timeZone: zone,
+            weekday: "short",
+            day: "numeric",
+            month: "short",
+        }).format(new Date(instant));
+    }
+    catch {
+        return instant.slice(0, 10);
+    }
+}
+function clock(instant, zone) {
+    try {
+        return new Intl.DateTimeFormat("en-GB", {
+            timeZone: zone,
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false,
+        }).format(new Date(instant));
+    }
+    catch {
+        return instant.slice(11, 16);
+    }
+}
+async function find(command, door) {
+    const query = new URLSearchParams({ q: command.query ?? "" });
+    if (command.calendarId)
+        query.set("calendar_id", command.calendarId);
+    if (command.limit !== undefined)
+        query.set("limit", String(command.limit));
+    const answer = await askAgentDoor(door, {
+        path: `/api/cal/find?${query.toString()}`,
+        method: "GET",
+        label: "cal find",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const matches = answer.body.matches ?? [];
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, query: command.query, matches });
+    if (matches.length === 0) {
+        writeLine(door.io.stdout, `Nothing in your calendars matched "${command.query}".`);
+        return 0;
+    }
+    const zone = command.timeZone ?? localTimeZone();
+    for (const match of matches) {
+        const when = match.next_occurrence
+            ? `${dayLabel(match.next_occurrence, zone)} ${clock(match.next_occurrence, zone)}`
+            : `last on ${dayLabel(match.starts_at, zone)}`;
+        writeLine(door.io.stdout, `${match.recurring ? "↻" : " "} ${when.padEnd(20)}  ${match.title.slice(0, 50).padEnd(50)}  ${match.calendar_name}`);
+    }
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, `${matches.length} match(es). Times are ${zone}.`);
+    return 0;
+}
+async function listCalendars(door) {
+    const answer = await askAgentDoor(door, {
+        path: "/api/cal/calendars",
+        method: "GET",
+        label: "cal calendars",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const calendars = answer.body.calendars ?? [];
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, calendars });
+    if (calendars.length === 0) {
+        writeLine(door.io.stdout, "No calendars attached yet.");
+        writeLine(door.io.stdout, "");
+        writeLine(door.io.stdout, "A personal calendar:  printf \"%s\" \"<secret iCal address>\" | cockpit cal add-ical");
+        writeLine(door.io.stdout, "A work calendar:      connect Google in the browser, then `cockpit cal calendars` again.");
+        return 0;
+    }
+    for (const calendar of calendars) {
+        const health = calendar.status === "active"
+            ? (calendar.last_sync_at ? `synced ${calendar.last_sync_at.slice(0, 16).replace("T", " ")}` : "never synced")
+            : `${calendar.status}: ${calendar.status_reason ?? "no reason recorded"}`;
+        const flags = `${calendar.org_visible ? "shared" : "private"}${calendar.selected ? "" : ", hidden"}`;
+        writeLine(door.io.stdout, `${calendar.name.slice(0, 32).padEnd(32)}  ${calendar.provider.padEnd(12)}  ${flags.padEnd(16)}  ${health}`);
+    }
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, `${calendars.length} calendar(s). ids: ${calendars.map((calendar) => calendar.id).join(", ")}`);
+    return 0;
+}
+async function addIcal(command, door) {
+    // The address comes from stdin and nowhere else. An interactive terminal
+    // with nothing piped in is told how, rather than left waiting on a prompt
+    // that would echo a permanent credential into the scrollback.
+    if (isInteractiveStdin(door.io)) {
+        return failAgentDoor(door, TAG, "address_required_on_stdin", 'The calendar\'s secret address is read from stdin, never from a flag. Try: printf "%s" "https://calendar.google.com/calendar/ical/…/basic.ics" | cockpit cal add-ical --name "Personal"');
+    }
+    let icalUrl;
+    try {
+        icalUrl = (await readPipedText(door.io.stdin, {
+            maxChars: URL_MAX_CHARS,
+            overflowMessage: "That is longer than any calendar address; nothing was attached.",
+        })).trim();
+    }
+    catch (error) {
+        return failAgentDoor(door, TAG, "address_unreadable", error instanceof Error ? error.message : String(error));
+    }
+    if (icalUrl === "") {
+        return failAgentDoor(door, TAG, "address_required_on_stdin", "Nothing arrived on stdin, so nothing was attached.");
+    }
+    const answer = await askAgentDoor(door, {
+        path: "/api/cal/calendars",
+        method: "POST",
+        label: "cal add-ical",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: {
+            ical_url: icalUrl,
+            name: command.name ?? null,
+            ...(command.orgVisible ? { org_visible: true } : {}),
+        },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const calendar = answer.body.calendar;
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, calendar });
+    writeLine(door.io.stdout, `Attached (${calendar?.id ?? "no id returned"}).`);
+    writeLine(door.io.stdout, `Nothing is read until a sync runs: \`cockpit cal sync ${calendar?.id ?? "<id>"}\`, or wait for the cron.`);
+    return 0;
+}
+async function create(command, door) {
+    const answer = await askAgentDoor(door, {
+        path: "/api/cal/events",
+        method: "POST",
+        label: "cal create",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: {
+            calendar_id: command.calendarId,
+            title: command.title,
+            starts_at: command.startsAt,
+            ends_at: command.endsAt,
+            ...(command.location ? { location: command.location } : {}),
+            ...(command.allDay ? { all_day: true } : {}),
+            ...(command.attendees.length > 0 ? { attendees: command.attendees } : {}),
+            time_zone: command.timeZone ?? localTimeZone(),
+        },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const event = answer.body.event;
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, event });
+    const zone = command.timeZone ?? localTimeZone();
+    writeLine(door.io.stdout, `Created "${event?.title ?? command.title}" on ${event ? `${dayLabel(event.starts_at, zone)} ${clock(event.starts_at, zone)}` : "that calendar"}.`);
+    if (event?.html_link)
+        writeLine(door.io.stdout, event.html_link);
+    if (command.attendees.length > 0) {
+        writeLine(door.io.stdout, `Invitations went to ${command.attendees.join(", ")} from Google.`);
+    }
+    return 0;
+}
+async function share(command, door) {
+    const orgVisible = command.orgVisible && !command.makePrivate;
+    const answer = await askAgentDoor(door, {
+        path: `/api/cal/calendars?calendar_id=${encodeURIComponent(command.subjectId ?? "")}`,
+        method: "PATCH",
+        label: "cal share",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: { org_visible: orgVisible },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const calendar = answer.body.calendar;
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, calendar });
+    writeLine(door.io.stdout, orgVisible
+        ? `"${calendar?.name ?? command.subjectId}" is now readable by everyone at BLI. Nobody but you can change it.`
+        : `"${calendar?.name ?? command.subjectId}" is private again — only you can read it.`);
+    return 0;
+}
+async function detach(command, door) {
+    const answer = await askAgentDoor(door, {
+        path: `/api/cal/calendars?calendar_id=${encodeURIComponent(command.subjectId ?? "")}`,
+        method: "DELETE",
+        label: "cal detach",
+        timeoutMs: WRITE_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, detached: command.subjectId });
+    writeLine(door.io.stdout, `Detached ${command.subjectId}. Its stored events went with it; the calendar itself is untouched at Google.`);
+    return 0;
+}
+async function sync(command, door) {
+    const answer = await askAgentDoor(door, {
+        path: `/api/cal/calendars/${encodeURIComponent(command.subjectId ?? "")}/sync${command.full ? "?full=1" : ""}`,
+        method: "POST",
+        label: "cal sync",
+        timeoutMs: SYNC_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const run = answer.body.run;
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, run });
+    if (!run) {
+        writeLine(door.io.stdout, "Tower answered without a run. Nothing to report.");
+        return 0;
+    }
+    if (run.reason === "ok") {
+        writeLine(door.io.stdout, run.detail === "feed_unchanged"
+            ? "Nothing has changed on that calendar since the last read."
+            : `Synced: ${run.eventsAdded} new, ${run.eventsUpdated} updated, ${run.eventsDeleted} gone.`);
+        return 0;
+    }
+    // A failure names itself; the exit code says it failed.
+    writeLine(door.io.stderr, `${TAG} sync ${JSON.stringify({ reason: run.reason, detail: run.detail })}`);
+    writeLine(door.io.stdout, `That calendar did not sync: ${run.reason}${run.detail ? ` (${run.detail})` : ""}.`);
+    return 1;
+}

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,
     });