@bli-cockpit/cli 0.2.259 → 0.2.260

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

@@ -1,5 +1,7 @@
 import { optionalNonEmpty, optionalPositiveInteger, optionalUrl, parseNamedArgs } from "./local-arg-values.js";
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** One `@`, no spaces: `"ping @bob"` is text, not an address (BLI-23213). */
+const DM_ADDRESS_PATTERN = /^[^\s@]+@[^\s@]+$/;
 import { MSG_CHANNEL_BOOLEAN_FLAGS, MSG_CHANNEL_VALUE_FLAGS, isMsgChannelAction, msgChannelNormalizeArgs, parseMsgChannelArgs, rejectMsgChannelFlags } from "./msg-channel-args.js";
 import { MSG_CONTEXT_VALUE_FLAGS, parseMsgContextArgs, rejectMsgContextFlags } from "./msg-context-args.js";
 import { MSG_MARK_VALUE_FLAGS, isMsgMarkAction, parseMsgMarkArgs, rejectMsgMarkFlags } from "./msg-mark-args.js";
@@ -123,14 +125,16 @@ export function parseMsgArgs(rawArgs) {
         throw new Error("--before belongs to msg read or msg thread.");
     }
     const { markRead, unreadFrom } = parseMsgReadLineFlags(action, values);
-    const { channelName, dmEmail } = parseMsgCreateTarget(action, rest);
+    const { channelName, dmEmail, dmTextArgument } = parseMsgCreateTarget(action, rest);
     const { isPrivate, memberEmails, description } = parseMsgCreateFlags(action, values);
     const { channelRef, threadId, limit } = parseMsgReadTarget(action, rest, values);
     const writeSafety = parseMsgWriteSafety(action, rest, values);
     const built = buildMsgCommand(values, action, channelRef, channelName, dmEmail, memberEmails, description, isPrivate, threadId, limit, markRead, unreadFrom, writeSafety);
     // `msg dm a@x b@y` is a group message: the single-address shape (dmEmail) is unchanged (BLI-21685).
     const withGroup = action === "dm" && rest.length > 1 ? { ...built, dmEmails: rest } : built;
