@sendly/cli 3.24.0 → 3.29.0

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

@@ -3,9 +3,9 @@ export default class SmsSchedule extends AuthenticatedCommand {
     static description: string;
     static examples: string[];
     static flags: {
-        to: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        text: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        at: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        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>;
+        at: 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, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;

package/dist/commands/sms/schedule.js

@@ -1,31 +1,31 @@
 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 { success, error, spinner, colors, formatStatus, json, isJsonMode, info, } from "../../lib/output.js";
+import * as chrono from "chrono-node";
+import inquirer from "inquirer";
 export default class SmsSchedule extends AuthenticatedCommand {
-    static description = "Schedule an SMS message for future delivery";
+    static description = "Schedule an SMS message for future delivery. Supports natural language dates like 'tomorrow at 9am' or 'in 2 hours'.";
     static examples = [
-        '<%= config.bin %> sms schedule --to +15551234567 --text "Reminder!" --at "2025-01-20T10:00:00Z"',
-        '<%= config.bin %> sms schedule --to +15551234567 --text "Meeting in 1 hour" --at "2025-01-15T14:00:00Z" --from "Sendly"',
-        '<%= config.bin %> sms schedule --to +15551234567 --text "Your code: 123456" --at "2025-01-20T10:00:00Z" --type transactional',
-        '<%= config.bin %> sms schedule --to +15551234567 --text "Hello!" --at "2025-01-20T10:00:00Z" --json',
+        '<%= config.bin %> sms schedule --to +15551234567 --text "Reminder!" --at "tomorrow at 9am"',
+        '<%= config.bin %> sms schedule --to +15551234567 --text "Meeting soon" --at "in 2 hours"',
+        '<%= config.bin %> sms schedule --to +15551234567 --text "Hello!" --at "next Monday 3pm"',
+        '<%= config.bin %> sms schedule --to +15551234567 --text "Sale!" --at "2026-04-01T10:00:00Z"',
+        '<%= config.bin %> sms schedule --to +15551234567 --text "Code: 123" --at "friday 5pm" --type transactional',
     ];
     static flags = {
         ...AuthenticatedCommand.baseFlags,
         to: Flags.string({
             char: "t",
             description: "Recipient phone number (E.164 format)",
-            required: true,
         }),
         text: Flags.string({
             char: "m",
             description: "Message text",
-            required: true,
         }),
         at: Flags.string({
             char: "a",
-            description: "Scheduled time (ISO 8601 format, e.g., 2025-01-20T10:00:00Z)",
-            required: true,
+            description: 'Scheduled time — ISO 8601 or natural language ("tomorrow at 9am", "in 2 hours", "next Monday 3pm")',
         }),
         from: Flags.string({
             char: "f",
@@ -39,45 +39,135 @@ export default class SmsSchedule extends AuthenticatedCommand {
     };
     async run() {
         const { flags } = await this.parse(SmsSchedule);
-        // Validate phone number format
-        if (!/^\+[1-9]\d{1,14}$/.test(flags.to)) {
+        let to = flags.to;
+        let text = flags.text;
+        let at = flags.at;
+        if (!to) {
+            if (process.stdin.isTTY) {
+                const answers = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "to",
+                        message: "Recipient phone number (E.164):",
+                        validate: (input) => {
+                            if (!input)
+                                return "Phone number is required";
+                            if (!/^\+[1-9]\d{1,14}$/.test(input)) {
+                                return "Invalid format. Use E.164: +15551234567";
+                            }
+                            return true;
+                        },
+                    },
+                ]);
+                to = answers.to;
+            }
+            else {
+                error("Missing required flag: --to", {
+                    hint: "Use --to +15551234567",
+                });
+                this.exit(1);
+            }
+        }
+        if (!text) {
+            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("Missing required flag: --text", {
+                    hint: 'Use --text "Your message"',
+                });
+                this.exit(1);
+            }
+        }
+        if (!at) {
+            if (process.stdin.isTTY) {
+                const answers = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "at",
+                        message: 'Schedule time (e.g. "tomorrow at 9am", "in 2 hours"):',
+                        validate: (input) => {
+                            if (!input.trim())
+                                return "Scheduled time is required";
+                            return true;
+                        },
+                    },
+                ]);
+                at = answers.at;
+            }
+            else {
+                error("Missing required flag: --at", {
+                    hint: 'Use --at "tomorrow at 9am"',
+                });
+                this.exit(1);
+            }
+        }
+        if (!/^\+[1-9]\d{1,14}$/.test(to)) {
             error("Invalid phone number format", {
                 hint: "Use E.164 format: +15551234567",
             });
             this.exit(1);
         }
-        // Validate message text
-        if (!flags.text.trim()) {
+        if (!text.trim()) {
             error("Message text cannot be empty");
             this.exit(1);
         }
-        // Validate scheduled time
-        const scheduledDate = new Date(flags.at);
+        let scheduledDate = new Date(at);
         if (isNaN(scheduledDate.getTime())) {
-            error("Invalid scheduled time format", {
-                hint: "Use ISO 8601 format: 2025-01-20T10:00:00Z",
+            const parsed = chrono.parseDate(at, new Date(), { forwardDate: true });
+            if (!parsed) {
+                error("Could not understand the scheduled time", {
+                    hint: 'Try: "tomorrow at 9am", "in 2 hours", "next Monday 3pm", or ISO 8601: 2026-04-01T10:00:00Z',
+                });
+                this.exit(1);
+            }
+            scheduledDate = parsed;
+            const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+            if (!isJsonMode()) {
+                info(`Interpreted "${at}" as ${scheduledDate.toLocaleString()} (${tz})`);
+            }
+        }
+        const timeUntilSend = scheduledDate.getTime() - Date.now();
+        if (timeUntilSend < 0) {
+            error("That time is in the past", {
+                hint: 'Did you mean a future time? Try: "tomorrow at 9am" or "in 2 hours"',
             });
             this.exit(1);
         }
-        // Check scheduling time constraints (carrier requires 5 min - 5 days)
         const FIVE_MINUTES = 5 * 60 * 1000;
-        const FIVE_DAYS = 5 * 24 * 60 * 60 * 1000;
-        const timeUntilSend = scheduledDate.getTime() - Date.now();
         if (timeUntilSend < FIVE_MINUTES) {
-            error("Scheduled time must be at least 5 minutes from now");
+            const mins = Math.ceil(timeUntilSend / 60000);
+            error(`Too soon — that's only ${mins} minute${mins !== 1 ? "s" : ""} from now`, {
+                hint: "Messages must be scheduled at least 5 minutes in the future",
+            });
             this.exit(1);
         }
+        const FIVE_DAYS = 5 * 24 * 60 * 60 * 1000;
         if (timeUntilSend > FIVE_DAYS) {
-            error("Scheduled time must be within 5 days");
+            error("Too far — must be within 5 days", {
+                hint: `That's ${Math.ceil(timeUntilSend / 86400000)} days from now. Maximum is 5 days.`,
+            });
             this.exit(1);
         }
         const spin = spinner("Scheduling message...");
         spin.start();
         try {
             const response = await apiClient.post("/api/v1/messages/schedule", {
-                to: flags.to,
-                text: flags.text,
-                scheduledAt: flags.at,
+                to,
+                text,
+                scheduledAt: scheduledDate.toISOString(),
                 messageType: flags.type,
                 ...(flags.from && { from: flags.from }),
             });
@@ -100,4 +190,4 @@ export default class SmsSchedule extends AuthenticatedCommand {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schedule.js","sourceRoot":"","sources":["../../../src/commands/sms/schedule.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;AAY7B,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,oBAAoB;IAC3D,MAAM,CAAC,WAAW,GAAG,6CAA6C,CAAC;IAEnE,MAAM,CAAC,QAAQ,GAAG;QAChB,iGAAiG;QACjG,yHAAyH;QACzH,8HAA8H;QAC9H,qGAAqG;KACtG,CAAC;IAEF,MAAM,CAAC,KAAK,GAAG;QACb,GAAG,oBAAoB,CAAC,SAAS;QACjC,EAAE,EAAE,KAAK,CAAC,MAAM,CAAC;YACf,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,uCAAuC;YACpD,QAAQ,EAAE,IAAI;SACf,CAAC;QACF,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC;YACjB,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,cAAc;YAC3B,QAAQ,EAAE,IAAI;SACf,CAAC;QACF,EAAE,EAAE,KAAK,CAAC,MAAM,CAAC;YACf,IAAI,EAAE,GAAG;YACT,WAAW,EACT,8DAA8D;YAChE,QAAQ,EAAE,IAAI;SACf,CAAC;QACF,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC;YACjB,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,2BAA2B;SACzC,CAAC;QACF,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC;YACjB,WAAW,EACT,gGAAgG;YAClG,OAAO,EAAE,CAAC,WAAW,EAAE,eAAe,CAAC;YACvC,OAAO,EAAE,WAAW;SACrB,CAAC;KACH,CAAC;IAEF,KAAK,CAAC,GAAG;QACP,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAEhD,+BAA+B;QAC/B,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;YACxC,KAAK,CAAC,6BAA6B,EAAE;gBACnC,IAAI,EAAE,gCAAgC;aACvC,CAAC,CAAC;YACH,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QAED,wBAAwB;QACxB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;YACvB,KAAK,CAAC,8BAA8B,CAAC,CAAC;YACtC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QAED,0BAA0B;QAC1B,MAAM,aAAa,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACzC,IAAI,KAAK,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC;YACnC,KAAK,CAAC,+BAA+B,EAAE;gBACrC,IAAI,EAAE,2CAA2C;aAClD,CAAC,CAAC;YACH,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QAED,sEAAsE;QACtE,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;QACnC,MAAM,SAAS,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;QAC1C,MAAM,aAAa,GAAG,aAAa,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAE3D,IAAI,aAAa,GAAG,YAAY,EAAE,CAAC;YACjC,KAAK,CAAC,oDAAoD,CAAC,CAAC;YAC5D,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QAED,IAAI,aAAa,GAAG,SAAS,EAAE,CAAC;YAC9B,KAAK,CAAC,sCAAsC,CAAC,CAAC;YAC9C,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QAED,MAAM,IAAI,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;QAC9C,IAAI,CAAC,KAAK,EAAE,CAAC;QAEb,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,IAAI,CACnC,2BAA2B,EAC3B;gBACE,EAAE,EAAE,KAAK,CAAC,EAAE;gBACZ,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,WAAW,EAAE,KAAK,CAAC,EAAE;gBACrB,WAAW,EAAE,KAAK,CAAC,IAAI;gBACvB,GAAG,CAAC,KAAK,CAAC,IAAI,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC;aACxC,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,MAAM,aAAa,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,cAAc,EAAE,CAAC;YAEtE,OAAO,CAAC,mBAAmB,EAAE;gBAC3B,EAAE,EAAE,QAAQ,CAAC,EAAE;gBACf,EAAE,EAAE,QAAQ,CAAC,EAAE;gBACf,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC;gBACrC,eAAe,EAAE,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC;aAC5C,CAAC,CAAC;QACL,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\";\n\ninterface ScheduledMessageResponse {\n  id: string;\n  to: string;\n  from?: string;\n  text: string;\n  status: string;\n  scheduledAt: string;\n  createdAt: string;\n}\n\nexport default class SmsSchedule extends AuthenticatedCommand {\n  static description = \"Schedule an SMS message for future delivery\";\n\n  static examples = [\n    '<%= config.bin %> sms schedule --to +15551234567 --text \"Reminder!\" --at \"2025-01-20T10:00:00Z\"',\n    '<%= config.bin %> sms schedule --to +15551234567 --text \"Meeting in 1 hour\" --at \"2025-01-15T14:00:00Z\" --from \"Sendly\"',\n    '<%= config.bin %> sms schedule --to +15551234567 --text \"Your code: 123456\" --at \"2025-01-20T10:00:00Z\" --type transactional',\n    '<%= config.bin %> sms schedule --to +15551234567 --text \"Hello!\" --at \"2025-01-20T10:00:00Z\" --json',\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    to: Flags.string({\n      char: \"t\",\n      description: \"Recipient phone number (E.164 format)\",\n      required: true,\n    }),\n    text: Flags.string({\n      char: \"m\",\n      description: \"Message text\",\n      required: true,\n    }),\n    at: Flags.string({\n      char: \"a\",\n      description:\n        \"Scheduled time (ISO 8601 format, e.g., 2025-01-20T10:00:00Z)\",\n      required: true,\n    }),\n    from: Flags.string({\n      char: \"f\",\n      description: \"Sender ID or phone number\",\n    }),\n    type: Flags.string({\n      description:\n        \"Message type: marketing (default) or transactional. Transactional messages bypass quiet hours.\",\n      options: [\"marketing\", \"transactional\"],\n      default: \"marketing\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(SmsSchedule);\n\n    // Validate phone number format\n    if (!/^\\+[1-9]\\d{1,14}$/.test(flags.to)) {\n      error(\"Invalid phone number format\", {\n        hint: \"Use E.164 format: +15551234567\",\n      });\n      this.exit(1);\n    }\n\n    // Validate message text\n    if (!flags.text.trim()) {\n      error(\"Message text cannot be empty\");\n      this.exit(1);\n    }\n\n    // Validate scheduled time\n    const scheduledDate = new Date(flags.at);\n    if (isNaN(scheduledDate.getTime())) {\n      error(\"Invalid scheduled time format\", {\n        hint: \"Use ISO 8601 format: 2025-01-20T10:00:00Z\",\n      });\n      this.exit(1);\n    }\n\n    // Check scheduling time constraints (carrier requires 5 min - 5 days)\n    const FIVE_MINUTES = 5 * 60 * 1000;\n    const FIVE_DAYS = 5 * 24 * 60 * 60 * 1000;\n    const timeUntilSend = scheduledDate.getTime() - Date.now();\n\n    if (timeUntilSend < FIVE_MINUTES) {\n      error(\"Scheduled time must be at least 5 minutes from now\");\n      this.exit(1);\n    }\n\n    if (timeUntilSend > FIVE_DAYS) {\n      error(\"Scheduled time must be within 5 days\");\n      this.exit(1);\n    }\n\n    const spin = spinner(\"Scheduling message...\");\n    spin.start();\n\n    try {\n      const response = await apiClient.post<ScheduledMessageResponse>(\n        \"/api/v1/messages/schedule\",\n        {\n          to: flags.to,\n          text: flags.text,\n          scheduledAt: flags.at,\n          messageType: flags.type,\n          ...(flags.from && { from: flags.from }),\n        },\n      );\n\n      spin.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      const formattedTime = new Date(response.scheduledAt).toLocaleString();\n\n      success(\"Message scheduled\", {\n        ID: response.id,\n        To: response.to,\n        Status: formatStatus(response.status),\n        \"Scheduled For\": colors.code(formattedTime),\n      });\n    } catch (err) {\n      spin.stop();\n      throw err;\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schedule.js","sourceRoot":"","sources":["../../../src/commands/sms/schedule.ts"],"names":[],"mappings":"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","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  info,\n} from \"../../lib/output.js\";\nimport * as chrono from \"chrono-node\";\nimport inquirer from \"inquirer\";\n\ninterface ScheduledMessageResponse {\n  id: string;\n  to: string;\n  from?: string;\n  text: string;\n  status: string;\n  scheduledAt: string;\n  createdAt: string;\n}\n\nexport default class SmsSchedule extends AuthenticatedCommand {\n  static description = \"Schedule an SMS message for future delivery. Supports natural language dates like 'tomorrow at 9am' or 'in 2 hours'.\";\n\n  static examples = [\n    '<%= config.bin %> sms schedule --to +15551234567 --text \"Reminder!\" --at \"tomorrow at 9am\"',\n    '<%= config.bin %> sms schedule --to +15551234567 --text \"Meeting soon\" --at \"in 2 hours\"',\n    '<%= config.bin %> sms schedule --to +15551234567 --text \"Hello!\" --at \"next Monday 3pm\"',\n    '<%= config.bin %> sms schedule --to +15551234567 --text \"Sale!\" --at \"2026-04-01T10:00:00Z\"',\n    '<%= config.bin %> sms schedule --to +15551234567 --text \"Code: 123\" --at \"friday 5pm\" --type transactional',\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    to: Flags.string({\n      char: \"t\",\n      description: \"Recipient phone number (E.164 format)\",\n    }),\n    text: Flags.string({\n      char: \"m\",\n      description: \"Message text\",\n    }),\n    at: Flags.string({\n      char: \"a\",\n      description: 'Scheduled time — ISO 8601 or natural language (\"tomorrow at 9am\", \"in 2 hours\", \"next Monday 3pm\")',\n    }),\n    from: Flags.string({\n      char: \"f\",\n      description: \"Sender ID or phone number\",\n    }),\n    type: Flags.string({\n      description:\n        \"Message type: marketing (default) or transactional. Transactional messages bypass quiet hours.\",\n      options: [\"marketing\", \"transactional\"],\n      default: \"marketing\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(SmsSchedule);\n\n    let to = flags.to;\n    let text = flags.text;\n    let at = flags.at;\n\n    if (!to) {\n      if (process.stdin.isTTY) {\n        const answers = await inquirer.prompt([\n          {\n            type: \"input\",\n            name: \"to\",\n            message: \"Recipient phone number (E.164):\",\n            validate: (input: string) => {\n              if (!input) return \"Phone number is required\";\n              if (!/^\\+[1-9]\\d{1,14}$/.test(input)) {\n                return \"Invalid format. Use E.164: +15551234567\";\n              }\n              return true;\n            },\n          },\n        ]);\n        to = answers.to;\n      } else {\n        error(\"Missing required flag: --to\", {\n          hint: \"Use --to +15551234567\",\n        });\n        this.exit(1);\n      }\n    }\n\n    if (!text) {\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(\"Missing required flag: --text\", {\n          hint: 'Use --text \"Your message\"',\n        });\n        this.exit(1);\n      }\n    }\n\n    if (!at) {\n      if (process.stdin.isTTY) {\n        const answers = await inquirer.prompt([\n          {\n            type: \"input\",\n            name: \"at\",\n            message: 'Schedule time (e.g. \"tomorrow at 9am\", \"in 2 hours\"):',\n            validate: (input: string) => {\n              if (!input.trim()) return \"Scheduled time is required\";\n              return true;\n            },\n          },\n        ]);\n        at = answers.at;\n      } else {\n        error(\"Missing required flag: --at\", {\n          hint: 'Use --at \"tomorrow at 9am\"',\n        });\n        this.exit(1);\n      }\n    }\n\n    if (!/^\\+[1-9]\\d{1,14}$/.test(to!)) {\n      error(\"Invalid phone number format\", {\n        hint: \"Use E.164 format: +15551234567\",\n      });\n      this.exit(1);\n    }\n\n    if (!text!.trim()) {\n      error(\"Message text cannot be empty\");\n      this.exit(1);\n    }\n\n    let scheduledDate = new Date(at!);\n\n    if (isNaN(scheduledDate.getTime())) {\n      const parsed = chrono.parseDate(at!, new Date(), { forwardDate: true });\n      if (!parsed) {\n        error(\"Could not understand the scheduled time\", {\n          hint: 'Try: \"tomorrow at 9am\", \"in 2 hours\", \"next Monday 3pm\", or ISO 8601: 2026-04-01T10:00:00Z',\n        });\n        this.exit(1);\n      }\n      scheduledDate = parsed;\n\n      const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;\n      if (!isJsonMode()) {\n        info(`Interpreted \"${at}\" as ${scheduledDate.toLocaleString()} (${tz})`);\n      }\n    }\n\n    const timeUntilSend = scheduledDate.getTime() - Date.now();\n\n    if (timeUntilSend < 0) {\n      error(\"That time is in the past\", {\n        hint: 'Did you mean a future time? Try: \"tomorrow at 9am\" or \"in 2 hours\"',\n      });\n      this.exit(1);\n    }\n\n    const FIVE_MINUTES = 5 * 60 * 1000;\n    if (timeUntilSend < FIVE_MINUTES) {\n      const mins = Math.ceil(timeUntilSend / 60000);\n      error(`Too soon — that's only ${mins} minute${mins !== 1 ? \"s\" : \"\"} from now`, {\n        hint: \"Messages must be scheduled at least 5 minutes in the future\",\n      });\n      this.exit(1);\n    }\n\n    const FIVE_DAYS = 5 * 24 * 60 * 60 * 1000;\n    if (timeUntilSend > FIVE_DAYS) {\n      error(\"Too far — must be within 5 days\", {\n        hint: `That's ${Math.ceil(timeUntilSend / 86400000)} days from now. Maximum is 5 days.`,\n      });\n      this.exit(1);\n    }\n\n    const spin = spinner(\"Scheduling message...\");\n    spin.start();\n\n    try {\n      const response = await apiClient.post<ScheduledMessageResponse>(\n        \"/api/v1/messages/schedule\",\n        {\n          to,\n          text,\n          scheduledAt: scheduledDate.toISOString(),\n          messageType: flags.type,\n          ...(flags.from && { from: flags.from }),\n        },\n      );\n\n      spin.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      const formattedTime = new Date(response.scheduledAt).toLocaleString();\n\n      success(\"Message scheduled\", {\n        ID: response.id,\n        To: response.to,\n        Status: formatStatus(response.status),\n        \"Scheduled For\": colors.code(formattedTime),\n      });\n    } catch (err) {\n      spin.stop();\n      throw err;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,16 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class SmsSearch extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        query: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        limit: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        page: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        offset: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number | 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/search.js

@@ -0,0 +1,105 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { table, json, info, formatStatus, formatRelativeTime, formatPhone, colors, isJsonMode, } from "../../lib/output.js";
+export default class SmsSearch extends AuthenticatedCommand {
+    static description = "Search messages by text content";
+    static examples = [
+        '<%= config.bin %> sms search "verification code"',
+        '<%= config.bin %> sms search "hello" --limit 10',
+        '<%= config.bin %> sms search "order" --json',
+    ];
+    static args = {
+        query: Args.string({
+            description: "Search query",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        limit: Flags.integer({
+            char: "l",
+            description: "Number of results per page",
+            default: 20,
+        }),
+        page: Flags.integer({
+            char: "p",
+            description: "Page number (starts at 1)",
+        }),
+        offset: Flags.integer({
+            description: "Offset from start (alternative to --page)",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SmsSearch);
+        const response = await apiClient.get("/api/v1/messages", {
+            q: args.query,
+            limit: flags.limit,
+            ...(flags.page && { page: flags.page }),
+            ...(flags.offset && { offset: flags.offset }),
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (response.data.length === 0) {
+            info(`No messages matching "${args.query}"`);
+            return;
+        }
+        const pagination = response.pagination || {
+            total: response.count,
+            page: 1,
+            totalPages: 1,
+            hasMore: false,
+        };
+        console.log();
+        console.log(colors.dim(`Showing ${response.data.length} results for "${args.query}" (page ${pagination.page} of ${pagination.totalPages}, ${pagination.total} total)`));
+        console.log();
+        table(response.data, [
+            {
+                header: "ID",
+                key: "id",
+                width: 18,
+                formatter: (v) => colors.dim(String(v).slice(0, 15) + "..."),
+            },
+            {
+                header: "To",
+                key: "to",
+                width: 16,
+                formatter: (v) => formatPhone(String(v)),
+            },
+            {
+                header: "Status",
+                key: "status",
+                width: 11,
+                formatter: (v) => formatStatus(String(v)),
+            },
+            {
+                header: "Mode",
+                key: "isSandbox",
+                width: 6,
+                formatter: (v) => (v ? colors.warning("test") : colors.success("live")),
+            },
+            {
+                header: "Text",
+                key: "text",
+                width: 25,
+                formatter: (v) => {
+                    const text = String(v);
+                    return text.length > 22 ? text.slice(0, 22) + "..." : text;
+                },
+            },
+            {
+                header: "Sent",
+                key: "createdAt",
+                width: 12,
+                formatter: (v) => formatRelativeTime(String(v)),
+            },
+        ]);
+        if (pagination.hasMore) {
+            console.log();
+            console.log(colors.dim(`  Use ${colors.code(`--page ${pagination.page + 1}`)} to see more`));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.js","sourceRoot":"","sources":["../../../src/commands/sms/search.ts"],"names":[],"mappings":"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","sourcesContent":["import { Args, Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport {\n  table,\n  json,\n  info,\n  formatStatus,\n  formatRelativeTime,\n  formatPhone,\n  colors,\n  isJsonMode,\n} from \"../../lib/output.js\";\n\ninterface Message {\n  id: string;\n  to: string;\n  from: string;\n  text: string;\n  status: string;\n  segments: number;\n  creditsUsed: number;\n  isSandbox: boolean;\n  createdAt: string;\n  deliveredAt?: string;\n}\n\ninterface Pagination {\n  total: number;\n  limit: number;\n  offset: number;\n  page: number;\n  totalPages: number;\n  hasMore: boolean;\n}\n\ninterface ListMessagesResponse {\n  data: Message[];\n  pagination: Pagination;\n  count: number;\n}\n\nexport default class SmsSearch extends AuthenticatedCommand {\n  static description = \"Search messages by text content\";\n\n  static examples = [\n    '<%= config.bin %> sms search \"verification code\"',\n    '<%= config.bin %> sms search \"hello\" --limit 10',\n    '<%= config.bin %> sms search \"order\" --json',\n  ];\n\n  static args = {\n    query: Args.string({\n      description: \"Search query\",\n      required: true,\n    }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    limit: Flags.integer({\n      char: \"l\",\n      description: \"Number of results per page\",\n      default: 20,\n    }),\n    page: Flags.integer({\n      char: \"p\",\n      description: \"Page number (starts at 1)\",\n    }),\n    offset: Flags.integer({\n      description: \"Offset from start (alternative to --page)\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { args, flags } = await this.parse(SmsSearch);\n\n    const response = await apiClient.get<ListMessagesResponse>(\n      \"/api/v1/messages\",\n      {\n        q: args.query,\n        limit: flags.limit,\n        ...(flags.page && { page: flags.page }),\n        ...(flags.offset && { offset: flags.offset }),\n      },\n    );\n\n    if (isJsonMode()) {\n      json(response);\n      return;\n    }\n\n    if (response.data.length === 0) {\n      info(`No messages matching \"${args.query}\"`);\n      return;\n    }\n\n    const pagination = response.pagination || {\n      total: response.count,\n      page: 1,\n      totalPages: 1,\n      hasMore: false,\n    };\n\n    console.log();\n    console.log(\n      colors.dim(\n        `Showing ${response.data.length} results for \"${args.query}\" (page ${pagination.page} of ${pagination.totalPages}, ${pagination.total} total)`,\n      ),\n    );\n    console.log();\n\n    table(response.data, [\n      {\n        header: \"ID\",\n        key: \"id\",\n        width: 18,\n        formatter: (v) => colors.dim(String(v).slice(0, 15) + \"...\"),\n      },\n      {\n        header: \"To\",\n        key: \"to\",\n        width: 16,\n        formatter: (v) => formatPhone(String(v)),\n      },\n      {\n        header: \"Status\",\n        key: \"status\",\n        width: 11,\n        formatter: (v) => formatStatus(String(v)),\n      },\n      {\n        header: \"Mode\",\n        key: \"isSandbox\",\n        width: 6,\n        formatter: (v) => (v ? colors.warning(\"test\") : colors.success(\"live\")),\n      },\n      {\n        header: \"Text\",\n        key: \"text\",\n        width: 25,\n        formatter: (v) => {\n          const text = String(v);\n          return text.length > 22 ? text.slice(0, 22) + \"...\" : text;\n        },\n      },\n      {\n        header: \"Sent\",\n        key: \"createdAt\",\n        width: 12,\n        formatter: (v) => formatRelativeTime(String(v)),\n      },\n    ]);\n\n    if (pagination.hasMore) {\n      console.log();\n      console.log(\n        colors.dim(\n          `  Use ${colors.code(`--page ${pagination.page + 1}`)} to see more`,\n        ),\n      );\n    }\n  }\n}\n"]}

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

@@ -3,7 +3,7 @@ export default class SmsSend extends AuthenticatedCommand {
     static description: string;
     static examples: string[];
     static flags: {
-        to: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        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, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;

package/dist/commands/sms/send.js

@@ -2,6 +2,7 @@ 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, formatCredits, json, isJsonMode, } from "../../lib/output.js";
+import inquirer from "inquirer";
 export default class SmsSend extends AuthenticatedCommand {
     static description = "Send an SMS or MMS message";
     static examples = [
@@ -18,7 +19,6 @@ export default class SmsSend extends AuthenticatedCommand {
         to: Flags.string({
             char: "t",
             description: "Recipient phone number (E.164 format)",
-            required: true,
         }),
         text: Flags.string({
             char: "m",
@@ -42,17 +42,62 @@ export default class SmsSend extends AuthenticatedCommand {
         const { flags } = await this.parse(SmsSend);
         const mediaUrls = flags["media-url"];
         const hasMedia = mediaUrls && mediaUrls.length > 0;
-        if (!/^\+[1-9]\d{1,14}$/.test(flags.to)) {
+        let to = flags.to;
+        let text = flags.text;
+        if (!to) {
+            if (process.stdin.isTTY) {
+                const answers = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "to",
+                        message: "Recipient phone number (E.164):",
+                        validate: (input) => {
+                            if (!input)
+                                return "Phone number is required";
+                            if (!/^\+[1-9]\d{1,14}$/.test(input)) {
+                                return "Invalid format. Use E.164: +15551234567";
+                            }
+                            return true;
+                        },
+                    },
+                ]);
+                to = answers.to;
+            }
+            else {
+                error("Missing required flag: --to", {
+                    hint: "Use --to +15551234567",
+                });
+                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 (!/^\+[1-9]\d{1,14}$/.test(to)) {
             error("Invalid phone number format", {
                 hint: "Use E.164 format: +15551234567",
             });
             this.exit(1);
         }
-        if (!flags.text && !hasMedia) {
-            error("Either --text or --media-url is required");
-            this.exit(1);
-        }
-        if (flags.text && !flags.text.trim()) {
+        if (text && !text.trim()) {
             error("Message text cannot be empty");
             this.exit(1);
         }
@@ -61,9 +106,9 @@ export default class SmsSend extends AuthenticatedCommand {
         spin.start();
         try {
             const response = await apiClient.post("/api/v1/messages", {
-                to: flags.to,
+                to,
                 messageType: flags.type,
-                ...(flags.text && { text: flags.text }),
+                ...(text && { text }),
                 ...(flags.from && { from: flags.from }),
                 ...(hasMedia && { mediaUrls }),
             });
@@ -93,4 +138,4 @@ export default class SmsSend extends AuthenticatedCommand {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"send.js","sourceRoot":"","sources":["../../../src/commands/sms/send.ts"],"names":[],"mappings":"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","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  formatCredits,\n  json,\n  isJsonMode,\n} from \"../../lib/output.js\";\n\ninterface SendMessageResponse {\n  id: string;\n  to: string;\n  from: string;\n  text: string;\n  status: string;\n  segments: number;\n  creditsUsed: number;\n  createdAt: string;\n  mediaUrls?: string[];\n}\n\nexport default class SmsSend extends AuthenticatedCommand {\n  static description = \"Send an SMS or MMS message\";\n\n  static examples = [\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\"',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\" --from \"Sendly\"',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\" --type transactional',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\" --json',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Check this out\" --media-url https://example.com/image.jpg',\n    '<%= config.bin %> sms send --to +15551234567 --media-url https://example.com/image.jpg',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Two images\" --media-url https://example.com/a.jpg --media-url https://example.com/b.jpg',\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    to: Flags.string({\n      char: \"t\",\n      description: \"Recipient phone number (E.164 format)\",\n      required: true,\n    }),\n    text: Flags.string({\n      char: \"m\",\n      description: \"Message text (optional when --media-url is provided)\",\n    }),\n    from: Flags.string({\n      char: \"f\",\n      description: \"Sender ID or phone number\",\n    }),\n    type: Flags.string({\n      description: \"Message type: marketing (default) or transactional\",\n      options: [\"marketing\", \"transactional\"],\n      default: \"marketing\",\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(SmsSend);\n    const mediaUrls = flags[\"media-url\"];\n    const hasMedia = mediaUrls && mediaUrls.length > 0;\n\n    if (!/^\\+[1-9]\\d{1,14}$/.test(flags.to)) {\n      error(\"Invalid phone number format\", {\n        hint: \"Use E.164 format: +15551234567\",\n      });\n      this.exit(1);\n    }\n\n    if (!flags.text && !hasMedia) {\n      error(\"Either --text or --media-url is required\");\n      this.exit(1);\n    }\n\n    if (flags.text && !flags.text.trim()) {\n      error(\"Message text cannot be empty\");\n      this.exit(1);\n    }\n\n    const messageLabel = hasMedia ? \"MMS\" : \"SMS\";\n    const spin = spinner(`Sending ${messageLabel} message...`);\n    spin.start();\n\n    try {\n      const response = await apiClient.post<SendMessageResponse>(\n        \"/api/v1/messages\",\n        {\n          to: flags.to,\n          messageType: flags.type,\n          ...(flags.text && { text: flags.text }),\n          ...(flags.from && { from: flags.from }),\n          ...(hasMedia && { mediaUrls }),\n        },\n      );\n\n      spin.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      success(`${messageLabel} sent`, {\n        ID: response.id,\n        To: response.to,\n        Type: messageLabel,\n        Status: formatStatus(response.status),\n        ...(response.segments != null && { Segments: response.segments }),\n        Credits: formatCredits(response.creditsUsed),\n        ...(hasMedia && { Media: `${mediaUrls.length} attachment${mediaUrls.length > 1 ? \"s\" : \"\"}` }),\n      });\n\n      if (hasMedia && !isJsonMode()) {\n        for (const url of mediaUrls) {\n          console.log(`  ${colors.dim(\"Media:\")} ${url}`);\n        }\n      }\n    } catch (err) {\n      spin.stop();\n      throw err;\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"send.js","sourceRoot":"","sources":["../../../src/commands/sms/send.ts"],"names":[],"mappings":"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","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  formatCredits,\n  json,\n  isJsonMode,\n} from \"../../lib/output.js\";\nimport inquirer from \"inquirer\";\n\ninterface SendMessageResponse {\n  id: string;\n  to: string;\n  from: string;\n  text: string;\n  status: string;\n  segments: number;\n  creditsUsed: number;\n  createdAt: string;\n  mediaUrls?: string[];\n}\n\nexport default class SmsSend extends AuthenticatedCommand {\n  static description = \"Send an SMS or MMS message\";\n\n  static examples = [\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\"',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\" --from \"Sendly\"',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\" --type transactional',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\" --json',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Check this out\" --media-url https://example.com/image.jpg',\n    '<%= config.bin %> sms send --to +15551234567 --media-url https://example.com/image.jpg',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Two images\" --media-url https://example.com/a.jpg --media-url https://example.com/b.jpg',\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    to: Flags.string({\n      char: \"t\",\n      description: \"Recipient phone number (E.164 format)\",\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\",\n    }),\n    type: Flags.string({\n      description: \"Message type: marketing (default) or transactional\",\n      options: [\"marketing\", \"transactional\"],\n      default: \"marketing\",\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(SmsSend);\n    const mediaUrls = flags[\"media-url\"];\n    const hasMedia = mediaUrls && mediaUrls.length > 0;\n\n    let to = flags.to;\n    let text = flags.text;\n\n    if (!to) {\n      if (process.stdin.isTTY) {\n        const answers = await inquirer.prompt([\n          {\n            type: \"input\",\n            name: \"to\",\n            message: \"Recipient phone number (E.164):\",\n            validate: (input: string) => {\n              if (!input) return \"Phone number is required\";\n              if (!/^\\+[1-9]\\d{1,14}$/.test(input)) {\n                return \"Invalid format. Use E.164: +15551234567\";\n              }\n              return true;\n            },\n          },\n        ]);\n        to = answers.to;\n      } else {\n        error(\"Missing required flag: --to\", {\n          hint: \"Use --to +15551234567\",\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 (!/^\\+[1-9]\\d{1,14}$/.test(to!)) {\n      error(\"Invalid phone number format\", {\n        hint: \"Use E.164 format: +15551234567\",\n      });\n      this.exit(1);\n    }\n\n    if (text && !text.trim()) {\n      error(\"Message text cannot be empty\");\n      this.exit(1);\n    }\n\n    const messageLabel = hasMedia ? \"MMS\" : \"SMS\";\n    const spin = spinner(`Sending ${messageLabel} message...`);\n    spin.start();\n\n    try {\n      const response = await apiClient.post<SendMessageResponse>(\n        \"/api/v1/messages\",\n        {\n          to,\n          messageType: flags.type,\n          ...(text && { text }),\n          ...(flags.from && { from: flags.from }),\n          ...(hasMedia && { mediaUrls }),\n        },\n      );\n\n      spin.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      success(`${messageLabel} sent`, {\n        ID: response.id,\n        To: response.to,\n        Type: messageLabel,\n        Status: formatStatus(response.status),\n        ...(response.segments != null && { Segments: response.segments }),\n        Credits: formatCredits(response.creditsUsed),\n        ...(hasMedia && { Media: `${mediaUrls.length} attachment${mediaUrls.length > 1 ? \"s\" : \"\"}` }),\n      });\n\n      if (hasMedia && !isJsonMode()) {\n        for (const url of mediaUrls) {\n          console.log(`  ${colors.dim(\"Media:\")} ${url}`);\n        }\n      }\n    } catch (err) {\n      spin.stop();\n      throw err;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,15 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class TemplatesUpdate 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: {
+        name: 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>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}