@bli-cockpit/cli 0.2.180 → 0.2.183

package/dist/commands/public-root.js

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

package/dist/commands/setup.js

@@ -0,0 +1,39 @@
+import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+export async function runSetup(command, io) {
+    const door = await openAgentDoor("setup", command, io);
+    const query = new URLSearchParams();
+    if (command.person)
+        query.set("person", command.person);
+    if (command.compare)
+        query.set("compare", command.compare);
+    const answer = await askAgentDoor(door, { method: "GET", path: `/api/setup?${query}`, label: "setup", timeoutMs: 30_000 });
+    if (!answer.ok)
+        return failAgentDoor(door, "[setup]", answer.reason, answer.detail);
+    if (door.json)
+        return emitAgentDoor(door, answer.body);
+    const body = answer.body;
+    const number = (value) => value === null ? "unknown" : value.toLocaleString(undefined, { maximumFractionDigits: 1 });
+    for (const person of body.people ?? []) {
+        writeLine(io.stdout, `${person.rank ? `#${person.rank} ` : "Unranked · "}${person.display_name ?? person.email ?? "Unknown person"}: ${number(person.prs_per_week)} merged PRs/week · ${number(person.tokens_per_pr)} tokens/merged PR · ${person.yield === null ? "unknown yield" : `${number(person.yield * 100)}% session yield`}`);
+        if (!person.machines.length)
+            writeLine(io.stdout, "  No setup received.");
+        for (const machine of person.machines) {
+            if (!machine.setup) {
+                writeLine(io.stdout, "  Setup is unknown.");
+                continue;
+            }
+            writeLine(io.stdout, `  ${machine.setup.os} · TOWER CLI ${machine.setup.cli_version}${machine.stale ? " · stale setup" : ""}`);
+            for (const tool of ["claude", "codex"])
+                writeLine(io.stdout, `  ${tool}: ${machine.setup[tool].model ?? "unknown model"}, ${machine.setup[tool].effort ?? "unknown effort"}`);
+        }
+    }
+    for (const pair of body.comparison ?? []) {
+        writeLine(io.stdout, `${pair.first ?? "Unknown person"} / ${pair.second ?? "Unknown person"}`);
+        for (const difference of pair.differences)
+            writeLine(io.stdout, `  ${difference}`);
+    }
+    if (body.note)
+        writeLine(io.stdout, body.note);
+    return 0;
+}

package/dist/commands/sync-doctor-request.js

@@ -0,0 +1,13 @@
+/** Only a doctor request is accepted. Nothing from Tower is ever a command line. */
+let requestId = null;
+export function noteDoctorRequest(value) {
+    if (!value || typeof value !== "object")
+        return;
+    const request = value;
+    if (request.action === "doctor" && typeof request.request_id === "string" && /^[0-9a-f-]{36}$/u.test(request.request_id)) {
+        requestId = request.request_id;
+        console.error("[sync-doctor] request received", JSON.stringify({ reason: "doctor_requested", request_id: requestId }));
+    }
+}
+export function requestedDoctorId() { return requestId; }
+export function clearDoctorRequest() { requestId = null; }

package/dist/commands/sync-doctor.js

@@ -0,0 +1,145 @@
+/** Full, non-interactive doctor after collection, with a durable receipt retry. */
+import { shouldSuppressFleetReceipts } from "../dev-build.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Writable } from "node:stream";
+import { acquireBackfillLock } from "../backfill-lock.js";
+import { getCollectorRuntimePaths, readLocalCollectorSessionFile } from "../local-state.js";
+import { isAutostartOptedOut } from "../autostart-opt-out.js";
+import { runAutostartSelfHealAfterSync } from "./sync-followups-autostart.js";
+import { checkAutostartState } from "./doctor-registration.js";
+import { heartbeatRefusalStatus } from "./heartbeat-token.js";
+import { runDoctor } from "./doctor.js";
+import { doctorNeedsPerson, sanitizeEventCode } from "./doctor-report.js";
+import { runSelfUpdate } from "./install-update.js";
+import { reportInstallEventsBestEffort } from "./install-receipts.js";
+import { clearDoctorRequest, requestedDoctorId } from "./sync-doctor-request.js";
+export async function runDoctorAfterSync(command, io, dashboardUrl, overrides = {}, facts) {
+    if (shouldSuppressFleetReceipts({ dashboardUrl }).suppressed) {
+        console.error("[sync-doctor] checkout does not repair the fleet machine", JSON.stringify({ reason: "receipt_suppressed:dev_build" }));
+        return;
+    }
+    const paths = getCollectorRuntimePaths(command.homeDir);
+    // A separate namespace: holding this lock must not block doctor's backfill.
+    const lock = await acquireBackfillLock({ ...paths, cursors_dir: path.join(paths.state_dir, "doctor") }).catch(() => {
+        console.error("[sync-doctor] could not acquire its lock", JSON.stringify({ reason: "doctor_lock_failed" }));
+        return null;
+    });
+    if (!lock)
+        return;
+    if (!lock.acquired) {
+        console.error("[sync-doctor] another doctor is running", JSON.stringify({ reason: "doctor_running" }));
+        return;
+    }
+    const outbox = path.join(paths.state_dir, "doctor-receipt.json");
+    try {
+        const pending = await fs.readFile(outbox, "utf8").then((text) => JSON.parse(text)).catch((error) => {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        });
+        if (pending) {
+            if (!await postReceipt(pending, command, io, dashboardUrl))
+                return;
+            await fs.rm(outbox, { force: true });
+            if (pending.request_id === requestedDoctorId())
+                clearDoctorRequest();
+            // The completed requested run is never repeated just to resend its receipt.
+            if (pending.request_id)
+                return;
+        }
+        const requestId = requestedDoctorId();
+        const session = await readLocalCollectorSessionFile(paths).catch(() => null);
+        let receipt = null;
+        const quiet = new Writable({ write(_chunk, _encoding, done) { done(); } });
+        const doctorIo = { ...io, stdout: quiet };
+        await runDoctor({ kind: "doctor", alias: "doctor", automaticTick: true, homeDir: command.homeDir, dashboardUrl, json: true, dryRun: false }, doctorIo, {
+            selfUpdate: (updateIo, options) => runSelfUpdate({ ...updateIo, stdout: quiet }, options),
+            runLogin: async () => { throw new Error("automatic_doctor_cannot_prompt"); },
+            resolveAndSaveRoots: async () => { throw new Error("automatic_doctor_cannot_pick_folders"); },
+            reportInstallEvents: (options) => reportInstallEventsBestEffort({ ...options, homeDir: command.homeDir,
+                // Automatic receipts carry labels, never terminal instructions or paths.
+                events: options.events.map((event) => ({ step: event.step, status: event.status, ...(event.error_code ? { error_code: event.error_code } : {}) })),
+            }),
+            onReceipt: (rows, repairs, setup) => {
+                const actions = new Set();
+                for (const item of doctorNeedsPerson(rows, setup)) {
+                    if (item.step === "authed" && (!session?.device_token || [401, 403].includes(heartbeatRefusalStatus() ?? 0)))
+                        actions.add("browser_sign_in");
+                    if (item.step === "roots-ok")
+                        actions.add("folder_selection");
+                    if (item.step === "single-install")
+                        actions.add("duplicate_install");
+                    if (item.reason === "needs_trust" || item.action?.includes("/hooks"))
+                        actions.add("hook_trust");
+                    if (/permission|eacces|eperm|access_denied/u.test(item.reason))
+                        actions.add("os_permission");
+                }
+                receipt = {
+                    request_id: requestId, completed_at: new Date().toISOString(),
+                    status: rows.some((row) => row.status === "fail" || row.status === "needs_fix") || actions.size ? "attention" : "pass",
+                    repairs: repairs.map((repair) => ({ step: repair.step, before: safeVerdict(repair.before), after: safeVerdict(repair.after), fix_attempted: repair.fix_attempted ?? false })),
+                    person_actions: [...actions],
+                };
+            },
+        }, {
+            // The collection phase already ran. Never recurse through another sync.
+            checkSync: async () => ({ id: "sync-fresh", status: facts?.status === "fail" ? "needs_fix" : "skipped", code: facts?.status === "fail" ? "tick_collection_failed" : "tick_collection_reported", message: "This tick already reported its collection outcome; it retries on the next tick." }),
+            fixSync: async (context) => context.deps.checkSync(context),
+            checkAutostart: async (context) => await isAutostartOptedOut(paths)
+                ? { id: "autostart-alive", status: "skipped", code: "operator_uninstalled", message: "Background sync was deliberately turned off." }
+                : checkAutostartState(context),
+            fixAutostart: async (context) => {
+                // macOS uses the detached healer; Windows repairs in place. Neither
+                // overrides an explicit opt-out nor unloads this tick's macOS job.
+                await runAutostartSelfHealAfterSync(command, io, dashboardUrl);
+                return checkAutostartState(context);
+            },
+            ...overrides,
+        });
+        if (!receipt)
+            throw new Error("doctor_receipt_missing");
+        await fs.mkdir(paths.state_dir, { recursive: true, mode: 0o700 });
+        await fs.writeFile(`${outbox}.tmp`, JSON.stringify(receipt), { mode: 0o600 });
+        await fs.rename(`${outbox}.tmp`, outbox);
+        console.error("[sync-doctor] run complete", JSON.stringify({ reason: "receipt_saved", request_id: receipt.request_id, rows: receipt.repairs.length }));
+        if (await postReceipt(receipt, command, io, dashboardUrl)) {
+            await fs.rm(outbox, { force: true });
+            if (requestId === requestedDoctorId())
+                clearDoctorRequest();
+        }
+    }
+    catch (error) {
+        console.error("[sync-doctor] run will retry next tick", JSON.stringify({ reason: "doctor_followup_failed", error_name: error instanceof Error ? error.name : typeof error }));
+    }
+    finally {
+        await lock.handle.release();
+    }
+}
+function safeVerdict(value) {
+    const [status, code] = (value ?? "fail:receipt_missing").split(":");
+    return `${status}:${sanitizeEventCode(code ?? "receipt_missing")}`;
+}
+async function postReceipt(receipt, command, io, dashboardUrl) {
+    if (shouldSuppressFleetReceipts({ dashboardUrl }).suppressed) {
+        console.error("[sync-doctor] checkout receipt retained locally", JSON.stringify({ reason: "receipt_suppressed:dev_build" }));
+        return false;
+    }
+    const session = await readLocalCollectorSessionFile(getCollectorRuntimePaths(command.homeDir));
+    if (!session?.device_token || !session.device_id) {
+        console.error("[sync-doctor] receipt retained", JSON.stringify({ reason: "device_session_missing" }));
+        return false;
+    }
+    try {
+        const response = await io.fetch(`${dashboardUrl}/api/ambient/devices/${encodeURIComponent(session.device_id)}/doctor`, {
+            method: "PATCH", headers: { "Content-Type": "application/json", Authorization: `Bearer ${session.device_token}` },
+            body: JSON.stringify(receipt), signal: AbortSignal.timeout(5_000),
+        });
+        console.error("[sync-doctor] receipt delivery", JSON.stringify({ reason: response.ok ? "receipt_recorded" : "receipt_rejected", http_status: response.status, request_id: receipt.request_id }));
+        return response.ok;
+    }
+    catch {
+        console.error("[sync-doctor] receipt retained", JSON.stringify({ reason: "receipt_transport_failed", request_id: receipt.request_id }));
+        return false;
+    }
+}

package/dist/commands/sync.js

@@ -103,7 +103,7 @@ async function runSyncTick(command, io, tick) {
         // so it is what separates a quiet machine from a dead one.
         await tick.heartbeat(() => sendSyncHeartbeat(command, io, dashboardUrl, result.heartbeat));
         await tick.outcomeReport(() => reportTickOutcome(command, io, dashboardUrl, result.completion));
-        await tick.converge(() => convergeAfterTick(command, io, dashboardUrl));
+        await tick.converge(() => convergeAfterTick(command, io, dashboardUrl, result.heartbeat));
         // BLI-3619 / BLI-11106: every tick, the staged copies of whatever the
         // server just committed go; a follow-up never blocks or fails collection.
         await tick.prune(() => runStagingPruneAfterSync(command, io, dashboardUrl));
@@ -119,7 +119,7 @@ async function runSyncTick(command, io, tick) {
             reason: errorCode,
         }));
         await tick.outcomeReport(() => reportTickThrew(command, io, dashboardUrl, error, errorCode));
