@bli-cockpit/cli 0.2.56 → 0.2.58

package/dist/commands/memory-install.js

@@ -13,38 +13,43 @@
  *   memory-install-claude.ts   ~/.claude.json (user-scope MCP) + ~/.claude/settings.json (hooks, allow-list)
  *   memory-install-codex.ts    ~/.codex/config.toml (one table) + ~/.codex/skills/bli-memory/
  *
- * What this module owns is the decisions around them:
+ * What this module owns is the top-level decision sequence
+ * (BLI-3717 readability pass, 629 lines to a table of contents). Every other
+ * responsibility lives in a `memory-install-*.ts` sibling:
+ *
+ *  - `memory-install-config.ts` — finding `bli-memory-mcp` on this machine
+ *    (`resolveMemoryMcpBin`, over the shared `mcp-bin-resolve.ts` walk) and
+ *    deciding which config shape to write (`resolveMemoryConfig`). **No
+ *    server, no write.** If the bin does not resolve, not one file is opened
+ *    and the outcome is `skipped bin_missing` — see `no_bin_no_write` there
+ *    for why a written-but-inert registration is the worse option.
+ *    `--print-config --claude` wins when the bin answers it; the built-in
+ *    template of the same shape is the fallback for an older server, and it
+ *    is only ever used with a bin that actually resolved.
+ *  - `memory-install-report.ts` — the dashboard URL, aggregating per-target
+ *    results into one outcome, and rendering it for a log line or a
+ *    terminal.
+ *
+ * Two rules bind the whole sequence:
  *
- * - **Where the server is.** `bli-memory-mcp` ships as a DEPENDENCY of
- *   `@bli-cockpit/cli`, so the canonical lookup is the `node_modules/.bin` on
- *   the way up from THIS MODULE's own file — realpath-ed first, because a
- *   global `cockpit` is a symlink and walking up from the symlink finds
- *   nothing; PATH is the fallback. Nobody ever installs a second global
- *   package. See `resolveMemoryMcpBin`, which carries the receipt.
- * - **No server, no write.** If the bin does not resolve, not one file is
- *   opened and the outcome is `skipped bin_missing` — see `no_bin_no_write`
- *   below for why a written-but-inert registration is the worse option.
- * - **Which config shape.** `bli-memory-mcp --print-config --claude` wins when
- *   the bin answers it; the built-in template of the same shape is the
- *   fallback for an older server, and it is only ever used with a bin that
- *   actually resolved.
  * - **Never throw at the caller.** The sync tick calls this. A failure is a
  *   named receipt, never an exception that could cost a machine its
  *   collection tick.
  * - **Never claim an install it did not read back** (BLI-2541). Both halves
  *   re-read and re-parse; this module only aggregates what they proved.
+ *
+ * Every public name is still importable from this file.
  */
-import fs from "node:fs";
 import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { writeLine } from "./cli-io.js";
-import { builtinMemoryInstallConfig, isUnsafeBinPath, MEMORY_MCP_BIN, parsePrintedMemoryInstallConfig, withResolvedBinPath, } from "./memory-install-contract.js";
+import { installTowerIntegration, inspectTowerIntegration } from "./tower-mcp-install.js";
 import { defaultMemoryFileIo, } from "./memory-install-files.js";
 import { installClaudeMemoryIntegration, inspectClaudeMemoryIntegration, } from "./memory-install-claude.js";
 import { installCodexMemoryIntegration, inspectCodexMemoryIntegration, } from "./memory-install-codex.js";
-import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, readLocalCollectorConfig, } from "../local-state.js";
-import { envWithNodeRuntimeOnPath } from "../scheduled-self-update.js";
+import { resolveMemoryConfig } from "./memory-install-config.js";
+import { aggregate, logMemoryOutcome, memoryOutcomeLines, resolveDashboardUrl } from "./memory-install-report.js";
+export { resolveMemoryMcpBin } from "./memory-install-config.js";
+export { memoryOutcomeLines, resolveDashboardUrl } from "./memory-install-report.js";
 export async function runMemoryInstall(command, io, deps = {}) {
     const outcome = command.action === "status"
         ? await inspectMemoryIntegration(command, io, deps)
@@ -80,6 +85,21 @@ export async function installMemoryIntegration(command, io, deps = {}) {
             io: fileIo,
         })));
     }
