@bli-cockpit/cli 0.2.167 → 0.2.168

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

@@ -16,7 +16,12 @@
  *   stores.
  * - **The message body.** `cockpit mail send` and `cockpit mail draft` take it
  *   from stdin or `--file`, the same discipline `cockpit issue comment` and
- *   `cockpit docs update` keep.
+ *   `cockpit docs update` keep. `--file` is the BODY and nothing else.
+ *
+ * `--attach <path>` (BLI-12661, repeatable, `send` and `draft` only) names a
+ * file to ride along. It is a PATH on argv, never the file's bytes: the bytes
+ * are read in `mail-attachments.ts`, screened there, and posted in the JSON
+ * body like the text is.
  *
  * `draft` (BLI-12530) takes `send`'s flags exactly — `--account`, `--to`,
  * `--cc`, `--subject`, `--reply-to`, `--file` — and is refused the same two
@@ -60,6 +65,7 @@ export function parseMailArgs(args) {
             "--subject",
             "--reply-to",
             "--file",
+            "--attach",
             "--body-stdin",
             "--out",
             "--json",
@@ -78,6 +84,7 @@ export function parseMailArgs(args) {
             "--subject",
             "--reply-to",
             "--file",
+            "--attach",
             "--out",
         ],
     });
@@ -87,7 +94,8 @@ export function parseMailArgs(args) {
     const { to, cc } = readMailRecipients(action, values);
     const outPath = readAttachmentPath(action, values);
     const limit = readMailLimit(action, values);
-    return buildMailCommand(values, action, subject, query, address, to, cc, outPath, limit);
+    const attachPaths = readAttachPaths(action, values);
+    return buildMailCommand(values, action, subject, query, address, to, cc, outPath, limit, attachPaths);
 }
 function readMailAction(values) {
     const first = values.positionals[0];
@@ -152,6 +160,24 @@ function readAttachmentPath(action, values) {
     }
     return outPath;
 }
