@getdial/cli 0.26.0 → 0.27.0

package/dist/cli.js

@@ -147,10 +147,11 @@ number
 });
 const message = program
     .command("message")
-    .description("Send an SMS. POST /api/v1/messages.")
+    .description("Send an SMS, optionally with media (MMS). POST /api/v1/messages.")
     .option("--to <e164>", "destination phone number, E.164 (e.g. +14155551234)")
     .option("--body <text>", "message body")
     .option("--from-number-id <id>", "phoneNumberId to send from (defaults to onboard's number)")
+    .option("--media <path-or-url>", "media attachment: local file path (uploaded) or public http(s) URL (repeatable, max 10)", (v, prev = []) => [...prev, v], [])
     .option("--json", "machine-readable output")
     .action(async (opts) => {
     if (!opts.to || !opts.body) {
@@ -161,6 +162,7 @@ const message = program
         to: opts.to,
         body: opts.body,
         fromNumberId: opts.fromNumberId,
+        media: opts.media,
         json: !!opts.json,
     }));
 });

package/dist/commands/message/list.js

@@ -13,7 +13,8 @@ export async function runMessageList(opts) {
             return 0;
         }
         for (const m of messages) {
-            console.log(`${m.createdAt}  ${(m.direction ?? "").padEnd(8)}  ${m.from} -> ${m.to}  ${m.body}`);
+            const mediaTag = m.media && m.media.length > 0 ? `  [${m.media.length} media]` : "";
+            console.log(`${m.createdAt}  ${(m.direction ?? "").padEnd(8)}  ${m.from} -> ${m.to}  ${m.body}${mediaTag}`);
         }
         return 0;
     }

package/dist/commands/message/send.js

