@bli-cockpit/cli 0.2.137 → 0.2.140

package/dist/commands/slack.js

@@ -29,9 +29,15 @@ export async function runSlack(command, io) {
         : runReadAction(command, io, tower);
 }
 async function runCoverageAction(command, io, tower) {
-    const query = command.workspace ? `?workspace=${encodeURIComponent(command.workspace)}` : "";
+    const params = new URLSearchParams();
+    if (command.workspace)
+        params.set("workspace", command.workspace);
+    // BLI-10450: counts alone could not answer "is there a Kaiben channel?".
+    if (command.list)
+        params.set("list", "1");
+    const query = params.toString();
     const result = await callTower(tower, {
-        path: `/api/ops/slack/coverage${query}`,
+        path: `/api/ops/slack/coverage${query ? `?${query}` : ""}`,
         label: "slack-coverage",
     });
     if (!result.ok) {
@@ -58,7 +64,7 @@ function writeCoverageReply(command, io, body, coverage, workspaces) {
         return;
     }
     const styled = colorEnabled(io);
-    for (const line of coverageLines(coverage, workspaces, command.staleOnly === true, (text) => dim(text, styled))) {
+    for (const line of coverageLines(coverage, workspaces, command.staleOnly === true, command.list === true, (text) => dim(text, styled))) {
         writeLine(io.stdout, line);
     }
 }
@@ -71,27 +77,43 @@ function logCoverageRead(command, io, workspaces) {
         stale: staleTotal,
         open_skips: workspaces.reduce((sum, row) => sum + numberOf(row["openSkipsTotal"]), 0),
         stale_only: command.staleOnly === true,
+        list: command.list === true,
     })}`);
 }
-function coverageLines(coverage, workspaces, staleOnly, paint) {
+function coverageLines(coverage, workspaces, staleOnly, list, paint) {
     const lines = [];
     const staleAfter = numberOf(coverage["staleAfterHours"]);
     for (const workspace of workspaces) {
-        writeWorkspaceCoverageLines(lines, workspace, staleAfter, staleOnly, paint);
+        writeWorkspaceCoverageLines(lines, workspace, staleAfter, staleOnly, list, paint);
     }
     writeCoverageFooter(lines, coverage, paint);
     return lines;
 }
-function writeWorkspaceCoverageLines(lines, workspace, staleAfter, staleOnly, paint) {
+function writeWorkspaceCoverageLines(lines, workspace, staleAfter, staleOnly, list, paint) {
     const key = String(workspace["workspace"] ?? "?");
     const known = numberOf(workspace["channelsKnown"]);
     const covered = numberOf(workspace["covered"]);
     lines.push(`${key.toUpperCase()}  ${covered} of ${known} channels readable`);
     writeVisibilityLines(lines, workspace, staleOnly, paint);
+    if (list)
+        writeChannelListLines(lines, workspace, paint);
     writeStaleChannelLines(lines, workspace, staleAfter, paint);
     writeOpenSkipLines(lines, workspace, paint);
     lines.push("");
 }
+/** BLI-10450: `--list` names every channel, not just the per-state counts. */
+function writeChannelListLines(lines, workspace, paint) {
+    const channels = Array.isArray(workspace["channels"])
+        ? workspace["channels"]
+        : [];
+    if (channels.length === 0)
+        return;
+    for (const channel of channels) {
+        const meaning = String(channel["meaning"] ?? "?");
+        const line = `  #${String(channel["name"] ?? "?")}  ${meaning}`;
+        lines.push(meaning === "readable" ? line : paint(line));
+    }
+}
 function writeCoverageFooter(lines, coverage, paint) {
     const orphanChannels = numberOf(coverage["orphanChannels"]);
     if (orphanChannels > 0) {
@@ -175,6 +197,8 @@ function buildReadBody(command) {
         body["channel"] = command.channel;
     if (command.query)
         body["query"] = command.query;
+    if (command.query && command.word)
+        body["word"] = true;
     if (command.since)
         body["since"] = command.since;
     if (command.until)
@@ -183,16 +207,32 @@ function buildReadBody(command) {
         body["limit"] = command.limit;
     return body;
 }
+/**
+ * BLI-10450: every result used to print twice. `read["summary"]` is built by
+ * `apps/dashboard/src/lib/jarvis/chat-v2/tools-slack-render.ts` `renderSummary`
+ * for the JARVIS chat tool, which needs ONE self-contained string — so it
+ * already embeds a header, one bullet line per message, AND the note. This
+ * CLI then rendered the SAME messages a second time as full blocks and
+ * appended the note a THIRD time. Only the header (summary's first line) is
+ * still printed verbatim, because it is the sentence that keeps an empty
+ * answer from reading as "nobody said anything"; the messages are rendered
+ * exactly once, in the format the caller asked for, and the note prints once.
+ */
 function writeReadReply(command, io, payload, read, messages) {
     if (command.json) {
         writeLine(io.stdout, JSON.stringify(payload));
+        return;
+    }
+    const styled = colorEnabled(io);
+    const summary = typeof read["summary"] === "string" ? read["summary"] : "";
+    const header = summary.split("\n")[0] ?? "";
+    if (header)
+        writeLine(io.stdout, header);
+    if (command.format === "compact") {
+        for (const message of messages)
+            writeLine(io.stdout, compactMessageLine(message));
     }
     else {
-        const styled = colorEnabled(io);
-        // The server's own summary, first and verbatim: it is the sentence that
-        // keeps an empty answer from reading as "nobody said anything".
-        if (typeof read["summary"] === "string")
-            writeLine(io.stdout, read["summary"]);
         if (messages.length > 0)
             writeLine(io.stdout, "");
         for (const message of messages) {
@@ -202,11 +242,15 @@ function writeReadReply(command, io, payload, read, messages) {
                 writeLine(io.stdout, dim(`  ${message["permalink"]}`, styled));
             }
         }
-        if (typeof read["note"] === "string" && read["note"]) {
-            writeLine(io.stdout, "");
-            writeLine(io.stdout, dim(read["note"], styled));
-        }
     }
+    if (typeof read["note"] === "string" && read["note"]) {
+        writeLine(io.stdout, "");
+        writeLine(io.stdout, dim(read["note"], styled));
+    }
+}
+function compactMessageLine(message) {
+    return `- #${String(message["channel"] ?? "?")} — ${String(message["author"] ?? "?")} — `
+        + `${String(message["messageTs"] ?? "?")} — "${String(message["text"] ?? "")}" — ${String(message["permalink"] ?? "")}`;
 }
 function logReadResult(command, io, read, messages) {
     const coverage = asRecord(read["coverage"]);

package/dist/tower-client.js

@@ -29,6 +29,20 @@ import { normalizeDashboardUrl, readResponseJson, responseErrorMessage, } from "
 const defaultLog = (line) => {
     console.error(line);
 };
+/**
+ * BLI-10450: every call printed `[tower client] responded {...}` on stderr,
+ * which mixed into content whenever a caller redirected `2>&1` — the exact
+ * shape an agent piping `cockpit docs read ... 2>&1` hit. The line is a
+ * per-request trace, not a decision (the failure branch below is the one the
+ * repo's "never fail silently" rule actually protects), so it is the one
+ * allowed to go quiet: under `--json` (the line is never meant for a person
+ * reading machine output), a bare `--quiet` (stripped by the router in
+ * `local.ts` and mirrored onto `COCKPIT_QUIET` so this module needs no extra
+ * plumbing), or the env var directly.
+ */
+export function shouldSuppressTowerSuccessLog(argv = process.argv) {
+    return argv.includes("--json") || Boolean(process.env.COCKPIT_QUIET);
+}
 /**
  * Loads the paired device session, or explains in one sentence why it cannot.
  *
@@ -82,13 +96,21 @@ export async function towerRequest(options) {
     try {
         const response = await options.fetch(url, init);
         const respondedMs = Date.now() - startedAt;
-        log(`[tower client] responded ${JSON.stringify({
-            request: options.label,
-            http_status: response.status,
-            content_type: response.headers.get("content-type") ?? "none",
-            streamed: (response.headers.get("content-type") ?? "").includes("application/x-ndjson"),
-            elapsed_ms: respondedMs,
-        })}`);
+        // The success branch always decided something (BLI-10450 kept the
+        // "log the success branch too" rule intact) — it is just that under
+        // `--json`/`--quiet` the reader already gets that decision back as the
+        // command's own stdout object, so a second copy on stderr is noise, not
+        // signal. The failure branch below never quiets: a request that reached
+        // no response at all is the one case AGENTS.md's logging rule protects.
+        if (!shouldSuppressTowerSuccessLog()) {
+            log(`[tower client] responded ${JSON.stringify({
+                request: options.label,
+                http_status: response.status,
+                content_type: response.headers.get("content-type") ?? "none",
+                streamed: (response.headers.get("content-type") ?? "").includes("application/x-ndjson"),
+                elapsed_ms: respondedMs,
+            })}`);
+        }
         return { ok: true, response, startedAt, respondedMs };
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.137",
+  "version": "0.2.140",
   "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-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-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.35",
-    "@bli-cockpit/mcp": "0.1.63",
+    "@bli-cockpit/memory-mcp": "0.1.36",
+    "@bli-cockpit/mcp": "0.1.65",
     "@bli-cockpit/telemetry-core": "0.1.48"
   }
 }