@sendly/cli 3.37.1 → 3.39.0

package/dist/commands/rcs/capability.js

@@ -0,0 +1,85 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient, ApiKeyRequiredError, NotFoundError, ValidationError, } from "../../lib/api-client.js";
+import { success, error, json, colors, spinner, isJsonMode, } from "../../lib/output.js";
+export default class RcsCapability extends AuthenticatedCommand {
+    static description = "Check whether a recipient's device can receive RCS before you send";
+    static examples = [
+        "<%= config.bin %> rcs capability --to +15125550190",
+        "<%= config.bin %> rcs capability --to +15125550190 --agent 3f6a1c9e-0000-0000-0000-000000000000",
+        "<%= config.bin %> rcs capability --to +15125550190 --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        to: Flags.string({
+            char: "t",
+            description: "Recipient phone number to check (E.164 format)",
+            required: true,
+        }),
+        agent: Flags.string({
+            description: "RCS agent id to check with (only needed when your workspace has more than one — see `rcs agents`)",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(RcsCapability);
+        const checkSpinner = spinner("Checking RCS capability...");
+        if (!isJsonMode()) {
+            checkSpinner.start();
+        }
+        let response;
+        try {
+            response = await apiClient.get("/api/v1/rcs/capability", {
+                to: flags.to,
+                ...(flags.agent && { agentId: flags.agent }),
+            });
+            checkSpinner.stop();
+        }
+        catch (err) {
+            checkSpinner.stop();
+            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.",
+                });
+                this.exit(1);
+            }
+            if (err instanceof ApiKeyRequiredError) {
+                error("RCS capability checks require a live API key.", {
+                    hint: "The check reaches the carrier network, so test keys can't run it — create one with `sendly keys create --type live`",
+                });
+                this.exit(1);
+            }
+            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`",
+                });
+                this.exit(1);
+            }
+            throw err;
+        }
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success("RCS capability check", {
+            To: response.to,
+            Agent: colors.code(response.agentId),
+            Capable: response.capable
+                ? colors.success("yes")
+                : colors.error("no"),
+            Features: response.features?.length
+                ? response.features.join(", ")
+                : colors.dim("—"),
+        });
+        console.log();
+        if (response.capable) {
+            console.log(colors.dim(`Send with: ${colors.code(`sendly rcs send --to ${response.to} --text "Hello!"`)}`));
+        }
+        else {
+            console.log(colors.dim("Sends to this recipient will deliver as plain SMS (unless you pass --no-fallback)."));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"capability.js","sourceRoot":"","sources":["../../../src/commands/rcs/capability.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport {\n  apiClient,\n  ApiKeyRequiredError,\n  NotFoundError,\n  ValidationError,\n} from \"../../lib/api-client.js\";\nimport {\n  success,\n  error,\n  json,\n  colors,\n  spinner,\n  isJsonMode,\n} from \"../../lib/output.js\";\n\ninterface CapabilityResponse {\n  to: string;\n  agentId: string;\n  capable: boolean;\n  features: string[];\n}\n\nexport default class RcsCapability extends AuthenticatedCommand {\n  static description =\n    \"Check whether a recipient's device can receive RCS before you send\";\n\n  static examples = [\n    \"<%= config.bin %> rcs capability --to +15125550190\",\n    \"<%= config.bin %> rcs capability --to +15125550190 --agent 3f6a1c9e-0000-0000-0000-000000000000\",\n    \"<%= config.bin %> rcs capability --to +15125550190 --json\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    to: Flags.string({\n      char: \"t\",\n      description: \"Recipient phone number to check (E.164 format)\",\n      required: true,\n    }),\n    agent: Flags.string({\n      description:\n        \"RCS agent id to check with (only needed when your workspace has more than one — see `rcs agents`)\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(RcsCapability);\n\n    const checkSpinner = spinner(\"Checking RCS capability...\");\n    if (!isJsonMode()) {\n      checkSpinner.start();\n    }\n\n    let response: CapabilityResponse;\n    try {\n      response = await apiClient.get<CapabilityResponse>(\n        \"/api/v1/rcs/capability\",\n        {\n          to: flags.to,\n          ...(flags.agent && { agentId: flags.agent }),\n        },\n      );\n      checkSpinner.stop();\n    } catch (err: any) {\n      checkSpinner.stop();\n      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        this.exit(1);\n      }\n      if (err instanceof ApiKeyRequiredError) {\n        error(\"RCS capability checks require a live API key.\", {\n          hint: \"The check reaches the carrier network, so test keys can't run it — create one with `sendly keys create --type live`\",\n        });\n        this.exit(1);\n      }\n      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        this.exit(1);\n      }\n      throw err;\n    }\n\n    if (isJsonMode()) {\n      json(response);\n      return;\n    }\n\n    success(\"RCS capability check\", {\n      To: response.to,\n      Agent: colors.code(response.agentId),\n      Capable: response.capable\n        ? colors.success(\"yes\")\n        : colors.error(\"no\"),\n      Features: response.features?.length\n        ? response.features.join(\", \")\n        : colors.dim(\"—\"),\n    });\n\n    console.log();\n    if (response.capable) {\n      console.log(\n        colors.dim(\n          `Send with: ${colors.code(`sendly rcs send --to ${response.to} --text \"Hello!\"`)}`,\n        ),\n      );\n    } else {\n      console.log(\n        colors.dim(\n          \"Sends to this recipient will deliver as plain SMS (unless you pass --no-fallback).\",\n        ),\n      );\n    }\n  }\n}\n"]}

package/dist/commands/rcs/dossier.d.ts

@@ -0,0 +1,10 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class RcsDossier extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/rcs/dossier.js

@@ -0,0 +1,73 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, info, warn, colors, spinner, isJsonMode, keyValue, } from "../../lib/output.js";
+import { isDict, reportRcsError, } from "../../lib/rcs-registration.js";
+const SOURCE_LABELS = {
+    tendlc: "your 10DLC brand",
+    verification: "your toll-free verification",
+    none: "nothing on file yet",
+};
+function flatten(value, prefix, out) {
+    if (isDict(value)) {
+        for (const [key, inner] of Object.entries(value)) {
+            flatten(inner, prefix ? `${prefix}.${key}` : key, out);
+        }
+        return;
+    }
+    if (value === null || value === undefined || value === "")
+        return;
+    out.push([prefix, String(value)]);
+}
+export default class RcsDossier extends AuthenticatedCommand {
+    static description = "Show the brand details Sendly can prefill from your 10DLC brand or toll-free verification";
+    static examples = [
+        "<%= config.bin %> rcs dossier",
+        "<%= config.bin %> rcs dossier --json > brand.json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        await this.parse(RcsDossier);
+        const loadSpinner = spinner("Fetching prefill details...");
+        if (!isJsonMode()) {
+            loadSpinner.start();
+        }
+        let response;
+        try {
+            response = await apiClient.get("/api/v1/rcs/dossier");
+            loadSpinner.stop();
+        }
+        catch (err) {
+            loadSpinner.stop();
+            if (reportRcsError(err))
+                this.exit(1);
+            throw err;
+        }
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        const rows = [];
+        flatten(response.brand ?? {}, "", rows);
+        console.log();
+        console.log(colors.bold("Prefilled brand details"));
+        console.log(colors.dim(`Source: ${SOURCE_LABELS[response.source] ?? response.source}`));
+        console.log();
+        if (rows.length === 0) {
+            info("Nothing to prefill yet — you'll enter the brand details yourself.");
+        }
+        else {
+            keyValue(rows);
+        }
+        if (!response.usEligible) {
+            console.log();
+            warn("Something on file names a non-US country. RCS registration is available to US businesses for now.");
+        }
+        console.log();
+        console.log(colors.dim("Use it:"));
+        console.log(`  Save:  ${colors.code("sendly rcs dossier --json > brand.json")}`);
+        console.log(`  Draft: ${colors.code("sendly rcs brands create --from-json brand.json --ein 12-3456789 ...")}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9zc2llci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21tYW5kcy9yY3MvZG9zc2llci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNqRSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDcEQsT0FBTyxFQUNMLElBQUksRUFDSixJQUFJLEVBQ0osSUFBSSxFQUNKLE1BQU0sRUFDTixPQUFPLEVBQ1AsVUFBVSxFQUNWLFFBQVEsR0FDVCxNQUFNLHFCQUFxQixDQUFDO0FBQzdCLE9BQU8sRUFDTCxNQUFNLEVBQ04sY0FBYyxHQUVmLE1BQU0sK0JBQStCLENBQUM7QUFFdkMsTUFBTSxhQUFhLEdBQThDO0lBQy9ELE1BQU0sRUFBRSxrQkFBa0I7SUFDMUIsWUFBWSxFQUFFLDZCQUE2QjtJQUMzQyxJQUFJLEVBQUUscUJBQXFCO0NBQzVCLENBQUM7QUFFRixTQUFTLE9BQU8sQ0FDZCxLQUFjLEVBQ2QsTUFBYyxFQUNkLEdBQTRCO0lBRTVCLElBQUksTUFBTSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7UUFDbEIsS0FBSyxNQUFNLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUNqRCxPQUFPLENBQUMsS0FBSyxFQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUMsR0FBRyxNQUFNLElBQUksR0FBRyxFQUFFLENBQUMsQ0FBQyxDQUFDLEdBQUcsRUFBRSxHQUFHLENBQUMsQ0FBQztRQUN6RCxDQUFDO1FBQ0QsT0FBTztJQUNULENBQUM7SUFDRCxJQUFJLEtBQUssS0FBSyxJQUFJLElBQUksS0FBSyxLQUFLLFNBQVMsSUFBSSxLQUFLLEtBQUssRUFBRTtRQUFFLE9BQU87SUFDbEUsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQ3BDLENBQUM7QUFFRCxNQUFNLENBQUMsT0FBTyxPQUFPLFVBQVcsU0FBUSxvQkFBb0I7SUFDMUQsTUFBTSxDQUFDLFdBQVcsR0FDaEIsMkZBQTJGLENBQUM7SUFFOUYsTUFBTSxDQUFDLFFBQVEsR0FBRztRQUNoQiwrQkFBK0I7UUFDL0IsbURBQW1EO0tBQ3BELENBQUM7SUFFRixNQUFNLENBQUMsS0FBSyxHQUFHO1FBQ2IsR0FBRyxvQkFBb0IsQ0FBQyxTQUFTO0tBQ2xDLENBQUM7SUFFRixLQUFLLENBQUMsR0FBRztRQUNQLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUU3QixNQUFNLFdBQVcsR0FBRyxPQUFPLENBQUMsNkJBQTZCLENBQUMsQ0FBQztRQUMzRCxJQUFJLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQztZQUNsQixXQUFXLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDdEIsQ0FBQztRQUVELElBQUksUUFBeUIsQ0FBQztRQUM5QixJQUFJLENBQUM7WUFDSCxRQUFRLEdBQUcsTUFBTSxTQUFTLENBQUMsR0FBRyxDQUFrQixxQkFBcUIsQ0FBQyxDQUFDO1lBQ3ZFLFdBQVcsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNyQixDQUFDO1FBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztZQUNiLFdBQVcsQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUNuQixJQUFJLGNBQWMsQ0FBQyxHQUFHLENBQUM7Z0JBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUN0QyxNQUFNLEdBQUcsQ0FBQztRQUNaLENBQUM7UUFFRCxJQUFJLFVBQVUsRUFBRSxFQUFFLENBQUM7WUFDakIsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQ2YsT0FBTztRQUNULENBQUM7UUFFRCxNQUFNLElBQUksR0FBNEIsRUFBRSxDQUFDO1FBQ3pDLE9BQU8sQ0FBQyxRQUFRLENBQUMsS0FBSyxJQUFJLEVBQUUsRUFBRSxFQUFFLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFFeEMsT0FBTyxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBQ2QsT0FBTyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLHlCQUF5QixDQUFDLENBQUMsQ0FBQztRQUNwRCxPQUFPLENBQUMsR0FBRyxDQUNULE1BQU0sQ0FBQyxHQUFHLENBQUMsV0FBVyxhQUFhLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxJQUFJLFFBQVEsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUMzRSxDQUFDO1FBQ0YsT0FBTyxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBRWQsSUFBSSxJQUFJLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQ3RCLElBQUksQ0FBQyxtRUFBbUUsQ0FBQyxDQUFDO1FBQzVFLENBQUM7YUFBTSxDQUFDO1lBQ04sUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2pCLENBQUM7UUFFRCxJQUFJLENBQUMsUUFBUSxDQUFDLFVBQVUsRUFBRSxDQUFDO1lBQ3pCLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUNkLElBQUksQ0FDRixtR0FBbUcsQ0FDcEcsQ0FBQztRQUNKLENBQUM7UUFFRCxPQUFPLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDZCxPQUFPLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQztRQUNuQyxPQUFPLENBQUMsR0FBRyxDQUNULFlBQVksTUFBTSxDQUFDLElBQUksQ0FBQyx3Q0FBd0MsQ0FBQyxFQUFFLENBQ3BFLENBQUM7UUFDRixPQUFPLENBQUMsR0FBRyxDQUNULFlBQVksTUFBTSxDQUFDLElBQUksQ0FBQyxzRUFBc0UsQ0FBQyxFQUFFLENBQ2xHLENBQUM7SUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXV0aGVudGljYXRlZENvbW1hbmQgfSBmcm9tIFwiLi4vLi4vbGliL2Jhc2UtY29tbWFuZC5qc1wiO1xuaW1wb3J0IHsgYXBpQ2xpZW50IH0gZnJvbSBcIi4uLy4uL2xpYi9hcGktY2xpZW50LmpzXCI7XG5pbXBvcnQge1xuICBqc29uLFxuICBpbmZvLFxuICB3YXJuLFxuICBjb2xvcnMsXG4gIHNwaW5uZXIsXG4gIGlzSnNvbk1vZGUsXG4gIGtleVZhbHVlLFxufSBmcm9tIFwiLi4vLi4vbGliL291dHB1dC5qc1wiO1xuaW1wb3J0IHtcbiAgaXNEaWN0LFxuICByZXBvcnRSY3NFcnJvcixcbiAgdHlwZSBEb3NzaWVyUmVzcG9uc2UsXG59IGZyb20gXCIuLi8uLi9saWIvcmNzLXJlZ2lzdHJhdGlvbi5qc1wiO1xuXG5jb25zdCBTT1VSQ0VfTEFCRUxTOiBSZWNvcmQ8RG9zc2llclJlc3BvbnNlW1wic291cmNlXCJdLCBzdHJpbmc+ID0ge1xuICB0ZW5kbGM6IFwieW91ciAxMERMQyBicmFuZFwiLFxuICB2ZXJpZmljYXRpb246IFwieW91ciB0b2xsLWZyZWUgdmVyaWZpY2F0aW9uXCIsXG4gIG5vbmU6IFwibm90aGluZyBvbiBmaWxlIHlldFwiLFxufTtcblxuZnVuY3Rpb24gZmxhdHRlbihcbiAgdmFsdWU6IHVua25vd24sXG4gIHByZWZpeDogc3RyaW5nLFxuICBvdXQ6IEFycmF5PFtzdHJpbmcsIHN0cmluZ10+LFxuKTogdm9pZCB7XG4gIGlmIChpc0RpY3QodmFsdWUpKSB7XG4gICAgZm9yIChjb25zdCBba2V5LCBpbm5lcl0gb2YgT2JqZWN0LmVudHJpZXModmFsdWUpKSB7XG4gICAgICBmbGF0dGVuKGlubmVyLCBwcmVmaXggPyBgJHtwcmVmaXh9LiR7a2V5fWAgOiBrZXksIG91dCk7XG4gICAgfVxuICAgIHJldHVybjtcbiAgfVxuICBpZiAodmFsdWUgPT09IG51bGwgfHwgdmFsdWUgPT09IHVuZGVmaW5lZCB8fCB2YWx1ZSA9PT0gXCJcIikgcmV0dXJuO1xuICBvdXQucHVzaChbcHJlZml4LCBTdHJpbmcodmFsdWUpXSk7XG59XG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIFJjc0Rvc3NpZXIgZXh0ZW5kcyBBdXRoZW50aWNhdGVkQ29tbWFuZCB7XG4gIHN0YXRpYyBkZXNjcmlwdGlvbiA9XG4gICAgXCJTaG93IHRoZSBicmFuZCBkZXRhaWxzIFNlbmRseSBjYW4gcHJlZmlsbCBmcm9tIHlvdXIgMTBETEMgYnJhbmQgb3IgdG9sbC1mcmVlIHZlcmlmaWNhdGlvblwiO1xuXG4gIHN0YXRpYyBleGFtcGxlcyA9IFtcbiAgICBcIjwlPSBjb25maWcuYmluICU+IHJjcyBkb3NzaWVyXCIsXG4gICAgXCI8JT0gY29uZmlnLmJpbiAlPiByY3MgZG9zc2llciAtLWpzb24gPiBicmFuZC5qc29uXCIsXG4gIF07XG5cbiAgc3RhdGljIGZsYWdzID0ge1xuICAgIC4uLkF1dGhlbnRpY2F0ZWRDb21tYW5kLmJhc2VGbGFncyxcbiAgfTtcblxuICBhc3luYyBydW4oKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgYXdhaXQgdGhpcy5wYXJzZShSY3NEb3NzaWVyKTtcblxuICAgIGNvbnN0IGxvYWRTcGlubmVyID0gc3Bpbm5lcihcIkZldGNoaW5nIHByZWZpbGwgZGV0YWlscy4uLlwiKTtcbiAgICBpZiAoIWlzSnNvbk1vZGUoKSkge1xuICAgICAgbG9hZFNwaW5uZXIuc3RhcnQoKTtcbiAgICB9XG5cbiAgICBsZXQgcmVzcG9uc2U6IERvc3NpZXJSZXNwb25zZTtcbiAgICB0cnkge1xuICAgICAgcmVzcG9uc2UgPSBhd2FpdCBhcGlDbGllbnQuZ2V0PERvc3NpZXJSZXNwb25zZT4oXCIvYXBpL3YxL3Jjcy9kb3NzaWVyXCIpO1xuICAgICAgbG9hZFNwaW5uZXIuc3RvcCgpO1xuICAgIH0gY2F0Y2ggKGVycikge1xuICAgICAgbG9hZFNwaW5uZXIuc3RvcCgpO1xuICAgICAgaWYgKHJlcG9ydFJjc0Vycm9yKGVycikpIHRoaXMuZXhpdCgxKTtcbiAgICAgIHRocm93IGVycjtcbiAgICB9XG5cbiAgICBpZiAoaXNKc29uTW9kZSgpKSB7XG4gICAgICBqc29uKHJlc3BvbnNlKTtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBjb25zdCByb3dzOiBBcnJheTxbc3RyaW5nLCBzdHJpbmddPiA9IFtdO1xuICAgIGZsYXR0ZW4ocmVzcG9uc2UuYnJhbmQgPz8ge30sIFwiXCIsIHJvd3MpO1xuXG4gICAgY29uc29sZS5sb2coKTtcbiAgICBjb25zb2xlLmxvZyhjb2xvcnMuYm9sZChcIlByZWZpbGxlZCBicmFuZCBkZXRhaWxzXCIpKTtcbiAgICBjb25zb2xlLmxvZyhcbiAgICAgIGNvbG9ycy5kaW0oYFNvdXJjZTogJHtTT1VSQ0VfTEFCRUxTW3Jlc3BvbnNlLnNvdXJjZV0gPz8gcmVzcG9uc2Uuc291cmNlfWApLFxuICAgICk7XG4gICAgY29uc29sZS5sb2coKTtcblxuICAgIGlmIChyb3dzLmxlbmd0aCA9PT0gMCkge1xuICAgICAgaW5mbyhcIk5vdGhpbmcgdG8gcHJlZmlsbCB5ZXQg4oCUIHlvdSdsbCBlbnRlciB0aGUgYnJhbmQgZGV0YWlscyB5b3Vyc2VsZi5cIik7XG4gICAgfSBlbHNlIHtcbiAgICAgIGtleVZhbHVlKHJvd3MpO1xuICAgIH1cblxuICAgIGlmICghcmVzcG9uc2UudXNFbGlnaWJsZSkge1xuICAgICAgY29uc29sZS5sb2coKTtcbiAgICAgIHdhcm4oXG4gICAgICAgIFwiU29tZXRoaW5nIG9uIGZpbGUgbmFtZXMgYSBub24tVVMgY291bnRyeS4gUkNTIHJlZ2lzdHJhdGlvbiBpcyBhdmFpbGFibGUgdG8gVVMgYnVzaW5lc3NlcyBmb3Igbm93LlwiLFxuICAgICAgKTtcbiAgICB9XG5cbiAgICBjb25zb2xlLmxvZygpO1xuICAgIGNvbnNvbGUubG9nKGNvbG9ycy5kaW0oXCJVc2UgaXQ6XCIpKTtcbiAgICBjb25zb2xlLmxvZyhcbiAgICAgIGAgIFNhdmU6ICAke2NvbG9ycy5jb2RlKFwic2VuZGx5IHJjcyBkb3NzaWVyIC0tanNvbiA+IGJyYW5kLmpzb25cIil9YCxcbiAgICApO1xuICAgIGNvbnNvbGUubG9nKFxuICAgICAgYCAgRHJhZnQ6ICR7Y29sb3JzLmNvZGUoXCJzZW5kbHkgcmNzIGJyYW5kcyBjcmVhdGUgLS1mcm9tLWpzb24gYnJhbmQuanNvbiAtLWVpbiAxMi0zNDU2Nzg5IC4uLlwiKX1gLFxuICAgICk7XG4gIH1cbn1cbiJdfQ==

