@bli-cockpit/cli 0.2.57 → 0.2.59

package/dist/commands/issue.js

@@ -0,0 +1,189 @@
+/**
+ * `cockpit issue` — Tower's issue tracker, typed (BLI-3716).
+ *
+ * Seven verbs over `/api/work/**`, the same doors the browser uses. Every
+ * one of those routes already accepted the collector device token
+ * (`resolveCaller({ allowDeviceToken: true })`, BLI-3703), so this command
+ * is a terminal in front of an existing door, not a new one.
+ *
+ * Three references a person actually types, resolved here or by the door:
+ *  - an ISSUE is `BLI-3654` or a uuid. The SERVER resolves it
+ *    (`lib/work/issue-ref.ts`), so `show`/`move`/`comment`/`history` cost one
+ *    request, not two.
+ *  - a PROJECT is its name or a uuid, resolved by `issue-contracts.ts`
+ *    against the same `GET /api/work/projects` list `cockpit project list`
+ *    prints — exact after case-folding, never fuzzy.
+ *  - a PARENT is another issue reference, resolved with one `GET` so the
+ *    create/patch body carries the uuid its schema demands.
+ *
+ * This file is the router plus the READ verbs (`list`, `show`, `history`);
+ * `issue-write.ts` holds `create`, `update`, `move` and `comment`, and
+ * `issue-contracts.ts` the shapes and resolvers both halves share.
+ *
+ * Bodies never travel on argv: a description or a comment comes from stdin
+ * or `--file`. A refusal keeps the door's own `reason` label verbatim
+ * (`agent-door.ts`) — `issue_not_found_or_unreadable`, `invalid_state`,
+ * `needs_rls_client`, `comment_too_long`, and so on.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+import { READ_DEADLINE_MS, TAG, resolveProjectId, } from "./issue-contracts.js";
+import { commentIssue, createIssue, moveIssue, updateIssue } from "./issue-write.js";
+export async function runIssue(command, io) {
+    const door = await openAgentDoor("issue", command, io);
+    switch (command.action) {
+        case "list":
+            return listIssues(command, door);
+        case "show":
+            return showIssue(command, door);
+        case "create":
+            return createIssue(command, door);
+        case "update":
+            return updateIssue(command, door);
+        case "move":
+            return moveIssue(command, door);
+        case "comment":
+            return commentIssue(command, door);
+        case "history":
+            return issueHistory(command, door);
+    }
+}
+function issueLine(issue) {
+    return `${issue.identifier.padEnd(9)}  ${issue.state.padEnd(11)}  ${issue.title}`;
+}
+async function listIssues(command, door) {
+    const query = new URLSearchParams();
+    if (command.stateFilter)
+        query.set("state", command.stateFilter);
+    if (command.assignee)
+        query.set("assignee_id", command.assignee);
+    if (command.limit !== undefined)
+        query.set("limit", String(command.limit));
+    if (command.project) {
+        const resolved = await resolveProjectId(door, command.project);
+        if (resolved.status === "list_failed")
+            return failAgentDoor(door, TAG, resolved.reason, resolved.detail);
+        if (resolved.status === "not_found") {
+            return failAgentDoor(door, TAG, "project_not_found_or_unreadable", `No project here is called "${command.project}" — run \`cockpit project list\` for the names.`);
+        }
+        query.set("project_id", resolved.id);
+    }
+    const suffix = query.toString();
+    const answer = await askAgentDoor(door, {
+        path: `/api/work/issues${suffix ? `?${suffix}` : ""}`,
+        method: "GET",
+        label: "issue list",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const issues = answer.body.issues ?? [];
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, issues });
+    if (issues.length === 0) {
+        writeLine(door.io.stdout, "No issues match that.");
+        return 0;
+    }
+    for (const issue of issues)
+        writeLine(door.io.stdout, issueLine(issue));
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, `${issues.length} issue(s).`);
+    return 0;
+}
+async function showIssue(command, door) {
+    const ref = command.issueRef ?? "";
+    const answer = await askAgentDoor(door, {
+        path: `/api/work/issues/${encodeURIComponent(ref)}`,
+        method: "GET",
+        label: "issue show",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const issue = answer.body.issue;
+    if (!issue) {
+        return failAgentDoor(door, TAG, "issue_not_found_or_unreadable", `That issue does not exist, or you cannot read it: ${ref}`);
+    }
+    // A comment read that fails does NOT fail the whole `show` — the issue is
+    // already in hand, and a named gap beats losing what was read.
+    const commentsAnswer = await askAgentDoor(door, {
+        path: `/api/work/issues/${encodeURIComponent(issue.id)}/comments`,
+        method: "GET",
+        label: "issue show comments",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    const comments = commentsAnswer.ok
+        ? (commentsAnswer.body.comments ?? [])
+        : [];
+    if (!commentsAnswer.ok) {
+        writeLine(door.io.stderr, `${TAG} comments unread ${JSON.stringify({ reason: commentsAnswer.reason, issue_id: issue.id })}`);
+    }
+    if (door.json) {
+        return emitAgentDoor(door, {
+            ok: true,
+            issue,
+            comments,
+            ...(commentsAnswer.ok ? {} : { comments_unread_reason: commentsAnswer.reason }),
+        });
+    }
+    writeLine(door.io.stdout, `${issue.identifier}  ${issue.title}`);
+    writeLine(door.io.stdout, `${issue.state}  ·  priority ${issue.priority ?? 0}  ·  assignee ${issue.assignee_id ?? "(nobody)"}  ·  updated ${issue.updated_at}`);
+    writeLine(door.io.stdout, `id ${issue.id}${issue.parent_id ? `  ·  parent ${issue.parent_id}` : ""}`);
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, issue.description ?? "(no description)");
+    if (comments.length > 0) {
+        writeLine(door.io.stdout, "");
+        writeLine(door.io.stdout, `--- ${comments.length} comment(s) ---`);
+        for (const comment of comments) {
+            writeLine(door.io.stdout, "");
+            writeLine(door.io.stdout, `[${comment.created_at}] ${comment.author_name ?? comment.author_id ?? "unknown"}`);
+            writeLine(door.io.stdout, comment.body_markdown);
+        }
+    }
+    else if (commentsAnswer.ok) {
+        writeLine(door.io.stdout, "");
+        writeLine(door.io.stdout, "No comments.");
+    }
+    return 0;
+}
+/**
+ * What a history row actually says. A row imported from Linear's issue
+ * TIMESTAMPS (created/started/completed/canceled) carries no state names at
+ * all: the reader refuses to name a workflow state it cannot prove
+ * (`linear-reader.ts` `buildSyntheticTransitions` — "naming a stale workflow
+ * state would be a small invented fact"), and only the state CATEGORY it did
+ * know is dropped on the way into `work_issue_history`. Printing
+ * "(none) -> (none)" is honest and useless; this says which it is, so nobody
+ * reads a real gap as a broken command.
+ */
+function historyChange(row) {
+    if (row.from_value === null && row.to_value === null) {
+        return `(no state names recorded — imported from ${row.source})`;
+    }
+    return `${row.from_value ?? "(none)"} -> ${row.to_value ?? "(none)"}`;
+}
+async function issueHistory(command, door) {
+    const ref = command.issueRef ?? "";
+    const query = command.limit === undefined ? "" : `?limit=${command.limit}`;
+    const answer = await askAgentDoor(door, {
+        path: `/api/work/issues/${encodeURIComponent(ref)}/history${query}`,
+        method: "GET",
+        label: "issue history",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const history = answer.body.history ?? [];
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, history });
+    if (history.length === 0) {
+        writeLine(door.io.stdout, `No recorded changes for ${ref}.`);
+        return 0;
+    }
+    for (const row of history) {
+        writeLine(door.io.stdout, `${row.occurred_at}  ${row.change_type.padEnd(9)}  ${historyChange(row)}  ${row.actor_name ?? ""}`.trimEnd());
+    }
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, `${history.length} change(s).`);
+    return 0;
+}

