@bli-cockpit/cli 0.2.58 → 0.2.60

package/dist/commands/status.js

@@ -15,6 +15,8 @@ import path from "node:path";
 import { writeLine } from "./cli-io.js";
 import { displayTicketId, displayWorkLabel, shortSha, stuckEvidenceLine, } from "./collection-report.js";
 import { discoverCommandWorktrees } from "./local-discovery.js";
+import { refreshSetupReceipt } from "./setup-receipt.js";
+import { setupReceiptBlock } from "./setup-receipt-lines.js";
 import { defaultCodexSessionDirs } from "../adapters/codex-attribution.js";
 import { describeError } from "../health-detail.js";
 import { backfillCompletionCovers, emptyBackfillCursorState, prepareBackfillCursorForScope, readBackfillCompletionMarker, readBackfillCursor, } from "../cursors/backfill-cursor.js";
@@ -43,8 +45,19 @@ export async function runStatus(command, io) {
         return 0;
     }
     const status = await inspectLocalCollectorStatus(command);
+    // BLI-3731: "is this machine actually connected?" belongs beside "is it
+    // collecting?", and it is read back off the host rather than remembered.
+    // Refreshing here also keeps the heartbeat's cache warm without the 15-minute
+    // tick paying for the probe.
+    const setupReceipt = await refreshSetupReceipt(io, {
+        ...(command.homeDir ? { homeDir: command.homeDir } : {}),
+    });
     if (command.json) {
-        writeLine(io.stdout, JSON.stringify({ ...status, backfill_cursor: backfillCursor }, null, 2));
+        writeLine(io.stdout, JSON.stringify({
+            ...status,
+            backfill_cursor: backfillCursor,
+            setup_receipt: setupReceipt?.receipt ?? null,
+        }, null, 2));
         return 0;
     }
     writeLine(io.stdout, "Tower status");
