@bli-cockpit/cli 0.2.222 → 0.2.236

package/dist/agent-plugins-converge.js

@@ -0,0 +1,182 @@
+/**
+ * Runs the host commands that put the company plugin on a machine (BLI-18200),
+ * and remembers what happened so the 15-minute tick never hammers a failure.
+ *
+ *   Claude Code  claude plugin marketplace add BLI-INC/bli-agents-marketplace
+ *                claude plugin install engineering-standards@bli-agents
+ *                daily: claude plugin marketplace update bli-agents
+ *                       claude plugin update engineering-standards@bli-agents
+ *   Codex        codex plugin marketplace add BLI-INC/bli-agents-marketplace
+ *                codex plugin add engineering-standards@bli-agents
+ *                daily: codex plugin marketplace upgrade bli-agents
+ *
+ * The marketplace follows the repository default branch (no ref is passed).
+ * These are the host programs the machine already runs (agent-setup.ts spawns
+ * them for `--version` the same way), never a person's own program, so this does
+ * not belong in `commands/editor.ts`.
+ *
+ * Never throws and never blocks: a missing program, a private-repo sign-in gap,
+ * a dead network or a program too old for `plugin` is a named reason in the
+ * returned outcome, the log and `agent-plugins.json`. The tick retries a failed
+ * host only after six hours; a person running `cockpit doctor` always retries.
+ * Logs carry reason labels, exit codes and timings only, never command output.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { AGENT_PLUGIN_ID, AGENT_PLUGIN_MARKETPLACE, AGENT_PLUGIN_SOURCE, PLUGIN_HOSTS, classifyPluginFailure, inspectAgentPlugins, locateHostBinary, } from "./agent-plugins.js";
+import { envWithNodeRuntimeOnPath } from "./scheduled-self-update.js";
+export const AGENT_PLUGINS_STATE_FILE = "agent-plugins.json";
+export const PLUGIN_RETRY_AFTER_FAILURE_MS = 6 * 60 * 60 * 1000;
+export const PLUGIN_REFRESH_EVERY_MS = 24 * 60 * 60 * 1000;
+/** A first marketplace clone is small; anything slower is a stuck prompt or a dead link. */
+export const PLUGIN_COMMAND_TIMEOUT_MS = 120_000;
+export async function readPluginState(stateDir) {
+    try {
+        const parsed = JSON.parse(await fs.readFile(path.join(stateDir, AGENT_PLUGINS_STATE_FILE), "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+async function writePluginState(stateDir, state) {
+    try {
+        await fs.mkdir(stateDir, { recursive: true });
+        await fs.writeFile(path.join(stateDir, AGENT_PLUGINS_STATE_FILE), JSON.stringify(state), { mode: 0o600 });
+    }
+    catch (error) {
+        console.error("[agent-plugins] state not saved", JSON.stringify({ reason: "state_write_failed", error_code: error.code ?? null }));
+    }
+}
+const msSince = (iso, now) => {
+    const at = iso ? Date.parse(iso) : Number.NaN;
+    return Number.isFinite(at) ? now.getTime() - at : Number.POSITIVE_INFINITY;
+};
+function spawnEnv(options) {
+    const env = envWithNodeRuntimeOnPath({ ...(options.env ?? process.env) }, options.nodeExecutable);
+    return {
+        ...env,
+        // git must fail, not ask: a prompt on a scheduled tick hangs until the timeout.
+        GIT_TERMINAL_PROMPT: "0",
+        GCM_INTERACTIVE: "never",
+        ...(options.unattended && !env["GIT_SSH_COMMAND"] ? { GIT_SSH_COMMAND: "ssh -o BatchMode=yes" } : {}),
+    };
+}
+function stepsFor(host, reading, refresh) {
+    const steps = [];
+    if (!reading.marketplace)
+        steps.push({ name: "marketplace_add", args: ["plugin", "marketplace", "add", AGENT_PLUGIN_SOURCE] });
+    if (!reading.installed)
+        steps.push({ name: "plugin_install", args: host === "claude" ? ["plugin", "install", AGENT_PLUGIN_ID] : ["plugin", "add", AGENT_PLUGIN_ID] });
+    if (reading.installed && refresh) {
+        steps.push(host === "claude"
+            ? { name: "marketplace_update", args: ["plugin", "marketplace", "update", AGENT_PLUGIN_MARKETPLACE] }
+            : { name: "marketplace_update", args: ["plugin", "marketplace", "upgrade", AGENT_PLUGIN_MARKETPLACE] });
+        if (host === "claude")
+            steps.push({ name: "plugin_update", args: ["plugin", "update", AGENT_PLUGIN_ID] });
+    }
+    return steps;
+}
+export async function convergeAgentPlugins(options) {
+    const now = options.now ?? new Date();
+    const state = await readPluginState(options.stateDir);
+    const before = JSON.stringify(state);
+    const outcomes = [];
+    let readings;
+    try {
+        readings = await inspectAgentPlugins(options.homeDir, options);
+    }
+    catch (error) {
+        console.error("[agent-plugins] host state unreadable", JSON.stringify({ reason: "inspect_threw", error_name: error instanceof Error ? error.name : typeof error }));
+        return PLUGIN_HOSTS.map((host) => ({ host, status: "failed", reason: "command_failed", quiet: false }));
+    }
+    for (const host of PLUGIN_HOSTS) {
+        const reading = readings.find((entry) => entry.host === host);
+        const entry = { ...state[host] };
+        const outcome = await convergeHost(host, reading, entry, options, now).catch((error) => {
+            console.error("[agent-plugins] host step threw", JSON.stringify({ reason: "unexpected_error", host, error_name: error instanceof Error ? error.name : typeof error }));
+            return { host, status: "failed", reason: "command_failed", quiet: false };
+        });
+        if (Object.keys(entry).length > 0)
+            state[host] = entry;
+        else
+            delete state[host];
+        outcomes.push(outcome);
+    }
+    if (JSON.stringify(state) !== before)
+        await writePluginState(options.stateDir, state);
+    return outcomes;
+}
+async function convergeHost(host, reading, entry, options, now) {
+    if (!reading.present)
+        return { host, status: "skipped", reason: "host_not_present", quiet: true };
+    if (reading.installed) {
+        // Installed by us or by hand: a failure remembered from before is spent.
+        delete entry.last_reason;
+        const due = options.refresh && msSince(entry.last_refresh_at, now) >= PLUGIN_REFRESH_EVERY_MS;
+        if (!due)
+            return { host, status: "already_installed", reason: "installed", quiet: true };
+        return refreshHost(host, reading, entry, options, now);
+    }
+    if (options.unattended && entry.last_reason !== undefined && msSince(entry.last_attempt_at, now) < PLUGIN_RETRY_AFTER_FAILURE_MS) {
+        console.error("[agent-plugins] retry waits; the last attempt failed under six hours ago", JSON.stringify({ reason: "retry_throttled", host, last_reason: entry.last_reason }));
+        return { host, status: entry.last_reason === "binary_missing" ? "skipped" : "failed", reason: entry.last_reason, quiet: true };
+    }
+    return installHost(host, reading, entry, options, now);
+}
+async function runSteps(host, binary, steps, options) {
+    const env = spawnEnv(options);
+    for (const step of steps) {
+        const started = Date.now();
+        // The runner contract never rejects; a runner that does is still just a failed command.
+        const result = await options.exec(binary, step.args, { env, timeoutMs: options.timeoutMs ?? PLUGIN_COMMAND_TIMEOUT_MS })
+            .catch(() => ({ code: 1, stdout: "", stderr: "" }));
+        const elapsed_ms = Date.now() - started;
+        if (result.code !== 0) {
+            const reason = classifyPluginFailure(result);
+            console.error("[agent-plugins] host command failed", JSON.stringify({ reason, host, step: step.name, exit_code: result.code, elapsed_ms }));
+            return reason;
+        }
+        console.error("[agent-plugins] host command ran", JSON.stringify({ reason: "step_ok", host, step: step.name, exit_code: 0, elapsed_ms }));
+    }
+    return null;
+}
+async function installHost(host, reading, entry, options, now) {
+    entry.last_attempt_at = now.toISOString();
+    const binary = await locateHostBinary(host, options.homeDir, options);
+    if (!binary) {
+        entry.last_reason = "binary_missing";
+        console.error("[agent-plugins] host program not found", JSON.stringify({ reason: "binary_missing", host }));
+        return { host, status: "skipped", reason: "binary_missing", quiet: false };
+    }
+    const failure = await runSteps(host, binary, stepsFor(host, reading, false), options);
+    if (failure) {
+        entry.last_reason = failure;
+        return { host, status: "failed", reason: failure, quiet: false };
+    }
+    // Verify against what the host recorded, not against the exit code we got.
+    const after = (await inspectAgentPlugins(options.homeDir, options)).find((candidate) => candidate.host === host);
+    if (!after?.installed) {
+        entry.last_reason = "install_not_recorded";
+        console.error("[agent-plugins] install ran but the host did not record it", JSON.stringify({ reason: "install_not_recorded", host }));
+        return { host, status: "failed", reason: "install_not_recorded", quiet: false };
+    }
+    delete entry.last_reason;
+    entry.last_refresh_at = now.toISOString();
+    console.error("[agent-plugins] plugin installed", JSON.stringify({ reason: "installed", host }));
+    return { host, status: "installed", reason: "installed", quiet: false };
+}
+/** The daily refresh. A failure here never un-installs anything; the next try is tomorrow's. */
+async function refreshHost(host, reading, entry, options, now) {
+    entry.last_refresh_at = now.toISOString();
+    const binary = await locateHostBinary(host, options.homeDir, options);
+    if (!binary) {
+        console.error("[agent-plugins] host program not found for the daily refresh", JSON.stringify({ reason: "binary_missing", host }));
+        return { host, status: "already_installed", reason: "refresh_skipped_binary_missing", quiet: true };
+    }
+    const failure = await runSteps(host, binary, stepsFor(host, reading, true), options);
+    if (failure)
+        return { host, status: "already_installed", reason: `refresh_failed_${failure}`, quiet: false };
+    console.error("[agent-plugins] plugin refreshed", JSON.stringify({ reason: "refreshed", host }));
+    return { host, status: "refreshed", reason: "refreshed", quiet: false };
+}

package/dist/agent-plugins.js

@@ -0,0 +1,116 @@
+/**
+ * The company `engineering-standards` plugin on an agent machine (BLI-18200).
+ *
+ * Every intern machine should carry the plugin from the private marketplace
+ * `BLI-INC/bli-agents-marketplace` in BOTH Claude Code and Codex. This module is
+ * the reading half: what the two hosts' own state files say, where each host's
+ * program lives, and how a failed host command is named. It spawns nothing;
+ * `agent-plugins-converge.ts` runs the commands, `commands/doctor-agent-plugins.ts`
+ * is the doctor row, `commands/sync-heal-agent-plugins.ts` is the 15-minute tick.
+ *
+ * Reads only the hosts' own files, rooted at the person's home, so the same code
+ * answers on macOS and native Windows:
+ *   Claude Code  ~/.claude/plugins/known_marketplaces.json  (marketplace added)
+ *                ~/.claude/plugins/installed_plugins.json   (plugin installed)
+ *   Codex        ~/.codex/config.toml  [marketplaces.bli-agents] / [plugins."<id>"]
+ *
+ * A host counts as PRESENT when its config directory exists (`~/.claude`,
+ * `~/.codex`). That is a file read, so a doctor check never spawns a program, and
+ * a machine whose agent was never started has nothing to install into yet.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+export const AGENT_PLUGIN_SOURCE = "BLI-INC/bli-agents-marketplace";
+export const AGENT_PLUGIN_MARKETPLACE = "bli-agents";
+export const AGENT_PLUGIN_NAME = "engineering-standards";
+export const AGENT_PLUGIN_ID = `${AGENT_PLUGIN_NAME}@${AGENT_PLUGIN_MARKETPLACE}`;
+export const PLUGIN_HOSTS = ["claude", "codex"];
+export const realPluginFiles = {
+    read: (file) => fs.readFile(file, "utf8").catch(() => null),
+    exists: (file) => fs.access(file).then(() => true, () => false),
+};
+const pathApi = (platform) => (platform === "win32" ? path.win32 : path.posix);
+function parseObject(text) {
+    if (text === null)
+        return null;
+    try {
+        const value = JSON.parse(text);
+        return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function inspectAgentPlugins(homeDir, runtime = {}) {
+    const platform = runtime.platform ?? process.platform;
+    const files = runtime.files ?? realPluginFiles;
+    const join = (...parts) => pathApi(platform).join(homeDir, ...parts);
+    const claudePresent = await files.exists(join(".claude"));
+    const marketplaces = parseObject(await files.read(join(".claude", "plugins", "known_marketplaces.json")));
+    const installedFile = parseObject(await files.read(join(".claude", "plugins", "installed_plugins.json")));
+    const installations = installedFile?.["plugins"]?.[AGENT_PLUGIN_ID];
+    const codexPresent = await files.exists(join(".codex"));
+    const toml = (await files.read(join(".codex", "config.toml"))) ?? "";
+    const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+    const marketplace = escapeRegExp(AGENT_PLUGIN_MARKETPLACE);
+    return [
+        {
+            host: "claude",
+            present: claudePresent,
+            marketplace: Boolean(marketplaces && Object.keys(marketplaces).includes(AGENT_PLUGIN_MARKETPLACE)),
+            // A plugin the person turned off by hand is still installed; it is not ours to switch back on.
+            installed: Array.isArray(installations) && installations.length > 0,
+        },
+        {
+            host: "codex",
+            present: codexPresent,
+            marketplace: new RegExp(`^\\s*\\[marketplaces\\.(?:"${marketplace}"|${marketplace})\\]\\s*$`, "mu").test(toml),
+            installed: new RegExp(`^\\s*\\[plugins\\."${escapeRegExp(AGENT_PLUGIN_ID)}"\\]\\s*$`, "mu").test(toml),
+        },
+    ];
+}
+/**
+ * Where a host's program lives, as an absolute path or null. A scheduled tick
+ * runs with a stripped PATH, so the person's PATH is tried first and then the
+ * places the host's installers use on each family. No exec: a file check.
+ */
+export async function locateHostBinary(host, homeDir, runtime = {}) {
+    const platform = runtime.platform ?? process.platform;
+    const files = runtime.files ?? realPluginFiles;
+    const api = pathApi(platform);
+    const env = runtime.env ?? process.env;
+    const windows = platform === "win32";
+    const fromPath = (env["PATH"] ?? env["Path"] ?? "").split(windows ? ";" : ":").filter(Boolean);
+    const known = windows
+        ? [api.join(homeDir, ".local", "bin"), api.join(homeDir, "AppData", "Roaming", "npm"), ...(host === "claude" ? [api.join(homeDir, ".claude", "local")] : [])]
+        : [api.join(homeDir, ".local", "bin"), api.join(homeDir, ".npm-global", "bin"), api.join(homeDir, ".bun", "bin"), "/opt/homebrew/bin", "/usr/local/bin", ...(host === "claude" ? [api.join(homeDir, ".claude", "local")] : [])];
+    const nodeDir = api.dirname(runtime.nodeExecutable ?? process.execPath);
+    const names = windows ? [`${host}.exe`, `${host}.cmd`] : [host];
+    for (const directory of [...new Set([...fromPath, ...known, nodeDir])]) {
+        for (const name of names) {
+            const candidate = api.join(directory, name);
+            if (await files.exists(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+/**
+ * Names a failed host command from its exit code and output. The output is read
+ * for the label and then dropped: only the label ever leaves this function, so a
+ * git error that echoed a URL with a credential in it cannot reach a log.
+ */
+export function classifyPluginFailure(result) {
+    if (result.code === 124)
+        return "timed_out";
+    const text = `${result.stderr}\n${result.stdout}`.toLowerCase();
+    if (/unknown (sub)?command|unrecognized (sub)?command|unexpected argument|no such (sub)?command|invalid subcommand|unknown option/u.test(text))
+        return "cli_too_old";
+    if (/authentication failed|could not read (username|password)|permission denied \(publickey|repository not found|terminal prompts disabled|invalid username or password|bad credentials|not logged in|returned error: (401|403|404)|access denied|saml|single sign-on/u.test(text))
+        return "private_repo_auth";
+    if (/could not resolve host|network is unreachable|failed to connect|connection (timed out|refused|reset)|econn(reset|refused)|enotfound|etimedout|eai_again|temporary failure in name resolution|ssl|tls|early eof|remote end hung up/u.test(text))
+        return "network_unreachable";
+    if (/plugin .*(not found|does not exist)|not found in (any )?marketplace|no plugin named|marketplace .*not found/u.test(text))
+        return "plugin_not_in_marketplace";
+    return "command_failed";
+}

package/dist/autostart-darwin-plist.js

@@ -1,7 +1,7 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths } from "./local-state.js";
+import { isDefaultDashboardUrl, getCollectorRuntimePaths } from "./local-state.js";
 import { savedDiscoveryLimitArgs } from "./discovery-limits.js";
 import { DARWIN_LOGIN_SHELL } from "./autostart-node-path.js";
 import { AUTOSTART_LABEL, fileExists, plistPathFor, resolveAutostartSettings, schedulerNodeExecutable, } from "./autostart-contract.js";
@@ -211,7 +211,7 @@ function watchPathsBlock(watchPaths) {
     ];
 }
 function renderDarwinSyncCommand(options) {
-    const dashboardArg = options.dashboardUrl === DEFAULT_DASHBOARD_URL
+    const dashboardArg = isDefaultDashboardUrl(options.dashboardUrl)
         ? ""
         : ` --dashboard-url ${shellQuote(options.dashboardUrl)}`;
     const discoveryArg = options.discoveryArgs.length > 0 ? ` ${options.discoveryArgs.join(" ")}` : "";

package/dist/autostart-windows-scripts.js

@@ -1,7 +1,7 @@
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths } from "./local-state.js";
+import { isDefaultDashboardUrl, getCollectorRuntimePaths } from "./local-state.js";
 import { savedDiscoveryLimitArgs } from "./discovery-limits.js";
 import { fileExists, resolveAutostartSettings, schedulerNodeExecutable, WINDOWS_AUTOSTART_TASK_NAME, } from "./autostart-contract.js";
 /**
@@ -271,7 +271,7 @@ function renderWindowsLauncherScript(options) {
     ].join("\r\n");
 }
 function renderWindowsSyncScript(options) {
-    const dashboardArgs = options.dashboardUrl === DEFAULT_DASHBOARD_URL
+    const dashboardArgs = isDefaultDashboardUrl(options.dashboardUrl)
         ? ""
         : ` --dashboard-url ${powershellLiteral(options.dashboardUrl)}`;
     const discoveryArgs = options.discoveryArgs.length > 0 ? ` ${options.discoveryArgs.join(" ")}` : "";

package/dist/commands/agent-door.js

@@ -57,6 +57,41 @@ export async function askAgentDoor(door, options) {
     }
     return { ok: true, httpStatus: result.response.status, body };
 }
+/**
+ * A GET whose answer is a FILE (ticket 20694, `cockpit docs export`): the bytes
+ * come back untouched, never through a JSON or text decode. A refusal keeps the
+ * door's own `reason` and `message`, exactly as `askAgentDoor` does.
+ */
+export async function fetchAgentDoorFile(door, options) {
+    const result = await towerRequest({
+        dashboardUrl: door.dashboardUrl,
+        path: options.path,
+        deviceToken: door.deviceToken,
+        fetch: door.io.fetch,
+        method: "GET",
+        label: options.label,
+        timeoutMs: options.timeoutMs,
+        ...(door.homeDir === undefined ? {} : { homeDir: door.homeDir }),
+        log: (line) => writeLine(door.io.stderr, line),
+    });
+    if (!result.ok) {
+        const failure = result;
+        return { ok: false, reason: failure.reason, detail: towerFailureDetail(failure.reason, failure.detail) };
+    }
+    if (!result.response.ok) {
+        const status = result.response.status;
+        const body = await readResponseJson(result.response);
+        return {
+            ok: false,
+            reason: doorReason(body) ?? `http_${status}`,
+            detail: doorMessage(body) ?? `Tower answered ${status} and said nothing about why.`,
+        };
+    }
+    const bytes = Buffer.from(await result.response.arrayBuffer());
+    const disposition = result.response.headers.get("content-disposition") ?? "";
+    const filename = /filename="([^"]+)"/.exec(disposition)?.[1] ?? null;
+    return { ok: true, bytes, filename, contentType: result.response.headers.get("content-type") ?? "" };
+}
 /** The door's own `reason` label (`document_not_found_or_unreadable`, `needs_rls_client`, …), verbatim. */
 function doorReason(body) {
     if (!body || typeof body !== "object")

package/dist/commands/approvals.js

@@ -232,4 +232,6 @@ async function readJsonObject(door, verb) {
         return { ok: false, reason: "invalid_json_body", detail: "stdin must be one JSON object, like {\"text\":\"...\"}. Nothing was sent." };
     }
     return { ok: true, value: parsed };
-}
+}
+// BLI-19259: `cockpit drills` is re-exported here so `local.ts` (at the readability ceiling) imports both on one line.
+export { runDrills } from "./drills.js";

package/dist/commands/brain.js

@@ -2,6 +2,27 @@ import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor } from "./age
 import { writeLine } from "./cli-io.js";
 const TAG = "[brain cli]";
 const READ_DEADLINE_MS = 55_000;
+async function runLadder(door, ladder, json) {
+    const base = "/api/brain/ladder";
+    const request = (() => {
+        switch (ladder.verb) {
+            case "show": return { path: base, method: "GET", label: "brain ladder show" };
+            case "promote": return { path: `${base}/promote`, method: "POST", label: "brain ladder promote", body: { class: ladder.className, anyway: ladder.anyway, note: ladder.note, via: "cli" } };
+            case "demote": return { path: `${base}/demote`, method: "POST", label: "brain ladder demote", body: { class: ladder.className, note: ladder.note, via: "cli" } };
+            case "predict": return { path: `${base}/predictions`, method: "POST", label: "brain ladder predict", body: { question: ladder.text, context: ladder.context, asker: ladder.asker, source_kind: ladder.sourceKind, source_ref: ladder.sourceRef } };
+            case "answer": return { path: `${base}/answers`, method: "POST", label: "brain ladder answer", body: { answer: ladder.text, prediction_id: ladder.predictionId, source_kind: ladder.sourceKind, source_ref: ladder.sourceRef } };
+        }
+    })();
+    const answer = await askAgentDoor(door, { path: request.path, method: request.method, label: request.label, timeoutMs: READ_DEADLINE_MS, ...(request.body ? { body: request.body } : {}) });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const body = answer.body;
+    writeLine(door.io.stderr, `${TAG} ladder ${ladder.verb} answered ${JSON.stringify({ ok: body.ok !== false, reason: body.reason ?? "ok" })}`);
+    if (json)
+        return emitAgentDoor(door, body, body.ok === false ? 1 : 0);
+    writeLine(door.io.stdout, body.text ?? body.message ?? "");
+    return body.ok === false ? 1 : 0;
+}
 export async function runBrain(command, io) {
     let door;
     try {
@@ -16,6 +37,8 @@ export async function runBrain(command, io) {
             writeLine(io.stderr, detail);
         return 1;
     }
+    if (command.ladder)
+        return runLadder(door, command.ladder, command.json);
     if (command.action === "retry") {
         const answer = await askAgentDoor(door, { path: "/api/brain/incidents/retry", method: "POST", label: "brain retry", timeoutMs: READ_DEADLINE_MS,
             body: { ids: command.ids, all_needs_human: command.allNeedsHuman, project: command.project, reason: command.reason } });

package/dist/commands/ci.js

@@ -0,0 +1,23 @@
+import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+import { parseNamedArgs, optionalNonEmpty, optionalUrl } from "./local-arg-values.js";
+export function parseCiArgs(args) {
+    const values = parseNamedArgs(args, { allowedFlags: ["--repo", "--json", "--home", "--dashboard-url"], valueFlags: ["--repo", "--home", "--dashboard-url"] });
+    const repo = values.flags.get("--repo");
+    if (values.positionals.length !== 1 || values.positionals[0] !== "report" || (repo !== undefined && !/^BLI-INC\/[A-Za-z0-9_.-]+$/.test(repo)))
+        throw new Error("Usage: cockpit ci report [--repo BLI-INC/name] [--json]");
+    return { kind: "ci", action: "report", repo, json: values.booleans.has("--json"), homeDir: optionalNonEmpty(values.flags.get("--home")), dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")) };
+}
+export async function runCi(command, io) {
+    const door = await openAgentDoor("ci", command, io);
+    const query = command.repo ? `?${new URLSearchParams({ repo: command.repo })}` : "";
+    const answer = await askAgentDoor(door, { path: `/api/ops/ci/report${query}`, method: "GET", label: "ci report", timeoutMs: 30_000 });
+    if (!answer.ok)
+        return failAgentDoor(door, "[ci cli]", answer.reason, answer.detail);
+    if (command.json)
+        return emitAgentDoor(door, answer.body);
+    const body = answer.body;
+    for (const line of body.lines)
+        writeLine(io.stdout, line);
+    return 0;
+}

package/dist/commands/docs-export.js

@@ -0,0 +1,62 @@
+/**
+ * `cockpit docs export <id|slug> [--format md|pdf|docx|txt] [--out <path>]`
+ * (ticket 20694). A sibling of `docs.ts`: one verb, one door.
+ *
+ * `GET /api/docs/documents/[id]/export?format=` is the same door the browser's
+ * Export menu calls. The bytes are written untouched; the filename is the one
+ * the door chose (a slug of the title plus the extension) unless `--out` names
+ * another. `cockpit docs read` already covers "copy": it prints the Markdown.
+ */
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { emitAgentDoor, failAgentDoor, fetchAgentDoorFile } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+import { resolveDocId } from "./docs.js";
+const TAG = "[docs cli]";
+const EXPORT_DEADLINE_MS = 90_000;
+async function isDirectory(target) {
+    try {
+        return (await stat(target)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export async function exportDoc(command, door) {
+    const ref = command.docRef ?? "";
+    const format = command.exportFormat ?? "md";
+    const resolved = await resolveDocId(door, ref);
+    if (resolved.status === "list_failed")
+        return failAgentDoor(door, TAG, resolved.reason, resolved.detail);
+    if (resolved.status === "not_found") {
+        return failAgentDoor(door, TAG, "document_not_found_or_unreadable", `That document does not exist, or you cannot read it: ${ref}`);
+    }
+    const started = Date.now();
+    const answer = await fetchAgentDoorFile(door, {
+        path: `/api/docs/documents/${encodeURIComponent(resolved.id)}/export?format=${encodeURIComponent(format)}`,
+        label: "docs export",
+        timeoutMs: EXPORT_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const filename = path.basename(answer.filename ?? `${ref}.${format}`);
+    let target = path.resolve(process.cwd(), filename);
+    if (command.outPath) {
+        const asked = path.resolve(command.outPath);
+        const wantsDirectory = /[\\/]$/.test(command.outPath) || (await isDirectory(asked));
+        target = wantsDirectory ? path.join(asked, filename) : asked;
+    }
+    try {
+        await mkdir(path.dirname(target), { recursive: true });
+        await writeFile(target, answer.bytes);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return failAgentDoor(door, TAG, "export_write_failed", `Could not write ${target}: ${detail}`);
+    }
+    writeLine(door.io.stderr, `${TAG} export ${JSON.stringify({ document_id: resolved.id, format, bytes: answer.bytes.length, duration_ms: Date.now() - started })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, path: target, bytes: answer.bytes.length, format });
+    writeLine(door.io.stdout, target);
+    return 0;
+}

package/dist/commands/docs.js

@@ -30,6 +30,7 @@
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
 import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
 import { readDoc } from "./docs-read.js";
+import { exportDoc } from "./docs-export.js";
 import { linkDoc, syncStatusDocs } from "./docs-notion.js";
 import { readNoteFile } from "./notes-file.js";
 import { cacheAgeLabel, cacheCoverage, readThroughCache } from "./read-cache.js";
@@ -56,6 +57,8 @@ export async function runDocs(command, io) {
             return linkDoc(command, door);
         case "sync-status":
             return syncStatusDocs(command, door);
+        case "export":
+            return exportDoc(command, door);
     }
 }
 /** `--parent`, `--query`, `--word`, `--limit`, `--bodies` (BLI-10450) as the door's own query parameters (BLI-3737). */

package/dist/commands/doctor-access.js

@@ -4,7 +4,7 @@ import { scanWorkDirectories } from "./local-discovery.js";
 import { sendCollectorHeartbeatBestEffort } from "./heartbeat.js";
 import { isInteractiveDoctorFix } from "./doctor-report.js";
 import { describeError } from "../health-detail.js";
-import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, readLocalCollectorConfig, readLocalCollectorSessionFile, toSessionReference, } from "../local-state.js";
+import { isDefaultDashboardUrl, getCollectorRuntimePaths, readLocalCollectorConfig, readLocalCollectorSessionFile, toSessionReference, } from "../local-state.js";
 import { normalizeCollectionRoots } from "../root-normalization.js";
 import { detectSecondCockpitInstall } from "../second-install.js";
 import { hardStop, needsFix, ok, skipped } from "./doctor-report.js";
@@ -140,7 +140,7 @@ export async function savedRoots(homeDir) {
 }
 function onboardOneLiner(command) {
     const workspace = command.repoRoot ?? "$PWD";
-    const dashboard = command.dashboardUrl === DEFAULT_DASHBOARD_URL
+    const dashboard = isDefaultDashboardUrl(command.dashboardUrl)
         ? ""
         : ` --dashboard-url ${shellQuote(command.dashboardUrl)}`;
     return `cockpit doctor --workspace ${shellQuote(workspace)}${dashboard}`;

package/dist/commands/doctor-agent-plugins.js

@@ -0,0 +1,82 @@
+/**
+ * The `agent-plugins` doctor row (BLI-18200): does this machine carry the
+ * company `engineering-standards` plugin in Claude Code and in Codex?
+ *
+ * The CHECK reads the two hosts' own files and the last attempt's remembered
+ * reason; it never starts a program, so `cockpit doctor --check` is free. The
+ * FIX runs the host commands through `agent-plugins-converge.ts` and answers by
+ * re-reading what the hosts recorded. A tick runs the fix too (the doctor the
+ * sync runs after collection), throttled to one retry per six hours; a person
+ * running `cockpit doctor` always retries.
+ *
+ * Never blocks anything else: a missing program is `skipped`, every other
+ * failure is a named reason on this row alone.
+ */
+import os from "node:os";
+import { AGENT_PLUGIN_NAME, AGENT_PLUGIN_SOURCE, inspectAgentPlugins, locateHostBinary, } from "../agent-plugins.js";
+import { convergeAgentPlugins, readPluginState } from "../agent-plugins-converge.js";
+import { getCollectorRuntimePaths } from "../local-state.js";
+import { needsFix, ok, skipped } from "./doctor-report.js";
+const ID = "agent-plugins";
+/** Worst first: the row names the reason a person can act on before the one that heals itself. */
+const REASON_PRIORITY = ["private_repo_auth", "cli_too_old", "plugin_not_in_marketplace", "install_not_recorded", "command_failed", "timed_out", "network_unreachable", "missing"];
+const SENTENCES = {
+    missing: { say: (hosts) => `the company ${AGENT_PLUGIN_NAME} plugin is not installed for ${hosts}; \`cockpit doctor\` installs it`, next: "cockpit doctor" },
+    private_repo_auth: {
+        say: (hosts) => `Tower could not read the company plugin repository ${AGENT_PLUGIN_SOURCE} for ${hosts}: GitHub sign-in or BLI-INC access is missing. Run \`gh auth login\` with your company account, then \`cockpit doctor\``,
+        next: "gh auth login",
+    },
+    cli_too_old: { say: (hosts) => `the installed ${hosts} program is too old to manage plugins; update it, then run \`cockpit doctor\``, next: "cockpit doctor" },
+    plugin_not_in_marketplace: { say: (hosts) => `the company marketplace did not offer ${AGENT_PLUGIN_NAME} for ${hosts}; ask in the engineering channel, then run \`cockpit doctor\``, next: "cockpit doctor" },
+    install_not_recorded: { say: (hosts) => `the install for ${hosts} ran but the program did not record it; run \`cockpit doctor\` again`, next: "cockpit doctor" },
+    command_failed: { say: (hosts) => `the plugin install for ${hosts} failed; run \`cockpit doctor\` to retry`, next: "cockpit doctor" },
+    timed_out: { say: (hosts) => `the plugin install for ${hosts} timed out; Tower retries on its own, or run \`cockpit doctor\``, next: "cockpit doctor" },
+    network_unreachable: { say: (hosts) => `the plugin install for ${hosts} could not reach GitHub; Tower retries on its own, or run \`cockpit doctor\``, next: "cockpit doctor" },
+};
+function homeOf(context) {
+    return context.command.homeDir ?? os.homedir();
+}
+/** `runtime` is for tests: a Windows layout, a fake file system. */
+export async function checkAgentPluginsState(context, runtime = {}) {
+    const homeDir = homeOf(context);
+    const present = (await inspectAgentPlugins(homeDir, runtime)).filter((reading) => reading.present);
+    if (present.length === 0) {
+        return skipped(ID, "no_agent_hosts", "neither Claude Code nor Codex is set up on this machine yet; Tower installs the company plugin once one is");
+    }
+    const missing = present.filter((reading) => !reading.installed);
+    if (missing.length === 0) {
+        return ok(ID, "installed", `the company ${AGENT_PLUGIN_NAME} plugin is installed for ${present.map((reading) => reading.host).join(", ")}`);
+    }
+    const remembered = await readPluginState(getCollectorRuntimePaths(context.command.homeDir).state_dir);
+    const reasons = new Map();
+    for (const reading of missing) {
+        const binary = await locateHostBinary(reading.host, homeDir, runtime);
+        reasons.set(reading.host, binary ? remembered[reading.host]?.last_reason ?? "missing" : "binary_missing");
+    }
+    // A remembered label this table does not know reads as a plain command failure.
+    const actionable = [...reasons].filter(([, reason]) => reason !== "binary_missing").map(([host, reason]) => ({ host, reason: REASON_PRIORITY.includes(reason) ? reason : "command_failed" }));
+    if (actionable.length === 0) {
+        return skipped(ID, "binary_missing", `${[...reasons.keys()].join(", ")} is set up but its program was not found; the plugin installs once it is`);
+    }
+    const code = REASON_PRIORITY.find((reason) => actionable.some((entry) => entry.reason === reason));
+    const hosts = actionable.filter((entry) => entry.reason === code).map((entry) => entry.host).join(" and ");
+    const sentence = SENTENCES[code];
+    return { ...needsFix(ID, code, sentence.say(hosts)), nextAction: sentence.next };
+}
+export async function fixAgentPluginsState(context, runtime = {}) {
+    const exec = context.io.exec;
+    if (!exec) {
+        console.error("[agent-plugins] no process runner on this io; the install could not be attempted", JSON.stringify({ reason: "runner_unavailable" }));
+        return needsFix(ID, "runner_unavailable", "this CLI has no process runner; reinstall it with `npm i -g @bli-cockpit/cli`, then run `cockpit doctor`");
+    }
+    const outcomes = await convergeAgentPlugins({
+        ...runtime,
+        homeDir: homeOf(context),
+        stateDir: getCollectorRuntimePaths(context.command.homeDir).state_dir,
+        exec,
+        unattended: Boolean(context.command.automaticTick),
+        refresh: false,
+    });
+    console.error("[agent-plugins] doctor repair done", JSON.stringify({ reason: "repair_done", outcomes: outcomes.map((outcome) => `${outcome.host}:${outcome.reason}`) }));
+    return checkAgentPluginsState(context, runtime);
+}