@bli-cockpit/cli 0.2.126 → 0.2.127

package/dist/commands/local-discovery.js

@@ -1,37 +1,15 @@
 import { writeLine } from "./cli-io.js";
 import { resolveDiscoveryLimits, saveDiscoveryLimits, } from "../discovery-limits.js";
+import { getCollectorRuntimePaths, readLocalCollectorConfig, } from "../local-state.js";
 import { discoverGitWorktreesInRootsWithStatus, } from "../repo-identity.js";
 export async function discoverCommandWorktrees(repoRoot, discovery = {}, io) {
     // What the operator typed this run, else what they typed some previous run,
     // else the built-in defaults (BLI-2362).
     const limits = await resolveDiscoveryLimits(discovery, discovery.homeDir);
-    const maxWorktrees = limits.maxRepos;
-    const roots = Array.isArray(repoRoot)
-        ? repoRoot
-        : [repoRoot ?? process.cwd()];
-    const result = await discoverGitWorktreesInRootsWithStatus(roots, {
-        maxDepth: limits.maxDepth,
-        maxWorktrees,
-    });
-    if (io && result.unreadable_dirs.length > 0) {
-        // Never silently dropped: anything under these folders is missing from the
-        // scan, so say so even when the run otherwise succeeds.
-        writeLine(io.stderr, unreadableDirectoriesMessage(result.unreadable_dirs));
-    }
+    const askedForRoots = repoRoot === undefined ? undefined : Array.isArray(repoRoot) ? repoRoot : [repoRoot];
+    const roots = askedForRoots ?? [process.cwd()];
+    const result = await scanRootsReportingWhatItMissed(roots, limits, discovery, io);
     const worktrees = result.worktrees;
-    if (!result.complete) {
-        const message = incompleteDiscoveryMessage({
-            result,
-            roots,
-            maxDepth: limits.maxDepth,
-            maxRepos: maxWorktrees,
-            found: worktrees.length,
-        });
-        if (io)
-            writeLine(io.stderr, message);
-        discovery.onPartial?.(message);
-        console.error("[local-discovery] partial collection", JSON.stringify({ reason: result.incomplete_reasons.join(","), roots: roots.length, incomplete_roots: result.incomplete_roots.length, max_depth: limits.maxDepth, found: worktrees.length }));
-    }
     if (worktrees.length === 0 && result.complete && !discovery.allowEmpty) {
         // "No git repos found" is only true when the scan could actually SEE
         // everywhere it looked. With unreadable folders in hand, the sentence sent
@@ -53,10 +31,86 @@ export async function discoverCommandWorktrees(repoRoot, discovery = {}, io) {
                 "Fix the permissions on those folders and run the command again, or point --workspace at the project folders you can read.",
             ].join("\n"));
         }
+        // An explicit --workspace is an instruction about WHERE to look, so an
+        // empty answer there is the answer. Without one, the folder the operator
+        // stood in was a guess, and this machine already knows a better one — for
+        // the commands that asked for it (BLI-4467).
+        if (askedForRoots === undefined && discovery.fallbackToSavedRoots) {
+            return await discoverInSavedCollectionRoots(limits, discovery, io);
+        }
         throw new Error("No git repos found. Run from a git repo, or from a parent folder containing git repos.");
     }
     return worktrees;
 }