-    return fileIds.length > 0 ? { ...withGroup, fileIds } : withGroup;
+    // BLI-23213: text typed after `msg dm <email>` is refused by name at run time (no help dump); the text is piped in.
+    const withText = dmTextArgument ? { ...withGroup, dmTextArgument } : withGroup;
+    return fileIds.length > 0 ? { ...withText, fileIds } : withText;
 }
 /**
  * `cockpit msg search [words] [--from <email|me>]... [--in <channel>] [--since <day>] [--until <day>] [--timezone <zone>]
@@ -333,8 +337,8 @@ function parseMsgWriteSafety(action, rest, values) {
     const requestId = optionalNonEmpty(values.flags.get("--request-id"));
     if (requestId && !UUID_PATTERN.test(requestId))
         throw new Error("--request-id must be a UUID.");
-    if (requestId && action !== "send" && action !== "edit" && action !== "delete") {
-        throw new Error("--request-id belongs to `cockpit msg send`, `edit` or `delete`.");
+    if (requestId && action !== "send" && action !== "dm" && action !== "edit" && action !== "delete") {
+        throw new Error("--request-id belongs to `cockpit msg send`, `dm`, `edit` or `delete`.");
     }
     const expectedRevision = optionalPositiveInteger(values.flags.get("--expected-revision"), "--expected-revision");
     if (expectedRevision !== undefined && action !== "edit" && action !== "delete") {
@@ -379,6 +383,7 @@ function parseMsgAction(positionals) {
 function parseMsgCreateTarget(action, rest) {
     let channelName;
     let dmEmail;
+    let dmTextArgument = false;
     if (action === "create") {
         channelName = optionalNonEmpty(rest[0]);
         if (!channelName)
@@ -396,11 +401,9 @@ function parseMsgCreateTarget(action, rest) {
         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` (several for a group message).");
-        const notAnAddress = rest.find((email) => !email.includes("@"));
-        if (notAnAddress !== undefined)
-            throw new Error(`msg dm takes email addresses; "${notAnAddress}" is not one.`);
+        dmTextArgument = rest.some((email) => !DM_ADDRESS_PATTERN.test(email));
     }
-    return { channelName, dmEmail };
+    return { channelName, dmEmail, dmTextArgument };
 }
 function parseMsgCreateFlags(action, values) {
     const isPrivate = values.booleans.has("--private");

package/dist/commands/local-help-commands-tower.js

@@ -107,7 +107,7 @@ export const TOWER_COMMAND_HELP = [
             "Channels and messages, typed. <channel> is a channel id, or its name with or without a leading #.",
             "channels — every channel you are a member of (or, as a super_admin, every channel).",
             "create <name> [--private] [--members a@x.test,b@y.test] [--description \"<text>\"] — makes a channel and prints its id. A leading # is fine; --private means membership decides who may read it, and --members names who joins at birth BY EMAIL. An address Tower does not carry refuses the whole create — no half-built channel.",
-            "dm <email> — opens (or re-opens) the direct message with one person. Idempotent: the same address always resolves to the same channel, and you never have to name yourself.",
+            "dm <email> [--request-id <uuid>] — opens (or re-opens) the direct message with one person. Idempotent: the same address always resolves to the same channel, and you never have to name yourself. Pipe text in and it is also sent there in the same call, through the same door and request-id receipt as send: `echo \"hello\" | cockpit msg dm ada@example.com` (retry a lost answer with the SAME --request-id; it posts once). The text is never accepted on the command line: `msg dm ada@example.com \"hello\"` is refused dm_text_argument, exit 1, and nothing is sent.",
             "dm <email> [<email>...] — with several addresses, opens (or re-opens) the group message with exactly those people plus you; the same set always resolves to the same channel. channel <channel> [--json] — the channel's details: name, description, kind, archived, audience (a public channel is everyone in the org, not a member count), source workspace label (where it came from; it grants no access), whether you can manage it, and whether you hid it. channel <channel> --rename <name> | --describe <text> | --archive | --unarchive — changes it (one update; --rename and --describe can go together). Only the person who made the channel, its owners and its moderators can; anyone else is refused channel_manage_refused, a name in use channel_name_taken, a direct message dm_not_editable. Archiving keeps every message and link and stops new posts (channel_archived); unarchive restores posting. members <channel> [--json] — who is in a private channel or a direct message; a public channel says everyone in the org can read it. members <channel> --add <email> | --remove <email> — private channels only, by the same people who can manage it; a removed person's next read is refused. A direct message keeps the people it started with (dm_not_editable): start a new group with `msg dm a@x b@y`. hide <channel> / unhide <channel> — drops a PUBLIC channel from your own sidebar, or puts it back; it changes nothing for anyone else and nothing about reading, search, mentions or notifications. A private channel or direct message is refused hide_not_public.",
             "read <channel> [--limit <n>] [--thread <id>] [--mark-read] — the channel's most recent top-level messages, oldest first; --thread <id> reads one thread's replies instead. The first page also says where the messages come from (for an imported Slack channel: how long ago the archive was checked, or that it is unknown) and where YOUR read line stands. Reading never moves the read line; --mark-read moves it to the newest message shown, and says plainly if that failed.",
             "unread <channel> --from <message-id> — marks that message and everything after it unread, so the web sidebar badge and the NEW MESSAGES line start there. Opening or reading a channel never clears unseen history.",

package/dist/commands/msg-dm.js

@@ -1,13 +1,39 @@
-/** `cockpit msg dm <email>`: lookup-or-create a direct message (BLI-3749). Split out of `msg.ts` for the file-size ratchet. */
+/**
+ * `cockpit msg dm <email> [<email>...]`: lookup-or-create a direct message (BLI-3749). Split out of `msg.ts` for the file-size ratchet.
+ * BLI-23213: text piped in is sent into the DM through the same send door `msg send` uses (request id, receipt,
+ * `--request-id` for a retry); text typed on the command line is refused by name, because a message never travels there.
+ */
+import { randomUUID } from "node:crypto";
 import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
