@sendly/cli 3.27.1 → 3.32.0

package/README.md

@@ -14,9 +14,19 @@ Official command-line interface for the [Sendly](https://sendly.live) SMS API.
 ## Installation
 
 ```bash
+# npm
 npm install -g @sendly/cli
+
+# or Homebrew (macOS / Linux)
+brew install SendlyHQ/tap/sendly
 ```
 
+## Staying up to date
+
+The CLI checks npm once a day and prints a one-line banner after your command if a newer version is out. Run `sendly upgrade` to update — it auto-detects your install path (Homebrew vs npm) and runs the right command. Use `sendly upgrade --check` to see what it would do without executing.
+
+Banner is silent in CI (`CI=true`) and offline-safe.
+
 ## Quick Start
 
 ```bash

package/dist/commands/contacts/bulk-mark-valid.d.ts

@@ -0,0 +1,12 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ContactsBulkMarkValid extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        ids: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        list: 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/contacts/bulk-mark-valid.js

@@ -0,0 +1,46 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, isJsonMode, error } from "../../lib/output.js";
+export default class ContactsBulkMarkValid extends AuthenticatedCommand {
+    static description = "Clear the invalid flag on many contacts at once. Pass --ids (comma-separated, up to 10,000) OR --list <id>, not both. Escape hatch for when auto-mark misclassifies at scale.";
+    static examples = [
+        "<%= config.bin %> contacts bulk-mark-valid --ids cnt_abc,cnt_def,cnt_ghi",
+        "<%= config.bin %> contacts bulk-mark-valid --list lst_xxx",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        ids: Flags.string({
+            description: "Comma-separated contact IDs to clear (max 10,000 per call)",
+            exclusive: ["list"],
+        }),
+        list: Flags.string({
+            description: "Clear every flagged member of this list ID",
+            exclusive: ["ids"],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ContactsBulkMarkValid);
+        if (!flags.ids && !flags.list) {
+            error("Provide either --ids or --list");
+            this.exit(1);
+        }
+        const body = flags.ids
+            ? {
+                ids: flags.ids
+                    .split(",")
+                    .map((s) => s.trim())
+                    .filter(Boolean),
+            }
+            : { listId: flags.list };
+        const result = await apiClient.post("/api/contacts/bulk-mark-valid", body);
+        if (isJsonMode()) {
+            json(result);
+            return;
+        }
+        success(result.cleared === 0
+            ? "No flagged contacts matched the selection"
+            : `${result.cleared} contact${result.cleared === 1 ? "" : "s"} marked as valid`, { Cleared: result.cleared });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVsay1tYXJrLXZhbGlkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbW1hbmRzL2NvbnRhY3RzL2J1bGstbWFyay12YWxpZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ3BDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNwRCxPQUFPLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsS0FBSyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFdkUsTUFBTSxDQUFDLE9BQU8sT0FBTyxxQkFBc0IsU0FBUSxvQkFBb0I7SUFDckUsTUFBTSxDQUFDLFdBQVcsR0FDaEIsK0tBQStLLENBQUM7SUFFbEwsTUFBTSxDQUFDLFFBQVEsR0FBRztRQUNoQiwwRUFBMEU7UUFDMUUsMkRBQTJEO0tBQzVELENBQUM7SUFFRixNQUFNLENBQUMsS0FBSyxHQUFHO1FBQ2IsR0FBRyxvQkFBb0IsQ0FBQyxTQUFTO1FBQ2pDLEdBQUcsRUFBRSxLQUFLLENBQUMsTUFBTSxDQUFDO1lBQ2hCLFdBQVcsRUFDVCw0REFBNEQ7WUFDOUQsU0FBUyxFQUFFLENBQUMsTUFBTSxDQUFDO1NBQ3BCLENBQUM7UUFDRixJQUFJLEVBQUUsS0FBSyxDQUFDLE1BQU0sQ0FBQztZQUNqQixXQUFXLEVBQUUsNENBQTRDO1lBQ3pELFNBQVMsRUFBRSxDQUFDLEtBQUssQ0FBQztTQUNuQixDQUFDO0tBQ0gsQ0FBQztJQUVGLEtBQUssQ0FBQyxHQUFHO1FBQ1AsTUFBTSxFQUFFLEtBQUssRUFBRSxHQUFHLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDO1FBRTFELElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDO1lBQzlCLEtBQUssQ0FBQyxnQ0FBZ0MsQ0FBQyxDQUFDO1lBQ3hDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDZixDQUFDO1FBRUQsTUFBTSxJQUFJLEdBQXdDLEtBQUssQ0FBQyxHQUFHO1lBQ3pELENBQUMsQ0FBQztnQkFDRSxHQUFHLEVBQUUsS0FBSyxDQUFDLEdBQUc7cUJBQ1gsS0FBSyxDQUFDLEdBQUcsQ0FBQztxQkFDVixHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztxQkFDcEIsTUFBTSxDQUFDLE9BQU8sQ0FBQzthQUNuQjtZQUNILENBQUMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUM7UUFFM0IsTUFBTSxNQUFNLEdBQUcsTUFBTSxTQUFTLENBQUMsSUFBSSxDQUNqQywrQkFBK0IsRUFDL0IsSUFBSSxDQUNMLENBQUM7UUFFRixJQUFJLFVBQVUsRUFBRSxFQUFFLENBQUM7WUFDakIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1lBQ2IsT0FBTztRQUNULENBQUM7UUFFRCxPQUFPLENBQ0wsTUFBTSxDQUFDLE9BQU8sS0FBSyxDQUFDO1lBQ2xCLENBQUMsQ0FBQywyQ0FBMkM7WUFDN0MsQ0FBQyxDQUFDLEdBQUcsTUFBTSxDQUFDLE9BQU8sV0FBVyxNQUFNLENBQUMsT0FBTyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxHQUFHLGtCQUFrQixFQUNqRixFQUFFLE9BQU8sRUFBRSxNQUFNLENBQUMsT0FBTyxFQUFFLENBQzVCLENBQUM7SUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRmxhZ3MgfSBmcm9tIFwiQG9jbGlmL2NvcmVcIjtcbmltcG9ydCB7IEF1dGhlbnRpY2F0ZWRDb21tYW5kIH0gZnJvbSBcIi4uLy4uL2xpYi9iYXNlLWNvbW1hbmQuanNcIjtcbmltcG9ydCB7IGFwaUNsaWVudCB9IGZyb20gXCIuLi8uLi9saWIvYXBpLWNsaWVudC5qc1wiO1xuaW1wb3J0IHsgc3VjY2VzcywganNvbiwgaXNKc29uTW9kZSwgZXJyb3IgfSBmcm9tIFwiLi4vLi4vbGliL291dHB1dC5qc1wiO1xuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBDb250YWN0c0J1bGtNYXJrVmFsaWQgZXh0ZW5kcyBBdXRoZW50aWNhdGVkQ29tbWFuZCB7XG4gIHN0YXRpYyBkZXNjcmlwdGlvbiA9XG4gICAgXCJDbGVhciB0aGUgaW52YWxpZCBmbGFnIG9uIG1hbnkgY29udGFjdHMgYXQgb25jZS4gUGFzcyAtLWlkcyAoY29tbWEtc2VwYXJhdGVkLCB1cCB0byAxMCwwMDApIE9SIC0tbGlzdCA8aWQ+LCBub3QgYm90aC4gRXNjYXBlIGhhdGNoIGZvciB3aGVuIGF1dG8tbWFyayBtaXNjbGFzc2lmaWVzIGF0IHNjYWxlLlwiO1xuXG4gIHN0YXRpYyBleGFtcGxlcyA9IFtcbiAgICBcIjwlPSBjb25maWcuYmluICU+IGNvbnRhY3RzIGJ1bGstbWFyay12YWxpZCAtLWlkcyBjbnRfYWJjLGNudF9kZWYsY250X2doaVwiLFxuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4gY29udGFjdHMgYnVsay1tYXJrLXZhbGlkIC0tbGlzdCBsc3RfeHh4XCIsXG4gIF07XG5cbiAgc3RhdGljIGZsYWdzID0ge1xuICAgIC4uLkF1dGhlbnRpY2F0ZWRDb21tYW5kLmJhc2VGbGFncyxcbiAgICBpZHM6IEZsYWdzLnN0cmluZyh7XG4gICAgICBkZXNjcmlwdGlvbjpcbiAgICAgICAgXCJDb21tYS1zZXBhcmF0ZWQgY29udGFjdCBJRHMgdG8gY2xlYXIgKG1heCAxMCwwMDAgcGVyIGNhbGwpXCIsXG4gICAgICBleGNsdXNpdmU6IFtcImxpc3RcIl0sXG4gICAgfSksXG4gICAgbGlzdDogRmxhZ3Muc3RyaW5nKHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcIkNsZWFyIGV2ZXJ5IGZsYWdnZWQgbWVtYmVyIG9mIHRoaXMgbGlzdCBJRFwiLFxuICAgICAgZXhjbHVzaXZlOiBbXCJpZHNcIl0sXG4gICAgfSksXG4gIH07XG5cbiAgYXN5bmMgcnVuKCk6IFByb21pc2U8dm9pZD4ge1xuICAgIGNvbnN0IHsgZmxhZ3MgfSA9IGF3YWl0IHRoaXMucGFyc2UoQ29udGFjdHNCdWxrTWFya1ZhbGlkKTtcblxuICAgIGlmICghZmxhZ3MuaWRzICYmICFmbGFncy5saXN0KSB7XG4gICAgICBlcnJvcihcIlByb3ZpZGUgZWl0aGVyIC0taWRzIG9yIC0tbGlzdFwiKTtcbiAgICAgIHRoaXMuZXhpdCgxKTtcbiAgICB9XG5cbiAgICBjb25zdCBib2R5OiB7IGlkcz86IHN0cmluZ1tdOyBsaXN0SWQ/OiBzdHJpbmcgfSA9IGZsYWdzLmlkc1xuICAgICAgPyB7XG4gICAgICAgICAgaWRzOiBmbGFncy5pZHNcbiAgICAgICAgICAgIC5zcGxpdChcIixcIilcbiAgICAgICAgICAgIC5tYXAoKHMpID0+IHMudHJpbSgpKVxuICAgICAgICAgICAgLmZpbHRlcihCb29sZWFuKSxcbiAgICAgICAgfVxuICAgICAgOiB7IGxpc3RJZDogZmxhZ3MubGlzdCB9O1xuXG4gICAgY29uc3QgcmVzdWx0ID0gYXdhaXQgYXBpQ2xpZW50LnBvc3Q8eyBjbGVhcmVkOiBudW1iZXIgfT4oXG4gICAgICBcIi9hcGkvY29udGFjdHMvYnVsay1tYXJrLXZhbGlkXCIsXG4gICAgICBib2R5LFxuICAgICk7XG5cbiAgICBpZiAoaXNKc29uTW9kZSgpKSB7XG4gICAgICBqc29uKHJlc3VsdCk7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgc3VjY2VzcyhcbiAgICAgIHJlc3VsdC5jbGVhcmVkID09PSAwXG4gICAgICAgID8gXCJObyBmbGFnZ2VkIGNvbnRhY3RzIG1hdGNoZWQgdGhlIHNlbGVjdGlvblwiXG4gICAgICAgIDogYCR7cmVzdWx0LmNsZWFyZWR9IGNvbnRhY3Qke3Jlc3VsdC5jbGVhcmVkID09PSAxID8gXCJcIiA6IFwic1wifSBtYXJrZWQgYXMgdmFsaWRgLFxuICAgICAgeyBDbGVhcmVkOiByZXN1bHQuY2xlYXJlZCB9LFxuICAgICk7XG4gIH1cbn1cbiJdfQ==

package/dist/commands/contacts/check-numbers.d.ts

@@ -0,0 +1,12 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ContactsCheckNumbers extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        list: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        force: 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/contacts/check-numbers.js

@@ -0,0 +1,41 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, isJsonMode, info } from "../../lib/output.js";
+export default class ContactsCheckNumbers extends AuthenticatedCommand {
+    static description = "Trigger a background carrier lookup across your contacts. Landlines and other non-SMS-capable numbers are auto-excluded from future campaigns. Runs asynchronously — results populate line_type / carrier_name / invalid_reason on affected contacts within a few minutes.";
+    static examples = [
+        "<%= config.bin %> contacts check-numbers",
+        "<%= config.bin %> contacts check-numbers --list lst_xxx",
+        "<%= config.bin %> contacts check-numbers --force",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        list: Flags.string({
+            char: "l",
+            description: "Scope the lookup to a single contact list",
+        }),
+        force: Flags.boolean({
+            description: "Re-check contacts even if already looked up",
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ContactsCheckNumbers);
+        const response = await apiClient.post("/api/contacts/lookup", {
+            listId: flags.list ?? null,
+            force: flags.force,
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success("Carrier lookup started", {
+            Scope: flags.list ? `list ${flags.list}` : "all un-checked contacts",
+            Force: flags.force ? "yes" : "no",
+        });
+        info(response.message ??
+            "Results will appear on contacts within a few minutes. Run `sendly contacts list` to check progress.");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/contacts/mark-valid.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ContactsMarkValid 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: {
+        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/contacts/mark-valid.js

@@ -0,0 +1,32 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, isJsonMode } from "../../lib/output.js";
+export default class ContactsMarkValid extends AuthenticatedCommand {
+    static description = "Clear the invalid flag on a contact so future campaigns include it again. Use when you disagree with an auto-exclusion (e.g. the recipient ported from a landline to mobile).";
+    static examples = [
+        "<%= config.bin %> contacts mark-valid cnt_xxx",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Contact ID to clear the invalid flag on",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(ContactsMarkValid);
+        const contact = await apiClient.post(`/api/contacts/${args.id}/mark-valid`);
+        if (isJsonMode()) {
+            json(contact);
+            return;
+        }
+        success("Contact marked as valid — future campaigns will include it", {
+            ID: contact.id,
+            Phone: contact.phoneNumber ?? contact.phone_number ?? "—",
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/countries.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from "../lib/base-command.js";
+/**
+ * `sendly countries` — list supported countries with pricing.
+ *
+ * Backs the public `GET /api/v1/countries` endpoint. No auth required so
+ * customers can browse before signing up. Useful for populating country
+ * pickers in sign-up forms, validating phone numbers client-side, and
+ * checking which tiers require registration (toll-free brand
+ * verification in US/CA, for instance).
+ */
+export default class Countries extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        search: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        tier: 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/countries.js

@@ -0,0 +1,96 @@
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../lib/base-command.js";
+import { apiClient } from "../lib/api-client.js";
+import { json, isJsonMode, colors, header } from "../lib/output.js";
+/**
+ * `sendly countries` — list supported countries with pricing.
+ *
+ * Backs the public `GET /api/v1/countries` endpoint. No auth required so
+ * customers can browse before signing up. Useful for populating country
+ * pickers in sign-up forms, validating phone numbers client-side, and
+ * checking which tiers require registration (toll-free brand
+ * verification in US/CA, for instance).
+ */
+export default class Countries extends BaseCommand {
+    static description = "List supported countries with pricing (credits per SMS, USD price, tier). No auth required.";
+    static examples = [
+        "<%= config.bin %> countries",
+        "<%= config.bin %> countries --search UK",
+        "<%= config.bin %> countries --tier domestic",
+        "<%= config.bin %> countries --json",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        search: Flags.string({
+            description: "Filter by name, country code, or dial code",
+        }),
+        tier: Flags.string({
+            description: "Filter by pricing tier (domestic, international, etc.)",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Countries);
+        const resp = await apiClient.get("/api/v1/countries");
+        const all = Array.isArray(resp)
+            ? resp
+            : (resp.countries ?? []);
+        const filtered = all.filter((c) => {
+            if (flags.tier && c.tier !== flags.tier)
+                return false;
+            if (flags.search) {
+                const q = flags.search.toLowerCase();
+                return (c.code.toLowerCase().includes(q) ||
+                    c.name.toLowerCase().includes(q) ||
+                    c.dial_code.includes(q));
+            }
+            return true;
+        });
+        if (isJsonMode()) {
+            json(filtered);
+            return;
+        }
+        header(`Supported countries (${filtered.length})`);
+        if (filtered.length === 0) {
+            console.log(colors.dim("  (no matches)"));
+            return;
+        }
+        // Column widths derived from the data so the table stays compact.
+        const codeW = 4;
+        const dialW = Math.max(...filtered.map((c) => c.dial_code.length), 5);
+        const nameW = Math.max(...filtered.map((c) => c.name.length), 12);
+        console.log("  " +
+            colors.dim("Code".padEnd(codeW)) +
+            "  " +
+            colors.dim("Dial".padEnd(dialW)) +
+            "  " +
+            colors.dim("Name".padEnd(nameW)) +
+            "  " +
+            colors.dim("Tier".padEnd(14)) +
+            "  " +
+            colors.dim("Credits/SMS".padStart(11)) +
+            "  " +
+            colors.dim("Price (USD)".padStart(11)) +
+            "  " +
+            colors.dim("Registration"));
+        for (const c of filtered) {
+            const regHint = c.requires_registration
+                ? colors.warning("required")
+                : colors.dim("not required");
+            console.log("  " +
+                c.code.padEnd(codeW) +
+                "  " +
+                c.dial_code.padEnd(dialW) +
+                "  " +
+                c.name.padEnd(nameW) +
+                "  " +
+                c.tier.padEnd(14) +
+                "  " +
+                String(c.credits_per_sms).padStart(11) +
+                "  " +
+                c.price_usd.toFixed(4).padStart(11) +
+                "  " +
+                regHint);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"countries.js","sourceRoot":"","sources":["../../src/commands/countries.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { BaseCommand } from \"../lib/base-command.js\";\nimport { apiClient } from \"../lib/api-client.js\";\nimport { json, isJsonMode, colors, header } from \"../lib/output.js\";\n\ninterface Country {\n  code: string;\n  name: string;\n  dial_code: string;\n  tier: string;\n  credits_per_sms: number;\n  price_usd: number;\n  requires_registration: boolean;\n}\n\n/**\n * `sendly countries` — list supported countries with pricing.\n *\n * Backs the public `GET /api/v1/countries` endpoint. No auth required so\n * customers can browse before signing up. Useful for populating country\n * pickers in sign-up forms, validating phone numbers client-side, and\n * checking which tiers require registration (toll-free brand\n * verification in US/CA, for instance).\n */\nexport default class Countries extends BaseCommand {\n  static description =\n    \"List supported countries with pricing (credits per SMS, USD price, tier). No auth required.\";\n\n  static examples = [\n    \"<%= config.bin %> countries\",\n    \"<%= config.bin %> countries --search UK\",\n    \"<%= config.bin %> countries --tier domestic\",\n    \"<%= config.bin %> countries --json\",\n  ];\n\n  static flags = {\n    ...BaseCommand.baseFlags,\n    search: Flags.string({\n      description: \"Filter by name, country code, or dial code\",\n    }),\n    tier: Flags.string({\n      description: \"Filter by pricing tier (domestic, international, etc.)\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(Countries);\n\n    const resp = await apiClient.get<{ countries?: Country[] } | Country[]>(\n      \"/api/v1/countries\",\n    );\n    const all: Country[] = Array.isArray(resp)\n      ? resp\n      : (resp.countries ?? []);\n\n    const filtered = all.filter((c) => {\n      if (flags.tier && c.tier !== flags.tier) return false;\n      if (flags.search) {\n        const q = flags.search.toLowerCase();\n        return (\n          c.code.toLowerCase().includes(q) ||\n          c.name.toLowerCase().includes(q) ||\n          c.dial_code.includes(q)\n        );\n      }\n      return true;\n    });\n\n    if (isJsonMode()) {\n      json(filtered);\n      return;\n    }\n\n    header(`Supported countries (${filtered.length})`);\n    if (filtered.length === 0) {\n      console.log(colors.dim(\"  (no matches)\"));\n      return;\n    }\n\n    // Column widths derived from the data so the table stays compact.\n    const codeW = 4;\n    const dialW = Math.max(...filtered.map((c) => c.dial_code.length), 5);\n    const nameW = Math.max(...filtered.map((c) => c.name.length), 12);\n\n    console.log(\n      \"  \" +\n        colors.dim(\"Code\".padEnd(codeW)) +\n        \"  \" +\n        colors.dim(\"Dial\".padEnd(dialW)) +\n        \"  \" +\n        colors.dim(\"Name\".padEnd(nameW)) +\n        \"  \" +\n        colors.dim(\"Tier\".padEnd(14)) +\n        \"  \" +\n        colors.dim(\"Credits/SMS\".padStart(11)) +\n        \"  \" +\n        colors.dim(\"Price (USD)\".padStart(11)) +\n        \"  \" +\n        colors.dim(\"Registration\"),\n    );\n    for (const c of filtered) {\n      const regHint = c.requires_registration\n        ? colors.warning(\"required\")\n        : colors.dim(\"not required\");\n      console.log(\n        \"  \" +\n          c.code.padEnd(codeW) +\n          \"  \" +\n          c.dial_code.padEnd(dialW) +\n          \"  \" +\n          c.name.padEnd(nameW) +\n          \"  \" +\n          c.tier.padEnd(14) +\n          \"  \" +\n          String(c.credits_per_sms).padStart(11) +\n          \"  \" +\n          c.price_usd.toFixed(4).padStart(11) +\n          \"  \" +\n          regHint,\n      );\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,22 @@
+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`
+ * 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: string;
+    static examples: string[];
+    static args: {
+        file: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        "content-type": 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/upload-media.js

@@ -0,0 +1,82 @@
+import { Args, Flags } from "@oclif/core";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, isJsonMode, colors, error, } from "../../lib/output.js";
+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`
+ * 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 examples = [
+        "<%= config.bin %> sms upload-media ./promo.jpg",
+        "<%= config.bin %> sms upload-media ./animated.gif --json",
+    ];
+    static args = {
+        file: Args.string({
+            description: "Path to the image file (JPEG, PNG, or GIF)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        "content-type": Flags.string({
+            description: "Override the detected mime type",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SmsUploadMedia);
+        const filePath = path.resolve(args.file);
+        if (!fs.existsSync(filePath)) {
+            error(`File not found: ${filePath}`);
+            this.exit(1);
+        }
+        const ext = path.extname(filePath).toLowerCase();
+        if (!ALLOWED_EXTS.includes(ext)) {
+            error(`Unsupported file extension '${ext}'. MMS supports JPEG, PNG, and GIF.`);
+            this.exit(1);
+        }
+        const buffer = fs.readFileSync(filePath);
+        const filename = path.basename(filePath);
+        const detected = flags["content-type"] ??
+            (ext === ".png"
+                ? "image/png"
+                : ext === ".gif"
+                    ? "image/gif"
+                    : "image/jpeg");
+        const resp = await apiClient.uploadFile("/api/v1/media", {
+            buffer,
+            filename,
+            mimetype: detected,
+        });
+        if (isJsonMode()) {
+            json(resp);
+            return;
+        }
+        success("Media uploaded", {
+            ID: resp.id,
+            URL: resp.url,
+            "Content-Type": resp.contentType,
+            Size: formatBytes(resp.sizeBytes),
+        });
+        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}"`));
+    }
+}
+function formatBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)} KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBsb2FkLW1lZGlhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbW1hbmRzL3Ntcy91cGxvYWQtbWVkaWEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDMUMsT0FBTyxLQUFLLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDOUIsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFDbEMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDakUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3BELE9BQU8sRUFDTCxPQUFPLEVBQ1AsSUFBSSxFQUNKLFVBQVUsRUFDVixNQUFNLEVBQ04sS0FBSyxHQUVOLE1BQU0scUJBQXFCLENBQUM7QUFTN0IsTUFBTSxZQUFZLEdBQUcsQ0FBQyxNQUFNLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQztBQUV2RDs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxDQUFDLE9BQU8sT0FBTyxjQUFlLFNBQVEsb0JBQW9CO0lBQzlELE1BQU0sQ0FBQyxXQUFXLEdBQ2hCLDJJQUEySSxDQUFDO0lBRTlJLE1BQU0sQ0FBQyxRQUFRLEdBQUc7UUFDaEIsZ0RBQWdEO1FBQ2hELDBEQUEwRDtLQUMzRCxDQUFDO0lBRUYsTUFBTSxDQUFDLElBQUksR0FBRztRQUNaLElBQUksRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDO1lBQ2hCLFdBQVcsRUFBRSw0Q0FBNEM7WUFDekQsUUFBUSxFQUFFLElBQUk7U0FDZixDQUFDO0tBQ0gsQ0FBQztJQUVGLE1BQU0sQ0FBQyxLQUFLLEdBQUc7UUFDYixHQUFHLG9CQUFvQixDQUFDLFNBQVM7UUFDakMsY0FBYyxFQUFFLEtBQUssQ0FBQyxNQUFNLENBQUM7WUFDM0IsV0FBVyxFQUFFLGlDQUFpQztTQUMvQyxDQUFDO0tBQ0gsQ0FBQztJQUVGLEtBQUssQ0FBQyxHQUFHO1FBQ1AsTUFBTSxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsR0FBRyxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsY0FBYyxDQUFDLENBQUM7UUFFekQsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDekMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQztZQUM3QixLQUFLLENBQUMsbUJBQW1CLFFBQVEsRUFBRSxDQUFDLENBQUM7WUFDckMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNmLENBQUM7UUFFRCxNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBQ2pELElBQUksQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDaEMsS0FBSyxDQUNILCtCQUErQixHQUFHLHFDQUFxQyxDQUN4RSxDQUFDO1lBQ0YsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNmLENBQUM7UUFFRCxNQUFNLE1BQU0sR0FBRyxFQUFFLENBQUMsWUFBWSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQ3pDLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLENBQUM7UUFFekMsTUFBTSxRQUFRLEdBQ1osS0FBSyxDQUFDLGNBQWMsQ0FBQztZQUNyQixDQUFDLEdBQUcsS0FBSyxNQUFNO2dCQUNiLENBQUMsQ0FBQyxXQUFXO2dCQUNiLENBQUMsQ0FBQyxHQUFHLEtBQUssTUFBTTtvQkFDZCxDQUFDLENBQUMsV0FBVztvQkFDYixDQUFDLENBQUMsWUFBWSxDQUFDLENBQUM7UUFFdEIsTUFBTSxJQUFJLEdBQUcsTUFBTSxTQUFTLENBQUMsVUFBVSxDQUNyQyxlQUFlLEVBQ2Y7WUFDRSxNQUFNO1lBQ04sUUFBUTtZQUNSLFFBQVEsRUFBRSxRQUFRO1NBQ25CLENBQ0YsQ0FBQztRQUVGLElBQUksVUFBVSxFQUFFLEVBQUUsQ0FBQztZQUNqQixJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDWCxPQUFPO1FBQ1QsQ0FBQztRQUVELE9BQU8sQ0FBQyxnQkFBZ0IsRUFBRTtZQUN4QixFQUFFLEVBQUUsSUFBSSxDQUFDLEVBQUU7WUFDWCxHQUFHLEVBQUUsSUFBSSxDQUFDLEdBQUc7WUFDYixjQUFjLEVBQUUsSUFBSSxDQUFDLFdBQVc7WUFDaEMsSUFBSSxFQUFFLFdBQVcsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDO1NBQ2xDLENBQUMsQ0FBQztRQUNILE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUNkLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxnQ0FBZ0MsQ0FBQyxDQUFDLENBQUM7UUFDMUQsT0FBTyxDQUFDLEdBQUcsQ0FDVCxNQUFNO1lBQ0osTUFBTSxDQUFDLElBQUksQ0FDVCwwREFBMEQsSUFBSSxDQUFDLEdBQUcsR0FBRyxDQUN0RSxDQUNKLENBQUM7SUFDSixDQUFDOztBQUdILFNBQVMsV0FBVyxDQUFDLENBQVM7SUFDNUIsSUFBSSxDQUFDLEdBQUcsSUFBSTtRQUFFLE9BQU8sR0FBRyxDQUFDLElBQUksQ0FBQztJQUM5QixJQUFJLENBQUMsR0FBRyxJQUFJLEdBQUcsSUFBSTtRQUFFLE9BQU8sR0FBRyxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQztJQUMxRCxPQUFPLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQztBQUNoRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXJncywgRmxhZ3MgfSBmcm9tIFwiQG9jbGlmL2NvcmVcIjtcbmltcG9ydCAqIGFzIGZzIGZyb20gXCJub2RlOmZzXCI7XG5pbXBvcnQgKiBhcyBwYXRoIGZyb20gXCJub2RlOnBhdGhcIjtcbmltcG9ydCB7IEF1dGhlbnRpY2F0ZWRDb21tYW5kIH0gZnJvbSBcIi4uLy4uL2xpYi9iYXNlLWNvbW1hbmQuanNcIjtcbmltcG9ydCB7IGFwaUNsaWVudCB9IGZyb20gXCIuLi8uLi9saWIvYXBpLWNsaWVudC5qc1wiO1xuaW1wb3J0IHtcbiAgc3VjY2VzcyxcbiAganNvbixcbiAgaXNKc29uTW9kZSxcbiAgY29sb3JzLFxuICBlcnJvcixcbiAga2V5VmFsdWUsXG59IGZyb20gXCIuLi8uLi9saWIvb3V0cHV0LmpzXCI7XG5cbmludGVyZmFjZSBNZWRpYVVwbG9hZFJlc3BvbnNlIHtcbiAgaWQ6IHN0cmluZztcbiAgdXJsOiBzdHJpbmc7XG4gIGNvbnRlbnRUeXBlOiBzdHJpbmc7XG4gIHNpemVCeXRlczogbnVtYmVyO1xufVxuXG5jb25zdCBBTExPV0VEX0VYVFMgPSBbXCIuanBnXCIsIFwiLmpwZWdcIiwgXCIucG5nXCIsIFwiLmdpZlwiXTtcblxuLyoqXG4gKiBgc2VuZGx5IHNtcyB1cGxvYWQtbWVkaWEgPGZpbGU+YCDigJQgdXBsb2FkIGFuIGltYWdlIGZvciBNTVMuXG4gKlxuICogV3JhcHMgYFBPU1QgL2FwaS92MS9tZWRpYWAuIFJldHVybnMgYSBwdWJsaWMgVVJMIHRoZSBjYWxsZXIgcGFzc2VzIGFzXG4gKiBgLS1tZWRpYWAgdG8gYHNtcyBzZW5kYCAvIGBzbXMgYmF0Y2hgLiBGbGFnLWdhdGVkIGJlaGluZCBgZW5hYmxlX21tc2BcbiAqIG9uIHRoZSBzZXJ2ZXIg4oCUIGlmIHlvdXIgYWNjb3VudCBkb2Vzbid0IGhhdmUgTU1TLCB0aGUgc2VydmVyIHJldHVybnNcbiAqIDQwMyBhbmQgdGhpcyBjb21tYW5kIHN1cmZhY2VzIGl0LlxuICovXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBTbXNVcGxvYWRNZWRpYSBleHRlbmRzIEF1dGhlbnRpY2F0ZWRDb21tYW5kIHtcbiAgc3RhdGljIGRlc2NyaXB0aW9uID1cbiAgICBcIlVwbG9hZCBhIEpQRUcvUE5HL0dJRiBpbWFnZSBmb3IgTU1TIGFuZCBnZXQgYmFjayBhIHB1YmxpYyBVUkwgdG8gcGFzcyB0byBgc21zIHNlbmQgLS1tZWRpYWAuIFJlcXVpcmVzIE1NUyB0byBiZSBlbmFibGVkIGZvciB5b3VyIGFjY291bnQuXCI7XG5cbiAgc3RhdGljIGV4YW1wbGVzID0gW1xuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4gc21zIHVwbG9hZC1tZWRpYSAuL3Byb21vLmpwZ1wiLFxuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4gc21zIHVwbG9hZC1tZWRpYSAuL2FuaW1hdGVkLmdpZiAtLWpzb25cIixcbiAgXTtcblxuICBzdGF0aWMgYXJncyA9IHtcbiAgICBmaWxlOiBBcmdzLnN0cmluZyh7XG4gICAgICBkZXNjcmlwdGlvbjogXCJQYXRoIHRvIHRoZSBpbWFnZSBmaWxlIChKUEVHLCBQTkcsIG9yIEdJRilcIixcbiAgICAgIHJlcXVpcmVkOiB0cnVlLFxuICAgIH0pLFxuICB9O1xuXG4gIHN0YXRpYyBmbGFncyA9IHtcbiAgICAuLi5BdXRoZW50aWNhdGVkQ29tbWFuZC5iYXNlRmxhZ3MsXG4gICAgXCJjb250ZW50LXR5cGVcIjogRmxhZ3Muc3RyaW5nKHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcIk92ZXJyaWRlIHRoZSBkZXRlY3RlZCBtaW1lIHR5cGVcIixcbiAgICB9KSxcbiAgfTtcblxuICBhc3luYyBydW4oKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgY29uc3QgeyBhcmdzLCBmbGFncyB9ID0gYXdhaXQgdGhpcy5wYXJzZShTbXNVcGxvYWRNZWRpYSk7XG5cbiAgICBjb25zdCBmaWxlUGF0aCA9IHBhdGgucmVzb2x2ZShhcmdzLmZpbGUpO1xuICAgIGlmICghZnMuZXhpc3RzU3luYyhmaWxlUGF0aCkpIHtcbiAgICAgIGVycm9yKGBGaWxlIG5vdCBmb3VuZDogJHtmaWxlUGF0aH1gKTtcbiAgICAgIHRoaXMuZXhpdCgxKTtcbiAgICB9XG5cbiAgICBjb25zdCBleHQgPSBwYXRoLmV4dG5hbWUoZmlsZVBhdGgpLnRvTG93ZXJDYXNlKCk7XG4gICAgaWYgKCFBTExPV0VEX0VYVFMuaW5jbHVkZXMoZXh0KSkge1xuICAgICAgZXJyb3IoXG4gICAgICAgIGBVbnN1cHBvcnRlZCBmaWxlIGV4dGVuc2lvbiAnJHtleHR9Jy4gTU1TIHN1cHBvcnRzIEpQRUcsIFBORywgYW5kIEdJRi5gLFxuICAgICAgKTtcbiAgICAgIHRoaXMuZXhpdCgxKTtcbiAgICB9XG5cbiAgICBjb25zdCBidWZmZXIgPSBmcy5yZWFkRmlsZVN5bmMoZmlsZVBhdGgpO1xuICAgIGNvbnN0IGZpbGVuYW1lID0gcGF0aC5iYXNlbmFtZShmaWxlUGF0aCk7XG5cbiAgICBjb25zdCBkZXRlY3RlZCA9XG4gICAgICBmbGFnc1tcImNvbnRlbnQtdHlwZVwiXSA/P1xuICAgICAgKGV4dCA9PT0gXCIucG5nXCJcbiAgICAgICAgPyBcImltYWdlL3BuZ1wiXG4gICAgICAgIDogZXh0ID09PSBcIi5naWZcIlxuICAgICAgICAgID8gXCJpbWFnZS9naWZcIlxuICAgICAgICAgIDogXCJpbWFnZS9qcGVnXCIpO1xuXG4gICAgY29uc3QgcmVzcCA9IGF3YWl0IGFwaUNsaWVudC51cGxvYWRGaWxlPE1lZGlhVXBsb2FkUmVzcG9uc2U+KFxuICAgICAgXCIvYXBpL3YxL21lZGlhXCIsXG4gICAgICB7XG4gICAgICAgIGJ1ZmZlcixcbiAgICAgICAgZmlsZW5hbWUsXG4gICAgICAgIG1pbWV0eXBlOiBkZXRlY3RlZCxcbiAgICAgIH0sXG4gICAgKTtcblxuICAgIGlmIChpc0pzb25Nb2RlKCkpIHtcbiAgICAgIGpzb24ocmVzcCk7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgc3VjY2VzcyhcIk1lZGlhIHVwbG9hZGVkXCIsIHtcbiAgICAgIElEOiByZXNwLmlkLFxuICAgICAgVVJMOiByZXNwLnVybCxcbiAgICAgIFwiQ29udGVudC1UeXBlXCI6IHJlc3AuY29udGVudFR5cGUsXG4gICAgICBTaXplOiBmb3JtYXRCeXRlcyhyZXNwLnNpemVCeXRlcyksXG4gICAgfSk7XG4gICAgY29uc29sZS5sb2coKTtcbiAgICBjb25zb2xlLmxvZyhjb2xvcnMuZGltKFwiICBTZW5kIGFuIE1NUyB3aXRoIHRoaXMgaW1hZ2U6XCIpKTtcbiAgICBjb25zb2xlLmxvZyhcbiAgICAgIFwiICAgIFwiICtcbiAgICAgICAgY29sb3JzLmNvZGUoXG4gICAgICAgICAgYHNlbmRseSBzbXMgc2VuZCAtLXRvICsxNTU1MTIzNDU2NyAtLXRleHQgXCJIaVwiIC0tbWVkaWEgXCIke3Jlc3AudXJsfVwiYCxcbiAgICAgICAgKSxcbiAgICApO1xuICB9XG59XG5cbmZ1bmN0aW9uIGZvcm1hdEJ5dGVzKG46IG51bWJlcik6IHN0cmluZyB7XG4gIGlmIChuIDwgMTAyNCkgcmV0dXJuIGAke259IEJgO1xuICBpZiAobiA8IDEwMjQgKiAxMDI0KSByZXR1cm4gYCR7KG4gLyAxMDI0KS50b0ZpeGVkKDEpfSBLQmA7XG4gIHJldHVybiBgJHsobiAvICgxMDI0ICogMTAyNCkpLnRvRml4ZWQoMSl9IE1CYDtcbn1cbiJdfQ==

