@sendly/cli 3.36.0 → 3.37.0

package/dist/commands/numbers/release.js

@@ -0,0 +1,67 @@
+import { Args, Flags } from "@oclif/core";
+import inquirer from "inquirer";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, info, json, colors, isJsonMode } from "../../lib/output.js";
+/**
+ * `sendly numbers release <id>` — give up a number you own. A live paid
+ * purchase is scheduled to release at the end of the current billing period
+ * (undo with `sendly numbers update <id> --keep`); anything else is released at
+ * the carrier immediately.
+ *
+ * Wraps `DELETE /api/v1/numbers/:id`. Prompts for confirmation unless --yes is
+ * passed. Returns 404 when the id isn't one of your numbers.
+ */
+export default class NumbersRelease extends AuthenticatedCommand {
+    static description = "Release a number you own (paid purchases release at period end, others immediately)";
+    static examples = [
+        "<%= config.bin %> numbers release num_abc123",
+        "<%= config.bin %> numbers release num_abc123 --yes",
+        "<%= config.bin %> numbers release num_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Phone number ID (from `sendly numbers list`)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(NumbersRelease);
+        if (!flags.yes && !isJsonMode() && process.stdin.isTTY) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Release ${colors.code(args.id)}? Paid numbers release at the end of the billing period; everything else releases immediately.`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                info("Release cancelled");
+                return;
+            }
+        }
+        const response = await apiClient.delete(`/api/v1/numbers/${encodeURIComponent(args.id)}`);
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (response.scheduled && response.scheduledReleaseAt) {
+            success("Number scheduled for release", {
+                Releases: new Date(response.scheduledReleaseAt).toLocaleDateString(),
+                Note: `It stays active until then. Undo with: sendly numbers update ${args.id} --keep`,
+            });
+            return;
+        }
+        success("Number released");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/numbers/update.d.ts

@@ -0,0 +1,25 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+/**
+ * `sendly numbers update <id>` — mutate a number you own. Two mutations are
+ * supported today:
+ *   --default   make this the workspace default sender (the number must be
+ *               active; the previous default is cleared atomically)
+ *   --keep      cancel a scheduled period-end release and keep the number
+ *
+ * Wraps `PATCH /api/v1/numbers/:id`. At least one of --default / --keep is
+ * required. Returns the full number record.
+ */
+export default class NumbersUpdate extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        default: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        keep: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        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/numbers/update.js

@@ -0,0 +1,70 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, json, colors, formatStatus, isJsonMode, } from "../../lib/output.js";
+/**
+ * `sendly numbers update <id>` — mutate a number you own. Two mutations are
+ * supported today:
+ *   --default   make this the workspace default sender (the number must be
+ *               active; the previous default is cleared atomically)
+ *   --keep      cancel a scheduled period-end release and keep the number
+ *
+ * Wraps `PATCH /api/v1/numbers/:id`. At least one of --default / --keep is
+ * required. Returns the full number record.
+ */
+export default class NumbersUpdate extends AuthenticatedCommand {
+    static description = "Update a number you own: make it the default sender (--default) or cancel a scheduled release (--keep)";
+    static examples = [
+        "<%= config.bin %> numbers update num_abc123 --default",
+        "<%= config.bin %> numbers update num_abc123 --keep",
+        "<%= config.bin %> numbers update num_abc123 --default --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Phone number ID (from `sendly numbers list`)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        default: Flags.boolean({
+            char: "d",
+            description: "Make this the workspace default sender (must be active)",
+            default: false,
+        }),
+        keep: Flags.boolean({
+            char: "k",
+            description: "Cancel a scheduled release and keep the number",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(NumbersUpdate);
+        const body = {};
+        if (flags.default)
+            body.isDefault = true;
+        if (flags.keep)
+            body.pendingCancellation = false;
+        if (Object.keys(body).length === 0) {
+            error("Nothing to update", {
+                hint: "Pass --default to make it the default sender, or --keep to cancel a scheduled release.",
+            });
+            this.exit(1);
+        }
+        const number = await apiClient.patch(`/api/v1/numbers/${encodeURIComponent(args.id)}`, body);
+        if (isJsonMode()) {
+            json(number);
+            return;
+        }
+        success("Number updated", {
+            ID: number.id,
+            Number: colors.code(number.phoneNumber),
+            Status: formatStatus(number.status),
+            Default: number.isDefault ? colors.success("yes") : "no",
+            "Pending release": number.pendingCancellation
+                ? colors.warning("yes")
+                : "no",
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,25 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+/**
+ * `sendly sms group` — send a group MMS to 2-8 recipients (US/Canada only).
+ *
+ * Wraps `POST /api/v1/messages/group`. Every recipient sees the others and
+ * replies fan out to the whole group. Group messaging is an A2P 10DLC
+ * capability, so the sending number must be an MMS-enabled, 10DLC-registered
+ * number you own — omit `--from` to use your workspace's default sender.
+ * Gated behind `group_mms` / `enable_mms` on the server; without the flag the
+ * server returns 403 and this command surfaces it.
+ */
+export default class SmsGroup extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        to: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, 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>;
+        from: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "media-url": 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/sms/group.js

@@ -0,0 +1,164 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, spinner, colors, formatStatus, json, isJsonMode, } from "../../lib/output.js";
+import inquirer from "inquirer";
+/**
+ * `sendly sms group` — send a group MMS to 2-8 recipients (US/Canada only).
+ *
+ * Wraps `POST /api/v1/messages/group`. Every recipient sees the others and
+ * replies fan out to the whole group. Group messaging is an A2P 10DLC
+ * capability, so the sending number must be an MMS-enabled, 10DLC-registered
+ * number you own — omit `--from` to use your workspace's default sender.
+ * Gated behind `group_mms` / `enable_mms` on the server; without the flag the
+ * server returns 403 and this command surfaces it.
+ */
+export default class SmsGroup extends AuthenticatedCommand {
+    static description = "Send a group MMS to 2-8 recipients (US/Canada only). Everyone sees the group and replies fan out to all participants.";
+    static examples = [
+        '<%= config.bin %> sms group --to +14155551234,+14155555678 --text "Team sync at noon?"',
+        '<%= config.bin %> sms group --to +14155551234,+14155555678 --media-url https://example.com/flyer.jpg',
+        '<%= config.bin %> sms group --to +14155551234,+14155555678 --text "Hi all" --from "+15551234567"',
+        '<%= config.bin %> sms group --to +14155551234,+14155555678 --text "Sale!" --type marketing',
+        '<%= config.bin %> sms group --to +14155551234,+14155555678 --text "Hi all" --json',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        to: Flags.string({
+            char: "t",
+            description: "Comma-separated recipient phone numbers (2-8, E.164 format, US/CA only)",
+        }),
+        text: Flags.string({
+            char: "m",
+            description: "Message text (optional when --media-url is provided)",
+        }),
+        from: Flags.string({
+            char: "f",
+            description: "Sender ID or phone number (MMS-enabled 10DLC number you own)",
+        }),
+        type: Flags.string({
+            description: "Message type: transactional (default) or marketing. Marketing applies quiet-hours rules.",
+            options: ["marketing", "transactional"],
+        }),
+        "media-url": Flags.string({
+            description: "Media URL to attach (MMS). Can be specified multiple times.",
+            multiple: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SmsGroup);
+        const mediaUrls = flags["media-url"];
+        const hasMedia = mediaUrls && mediaUrls.length > 0;
+        let rawTo = flags.to;
+        let text = flags.text;
+        if (!rawTo) {
+            if (process.stdin.isTTY) {
+                const answers = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "to",
+                        message: "Recipient phone numbers (comma-separated, 2-8):",
+                        validate: (input) => {
+                            if (!input.trim())
+                                return "At least 2 recipients are required";
+                            return true;
+                        },
+                    },
+                ]);
+                rawTo = answers.to;
+            }
+            else {
+                error("Missing required flag: --to", {
+                    hint: "Use --to +14155551234,+14155555678",
+                });
+                this.exit(1);
+            }
+        }
+        const to = rawTo
+            .split(",")
+            .map((p) => p.trim())
+            .filter((p) => p.length > 0)
+            .map((p) => (p.startsWith("+") ? p : `+${p}`));
+        if (to.length < 2) {
+            error("Group messaging requires at least 2 recipients", {
+                hint: "Pass 2-8 numbers: --to +14155551234,+14155555678",
+            });
+            this.exit(1);
+        }
+        if (to.length > 8) {
+            error("Group messaging supports at most 8 recipients");
+            this.exit(1);
+        }
+        for (const recipient of to) {
+            if (!/^\+[1-9]\d{1,14}$/.test(recipient)) {
+                error(`Invalid phone number: ${recipient}`, {
+                    hint: "Use E.164 format: +14155551234",
+                });
+                this.exit(1);
+            }
+        }
+        if (!text && !hasMedia) {
+            if (process.stdin.isTTY) {
+                const answers = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "text",
+                        message: "Message text:",
+                        validate: (input) => {
+                            if (!input.trim())
+                                return "Message text cannot be empty";
+                            return true;
+                        },
+                    },
+                ]);
+                text = answers.text;
+            }
+            else {
+                error("Either --text or --media-url is required");
+                this.exit(1);
+            }
+        }
+        if (text && !text.trim()) {
+            error("Message text cannot be empty");
+            this.exit(1);
+        }
+        const spin = spinner(`Sending group MMS to ${to.length} recipients...`);
+        spin.start();
+        try {
+            const response = await apiClient.post("/api/v1/messages/group", {
+                to,
+                ...(text && { text }),
+                ...(flags.from && { from: flags.from }),
+                ...(hasMedia && { mediaUrls }),
+                ...(flags.type && { messageType: flags.type }),
+            });
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Group MMS sent", {
+                ID: response.id,
+                Recipients: response.to.length,
+                Status: formatStatus(response.status),
+                ...(response.group_message_id && {
+                    "Group ID": response.group_message_id,
+                }),
+                ...(hasMedia && {
+                    Media: `${mediaUrls.length} attachment${mediaUrls.length > 1 ? "s" : ""}`,
+                }),
+                ...(response.simulated && { Simulated: "yes" }),
+            });
+            if (!isJsonMode()) {
+                for (const recipient of response.to) {
+                    console.log(`  ${colors.dim("To:")} ${colors.code(recipient)}`);
+                }
+            }
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"group.js","sourceRoot":"","sources":["../../../src/commands/sms/group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EACL,OAAO,EACP,KAAK,EACL,OAAO,EACP,MAAM,EACN,YAAY,EACZ,IAAI,EACJ,UAAU,GACX,MAAM,qBAAqB,CAAC;AAC7B,OAAO,QAAQ,MAAM,UAAU,CAAC;AAUhC;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,oBAAoB;IACxD,MAAM,CAAC,WAAW,GAChB,uHAAuH,CAAC;IAE1H,MAAM,CAAC,QAAQ,GAAG;QAChB,wFAAwF;QACxF,sGAAsG;QACtG,kGAAkG;QAClG,4FAA4F;QAC5F,mFAAmF;KACpF,CAAC;IAEF,MAAM,CAAC,KAAK,GAAG;QACb,GAAG,oBAAoB,CAAC,SAAS;QACjC,EAAE,EAAE,KAAK,CAAC,MAAM,CAAC;YACf,IAAI,EAAE,GAAG;YACT,WAAW,EACT,yEAAyE;SAC5E,CAAC;QACF,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC;YACjB,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,sDAAsD;SACpE,CAAC;QACF,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC;YACjB,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,8DAA8D;SAC5E,CAAC;QACF,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC;YACjB,WAAW,EACT,0FAA0F;YAC5F,OAAO,EAAE,CAAC,WAAW,EAAE,eAAe,CAAC;SACxC,CAAC;QACF,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC;YACxB,WAAW,EAAE,6DAA6D;YAC1E,QAAQ,EAAE,IAAI;SACf,CAAC;KACH,CAAC;IAEF,KAAK,CAAC,GAAG;QACP,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAC7C,MAAM,SAAS,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC;QACrC,MAAM,QAAQ,GAAG,SAAS,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;QAEnD,IAAI,KAAK,GAAG,KAAK,CAAC,EAAE,CAAC;QACrB,IAAI,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;QAEtB,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;gBACxB,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAC;oBACpC;wBACE,IAAI,EAAE,OAAO;wBACb,IAAI,EAAE,IAAI;wBACV,OAAO,EAAE,iDAAiD;wBAC1D,QAAQ,EAAE,CAAC,KAAa,EAAE,EAAE;4BAC1B,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE;gCAAE,OAAO,oCAAoC,CAAC;4BAC/D,OAAO,IAAI,CAAC;wBACd,CAAC;qBACF;iBACF,CAAC,CAAC;gBACH,KAAK,GAAG,OAAO,CAAC,EAAE,CAAC;YACrB,CAAC;iBAAM,CAAC;gBACN,KAAK,CAAC,6BAA6B,EAAE;oBACnC,IAAI,EAAE,oCAAoC;iBAC3C,CAAC,CAAC;gBACH,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACf,CAAC;QACH,CAAC;QAED,MAAM,EAAE,GAAG,KAAM;aACd,KAAK,CAAC,GAAG,CAAC;aACV,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;aACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;aAC3B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;QAEjD,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAClB,KAAK,CAAC,gDAAgD,EAAE;gBACtD,IAAI,EAAE,kDAAkD;aACzD,CAAC,CAAC;YACH,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QAED,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAClB,KAAK,CAAC,+CAA+C,CAAC,CAAC;YACvD,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QAED,KAAK,MAAM,SAAS,IAAI,EAAE,EAAE,CAAC;YAC3B,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;gBACzC,KAAK,CAAC,yBAAyB,SAAS,EAAE,EAAE;oBAC1C,IAAI,EAAE,gCAAgC;iBACvC,CAAC,CAAC;gBACH,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACf,CAAC;QACH,CAAC;QAED,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACvB,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;gBACxB,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAC;oBACpC;wBACE,IAAI,EAAE,OAAO;wBACb,IAAI,EAAE,MAAM;wBACZ,OAAO,EAAE,eAAe;wBACxB,QAAQ,EAAE,CAAC,KAAa,EAAE,EAAE;4BAC1B,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE;gCAAE,OAAO,8BAA8B,CAAC;4BACzD,OAAO,IAAI,CAAC;wBACd,CAAC;qBACF;iBACF,CAAC,CAAC;gBACH,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;YACtB,CAAC;iBAAM,CAAC;gBACN,KAAK,CAAC,0CAA0C,CAAC,CAAC;gBAClD,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACf,CAAC;QACH,CAAC;QAED,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;YACzB,KAAK,CAAC,8BAA8B,CAAC,CAAC;YACtC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QAED,MAAM,IAAI,GAAG,OAAO,CAAC,wBAAwB,EAAE,CAAC,MAAM,gBAAgB,CAAC,CAAC;QACxE,IAAI,CAAC,KAAK,EAAE,CAAC;QAEb,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,IAAI,CACnC,wBAAwB,EACxB;gBACE,EAAE;gBACF,GAAG,CAAC,IAAI,IAAI,EAAE,IAAI,EAAE,CAAC;gBACrB,GAAG,CAAC,KAAK,CAAC,IAAI,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC;gBACvC,GAAG,CAAC,QAAQ,IAAI,EAAE,SAAS,EAAE,CAAC;gBAC9B,GAAG,CAAC,KAAK,CAAC,IAAI,IAAI,EAAE,WAAW,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC;aAC/C,CACF,CAAC;YAEF,IAAI,CAAC,IAAI,EAAE,CAAC;YAEZ,IAAI,UAAU,EAAE,EAAE,CAAC;gBACjB,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACf,OAAO;YACT,CAAC;YAED,OAAO,CAAC,gBAAgB,EAAE;gBACxB,EAAE,EAAE,QAAQ,CAAC,EAAE;gBACf,UAAU,EAAE,QAAQ,CAAC,EAAE,CAAC,MAAM;gBAC9B,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC;gBACrC,GAAG,CAAC,QAAQ,CAAC,gBAAgB,IAAI;oBAC/B,UAAU,EAAE,QAAQ,CAAC,gBAAgB;iBACtC,CAAC;gBACF,GAAG,CAAC,QAAQ,IAAI;oBACd,KAAK,EAAE,GAAG,SAAS,CAAC,MAAM,cAAc,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;iBAC1E,CAAC;gBACF,GAAG,CAAC,QAAQ,CAAC,SAAS,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;aAChD,CAAC,CAAC;YAEH,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;gBAClB,KAAK,MAAM,SAAS,IAAI,QAAQ,CAAC,EAAE,EAAE,CAAC;oBACpC,OAAO,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;gBAClE,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,IAAI,EAAE,CAAC;YACZ,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport {\n  success,\n  error,\n  spinner,\n  colors,\n  formatStatus,\n  json,\n  isJsonMode,\n} from \"../../lib/output.js\";\nimport inquirer from \"inquirer\";\n\ninterface GroupMessageResponse {\n  id: string;\n  status: string;\n  to: string[];\n  group_message_id?: string;\n  simulated?: boolean;\n}\n\n/**\n * `sendly sms group` — send a group MMS to 2-8 recipients (US/Canada only).\n *\n * Wraps `POST /api/v1/messages/group`. Every recipient sees the others and\n * replies fan out to the whole group. Group messaging is an A2P 10DLC\n * capability, so the sending number must be an MMS-enabled, 10DLC-registered\n * number you own — omit `--from` to use your workspace's default sender.\n * Gated behind `group_mms` / `enable_mms` on the server; without the flag the\n * server returns 403 and this command surfaces it.\n */\nexport default class SmsGroup extends AuthenticatedCommand {\n  static description =\n    \"Send a group MMS to 2-8 recipients (US/Canada only). Everyone sees the group and replies fan out to all participants.\";\n\n  static examples = [\n    '<%= config.bin %> sms group --to +14155551234,+14155555678 --text \"Team sync at noon?\"',\n    '<%= config.bin %> sms group --to +14155551234,+14155555678 --media-url https://example.com/flyer.jpg',\n    '<%= config.bin %> sms group --to +14155551234,+14155555678 --text \"Hi all\" --from \"+15551234567\"',\n    '<%= config.bin %> sms group --to +14155551234,+14155555678 --text \"Sale!\" --type marketing',\n    '<%= config.bin %> sms group --to +14155551234,+14155555678 --text \"Hi all\" --json',\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    to: Flags.string({\n      char: \"t\",\n      description:\n        \"Comma-separated recipient phone numbers (2-8, E.164 format, US/CA only)\",\n    }),\n    text: Flags.string({\n      char: \"m\",\n      description: \"Message text (optional when --media-url is provided)\",\n    }),\n    from: Flags.string({\n      char: \"f\",\n      description: \"Sender ID or phone number (MMS-enabled 10DLC number you own)\",\n    }),\n    type: Flags.string({\n      description:\n        \"Message type: transactional (default) or marketing. Marketing applies quiet-hours rules.\",\n      options: [\"marketing\", \"transactional\"],\n    }),\n    \"media-url\": Flags.string({\n      description: \"Media URL to attach (MMS). Can be specified multiple times.\",\n      multiple: true,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(SmsGroup);\n    const mediaUrls = flags[\"media-url\"];\n    const hasMedia = mediaUrls && mediaUrls.length > 0;\n\n    let rawTo = flags.to;\n    let text = flags.text;\n\n    if (!rawTo) {\n      if (process.stdin.isTTY) {\n        const answers = await inquirer.prompt([\n          {\n            type: \"input\",\n            name: \"to\",\n            message: \"Recipient phone numbers (comma-separated, 2-8):\",\n            validate: (input: string) => {\n              if (!input.trim()) return \"At least 2 recipients are required\";\n              return true;\n            },\n          },\n        ]);\n        rawTo = answers.to;\n      } else {\n        error(\"Missing required flag: --to\", {\n          hint: \"Use --to +14155551234,+14155555678\",\n        });\n        this.exit(1);\n      }\n    }\n\n    const to = rawTo!\n      .split(\",\")\n      .map((p) => p.trim())\n      .filter((p) => p.length > 0)\n      .map((p) => (p.startsWith(\"+\") ? p : `+${p}`));\n\n    if (to.length < 2) {\n      error(\"Group messaging requires at least 2 recipients\", {\n        hint: \"Pass 2-8 numbers: --to +14155551234,+14155555678\",\n      });\n      this.exit(1);\n    }\n\n    if (to.length > 8) {\n      error(\"Group messaging supports at most 8 recipients\");\n      this.exit(1);\n    }\n\n    for (const recipient of to) {\n      if (!/^\\+[1-9]\\d{1,14}$/.test(recipient)) {\n        error(`Invalid phone number: ${recipient}`, {\n          hint: \"Use E.164 format: +14155551234\",\n        });\n        this.exit(1);\n      }\n    }\n\n    if (!text && !hasMedia) {\n      if (process.stdin.isTTY) {\n        const answers = await inquirer.prompt([\n          {\n            type: \"input\",\n            name: \"text\",\n            message: \"Message text:\",\n            validate: (input: string) => {\n              if (!input.trim()) return \"Message text cannot be empty\";\n              return true;\n            },\n          },\n        ]);\n        text = answers.text;\n      } else {\n        error(\"Either --text or --media-url is required\");\n        this.exit(1);\n      }\n    }\n\n    if (text && !text.trim()) {\n      error(\"Message text cannot be empty\");\n      this.exit(1);\n    }\n\n    const spin = spinner(`Sending group MMS to ${to.length} recipients...`);\n    spin.start();\n\n    try {\n      const response = await apiClient.post<GroupMessageResponse>(\n        \"/api/v1/messages/group\",\n        {\n          to,\n          ...(text && { text }),\n          ...(flags.from && { from: flags.from }),\n          ...(hasMedia && { mediaUrls }),\n          ...(flags.type && { messageType: flags.type }),\n        },\n      );\n\n      spin.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      success(\"Group MMS sent\", {\n        ID: response.id,\n        Recipients: response.to.length,\n        Status: formatStatus(response.status),\n        ...(response.group_message_id && {\n          \"Group ID\": response.group_message_id,\n        }),\n        ...(hasMedia && {\n          Media: `${mediaUrls.length} attachment${mediaUrls.length > 1 ? \"s\" : \"\"}`,\n        }),\n        ...(response.simulated && { Simulated: \"yes\" }),\n      });\n\n      if (!isJsonMode()) {\n        for (const recipient of response.to) {\n          console.log(`  ${colors.dim(\"To:\")} ${colors.code(recipient)}`);\n        }\n      }\n    } catch (err) {\n      spin.stop();\n      throw err;\n    }\n  }\n}\n"]}

package/dist/commands/sms/upload-media.d.ts

@@ -3,7 +3,7 @@ import { AuthenticatedCommand } from "../../lib/base-command.js";
  * `sendly sms upload-media <file>` — upload an image for MMS.
  *
  * Wraps `POST /api/v1/media`. Returns a public URL the caller passes as
- * `--media` to `sms send` / `sms batch`. Flag-gated behind `enable_mms`
+ * `--media-url` to `sms send`. Flag-gated behind `enable_mms`
  * on the server — if your account doesn't have MMS, the server returns
  * 403 and this command surfaces it.
  */

package/dist/commands/sms/upload-media.js

@@ -9,12 +9,12 @@ const ALLOWED_EXTS = [".jpg", ".jpeg", ".png", ".gif"];
  * `sendly sms upload-media <file>` — upload an image for MMS.
  *
  * Wraps `POST /api/v1/media`. Returns a public URL the caller passes as
- * `--media` to `sms send` / `sms batch`. Flag-gated behind `enable_mms`
+ * `--media-url` to `sms send`. Flag-gated behind `enable_mms`
  * on the server — if your account doesn't have MMS, the server returns
  * 403 and this command surfaces it.
  */
 export default class SmsUploadMedia extends AuthenticatedCommand {
-    static description = "Upload a JPEG/PNG/GIF image for MMS and get back a public URL to pass to `sms send --media`. Requires MMS to be enabled for your account.";
+    static description = "Upload a JPEG/PNG/GIF image for MMS and get back a public URL to pass to `sms send --media-url`. Requires MMS to be enabled for your account.";
     static examples = [
         "<%= config.bin %> sms upload-media ./promo.jpg",
         "<%= config.bin %> sms upload-media ./animated.gif --json",
@@ -69,7 +69,7 @@ export default class SmsUploadMedia extends AuthenticatedCommand {
         console.log();
         console.log(colors.dim("  Send an MMS with this image:"));
         console.log("    " +
-            colors.code(`sendly sms send --to +15551234567 --text "Hi" --media "${resp.url}"`));
+            colors.code(`sendly sms send --to +15551234567 --text "Hi" --media-url "${resp.url}"`));
     }
 }
 function formatBytes(n) {
@@ -79,4 +79,4 @@ function formatBytes(n) {
         return `${(n / 1024).toFixed(1)} KB`;
     return `${(n / (1024 * 1024)).toFixed(1)} MB`;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/templates/enhance.js

@@ -51,8 +51,8 @@ export default class TemplatesEnhance extends AuthenticatedCommand {
                 process.stdin.on("end", () => resolve(buf.trim()));
             });
         }
-        if (!text && !flags["message-type"]) {
-            error("Provide text via --text, --file, positional arg, or stdin (or at least --message-type for a template suggestion).");
+        if (!text) {
+            error("Provide text to enhance via --text, --file, a positional arg, or stdin.");
             this.exit(1);
         }
         const resp = await apiClient.post("/api/v1/ai/enhance", {
@@ -74,4 +74,4 @@ export default class TemplatesEnhance extends AuthenticatedCommand {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5oYW5jZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21tYW5kcy90ZW1wbGF0ZXMvZW5oYW5jZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUMxQyxPQUFPLEtBQUssRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUM5QixPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNqRSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDcEQsT0FBTyxFQUNMLE9BQU8sRUFDUCxJQUFJLEVBQ0osVUFBVSxFQUNWLE1BQU0sRUFDTixNQUFNLEVBQ04sSUFBSSxFQUNKLEtBQUssR0FDTixNQUFNLHFCQUFxQixDQUFDO0FBTzdCOzs7Ozs7OztHQVFHO0FBQ0gsTUFBTSxDQUFDLE9BQU8sT0FBTyxnQkFBaUIsU0FBUSxvQkFBb0I7SUFDaEUsTUFBTSxDQUFDLFdBQVcsR0FDaEIseUhBQXlILENBQUM7SUFFNUgsTUFBTSxDQUFDLFFBQVEsR0FBRztRQUNoQiwwRUFBMEU7UUFDMUUsaUZBQWlGO1FBQ2pGLDhGQUE4RjtLQUMvRixDQUFDO0lBRUYsTUFBTSxDQUFDLElBQUksR0FBRztRQUNaLElBQUksRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDO1lBQ2hCLFdBQVcsRUFBRSwwREFBMEQ7WUFDdkUsUUFBUSxFQUFFLEtBQUs7U0FDaEIsQ0FBQztLQUNILENBQUM7SUFFRixNQUFNLENBQUMsS0FBSyxHQUFHO1FBQ2IsR0FBRyxvQkFBb0IsQ0FBQyxTQUFTO1FBQ2pDLElBQUksRUFBRSxLQUFLLENBQUMsTUFBTSxDQUFDO1lBQ2pCLFdBQVcsRUFBRSx5QkFBeUI7U0FDdkMsQ0FBQztRQUNGLElBQUksRUFBRSxLQUFLLENBQUMsTUFBTSxDQUFDO1lBQ2pCLFdBQVcsRUFBRSxvQ0FBb0M7U0FDbEQsQ0FBQztRQUNGLGNBQWMsRUFBRSxLQUFLLENBQUMsTUFBTSxDQUFDO1lBQzNCLFdBQVcsRUFDVCxrR0FBa0c7U0FDckcsQ0FBQztLQUNILENBQUM7SUFFRixLQUFLLENBQUMsR0FBRztRQUNQLE1BQU0sRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLEdBQUcsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLGdCQUFnQixDQUFDLENBQUM7UUFFM0QsSUFBSSxJQUFJLEdBQXVCLEtBQUssQ0FBQyxJQUFJLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQztRQUN2RCxJQUFJLENBQUMsSUFBSSxJQUFJLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUN4QixJQUFJLEdBQUcsRUFBRSxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ3BELENBQUM7UUFDRCxJQUFJLENBQUMsSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUNsQyxJQUFJLEdBQUcsTUFBTSxJQUFJLE9BQU8sQ0FBUyxDQUFDLE9BQU8sRUFBRSxFQUFFO2dCQUMzQyxJQUFJLEdBQUcsR0FBRyxFQUFFLENBQUM7Z0JBQ2IsT0FBTyxDQUFDLEtBQUssQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLENBQUM7Z0JBQ2xDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztnQkFDNUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsS0FBSyxFQUFFLEdBQUcsRUFBRSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDO1lBQ3JELENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztRQUVELElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUNWLEtBQUssQ0FDSCx5RUFBeUUsQ0FDMUUsQ0FBQztZQUNGLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDZixDQUFDO1FBRUQsTUFBTSxJQUFJLEdBQUcsTUFBTSxTQUFTLENBQUMsSUFBSSxDQUMvQixvQkFBb0IsRUFDcEI7WUFDRSxJQUFJLEVBQUUsSUFBSSxJQUFJLEVBQUU7WUFDaEIsV0FBVyxFQUFFLEtBQUssQ0FBQyxjQUFjLENBQUM7U0FDbkMsQ0FDRixDQUFDO1FBRUYsSUFBSSxVQUFVLEVBQUUsRUFBRSxDQUFDO1lBQ2pCLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUNYLE9BQU87UUFDVCxDQUFDO1FBRUQsTUFBTSxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQ3hCLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxHQUFHLENBQUMsSUFBSSxDQUFDLFFBQVEsSUFBSSxNQUFNLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNqRSxJQUFJLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUNyQixPQUFPLENBQUMsR0FBRyxFQUFFLENBQUM7WUFDZCxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQ3pCLENBQUM7UUFDRCxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsSUFBSSxJQUFJLENBQUMsUUFBUSxLQUFLLElBQUksRUFBRSxDQUFDO1lBQzdDLE9BQU8sQ0FBQyxzREFBc0QsQ0FBQyxDQUFDO1FBQ2xFLENBQUM7SUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXJncywgRmxhZ3MgfSBmcm9tIFwiQG9jbGlmL2NvcmVcIjtcbmltcG9ydCAqIGFzIGZzIGZyb20gXCJub2RlOmZzXCI7XG5pbXBvcnQgeyBBdXRoZW50aWNhdGVkQ29tbWFuZCB9IGZyb20gXCIuLi8uLi9saWIvYmFzZS1jb21tYW5kLmpzXCI7XG5pbXBvcnQgeyBhcGlDbGllbnQgfSBmcm9tIFwiLi4vLi4vbGliL2FwaS1jbGllbnQuanNcIjtcbmltcG9ydCB7XG4gIHN1Y2Nlc3MsXG4gIGpzb24sXG4gIGlzSnNvbk1vZGUsXG4gIGNvbG9ycyxcbiAgaGVhZGVyLFxuICBpbmZvLFxuICBlcnJvcixcbn0gZnJvbSBcIi4uLy4uL2xpYi9vdXRwdXQuanNcIjtcblxuaW50ZXJmYWNlIEVuaGFuY2VSZXNwb25zZSB7XG4gIGVuaGFuY2VkOiBzdHJpbmc7XG4gIGV4cGxhbmF0aW9uOiBzdHJpbmc7XG59XG5cbi8qKlxuICogYHNlbmRseSB0ZW1wbGF0ZXMgZW5oYW5jZWAg4oCUIEFJIHJld3JpdGUgYSBtZXNzYWdlIHRlbXBsYXRlIGZvclxuICogY29tcGxpYW5jZS9jbGFyaXR5L2NvbnZlcnNpb25zLlxuICpcbiAqIFdyYXBzIGBQT1NUIC9hcGkvdjEvYWkvZW5oYW5jZWAgKGZsYWctZ2F0ZWQgYmVoaW5kIGBhaV9jbGFzc2lmaWNhdGlvbmBcbiAqIG9uIHRoZSBzZXJ2ZXIg4oCUIGlmIHlvdXIgYWNjb3VudCBkb2Vzbid0IGhhdmUgdGhlIGZsYWcsIHRoZSBzZXJ2ZXJcbiAqIHJldHVybnMgNDA0IGFuZCB0aGlzIGNvbW1hbmQgc3VyZmFjZXMgaXQpLiBBY2NlcHRzIHRleHQgZGlyZWN0bHkgdmlhXG4gKiBgLS10ZXh0YCwgZnJvbSBhIGZpbGUgdmlhIGAtLWZpbGVgLCBvciBwaXBlZCBvbiBzdGRpbi5cbiAqL1xuZXhwb3J0IGRlZmF1bHQgY2xhc3MgVGVtcGxhdGVzRW5oYW5jZSBleHRlbmRzIEF1dGhlbnRpY2F0ZWRDb21tYW5kIHtcbiAgc3RhdGljIGRlc2NyaXB0aW9uID1cbiAgICBcIkFJLWVuaGFuY2UgYSBtZXNzYWdlIHRlbXBsYXRlIGZvciBjbGFyaXR5LCBjb21wbGlhbmNlLCBhbmQgc2VuZC1yZWFkaW5lc3MuIFJldHVybnMgdGhlIHJld3JpdHRlbiB0ZXh0ICsgYW4gZXhwbGFuYXRpb24uXCI7XG5cbiAgc3RhdGljIGV4YW1wbGVzID0gW1xuICAgICc8JT0gY29uZmlnLmJpbiAlPiB0ZW1wbGF0ZXMgZW5oYW5jZSAtLXRleHQgXCJoZXkgY29tZSBjaGVjayBvdXQgb3VyIHNhbGVcIicsXG4gICAgJzwlPSBjb25maWcuYmluICU+IHRlbXBsYXRlcyBlbmhhbmNlIC0tZmlsZSAuL2RyYWZ0LnR4dCAtLW1lc3NhZ2UtdHlwZSBtYXJrZXRpbmcnLFxuICAgICc8JT0gY29uZmlnLmJpbiAlPiBlY2hvIFwieW91ciBzYWxlIG1zZ1wiIHwgc2VuZGx5IHRlbXBsYXRlcyBlbmhhbmNlIC0tbWVzc2FnZS10eXBlIHByb21vdGlvbmFsJyxcbiAgXTtcblxuICBzdGF0aWMgYXJncyA9IHtcbiAgICB0ZXh0OiBBcmdzLnN0cmluZyh7XG4gICAgICBkZXNjcmlwdGlvbjogXCJNZXNzYWdlIHRleHQgdG8gZW5oYW5jZSAoYWx0ZXJuYXRpdmUgdG8gLS10ZXh0IC8gLS1maWxlKVwiLFxuICAgICAgcmVxdWlyZWQ6IGZhbHNlLFxuICAgIH0pLFxuICB9O1xuXG4gIHN0YXRpYyBmbGFncyA9IHtcbiAgICAuLi5BdXRoZW50aWNhdGVkQ29tbWFuZC5iYXNlRmxhZ3MsXG4gICAgdGV4dDogRmxhZ3Muc3RyaW5nKHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcIk1lc3NhZ2UgdGV4dCB0byBlbmhhbmNlXCIsXG4gICAgfSksXG4gICAgZmlsZTogRmxhZ3Muc3RyaW5nKHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcIlJlYWQgbWVzc2FnZSB0ZXh0IGZyb20gYSBmaWxlIHBhdGhcIixcbiAgICB9KSxcbiAgICBcIm1lc3NhZ2UtdHlwZVwiOiBGbGFncy5zdHJpbmcoe1xuICAgICAgZGVzY3JpcHRpb246XG4gICAgICAgIFwiSGludCB0aGUga2luZCBvZiBtZXNzYWdlIChlLmcuIG1hcmtldGluZywgdHJhbnNhY3Rpb25hbCwgbm90aWZpY2F0aW9uKSBmb3IgdGFyZ2V0ZWQgZW5oYW5jZW1lbnRzXCIsXG4gICAgfSksXG4gIH07XG5cbiAgYXN5bmMgcnVuKCk6IFByb21pc2U8dm9pZD4ge1xuICAgIGNvbnN0IHsgYXJncywgZmxhZ3MgfSA9IGF3YWl0IHRoaXMucGFyc2UoVGVtcGxhdGVzRW5oYW5jZSk7XG5cbiAgICBsZXQgdGV4dDogc3RyaW5nIHwgdW5kZWZpbmVkID0gZmxhZ3MudGV4dCA/PyBhcmdzLnRleHQ7XG4gICAgaWYgKCF0ZXh0ICYmIGZsYWdzLmZpbGUpIHtcbiAgICAgIHRleHQgPSBmcy5yZWFkRmlsZVN5bmMoZmxhZ3MuZmlsZSwgXCJ1dGY4XCIpLnRyaW0oKTtcbiAgICB9XG4gICAgaWYgKCF0ZXh0ICYmICFwcm9jZXNzLnN0ZGluLmlzVFRZKSB7XG4gICAgICB0ZXh0ID0gYXdhaXQgbmV3IFByb21pc2U8c3RyaW5nPigocmVzb2x2ZSkgPT4ge1xuICAgICAgICBsZXQgYnVmID0gXCJcIjtcbiAgICAgICAgcHJvY2Vzcy5zdGRpbi5zZXRFbmNvZGluZyhcInV0ZjhcIik7XG4gICAgICAgIHByb2Nlc3Muc3RkaW4ub24oXCJkYXRhXCIsIChjKSA9PiAoYnVmICs9IGMpKTtcbiAgICAgICAgcHJvY2Vzcy5zdGRpbi5vbihcImVuZFwiLCAoKSA9PiByZXNvbHZlKGJ1Zi50cmltKCkpKTtcbiAgICAgIH0pO1xuICAgIH1cblxuICAgIGlmICghdGV4dCkge1xuICAgICAgZXJyb3IoXG4gICAgICAgIFwiUHJvdmlkZSB0ZXh0IHRvIGVuaGFuY2UgdmlhIC0tdGV4dCwgLS1maWxlLCBhIHBvc2l0aW9uYWwgYXJnLCBvciBzdGRpbi5cIixcbiAgICAgICk7XG4gICAgICB0aGlzLmV4aXQoMSk7XG4gICAgfVxuXG4gICAgY29uc3QgcmVzcCA9IGF3YWl0IGFwaUNsaWVudC5wb3N0PEVuaGFuY2VSZXNwb25zZT4oXG4gICAgICBcIi9hcGkvdjEvYWkvZW5oYW5jZVwiLFxuICAgICAge1xuICAgICAgICB0ZXh0OiB0ZXh0ID8/IFwiXCIsXG4gICAgICAgIG1lc3NhZ2VUeXBlOiBmbGFnc1tcIm1lc3NhZ2UtdHlwZVwiXSxcbiAgICAgIH0sXG4gICAgKTtcblxuICAgIGlmIChpc0pzb25Nb2RlKCkpIHtcbiAgICAgIGpzb24ocmVzcCk7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgaGVhZGVyKFwiRW5oYW5jZWQgdGV4dFwiKTtcbiAgICBjb25zb2xlLmxvZyhcIiAgXCIgKyAocmVzcC5lbmhhbmNlZCB8fCBjb2xvcnMuZGltKFwiKG5vIGNoYW5nZSlcIikpKTtcbiAgICBpZiAocmVzcC5leHBsYW5hdGlvbikge1xuICAgICAgY29uc29sZS5sb2coKTtcbiAgICAgIGluZm8ocmVzcC5leHBsYW5hdGlvbik7XG4gICAgfVxuICAgIGlmICghcmVzcC5lbmhhbmNlZCB8fCByZXNwLmVuaGFuY2VkID09PSB0ZXh0KSB7XG4gICAgICBzdWNjZXNzKFwiTm8gZW5oYW5jZW1lbnQgc3VnZ2VzdGVkIOKAlCBvcmlnaW5hbCB0ZXh0IGxvb2tzIGdvb2QuXCIpO1xuICAgIH1cbiAgfVxufVxuIl19

package/dist/commands/upgrade.d.ts

@@ -1,20 +1,4 @@
 import { Command } from "@oclif/core";
-/**
- * `sendly upgrade` — bring the CLI up to the latest version.
- *
- * Detects the install path (Homebrew vs npm-global vs unknown) and
- * executes the matching package-manager upgrade command. If the install
- * path is unknown we print both options for the user to pick.
- *
- * The `--check` flag does a dry-run: prints what would happen without
- * executing anything. Useful in restricted shells where we don't want
- * to trigger a brew/npm run accidentally.
- *
- * The unattended in-band update banner that prompts users to run this
- * comes from the `@oclif/plugin-warn-if-update-available` plugin wired
- * in package.json; this command is the companion action for that
- * banner.
- */
 export default class Upgrade extends Command {
     static description: string;
     static examples: string[];
@@ -22,4 +6,5 @@ export default class Upgrade extends Command {
         check: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    private renderSuccess;
 }