-import { writeLine } from "./cli-io.js";
+import { isInteractiveStdin, writeLine } from "./cli-io.js";
+import { postMessage, readContent } from "./msg-write.js";
 const TAG = "[msg cli]";
 const WRITE_DEADLINE_MS = 30_000;
+export const DM_TEXT_ARGUMENT_DETAIL = "dm takes addresses only; pipe the text in: echo \"<text>\" | cockpit msg dm <email>";
+/**
+ * `msg dm a@x "hello"` used to drown its one reason line in the whole msg manual and send nothing, so reports
+ * written that way vanished. It is refused here, before pairing or any request, with the reason and the right form.
+ */
+export function refuseDmTextArgument(command, io) {
+    writeLine(io.stderr, `${TAG} refused ${JSON.stringify({ reason: "dm_text_argument" })}`);
+    if (command.json)
+        writeLine(io.stdout, JSON.stringify({ ok: false, error: "dm_text_argument", detail: DM_TEXT_ARGUMENT_DETAIL }));
+    else
+        writeLine(io.stderr, DM_TEXT_ARGUMENT_DETAIL);
+    return 1;
+}
 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.");
+    // Read before opening, so text over the limit is refused before anything is created.
+    const piped = isInteractiveStdin(door.io) ? { ok: true, text: "" } : await readContent(door.io);
+    if (!piped.ok)
+        return failAgentDoor(door, TAG, piped.reason, piped.detail);
+    if (command.requestId && piped.text === "") {
+        return failAgentDoor(door, TAG, "invalid_body", "--request-id on msg dm goes with piped text, e.g. `echo \"hello\" | cockpit msg dm <email> --request-id <uuid>`. Nothing was opened or sent.");
+    }
     const answer = await askAgentDoor(door, {
         path: "/api/msg/channels",
         method: "POST",
@@ -18,11 +44,25 @@ export async function openDm(command, door) {
     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 });
+    writeLine(door.io.stderr, `${TAG} dm resolved ${JSON.stringify({ channel_id: channel?.id ?? null, piped_chars: piped.text.length })}`);
     // 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 ?? "?"}`);
+    const opened = `${emails.length > 1 ? "Group message" : "Direct message"} with ${email}: ${channel?.id ?? "?"}`;
+    if (piped.text === "") {
+        if (door.json)
+            return emitAgentDoor(door, { ok: true, channel });
+        writeLine(door.io.stdout, opened);
+        return 0;
+    }
+    if (!channel?.id)
+        return failAgentDoor(door, TAG, "dm_channel_missing", "Tower answered without the direct message's id, so the piped text was NOT sent.");
+    const requestId = command.requestId ?? randomUUID();
+    const sent = await postMessage(door, channel.id, { text: piped.text, requestId });
+    if (!sent.ok)
+        return sent.exitCode;
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, channel, message: sent.message, mutation: sent.mutation });
+    writeLine(door.io.stdout, opened);
+    writeLine(door.io.stdout, `Sent to ${email} (${sent.message?.id ?? "?"}).`);
     return 0;
 }

package/dist/commands/msg-write.js

@@ -60,6 +60,31 @@ export function refuseMsgWrite(door, answer, requestId, verb) {
     }
     return failAgentDoor(door, TAG, answer.reason, answer.detail, mutation ? { mutation } : {});
 }
