@sendly/cli 3.29.0 → 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/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,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

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>;
+}

package/dist/commands/upgrade.js

@@ -0,0 +1,67 @@
+import { Command, Flags } from "@oclif/core";
+import { spawn } from "node:child_process";
+import { detectInstallPath, upgradeCommandFor, } from "../lib/detect-install-path.js";
+import { success, error, info } from "../lib/output.js";
+/**
+ * `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 = "Upgrade Sendly CLI to the latest version using the package manager that installed it (Homebrew or npm).";
+    static examples = [
+        "<%= config.bin %> upgrade",
+        "<%= config.bin %> upgrade --check",
+    ];
+    static flags = {
+        check: Flags.boolean({
+            description: "Print the upgrade command for your install path without executing it",
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Upgrade);
+        const installPath = detectInstallPath();
+        const command = upgradeCommandFor(installPath);
+        if (installPath === "unknown") {
+            info("Can't detect how you installed the Sendly CLI. Pick the matching command:\n" +
+                "  • Homebrew: brew upgrade sendly\n" +
+                "  • npm:      npm install -g @sendly/cli@latest");
+            return;
+        }
+        if (flags.check) {
+            info(`Detected install path: ${installPath}\nWould run: ${command}`);
+            return;
+        }
+        info(`Upgrading via ${installPath}: ${command}`);
+        const [bin, ...args] = command.split(" ");
+        const child = spawn(bin, args, { stdio: "inherit" });
+        await new Promise((resolve) => {
+            child.on("exit", (code) => {
+                if (code === 0) {
+                    success("Upgrade complete. Run `sendly --version` to confirm the new version.");
+                }
+                else {
+                    error(`Upgrade command exited with code ${code}. Try running \`${command}\` manually.`);
+                }
+                resolve();
+            });
+            child.on("error", (err) => {
+                error(`Failed to execute upgrade command: ${err.message}. Try running \`${command}\` manually.`);
+                resolve();
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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