package/dist/commands/templates/enhance.d.ts

@@ -0,0 +1,25 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+/**
+ * `sendly templates enhance` — AI rewrite a message template for
+ * compliance/clarity/conversions.
+ *
+ * Wraps `POST /api/v1/ai/enhance` (flag-gated behind `ai_classification`
+ * on the server — if your account doesn't have the flag, the server
+ * returns 404 and this command surfaces it). Accepts text directly via
+ * `--text`, from a file via `--file`, or piped on stdin.
+ */
+export default class TemplatesEnhance extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        text: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        text: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        file: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "message-type": 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/templates/enhance.js

@@ -0,0 +1,77 @@
+import { Args, Flags } from "@oclif/core";
+import * as fs from "node:fs";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, isJsonMode, colors, header, info, error, } from "../../lib/output.js";
+/**
+ * `sendly templates enhance` — AI rewrite a message template for
+ * compliance/clarity/conversions.
+ *
+ * Wraps `POST /api/v1/ai/enhance` (flag-gated behind `ai_classification`
+ * on the server — if your account doesn't have the flag, the server
+ * returns 404 and this command surfaces it). Accepts text directly via
+ * `--text`, from a file via `--file`, or piped on stdin.
+ */
+export default class TemplatesEnhance extends AuthenticatedCommand {
+    static description = "AI-enhance a message template for clarity, compliance, and send-readiness. Returns the rewritten text + an explanation.";
+    static examples = [
+        '<%= config.bin %> templates enhance --text "hey come check out our sale"',
+        '<%= config.bin %> templates enhance --file ./draft.txt --message-type marketing',
+        '<%= config.bin %> echo "your sale msg" | sendly templates enhance --message-type promotional',
+    ];
+    static args = {
+        text: Args.string({
+            description: "Message text to enhance (alternative to --text / --file)",
+            required: false,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        text: Flags.string({
+            description: "Message text to enhance",
+        }),
+        file: Flags.string({
+            description: "Read message text from a file path",
+        }),
+        "message-type": Flags.string({
+            description: "Hint the kind of message (e.g. marketing, transactional, notification) for targeted enhancements",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TemplatesEnhance);
+        let text = flags.text ?? args.text;
+        if (!text && flags.file) {
+            text = fs.readFileSync(flags.file, "utf8").trim();
+        }
+        if (!text && !process.stdin.isTTY) {
+            text = await new Promise((resolve) => {
+                let buf = "";
+                process.stdin.setEncoding("utf8");
+                process.stdin.on("data", (c) => (buf += c));
+                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).");
+            this.exit(1);
+        }
+        const resp = await apiClient.post("/api/v1/ai/enhance", {
+            text: text ?? "",
+            messageType: flags["message-type"],
+        });
+        if (isJsonMode()) {
+            json(resp);
+            return;
+        }
+        header("Enhanced text");
+        console.log("  " + (resp.enhanced || colors.dim("(no change)")));
+        if (resp.explanation) {
+            console.log();
+            info(resp.explanation);
+        }
+        if (!resp.enhanced || resp.enhanced === text) {
+            success("No enhancement suggested — original text looks good.");
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/upgrade.d.ts

@@ -0,0 +1,25 @@
+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[];
+    static flags: {
+        check: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}