@sendly/cli 3.37.0 → 3.38.0

package/dist/commands/rcs/send.js

@@ -0,0 +1,240 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient, ApiError, ApiKeyRequiredError, AuthenticationError, NotFoundError, ValidationError, } from "../../lib/api-client.js";
+import { success, error, json, colors, spinner, isJsonMode, formatStatus, formatCredits, } from "../../lib/output.js";
+/** Parse repeatable "text=postback" pairs into reply suggestions. */
+function parseReplies(raw) {
+    if (!raw || raw.length === 0)
+        return [];
+    const out = [];
+    for (const item of raw) {
+        const idx = item.indexOf("=");
+        if (idx <= 0 || idx === item.length - 1) {
+            return `Invalid --suggest-reply "${item}" — use text=postback (e.g. "Track order=TRACK")`;
+        }
+        out.push({
+            reply: {
+                text: item.slice(0, idx).trim(),
+                postbackData: item.slice(idx + 1),
+            },
+        });
+    }
+    return out;
+}
+/** Parse repeatable "text=postback=url" triples into open-URL suggestions. */
+function parseUrlActions(raw) {
+    if (!raw || raw.length === 0)
+        return [];
+    const out = [];
+    for (const item of raw) {
+        const first = item.indexOf("=");
+        const second = first === -1 ? -1 : item.indexOf("=", first + 1);
+        const text = first > 0 ? item.slice(0, first).trim() : "";
+        const postbackData = second > first + 1 ? item.slice(first + 1, second) : "";
+        const url = second === -1 ? "" : item.slice(second + 1);
+        if (!text || !postbackData || !url) {
+            return `Invalid --suggest-url "${item}" — use text=postback=url (e.g. "View order=VIEW=https://example.com/o/4821")`;
+        }
+        out.push({ action: { text, postbackData, url } });
+    }
+    return out;
+}
+export default class RcsSend extends AuthenticatedCommand {
+    static description = "Send an RCS message — rich text with suggestion chips or a rich card; recipients without RCS get it as plain SMS unless --no-fallback";
+    static examples = [
+        '<%= config.bin %> rcs send --to +15125550190 --text "Your order shipped!"',
+        '<%= config.bin %> rcs send --to +15125550190 --text "Need anything else?" --suggest-reply "Track order=TRACK" --suggest-url "View receipt=RECEIPT=https://example.com/r/4821"',
+        '<%= config.bin %> rcs send --to +15125550190 --card-title "Spring sale" --card-description "20% off everything this weekend" --card-media https://example.com/sale.jpg',
+        '<%= config.bin %> rcs send --to +15125550190 --text "RCS only please" --no-fallback',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        to: Flags.string({
+            char: "t",
+            description: "Recipient phone number (E.164 format)",
+            required: true,
+        }),
+        text: Flags.string({
+            char: "m",
+            description: "Message text (falls back to SMS for non-RCS recipients)",
+            exclusive: [
+                "card-title",
+                "card-description",
+                "card-media",
+                "card-orientation",
+            ],
+        }),
+        agent: Flags.string({
+            description: "RCS agent id to send from (only needed when your workspace has more than one — see `rcs agents`)",
+        }),
+        "card-title": Flags.string({
+            description: "Rich card title (cards have no SMS form — RCS-capable recipients only)",
+        }),
+        "card-description": Flags.string({
+            description: "Rich card body text; required with --card-title",
+            dependsOn: ["card-title"],
+        }),
+        "card-media": Flags.string({
+            description: "Public JPEG, PNG, or GIF image URL for the card",
+            dependsOn: ["card-title"],
+        }),
+        "card-orientation": Flags.string({
+            description: "Card layout",
+            options: ["vertical", "horizontal"],
+            dependsOn: ["card-title"],
+        }),
+        "suggest-reply": Flags.string({
+            description: 'Reply chip as "text=postback" (e.g. --suggest-reply "Track order=TRACK"). Repeatable.',
+            multiple: true,
+        }),
+        "suggest-url": Flags.string({
+            description: 'Open-URL chip as "text=postback=url" (e.g. --suggest-url "View order=VIEW=https://example.com/o/4821"). Repeatable.',
+            multiple: true,
+        }),
+        "no-fallback": Flags.boolean({
+            description: "Fail with an error instead of delivering as SMS when the recipient doesn't support RCS",
+            default: false,
+        }),
+        "idempotency-key": Flags.string({
+            description: "Idempotency key (1-255 printable ASCII characters). Re-running with the same key within 24 hours returns the original result instead of sending again.",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(RcsSend);
+        const hasCard = flags["card-title"] !== undefined;
+        if (!flags.text && !hasCard) {
+            error("Provide either --text or --card-title", {
+                hint: 'Text: --text "Hello!" · Card: --card-title "Spring sale" --card-description "20% off"',
+            });
+            this.exit(1);
+        }
+        if (hasCard && flags["card-description"] === undefined) {
+            error("Missing --card-description for the card", {
+                hint: "Rich cards need both a title and a description",
+            });
+            this.exit(1);
+        }
+        const replies = parseReplies(flags["suggest-reply"]);
+        if (typeof replies === "string") {
+            error(replies);
+            this.exit(1);
+        }
+        const urlActions = parseUrlActions(flags["suggest-url"]);
+        if (typeof urlActions === "string") {
+            error(urlActions);
+            this.exit(1);
+        }
+        const suggestions = [
+            ...replies,
+            ...urlActions,
+        ];
+        const sendSpinner = spinner("Sending RCS message...");
+        if (!isJsonMode()) {
+            sendSpinner.start();
+        }
+        try {
+            const response = await apiClient.post("/api/v1/messages", {
+                channel: "rcs",
+                to: flags.to,
+                ...(flags.agent && { agentId: flags.agent }),
+                ...(hasCard
+                    ? {
+                        card: {
+                            title: flags["card-title"],
+                            description: flags["card-description"],
+                            ...(flags["card-media"] && {
+                                mediaUrl: flags["card-media"],
+                            }),
+                            ...(flags["card-orientation"] && {
+                                orientation: flags["card-orientation"],
+                            }),
+                            ...(suggestions.length > 0 && { suggestions }),
+                        },
+                    }
+                    : {
+                        text: flags.text,
+                        ...(suggestions.length > 0 && { suggestions }),
+                    }),
+                ...(flags["no-fallback"] && { fallbackToSms: false }),
+            }, true, { idempotencyKey: flags["idempotency-key"] });
+            sendSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            if (response.fellBackTo === "sms") {
+                success("Message queued as SMS — recipient doesn't support RCS", {
+                    "Message ID": colors.code(response.id),
+                    To: response.to,
+                    From: response.from,
+                    Status: formatStatus(response.status),
+                    Segments: response.segments,
+                    Credits: formatCredits(response.creditsUsed),
+                });
+                if (response.rcs?.suggestionsDropped) {
+                    console.log();
+                    console.log(colors.dim("Suggestion chips have no SMS form and were dropped from this message."));
+                }
+                return;
+            }
+            success("RCS message queued", {
+                "Message ID": colors.code(response.id),
+                To: response.to,
+                From: response.from,
+                Kind: response.rcs?.kind ?? (hasCard ? "card" : "text"),
+                Status: formatStatus(response.status),
+                Credits: formatCredits(response.creditsUsed),
+            });
+        }
+        catch (err) {
+            sendSpinner.stop();
+            if (err instanceof ApiError &&
+                err.code === "rcs_not_supported_for_recipient") {
+                error(err.message, {
+                    hint: hasCard
+                        ? "Cards have no SMS form — send a text message to reach non-RCS recipients"
+                        : "Drop --no-fallback to deliver to non-RCS recipients as SMS",
+                });
+            }
+            else if (err instanceof NotFoundError) {
+                error(err.message === "Resource not found"
+                    ? "RCS isn't available on your workspace yet."
+                    : err.message, {
+                    hint: "RCS is rolling out gradually — contact support@sendly.live for early access.",
+                });
+            }
+            else if (err instanceof ApiKeyRequiredError) {
+                error("RCS messages require a live API key.", {
+                    hint: "RCS delivery is never simulated on a test key — create one with `sendly keys create --type live`",
+                });
+            }
+            else if (err instanceof ValidationError &&
+                /more than one RCS agent/i.test(err.message ?? "")) {
+                error(err.message, {
+                    hint: "Pass --agent <id> — list them with `sendly rcs agents`",
+                });
+            }
+            else if (err instanceof AuthenticationError &&
+                /opted out/i.test(err.message ?? "")) {
+                error(err.message);
+            }
+            else if (err instanceof AuthenticationError &&
+                /agent/i.test(err.message ?? "")) {
+                error(err.message, {
+                    hint: "See which agents can send with `sendly rcs agents`",
+                });
+            }
+            else if (err instanceof AuthenticationError &&
+                /rcs|verification|not supported|registration/i.test(err.message ?? "")) {
+                error(err.message, {
+                    hint: "This recipient can't receive RCS and your account can't send SMS to this destination — complete verification, or message an RCS-capable recipient",
+                });
+            }
+            else {
+                throw err;
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"send.js","sourceRoot":"","sources":["../../../src/commands/rcs/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EACL,SAAS,EACT,QAAQ,EACR,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,eAAe,GAChB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,OAAO,EACP,KAAK,EACL,IAAI,EACJ,MAAM,EACN,OAAO,EACP,UAAU,EACV,YAAY,EACZ,aAAa,GACd,MAAM,qBAAqB,CAAC;AA4B7B,qEAAqE;AACrE,SAAS,YAAY,CACnB,GAAyB;IAEzB,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IACxC,MAAM,GAAG,GAAoB,EAAE,CAAC;IAChC,KAAK,MAAM,IAAI,IAAI,GAAG,EAAE,CAAC;QACvB,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC9B,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxC,OAAO,4BAA4B,IAAI,kDAAkD,CAAC;QAC5F,CAAC;QACD,GAAG,CAAC,IAAI,CAAC;YACP,KAAK,EAAE;gBACL,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE;gBAC/B,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC;aAClC;SACF,CAAC,CAAC;IACL,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,8EAA8E;AAC9E,SAAS,eAAe,CACtB,GAAyB;IAEzB,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IACxC,MAAM,GAAG,GAAoB,EAAE,CAAC;IAChC,KAAK,MAAM,IAAI,IAAI,GAAG,EAAE,CAAC;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAChC,MAAM,MAAM,GAAG,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC;QAChE,MAAM,IAAI,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC1D,MAAM,YAAY,GAAG,MAAM,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7E,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACxD,IAAI,CAAC,IAAI,IAAI,CAAC,YAAY,IAAI,CAAC,GAAG,EAAE,CAAC;YACnC,OAAO,0BAA0B,IAAI,+EAA+E,CAAC;QACvH,CAAC;QACD,GAAG,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;IACpD,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,CAAC,OAAO,OAAO,OAAQ,SAAQ,oBAAoB;IACvD,MAAM,CAAC,WAAW,GAChB,uIAAuI,CAAC;IAE1I,MAAM,CAAC,QAAQ,GAAG;QAChB,2EAA2E;QAC3E,+KAA+K;QAC/K,wKAAwK;QACxK,qFAAqF;KACtF,CAAC;IAEF,MAAM,CAAC,KAAK,GAAG;QACb,GAAG,oBAAoB,CAAC,SAAS;QACjC,EAAE,EAAE,KAAK,CAAC,MAAM,CAAC;YACf,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,uCAAuC;YACpD,QAAQ,EAAE,IAAI;SACf,CAAC;QACF,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC;YACjB,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,yDAAyD;YACtE,SAAS,EAAE;gBACT,YAAY;gBACZ,kBAAkB;gBAClB,YAAY;gBACZ,kBAAkB;aACnB;SACF,CAAC;QACF,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC;YAClB,WAAW,EACT,kGAAkG;SACrG,CAAC;QACF,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC;YACzB,WAAW,EAAE,wEAAwE;SACtF,CAAC;QACF,kBAAkB,EAAE,KAAK,CAAC,MAAM,CAAC;YAC/B,WAAW,EAAE,iDAAiD;YAC9D,SAAS,EAAE,CAAC,YAAY,CAAC;SAC1B,CAAC;QACF,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC;YACzB,WAAW,EAAE,iDAAiD;YAC9D,SAAS,EAAE,CAAC,YAAY,CAAC;SAC1B,CAAC;QACF,kBAAkB,EAAE,KAAK,CAAC,MAAM,CAAC;YAC/B,WAAW,EAAE,aAAa;YAC1B,OAAO,EAAE,CAAC,UAAU,EAAE,YAAY,CAAC;YACnC,SAAS,EAAE,CAAC,YAAY,CAAC;SAC1B,CAAC;QACF,eAAe,EAAE,KAAK,CAAC,MAAM,CAAC;YAC5B,WAAW,EACT,uFAAuF;YACzF,QAAQ,EAAE,IAAI;SACf,CAAC;QACF,aAAa,EAAE,KAAK,CAAC,MAAM,CAAC;YAC1B,WAAW,EACT,qHAAqH;YACvH,QAAQ,EAAE,IAAI;SACf,CAAC;QACF,aAAa,EAAE,KAAK,CAAC,OAAO,CAAC;YAC3B,WAAW,EACT,wFAAwF;YAC1F,OAAO,EAAE,KAAK;SACf,CAAC;QACF,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC;YAC9B,WAAW,EACT,wJAAwJ;SAC3J,CAAC;KACH,CAAC;IAEF,KAAK,CAAC,GAAG;QACP,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAE5C,MAAM,OAAO,GAAG,KAAK,CAAC,YAAY,CAAC,KAAK,SAAS,CAAC;QAClD,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAC5B,KAAK,CAAC,uCAAuC,EAAE;gBAC7C,IAAI,EAAE,uFAAuF;aAC9F,CAAC,CAAC;YACH,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QACD,IAAI,OAAO,IAAI,KAAK,CAAC,kBAAkB,CAAC,KAAK,SAAS,EAAE,CAAC;YACvD,KAAK,CAAC,yCAAyC,EAAE;gBAC/C,IAAI,EAAE,gDAAgD;aACvD,CAAC,CAAC;YACH,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QAED,MAAM,OAAO,GAAG,YAAY,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC;QACrD,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YAChC,KAAK,CAAC,OAAO,CAAC,CAAC;YACf,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QACD,MAAM,UAAU,GAAG,eAAe,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC;QACzD,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;YACnC,KAAK,CAAC,UAAU,CAAC,CAAC;YAClB,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QACD,MAAM,WAAW,GAAG;YAClB,GAAI,OAA2B;YAC/B,GAAI,UAA8B;SACnC,CAAC;QAEF,MAAM,WAAW,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;QACtD,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;YAClB,WAAW,CAAC,KAAK,EAAE,CAAC;QACtB,CAAC;QAED,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,IAAI,CACnC,kBAAkB,EAClB;gBACE,OAAO,EAAE,KAAK;gBACd,EAAE,EAAE,KAAK,CAAC,EAAE;gBACZ,GAAG,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;gBAC5C,GAAG,CAAC,OAAO;oBACT,CAAC,CAAC;wBACE,IAAI,EAAE;4BACJ,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC;4BAC1B,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC;4BACtC,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI;gCACzB,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;6BAC9B,CAAC;4BACF,GAAG,CAAC,KAAK,CAAC,kBAAkB,CAAC,IAAI;gCAC/B,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC;6BACvC,CAAC;4BACF,GAAG,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,WAAW,EAAE,CAAC;yBAC/C;qBACF;oBACH,CAAC,CAAC;wBACE,IAAI,EAAE,KAAK,CAAC,IAAI;wBAChB,GAAG,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,WAAW,EAAE,CAAC;qBAC/C,CAAC;gBACN,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC;aACtD,EACD,IAAI,EACJ,EAAE,cAAc,EAAE,KAAK,CAAC,iBAAiB,CAAC,EAAE,CAC7C,CAAC;YAEF,WAAW,CAAC,IAAI,EAAE,CAAC;YAEnB,IAAI,UAAU,EAAE,EAAE,CAAC;gBACjB,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACf,OAAO;YACT,CAAC;YAED,IAAI,QAAQ,CAAC,UAAU,KAAK,KAAK,EAAE,CAAC;gBAClC,OAAO,CAAC,uDAAuD,EAAE;oBAC/D,YAAY,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACtC,EAAE,EAAE,QAAQ,CAAC,EAAE;oBACf,IAAI,EAAE,QAAQ,CAAC,IAAI;oBACnB,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC;oBACrC,QAAQ,EAAE,QAAQ,CAAC,QAAQ;oBAC3B,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,WAAW,CAAC;iBAC7C,CAAC,CAAC;gBACH,IAAI,QAAQ,CAAC,GAAG,EAAE,kBAAkB,EAAE,CAAC;oBACrC,OAAO,CAAC,GAAG,EAAE,CAAC;oBACd,OAAO,CAAC,GAAG,CACT,MAAM,CAAC,GAAG,CACR,uEAAuE,CACxE,CACF,CAAC;gBACJ,CAAC;gBACD,OAAO;YACT,CAAC;YAED,OAAO,CAAC,oBAAoB,EAAE;gBAC5B,YAAY,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACtC,EAAE,EAAE,QAAQ,CAAC,EAAE;gBACf,IAAI,EAAE,QAAQ,CAAC,IAAI;gBACnB,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC;gBACvD,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC;gBACrC,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,WAAW,CAAC;aAC7C,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,GAAQ,EAAE,CAAC;YAClB,WAAW,CAAC,IAAI,EAAE,CAAC;YAEnB,IACE,GAAG,YAAY,QAAQ;gBACvB,GAAG,CAAC,IAAI,KAAK,iCAAiC,EAC9C,CAAC;gBACD,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE;oBACjB,IAAI,EAAE,OAAO;wBACX,CAAC,CAAC,0EAA0E;wBAC5E,CAAC,CAAC,4DAA4D;iBACjE,CAAC,CAAC;YACL,CAAC;iBAAM,IAAI,GAAG,YAAY,aAAa,EAAE,CAAC;gBACxC,KAAK,CACH,GAAG,CAAC,OAAO,KAAK,oBAAoB;oBAClC,CAAC,CAAC,4CAA4C;oBAC9C,CAAC,CAAC,GAAG,CAAC,OAAO,EACf;oBACE,IAAI,EAAE,8EAA8E;iBACrF,CACF,CAAC;YACJ,CAAC;iBAAM,IAAI,GAAG,YAAY,mBAAmB,EAAE,CAAC;gBAC9C,KAAK,CAAC,sCAAsC,EAAE;oBAC5C,IAAI,EAAE,kGAAkG;iBACzG,CAAC,CAAC;YACL,CAAC;iBAAM,IACL,GAAG,YAAY,eAAe;gBAC9B,0BAA0B,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC,EAClD,CAAC;gBACD,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE;oBACjB,IAAI,EAAE,wDAAwD;iBAC/D,CAAC,CAAC;YACL,CAAC;iBAAM,IACL,GAAG,YAAY,mBAAmB;gBAClC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC,EACpC,CAAC;gBACD,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YACrB,CAAC;iBAAM,IACL,GAAG,YAAY,mBAAmB;gBAClC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC,EAChC,CAAC;gBACD,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE;oBACjB,IAAI,EAAE,oDAAoD;iBAC3D,CAAC,CAAC;YACL,CAAC;iBAAM,IACL,GAAG,YAAY,mBAAmB;gBAClC,8CAA8C,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC,EACtE,CAAC;gBACD,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE;oBACjB,IAAI,EAAE,mJAAmJ;iBAC1J,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,MAAM,GAAG,CAAC;YACZ,CAAC;YACD,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;IACH,CAAC","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport {\n  apiClient,\n  ApiError,\n  ApiKeyRequiredError,\n  AuthenticationError,\n  NotFoundError,\n  ValidationError,\n} from \"../../lib/api-client.js\";\nimport {\n  success,\n  error,\n  json,\n  colors,\n  spinner,\n  isJsonMode,\n  formatStatus,\n  formatCredits,\n} from \"../../lib/output.js\";\n\ninterface RcsSendResponse {\n  id: string;\n  channel: string;\n  fellBackTo?: string;\n  message_format: string;\n  to: string;\n  from: string;\n  text: string | null;\n  status: string;\n  segments: number;\n  creditsUsed: number;\n  rcs: {\n    kind?: string;\n    agentId: string;\n    agentName?: string;\n    requestedChannel?: string;\n    suggestionsDropped?: boolean;\n  };\n  createdAt: string;\n  metadata: Record<string, unknown>;\n}\n\ntype RcsSuggestion =\n  | { reply: { text: string; postbackData: string } }\n  | { action: { text: string; postbackData: string; url: string } };\n\n/** Parse repeatable \"text=postback\" pairs into reply suggestions. */\nfunction parseReplies(\n  raw: string[] | undefined,\n): RcsSuggestion[] | string {\n  if (!raw || raw.length === 0) return [];\n  const out: RcsSuggestion[] = [];\n  for (const item of raw) {\n    const idx = item.indexOf(\"=\");\n    if (idx <= 0 || idx === item.length - 1) {\n      return `Invalid --suggest-reply \"${item}\" — use text=postback (e.g. \"Track order=TRACK\")`;\n    }\n    out.push({\n      reply: {\n        text: item.slice(0, idx).trim(),\n        postbackData: item.slice(idx + 1),\n      },\n    });\n  }\n  return out;\n}\n\n/** Parse repeatable \"text=postback=url\" triples into open-URL suggestions. */\nfunction parseUrlActions(\n  raw: string[] | undefined,\n): RcsSuggestion[] | string {\n  if (!raw || raw.length === 0) return [];\n  const out: RcsSuggestion[] = [];\n  for (const item of raw) {\n    const first = item.indexOf(\"=\");\n    const second = first === -1 ? -1 : item.indexOf(\"=\", first + 1);\n    const text = first > 0 ? item.slice(0, first).trim() : \"\";\n    const postbackData = second > first + 1 ? item.slice(first + 1, second) : \"\";\n    const url = second === -1 ? \"\" : item.slice(second + 1);\n    if (!text || !postbackData || !url) {\n      return `Invalid --suggest-url \"${item}\" — use text=postback=url (e.g. \"View order=VIEW=https://example.com/o/4821\")`;\n    }\n    out.push({ action: { text, postbackData, url } });\n  }\n  return out;\n}\n\nexport default class RcsSend extends AuthenticatedCommand {\n  static description =\n    \"Send an RCS message — rich text with suggestion chips or a rich card; recipients without RCS get it as plain SMS unless --no-fallback\";\n\n  static examples = [\n    '<%= config.bin %> rcs send --to +15125550190 --text \"Your order shipped!\"',\n    '<%= config.bin %> rcs send --to +15125550190 --text \"Need anything else?\" --suggest-reply \"Track order=TRACK\" --suggest-url \"View receipt=RECEIPT=https://example.com/r/4821\"',\n    '<%= config.bin %> rcs send --to +15125550190 --card-title \"Spring sale\" --card-description \"20% off everything this weekend\" --card-media https://example.com/sale.jpg',\n    '<%= config.bin %> rcs send --to +15125550190 --text \"RCS only please\" --no-fallback',\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    to: Flags.string({\n      char: \"t\",\n      description: \"Recipient phone number (E.164 format)\",\n      required: true,\n    }),\n    text: Flags.string({\n      char: \"m\",\n      description: \"Message text (falls back to SMS for non-RCS recipients)\",\n      exclusive: [\n        \"card-title\",\n        \"card-description\",\n        \"card-media\",\n        \"card-orientation\",\n      ],\n    }),\n    agent: Flags.string({\n      description:\n        \"RCS agent id to send from (only needed when your workspace has more than one — see `rcs agents`)\",\n    }),\n    \"card-title\": Flags.string({\n      description: \"Rich card title (cards have no SMS form — RCS-capable recipients only)\",\n    }),\n    \"card-description\": Flags.string({\n      description: \"Rich card body text; required with --card-title\",\n      dependsOn: [\"card-title\"],\n    }),\n    \"card-media\": Flags.string({\n      description: \"Public JPEG, PNG, or GIF image URL for the card\",\n      dependsOn: [\"card-title\"],\n    }),\n    \"card-orientation\": Flags.string({\n      description: \"Card layout\",\n      options: [\"vertical\", \"horizontal\"],\n      dependsOn: [\"card-title\"],\n    }),\n    \"suggest-reply\": Flags.string({\n      description:\n        'Reply chip as \"text=postback\" (e.g. --suggest-reply \"Track order=TRACK\"). Repeatable.',\n      multiple: true,\n    }),\n    \"suggest-url\": Flags.string({\n      description:\n        'Open-URL chip as \"text=postback=url\" (e.g. --suggest-url \"View order=VIEW=https://example.com/o/4821\"). Repeatable.',\n      multiple: true,\n    }),\n    \"no-fallback\": Flags.boolean({\n      description:\n        \"Fail with an error instead of delivering as SMS when the recipient doesn't support RCS\",\n      default: false,\n    }),\n    \"idempotency-key\": Flags.string({\n      description:\n        \"Idempotency key (1-255 printable ASCII characters). Re-running with the same key within 24 hours returns the original result instead of sending again.\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(RcsSend);\n\n    const hasCard = flags[\"card-title\"] !== undefined;\n    if (!flags.text && !hasCard) {\n      error(\"Provide either --text or --card-title\", {\n        hint: 'Text: --text \"Hello!\" · Card: --card-title \"Spring sale\" --card-description \"20% off\"',\n      });\n      this.exit(1);\n    }\n    if (hasCard && flags[\"card-description\"] === undefined) {\n      error(\"Missing --card-description for the card\", {\n        hint: \"Rich cards need both a title and a description\",\n      });\n      this.exit(1);\n    }\n\n    const replies = parseReplies(flags[\"suggest-reply\"]);\n    if (typeof replies === \"string\") {\n      error(replies);\n      this.exit(1);\n    }\n    const urlActions = parseUrlActions(flags[\"suggest-url\"]);\n    if (typeof urlActions === \"string\") {\n      error(urlActions);\n      this.exit(1);\n    }\n    const suggestions = [\n      ...(replies as RcsSuggestion[]),\n      ...(urlActions as RcsSuggestion[]),\n    ];\n\n    const sendSpinner = spinner(\"Sending RCS message...\");\n    if (!isJsonMode()) {\n      sendSpinner.start();\n    }\n\n    try {\n      const response = await apiClient.post<RcsSendResponse>(\n        \"/api/v1/messages\",\n        {\n          channel: \"rcs\",\n          to: flags.to,\n          ...(flags.agent && { agentId: flags.agent }),\n          ...(hasCard\n            ? {\n                card: {\n                  title: flags[\"card-title\"],\n                  description: flags[\"card-description\"],\n                  ...(flags[\"card-media\"] && {\n                    mediaUrl: flags[\"card-media\"],\n                  }),\n                  ...(flags[\"card-orientation\"] && {\n                    orientation: flags[\"card-orientation\"],\n                  }),\n                  ...(suggestions.length > 0 && { suggestions }),\n                },\n              }\n            : {\n                text: flags.text,\n                ...(suggestions.length > 0 && { suggestions }),\n              }),\n          ...(flags[\"no-fallback\"] && { fallbackToSms: false }),\n        },\n        true,\n        { idempotencyKey: flags[\"idempotency-key\"] },\n      );\n\n      sendSpinner.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      if (response.fellBackTo === \"sms\") {\n        success(\"Message queued as SMS — recipient doesn't support RCS\", {\n          \"Message ID\": colors.code(response.id),\n          To: response.to,\n          From: response.from,\n          Status: formatStatus(response.status),\n          Segments: response.segments,\n          Credits: formatCredits(response.creditsUsed),\n        });\n        if (response.rcs?.suggestionsDropped) {\n          console.log();\n          console.log(\n            colors.dim(\n              \"Suggestion chips have no SMS form and were dropped from this message.\",\n            ),\n          );\n        }\n        return;\n      }\n\n      success(\"RCS message queued\", {\n        \"Message ID\": colors.code(response.id),\n        To: response.to,\n        From: response.from,\n        Kind: response.rcs?.kind ?? (hasCard ? \"card\" : \"text\"),\n        Status: formatStatus(response.status),\n        Credits: formatCredits(response.creditsUsed),\n      });\n    } catch (err: any) {\n      sendSpinner.stop();\n\n      if (\n        err instanceof ApiError &&\n        err.code === \"rcs_not_supported_for_recipient\"\n      ) {\n        error(err.message, {\n          hint: hasCard\n            ? \"Cards have no SMS form — send a text message to reach non-RCS recipients\"\n            : \"Drop --no-fallback to deliver to non-RCS recipients as SMS\",\n        });\n      } else if (err instanceof NotFoundError) {\n        error(\n          err.message === \"Resource not found\"\n            ? \"RCS isn't available on your workspace yet.\"\n            : err.message,\n          {\n            hint: \"RCS is rolling out gradually — contact support@sendly.live for early access.\",\n          },\n        );\n      } else if (err instanceof ApiKeyRequiredError) {\n        error(\"RCS messages require a live API key.\", {\n          hint: \"RCS delivery is never simulated on a test key — create one with `sendly keys create --type live`\",\n        });\n      } else if (\n        err instanceof ValidationError &&\n        /more than one RCS agent/i.test(err.message ?? \"\")\n      ) {\n        error(err.message, {\n          hint: \"Pass --agent <id> — list them with `sendly rcs agents`\",\n        });\n      } else if (\n        err instanceof AuthenticationError &&\n        /opted out/i.test(err.message ?? \"\")\n      ) {\n        error(err.message);\n      } else if (\n        err instanceof AuthenticationError &&\n        /agent/i.test(err.message ?? \"\")\n      ) {\n        error(err.message, {\n          hint: \"See which agents can send with `sendly rcs agents`\",\n        });\n      } else if (\n        err instanceof AuthenticationError &&\n        /rcs|verification|not supported|registration/i.test(err.message ?? \"\")\n      ) {\n        error(err.message, {\n          hint: \"This recipient can't receive RCS and your account can't send SMS to this destination — complete verification, or message an RCS-capable recipient\",\n        });\n      } else {\n        throw err;\n      }\n      this.exit(1);\n    }\n  }\n}\n"]}

package/dist/commands/send.d.ts

@@ -6,6 +6,7 @@ export default class Send extends AuthenticatedCommand {
         to: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         text: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         from: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "idempotency-key": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };

package/dist/commands/send.js

@@ -25,6 +25,9 @@ export default class Send extends AuthenticatedCommand {
             char: "f",
             description: "Sender phone number (optional, uses default if not set)",
         }),
+        "idempotency-key": Flags.string({
+            description: "Idempotency key (1-255 printable ASCII characters). Re-running with the same key within 24 hours returns the original result instead of sending again.",
+        }),
     };
     async run() {
         const { flags } = await this.parse(Send);
@@ -37,7 +40,7 @@ export default class Send extends AuthenticatedCommand {
                 to: flags.to,
                 text: flags.text,
                 ...(flags.from && { from: flags.from }),
-            });
+            }, true, { idempotencyKey: flags["idempotency-key"] });
             sendSpinner.stop();
             if (isJsonMode()) {
                 json(response);
@@ -72,4 +75,4 @@ export default class Send extends AuthenticatedCommand {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/sms/batch.d.ts

@@ -11,6 +11,7 @@ export default class SmsBatch extends AuthenticatedCommand {
         "dry-run": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         reuse: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         history: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        "idempotency-key": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };