@sendly/cli 1.0.0

package/dist/commands/sms/batch.js

@@ -0,0 +1,163 @@
+import { Flags } from "@oclif/core";
+import { readFileSync } from "fs";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, spinner, colors, json, isJsonMode, } from "../../lib/output.js";
+export default class SmsBatch extends AuthenticatedCommand {
+    static description = "Send batch SMS messages";
+    static examples = [
+        "<%= config.bin %> sms batch --file recipients.json",
+        '<%= config.bin %> sms batch --to +15551234567,+15559876543 --text "Hello everyone!"',
+        '<%= config.bin %> sms batch --file recipients.csv --from "Sendly"',
+        "<%= config.bin %> sms batch --file messages.json --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        file: Flags.string({
+            char: "F",
+            description: "JSON file with messages array [{to, text}, ...]",
+            exclusive: ["to"],
+        }),
+        to: Flags.string({
+            char: "t",
+            description: "Comma-separated recipient phone numbers (E.164 format)",
+            exclusive: ["file"],
+        }),
+        text: Flags.string({
+            char: "m",
+            description: "Message text (used with --to flag)",
+        }),
+        from: Flags.string({
+            char: "f",
+            description: "Sender ID or phone number for all messages",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SmsBatch);
+        let messages = [];
+        // Parse messages from file or flags
+        if (flags.file) {
+            messages = this.parseMessagesFromFile(flags.file);
+        }
+        else if (flags.to) {
+            if (!flags.text) {
+                error("--text is required when using --to");
+                this.exit(1);
+            }
+            messages = this.parseMessagesFromFlags(flags.to, flags.text);
+        }
+        else {
+            error("Either --file or --to is required");
+            this.exit(1);
+        }
+        // Validate messages
+        if (messages.length === 0) {
+            error("No messages to send");
+            this.exit(1);
+        }
+        if (messages.length > 1000) {
+            error("Batch size cannot exceed 1000 messages", {
+                hint: "Split your messages into smaller batches",
+            });
+            this.exit(1);
+        }
+        // Validate each message
+        for (const msg of messages) {
+            if (!/^\+[1-9]\d{1,14}$/.test(msg.to)) {
+                error(`Invalid phone number: ${msg.to}`, {
+                    hint: "Use E.164 format: +15551234567",
+                });
+                this.exit(1);
+            }
+            if (!msg.text?.trim()) {
+                error(`Empty message text for ${msg.to}`);
+                this.exit(1);
+            }
+        }
+        const spin = spinner(`Sending ${messages.length} messages...`);
+        spin.start();
+        try {
+            const response = await apiClient.post("/api/v1/messages/batch", {
+                messages,
+                ...(flags.from && { from: flags.from }),
+            });
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Batch sent", {
+                "Batch ID": response.batchId,
+                Total: response.total,
+                Queued: colors.success(String(response.queued)),
+                Failed: response.failed > 0 ? colors.error(String(response.failed)) : "0",
+                "Credits Used": response.creditsUsed,
+                Status: response.status,
+            });
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+    parseMessagesFromFile(filePath) {
+        try {
+            const content = readFileSync(filePath, "utf-8");
+            // Try JSON first
+            if (filePath.endsWith(".json")) {
+                const data = JSON.parse(content);
+                if (Array.isArray(data)) {
+                    return data.map((item) => ({
+                        to: item.to,
+                        text: item.text,
+                    }));
+                }
+                if (data.messages && Array.isArray(data.messages)) {
+                    return data.messages;
+                }
+                error("Invalid JSON format", {
+                    hint: "Expected array of {to, text} objects or {messages: [...]}",
+                });
+                this.exit(1);
+            }
+            // Try CSV
+            if (filePath.endsWith(".csv")) {
+                const lines = content.trim().split("\n");
+                const messages = [];
+                // Skip header if present
+                const startIndex = lines[0].toLowerCase().includes("to") ? 1 : 0;
+                for (let i = startIndex; i < lines.length; i++) {
+                    const parts = lines[i].split(",");
+                    if (parts.length >= 2) {
+                        messages.push({
+                            to: parts[0].trim().replace(/"/g, ""),
+                            text: parts.slice(1).join(",").trim().replace(/"/g, ""),
+                        });
+                    }
+                }
+                return messages;
+            }
+            error("Unsupported file format", {
+                hint: "Use .json or .csv file",
+            });
+            this.exit(1);
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                error(`File not found: ${filePath}`);
+            }
+            else if (err instanceof SyntaxError) {
+                error("Invalid JSON in file", { hint: err.message });
+            }
+            else {
+                throw err;
+            }
+            this.exit(1);
+        }
+    }
+    parseMessagesFromFlags(to, text) {
+        const phones = to.split(",").map((p) => p.trim());
+        return phones.map((phone) => ({ to: phone, text }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"batch.js","sourceRoot":"","sources":["../../../src/commands/sms/batch.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { readFileSync } from \"fs\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport {\n  success,\n  error,\n  spinner,\n  colors,\n  json,\n  isJsonMode,\n} from \"../../lib/output.js\";\n\ninterface BatchMessage {\n  to: string;\n  text: string;\n}\n\ninterface BatchResponse {\n  batchId: string;\n  total: number;\n  queued: number;\n  failed: number;\n  creditsUsed: number;\n  status: string;\n}\n\nexport default class SmsBatch extends AuthenticatedCommand {\n  static description = \"Send batch SMS messages\";\n\n  static examples = [\n    \"<%= config.bin %> sms batch --file recipients.json\",\n    '<%= config.bin %> sms batch --to +15551234567,+15559876543 --text \"Hello everyone!\"',\n    '<%= config.bin %> sms batch --file recipients.csv --from \"Sendly\"',\n    \"<%= config.bin %> sms batch --file messages.json --json\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    file: Flags.string({\n      char: \"F\",\n      description: \"JSON file with messages array [{to, text}, ...]\",\n      exclusive: [\"to\"],\n    }),\n    to: Flags.string({\n      char: \"t\",\n      description: \"Comma-separated recipient phone numbers (E.164 format)\",\n      exclusive: [\"file\"],\n    }),\n    text: Flags.string({\n      char: \"m\",\n      description: \"Message text (used with --to flag)\",\n    }),\n    from: Flags.string({\n      char: \"f\",\n      description: \"Sender ID or phone number for all messages\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(SmsBatch);\n\n    let messages: BatchMessage[] = [];\n\n    // Parse messages from file or flags\n    if (flags.file) {\n      messages = this.parseMessagesFromFile(flags.file);\n    } else if (flags.to) {\n      if (!flags.text) {\n        error(\"--text is required when using --to\");\n        this.exit(1);\n      }\n      messages = this.parseMessagesFromFlags(flags.to, flags.text);\n    } else {\n      error(\"Either --file or --to is required\");\n      this.exit(1);\n    }\n\n    // Validate messages\n    if (messages.length === 0) {\n      error(\"No messages to send\");\n      this.exit(1);\n    }\n\n    if (messages.length > 1000) {\n      error(\"Batch size cannot exceed 1000 messages\", {\n        hint: \"Split your messages into smaller batches\",\n      });\n      this.exit(1);\n    }\n\n    // Validate each message\n    for (const msg of messages) {\n      if (!/^\\+[1-9]\\d{1,14}$/.test(msg.to)) {\n        error(`Invalid phone number: ${msg.to}`, {\n          hint: \"Use E.164 format: +15551234567\",\n        });\n        this.exit(1);\n      }\n      if (!msg.text?.trim()) {\n        error(`Empty message text for ${msg.to}`);\n        this.exit(1);\n      }\n    }\n\n    const spin = spinner(`Sending ${messages.length} messages...`);\n    spin.start();\n\n    try {\n      const response = await apiClient.post<BatchResponse>(\n        \"/api/v1/messages/batch\",\n        {\n          messages,\n          ...(flags.from && { from: flags.from }),\n        },\n      );\n\n      spin.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      success(\"Batch sent\", {\n        \"Batch ID\": response.batchId,\n        Total: response.total,\n        Queued: colors.success(String(response.queued)),\n        Failed:\n          response.failed > 0 ? colors.error(String(response.failed)) : \"0\",\n        \"Credits Used\": response.creditsUsed,\n        Status: response.status,\n      });\n    } catch (err) {\n      spin.stop();\n      throw err;\n    }\n  }\n\n  private parseMessagesFromFile(filePath: string): BatchMessage[] {\n    try {\n      const content = readFileSync(filePath, \"utf-8\");\n\n      // Try JSON first\n      if (filePath.endsWith(\".json\")) {\n        const data = JSON.parse(content);\n        if (Array.isArray(data)) {\n          return data.map((item) => ({\n            to: item.to,\n            text: item.text,\n          }));\n        }\n        if (data.messages && Array.isArray(data.messages)) {\n          return data.messages;\n        }\n        error(\"Invalid JSON format\", {\n          hint: \"Expected array of {to, text} objects or {messages: [...]}\",\n        });\n        this.exit(1);\n      }\n\n      // Try CSV\n      if (filePath.endsWith(\".csv\")) {\n        const lines = content.trim().split(\"\\n\");\n        const messages: BatchMessage[] = [];\n\n        // Skip header if present\n        const startIndex = lines[0].toLowerCase().includes(\"to\") ? 1 : 0;\n\n        for (let i = startIndex; i < lines.length; i++) {\n          const parts = lines[i].split(\",\");\n          if (parts.length >= 2) {\n            messages.push({\n              to: parts[0].trim().replace(/\"/g, \"\"),\n              text: parts.slice(1).join(\",\").trim().replace(/\"/g, \"\"),\n            });\n          }\n        }\n        return messages;\n      }\n\n      error(\"Unsupported file format\", {\n        hint: \"Use .json or .csv file\",\n      });\n      this.exit(1);\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code === \"ENOENT\") {\n        error(`File not found: ${filePath}`);\n      } else if (err instanceof SyntaxError) {\n        error(\"Invalid JSON in file\", { hint: err.message });\n      } else {\n        throw err;\n      }\n      this.exit(1);\n    }\n  }\n\n  private parseMessagesFromFlags(to: string, text: string): BatchMessage[] {\n    const phones = to.split(\",\").map((p) => p.trim());\n    return phones.map((phone) => ({ to: phone, text }));\n  }\n}\n"]}

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

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class SmsCancel 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/sms/cancel.js

@@ -0,0 +1,46 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, spinner, json, isJsonMode, } from "../../lib/output.js";
+export default class SmsCancel extends AuthenticatedCommand {
+    static description = "Cancel a scheduled message";
+    static examples = [
+        "<%= config.bin %> sms cancel sched_abc123",
+        "<%= config.bin %> sms cancel sched_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Scheduled message ID to cancel",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(SmsCancel);
+        if (!args.id.trim()) {
+            error("Scheduled message ID is required");
+            this.exit(1);
+        }
+        const spin = spinner("Cancelling scheduled message...");
+        spin.start();
+        try {
+            const response = await apiClient.delete(`/api/v1/messages/scheduled/${encodeURIComponent(args.id)}`);
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Scheduled message cancelled", {
+                ID: response.id,
+                Status: "cancelled",
+            });
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class SmsGet 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/sms/get.js

@@ -0,0 +1,51 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { keyValue, json, header, formatStatus, formatDate, formatCredits, formatPhone, colors, divider, isJsonMode, } from "../../lib/output.js";
+export default class SmsGet extends AuthenticatedCommand {
+    static description = "Get details of a specific message";
+    static examples = [
+        "<%= config.bin %> sms get msg_abc123",
+        "<%= config.bin %> sms get msg_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Message ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(SmsGet);
+        const message = await apiClient.get(`/api/v1/messages/${encodeURIComponent(args.id)}`);
+        if (isJsonMode()) {
+            json(message);
+            return;
+        }
+        header("Message Details");
+        keyValue({
+            ID: message.id,
+            To: formatPhone(message.to),
+            From: message.from || colors.dim("(default)"),
+            Status: formatStatus(message.status),
+            Segments: message.segments,
+            Credits: formatCredits(message.creditsUsed),
+            Sandbox: message.isSandbox ? colors.warning("Yes") : "No",
+            Created: formatDate(message.createdAt),
+            ...(message.deliveredAt && {
+                Delivered: formatDate(message.deliveredAt),
+            }),
+            ...(message.error && {
+                Error: colors.error(message.error),
+            }),
+        });
+        divider();
+        console.log(colors.bold("Message Text:"));
+        console.log(colors.dim("─".repeat(40)));
+        console.log(message.text);
+        console.log();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

@@ -0,0 +1,79 @@
+import { 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 SmsList extends AuthenticatedCommand {
+    static description = "List sent messages";
+    static examples = [
+        "<%= config.bin %> sms list",
+        "<%= config.bin %> sms list --limit 10",
+        "<%= config.bin %> sms list --status delivered",
+        "<%= config.bin %> sms list --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        limit: Flags.integer({
+            char: "l",
+            description: "Number of messages to show",
+            default: 20,
+        }),
+        status: Flags.string({
+            char: "s",
+            description: "Filter by status (queued, sent, delivered, failed)",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SmsList);
+        const response = await apiClient.get("/api/v1/messages", {
+            limit: flags.limit,
+            ...(flags.status && { status: flags.status }),
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (response.data.length === 0) {
+            info("No messages found");
+            return;
+        }
+        console.log();
+        console.log(colors.dim(`Showing ${response.data.length} of ${response.count} messages`));
+        console.log();
+        table(response.data, [
+            {
+                header: "ID",
+                key: "id",
+                width: 20,
+                formatter: (v) => colors.dim(String(v).slice(0, 16) + "..."),
+            },
+            {
+                header: "To",
+                key: "to",
+                width: 18,
+                formatter: (v) => formatPhone(String(v)),
+            },
+            {
+                header: "Status",
+                key: "status",
+                width: 12,
+                formatter: (v) => formatStatus(String(v)),
+            },
+            {
+                header: "Text",
+                key: "text",
+                width: 30,
+                formatter: (v) => {
+                    const text = String(v);
+                    return text.length > 27 ? text.slice(0, 27) + "..." : text;
+                },
+            },
+            {
+                header: "Sent",
+                key: "createdAt",
+                width: 12,
+                formatter: (v) => formatRelativeTime(String(v)),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+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>;
+        from: 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/schedule.js

@@ -0,0 +1,91 @@
+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";
+export default class SmsSchedule extends AuthenticatedCommand {
+    static description = "Schedule an SMS message for future delivery";
+    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 "Hello!" --at "2025-01-20T10:00:00Z" --json',
+    ];
+    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,
+        }),
+        from: Flags.string({
+            char: "f",
+            description: "Sender ID or phone number",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SmsSchedule);
+        // Validate phone number format
+        if (!/^\+[1-9]\d{1,14}$/.test(flags.to)) {
+            error("Invalid phone number format", {
+                hint: "Use E.164 format: +15551234567",
+            });
+            this.exit(1);
+        }
+        // Validate message text
+        if (!flags.text.trim()) {
+            error("Message text cannot be empty");
+            this.exit(1);
+        }
+        // Validate scheduled time
+        const scheduledDate = new Date(flags.at);
+        if (isNaN(scheduledDate.getTime())) {
+            error("Invalid scheduled time format", {
+                hint: "Use ISO 8601 format: 2025-01-20T10:00:00Z",
+            });
+            this.exit(1);
+        }
+        // Check if scheduled time is in the future
+        if (scheduledDate.getTime() <= Date.now()) {
+            error("Scheduled time must be in the future", {
+                hint: "The scheduled time must be at least 1 minute from now",
+            });
+            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,
+                ...(flags.from && { from: flags.from }),
+            });
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            const formattedTime = new Date(response.scheduledAt).toLocaleString();
+            success("Message scheduled", {
+                ID: response.id,
+                To: response.to,
+                Status: formatStatus(response.status),
+                "Scheduled For": colors.code(formattedTime),
+            });
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+}
+//# 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} 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 \"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  };\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 if scheduled time is in the future\n    if (scheduledDate.getTime() <= Date.now()) {\n      error(\"Scheduled time must be in the future\", {\n        hint: \"The scheduled time must be at least 1 minute from now\",\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: flags.to,\n          text: flags.text,\n          scheduledAt: flags.at,\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/scheduled.d.ts

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