+    // BLI-3706: `bli-tower` (docs_*/msg_* over the collector device token)
+    // registers beside `bli-memory` on the SAME command — see
+    // tower-mcp-install.ts's header for why this rides here rather than a
+    // separate, un-invoked verb. Independent of the memory outcome above: a
+    // machine with one server but not the other is a real machine.
+    targets.push(...(await installTowerIntegration({
+        io: fileIo,
+        platform,
+        homeDir,
+        dashboardUrl: await resolveDashboardUrl(command, deps),
+        env: io.env ?? process.env,
+        fileExists: deps.fileExists,
+        cliEntryPoint: deps.cliEntryPoint,
+        realpath: deps.realpath,
+    }, command.dryRun)));
     const outcome = {
         action: "install",
         ...aggregate(targets),
@@ -112,6 +132,17 @@ export async function inspectMemoryIntegration(command, io, deps = {}) {
             io: fileIo,
         })));
     }
+    // BLI-3706: see the matching note in `installMemoryIntegration`.
+    targets.push(...(await inspectTowerIntegration({
+        io: fileIo,
+        platform,
+        homeDir,
+        dashboardUrl: await resolveDashboardUrl(command, deps),
+        env: io.env ?? process.env,
+        fileExists: deps.fileExists,
+        cliEntryPoint: deps.cliEntryPoint,
+        realpath: deps.realpath,
+    })));
     return {
         action: "status",
         ...aggregate(targets),
@@ -120,346 +151,4 @@ export async function inspectMemoryIntegration(command, io, deps = {}) {
         ...(resolved.bin_source ? { bin_source: resolved.bin_source } : {}),
         targets,
     };
-}
-/**
- * **`no_bin_no_write`.** When `bli-memory-mcp` cannot be resolved, this command
- * writes NOTHING — not the MCP entry, not the hooks, not the Codex table, not
- * the skills.
- *
- * An earlier revision wrote the registration anyway, on the reasoning that a
- * correct shape waiting for the package is better than nothing. It is not:
- * Claude Code RUNS a registered hook. Three hooks pointing at a binary that
- * does not exist would print a hook failure on every SessionStart, every
- * prompt and every Stop, on every intern machine, until the package shipped —
- * a self-inflicted outage in the one surface people look at all day.
- *
- * So an absent bin is `skipped bin_missing`: a receipt, not a write. The daily
- * self-heal retries tomorrow, and the first tick after the package lands does
- * the whole registration at once.
- */
-async function resolveMemoryConfig(command, io, platform, deps) {
-    const dashboardUrl = await resolveDashboardUrl(command, deps);
-    const found = await resolveMemoryMcpBin({
-        env: envWithNodeRuntimeOnPath(io.env ?? process.env),
-        platform,
-        fileExists: deps.fileExists,
-        cliEntryPoint: deps.cliEntryPoint,
-        realpath: deps.realpath,
-    });
-    if (!found) {
-        return {
-            config: null,
-            source: "none",
-            binTarget: {
-                target: "bin",
-                status: "skipped",
-                reason: "bin_missing",
-                detail: `${MEMORY_MCP_BIN} is not installed beside this CLI or on PATH; nothing was written, and the next daily run will try again`,
-            },
-        };
-    }
-    if (isUnsafeBinPath(found.path)) {
-        // A hook command is a shell string by the platform's design. A path that
-        // cannot be quoted safely is not escaped cleverly, and it is not swapped
-        // for a bare name that may resolve to something else either — the install
-        // refuses and says why.
-        return {
-            config: null,
-            source: "none",
-            binTarget: {
-                target: "bin",
-                status: "failed",
-                reason: "bin_path_unsafe",
-                detail: "the resolved bin path contains characters that cannot appear in a hook command; nothing was written",
-            },
-            bin_source: found.source,
-        };
-    }
-    const printed = await printedMemoryConfig(io, found.path);
-    if (printed) {
-        // The bin prints a BARE command name — it cannot know where it was
-        // installed, and it is nested inside the CLI's node_modules rather than on
-        // PATH. Path-qualifying it here is what makes the registration runnable at
-        // all; see `withResolvedBinPath`.
-        const qualified = withResolvedBinPath(printed, {
-            binPath: found.path,
-            platform,
-            dashboardUrl,
-        });
-        if (qualified) {
-            return {
-                config: qualified,
-                source: "bin",
-                binTarget: { target: "bin", status: "already", reason: "bin_printed_config" },
-                bin_source: found.source,
-            };
-        }
-        // A printed hook command this installer cannot re-point. The template is
-        // always path-qualified, so it is the safe answer — and the reason says
-        // which of the two fallbacks happened.
-        return {
-            config: builtinMemoryInstallConfig({ binPath: found.path, platform, dashboardUrl }),
-            source: "template",
-            binTarget: {
-                target: "bin",
-                status: "already",
-                reason: "bin_printed_config_unqualifiable",
-                detail: "the bin printed a hook command this installer could not re-point at the resolved path; the built-in shape was used",
-            },
-            bin_source: found.source,
-        };
-    }
-    return {
-        config: builtinMemoryInstallConfig({
-            binPath: found.path,
-            platform,
-            dashboardUrl,
-        }),
-        source: "template",
-        binTarget: {
-            target: "bin",
-            status: "already",
-            reason: "bin_present_template_used",
-            detail: "the bin did not print a usable --print-config; the built-in shape was used",
-        },
-        bin_source: found.source,
-    };
-}
-/**
- * Asks the server for its own shape. Arguments go as an ARRAY — nothing is
- * interpolated into a command line — and on Windows the captured runner routes
- * a `.cmd` shim through ComSpec with its own escaping (process-runner.ts).
- */
-async function printedMemoryConfig(io, binPath) {
-    const exec = io.exec;
-    if (!exec)
-        return null;
-    try {
-        const result = await exec(binPath, ["--print-config", "--claude"]);
-        if (result.code !== 0)
-            return null;
-        return parsePrintedMemoryInstallConfig(result.stdout);
-    }
-    catch {
-        // Deliberately silent here: the caller reports
-        // `bin_present_template_used`, which is the same information with a name
-        // on it, and this path is reached on every machine that has an older bin.
-        return null;
-    }
-}
-/**
- * Two steps, in this order, and the first is the canonical one.
- *
- * **1. Beside the CLI that is running.** `bli-memory-mcp` ships as a DEPENDENCY
- * of `@bli-cockpit/cli`, so installing the CLI installs the server, and npm
- * links its bin into a `node_modules/.bin` on the path from this package up to
- * the install root — `…/@bli-cockpit/cli/node_modules/.bin` when it is nested,
- * `…/lib/node_modules/.bin` when npm hoists it. It is the ONLY lookup that
- * cannot find somebody else's `bli-memory-mcp`. Nobody ever runs `npm i -g` for
- * a second package.
- *
- * **2. PATH, as a fallback**, for a linked checkout or a hand-installed server.
- * Done in this process rather than through `which`/`where`: it spawns nothing,
- * behaves the same on both host families, and is testable without a fixture
- * binary. The npm global bin sits beside the running node binary in the
- * standard layouts, which is why the caller passes a PATH that already includes
- * it (`envWithNodeRuntimeOnPath`) — the launchd tick's PATH is otherwise
- * `/usr/bin:/bin:/usr/sbin:/sbin` and would find nothing.
- *
- * **What step 1 got wrong on the first real machine** (BLI-3580, CLI 0.2.50):
- * it walked up from `process.argv[1]`, resolved with `path.resolve` and no
- * symlink following. For a global install `argv[1]` is the SHIM — on Edward's
- * Mac `/opt/homebrew/bin/cockpit`, a symlink into
- * `/opt/homebrew/lib/node_modules/@bli-cockpit/cli/dist/cli.js`. The walk
- * therefore started in `/opt/homebrew/bin`, went up through `/opt` to `/`, and
- * never came within reach of the nested `.bin` that was sitting right there.
- * Every machine reported `skipped bin_missing` with the server installed.
- *
- * Two changes, both in `besideAnchors` / `resolveBesideCli`:
- *
- *  - The anchor is **this module's own file** first (`import.meta.url`), which
- *    is inside the installed package by construction and is never a shim. The
- *    entry point (injected, or `argv[1]`) stays as a second anchor for a build
- *    layout where this module has been bundled somewhere else.
- *  - Every anchor is **realpath-ed** before the walk, so a symlinked entry
- *    lands in the real tree. A path that will not resolve is used as given —
- *    the same bounded silence `container-tag.ts` uses, because a path that
- *    cannot be realpath-ed still identifies a directory well enough to look in.
- */
-export async function resolveMemoryMcpBin(options) {
-    const exists = options.fileExists ?? defaultFileExists;
-    const beside = await resolveBesideCli(options, exists);
-    if (beside)
-        return { path: beside, source: "cli_dependency" };
-    const onPath = await resolveOnPath(options, exists);
-    return onPath ? { path: onPath, source: "path" } : null;
-}
-/**
- * Where to start walking, in order of trustworthiness. This module's own
- * location first: it is inside the installed package and cannot be a shim.
- */
-function besideAnchors(options) {
-    const anchors = [];
-    const own = currentModulePath();
-    if (own)
-        anchors.push(own);
-    const entry = options.cliEntryPoint ?? process.argv[1];
-    if (entry)
-        anchors.push(entry);
-    return anchors;
-}
-function currentModulePath() {
-    try {
-        return fileURLToPath(import.meta.url);
-    }
-    catch {
-        // A bundler that dropped `import.meta` support. The entry-point anchor
-        // still covers it, so this is a narrowing rather than a failure.
-        return null;
-    }
-}
-async function resolveBesideCli(options, exists) {
-    const platformPath = options.platform === "win32" ? path.win32 : path.posix;
-    const extensions = binExtensions(options.platform);
-    const realpath = options.realpath ?? defaultRealpath;
-    for (const anchor of besideAnchors(options)) {
-        let directory = platformPath.dirname(realpath(platformPath.resolve(anchor)));
-        // Bounded walk: deep enough for `…/node_modules/@scope/pkg/dist/cli.js`
-        // plus a hoisted root above it, and it stops at the filesystem root anyway.
-        for (let depth = 0; depth < 12; depth += 1) {
-            for (const extension of extensions) {
-                const candidate = platformPath.join(directory, "node_modules", ".bin", `${MEMORY_MCP_BIN}${extension}`);
-                if (await exists(candidate))
-                    return candidate;
-            }
-            const parent = platformPath.dirname(directory);
-            if (parent === directory)
-                break;
-            directory = parent;
-        }
-    }
-    return null;
-}
-/**
- * `realpathSync.native` follows the symlink npm writes for a global bin. A
- * path that does not resolve — a Windows path being reasoned about from a Mac
- * in a test, a directory that has since moved — comes back unchanged rather
- * than throwing, because the walk above can still look inside it.
- */
-function defaultRealpath(value) {
-    try {
-        return fs.realpathSync.native(value);
-    }
-    catch {
-        return value;
-    }
-}
-async function resolveOnPath(options, exists) {
-    // The TARGET platform's path rules, not the running one's. On a real machine
-    // they are the same; asking for them explicitly is what lets the Windows
-    // lookup be tested from a Mac, which is the only Windows proof this repo
-    // gets before a release (AGENTS.md, supported fleet).
-    const platformPath = options.platform === "win32" ? path.win32 : path.posix;
-    const entries = (options.env["PATH"] ?? options.env["Path"] ?? "")
-        .split(platformPath.delimiter)
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-    for (const entry of entries) {
-        for (const extension of binExtensions(options.platform)) {
-            const candidate = platformPath.join(entry, `${MEMORY_MCP_BIN}${extension}`);
-            if (await exists(candidate))
-                return candidate;
-        }
-    }
-    return null;
-}
-/** npm writes `.cmd` (and `.ps1`) shims on Windows; POSIX gets the bare name. */
-function binExtensions(platform) {
-    return platform === "win32" ? [".cmd", ".exe", ".bat", ""] : [""];
-}
-async function defaultFileExists(file) {
-    const { stat } = await import("node:fs/promises");
-    try {
-        return (await stat(file)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-async function resolveDashboardUrl(command, deps) {
-    if (command.dashboardUrl)
-        return command.dashboardUrl;
-    const paths = getCollectorRuntimePaths(deps.homeDir ?? command.homeDir);
-    const config = await readLocalCollectorConfig(paths).catch(() => null);
-    return config?.dashboard_url ?? DEFAULT_DASHBOARD_URL;
-}
-function aggregate(targets) {
-    const failed = targets.filter((target) => target.status === "failed");
-    if (failed.length > 0) {
-        return {
-            status: "failed",
-            // The first named reason, not a count: an operator needs the reason, and
-            // the per-target list beside it carries the rest.
-            reason: failed[0]?.reason ?? "unknown_failure",
-        };
-    }
-    if (targets.some((target) => target.status === "would_install")) {
-        return { status: "would_install", reason: "dry_run" };
-    }
-    if (targets.some((target) => target.status === "installed")) {
-        return { status: "installed", reason: "wrote_entry" };
-    }
-    if (targets.some((target) => target.status === "mismatch" || target.status === "missing")) {
-        return { status: "missing", reason: "entry_absent" };
-    }
-    const skipped = targets.find((target) => target.status === "skipped");
-    if (skipped) {
-        // Not a failure and not a success: nothing was written, on purpose, and
-        // the next daily run will try again. `bin_missing` is the only one today.
-        return { status: "skipped", reason: skipped.reason };
-    }
-    return { status: "already", reason: "already_current" };
-}
-/**
- * Both branches log, and neither carries a path — a home directory names a
- * person, and this line ends up in `sync.err.log` on every machine.
- */
-function logMemoryOutcome(outcome, platform) {
-    const fields = {
-        status: outcome.status,
-        reason: outcome.reason,
-        config_source: outcome.config_source,
-        bin_found: outcome.bin_found,
-        platform,
-        installed_count: outcome.targets.filter((target) => target.status === "installed").length,
-        already_count: outcome.targets.filter((target) => target.status === "already").length,
-        failed: outcome.targets
-            .filter((target) => target.status === "failed")
-            .map((target) => `${target.target}:${target.reason}`),
-    };
-    // stderr on both branches: launchd captures it to sync.err.log, and stdout is
-    // reserved for `--json`.
-    console.error(outcome.status === "failed"
-        ? "[memory-install] BLI Memory is not fully registered on this machine"
-        : "[memory-install] BLI Memory registration converged", JSON.stringify(fields));
-}
-export function memoryOutcomeLines(outcome) {
-    const headline = outcome.status === "installed"
-        ? "BLI Memory registered on this machine."
-        : outcome.status === "already"
-            ? "BLI Memory is already registered on this machine."
-            : outcome.status === "would_install"
-                ? "BLI Memory would be registered (dry run; nothing was written)."
-                : outcome.status === "missing"
-                    ? "BLI Memory is not registered on this machine."
-                    : outcome.status === "skipped"
-                        ? "BLI Memory was not registered and nothing was written: the bli-memory-mcp server is not on this machine yet."
-                        : `BLI Memory is not fully registered: ${outcome.reason}.`;
-    const lines = [headline];
-    for (const target of outcome.targets) {
-        const where = target.path ? ` ${target.path}` : "";
-        const detail = target.detail ? ` — ${target.detail}` : "";
-        lines.push(`  ${target.target}: ${target.status} (${target.reason})${where}${detail}`);
-    }
-    return lines;
 }

package/dist/commands/msg.js

@@ -0,0 +1,188 @@
+/**
+ * `cockpit msg` — channels and messages, typed (BLI-3706).
+ *
+ * Four verbs over `/api/msg/**` (BLI-3654 Wave 1a), which already accepts the
+ * collector device token through `resolveCaller({ allowDeviceToken: true })`
+ * on every route — no server-side door change was needed for this terminal.
+ *
+ * `<channel>` is a channel id, or its name with or without a leading `#`,
+ * resolved locally against `GET /api/msg/channels` — exact match only, never
+ * fuzzy, same discipline `docs.ts` uses for a slug.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
+import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
+const TAG = "[msg cli]";
+const READ_DEADLINE_MS = 30_000;
+const WRITE_DEADLINE_MS = 30_000;
+const CONTENT_MAX_CHARS = 8_000;
+export async function runMsg(command, io) {
+    const door = await openAgentDoor("msg", command, io);
+    switch (command.action) {
+        case "channels":
+            return listChannels(door);
+        case "read":
+            return readChannel(command, door);
+        case "send":
+            return sendMessage(command, door);
+        case "thread":
+            return readThread(command, door);
+    }
+}
+async function fetchChannels(door) {
+    const answer = await askAgentDoor(door, {
+        path: "/api/msg/channels",
+        method: "GET",
+        label: "msg channels",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return { ok: false, reason: answer.reason, detail: answer.detail };
+    return { ok: true, channels: answer.body.channels ?? [] };
+}
+async function listChannels(door) {
+    const fetched = await fetchChannels(door);
+    if (!fetched.ok)
+        return failAgentDoor(door, TAG, fetched.reason, fetched.detail);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, channels: fetched.channels });
+    if (fetched.channels.length === 0) {
+        writeLine(door.io.stdout, "No channels.");
+        return 0;
+    }
+    for (const channel of fetched.channels) {
+        const label = channel.is_dm ? "dm" : channel.is_private ? "private" : "public";
+        writeLine(door.io.stdout, `${channel.id}  ${label.padEnd(7)}  ${channel.name ?? "(unnamed)"}`);
+    }
+    return 0;
+}
+/** Exact id, or exact name with or without a leading `#`. Never fuzzy. */
+async function resolveChannelId(door, ref) {
+    const fetched = await fetchChannels(door);
+    if (!fetched.ok)
+        return { status: "list_failed", reason: fetched.reason, detail: fetched.detail };
+    const byId = fetched.channels.find((channel) => channel.id === ref);
+    if (byId)
+        return { status: "ok", id: byId.id };
+    const bare = ref.startsWith("#") ? ref.slice(1) : ref;
+    const byName = fetched.channels.find((channel) => channel.name === bare);
+    if (byName)
+        return { status: "ok", id: byName.id };
+    return { status: "not_found" };
+}
+function channelNotFound(door, ref) {
+    return failAgentDoor(door, TAG, "channel_not_found_or_unreadable", `That channel does not exist, or you cannot read it: ${ref}`);
+}
+async function readChannel(command, door) {
+    const ref = command.channelRef ?? "";
+    const resolved = await resolveChannelId(door, ref);
+    if (resolved.status === "list_failed")
+        return failAgentDoor(door, TAG, resolved.reason, resolved.detail);
+    if (resolved.status === "not_found")
+        return channelNotFound(door, ref);
+    const query = new URLSearchParams();
+    if (command.limit !== undefined)
+        query.set("limit", String(command.limit));
+    if (command.threadId)
+        query.set("thread_parent_id", command.threadId);
+    const rendered = query.toString();
+    const answer = await askAgentDoor(door, {
+        path: `/api/msg/channels/${encodeURIComponent(resolved.id)}/messages${rendered ? `?${rendered}` : ""}`,
+        method: "GET",
+        label: "msg read",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const messages = answer.body.messages ?? [];
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, channelId: resolved.id, messages });
+    if (messages.length === 0) {
+        writeLine(door.io.stdout, "No messages.");
+        return 0;
+    }
+    for (const message of [...messages].reverse()) {
+        const who = message.agent_label ?? message.user_id;
+        writeLine(door.io.stdout, `${message.created_at}  ${who}  ${message.content ?? ""}`);
+    }
+    return 0;
+}
+async function readThread(command, door) {
+    if (!command.channelRef) {
+        return failAgentDoor(door, TAG, "invalid_body", "msg thread needs --channel <channel>.");
+    }
+    const resolved = await resolveChannelId(door, command.channelRef);
+    if (resolved.status === "list_failed")
+        return failAgentDoor(door, TAG, resolved.reason, resolved.detail);
+    if (resolved.status === "not_found")
+        return channelNotFound(door, command.channelRef);
+    const answer = await askAgentDoor(door, {
+        path: `/api/msg/channels/${encodeURIComponent(resolved.id)}/messages?thread_parent_id=${encodeURIComponent(command.threadId ?? "")}`,
+        method: "GET",
+        label: "msg thread",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const messages = answer.body.messages ?? [];
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, channelId: resolved.id, threadParentId: command.threadId, messages });
+    if (messages.length === 0) {
+        writeLine(door.io.stdout, "No replies.");
+        return 0;
+    }
+    for (const message of [...messages].reverse()) {
+        const who = message.agent_label ?? message.user_id;
+        writeLine(door.io.stdout, `${message.created_at}  ${who}  ${message.content ?? ""}`);
+    }
+    return 0;
+}
+async function readContent(io) {
+    if (isInteractiveStdin(io)) {
+        return {
+            ok: false,
+            reason: "nothing_piped",
+            detail: "Pipe the message in, e.g. `echo \"hello\" | cockpit msg send general`. A message never travels on the command line.",
+        };
+    }
+    try {
+        const text = await readPipedText(io.stdin, {
+            maxChars: CONTENT_MAX_CHARS,
+            overflowMessage: `A message is limited to ${CONTENT_MAX_CHARS} characters.`,
+        });
+        return { ok: true, text: text.trim() };
+    }
+    catch (error) {
+        return { ok: false, reason: "content_too_long", detail: error instanceof Error ? error.message : String(error) };
+    }
+}
+async function sendMessage(command, door) {
+    const ref = command.channelRef ?? "";
+    const resolved = await resolveChannelId(door, ref);
+    if (resolved.status === "list_failed")
+        return failAgentDoor(door, TAG, resolved.reason, resolved.detail);
+    if (resolved.status === "not_found")
+        return channelNotFound(door, ref);
+    const content = await readContent(door.io);
+    if (!content.ok)
+        return failAgentDoor(door, TAG, content.reason, content.detail);
+    if (content.text === "")
+        return failAgentDoor(door, TAG, "invalid_body", "There was nothing to send. Nothing was sent.");
+    const answer = await askAgentDoor(door, {
+        path: `/api/msg/channels/${encodeURIComponent(resolved.id)}/messages`,
+        method: "POST",
+        label: "msg send",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: {
+            content: content.text,
+            ...(command.threadId ? { thread_parent_id: command.threadId } : {}),
+        },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const message = answer.body.message ?? null;
+    writeLine(door.io.stderr, `${TAG} sent ${JSON.stringify({ channel_id: resolved.id, message_id: message?.id ?? null, chars: content.text.length })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, message });
+    writeLine(door.io.stdout, `Sent to ${ref} (${message?.id ?? "?"}).`);
+    return 0;
+}