+/**
+ * `--attach <path>`, repeatable (BLI-12661): files that ride along with a
+ * `send` or a `draft`. Collected here and read, screened and refused by name in
+ * `mail-attachments.ts`, so a missing file or a fifth too many answers as a
+ * door refusal with a reason label (and under --json as one object) rather than
+ * as a usage error. `--file` is untouched and still means the BODY.
+ */
+function readAttachPaths(action, values) {
+    const named = values.flagValues.get("--attach") ?? [];
+    if (named.length > 0 && !MAIL_ACTIONS_COMPOSING.has(action)) {
+        throw new Error("--attach belongs to `cockpit mail send` and `cockpit mail draft`: a file to attach to the message.");
+    }
+    // A blank path is a mistake to name, never a file to drop without a word.
+    const paths = named.map((value) => optionalNonEmpty(value));
+    if (paths.some((value) => value === undefined))
+        throw new Error("--attach needs a file path, not a blank value.");
+    return paths;
+}
 function readMailLimit(action, values) {
     const limit = optionalPositiveInteger(values.flags.get("--limit"), "--limit");
     if (limit !== undefined && action !== "inbox" && action !== "search") {
@@ -159,7 +185,7 @@ function readMailLimit(action, values) {
     }
     return limit;
 }
-function buildMailCommand(values, action, subject, query, address, to, cc, outPath, limit) {
+function buildMailCommand(values, action, subject, query, address, to, cc, outPath, limit, attachPaths) {
     return {
         kind: "mail",
         action,
@@ -179,6 +205,7 @@ function buildMailCommand(values, action, subject, query, address, to, cc, outPa
         subjectLine: optionalNonEmpty(values.flags.get("--subject")),
         replyTo: optionalNonEmpty(values.flags.get("--reply-to")),
         filePath: optionalNonEmpty(values.flags.get("--file")),
+        ...(attachPaths.length > 0 ? { attachPaths } : {}),
         bodyStdin: values.booleans.has("--body-stdin"),
         outPath,
         json: values.booleans.has("--json"),

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

@@ -133,8 +133,9 @@ export const TOWER_COMMAND_HELP = [
             "inbox [--account <id>] [--unread] [--label <l>] [--limit <n>] [--before <iso>] — everything across every mailbox, newest first. * is unread, @ has an attachment. Every row (text or --json) carries the thread id — `[thread <id>]` in text — so `mail read <thread>` never costs a second --json call to learn it (BLI-10450).",
             "read <thread> — one conversation with its bodies. Thread ids come from `cockpit mail inbox` or `cockpit mail search`, in either --json or plain text.",
             "search \"<words>\" [--account <id>] [--limit <n>] — full text over subject and body. Quotes and OR work the way they do in a search box. Every row (text or --json) carries the thread id.",
-            "send --account <id> --to <a[,b]> [--cc <c>] --subject \"<s>\" [--reply-to <message id>] [--file <path>] — the BODY comes from --file or stdin. --account is required: which address this goes out from is yours to say.",
-            "draft --account <id> --to <a[,b]> [--cc <c>] --subject \"<s>\" [--reply-to <message id>] [--file <path>] — saves the message as a DRAFT in that mailbox for a person to read, edit and send themselves. NOTHING IS SENT and nobody is notified, so there is no confirmation step. Same flags and same body rule as send (--file or stdin). Only the mailbox's owner can draft into it. --reply-to threads the draft into that conversation the way send does; Gmail files it there only when the subject matches the original's, and the answer says whether it did. Gmail mailboxes only: an IMAP mailbox is refused as imap_drafts_unsupported. --json answers { ok, draft: { account_id, address, provider_draft_id, provider_thread_id, threaded } } (BLI-12530).",
+            "send --account <id> --to <a[,b]> [--cc <c>] --subject \"<s>\" [--reply-to <message id>] [--file <path>] [--attach <path>]... — the BODY comes from --file or stdin. --account is required: which address this goes out from is yours to say.",
+            "draft --account <id> --to <a[,b]> [--cc <c>] --subject \"<s>\" [--reply-to <message id>] [--file <path>] [--attach <path>]... — saves the message as a DRAFT in that mailbox for a person to read, edit and send themselves. NOTHING IS SENT and nobody is notified, so there is no confirmation step. Same flags and same body rule as send (--file or stdin). Only the mailbox's owner can draft into it. --reply-to threads the draft into that conversation the way send does; Gmail files it there only when the subject matches the original's, and the answer says whether it did. Gmail mailboxes only: an IMAP mailbox is refused as imap_drafts_unsupported. --json answers { ok, draft: { account_id, address, provider_draft_id, provider_thread_id, threaded } } (BLI-12530).",
+            "--attach <path> (send and draft; repeat it for each file) — a file that rides along with the message: up to 10, and 3,000,000 bytes together (about 3 MB: a request to Tower is capped at 4.5 MB and a file travels as base64, a third bigger than itself). The type comes from the extension (.docx .pdf .png .jpg .jpeg .txt .csv .md .zip and more; anything else goes as application/octet-stream), the name is the file's own. --file is still the BODY and only the body. Refused BEFORE anything is sent, by name and with the numbers: too_many_attachments, attachment_unreadable (a path that is missing, a folder or empty), attachment_too_large. A reply (--reply-to) keeps its thread with files in it. Works on Gmail mailboxes and on IMAP mailboxes for send; a draft is Gmail only. --json adds { attachments: { count, bytes, content_types } } to the answer. The terminal reports from Tower's own answer, not from what it posted: if Tower does not confirm the files (an older Tower), it exits 1 with attachments_not_confirmed and says whether the message went. Names, paths and contents are never logged; a refusal says \"Attachment 2\", not which file (BLI-12661).",
             "attachment <id> --out <path> — downloads one attachment to a file. Attachments are pointers until you ask; nothing is stored in Tower.",
             "sync <account> — reads that mailbox now instead of waiting for the cron. Prints what landed, or the reason it did not.",
             "sync-status [<account>] — every mailbox's health, or one's: last successful sync, the last pass's own reason, how many messages it carried, failures in the last 24h, and the lag between a message's own clock and when Tower stored it (ticket 10730).",

package/dist/commands/local-help.js

@@ -124,7 +124,7 @@ export function localCommandHelp(command) {
         "  cockpit docs [list|tree|read <id|slug>|create --title <t>|update <id>|delete <id|slug>] [--parent <id>|root|--clear-parent] [--query <text> [--word]] [--limit <n>] [--visibility org|private] [--file <path>|--body-stdin] [--allow-empty] [--dashboard-url <url>] [--json]",
         "  cockpit msg [channels|create <name>|dm <email>|read <channel>|send <channel>|thread <id> --channel <channel>] [--private] [--members a@x,b@y] [--description <text>] [--thread <id>] [--limit <n>] [--dashboard-url <url>] [--json]",
         "  cockpit issue [list|show <BLI-id>|create --title <t>|update <BLI-id>|move <BLI-id> <state>|comment <BLI-id>|history <BLI-id>] [--state <s>] [--assignee me|unassigned|<uuid>] [--project <name|id>] [--limit <n>] [--priority 0-4] [--size S|M|L] [--parent <BLI-id>] [--file <path>|--body-stdin] [--dashboard-url <url>] [--json]",
-        "  cockpit mail [accounts|add-imap --address <a>|inbox|read <thread>|search \"<words>\"|send --account <id> --to <a> --subject <s>|draft --account <id> --to <a> --subject <s> [--reply-to <message id>]|attachment <id> --out <path>|sync <account>|detach <account>] [--account <id>] [--limit <n>] [--unread] [--label <l>] [--file <path>] [--dashboard-url <url>] [--json]",
+        "  cockpit mail [accounts|add-imap --address <a>|inbox|read <thread>|search \"<words>\"|send --account <id> --to <a> --subject <s>|draft --account <id> --to <a> --subject <s> [--reply-to <message id>]|attachment <id> --out <path>|sync <account>|detach <account>] [--account <id>] [--limit <n>] [--unread] [--label <l>] [--file <path>] [--attach <path>]... [--dashboard-url <url>] [--json]",
         "  cockpit cal [today|week|next|find \"<words>\"|calendars|add-ical|create --calendar <id> --title <t> --at <iso> --until <iso>|share <id> --org-visible|--private|sync <id> [--full]|detach <id>] [--tz <zone>] [--offset <n>] [--hours <n>] [--from <d> --to <d>] [--calendar <id>] [--limit <n>] [--all] [--dashboard-url <url>] [--json]",
         "  cockpit project [list] [--archived] [--dashboard-url <url>] [--json]",
         "  cockpit github <pr|merge|retitle|rerun> <owner/repo> <n> [--claim <state>] [--method squash|merge|rebase] [--title \"<text>\"] [--run <id>] [--confirm <code>] [--dashboard-url <url>] [--json]",

package/dist/commands/mail-attachments.js

@@ -0,0 +1,207 @@
+/**
+ * `--attach <path>` for `cockpit mail send` and `cockpit mail draft` (BLI-12661):
+ * read the files on THIS machine, screen them, and turn them into the
+ * `attachments` the two doors take. Nothing here talks to Tower, and nothing is
+ * read from a disk that is not the person's own: the server is never handed a
+ * path.
+ *
+ * **Everything that can be refused is refused before a byte leaves the
+ * machine**, each with a named reason and its numbers (the server holds the same
+ * caps and says the same words, `lib/mail/outbound-attachments.ts`):
+ *
+ *   too_many_attachments   more than 10 `--attach`
+ *   attachment_unreadable  a path that is missing, is not a regular file, cannot
+ *                          be read, or is empty
+ *   attachment_too_large   more than 3,000,000 bytes together, or a whole
+ *                          request that would not fit the platform's body cap
+ *
+ * **Why 3,000,000 bytes.** Vercel caps a function REQUEST body at 4.5 MB (413
+ * `FUNCTION_PAYLOAD_TOO_LARGE`, before Tower's code runs), and a file travels as
+ * base64, a third bigger than itself. 3,000,000 bytes is 4,000,000 characters of
+ * base64, which leaves about half a megabyte for the JSON around it. Gmail's own
+ * 25 MB is not the binding limit. `MAIL_REQUEST_MAX_BYTES` is the second check:
+ * a 3 MB file next to a very long body is still too big for one request, and a
+ * platform 413 says nothing about why.
+ *
+ * **Sizes are read off `stat` first.** Every file is stat'ed, the total is
+ * checked, and only then is a single byte read, so a 5 GB file named by mistake
+ * costs one system call and no memory.
+ *
+ * **The type comes from the extension and nothing else.** Unknown is
+ * `application/octet-stream`. The table is copied, on purpose, into
+ * `packages/bli-cockpit-mcp/src/mail-attachments.ts` (that package depends on
+ * neither this one nor `cockpit-cli`), and `mail-attachment-parity.test.ts` in
+ * the MCP package fails when the two drift.
+ *
+ * **Names are never logged, and nor are paths.** The one success line says how
+ * many files, how big and of what type (`describeMailAttachments`). A refusal
+ * names the file by POSITION ("Attachment 2") and the file system's own error
+ * CODE, never its path or its name (the message standard: no local path in an
+ * operator-facing string): the person who typed the command is looking at it.
+ *
+ * No secret-name refusal lives here (`notes upload` has one): a person who names
+ * a file here has decided to send it, and the outbound guard masks text, not
+ * files. See the doc.
+ */
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { isSecretLikePathSegment } from "@bli-cockpit/telemetry-core";
+export const MAIL_ATTACHMENT_MAX_COUNT = 10;
+export const MAIL_ATTACHMENTS_MAX_TOTAL_BYTES = 3_000_000;
+/** The whole JSON request, under Vercel's 4.5 MB function-body cap with room for the headers. */
+export const MAIL_REQUEST_MAX_BYTES = 4_400_000;
+// BEGIN content types: identical in packages/bli-cockpit-mcp/src/mail-attachments.ts
+export const MAIL_ATTACHMENT_CONTENT_TYPES = {
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    doc: "application/msword",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    xls: "application/vnd.ms-excel",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ppt: "application/vnd.ms-powerpoint",
+    pdf: "application/pdf",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    txt: "text/plain",
+    csv: "text/csv",
+    md: "text/markdown",
+    json: "application/json",
+    html: "text/html",
+    rtf: "application/rtf",
+    zip: "application/zip",
+};
+// END content types
+// BEGIN secret-like names: identical in the CLI and MCP mail-attachments.ts
+/**
+ * A name a person almost never means to email: the repo's own secret-name rule
+ * (`isSecretLikePathSegment`, the one `notes upload` uses: `.env*`, anything with
+ * secret, credential, private_key or service_role in it), with `.env.example`
+ * let through (a template, no values), plus the private-key names that rule does
+ * not know: id_rsa and its siblings, `*.pem`, `*.key`.
+ */
+export function attachmentLooksSecret(fileName) {
+    if (/^\.env\.example$/i.test(fileName))
+        return false;
+    return isSecretLikePathSegment(fileName) || /^id_(rsa|dsa|ecdsa|ed25519)$/i.test(fileName) || /\.(pem|key)$/i.test(fileName);
+}
+// END secret-like names
+const FALLBACK_CONTENT_TYPE = "application/octet-stream";
+/** The type a file name's extension says it is. Case-insensitive; anything unknown is octet-stream. */
+export function mailAttachmentContentType(fileName) {
+    const extension = path.extname(fileName).slice(1).toLowerCase();
+    return MAIL_ATTACHMENT_CONTENT_TYPES[extension] ?? FALLBACK_CONTENT_TYPE;
+}
+const NOTHING_SENT = "Nothing was sent.";
+function refuse(reason, detail) {
+    return { ok: false, reason, detail };
+}
+function bytesLabel(count) {
+    return `${count.toLocaleString("en-US")} byte${count === 1 ? "" : "s"}`;
+}
+/** The verdict on a set of sizes, or null when it may go. Shared by the stat pass and the read pass. */
+function totalTooLarge(total) {
+    if (total <= MAIL_ATTACHMENTS_MAX_TOTAL_BYTES)
+        return null;
+    return refuse("attachment_too_large", `The attachments come to ${bytesLabel(total)} and one message carries at most ${bytesLabel(MAIL_ATTACHMENTS_MAX_TOTAL_BYTES)} `
+        + "(about 3 MB: the most one request to Tower holds once the files are encoded). "
+        + `Share a link for anything bigger. ${NOTHING_SENT}`);
+}
+/**
+ * Reads every `--attach` path, or says which one cannot go and why. Never throws.
+ * Order: the count, then each file's `stat` (missing, not a file, empty), then the
+ * total, and only then the bytes.
+ */
+export async function readMailAttachments(paths) {
+    if (paths.length === 0)
+        return { ok: true, attachments: [], summary: { count: 0, bytes: 0, sizes: [], content_types: [] } };
+    if (paths.length > MAIL_ATTACHMENT_MAX_COUNT) {
+        return refuse("too_many_attachments", `${paths.length} files were named with --attach and one message carries at most ${MAIL_ATTACHMENT_MAX_COUNT}. ${NOTHING_SENT}`);
+    }
+    // Names first, before a single stat or read: a secret-looking file is never opened.
+    const secret = paths.findIndex((filePath) => attachmentLooksSecret(path.basename(filePath)));
+    if (secret !== -1) {
+        return refuse("attachment_secret_like", `Attachment ${secret + 1} has a name that looks like a key or credential file, so it was not opened. ${NOTHING_SENT}`);
+    }
+    const sizes = [];
+    for (const [index, filePath] of paths.entries()) {
+        const label = `Attachment ${index + 1}`;
+        let size;
+        try {
+            const info = await stat(filePath);
+            if (!info.isFile())
+                return refuse("attachment_unreadable", `${label} is not a regular file: a folder or a device cannot be attached. ${NOTHING_SENT}`);
+            size = info.size;
+        }
+        catch (error) {
+            const code = error.code;
+            return refuse("attachment_unreadable", code === "ENOENT"
+                ? `${label} does not exist. ${NOTHING_SENT}`
+                : `${label} could not be read (${code ?? "unknown error"}). ${NOTHING_SENT}`);
+        }
+        if (size === 0)
+            return refuse("attachment_unreadable", `${label} is empty, and an empty file is not worth sending. ${NOTHING_SENT}`);
+        sizes.push(size);
+    }
+    const tooLarge = totalTooLarge(sizes.reduce((sum, size) => sum + size, 0));
+    if (tooLarge)
+        return tooLarge;
+    const attachments = [];
+    const actual = [];
+    for (const [index, filePath] of paths.entries()) {
+        let bytes;
+        try {
+            bytes = await readFile(filePath);
+        }
+        catch (error) {
+            const code = error.code;
+            return refuse("attachment_unreadable", `Attachment ${index + 1} could not be read (${code ?? "unknown error"}). ${NOTHING_SENT}`);
+        }
+        actual.push(bytes.length);
+        const filename = path.basename(filePath);
+        attachments.push({
+            filename,
+            content_type: mailAttachmentContentType(filename),
+            content_base64: bytes.toString("base64"),
+        });
+    }
+    // A file that grew between the stat and the read is the file as it is now.
+    const total = actual.reduce((sum, size) => sum + size, 0);
+    const grew = totalTooLarge(total);
+    if (grew)
+        return grew;
+    if (actual.includes(0)) {
+        return refuse("attachment_unreadable", `Attachment ${actual.indexOf(0) + 1} is empty, and an empty file is not worth sending. ${NOTHING_SENT}`);
+    }
+    return {
+        ok: true,
+        attachments,
+        summary: {
+            count: attachments.length,
+            bytes: total,
+            sizes: actual,
+            content_types: attachments.map((attachment) => attachment.content_type),
+        },
+    };
+}
+/**
+ * The second check: the whole request, not just the files. Called with the JSON
+ * body about to be posted, and only when it carries files.
+ */
+export function mailRequestFits(body) {
+    const bytes = Buffer.byteLength(JSON.stringify(body), "utf8");
+    if (bytes <= MAIL_REQUEST_MAX_BYTES)
+        return { ok: true, bytes };
+    return refuse("attachment_too_large", `The whole request would be ${bytesLabel(bytes)} (the message, the files encoded as base64, and the JSON around them) `
+        + `and Tower takes at most ${bytesLabel(MAIL_REQUEST_MAX_BYTES)}: a request over 4.5 MB is refused by the platform before Tower sees it. `
+        + `Shorten the message or send fewer or smaller files. ${NOTHING_SENT}`);
+}
+/** The single stderr line for a send or a draft that carries files: count, bytes, sizes, types. */
+export function describeMailAttachments(summary) {
+    return `[mail cli] attaching ${JSON.stringify(summary)}`;
+}
+/** The sentence a person reads after a send or a draft that carried files. */
+export function attachmentSentence(summary) {
+    return `${summary.count} attachment${summary.count === 1 ? "" : "s"} went with it (${bytesLabel(summary.bytes)}).`;
+}

package/dist/commands/mail-compose.js

@@ -18,9 +18,16 @@
  * `send`, `issue comment` and `docs update` already keep — argv is world-
  * readable on a shared machine and is captured by this product's own session
  * harvester.
+ *
+ * FILES RIDE ALONG WITH `--attach <path>` (BLI-12661), repeatable, on `send` and
+ * `draft` alike. `composeMessage` reads them through `mail-attachments.ts` and
+ * puts them in the one request body both verbs post, so a field added for one
+ * cannot be forgotten by the other. `--file` still means the body and only the
+ * body; a path on argv is a path, not the file's contents.
  */
 import { askAgentDoor, emitAgentDoor, failAgentDoor, } from "./agent-door.js";
 import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
+import { attachmentSentence, describeMailAttachments, mailRequestFits, readMailAttachments, } from "./mail-attachments.js";
 import { readNoteFile } from "./notes-file.js";
 // One spelling per surface: the same tag `mail.ts` uses.
 const TAG = "[mail cli]";
@@ -51,18 +58,86 @@ export async function readMailBody(command, door) {
 /**
  * The JSON that `send` and `draft` post. One shape on purpose: the two doors
  * take the same fields, and a message that can be sent can be saved unsent.
+ * `attachments` is present only when there are files (BLI-12661), so a message
+ * without any is the same bytes it always was.
  */
-export function composedMessageBody(command, text) {
+export function composedMessageBody(command, text, attachments = []) {
     return {
         account_id: command.accountId,
         to: command.to.map((address) => ({ address })),
         ...(command.cc.length > 0 ? { cc: command.cc.map((address) => ({ address })) } : {}),
         subject: command.subjectLine ?? "",
         text,
+        ...(attachments.length > 0 ? { attachments } : {}),
         ...(command.replyTo ? { in_reply_to_message_id: command.replyTo } : {}),
     };
 }
-/** `draft --account <id> --to <a[,b]> [--cc <c>] --subject "<s>" [--reply-to <message id>] [--file <path>]` */
+const NO_ATTACHMENTS = { json: {}, sentence: null, posted: null };
+/**
+ * Did the door SAY it carried the files that were posted? Claim only what the
+ * receipt shows: a Tower that predates attachments answers an ordinary 201,
+ * because its schema strips the key it does not know, and the message goes out
+ * or is saved WITHOUT its files while a terminal that reported from what it
+ * posted would say they went. Only the door's own `attachments` receipt (count
+ * and bytes, both) says they did.
+ *
+ * Returns the sentence to print when the answer does not say so, else null.
+ */
+export function unconfirmedAttachments(receipt, carried, verb) {
+    if (!receipt.posted)
+        return null;
+    const said = carried !== null && typeof carried === "object" ? carried : {};
+    if (said.count === receipt.posted.count && said.bytes === receipt.posted.bytes)
+        return null;
+    const files = `${receipt.posted.count} attachment${receipt.posted.count === 1 ? "" : "s"}`;
+    return verb === "send"
+        ? `Tower accepted the message but did not confirm that its ${files} ${receipt.posted.count === 1 ? "was" : "were"} in it. `
+            + "That usually means this Tower deployment predates attachments, in which case the message went out WITHOUT them. "
+            + "It was sent once: look in that mailbox's Sent folder before doing anything else."
+        : `Tower saved the draft but did not confirm that its ${files} ${receipt.posted.count === 1 ? "was" : "were"} in it. `
+            + "That usually means this Tower deployment predates attachments, in which case the draft has NO file. "
+            + "Open that mailbox's Drafts, delete it, and try again once Tower is updated.";
+}
+/** The failure for a send or a draft whose files the door did not confirm. The message DID go, so the answer rides along. */
+export function failAttachmentsUnconfirmed(door, verb, detail, answer) {
+    writeLine(door.io.stderr, `${TAG} not confirmed ${JSON.stringify({ reason: "attachments_not_confirmed" })}`);
+    if (door.json) {
+        writeLine(door.io.stdout, JSON.stringify({ ok: false, error: "attachments_not_confirmed", detail, [verb === "send" ? "sent" : "draft"]: answer }));
+    }
+    else {
+        writeLine(door.io.stderr, detail);
+    }
+    return 1;
+}
+/**
+ * The request `send` and `draft` post: the body, plus the files named with
+ * `--attach`, read and screened HERE, before any request is made (BLI-12661).
+ * A refusal is the named reason and its numbers (`mail-attachments.ts`).
+ *
+ * The one stderr line it writes says how many files, how big and of what type;
+ * never a name, never a byte. Under `--json` stdout still carries one object.
+ */
+export async function composeMessage(command, door, text) {
+    const read = await readMailAttachments(command.attachPaths ?? []);
+    if (!read.ok)
+        return read;
+    if (read.attachments.length === 0)
+        return { ok: true, body: composedMessageBody(command, text), receipt: NO_ATTACHMENTS };
+    const body = composedMessageBody(command, text, read.attachments);
+    const fits = mailRequestFits(body);
+    if (!fits.ok)
+        return fits;
+    writeLine(door.io.stderr, describeMailAttachments(read.summary));
+    return { ok: true, body, receipt: attachmentReceipt(read.summary) };
+}
+function attachmentReceipt(summary) {
+    return {
+        json: { attachments: { count: summary.count, bytes: summary.bytes, content_types: summary.content_types } },
+        sentence: attachmentSentence(summary),
+        posted: { count: summary.count, bytes: summary.bytes },
+    };
+}
+/** `draft --account <id> --to <a[,b]> [--cc <c>] --subject "<s>" [--reply-to <message id>] [--file <path>] [--attach <path>]...` */
 export async function runMailDraft(command, door) {
     const body = await readMailBody(command, door);
     if (!body.ok)
@@ -70,20 +145,29 @@ export async function runMailDraft(command, door) {
     if (body.text.trim() === "") {
         return failAgentDoor(door, TAG, "body_required", 'A draft needs a body: `echo "Tuesday works for me." | cockpit mail draft --account <id> --to someone@example.com --subject "Re: lunch"`.');
     }
+    const message = await composeMessage(command, door, body.text);
+    if (!message.ok)
+        return failAgentDoor(door, TAG, message.reason, message.detail);
     const answer = await askAgentDoor(door, {
         path: "/api/mail/drafts",
         method: "POST",
         label: "mail draft",
         timeoutMs: WRITE_DEADLINE_MS,
-        body: composedMessageBody(command, body.text),
+        body: message.body,
     });
     if (!answer.ok)
         return failAgentDoor(door, TAG, answer.reason, answer.detail);
     const draft = answer.body.draft;
+    // Report only what the door's receipt shows (BLI-12661), never what was posted.
+    const unconfirmed = unconfirmedAttachments(message.receipt, draft?.attachments, "draft");
+    if (unconfirmed)
+        return failAttachmentsUnconfirmed(door, "draft", unconfirmed, draft);
     if (door.json)
-        return emitAgentDoor(door, { ok: true, draft });
+        return emitAgentDoor(door, { ok: true, draft, ...message.receipt.json });
     writeLine(door.io.stdout, `Saved a draft in ${draft?.address ?? "that mailbox"} for ${command.to.join(", ")}. `
         + "Nothing was sent: it is in Drafts for a person to read, edit and send.");
+    if (message.receipt.sentence)
+        writeLine(door.io.stdout, message.receipt.sentence);
     if (command.replyTo) {
         // `threaded` is what Gmail answered, not what was asked: a reply is only
         // filed in its conversation when the subject still matches the original's.

package/dist/commands/mail.js

@@ -25,7 +25,7 @@
 import { writeFile } from "node:fs/promises";
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
 import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
-import { composedMessageBody, readMailBody, runMailDraft } from "./mail-compose.js";
+import { composeMessage, failAttachmentsUnconfirmed, readMailBody, runMailDraft, unconfirmedAttachments, } from "./mail-compose.js";
 import { cacheAgeLabel, readThroughCache } from "./read-cache.js";
 import { towerRequest } from "../tower-client.js";
 const TAG = "[mail cli]";
@@ -259,19 +259,29 @@ async function send(command, door) {
     if (body.text.trim() === "") {
         return failAgentDoor(door, TAG, "body_required", 'A message needs a body: `echo "on my way" | cockpit mail send --account <id> --to someone@example.com --subject "Re: lunch"`.');
     }
+    // The files named with --attach are read and refused HERE, by name, before any request.
+    const message = await composeMessage(command, door, body.text);
+    if (!message.ok)
+        return failAgentDoor(door, TAG, message.reason, message.detail);
     const answer = await askAgentDoor(door, {
         path: "/api/mail/send",
         method: "POST",
         label: "mail send",
         timeoutMs: WRITE_DEADLINE_MS,
-        body: composedMessageBody(command, body.text),
+        body: message.body,
     });
     if (!answer.ok)
         return failAgentDoor(door, TAG, answer.reason, answer.detail);
     const sent = answer.body.sent;
+    // Report only what the door's receipt shows (BLI-12661), never what was posted.
+    const unconfirmed = unconfirmedAttachments(message.receipt, sent?.attachments, "send");
+    if (unconfirmed)
+        return failAttachmentsUnconfirmed(door, "send", unconfirmed, sent);
     if (door.json)
-        return emitAgentDoor(door, { ok: true, sent });
+        return emitAgentDoor(door, { ok: true, sent, ...message.receipt.json });
     writeLine(door.io.stdout, `Sent from ${sent?.address ?? "that mailbox"} to ${command.to.join(", ")}${sent?.threaded ? " (as a reply)" : ""}.`);
+    if (message.receipt.sentence)
+        writeLine(door.io.stdout, message.receipt.sentence);
     return 0;
 }
 async function attachment(command, door) {

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.167");
+    writeLine(io?.stdout ?? process.stdout, "0.2.168");
     return 0;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.167",
+  "version": "0.2.168",
   "private": false,
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@bli-cockpit/memory-mcp": "0.1.45",
-    "@bli-cockpit/mcp": "0.1.85",
+    "@bli-cockpit/mcp": "0.1.86",
     "@bli-cockpit/telemetry-core": "0.1.57"
   },
   "repository": {