@sendmux/cli 1.1.0 → 1.2.0

package/dist/operation-runner.js

@@ -1,4 +1,6 @@
 import * as sdk from "@sendmux/sdk";
+import { readFile, stat } from "node:fs/promises";
+import { basename, extname } from "node:path";
 import { parseOperationOptions, } from "./operation-flags.js";
 const surfaceModules = {
     mailbox: sdk.mailbox,
@@ -11,6 +13,7 @@ const clientFactories = {
     sending: sdk.sending.createSendingClient,
 };
 export async function runSdkOperation(command, operation, flags) {
+    validateAttachmentConvenienceFlags(command, operation, flags);
     const auth = await command.resolveAuth(flags, operation.requiredKeyKind);
     const clientConfig = {
         apiKey: auth.apiKey,
@@ -19,6 +22,20 @@ export async function runSdkOperation(command, operation, flags) {
     const client = clientFactories[operation.surface](clientConfig);
     const operationOptions = await parseOperationOptions(command, operation, flags);
     const sdkOperation = operationFor(operation);
+    if (operation.operationId === "mailboxCreateAttachmentUpload" && flags.file) {
+        return createMailboxAttachmentUploadFromFile(command, client, operationOptions, flags);
+    }
+    if (operation.operationId === "mailboxUploadAttachment" && flags.file) {
+        return uploadMailboxAttachmentFromFile(command, client, operationOptions, flags);
+    }
+    if ((operation.operationId === "mailboxSendMessage" || operation.operationId === "sendingSendEmail") && flags.attach?.length) {
+        const nextOptions = await withAttachedFiles(command, operation, client, operationOptions, flags);
+        const response = await sdkOperation({
+            client,
+            ...nextOptions,
+        });
+        return command.renderResult(rawResponseData(response));
+    }
     if (operation.operationId === "mailboxStreamEvents") {
         const controller = new AbortController();
         const response = await sdkOperation({
@@ -26,6 +43,9 @@ export async function runSdkOperation(command, operation, flags) {
             ...operationOptions,
             signal: controller.signal,
         });
+        if (flags.follow) {
+            return streamEvents(command, response, controller);
+        }
         return command.renderResult(await firstStreamEvent(response, controller));
     }
     if (operation.operationId === "mailboxGetMessageAttachment") {
@@ -50,6 +70,241 @@ export async function runSdkOperation(command, operation, flags) {
     }
     return command.renderResult(data);
 }
+function validateAttachmentConvenienceFlags(command, operation, flags) {
+    const supportsFile = operation.operationId === "mailboxUploadAttachment" || operation.operationId === "mailboxCreateAttachmentUpload";
+    if (flags.file && !supportsFile) {
+        command.error("This command does not support --file. Use --attach on send commands.", { exit: 2 });
+    }
+    if (flags["via-presigned"] && operation.operationId !== "mailboxUploadAttachment") {
+        command.error("--via-presigned is only supported by mailbox:upload-attachment --file.", { exit: 2 });
+    }
+    const supportsAttach = operation.operationId === "mailboxSendMessage" || operation.operationId === "sendingSendEmail";
+    if (flags.attach?.length && !supportsAttach) {
+        command.error("--attach is only supported by mailbox:send-message and sending:send.", { exit: 2 });
+    }
+    if (flags.attach?.length && flags["content-type"] && flags.attach.length > 1) {
+        command.error("--content-type with multiple --attach files would apply the same type to every file. Omit it to infer per file.", {
+            exit: 2,
+        });
+    }
+}
+async function createMailboxAttachmentUploadFromFile(command, client, operationOptions, flags) {
+    const file = await readAttachmentFile(command, flags.file, flags["content-type"]);
+    const response = await sdk.mailbox.mailboxCreateAttachmentUpload({
+        client: client,
+        body: {
+            content_type: file.contentType,
+            filename: file.filename,
+            size_bytes: file.sizeBytes,
+        },
+        query: mailboxUploadQuery(operationOptions),
+    });
+    return command.renderResult(rawResponseData(response));
+}
+async function uploadMailboxAttachmentFromFile(command, client, operationOptions, flags) {
+    const file = await readAttachmentFile(command, flags.file, flags["content-type"]);
+    if (flags["via-presigned"]) {
+        const intentResponse = await sdk.mailbox.mailboxCreateAttachmentUpload({
+            client: client,
+            query: mailboxUploadQuery(operationOptions),
+            body: {
+                content_type: file.contentType,
+                filename: file.filename,
+                size_bytes: file.sizeBytes,
+            },
+        });
+        const intent = envelopeData(intentResponse, "mailboxCreateAttachmentUpload");
+        const uploadUrl = stringField(intent, "upload_url", "mailboxCreateAttachmentUpload");
+        const method = stringField(intent, "method", "mailboxCreateAttachmentUpload");
+        const headers = recordField(intent, "headers", "mailboxCreateAttachmentUpload");
+        const contentType = stringField(headers, "Content-Type", "mailboxCreateAttachmentUpload headers");
+        const contentLength = stringField(headers, "Content-Length", "mailboxCreateAttachmentUpload headers");
+        if (method !== "PUT") {
+            throw new Error(`mailboxCreateAttachmentUpload returned unsupported method ${method}`);
+        }
+        const putResponse = await fetch(uploadUrl, {
+            body: arrayBufferFor(file.bytes),
+            headers: {
+                "Content-Length": contentLength,
+                "Content-Type": contentType,
+            },
+            method,
+        });
+        const payload = await putResponse.json().catch(() => undefined);
+        if (!putResponse.ok) {
+            throw new Error(`Presigned attachment upload failed with HTTP ${putResponse.status}`);
+        }
+        return command.renderResult(payload);
+    }
+    const response = await sdk.mailbox.mailboxUploadAttachment({
+        client: client,
+        body: blobFor(file),
+        headers: {
+            ...(recordOrUndefined(operationOptions.headers)),
+            "Content-Type": file.contentType,
+        },
+        query: {
+            ...mailboxUploadQuery(operationOptions),
+            filename: file.filename,
+        },
+    });
+    return command.renderResult(rawResponseData(response));
+}
+async function withAttachedFiles(command, operation, client, operationOptions, flags) {
+    const body = jsonObjectBody(command, operationOptions.body);
+    const existingAttachments = attachmentArray(command, body.attachments);
+    const files = [];
+    for (const path of flags.attach ?? []) {
+        files.push(await readAttachmentFile(command, path, flags["content-type"]));
+    }
+    if (operation.operationId === "mailboxSendMessage") {
+        const uploaded = [];
+        for (const file of files) {
+            const uploadResponse = await sdk.mailbox.mailboxUploadAttachment({
+                client: client,
+                body: blobFor(file),
+                headers: {
+                    "Content-Type": file.contentType,
+                },
+                query: {
+                    ...mailboxUploadQuery(operationOptions),
+                    filename: file.filename,
+                },
+            });
+            const result = envelopeData(uploadResponse, "mailboxUploadAttachment");
+            uploaded.push({
+                blob_id: stringField(result, "blob_id", "mailboxUploadAttachment"),
+                content_type: stringField(result, "content_type", "mailboxUploadAttachment"),
+                filename: stringField(result, "filename", "mailboxUploadAttachment"),
+            });
+        }
+        return {
+            ...operationOptions,
+            body: {
+                ...body,
+                attachments: [...existingAttachments, ...uploaded],
+            },
+        };
+    }
+    return {
+        ...operationOptions,
+        body: {
+            ...body,
+            attachments: [
+                ...existingAttachments,
+                ...files.map((file) => ({
+                    content: file.bytes.toString("base64"),
+                    encoding: "base64",
+                    filename: file.filename,
+                    type: file.contentType,
+                })),
+            ],
+        },
+    };
+}
+async function readAttachmentFile(command, filePath, contentTypeOverride) {
+    const info = await stat(filePath).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        command.error(`Could not read attachment file ${filePath}: ${message}`, { exit: 2 });
+    });
+    if (!info.isFile()) {
+        command.error(`Attachment path is not a regular file: ${filePath}`, { exit: 2 });
+    }
+    if (info.size === 0) {
+        command.error(`Attachment file is empty: ${filePath}`, { exit: 2 });
+    }
+    const bytes = await readFile(filePath);
+    return {
+        bytes,
+        contentType: contentTypeOverride ?? inferContentType(filePath),
+        filename: basename(filePath),
+        sizeBytes: bytes.byteLength,
+    };
+}
+function inferContentType(filePath) {
+    switch (extname(filePath).toLowerCase()) {
+        case ".csv":
+            return "text/csv";
+        case ".gif":
+            return "image/gif";
+        case ".htm":
+        case ".html":
+            return "text/html";
+        case ".jpeg":
+        case ".jpg":
+            return "image/jpeg";
+        case ".json":
+            return "application/json";
+        case ".md":
+        case ".txt":
+            return "text/plain";
+        case ".pdf":
+            return "application/pdf";
+        case ".png":
+            return "image/png";
+        case ".webp":
+            return "image/webp";
+        case ".zip":
+            return "application/zip";
+        default:
+            return "application/octet-stream";
+    }
+}
+function jsonObjectBody(command, value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        command.error("--attach requires a JSON object request body.", { exit: 2 });
+    }
+    return value;
+}
+function attachmentArray(command, value) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        command.error('Request body field "attachments" must be an array when using --attach.', { exit: 2 });
+    }
+    return value;
+}
+function mailboxUploadQuery(operationOptions) {
+    const mailboxId = recordOrUndefined(operationOptions.query)?.mailbox_id;
+    return typeof mailboxId === "string" && mailboxId.length > 0 ? { mailbox_id: mailboxId } : {};
+}
+function envelopeData(value, operationId) {
+    const raw = rawResponseData(value);
+    if (!raw || typeof raw !== "object" || !("data" in raw)) {
+        throw new Error(`SDK operation ${operationId} did not return an API envelope`);
+    }
+    const data = raw.data;
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+        throw new Error(`SDK operation ${operationId} did not return object data`);
+    }
+    return data;
+}
+function stringField(record, field, source) {
+    const value = record[field];
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`${source} did not return string field ${field}`);
+    }
+    return value;
+}
+function recordField(record, field, source) {
+    const value = record[field];
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${source} did not return object field ${field}`);
+    }
+    return value;
+}
+function recordOrUndefined(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function blobFor(file) {
+    return new Blob([arrayBufferFor(file.bytes)], { type: file.contentType });
+}
+function arrayBufferFor(bytes) {
+    const copy = new Uint8Array(bytes.byteLength);
+    copy.set(bytes);
+    return copy.buffer;
+}
 async function firstStreamEvent(value, controller) {
     const stream = value?.stream;
     if (!stream || typeof stream[Symbol.asyncIterator] !== "function") {
@@ -75,6 +330,33 @@ async function firstStreamEvent(value, controller) {
         await closeAsyncIterator(iterator);
     }
 }
+async function streamEvents(command, value, controller) {
+    const stream = value?.stream;
+    if (!stream || typeof stream[Symbol.asyncIterator] !== "function") {
+        throw new Error("SDK operation mailboxStreamEvents did not return an async stream");
+    }
+    const iterator = stream[Symbol.asyncIterator]();
+    const abort = () => {
+        controller.abort();
+    };
+    process.once("SIGINT", abort);
+    process.once("SIGTERM", abort);
+    try {
+        while (true) {
+            const next = await iterator.next();
+            if (next.done) {
+                return;
+            }
+            command.log(JSON.stringify(next.value));
+        }
+    }
+    finally {
+        process.off("SIGINT", abort);
+        process.off("SIGTERM", abort);
+        controller.abort();
+        await closeAsyncIterator(iterator);
+    }
+}
 async function closeAsyncIterator(iterator) {
     if (typeof iterator.return !== "function") {
         return;