package/dist/commands/jarvis-answer-envelope.js

@@ -0,0 +1,80 @@
+/**
+ * The ONE shape a JARVIS answer wears when nobody is reading it with their
+ * eyes (BLI-3732).
+ *
+ * `cockpit jarvis --json` and the `bli-tower` MCP server's `jarvis_ask` reach
+ * the same door (`POST /api/jarvis/cli`) with the same device token and get
+ * the same reply body back. Before this file they described that body two
+ * different ways, so a script and an agent read two contracts for one turn.
+ * Now both build this envelope, and the five fields a consumer actually asks
+ * for — the answer, where it came from, which turn it was, which conversation
+ * it belongs to, and whether anything about it was second-rate — have one
+ * spelling each.
+ *
+ * ## Where the second copy is, and why
+ *
+ * `packages/bli-cockpit-mcp/src/jarvis-answer-envelope.ts` is a deliberate
+ * copy of this file. That package declares no dependency on this one — see
+ * `packages/bli-cockpit-mcp/src/agent-door-session.ts`, whose own header makes
+ * the same call for the same reason — so the shape is duplicated rather than
+ * imported. Both copies are pinned by a test on the same literal key list
+ * (`JARVIS_ANSWER_ENVELOPE_KEYS` below), so a field added on one side and not
+ * the other fails a suite instead of drifting quietly.
+ *
+ * ## What `--json` still prints
+ *
+ * These keys are ADDED to what `cockpit jarvis --json` already printed; the
+ * older `reply` / `thread` / `traceId` / `model` / `trace` / `latency` /
+ * `clientLatency` keys are untouched, because scripts already read them and a
+ * one-contract ticket that broke the contract would be a joke.
+ */
+/**
+ * Every key of the envelope, in the order it is written. The literal list IS
+ * the contract: both copies assert against it, so a drift is a red suite.
+ */
+export const JARVIS_ANSWER_ENVELOPE_KEYS = [
+    "ok",
+    "answer",
+    "sources",
+    "turn_id",
+    "thread_id",
+    "trace_thread_id",
+    "degraded",
+    "degraded_reasons",
+];
+/** A `Source:` line, as the grounding gate renders it into the answer. */
+const SOURCE_LINE = /^\s*Source:\s*\S/;
+/**
+ * The `Source:` lines inside an answer. Pure string work on what the server
+ * already sent — this side never decides what a source IS, it only finds the
+ * lines the server wrote, so a new citation kind needs no change here.
+ */
+export function extractSourceLines(answer) {
+    return answer
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => SOURCE_LINE.test(line));
+}
+export function buildJarvisAnswerEnvelope(input) {
+    const reasons = [];
+    if (input.modelFallback === true)
+        reasons.push("model_fallback");
+    if (input.revised === true)
+        reasons.push("answer_revised");
+    if ((input.trace ?? []).some((step) => step?.status === "failed")) {
+        reasons.push("tool_step_failed");
+    }
+    const turnId = input.traceId ?? null;
+    if (!turnId)
+        reasons.push("no_turn_id");
+    return {
+        ok: true,
+        answer: input.reply,
+        sources: extractSourceLines(input.reply),
+        turn_id: turnId,
+        thread_id: input.thread ?? null,
+        trace_thread_id: input.traceThread ?? null,
+        degraded: reasons.length > 0,
+        degraded_reasons: reasons,
+    };
+}

