@bli-cockpit/cli 0.2.242 → 0.2.244

package/dist/commands/manager-render-home.js

@@ -83,13 +83,14 @@ export function withTodayLine(rows, dates, today) {
     const line = [todayLine(today)];
     return at === -1 ? [...rows, line] : [...rows.slice(0, at), line, ...rows.slice(at)];
 }
-/** Who wrote the card, by its `source`: the credit's opening words (the day follows; a person's name comes after "Edited by"). */
+/** Who wrote the card, by its `source`: the credit's opening words (the day follows; a person's name comes after "Edited by" and "Written by", then "'s agent" for the agent's card). */
 export const SUMMARY_SOURCE_WORDS = {
     model: "Written by AI",
     computed: "AI unavailable · computed from counts",
     person: "Edited by",
+    agent: "Written by",
 };
-/** Who wrote the card and when: "written by AI", "computed from counts", or "edited by" a person. */
+/** Who wrote the card and when: "written by AI", "computed from counts", "edited by" a person, or "written by" a person's agent. */
 function authorLine(summary, now) {
     // The server's own Vancouver day when it sends one; never worked out here when it did.
     const at = summary.writtenOn ? `${dayWords(summary.writtenOn)} (${ageText(summary.writtenAt, now)})` : when(summary.writtenAt, now);
@@ -98,6 +99,8 @@ function authorLine(summary, now) {
     if (summary.source === "computed")
         return `${SUMMARY_SOURCE_WORDS.computed}, ${at}.`;
     // Never a user id in a person's terminal: the door fills the name, or says "a teammate".
+    if (summary.source === "agent")
+        return `${SUMMARY_SOURCE_WORDS.agent} ${summary.editedByName ?? "a teammate"}'s agent, ${at}.`;
     return `${SUMMARY_SOURCE_WORDS.person} ${summary.editedByName ?? "a teammate"}, ${at}.`;
 }
 const CAP_WORDS = {
@@ -169,8 +172,11 @@ function summaryLines(home, now, color) {
         if (checked !== null && Number.isFinite(new Date(checked).getTime()))
             lines.push(`  Last checked ${ageText(checked, now)}.`);
     }
-    if (summary.inputsChanged && !summary.lastCheckFailed)
-        lines.push("  Inputs changed since: the client's data changed, an action went overdue or an open action passed 14 days overdue (for an AI-written card, also a meeting or milestone came within a week or passed) after this was written; the next check writes it again.");
+    if (summary.inputsChanged && !summary.lastCheckFailed) {
+        lines.push(summary.source === "agent"
+            ? "  Inputs changed since: the client's data changed, an action went overdue or an open action passed 14 days overdue after this was written; Tower's check leaves the agent's card, so the agent or a person writes it again."
+            : "  Inputs changed since: the client's data changed, an action went overdue or an open action passed 14 days overdue (for an AI-written card, also a meeting or milestone came within a week or passed) after this was written; the next check writes it again.");
+    }
     lines.push(counts, dim(`  version ${summary.updatedAt} (what \`summary --version\` takes)`, color));
     return lines;
 }
@@ -378,7 +384,9 @@ export function summaryWrittenLines(summary, color, now = new Date()) {
         lines.push(`  Next: ${summary.next}`);
     if (summary.blocker)
         lines.push(`  Blocker: ${summary.blocker}`);
-    lines.push(`  ${authorLine(summary, now)} It stands until the client's data changes, an action goes overdue or an open action passes 14 days overdue; the next check after that writes it again.`);
+    lines.push(summary.source === "agent"
+        ? `  ${authorLine(summary, now)} Tower's check never rewrites it; your agent's next edit, or a person's on the page, replaces it.`
+        : `  ${authorLine(summary, now)} It stands until the client's data changes, an action goes overdue or an open action passes 14 days overdue; the next check after that writes it again.`);
     lines.push(dim(`  version ${summary.updatedAt}`, color));
     return lines;
 }

package/dist/commands/manager-render.js

@@ -149,6 +149,9 @@ export function handledByLines(item, timeline) {
     const human = item.origin === "human";
     if (human && item.createdBy)
         lines.push(`Added by ${person(item.createdByName)}${onDay(item.createdAt)}.`);
+    // An AI item with a creator is a person's agent's add through the door (BLI-21947); the model's own have none.
+    if (!human && item.createdBy)
+        lines.push(`Added by ${person(item.createdByName)}'s agent${onDay(item.createdAt)}${item.reviewStatus === "unreviewed" ? "; not checked yet" : ""}.`);
     if (item.reviewStatus === "rejected" && item.reviewedBy)
         lines.push(`Dismissed by ${person(item.reviewedByName)}${onDay(item.reviewedAt)}.`);
     else if (item.reviewedBy && item.reviewStatus === "reviewed") {

package/dist/commands/manager.js

@@ -144,6 +144,8 @@ function renderAnswer(command, body, color) {
 }
 /** An add answered `created: false`: the same request id came back, so the item that already existed is returned. */
 const ALREADY_ADDED = "Already added earlier under this request id; nothing new was written.";
+/** An add the server stored as the caller's agent's, unchecked (BLI-21947); an older server's reviewed add says nothing more. */
+const addedUnchecked = (body) => body.item?.reviewStatus === "unreviewed" ? " Stored as added by your agent, not yet checked: a person approves or dismisses it." : "";
 /** What a write did, in one sentence a person reads; the item's new version follows on its row. */
 function writeSentence(command, body) {
     const as = "as you";
@@ -152,7 +154,7 @@ function writeSentence(command, body) {
     const queue = waiting === 0 ? "It leaves the review queue." : `${waiting === 1 ? "Its other suggested change still waits" : `Its ${waiting} other suggested changes still wait`} in the review queue.`;
     switch (command.action) {
         // Only an explicit `created: false` is "not created": an older server sends no field, and that add did write.
-        case "add": return body.created === false ? [ALREADY_ADDED] : [command.timeline && !command.occurredAt ? "Added. It has no date, so it sits in \"Needs a date\"." : "Added."];
+        case "add": return body.created === false ? [ALREADY_ADDED] : [`${command.timeline && !command.occurredAt ? "Added. It has no date, so it sits in \"Needs a date\"." : "Added."}${addedUnchecked(body)}`];
         // Railway writes nothing when every field already equals the stored one: no new version, no reviewed mark.
         case "edit": return [body.unchanged === true ? "No change; nothing was written." : "Saved your changes."];
         // Railway writes nothing when the action already has that status, so its version comes back unchanged.

package/dist/commands/mcp-stdio-probe.js

@@ -260,6 +260,7 @@ function defaultSpawn(command, args, options) {
     return spawn(command, args, {
         env: options.env,
         stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true,
     });
 }
 function defaultRealpath(value) {

package/dist/commands/msg-activity.js

@@ -0,0 +1,134 @@
+/**
+ * The activity verbs of `cockpit msg` (BLI-21598): `activity`, `follow`, `unfollow` and `react`. Same doors
+ * the browser calls (`/api/msg/activity`, `/messages/<id>/follow`, `/messages/<id>/reactions`); `--json`
+ * prints the door's body unchanged so ids, rows, coverage and reasons match HTTP. Split out of `msg.ts` for the file-size ratchet.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+import { runMsgNotify } from "./msg-notify.js";
+const TAG = "[msg cli]";
+const READ_DEADLINE_MS = 30_000;
+const WRITE_DEADLINE_MS = 30_000;
+/** One line for a body: the first line of text, trimmed to a readable length. */
+function preview(content) {
+    const line = (content ?? "").split("\n")[0] ?? "";
+    return line.length > 140 ? `${line.slice(0, 137)}...` : line;
+}
+function countsLine(counts) {
+    if (!counts)
+        return "Unread counts are unavailable right now.";
+    const part = (label, count) => `${label} ${count.unread}${count.capped ? "+" : ""}`;
+    return `Unread: ${part("mentions", counts.mention)}, ${part("threads", counts.reply)}.`;
+}
+/** `cockpit msg activity [--mentions|--threads] [--unread] [--before <cursor>] [--limit <n>] [--mark-read]` */
+export async function runMsgActivity(command, door) {
+    const query = new URLSearchParams();
+    if (command.activityKind)
+        query.set("kind", command.activityKind);
+    if (command.unreadOnly)
+        query.set("unread", "1");
+    if (command.before)
+        query.set("before", command.before);
+    if (command.limit)
+        query.set("limit", String(command.limit));
+    const answer = await askAgentDoor(door, {
+        path: `/api/msg/activity${query.size > 0 ? `?${query.toString()}` : ""}`,
+        method: "GET",
+        label: "msg activity",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const body = answer.body;
+    const items = body.items ?? [];
+    writeLine(door.io.stderr, `${TAG} activity ${JSON.stringify({ returned: items.length, dropped: body.coverage?.dropped ?? 0, has_more: body.hasMore === true })}`);
+    // `--mark-read` is the person asking to be told these now: it marks exactly the unread items just printed.
+    let marked = null;
+    const unreadIds = items.filter((item) => item.read_at === null).map((item) => item.message_id);
+    if (command.markRead && unreadIds.length > 0) {
+        const read = await askAgentDoor(door, {
+            path: "/api/msg/activity/read",
+            method: "POST",
+            label: "msg activity read",
+            timeoutMs: WRITE_DEADLINE_MS,
+            body: { message_ids: unreadIds },
+        });
+        if (!read.ok)
+            return failAgentDoor(door, TAG, read.reason, `${read.detail} The items above were NOT marked read.`);
+        marked = read.body;
+    }
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, ...body, ...(command.markRead ? { markRead: marked ?? { requested: 0, marked: 0 } } : {}) });
+    writeLine(door.io.stdout, countsLine(body.counts));
+    if (items.length === 0) {
+        writeLine(door.io.stdout, command.unreadOnly ? "Nothing unread." : "No activity yet.");
+    }
+    for (const item of items) {
+        const channel = body.channels?.[item.channel_id];
+        const where = channel ? (channel.is_dm ? "a direct message" : `#${channel.name ?? "unnamed"}`) : item.channel_id;
+        const who = (item.message.user_id ? body.displayNameById?.[item.message.user_id] : null) ?? item.message.agent_label ?? item.message.slack_author_label ?? "Someone";
+        writeLine(door.io.stdout, `${item.message_id}  ${item.created_at}  ${item.kind}${item.read_at === null ? " (unread)" : ""}  ${where}  ${who}  ${preview(item.message.content)}`);
+    }
+    if ((body.coverage?.dropped ?? 0) > 0)
+        writeLine(door.io.stdout, `${body.coverage?.dropped} item(s) no longer readable were left out.`);
+    if (body.nextCursor)
+        writeLine(door.io.stdout, `More: --before ${body.nextCursor}`);
+    if (marked)
+        writeLine(door.io.stdout, `Marked ${marked.marked} read.`);
+    return 0;
+}
+/** `cockpit msg follow|unfollow <message-id>` — the id is the thread's top-level message. */
+export async function runMsgFollow(command, door) {
+    const following = command.action === "follow";
+    const answer = await askAgentDoor(door, {
+        path: `/api/msg/messages/${encodeURIComponent(command.targetId ?? "")}/follow`,
+        method: following ? "PUT" : "DELETE",
+        label: `msg ${command.action}`,
+        timeoutMs: WRITE_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const follow = answer.body.follow ?? {};
+    writeLine(door.io.stderr, `${TAG} ${command.action} ${JSON.stringify({ message_id: command.targetId, following: follow.following === true, changed: follow.changed === true })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, ...answer.body });
+    const state = follow.following ? "Following" : "Not following";
+    writeLine(door.io.stdout, `${state} thread ${command.targetId}${follow.reason ? ` (${follow.reason})` : ""}${follow.changed === false ? ": it was already that way." : "."}`);
+    return 0;
+}
+/** `cockpit msg react <message-id> <emoji> [--remove]` */
+export async function runMsgReact(command, door) {
+    const emoji = command.emoji ?? "";
+    const id = encodeURIComponent(command.targetId ?? "");
+    const answer = command.remove
+        ? await askAgentDoor(door, {
+            path: `/api/msg/messages/${id}/reactions?emoji=${encodeURIComponent(emoji)}`,
+            method: "DELETE",
+            label: "msg react remove",
+            timeoutMs: WRITE_DEADLINE_MS,
+        })
+        : await askAgentDoor(door, {
+            path: `/api/msg/messages/${id}/reactions`,
+            method: "POST",
+            label: "msg react",
+            timeoutMs: WRITE_DEADLINE_MS,
+            body: { emoji },
+        });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    writeLine(door.io.stderr, `${TAG} react ${JSON.stringify({ message_id: command.targetId, removed: command.remove === true })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, removed: command.remove === true, ...(answer.body ?? {}) });
+    writeLine(door.io.stdout, command.remove ? `Removed ${emoji} from ${command.targetId}.` : `Reacted ${emoji} on ${command.targetId}.`);
+    return 0;
+}
+/** The one entry `runMsg` calls for activity, follow, unfollow, react and notify (BLI-21605; `resolve` turns a channel name into its id). */
+export function runMsgActivityVerb(command, door, resolve) {
+    if (command.action === "notify")
+        return runMsgNotify(command, door, resolve);
+    if (command.action === "activity")
+        return runMsgActivity(command, door);
+    if (command.action === "react")
+        return runMsgReact(command, door);
+    return runMsgFollow(command, door);
+}

package/dist/commands/msg-channel-args.js

@@ -0,0 +1,92 @@
+/**
+ * Arguments of `cockpit msg channel|members|hide|unhide` (BLI-21685): `channel <channel>` shows details, with
+ * `--rename <name> | --describe <text> | --archive | --unarchive` it changes them; `members <channel>` lists, with
+ * `--add <email> | --remove <email>` it changes membership; `hide <channel>` / `unhide <channel>` change only your own
+ * sidebar. Split out of `local-args-tower-msg.ts`.
+ *
+ * `--remove` is a switch for `msg react`, and an email here. `members` is spotted in the raw words and its `--remove` is
+ * renamed before the shared parser sees it (`msgChannelNormalizeArgs`).
+ */
+import { optionalNonEmpty, optionalUrl } from "./local-arg-values.js";
+export const MSG_CHANNEL_ACTIONS = ["channel", "members", "hide", "unhide"];
+export const MSG_CHANNEL_VALUE_FLAGS = ["--rename", "--describe", "--add", "--remove-member"];
+export const MSG_CHANNEL_BOOLEAN_FLAGS = ["--archive", "--unarchive"];
+const MSG_CHANNEL_ONLY_FLAGS = [...MSG_CHANNEL_VALUE_FLAGS, ...MSG_CHANNEL_BOOLEAN_FLAGS];
+export function isMsgChannelAction(action) {
+    return MSG_CHANNEL_ACTIONS.includes(action);
+}
+/** For `msg members ... --remove <email>`: the shared parser sees `--remove-member`, so `msg react --remove` is untouched. */
+export function msgChannelNormalizeArgs(args) {
+    const action = args.find((arg) => !arg.startsWith("--") && (isMsgChannelAction(arg) || ["channels", "read", "send", "react", "thread", "create", "dm", "show"].includes(arg)));
+    if (action !== "members")
+        return args;
+    return args.map((arg) => (arg === "--remove" ? "--remove-member" : arg.startsWith("--remove=") ? `--remove-member=${arg.slice(9)}` : arg));
+}
+/** A flag of these verbs used on another msg verb is named, not ignored. */
+export function rejectMsgChannelFlags(values) {
+    const stray = MSG_CHANNEL_ONLY_FLAGS.find((flag) => values.flags.has(flag) || values.booleans.has(flag));
+    if (stray)
+        throw new Error(`${stray === "--remove-member" ? "--remove" : stray} does not belong here; it is for \`cockpit msg channel\` or \`cockpit msg members\`.`);
+}
+function emailOf(raw, flag) {
+    const email = optionalNonEmpty(raw) ?? "";
+    if (!email.includes("@"))
+        throw new Error(`${flag} takes an email address; "${email}" is not one.`);
+    return email;
+}
+export function parseMsgChannelArgs(action, values, rest) {
+    const has = (flag) => values.flags.has(flag) || values.booleans.has(flag);
+    const stray = ["--thread", "--channel", "--members", "--description", "--from", "--request-id", "--expected-revision", "--name", "--out", "--file", "--mark-read", "--mentions", "--threads", "--unread", "--private", "--before", "--limit", "--level", "--timezone", "--message", "--mute", "--unmute", "--clear", "--off"].find(has);
+    if (stray)
+        throw new Error(`${stray} does not belong to \`cockpit msg ${action}\`.`);
+    if (values.booleans.has("--remove"))
+        throw new Error("--remove belongs to `cockpit msg react`; for members use `cockpit msg members <channel> --remove <email>`.");
+    const channelRef = optionalNonEmpty(rest[0]);
+    if (!channelRef)
+        throw new Error(`msg ${action} needs a channel id or name, e.g. \`cockpit msg ${action} general\`.`);
+    if (rest.length > 1)
+        throw new Error(`msg ${action} takes one channel, not ${rest.length}.`);
+    const rename = values.flags.get("--rename");
+    const describe = values.flags.get("--describe");
+    const archive = values.booleans.has("--archive");
+    const unarchive = values.booleans.has("--unarchive");
+    const add = values.flags.get("--add");
+    const remove = values.flags.get("--remove-member");
+    const base = {
+        kind: "msg",
+        action,
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        isPrivate: false,
+        channelRef,
+        json: values.booleans.has("--json"),
+    };
+    if (action === "channel") {
+        if (add || remove)
+            throw new Error("--add and --remove belong to `cockpit msg members`.");
+        if (archive && unarchive)
+            throw new Error("Pick one of --archive or --unarchive.");
+        const changes = [];
+        if (rename !== undefined)
+            changes.push({ kind: "rename", name: rename.replace(/^#/, "") });
+        if (describe !== undefined)
+            changes.push({ kind: "describe", text: describe });
+        if (archive)
+            changes.push({ kind: "archive" });
+        if (unarchive)
+            changes.push({ kind: "unarchive" });
+        return { ...base, channelChanges: changes };
+    }
+    if (rename !== undefined || describe !== undefined || archive || unarchive) {
+        throw new Error("--rename, --describe, --archive and --unarchive belong to `cockpit msg channel`.");
+    }
+    if (action === "members") {
+        if (add && remove)
+            throw new Error("Pick one of --add or --remove.");
+        const memberChange = add ? { kind: "add", email: emailOf(add, "--add") } : remove ? { kind: "remove", email: emailOf(remove, "--remove") } : undefined;
+        return { ...base, ...(memberChange ? { memberChange } : {}) };
+    }
+    if (add || remove)
+        throw new Error(`--add and --remove belong to \`cockpit msg members\`, not \`msg ${action}\`.`);
+    return base;
+}

package/dist/commands/msg-channel.js

@@ -0,0 +1,125 @@
+/**
+ * `cockpit msg channel|members|hide|unhide` (BLI-21685): a channel's details and its changes, its people, and your own
+ * sidebar. Same doors the browser calls (`/api/msg/channels/<id>`, `.../members`, `.../hidden`); `--json` prints the
+ * door's body unchanged so ids, audience and the manage answer match HTTP. A refusal keeps the door's reason:
+ * channel_manage_refused, channel_name_taken, dm_not_editable, hide_not_public, person_not_found.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+const TAG = "[msg cli]";
+const DEADLINE_MS = 30_000;
+function audienceLine(details) {
+    if (details.audience === "org")
+        return "Audience: everyone in the org can read it";
+    if (details.audience === "participants")
+        return `Audience: ${details.member_count ?? 0} people in this conversation`;
+    return `Audience: ${details.member_count ?? 0} members`;
+}
+function printDetails(door, details) {
+    const out = door.io.stdout;
+    writeLine(out, `${details.is_dm ? "Direct message" : `#${details.name ?? ""}`} (${details.id})`);
+    writeLine(out, `Kind: ${details.is_dm ? "direct message" : details.is_private ? "private channel" : "public channel"}${details.archived_at ? " (archived)" : ""}`);
+    writeLine(out, `Description: ${details.description ?? "none"}`);
+    writeLine(out, audienceLine(details));
+    if (details.source_workspace)
+        writeLine(out, `Imported from the ${details.source_workspace} Slack workspace (a label; it grants no access)`);
+    writeLine(out, `You can manage it: ${details.can_manage ? "yes" : "no"}`);
+    if (!details.is_dm && !details.is_private)
+        writeLine(out, `Hidden from your sidebar: ${details.hidden ? "yes" : "no"}`);
+}
+async function resolveOrFail(command, door, resolve) {
+    const ref = command.channelRef ?? "";
+    const resolved = await resolve(ref);
+    if (resolved.status === "list_failed")
+        return failAgentDoor(door, TAG, resolved.reason, resolved.detail);
+    if (resolved.status === "not_found") {
+        return failAgentDoor(door, TAG, "channel_not_found_or_unreadable", `That channel does not exist, or you cannot read it: ${ref}`);
+    }
+    return resolved.id;
+}
+async function channelVerb(command, door, id) {
+    const path = `/api/msg/channels/${encodeURIComponent(id)}`;
+    const changes = command.channelChanges ?? [];
+    if (changes.length === 0) {
+        const answer = await askAgentDoor(door, { path, method: "GET", label: "msg channel", timeoutMs: DEADLINE_MS });
+        if (!answer.ok)
+            return failAgentDoor(door, TAG, answer.reason, answer.detail);
+        const details = answer.body.channel;
+        writeLine(door.io.stderr, `${TAG} channel details ${JSON.stringify({ channel_id: id, audience: details.audience, can_manage: details.can_manage })}`);
+        if (door.json)
+            return emitAgentDoor(door, { ok: true, ...answer.body });
+        printDetails(door, details);
+        return 0;
+    }
+    const body = {};
+    for (const change of changes) {
+        if (change.kind === "rename")
+            body["name"] = change.name;
+        if (change.kind === "describe")
+            body["description"] = change.text;
+        if (change.kind === "archive")
+            body["archived"] = true;
+        if (change.kind === "unarchive")
+            body["archived"] = false;
+    }
+    const answer = await askAgentDoor(door, { path, method: "PATCH", label: "msg channel update", timeoutMs: DEADLINE_MS, body });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    writeLine(door.io.stderr, `${TAG} channel updated ${JSON.stringify({ channel_id: id, fields: Object.keys(body) })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, ...answer.body });
+    printDetails(door, answer.body.channel);
+    return 0;
+}
+async function membersVerb(command, door, id) {
+    const path = `/api/msg/channels/${encodeURIComponent(id)}/members`;
+    const change = command.memberChange;
+    if (change) {
+        const answer = change.kind === "add"
+            ? await askAgentDoor(door, { path, method: "POST", label: "msg members add", timeoutMs: DEADLINE_MS, body: { email: change.email } })
+            : await askAgentDoor(door, { path: `${path}?email=${encodeURIComponent(change.email)}`, method: "DELETE", label: "msg members remove", timeoutMs: DEADLINE_MS });
+        if (!answer.ok)
+            return failAgentDoor(door, TAG, answer.reason, answer.detail);
+        writeLine(door.io.stderr, `${TAG} members ${change.kind} ${JSON.stringify({ channel_id: id })}`);
+        if (door.json)
+            return emitAgentDoor(door, { ok: true, channel_id: id, change: change.kind, email: change.email });
+        writeLine(door.io.stdout, change.kind === "add" ? `Added ${change.email}.` : `Removed ${change.email}. Their next read of a private channel is refused.`);
+        return 0;
+    }
+    const answer = await askAgentDoor(door, { path, method: "GET", label: "msg members", timeoutMs: DEADLINE_MS });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const body = answer.body;
+    const members = body.members ?? [];
+    writeLine(door.io.stderr, `${TAG} members listed ${JSON.stringify({ channel_id: id, count: members.length, audience: body.audience ?? null })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, ...body });
+    if (body.audience === "org")
+        writeLine(door.io.stdout, "Everyone in the org can read this channel.");
+    for (const member of members)
+        writeLine(door.io.stdout, `${member.user_id}  ${member.role.padEnd(14)}  ${body.display_names?.[member.user_id] ?? "someone"}`);
+    if (members.length === 0 && body.audience !== "org")
+        writeLine(door.io.stdout, "No members.");
+    return 0;
+}
+async function hideVerb(command, door, id) {
+    const hide = command.action === "hide";
+    const answer = await askAgentDoor(door, { path: `/api/msg/channels/${encodeURIComponent(id)}/hidden`, method: hide ? "PUT" : "DELETE", label: hide ? "msg hide" : "msg unhide", timeoutMs: DEADLINE_MS });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    writeLine(door.io.stderr, `${TAG} ${command.action} ${JSON.stringify({ channel_id: id })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, ...answer.body });
+    writeLine(door.io.stdout, hide ? "Hidden from your sidebar. Everyone can still read, search and link to it." : "Shown in your sidebar again.");
+    return 0;
+}
+export async function runMsgChannel(command, door, resolve) {
+    const id = await resolveOrFail(command, door, resolve);
+    if (typeof id === "number")
+        return id;
+    if (command.action === "channel")
+        return channelVerb(command, door, id);
+    if (command.action === "members")
+        return membersVerb(command, door, id);
+    return hideVerb(command, door, id);
+}

package/dist/commands/msg-context-args.js

@@ -0,0 +1,67 @@
+/**
+ * Arguments of `cockpit msg context <message-id> [--add <kind:id>] [--remove <link-id>] [--json]` (BLI-21829).
+ * `--add doc:<id>|ticket:<BLI-id or uuid>|event:<id>[@<iso occurrence>]|note:<id>`; `--remove` takes the message id first and the
+ * link id after it. Split out of `local-args-tower-msg.ts`.
+ */
+import { optionalNonEmpty, optionalUrl } from "./local-arg-values.js";
+export const MSG_CONTEXT_VALUE_FLAGS = ["--add"];
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const IDENTIFIER = /^[A-Za-z][A-Za-z0-9]{1,12}-\d+$/;
+const KINDS = ["doc", "ticket", "event", "note"];
+/** `--add` used on another msg verb is named, not ignored. */
+export function rejectMsgContextFlags(values) {
+    if (values.flags.has("--add"))
+        throw new Error("--add belongs to `cockpit msg context`.");
+}
+export function parseContextSpec(spec) {
+    const match = /^(doc|ticket|event|note):(.+)$/i.exec(spec.trim());
+    if (!match)
+        throw new Error("--add takes doc:<id>, ticket:<BLI-id or uuid>, event:<id>[@<iso occurrence>] or note:<id>.");
+    const kind = match[1].toLowerCase();
+    const [id = "", occurrence] = match[2].split("@", 2);
+    const ok = kind === "ticket" ? UUID.test(id) || IDENTIFIER.test(id) : UUID.test(id);
+    if (!ok)
+        throw new Error(`--add ${kind}: needs ${kind === "ticket" ? "a BLI id or a uuid" : "a uuid"}, not "${id}".`);
+    if (occurrence !== undefined) {
+        if (kind !== "event")
+            throw new Error("An @<iso occurrence> belongs to event: only.");
+        const time = Date.parse(occurrence);
+        if (Number.isNaN(time))
+            throw new Error(`--add event: the occurrence "${occurrence}" is not an ISO time.`);
+        return { kind, id, occurrence: new Date(time).toISOString() };
+    }
+    return { kind, id };
+}
+export function parseMsgContextArgs(values, rest) {
+    const stray = ["--channel", "--members", "--description", "--from", "--expected-revision", "--name", "--out", "--file", "--level", "--timezone", "--message", "--to", "--before", "--limit", "--thread", "--request-id"]
+        .find((flag) => values.flags.has(flag));
+    if (stray || values.booleans.has("--private"))
+        throw new Error(`${stray ?? "--private"} does not belong to \`cockpit msg context\`.`);
+    const targetId = optionalNonEmpty(rest[0]);
+    if (!targetId || !UUID.test(targetId)) {
+        throw new Error("msg context needs a message id (a UUID), e.g. `cockpit msg context <message-id> --json`.");
+    }
+    const add = optionalNonEmpty(values.flags.get("--add"));
+    const removing = values.booleans.has("--remove");
+    if (add && removing)
+        throw new Error("msg context takes --add or --remove, not both.");
+    const base = {
+        kind: "msg",
+        action: "context",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        isPrivate: false,
+        json: values.booleans.has("--json"),
+        targetId,
+    };
+    if (removing) {
+        const linkId = optionalNonEmpty(rest[1]);
+        if (!linkId || !UUID.test(linkId) || rest.length > 2) {
+            throw new Error("msg context --remove takes the message id and then the link id, e.g. `cockpit msg context <message-id> --remove <link-id>`.");
+        }
+        return { ...base, contextRemove: linkId };
+    }
+    if (rest.length > 1)
+        throw new Error(`msg context takes one message id, not ${rest.length}.`);
+    return { ...base, ...(add ? { contextAdd: parseContextSpec(add) } : {}) };
+}

package/dist/commands/msg-context.js

@@ -0,0 +1,65 @@
+/**
+ * `cockpit msg context` (BLI-21829): the Tower docs, tickets, calendar events and meeting notes pointed at from one message.
+ * Same doors the browser calls (`/api/msg/messages/<id>/context`, `.../context/<link-id>`); `--json` prints the door's body
+ * unchanged so link ids, kinds and `state: "unavailable"` match HTTP. Every target is read again for YOU: one you cannot open
+ * shows as "Not available to you" with no title. A refusal keeps the door's reason: context_target_unavailable,
+ * context_not_author, context_already_linked, context_limit_reached, context_link_not_found.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+const TAG = "[msg cli]";
+const DEADLINE_MS = 30_000;
+function line(link) {
+    if (link.state === "unavailable")
+        return `${link.link_id}  ${link.kind}  Not available to you`;
+    const label = link.kind === "ticket" && link.identifier ? `${link.identifier} ${link.title ?? ""}`.trim() : (link.title ?? link.id);
+    return `${link.link_id}  ${link.kind}  ${label}${link.href ? `  ${link.href}` : ""}`;
+}
+export async function runMsgContext(command, door) {
+    const messageId = encodeURIComponent(command.targetId ?? "");
+    if (command.contextRemove) {
+        const answer = await askAgentDoor(door, {
+            path: `/api/msg/messages/${messageId}/context/${encodeURIComponent(command.contextRemove)}`,
+            method: "DELETE",
+            label: "msg context remove",
+            timeoutMs: DEADLINE_MS,
+        });
+        if (!answer.ok)
+            return failAgentDoor(door, TAG, answer.reason, answer.detail);
+        writeLine(door.io.stderr, `${TAG} context removed ${JSON.stringify({ message_id: command.targetId, link_id: command.contextRemove })}`);
+        if (door.json)
+            return emitAgentDoor(door, { ok: true, ...answer.body });
+        writeLine(door.io.stdout, `Removed context ${command.contextRemove} from ${command.targetId}.`);
+        return 0;
+    }
+    if (command.contextAdd) {
+        const add = command.contextAdd;
+        const answer = await askAgentDoor(door, {
+            path: `/api/msg/messages/${messageId}/context`,
+            method: "POST",
+            body: { target_kind: add.kind, target_id: add.id, ...(add.occurrence ? { occurrence_start: add.occurrence } : {}) },
+            label: "msg context add",
+            timeoutMs: DEADLINE_MS,
+        });
+        if (!answer.ok)
+            return failAgentDoor(door, TAG, answer.reason, answer.detail);
+        const link = answer.body.link;
+        writeLine(door.io.stderr, `${TAG} context added ${JSON.stringify({ message_id: command.targetId, kind: add.kind, link_id: link?.link_id ?? null })}`);
+        if (door.json)
+            return emitAgentDoor(door, { ok: true, ...answer.body });
+        writeLine(door.io.stdout, `Added ${add.kind} context to ${command.targetId}${link ? `:\n${line(link)}` : "."}`);
+        return 0;
+    }
+    const answer = await askAgentDoor(door, { path: `/api/msg/messages/${messageId}/context`, method: "GET", label: "msg context", timeoutMs: DEADLINE_MS });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const links = answer.body.links ?? [];
+    writeLine(door.io.stderr, `${TAG} context ${JSON.stringify({ message_id: command.targetId, links: links.length, unavailable: links.filter((link) => link.state === "unavailable").length })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, ...answer.body });
+    for (const link of links)
+        writeLine(door.io.stdout, line(link));
+    if (links.length === 0)
+        writeLine(door.io.stdout, "No Tower context on this message.");
+    return 0;
+}

package/dist/commands/msg-dm.js

@@ -0,0 +1,28 @@
+/** `cockpit msg dm <email>`: lookup-or-create a direct message (BLI-3749). Split out of `msg.ts` for the file-size ratchet. */
+import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+const TAG = "[msg cli]";
+const WRITE_DEADLINE_MS = 30_000;
+export async function openDm(command, door) {
+    const emails = command.dmEmails ?? (command.dmEmail ? [command.dmEmail] : []);
+    const email = emails.join(", ");
+    if (emails.length === 0)
+        return failAgentDoor(door, TAG, "invalid_body", "msg dm needs an email address.");
+    const answer = await askAgentDoor(door, {
+        path: "/api/msg/channels",
+        method: "POST",
+        label: "msg dm",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: { dm_participant_emails: emails },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const channel = answer.body.channel ?? null;
+    writeLine(door.io.stderr, `${TAG} dm resolved ${JSON.stringify({ channel_id: channel?.id ?? null })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, channel });
+    // Idempotent by contract (`get_or_create_dm`), so the wording says what is
+    // true either way rather than claiming a creation that may not have happened.
+    writeLine(door.io.stdout, `${emails.length > 1 ? "Group message" : "Direct message"} with ${email}: ${channel?.id ?? "?"}`);
+    return 0;
+}