+/**
+ * The ONE send door `msg send` and `msg dm` (with piped text, BLI-23213) share: `POST /api/msg/channels/<id>/messages`
+ * with a request id, so a lost answer can be checked with `msg outcome` and a retry with the same id posts once.
+ * A refusal has already been printed when this answers `ok: false`; the receipt line is printed on success.
+ */
+export async function postMessage(door, channelId, post) {
+    const fileIds = post.fileIds ?? [];
+    const answer = await askAgentDoor(door, {
+        path: `/api/msg/channels/${encodeURIComponent(channelId)}/messages`,
+        method: "POST",
+        label: "msg send",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: {
+            ...(post.text === "" ? {} : { content: post.text }),
+            ...(fileIds.length > 0 ? { file_ids: fileIds } : {}),
+            request_id: post.requestId,
+            ...(post.threadId ? { thread_parent_id: post.threadId } : {}),
+        },
+    });
+    if (!answer.ok)
+        return { ok: false, exitCode: refuseMsgWrite(door, answer, post.requestId, "send") };
+    const { message = null, mutation = null } = answer.body;
+    writeLine(door.io.stderr, `${TAG} sent ${JSON.stringify({ channel_id: channelId, message_id: message?.id ?? null, request_id: post.requestId, chars: post.text.length, files: fileIds.length })}`);
+    return { ok: true, message, mutation };
+}
 /** `cockpit msg edit <message-id> [--expected-revision <n>] [--request-id <uuid>]` — the new text is piped in. */
 export async function editMessage(command, door) {
     const content = await readContent(door.io);

package/dist/commands/msg.js

@@ -23,14 +23,16 @@ import { markReadThrough } from "./msg-read-line.js";
 import { runMsgActivityVerb } from "./msg-activity.js";
 import { runMsgDraft } from "./msg-draft.js";
 import { runMsgSearch } from "./msg-search.js";
-import { openDm } from "./msg-dm.js";
+import { openDm, refuseDmTextArgument } from "./msg-dm.js";
 import { runMsgMark } from "./msg-mark.js";
 import { runMsgChannel } from "./msg-channel.js";
 import { runMsgFile } from "./msg-file.js";
-import { deleteMessage, editMessage, messageOutcome, messageText, readContent, refuseMsgWrite } from "./msg-write.js";
+import { deleteMessage, editMessage, messageOutcome, messageText, postMessage, readContent } from "./msg-write.js";
 const TAG = "[msg cli]";
 const [READ_DEADLINE_MS, WRITE_DEADLINE_MS] = [30_000, 30_000];
 export async function runMsg(command, io) {
+    if (command.action === "dm" && command.dmTextArgument)
+        return refuseDmTextArgument(command, io);
     const door = await openAgentDoor("msg", command, io);
     switch (command.action) {
         case "show": return showMessage(command, door);
@@ -327,22 +329,10 @@ async function sendMessage(command, door) {
         return failAgentDoor(door, TAG, "invalid_body", "There was nothing to send. Nothing was sent.");
     // BLI-21314: every send carries a request id, so a lost response can be checked and a retry posts once.
     const requestId = command.requestId ?? randomUUID();
-    const answer = await askAgentDoor(door, {
-        path: `/api/msg/channels/${encodeURIComponent(resolved.id)}/messages`,
-        method: "POST",
-        label: "msg send",
-        timeoutMs: WRITE_DEADLINE_MS,
-        body: {
-            ...(text === "" ? {} : { content: text }),
-            ...(fileIds.length > 0 ? { file_ids: fileIds } : {}),
-            request_id: requestId,
-            ...(command.threadId ? { thread_parent_id: command.threadId } : {}),
-        },
-    });
-    if (!answer.ok)
-        return refuseMsgWrite(door, answer, requestId, "send");
-    const { message = null, mutation = null } = answer.body;
-    writeLine(door.io.stderr, `${TAG} sent ${JSON.stringify({ channel_id: resolved.id, message_id: message?.id ?? null, request_id: requestId, chars: text.length, files: fileIds.length })}`);
+    const sent = await postMessage(door, resolved.id, { text, fileIds, requestId, ...(command.threadId ? { threadId: command.threadId } : {}) });
+    if (!sent.ok)
+        return sent.exitCode;
+    const { message, mutation } = sent;
     if (door.json)
         return emitAgentDoor(door, { ok: true, message, mutation });
     writeLine(door.io.stdout, `Sent to ${ref} (${message?.id ?? "?"}).`);

package/dist/commands/public-root.js

@@ -21,7 +21,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.259");
+    writeLine(io?.stdout ?? process.stdout, "0.2.260");
     return 0;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.259",
+  "version": "0.2.260",
   "private": false,
   "type": "module",
   "bin": {