package/dist/commands/jarvis-turn.js

@@ -7,6 +7,7 @@
  * `jarvis-render.ts` — imported one direction only.
  */
 import { colorEnabled, dim, writeLine } from "./cli-io.js";
+import { buildJarvisAnswerEnvelope } from "./jarvis-answer-envelope.js";
 import { readAttachedImage } from "./jarvis-attachment.js";
 import { rememberTurnTrace } from "./jarvis-trace.js";
 import { towerFailureDetail, towerJsonRequest, towerRequest } from "../tower-client.js";
@@ -131,7 +132,21 @@ export async function sendOneTurn(context, prompt, io) {
     await rememberTurnTrace({ traceId: body.traceId ?? null, threadId: body.traceThread ?? null }, io, context.command.homeDir);
     if (context.command.json) {
         writeLine(io.stdout, JSON.stringify({
-            ok: true,
+            // BLI-3732: the shared envelope FIRST — `answer`, `sources`,
+            // `turn_id`, `thread_id`, `trace_thread_id`, `degraded`,
+            // `degraded_reasons` — so a script here and an agent on the
+            // `jarvis_ask` MCP tool read one contract for one turn. The keys
+            // below it are the ones this command has always printed and are
+            // untouched; `reply` and `answer` are the same string.
+            ...buildJarvisAnswerEnvelope({
+                reply: body.reply,
+                thread: body.thread ?? context.command.thread,
+                traceId: body.traceId,
+                traceThread: body.traceThread,
+                modelFallback: body.model?.fallback,
+                revised: body.revised,
+                trace,
+            }),
             reply: body.reply,
             thread: body.thread ?? context.command.thread,
             model: body.model ?? null,

package/dist/commands/jarvis.js

@@ -12,6 +12,9 @@
  * - `jarvis-contracts.ts` — the parsed `cockpit jarvis` command type, and the
  *   loose reply shapes read off `/api/jarvis/cli`, `--threads` and
  *   `--history`.
+ * - `jarvis-answer-envelope.ts` — the shape `--json` prints (BLI-3732), which
+ *   is the same shape the `bli-tower` MCP server's `jarvis_ask` returns, so a
+ *   script and an agent read one contract for one turn.
  * - `jarvis-turn.ts` — the turn engine: `sendOneTurn` (attach, request,
  *   stream, settle, print, log — the one send for both a one-shot invocation
  *   and the interactive loop below) and `readHistory` (`--threads` /

package/dist/commands/local-args-collector-setup.js

@@ -31,6 +31,11 @@ function parseOnboardLikeArgs(args, command) {
             "--max-depth",
             "--max-repos",
             "--allow-home-root",
+            // BLI-3731, the one-sign-in ceremony. Same three flags as `login`, so a
+            // person who learned them on one door does not relearn them on another.
+            "--pair",
+            "--no-browser",
+            "--legacy-pair",
         ],
         valueFlags: [
             "--home",
@@ -45,6 +50,7 @@ function parseOnboardLikeArgs(args, command) {
             "--timeout-ms",
             "--max-depth",
             "--max-repos",
+            "--pair",
         ],
     });
     assertNoPositionals(values.positionals, command);
@@ -65,6 +71,9 @@ function parseOnboardLikeArgs(args, command) {
         maxDepth: optionalPositiveInteger(values.flags.get("--max-depth"), "--max-depth"),
         maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
         allowHomeRoot: values.booleans.has("--allow-home-root"),
+        noBrowser: values.booleans.has("--no-browser"),
+        legacyPair: values.booleans.has("--legacy-pair"),
+        pairCode: optionalNonEmpty(values.flags.get("--pair")),
     };
 }
 export function parseOnboardArgs(args) {
@@ -210,6 +219,10 @@ export function parseLoginArgs(args) {
             "--no-auth",
             "--poll-interval-ms",
             "--timeout-ms",
+            // BLI-3731, the one-sign-in ceremony.
+            "--pair",
+            "--no-browser",
+            "--legacy-pair",
         ],
         valueFlags: [
             "--home",
@@ -218,6 +231,7 @@ export function parseLoginArgs(args) {
             "--device-name",
             "--poll-interval-ms",
             "--timeout-ms",
+            "--pair",
         ],
     });
     assertNoPositionals(values.positionals, "login");
@@ -231,6 +245,9 @@ export function parseLoginArgs(args) {
         noAuth: values.booleans.has("--no-auth"),
         pollIntervalMs: optionalPositiveInteger(values.flags.get("--poll-interval-ms"), "--poll-interval-ms"),
         timeoutMs: optionalPositiveInteger(values.flags.get("--timeout-ms"), "--timeout-ms"),
+        pairCode: optionalNonEmpty(values.flags.get("--pair")),
+        noBrowser: values.booleans.has("--no-browser"),
+        legacyPair: values.booleans.has("--legacy-pair"),
     };
 }
 export function parseLogoutArgs(args) {

package/dist/commands/local-args-tower-admin.js

@@ -48,7 +48,7 @@ export function parseScoutArgs(args) {
     return { kind: "scout", action: rawAction, experimentRef, ...base };
 }
 /**
- * `cockpit ops status [--job <id>] [--skips]` and
+ * `cockpit ops status [--job <id>] [--skips] [--memory [--memory-days N]]` and
  * `cockpit ops recompile --person <p> [--dry-run]` (BLI-3462).
  *
  * There is deliberately **no `--cadence`** on `recompile`. The compile path
@@ -64,11 +64,13 @@ export function parseOpsArgs(args) {
             "--dashboard-url",
             "--job",
             "--skips",
+            "--memory",
+            "--memory-days",
             "--person",
             "--dry-run",
             "--json",
         ],
-        valueFlags: ["--home", "--dashboard-url", "--job", "--person"],
+        valueFlags: ["--home", "--dashboard-url", "--job", "--person", "--memory-days"],
     });
     if (values.positionals.length > 1) {
         throw new Error("ops accepts one action: status or recompile.");
@@ -83,11 +85,19 @@ export function parseOpsArgs(args) {
         json: values.booleans.has("--json"),
     };
     if (rawAction === "status") {
+        // BLI-3729: `--memory-days N` implies `--memory`, because asking for a
+        // window and getting nothing back is the silent breakage BLI-2490 forbids.
+        const memoryDays = optionalNonEmpty(values.flags.get("--memory-days"));
+        if (memoryDays !== undefined && !/^[0-9]{1,2}$/u.test(memoryDays)) {
+            throw new Error("ops --memory-days takes a whole number of days, 1 to 30.");
+        }
         return {
             kind: "ops",
             action: "status",
             job: optionalNonEmpty(values.flags.get("--job")),
             skips: values.booleans.has("--skips"),
+            memory: values.booleans.has("--memory") || memoryDays !== undefined,
+            ...(memoryDays === undefined ? {} : { memoryDays: Number(memoryDays) }),
             ...base,
         };
     }

package/dist/commands/local-args-tower-docs-msg.js

@@ -20,9 +20,11 @@ export function parseDocsArgs(args) {
             "--visibility",
             "--file",
             "--body-stdin",
+            "--query",
+            "--limit",
             "--json",
         ],
-        valueFlags: ["--home", "--dashboard-url", "--title", "--parent", "--visibility", "--file"],
+        valueFlags: ["--home", "--dashboard-url", "--title", "--parent", "--visibility", "--file", "--query", "--limit"],
     });
     const first = values.positionals[0];
     const action = (first === undefined ? "list" : first);
@@ -57,6 +59,18 @@ export function parseDocsArgs(args) {
     if (action === "create" && !title) {
         throw new Error("docs create needs --title.");
     }
+    // BLI-3737: narrowing belongs to `list` only. `--parent` keeps its create/
+    // update meaning elsewhere (which parent to file the document under); on
+    // `list` the same word names which parent to list UNDER, plus the literal
+    // `root` for the top of the tree.
+    const query = optionalNonEmpty(values.flags.get("--query"));
+    if (query && action !== "list") {
+        throw new Error("--query belongs to `cockpit docs list`.");
+    }
+    const limit = optionalPositiveInteger(values.flags.get("--limit"), "--limit");
+    if (limit !== undefined && action !== "list") {
+        throw new Error("--limit belongs to `cockpit docs list`.");
+    }
     return {
         kind: "docs",
         action,
@@ -69,22 +83,92 @@ export function parseDocsArgs(args) {
         visibility: visibility,
         filePath: optionalNonEmpty(values.flags.get("--file")),
         bodyStdin: values.booleans.has("--body-stdin"),
+        ...(query ? { query } : {}),
+        ...(limit === undefined ? {} : { limit }),
         json: values.booleans.has("--json"),
     };
 }
-const MSG_ACTIONS = new Set(["channels", "read", "send", "thread"]);
+const MSG_ACTIONS = new Set(["channels", "read", "send", "thread", "create", "dm"]);
 const MSG_ACTIONS_NEEDING_A_CHANNEL = new Set(["read", "send"]);
+/**
+ * `--members a@x.test,b@y.test` — addresses only, split on commas, never
+ * fuzzy (BLI-3749). The door resolves each one exactly, so a typo comes back
+ * as `person_not_found` naming the address rather than as a stranger added
+ * to a private channel.
+ */
+function parseMemberEmails(raw) {
+    const value = optionalNonEmpty(raw);
+    if (!value)
+        return undefined;
+    const emails = value
+        .split(",")
+        .map((part) => part.trim())
+        .filter((part) => part !== "");
+    if (emails.length === 0)
+        throw new Error("msg create --members needs at least one email address.");
+    const notAnAddress = emails.find((email) => !email.includes("@"));
+    if (notAnAddress) {
+        throw new Error(`msg create --members takes email addresses; "${notAnAddress}" is not one.`);
+    }
+    return emails;
+}
 export function parseMsgArgs(args) {
     const values = parseNamedArgs(args, {
-        allowedFlags: ["--home", "--dashboard-url", "--channel", "--thread", "--limit", "--json"],
-        valueFlags: ["--home", "--dashboard-url", "--channel", "--thread", "--limit"],
+        allowedFlags: [
+            "--home",
+            "--dashboard-url",
+            "--channel",
+            "--thread",
+            "--limit",
+            "--private",
+            "--members",
+            "--description",
+            "--json",
+        ],
+        valueFlags: ["--home", "--dashboard-url", "--channel", "--thread", "--limit", "--members", "--description"],
     });
     const first = values.positionals[0];
     const action = (first === undefined ? "channels" : first);
     if (!MSG_ACTIONS.has(action)) {
-        throw new Error(`Unknown msg command: ${first}. Try channels, read, send, or thread.`);
+        throw new Error(`Unknown msg command: ${first}. Try channels, read, send, thread, create, or dm.`);
     }
     const rest = values.positionals.slice(first === undefined ? 0 : 1);
+    let channelName;
+    let dmEmail;
+    if (action === "create") {
+        channelName = optionalNonEmpty(rest[0]);
+        if (!channelName)
+            throw new Error("msg create needs a channel name, e.g. `cockpit msg create general`.");
+        if (rest.length > 1)
+            throw new Error(`msg create takes one channel name, not ${rest.length}.`);
+        // `#general` is how a person says it and how `read`/`send` accept it, so
+        // the leading # is dropped here rather than becoming part of the name.
+        if (channelName.startsWith("#"))
+            channelName = channelName.slice(1);
+        if (channelName === "")
+            throw new Error("msg create needs a channel name, e.g. `cockpit msg create general`.");
+    }
+    else if (action === "dm") {
+        dmEmail = optionalNonEmpty(rest[0]);
+        if (!dmEmail)
+            throw new Error("msg dm needs the person's email address, e.g. `cockpit msg dm ada@example.com`.");
+        if (rest.length > 1)
+            throw new Error(`msg dm takes one email address, not ${rest.length}.`);
+        if (!dmEmail.includes("@"))
+            throw new Error(`msg dm takes an email address; "${dmEmail}" is not one.`);
+    }
+    const isPrivate = values.booleans.has("--private");
+    if (isPrivate && action !== "create") {
+        throw new Error("--private belongs to `cockpit msg create`.");
+    }
+    const memberEmails = parseMemberEmails(values.flags.get("--members"));
+    if (memberEmails && action !== "create") {
+        throw new Error("--members belongs to `cockpit msg create`.");
+    }
+    const description = optionalNonEmpty(values.flags.get("--description"));
+    if (description && action !== "create") {
+        throw new Error("--description belongs to `cockpit msg create`.");
+    }
     let channelRef;
     if (MSG_ACTIONS_NEEDING_A_CHANNEL.has(action)) {
         channelRef = optionalNonEmpty(rest[0]);
@@ -99,7 +183,7 @@ export function parseMsgArgs(args) {
         if (rest.length > 1)
             throw new Error(`msg thread takes one thread id, not ${rest.length}.`);
     }
-    else if (rest.length > 0) {
+    else if (action !== "create" && action !== "dm" && rest.length > 0) {
         throw new Error(`msg ${action} does not take "${rest[0]}".`);
     }
     const threadFlag = optionalNonEmpty(values.flags.get("--thread"));
@@ -119,6 +203,11 @@ export function parseMsgArgs(args) {
         homeDir: optionalNonEmpty(values.flags.get("--home")),
         dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
         ...(channelRef ? { channelRef } : {}),
+        ...(channelName ? { channelName } : {}),
+        ...(dmEmail ? { dmEmail } : {}),
+        ...(memberEmails ? { memberEmails } : {}),
+        ...(description ? { description } : {}),
+        isPrivate,
         ...(threadId ? { threadId } : {}),
         ...(limit === undefined ? {} : { limit }),
         json: values.booleans.has("--json"),

package/dist/commands/local-args-tower-search.js

@@ -0,0 +1,50 @@
+/**
+ * `cockpit search` argument parsing (BLI-3728).
+ *
+ * Its own sibling of `local-args-tower.ts` rather than folded into
+ * `local-args-tower-pages.ts` or `-docs-msg.ts`: search is not one surface's
+ * verb, it is the door OVER all of them — documents, messages, issues, meeting
+ * notes and memory — and putting it under any one family's doc comment would
+ * say something untrue about what it reads.
+ *
+ * The query is a POSITIONAL, not a flag, because that is how every search
+ * command a person has ever typed works (`grep`, `rg`, `gh search`). Several
+ * positionals are joined with a space so `cockpit search storage ceiling`
+ * behaves the way it looks, without demanding quotes.
+ */
+import { optionalNonEmpty, optionalPositiveInteger, optionalUrl, parseNamedArgs, } from "./local-arg-values.js";
+/** The five corpora. Kept here so an unknown kind is refused BEFORE a round trip. */
+export const SEARCH_KINDS = ["doc", "msg", "issue", "note", "memory"];
+export function parseSearchArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: ["--home", "--dashboard-url", "--kind", "--limit", "--json"],
+        valueFlags: ["--home", "--dashboard-url", "--kind", "--limit"],
+    });
+    const query = values.positionals.join(" ").trim();
+    if (query.length === 0) {
+        throw new Error('search needs something to search for, e.g. `cockpit search "storage ceiling"`.');
+    }
+    const kindFlag = optionalNonEmpty(values.flags.get("--kind"));
+    let kinds;
+    if (kindFlag) {
+        kinds = [];
+        for (const part of kindFlag.split(",").map((entry) => entry.trim()).filter(Boolean)) {
+            if (!SEARCH_KINDS.includes(part)) {
+                throw new Error(`search --kind must be one or more of ${SEARCH_KINDS.join(", ")} — not "${part}".`);
+            }
+            if (!kinds.includes(part))
+                kinds.push(part);
+        }
+        if (kinds.length === 0)
+            kinds = undefined;
+    }
+    return {
+        kind: "search",
+        query,
+        ...(kinds ? { kinds } : {}),
+        limit: optionalPositiveInteger(values.flags.get("--limit"), "--limit"),
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        json: values.booleans.has("--json"),
+    };
+}