@@ -69,6 +82,12 @@ export async function runStatus(command, io) {
     writeLine(io.stdout, `Stuck files: ${stuckEvidenceLine(status)}`);
     for (const detail of status.details)
         writeLine(io.stdout, `- ${detail}`);
+    writeLine(io.stdout, "Connected:");
+    for (const line of setupReceipt
+        ? setupReceiptBlock(setupReceipt, { indent: "  " })
+        : ["  unknown — run `cockpit doctor` to read this machine."]) {
+        writeLine(io.stdout, line);
+    }
     return 0;
 }
 /**

package/dist/commands/tower-mcp-install.js

@@ -6,9 +6,11 @@
  * verb: that command already runs unasked from `do-everything` and the daily
  * sync tick (`memory-install.ts`'s own header), which is the ONLY way a
  * registration reaches every intern machine without anyone typing anything.
- * A second, un-invoked `cockpit mcp install` command would ship the feature
+ * A second, un-invoked `mcp install` verb of its own would ship the feature
  * and still leave every existing machine unregistered until someone learned
- * to type the new verb.
+ * to type it. (Deliberately not written as a `cockpit ...` invocation here:
+ * BLI-3768's census refuses any spelled-out command the router would answer
+ * `Unknown command` to, and this one is a road not taken.)
  *
  * `no_bin_no_write` applies here too, for the identical reason
  * `memory-install.ts` states it for `bli-memory-mcp`: a Claude Code entry

package/dist/local-state-pairing-code.js

@@ -0,0 +1,200 @@
+import { LocalCollectorSessionFileSchema, } from "@bli-cockpit/telemetry-core";
+import os from "node:os";
+import { ensureRuntimeDirectories, getCollectorRuntimePaths, } from "./local-state-paths.js";
+import { writeJsonFile } from "./local-state-files.js";
+import { DEFAULT_DASHBOARD_URL, defaultDeviceName, LOCAL_COLLECTOR_VERSION, normalizeDashboardUrl, normalizeDeviceName, readLocalCollectorConfig, } from "./local-state-config.js";
+import { toSessionReference } from "./local-state-session.js";
+/** Everything that can go wrong, with the same name on both sides of the wire. */
+export class PairingCodeError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.name = "PairingCodeError";
+        this.reason = reason;
+    }
+}
+const TAG = "[pair link]";
+const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
+export async function pairLocalCollectorViaLink(options = {}) {
+    const homeDir = options.homeDir ?? os.homedir();
+    const paths = getCollectorRuntimePaths(homeDir);
+    await ensureRuntimeDirectories(paths);
+    const config = await readLocalCollectorConfig(paths).catch(() => null);
+    const dashboardUrl = normalizeDashboardUrl(options.dashboardUrl ?? config?.dashboard_url ?? DEFAULT_DASHBOARD_URL);
+    const deviceId = config?.device_id;
+    if (!deviceId) {
+        throw new PairingCodeError("config_missing_device_id", "Local config has no device id. Run `cockpit onboard` (or `cockpit install`) first.");
+    }
+    const deviceName = normalizeDeviceName(options.deviceName) ??
+        config?.device_name ??
+        defaultDeviceName();
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (!fetchImpl) {
+        throw new PairingCodeError("fetch_unavailable", "global fetch is unavailable; use Node.js 20 or newer.");
+    }
+    const minted = options.pairCode
+        ? null
+        : await mintPairingCode(fetchImpl, dashboardUrl, {
+            device_id: deviceId,
+            device_name: deviceName,
+            claimed_owner_email: options.claimedOwnerEmail,
+            collector_version: LOCAL_COLLECTOR_VERSION,
+        });
+    if (minted) {
+        options.onLinkReady?.({
+            connect_url: minted.connect_url,
+            expires_at: minted.expires_at,
+        });
+    }
+    const session = await pollExchange(fetchImpl, dashboardUrl, {
+        paths,
+        code: options.pairCode ?? minted?.code ?? "",
+        clientSecret: minted?.client_secret,
+        deviceId,
+        deviceName,
+        pollIntervalMs: options.pollIntervalMs ?? minted?.poll_after_ms,
+        timeoutMs: options.timeoutMs,
+        sleep: options.sleep,
+        now: options.now,
+    });
+    return {
+        status: "paired",
+        session: toSessionReference(session),
+        session_file: paths.session_file,
+        dashboard_url: dashboardUrl,
+        ...(minted ? { connect_url: minted.connect_url } : {}),
+        direction: minted ? "cli_first" : "browser_first",
+    };
+}
+async function mintPairingCode(fetchImpl, dashboardUrl, body) {
+    const response = await fetchImpl(`${dashboardUrl}/api/devices/pair/code`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    const parsed = await readResponseJson(response, "mint");
+    if (!response.ok) {
+        throw refusalFrom("pair_code_mint_refused", response, parsed);
+    }
+    const record = asRecord(parsed);
+    const code = readString(record, "code");
+    const connectUrl = readString(record, "connect_url");
+    const expiresAt = readString(record, "expires_at");
+    if (!code || !connectUrl || !expiresAt) {
+        throw new PairingCodeError("pair_code_mint_malformed", "The dashboard did not return a usable pairing code.");
+    }
+    return {
+        code,
+        client_secret: readString(record, "client_secret") ?? undefined,
+        connect_url: connectUrl,
+        expires_at: expiresAt,
+        poll_after_ms: readNumber(record, "poll_after_ms") ?? 2_000,
+        direction: readString(record, "direction") === "browser_first"
+            ? "browser_first"
+            : "cli_first",
+    };
+}
+async function pollExchange(fetchImpl, dashboardUrl, options) {
+    if (!options.code) {
+        throw new PairingCodeError("pair_code_missing", "No pairing code to exchange.");
+    }
+    const pollIntervalMs = Math.max(250, options.pollIntervalMs ?? 2_000);
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const sleepImpl = options.sleep ??
+        ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+    const startedAt = options.now?.getTime() ?? Date.now();
+    const deadline = startedAt + timeoutMs;
+    let attempts = 0;
+    while (Date.now() <= deadline) {
+        attempts += 1;
+        const response = await fetchImpl(`${dashboardUrl}/api/devices/pair/exchange`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                code: options.code,
+                ...(options.clientSecret ? { client_secret: options.clientSecret } : {}),
+                device_id: options.deviceId,
+                device_name: options.deviceName,
+                collector_version: LOCAL_COLLECTOR_VERSION,
+            }),
+        });
+        const parsed = await readResponseJson(response, "exchange");
+        const record = asRecord(parsed);
+        const status = readString(record, "status");
+        if (!response.ok) {
+            throw refusalFrom(readString(record, "reason") ?? "pair_exchange_refused", response, parsed);
+        }
+        if (status === "paired") {
+            const session = parseExchangedSession(record, options.paths.session_file);
+            await writeJsonFile(options.paths.session_file, session);
+            console.error(`${TAG} paired`, JSON.stringify({ reason: "exchange_ok", attempts }));
+            return session;
+        }
+        if (status === "refused") {
+            throw new PairingCodeError(readString(record, "reason") ?? "pair_exchange_refused", readString(record, "message") ?? "Pairing was refused.");
+        }
+        if (status !== "pending_claim") {
+            throw new PairingCodeError("pair_exchange_unexpected_status", `Unexpected pairing status: ${status ?? "none"}`);
+        }
+        await sleepImpl(pollIntervalMs);
+    }
+    console.error(`${TAG} gave up waiting`, JSON.stringify({ reason: "pair_exchange_timeout", attempts }));
+    throw new PairingCodeError("pair_exchange_timeout", "Timed out waiting for the browser sign-in. Run `cockpit login` again.");
+}
+function parseExchangedSession(record, sessionFilePath) {
+    const session = record?.["session"];
+    if (!session || typeof session !== "object") {
+        throw new PairingCodeError("pair_exchange_no_session", "Pairing succeeded but the dashboard returned no session.");
+    }
+    return LocalCollectorSessionFileSchema.parse({
+        ...session,
+        session_file_path: sessionFilePath,
+    });
+}
+/**
+ * The server's own words first, then the status, so a captive portal, a wrong
+ * dashboard URL and a real refusal never read the same. Logged as well as
+ * thrown: pairing runs on a machine that is not collecting yet, so the
+ * terminal is the only receipt there is.
+ */
+function refusalFrom(reason, response, body) {
+    const record = asRecord(body);
+    const words = readString(record, "message") ??
+        readString(record, "error") ??
+        "Pairing request failed";
+    console.error(`${TAG} refused`, JSON.stringify({ reason, http_status: response.status }));
+    return new PairingCodeError(reason, `${words} (HTTP ${response.status})`);
+}
+async function readResponseJson(response, stage) {
+    const text = await response.text();
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        // A captive portal or a proxy answering with HTML is the classic reason a
+        // new machine cannot pair. The body is never logged; its shape is.
+        console.error(`${TAG} reply was not JSON`, JSON.stringify({
+            reason: "response_body_not_json",
+            stage,
+            http_status: response.status,
+            byte_size: text.length,
+            content_type: response.headers.get("content-type") ?? "none",
+        }));
+        return { message: text.slice(0, 200) };
+    }
+}
+function asRecord(value) {
+    return value && typeof value === "object"
+        ? value
+        : null;
+}
+function readString(record, field) {
+    const value = record?.[field];
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function readNumber(record, field) {
+    const value = record?.[field];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}

package/dist/local-state.js

@@ -18,6 +18,11 @@
  * - `local-state-pairing.ts` — `cockpit login` and `cockpit logout`: the two
  *   operations that make and unmake that session file, plus the pair
  *   start/poll HTTP client and its refusal message.
+ * - `local-state-pairing-code.ts` — the ONE-SIGN-IN ceremony (BLI-3731): mint
+ *   a pairing code, print and open `<dashboard>/connect?pair=…`, and poll the
+ *   exchange until the browser's single magic link has claimed it. Writes the
+ *   same session file its older sibling does, because the server issues it
+ *   from the same `pollDevicePairRequest`.
  * - `local-state-identity.ts` — which repo and worktree a folder is, with the
  *   path-derived fallback that keeps a non-git folder collectable.
  * - `local-state-attributed-target.ts` — re-derives a caller-supplied identity
@@ -34,6 +39,7 @@ export { getCollectorRuntimePaths } from "./local-state-paths.js";
 export { DEFAULT_DASHBOARD_URL, ensureLocalCollectorConfig, installLocalCollector, LOCAL_COLLECTOR_VERSION, readLocalCollectorConfig, } from "./local-state-config.js";
 export { readLocalCollectorSessionFile, readLocalSessionReference, } from "./local-state-session.js";
 export { logoutLocalCollector, pairLocalCollector, } from "./local-state-pairing.js";
+export { PairingCodeError, pairLocalCollectorViaLink, } from "./local-state-pairing-code.js";
 export { resolveGitBranch } from "./local-state-identity.js";
 export { readLocalWorkContext, readLocalWorkContextForRepo, startLocalWorkContext, startLocalWorkContextForAttributedTarget, } from "./local-state-work-context.js";
 export { classifyCollectorFreshness, inspectLocalCollectorStatus, } from "./local-state-status.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.58",
+  "version": "0.2.60",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,8 +27,8 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.6",
-    "@bli-cockpit/mcp": "0.1.1",
-    "@bli-cockpit/telemetry-core": "0.1.28"
+    "@bli-cockpit/memory-mcp": "0.1.7",
+    "@bli-cockpit/mcp": "0.1.4",
+    "@bli-cockpit/telemetry-core": "0.1.29"
   }
 }