package/dist/commands/rcs/registration.d.ts

@@ -0,0 +1,10 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class RcsRegistration extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/rcs/registration.js

@@ -0,0 +1,59 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, info, warn, colors, spinner, isJsonMode, } from "../../lib/output.js";
+import { formatStage, nextStepFor, printAgent, printBrand, printDevices, printNextSteps, reportRcsError, } from "../../lib/rcs-registration.js";
+export default class RcsRegistration extends AuthenticatedCommand {
+    static description = "Show where your RCS registration stands — brand, agent, test devices, and what to do next";
+    static examples = [
+        "<%= config.bin %> rcs registration",
+        "<%= config.bin %> rcs registration --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        await this.parse(RcsRegistration);
+        const loadSpinner = spinner("Fetching RCS registration...");
+        if (!isJsonMode()) {
+            loadSpinner.start();
+        }
+        let response;
+        try {
+            response = await apiClient.get("/api/v1/rcs/registration");
+            loadSpinner.stop();
+        }
+        catch (err) {
+            loadSpinner.stop();
+            if (reportRcsError(err))
+                this.exit(1);
+            throw err;
+        }
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        const { brand, agent, devices, stage, usEligible } = response;
+        console.log();
+        console.log(`${colors.bold("RCS registration")}  ${formatStage(stage)}`);
+        console.log();
+        if (!usEligible) {
+            warn("The business details on file name a non-US country. RCS registration is available to US businesses for now.");
+            console.log();
+        }
+        if (!brand && !agent) {
+            info("No RCS registration yet.");
+            printNextSteps(nextStepFor("draft", {}));
+            return;
+        }
+        if (brand) {
+            printBrand(brand);
+            console.log();
+        }
+        if (agent) {
+            printAgent(agent);
+            printDevices(devices ?? []);
+        }
+        printNextSteps(nextStepFor(stage, { brandId: brand?.id, agentId: agent?.id }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0cmF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbW1hbmRzL3Jjcy9yZWdpc3RyYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDakUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3BELE9BQU8sRUFDTCxJQUFJLEVBQ0osSUFBSSxFQUNKLElBQUksRUFDSixNQUFNLEVBQ04sT0FBTyxFQUNQLFVBQVUsR0FDWCxNQUFNLHFCQUFxQixDQUFDO0FBQzdCLE9BQU8sRUFDTCxXQUFXLEVBQ1gsV0FBVyxFQUNYLFVBQVUsRUFDVixVQUFVLEVBQ1YsWUFBWSxFQUNaLGNBQWMsRUFDZCxjQUFjLEdBRWYsTUFBTSwrQkFBK0IsQ0FBQztBQUV2QyxNQUFNLENBQUMsT0FBTyxPQUFPLGVBQWdCLFNBQVEsb0JBQW9CO0lBQy9ELE1BQU0sQ0FBQyxXQUFXLEdBQ2hCLDJGQUEyRixDQUFDO0lBRTlGLE1BQU0sQ0FBQyxRQUFRLEdBQUc7UUFDaEIsb0NBQW9DO1FBQ3BDLDJDQUEyQztLQUM1QyxDQUFDO0lBRUYsTUFBTSxDQUFDLEtBQUssR0FBRztRQUNiLEdBQUcsb0JBQW9CLENBQUMsU0FBUztLQUNsQyxDQUFDO0lBRUYsS0FBSyxDQUFDLEdBQUc7UUFDUCxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsZUFBZSxDQUFDLENBQUM7UUFFbEMsTUFBTSxXQUFXLEdBQUcsT0FBTyxDQUFDLDhCQUE4QixDQUFDLENBQUM7UUFDNUQsSUFBSSxDQUFDLFVBQVUsRUFBRSxFQUFFLENBQUM7WUFDbEIsV0FBVyxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ3RCLENBQUM7UUFFRCxJQUFJLFFBQThCLENBQUM7UUFDbkMsSUFBSSxDQUFDO1lBQ0gsUUFBUSxHQUFHLE1BQU0sU0FBUyxDQUFDLEdBQUcsQ0FDNUIsMEJBQTBCLENBQzNCLENBQUM7WUFDRixXQUFXLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDckIsQ0FBQztRQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7WUFDYixXQUFXLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDbkIsSUFBSSxjQUFjLENBQUMsR0FBRyxDQUFDO2dCQUFFLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDdEMsTUFBTSxHQUFHLENBQUM7UUFDWixDQUFDO1FBRUQsSUFBSSxVQUFVLEVBQUUsRUFBRSxDQUFDO1lBQ2pCLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUNmLE9BQU87UUFDVCxDQUFDO1FBRUQsTUFBTSxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxVQUFVLEVBQUUsR0FBRyxRQUFRLENBQUM7UUFFOUQsT0FBTyxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBQ2QsT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsS0FBSyxXQUFXLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBQ3pFLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUVkLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztZQUNoQixJQUFJLENBQ0YsNkdBQTZHLENBQzlHLENBQUM7WUFDRixPQUFPLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDaEIsQ0FBQztRQUVELElBQUksQ0FBQyxLQUFLLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUNyQixJQUFJLENBQUMsMEJBQTBCLENBQUMsQ0FBQztZQUNqQyxjQUFjLENBQUMsV0FBVyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDO1lBQ3pDLE9BQU87UUFDVCxDQUFDO1FBRUQsSUFBSSxLQUFLLEVBQUUsQ0FBQztZQUNWLFVBQVUsQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUNsQixPQUFPLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDaEIsQ0FBQztRQUVELElBQUksS0FBSyxFQUFFLENBQUM7WUFDVixVQUFVLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDbEIsWUFBWSxDQUFDLE9BQU8sSUFBSSxFQUFFLENBQUMsQ0FBQztRQUM5QixDQUFDO1FBRUQsY0FBYyxDQUNaLFdBQVcsQ0FBQyxLQUFLLEVBQUUsRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLEVBQUUsRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQy9ELENBQUM7SUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXV0aGVudGljYXRlZENvbW1hbmQgfSBmcm9tIFwiLi4vLi4vbGliL2Jhc2UtY29tbWFuZC5qc1wiO1xuaW1wb3J0IHsgYXBpQ2xpZW50IH0gZnJvbSBcIi4uLy4uL2xpYi9hcGktY2xpZW50LmpzXCI7XG5pbXBvcnQge1xuICBqc29uLFxuICBpbmZvLFxuICB3YXJuLFxuICBjb2xvcnMsXG4gIHNwaW5uZXIsXG4gIGlzSnNvbk1vZGUsXG59IGZyb20gXCIuLi8uLi9saWIvb3V0cHV0LmpzXCI7XG5pbXBvcnQge1xuICBmb3JtYXRTdGFnZSxcbiAgbmV4dFN0ZXBGb3IsXG4gIHByaW50QWdlbnQsXG4gIHByaW50QnJhbmQsXG4gIHByaW50RGV2aWNlcyxcbiAgcHJpbnROZXh0U3RlcHMsXG4gIHJlcG9ydFJjc0Vycm9yLFxuICB0eXBlIFJlZ2lzdHJhdGlvblJlc3BvbnNlLFxufSBmcm9tIFwiLi4vLi4vbGliL3Jjcy1yZWdpc3RyYXRpb24uanNcIjtcblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgUmNzUmVnaXN0cmF0aW9uIGV4dGVuZHMgQXV0aGVudGljYXRlZENvbW1hbmQge1xuICBzdGF0aWMgZGVzY3JpcHRpb24gPVxuICAgIFwiU2hvdyB3aGVyZSB5b3VyIFJDUyByZWdpc3RyYXRpb24gc3RhbmRzIOKAlCBicmFuZCwgYWdlbnQsIHRlc3QgZGV2aWNlcywgYW5kIHdoYXQgdG8gZG8gbmV4dFwiO1xuXG4gIHN0YXRpYyBleGFtcGxlcyA9IFtcbiAgICBcIjwlPSBjb25maWcuYmluICU+IHJjcyByZWdpc3RyYXRpb25cIixcbiAgICBcIjwlPSBjb25maWcuYmluICU+IHJjcyByZWdpc3RyYXRpb24gLS1qc29uXCIsXG4gIF07XG5cbiAgc3RhdGljIGZsYWdzID0ge1xuICAgIC4uLkF1dGhlbnRpY2F0ZWRDb21tYW5kLmJhc2VGbGFncyxcbiAgfTtcblxuICBhc3luYyBydW4oKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgYXdhaXQgdGhpcy5wYXJzZShSY3NSZWdpc3RyYXRpb24pO1xuXG4gICAgY29uc3QgbG9hZFNwaW5uZXIgPSBzcGlubmVyKFwiRmV0Y2hpbmcgUkNTIHJlZ2lzdHJhdGlvbi4uLlwiKTtcbiAgICBpZiAoIWlzSnNvbk1vZGUoKSkge1xuICAgICAgbG9hZFNwaW5uZXIuc3RhcnQoKTtcbiAgICB9XG5cbiAgICBsZXQgcmVzcG9uc2U6IFJlZ2lzdHJhdGlvblJlc3BvbnNlO1xuICAgIHRyeSB7XG4gICAgICByZXNwb25zZSA9IGF3YWl0IGFwaUNsaWVudC5nZXQ8UmVnaXN0cmF0aW9uUmVzcG9uc2U+KFxuICAgICAgICBcIi9hcGkvdjEvcmNzL3JlZ2lzdHJhdGlvblwiLFxuICAgICAgKTtcbiAgICAgIGxvYWRTcGlubmVyLnN0b3AoKTtcbiAgICB9IGNhdGNoIChlcnIpIHtcbiAgICAgIGxvYWRTcGlubmVyLnN0b3AoKTtcbiAgICAgIGlmIChyZXBvcnRSY3NFcnJvcihlcnIpKSB0aGlzLmV4aXQoMSk7XG4gICAgICB0aHJvdyBlcnI7XG4gICAgfVxuXG4gICAgaWYgKGlzSnNvbk1vZGUoKSkge1xuICAgICAganNvbihyZXNwb25zZSk7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgY29uc3QgeyBicmFuZCwgYWdlbnQsIGRldmljZXMsIHN0YWdlLCB1c0VsaWdpYmxlIH0gPSByZXNwb25zZTtcblxuICAgIGNvbnNvbGUubG9nKCk7XG4gICAgY29uc29sZS5sb2coYCR7Y29sb3JzLmJvbGQoXCJSQ1MgcmVnaXN0cmF0aW9uXCIpfSAgJHtmb3JtYXRTdGFnZShzdGFnZSl9YCk7XG4gICAgY29uc29sZS5sb2coKTtcblxuICAgIGlmICghdXNFbGlnaWJsZSkge1xuICAgICAgd2FybihcbiAgICAgICAgXCJUaGUgYnVzaW5lc3MgZGV0YWlscyBvbiBmaWxlIG5hbWUgYSBub24tVVMgY291bnRyeS4gUkNTIHJlZ2lzdHJhdGlvbiBpcyBhdmFpbGFibGUgdG8gVVMgYnVzaW5lc3NlcyBmb3Igbm93LlwiLFxuICAgICAgKTtcbiAgICAgIGNvbnNvbGUubG9nKCk7XG4gICAgfVxuXG4gICAgaWYgKCFicmFuZCAmJiAhYWdlbnQpIHtcbiAgICAgIGluZm8oXCJObyBSQ1MgcmVnaXN0cmF0aW9uIHlldC5cIik7XG4gICAgICBwcmludE5leHRTdGVwcyhuZXh0U3RlcEZvcihcImRyYWZ0XCIsIHt9KSk7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgaWYgKGJyYW5kKSB7XG4gICAgICBwcmludEJyYW5kKGJyYW5kKTtcbiAgICAgIGNvbnNvbGUubG9nKCk7XG4gICAgfVxuXG4gICAgaWYgKGFnZW50KSB7XG4gICAgICBwcmludEFnZW50KGFnZW50KTtcbiAgICAgIHByaW50RGV2aWNlcyhkZXZpY2VzID8/IFtdKTtcbiAgICB9XG5cbiAgICBwcmludE5leHRTdGVwcyhcbiAgICAgIG5leHRTdGVwRm9yKHN0YWdlLCB7IGJyYW5kSWQ6IGJyYW5kPy5pZCwgYWdlbnRJZDogYWdlbnQ/LmlkIH0pLFxuICAgICk7XG4gIH1cbn1cbiJdfQ==

package/dist/commands/rcs/send.d.ts

@@ -0,0 +1,21 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class RcsSend extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        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 | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        agent: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "card-title": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "card-description": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "card-media": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "card-orientation": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "suggest-reply": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "suggest-url": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "no-fallback": 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>;
+    };
+    run(): Promise<void>;
+}

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":"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","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>;
     };