-        await tick.converge(() => convergeAfterTick(command, io, dashboardUrl));
+        await tick.converge(() => convergeAfterTick(command, io, dashboardUrl, { status: "fail", reason: errorCode }));
         await tick.prune(() => runStagingPruneAfterSync(command, io, dashboardUrl));
         throw error;
     }
@@ -186,11 +186,12 @@ async function reportTickThrew(command, io, dashboardUrl, error, errorCode) {
  * Memory's registration — each at most once a day, each with its own receipt,
  * and none of them able to block or fail collection (BLI-3580).
  */
-async function convergeAfterTick(command, io, dashboardUrl) {
+async function convergeAfterTick(command, io, dashboardUrl, facts) {
     await runAutostartSelfHealAfterSync(command, io, dashboardUrl);
     await runMemoryInstallAfterSync(command, io, dashboardUrl);
     // BLI-12828: the repairs `cockpit doctor` also makes (agent rules, a lapsed
     // sign-in), so nobody has to be told to run it.
     await runMachineHealAfterSync(command, io, dashboardUrl);
+    await io.runDoctorAfterSync?.(command, io, dashboardUrl, {}, facts);
     await runMemoryExperienceAfterSync({ ...command, dashboardUrl }, io);
 }

package/dist/commands/team.js

@@ -31,6 +31,8 @@ export async function runTeam(command, io) {
         return changeRole(command, tower, io);
     if (command.action === "device-list")
         return deviceList(command, tower, io);
+    if (command.action === "device-doctor")
+        return deviceDoctor(command, tower, io);
     return deviceRevoke(command, tower, io);
 }
 async function showMembers(command, tower, io) {
@@ -188,4 +190,21 @@ async function deviceRevoke(command, tower, io) {
     }
     writeLine(io.stdout, renderDeviceRevoked(body));
     return 0;
+}
+async function deviceDoctor(command, tower, io) {
+    const listed = await callTower(tower, { path: "/api/team/devices", label: "team device doctor lookup" });
+    if (!listed.ok)
+        return writeCommandFailure(io, command.json, listed);
+    const device = findDevice(devicesOf(asRecord(listed.body)), command.deviceRef ?? "");
+    if (!device)
+        return writeCommandFailure(io, command.json, { reason: "device_not_found", detail: "No unique device matches. Run cockpit team device list to see ids and names." });
+    const result = await callTower(tower, {
+        path: `/api/ambient/devices/${encodeURIComponent(device.device_id)}/doctor`,
+        method: "POST", label: "team device doctor", body: { action: "doctor" },
+    });
+    console.error("[team cli] device doctor", JSON.stringify({ device_id: device.device_id, reason: result.ok ? "requested" : result.reason }));
+    if (!result.ok)
+        return writeCommandFailure(io, command.json, result);
+    writeLine(io.stdout, command.json ? JSON.stringify({ ok: true, ...asRecord(result.body) }) : `Doctor requested for ${device.device_name ?? device.device_id}. Waiting for its next check-in.`);
+    return 0;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.180",
+  "version": "0.2.183",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,9 +27,9 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-verb-help.mjs && node ../../scripts/assert-public-cli-surface-doors.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-exit-contract.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-cli-doctor-json.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.53",
-    "@bli-cockpit/mcp": "0.1.95",
-    "@bli-cockpit/telemetry-core": "0.1.65"
+    "@bli-cockpit/memory-mcp": "0.1.55",
+    "@bli-cockpit/mcp": "0.1.97",
+    "@bli-cockpit/telemetry-core": "0.1.66"
   },
   "repository": {
     "type": "git",