+/**
+ * The second look: this machine's approved collection roots, scanned with the
+ * same limits and the same partial/unreadable reporting as the first. Refuses
+ * only when there are no approved roots to read, because then the machine
+ * genuinely has nothing to point the operator at (BLI-4467).
+ */
+async function discoverInSavedCollectionRoots(limits, discovery, io) {
+    const savedRoots = await readSavedCollectionRoots(discovery.homeDir);
+    if (savedRoots.length === 0) {
+        console.error("[local-discovery] cwd holds no repos and this machine has no saved collection roots", JSON.stringify({ reason: "no_saved_roots" }));
+        throw new Error([
+            "No git repos found here and this machine has no approved collection roots.",
+            "Run `cockpit doctor` to set them up, or `cockpit roots add <dir>`.",
+        ].join("\n"));
+    }
+    console.error("[local-discovery] cwd holds no repos, using the saved collection roots", JSON.stringify({ reason: "roots_fallback", roots: savedRoots.length }));
+    if (io)
+        writeLine(io.stderr, "No git repo here; reading the machine's approved roots.");
+    const result = await scanRootsReportingWhatItMissed(savedRoots, limits, discovery, io);
+    console.error("[local-discovery] saved collection roots scanned", JSON.stringify({
+        reason: "roots_fallback_result",
+        roots: savedRoots.length,
+        found: result.worktrees.length,
+        complete: result.complete,
+    }));
+    return result.worktrees;
+}
+/** The approved roots this machine already agreed to collect, or none if the config cannot be read. */
+async function readSavedCollectionRoots(homeDir) {
+    const paths = getCollectorRuntimePaths(homeDir);
+    const config = await readLocalCollectorConfig(paths).catch((error) => {
+        console.error("[local-discovery] could not read the saved collection roots", JSON.stringify({
+            reason: error.code ?? "config_unreadable",
+        }));
+        return null;
+    });
+    return config?.default_repo_paths ?? [];
+}
+/**
+ * One scan plus the two things a scan owes the operator: the folders it could
+ * not open, and the coverage it could not finish. Shared so the fallback scan
+ * reports exactly what the first one does.
+ */
+async function scanRootsReportingWhatItMissed(roots, limits, discovery, io) {
+    const maxWorktrees = limits.maxRepos;
+    const result = await discoverGitWorktreesInRootsWithStatus(roots, {
+        maxDepth: limits.maxDepth,
+        maxWorktrees,
+    });
+    if (io && result.unreadable_dirs.length > 0) {
+        // Never silently dropped: anything under these folders is missing from the
+        // scan, so say so even when the run otherwise succeeds.
+        writeLine(io.stderr, unreadableDirectoriesMessage(result.unreadable_dirs));
+    }
+    if (!result.complete) {
+        const message = incompleteDiscoveryMessage({
+            result,
+            roots,
+            maxDepth: limits.maxDepth,
+            maxRepos: maxWorktrees,
+            found: result.worktrees.length,
+        });
+        if (io)
+            writeLine(io.stderr, message);
+        discovery.onPartial?.(message);
+        console.error("[local-discovery] partial collection", JSON.stringify({ reason: result.incomplete_reasons.join(","), roots: roots.length, incomplete_roots: result.incomplete_roots.length, max_depth: limits.maxDepth, found: result.worktrees.length }));
+    }
+    return result;
+}
 /**
  * Persists `--max-depth` / `--max-repos` when a command carried them, so the
  * number survives into the background sync and the doctor's own sync — neither

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

package/dist/commands/sessions.js

@@ -19,7 +19,14 @@ const SESSION_SCAN_OVERRIDE_LIMIT = 10_000;
 export async function runSessions(command, io) {
     const now = new Date();
     const homeDir = command.homeDir ?? os.homedir();
-    const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos, homeDir: command.homeDir }, io);
+    const worktrees = await discoverCommandWorktrees(command.repoRoot, {
+        maxDepth: command.maxDepth,
+        maxRepos: command.maxRepos,
+        homeDir: command.homeDir,
+        // BLI-4467: a read-only question about what this machine has observed,
+        // so the approved roots answer it from any folder.
+        fallbackToSavedRoots: true,
+    }, io);
     const window = await sessionsScanWindow(command, now);
     const { codex, claude } = await scanSessionSources(command, homeDir, worktrees, now, window);
     const { codexRows, claudeRows } = sessionRows(codex, claude);

package/dist/commands/status.js

@@ -30,11 +30,26 @@ import { normalizeCollectionRoots } from "../root-normalization.js";
 export async function runStatus(command, io) {
     const backfillCursor = await inspectBackfillCursor(command.homeDir);
     const setupReceipt = await readMachineSetupReceipt(command.homeDir, io);
-    const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos, homeDir: command.homeDir }, io);
+    const worktrees = await discoverCommandWorktrees(command.repoRoot, {
+        maxDepth: command.maxDepth,
+        maxRepos: command.maxRepos,
+        homeDir: command.homeDir,
+        // BLI-4467: this command answers "what does this machine believe about
+        // itself", so standing in a folder with no repo is not a reason to
+        // refuse — the approved roots are the better answer.
+        fallbackToSavedRoots: true,
+    }, io);
     if (worktrees.length > 1) {
         return writeMultiRepoStatus(command, io, backfillCursor, setupReceipt, worktrees);
     }
-    return writeSingleRepoStatus(command, io, backfillCursor, setupReceipt);
+    // BLI-4467: with no --workspace, the folder was a guess and discovery is the
+    // one that knows which worktree this is about — the fallback above may have
+    // found it under an approved root, nowhere near the cwd. Describing the guess
+    // printed `repo: <the empty folder>` and `branch: unknown` while exiting 0.
+    const single = command.repoRoot === undefined && worktrees.length === 1
+        ? { ...command, repoRoot: worktrees[0].repo_root }
+        : command;
+    return writeSingleRepoStatus(single, io, backfillCursor, setupReceipt);
 }
 async function readMachineSetupReceipt(homeDir, io) {
     // BLI-3731: "is this machine actually connected?" belongs beside "is it

package/dist/upload-agent-artifacts.js

@@ -40,20 +40,26 @@ export async function reportAgentImageArtifacts(options) {
         // Both non-2xx branches returned a label and said nothing (BLI-3483). An
         // image that never gets reported is never redacted and never OCR'd, and
         // the only place that fact existed was a return value the sync discards.
-        if (response.status === 404) {
-            console.error("[agent-artifacts] the dashboard has no agent-artifact route; these images stay unreported", JSON.stringify({
-                reason: "agent_artifact_api_unavailable",
-                http_status: 404,
-                artifact_count: artifacts.length,
-            }));
-            return {
-                posted: false,
-                reason: "agent_artifact_api_unavailable",
-                recorded_count: 0,
-            };
-        }
         if (!response.ok) {
-            const serverReason = serverFailureDetail(await readResponseJson(response));
+            const errorBody = await readResponseJson(response);
+            // A 404 is two different facts. "No such route" is the platform
+            // answering with an empty or HTML body; a JSON error envelope means the
+            // route answered and refused, and calling that "the dashboard has no
+            // agent-artifact route" hid a real refusal behind a shrug for as long as
+            // the door rejected ambient tickets.
+            if (response.status === 404 && !routeAnswered(errorBody)) {
+                console.error("[agent-artifacts] nothing answered at the agent-artifact path; these images stay unreported", JSON.stringify({
+                    reason: "agent_artifact_api_unavailable",
+                    http_status: 404,
+                    artifact_count: artifacts.length,
+                }));
+                return {
+                    posted: false,
+                    reason: "agent_artifact_api_unavailable",
+                    recorded_count: 0,
+                };
+            }
+            const serverReason = serverFailureDetail(errorBody);
             console.error("[agent-artifacts] report refused", JSON.stringify({
                 reason: "report_failed",
                 http_status: response.status,
@@ -99,6 +105,20 @@ export async function reportAgentImageArtifacts(options) {
         return { posted: false, reason: "report_network_error", recorded_count: 0 };
     }
 }
+/**
+ * Did the route answer, or did something in front of it?
+ *
+ * The dashboard's refusals are always a JSON envelope carrying a `code` (and
+ * sometimes a `reason`); a missing route answers with an empty body or a
+ * platform HTML page, which `readResponseJson` hands back as `{ message }`.
+ * That difference is the whole reason a 404 can mean two things.
+ */
+function routeAnswered(body) {
+    if (!body || typeof body !== "object")
+        return false;
+    const record = body;
+    return (typeof record["code"] === "string" || typeof record["reason"] === "string");
+}
 /**
  * The images this sync made durable, from both directions.
  *

package/dist/upload-http.js

@@ -39,11 +39,19 @@ export async function readResponseJson(response) {
  * The server's own reason for refusing, as something safe to log.
  *
  * The dashboard's error envelopes answer `{ code, message, reason? }`. A
- * `reason`/`code` that already looks like a label travels verbatim — that is
- * the bucket the server chose, and reproducing it is how "storage rejected 116
- * MB" reaches an operator instead of "upload failed" (BLI-2528). Anything else
- * falls back to the message, redacted and capped, because a proxy's error page
- * is unbounded and a route's message can carry a path.
+ * `reason`/`code` that already looks like a label is the bucket the server
+ * chose and travels verbatim at the head — that is how "storage rejected 116
+ * MB" reaches an operator instead of "upload failed" (BLI-2528).
+ *
+ * The label alone is not the whole fact. Every dashboard envelope carries a
+ * `code`, so a label-first helper that stopped at the first match never read
+ * `message` on any refusal: four fleet machines showed `ingest_rejected: http
+ * 500; server reason BLI-E001` while the server had sent "Collector device
+ * lookup failed: <cause>" in the same body. The failure knew its reason and
+ * the collector discarded it. So the sentence rides behind the label as
+ * `label: message`, redacted and capped — a proxy's error page is unbounded
+ * and a route's message can carry a path. A message that merely restates the
+ * `reason` is dropped rather than repeated.
  *
  * `null` means the body said nothing usable — which is itself worth logging as
  * `"none"`, since "the server gave no reason" and "we never looked" are
@@ -53,14 +61,26 @@ export function serverFailureDetail(value) {
     if (!value || typeof value !== "object")
         return null;
     const record = value;
+    let head = null;
+    let headIsReason = false;
     for (const key of ["reason", "code"]) {
         const candidate = record[key];
         if (typeof candidate === "string" && /^[a-z0-9_:.-]{1,80}$/iu.test(candidate)) {
-            return candidate;
+            head = candidate;
+            headIsReason = key === "reason";
+            break;
         }
     }
     const message = record["message"] ?? record["error"];
-    return typeof message === "string" ? boundedFailureDetail(message) : null;
+    const sentence = typeof message === "string" ? boundedFailureDetail(message) : null;
+    if (!head)
+        return sentence;
+    if (!sentence)
+        return head;
+    if (headIsReason && sentence.trim().toLowerCase() === head.trim().toLowerCase()) {
+        return head;
+    }
+    return `${head}: ${sentence}`;
 }
 /** The server's own words when it supplied any, otherwise our fallback. */
 export function responseErrorMessage(value, fallback) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.126",
+  "version": "0.2.127",
   "private": false,
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@bli-cockpit/memory-mcp": "0.1.32",
-    "@bli-cockpit/mcp": "0.1.53",
+    "@bli-cockpit/mcp": "0.1.54",
     "@bli-cockpit/telemetry-core": "0.1.48"
   }
 }