@@ -3,7 +3,7 @@ import { isDialError } from "../../lib/ops/errors.js";
 import { printDialError } from "../../lib/cli-error.js";
 export async function runMessageSend(opts) {
     try {
-        const m = await sendMessage({ to: opts.to, body: opts.body, fromNumberId: opts.fromNumberId });
+        const m = await sendMessage({ to: opts.to, body: opts.body, fromNumberId: opts.fromNumberId, media: opts.media });
         if (opts.json) {
             console.log(JSON.stringify({ ok: true, message: m }));
         }
@@ -13,6 +13,9 @@ export async function runMessageSend(opts) {
             console.log(`  from:     ${m.from}`);
             console.log(`  to:       ${m.to}`);
             console.log(`  body:     ${m.body}`);
+            for (const item of m.media ?? []) {
+                console.log(`  media:    ${item.url} (${item.contentType})`);
+            }
             console.log(`  status:   ${m.status}`);
         }
         return 0;

package/dist/lib/api.js

@@ -1,6 +1,9 @@
-import { request } from "undici";
+import { request, fetch as undiciFetch, FormData as UndiciFormData } from "undici";
 import { logger } from "./log.js";
 import { VERSION } from "./version.js";
+// The bundled undici only multipart-encodes its own FormData class (realm
+// check) — Node's global FormData would be coerced to a text/plain string.
+export { UndiciFormData as ApiFormData };
 const DEFAULT_BASE = "https://api.getdial.ai";
 // Identifies the CLI on every request, so server-side request logs attribute
 // provisioning (and everything else) to the client + version that made the call.
@@ -17,6 +20,26 @@ export async function apiGet(path, apiKey) {
 export async function apiPatch(path, body, apiKey) {
     return apiRequest("PATCH", path, body, apiKey);
 }
+function toResult(statusCode, text) {
+    let parsed = null;
+    try {
+        parsed = text ? JSON.parse(text) : null;
+    }
+    catch { /* keep raw */ }
+    if (statusCode >= 200 && statusCode < 300) {
+        return { ok: true, status: statusCode, data: parsed };
+    }
+    // The server's `error` field is usually a string, but validation failures
+    // return a structured object (Zod's flatten). Stringify those as JSON rather
+    // than letting them coerce to "[object Object]", so the real reason survives.
+    const rawError = parsed?.error;
+    const errMsg = typeof rawError === "string"
+        ? rawError
+        : rawError != null
+            ? JSON.stringify(rawError)
+            : text || `HTTP ${statusCode}`;
+    return { ok: false, status: statusCode, error: errMsg };
+}
 async function apiRequest(method, path, body, apiKey, extraHeaders) {
     const url = `${baseUrl()}${path}`;
     const headers = { "content-type": "application/json", "user-agent": USER_AGENT, ...(extraHeaders ?? {}) };
@@ -28,25 +51,21 @@ async function apiRequest(method, path, body, apiKey, extraHeaders) {
             headers,
             body: body !== undefined ? JSON.stringify(body) : undefined,
         });
-        const text = await res.body.text();
-        let parsed = null;
-        try {
-            parsed = text ? JSON.parse(text) : null;
-        }
-        catch { /* keep raw */ }
-        if (res.statusCode >= 200 && res.statusCode < 300) {
-            return { ok: true, status: res.statusCode, data: parsed };
-        }
-        // The server's `error` field is usually a string, but validation failures
-        // return a structured object (Zod's flatten). Stringify those as JSON rather
-        // than letting them coerce to "[object Object]", so the real reason survives.
-        const rawError = parsed?.error;
-        const errMsg = typeof rawError === "string"
-            ? rawError
-            : rawError != null
-                ? JSON.stringify(rawError)
-                : text || `HTTP ${res.statusCode}`;
-        return { ok: false, status: res.statusCode, error: errMsg };
+        return toResult(res.statusCode, await res.body.text());
+    }
+    catch (err) {
+        return { ok: false, status: 0, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+/** POST a multipart/form-data body (file uploads). fetch sets the boundary header itself. */
+export async function apiPostMultipart(path, form, apiKey) {
+    const url = `${baseUrl()}${path}`;
+    const headers = {};
+    if (apiKey)
+        headers.authorization = `Bearer ${apiKey}`;
+    try {
+        const res = await undiciFetch(url, { method: "POST", headers, body: form });
+        return toResult(res.status, await res.text());
     }
     catch (err) {
         return { ok: false, status: 0, error: err instanceof Error ? err.message : String(err) };

package/dist/lib/ops/messages.js

@@ -1,13 +1,81 @@
-import { apiGet, apiPost } from "../api.js";
+import { readFileSync } from "node:fs";
+import { basename, extname } from "node:path";
+import { apiGet, apiPost, apiPostMultipart, ApiFormData } from "../api.js";
 import { requireAuth, requireFromNumberId } from "./auth.js";
 import { DialError } from "./errors.js";
+export const MAX_MEDIA_ITEMS = 10;
+// File extensions the API accepts for uploads, mapped to their MIME type
+// (mirrors the server's supported-content-type list).
+const EXT_CONTENT_TYPE = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    bmp: "image/bmp",
+    mp3: "audio/mpeg",
+    m4a: "audio/mp4",
+    ogg: "audio/ogg",
+    wav: "audio/wav",
+    amr: "audio/amr",
+    mp4: "video/mp4",
+    "3gp": "video/3gpp",
+    pdf: "application/pdf",
+    vcf: "text/vcard",
+    ics: "text/calendar",
+};
+function isHttpUrl(value) {
+    return /^https?:\/\//i.test(value);
+}
+/** Read a local media file and resolve its MIME type from the extension. */
+function readMediaFile(path) {
+    const ext = extname(path).slice(1).toLowerCase();
+    const contentType = EXT_CONTENT_TYPE[ext];
+    if (!contentType) {
+        const supported = Object.keys(EXT_CONTENT_TYPE).join(", ");
+        throw new DialError("unsupported_media", `unsupported media file extension ".${ext}" (${path}). Supported: ${supported}`);
+    }
+    let data;
+    try {
+        data = readFileSync(path);
+    }
+    catch (err) {
+        throw new DialError("media_read_failed", `could not read media file ${path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return { data, contentType, name: basename(path) };
+}
 export async function sendMessage(opts) {
     const auth = requireAuth();
     const fromNumberId = requireFromNumberId(auth, opts.fromNumberId);
+    const media = opts.media ?? [];
+    if (media.length > MAX_MEDIA_ITEMS) {
+        throw new DialError("too_much_media", `at most ${MAX_MEDIA_ITEMS} media items are allowed per message (got ${media.length})`);
+    }
     // No `channel`: the server determines it from the from-number (a standard number
     // sends SMS; an iMessage number sends iMessage with RCS/SMS fallback) and its send
     // schema is strict — sending a stale `channel` field is rejected as a 400.
-    const res = await apiPost("/api/v1/messages", { to: opts.to, body: opts.body, fromNumberId }, auth.apiKey);
+    // URLs-only goes as plain JSON; any local file switches to multipart.
+    const hasFiles = media.some((m) => !isHttpUrl(m));
+    let res;
+    if (!hasFiles) {
+        res = await apiPost("/api/v1/messages", { to: opts.to, body: opts.body, fromNumberId, ...(media.length ? { mediaUrls: media } : {}) }, auth.apiKey);
+    }
+    else {
+        const form = new ApiFormData();
+        form.set("to", opts.to);
+        form.set("body", opts.body);
+        form.set("fromNumberId", fromNumberId);
+        for (const item of media) {
+            if (isHttpUrl(item)) {
+                form.append("mediaUrls", item);
+            }
+            else {
+                const file = readMediaFile(item);
+                form.append("media", new Blob([new Uint8Array(file.data)], { type: file.contentType }), file.name);
+            }
+        }
+        res = await apiPostMultipart("/api/v1/messages", form, auth.apiKey);
+    }
     if (!res.ok)
         throw new DialError("send_failed", res.error, res.status);
     return res.data.message;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getdial/cli",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "Dial CLI — install, sign up, and run the local listen service.",
   "license": "MIT",
   "repository": {