@sendly/cli 3.12.2 → 3.13.0

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

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

@@ -0,0 +1,34 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, success, colors, isJsonMode, keyValue } from "../../lib/output.js";
+export default class CampaignsCancel extends AuthenticatedCommand {
+    static description = "Cancel a scheduled campaign";
+    static examples = [
+        "<%= config.bin %> campaigns cancel cmp_xxx",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Campaign ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(CampaignsCancel);
+        const campaign = await apiClient.post(`/api/v1/campaigns/${args.id}/cancel`);
+        if (isJsonMode()) {
+            json(campaign);
+            return;
+        }
+        success(`Campaign cancelled`);
+        console.log();
+        keyValue([
+            ["Campaign", campaign.name],
+            ["Status", colors.dim("cancelled")],
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/campaigns/create.d.ts

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

@@ -0,0 +1,63 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, success, colors, isJsonMode, keyValue } from "../../lib/output.js";
+export default class CampaignsCreate extends AuthenticatedCommand {
+    static description = "Create a new campaign";
+    static examples = [
+        '<%= config.bin %> campaigns create --name "Welcome" --text "Hello {{name}}!" --list lst_xxx',
+        '<%= config.bin %> campaigns create --name "Sale" --text "50% off today!" --list lst_customers --list lst_subscribers',
+        "<%= config.bin %> campaigns create --name \"OTP\" --template tpl_preset_otp --list lst_xxx",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "Campaign name",
+            required: true,
+        }),
+        text: Flags.string({
+            char: "t",
+            description: "Message text (supports {{variables}})",
+        }),
+        template: Flags.string({
+            description: "Template ID to use instead of text",
+        }),
+        list: Flags.string({
+            char: "l",
+            description: "Contact list ID (can specify multiple)",
+            multiple: true,
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(CampaignsCreate);
+        if (!flags.text && !flags.template) {
+            this.error("Either --text or --template is required");
+        }
+        const campaign = await apiClient.post("/api/v1/campaigns", {
+            name: flags.name,
+            text: flags.text,
+            templateId: flags.template,
+            contactListIds: flags.list,
+        });
+        if (isJsonMode()) {
+            json(campaign);
+            return;
+        }
+        success(`Campaign created: ${campaign.id}`);
+        console.log();
+        keyValue([
+            ["Name", campaign.name],
+            ["Status", colors.dim("draft")],
+            ["Recipients", String(campaign.recipientCount)],
+            ["Estimated Credits", String(campaign.estimatedCredits)],
+        ]);
+        console.log();
+        console.log(colors.dim("Next steps:"));
+        console.log(`  Preview:  ${colors.code(`sendly campaigns preview ${campaign.id}`)}`);
+        console.log(`  Send now: ${colors.code(`sendly campaigns send ${campaign.id}`)}`);
+        console.log(`  Schedule: ${colors.code(`sendly campaigns schedule ${campaign.id} --at "2024-01-15T10:00:00Z"`)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/campaigns/delete.d.ts

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

package/dist/commands/campaigns/delete.js

@@ -0,0 +1,63 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, success, colors, isJsonMode, warn } from "../../lib/output.js";
+import * as readline from "readline";
+async function confirm(message) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(`${message} (y/N) `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+        });
+    });
+}
+export default class CampaignsDelete extends AuthenticatedCommand {
+    static description = "Delete a campaign";
+    static examples = [
+        "<%= config.bin %> campaigns delete cmp_xxx",
+        "<%= config.bin %> campaigns delete cmp_xxx --yes",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Campaign ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(CampaignsDelete);
+        const campaign = await apiClient.get(`/api/v1/campaigns/${args.id}`);
+        if (!["draft", "cancelled"].includes(campaign.status)) {
+            warn(`Cannot delete a campaign with status "${campaign.status}". Only draft and cancelled campaigns can be deleted.`);
+            this.exit(1);
+        }
+        if (!flags.yes && !isJsonMode()) {
+            console.log();
+            console.log(`Campaign: ${colors.bold(campaign.name)}`);
+            console.log();
+            const confirmed = await confirm(colors.warning("Delete this campaign permanently?"));
+            if (!confirmed) {
+                console.log(colors.dim("Cancelled"));
+                return;
+            }
+        }
+        await apiClient.delete(`/api/v1/campaigns/${args.id}`);
+        if (isJsonMode()) {
+            json({ deleted: true, id: args.id });
+            return;
+        }
+        success(`Campaign deleted`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

@@ -0,0 +1,91 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, colors, isJsonMode, keyValue } from "../../lib/output.js";
+function formatStatus(status) {
+    switch (status) {
+        case "draft":
+            return colors.dim("Draft");
+        case "scheduled":
+            return colors.warning("Scheduled");
+        case "sending":
+            return colors.info("Sending");
+        case "sent":
+            return colors.success("Sent");
+        case "paused":
+            return colors.warning("Paused");
+        case "cancelled":
+            return colors.dim("Cancelled");
+        case "failed":
+            return colors.error("Failed");
+        default:
+            return status;
+    }
+}
+export default class CampaignsGet extends AuthenticatedCommand {
+    static description = "Get campaign details";
+    static examples = [
+        "<%= config.bin %> campaigns get cmp_xxx",
+        "<%= config.bin %> campaigns get cmp_xxx --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Campaign ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(CampaignsGet);
+        const campaign = await apiClient.get(`/api/v1/campaigns/${args.id}`);
+        if (isJsonMode()) {
+            json(campaign);
+            return;
+        }
+        console.log();
+        console.log(colors.bold(`Campaign: ${campaign.name}`));
+        console.log();
+        keyValue([
+            ["ID", campaign.id],
+            ["Status", formatStatus(campaign.status)],
+            ["Recipients", String(campaign.recipientCount)],
+            ...(campaign.status === "sent" || campaign.status === "sending"
+                ? [
+                    ["Sent", String(campaign.sentCount)],
+                    ["Delivered", colors.success(String(campaign.deliveredCount))],
+                    ["Failed", campaign.failedCount > 0 ? colors.error(String(campaign.failedCount)) : "0"],
+                ]
+                : []),
+            ["Estimated Credits", String(campaign.estimatedCredits)],
+            ...(campaign.creditsUsed > 0
+                ? [["Credits Used", String(campaign.creditsUsed)]]
+                : []),
+            ...(campaign.scheduledAt
+                ? [["Scheduled For", new Date(campaign.scheduledAt).toLocaleString()]]
+                : []),
+            ...(campaign.timezone
+                ? [["Timezone", campaign.timezone]]
+                : []),
+            ["Created", new Date(campaign.createdAt).toLocaleString()],
+            ...(campaign.startedAt
+                ? [["Started", new Date(campaign.startedAt).toLocaleString()]]
+                : []),
+            ...(campaign.completedAt
+                ? [["Completed", new Date(campaign.completedAt).toLocaleString()]]
+                : []),
+        ]);
+        console.log();
+        console.log(colors.dim("Message:"));
+        console.log(`  ${campaign.text}`);
+        if (campaign.contactListIds.length > 0) {
+            console.log();
+            console.log(colors.dim("Contact Lists:"));
+            campaign.contactListIds.forEach((id) => {
+                console.log(`  - ${id}`);
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"get.js","sourceRoot":"","sources":["../../../src/commands/campaigns/get.ts"],"names":[],"mappings":"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","sourcesContent":["import { Args } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport { json, colors, isJsonMode, keyValue } from \"../../lib/output.js\";\n\ninterface Campaign {\n  id: string;\n  name: string;\n  text: string;\n  templateId?: string;\n  contactListIds: string[];\n  status: string;\n  recipientCount: number;\n  sentCount: number;\n  deliveredCount: number;\n  failedCount: number;\n  estimatedCredits: number;\n  creditsUsed: number;\n  scheduledAt?: string;\n  timezone?: string;\n  startedAt?: string;\n  completedAt?: string;\n  createdAt: string;\n  updatedAt: string;\n}\n\nfunction formatStatus(status: string): string {\n  switch (status) {\n    case \"draft\":\n      return colors.dim(\"Draft\");\n    case \"scheduled\":\n      return colors.warning(\"Scheduled\");\n    case \"sending\":\n      return colors.info(\"Sending\");\n    case \"sent\":\n      return colors.success(\"Sent\");\n    case \"paused\":\n      return colors.warning(\"Paused\");\n    case \"cancelled\":\n      return colors.dim(\"Cancelled\");\n    case \"failed\":\n      return colors.error(\"Failed\");\n    default:\n      return status;\n  }\n}\n\nexport default class CampaignsGet extends AuthenticatedCommand {\n  static description = \"Get campaign details\";\n\n  static examples = [\n    \"<%= config.bin %> campaigns get cmp_xxx\",\n    \"<%= config.bin %> campaigns get cmp_xxx --json\",\n  ];\n\n  static args = {\n    id: Args.string({\n      description: \"Campaign ID\",\n      required: true,\n    }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n  };\n\n  async run(): Promise<void> {\n    const { args } = await this.parse(CampaignsGet);\n\n    const campaign = await apiClient.get<Campaign>(\n      `/api/v1/campaigns/${args.id}`,\n    );\n\n    if (isJsonMode()) {\n      json(campaign);\n      return;\n    }\n\n    console.log();\n    console.log(colors.bold(`Campaign: ${campaign.name}`));\n    console.log();\n\n    keyValue([\n      [\"ID\", campaign.id],\n      [\"Status\", formatStatus(campaign.status)],\n      [\"Recipients\", String(campaign.recipientCount)],\n      ...(campaign.status === \"sent\" || campaign.status === \"sending\"\n        ? [\n            [\"Sent\", String(campaign.sentCount)] as [string, string],\n            [\"Delivered\", colors.success(String(campaign.deliveredCount))] as [string, string],\n            [\"Failed\", campaign.failedCount > 0 ? colors.error(String(campaign.failedCount)) : \"0\"] as [string, string],\n          ]\n        : []),\n      [\"Estimated Credits\", String(campaign.estimatedCredits)],\n      ...(campaign.creditsUsed > 0\n        ? [[\"Credits Used\", String(campaign.creditsUsed)] as [string, string]]\n        : []),\n      ...(campaign.scheduledAt\n        ? [[\"Scheduled For\", new Date(campaign.scheduledAt).toLocaleString()] as [string, string]]\n        : []),\n      ...(campaign.timezone\n        ? [[\"Timezone\", campaign.timezone] as [string, string]]\n        : []),\n      [\"Created\", new Date(campaign.createdAt).toLocaleString()],\n      ...(campaign.startedAt\n        ? [[\"Started\", new Date(campaign.startedAt).toLocaleString()] as [string, string]]\n        : []),\n      ...(campaign.completedAt\n        ? [[\"Completed\", new Date(campaign.completedAt).toLocaleString()] as [string, string]]\n        : []),\n    ]);\n\n    console.log();\n    console.log(colors.dim(\"Message:\"));\n    console.log(`  ${campaign.text}`);\n\n    if (campaign.contactListIds.length > 0) {\n      console.log();\n      console.log(colors.dim(\"Contact Lists:\"));\n      campaign.contactListIds.forEach((id) => {\n        console.log(`  - ${id}`);\n      });\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class CampaignsList 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>;
+        offset: 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/campaigns/list.js

@@ -0,0 +1,116 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { table, json, info, formatRelativeTime, colors, isJsonMode, } from "../../lib/output.js";
+function formatCampaignStatus(status) {
+    switch (status) {
+        case "draft":
+            return colors.dim("draft");
+        case "scheduled":
+            return colors.warning("scheduled");
+        case "sending":
+            return colors.info("sending");
+        case "sent":
+            return colors.success("sent");
+        case "paused":
+            return colors.warning("paused");
+        case "cancelled":
+            return colors.dim("cancelled");
+        case "failed":
+            return colors.error("failed");
+        default:
+            return status;
+    }
+}
+export default class CampaignsList extends AuthenticatedCommand {
+    static description = "List campaigns";
+    static examples = [
+        "<%= config.bin %> campaigns list",
+        "<%= config.bin %> campaigns list --status draft",
+        "<%= config.bin %> campaigns list --limit 10",
+        "<%= config.bin %> campaigns list --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        limit: Flags.integer({
+            char: "l",
+            description: "Number of campaigns to show",
+            default: 20,
+        }),
+        offset: Flags.integer({
+            description: "Offset for pagination",
+            default: 0,
+        }),
+        status: Flags.string({
+            char: "s",
+            description: "Filter by status (draft, scheduled, sending, sent, cancelled)",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(CampaignsList);
+        const response = await apiClient.get("/api/v1/campaigns", {
+            limit: flags.limit,
+            offset: flags.offset,
+            ...(flags.status && { status: flags.status }),
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (response.campaigns.length === 0) {
+            info("No campaigns found");
+            return;
+        }
+        console.log();
+        console.log(colors.dim(`Showing ${response.campaigns.length} of ${response.total} campaigns`));
+        console.log();
+        table(response.campaigns, [
+            {
+                header: "ID",
+                key: "id",
+                width: 18,
+                formatter: (v) => colors.dim(String(v).slice(0, 15) + "..."),
+            },
+            {
+                header: "Name",
+                key: "name",
+                width: 20,
+                formatter: (v) => {
+                    const name = String(v);
+                    return name.length > 18 ? name.slice(0, 18) + "..." : name;
+                },
+            },
+            {
+                header: "Status",
+                key: "status",
+                width: 11,
+                formatter: (v) => formatCampaignStatus(String(v)),
+            },
+            {
+                header: "Recipients",
+                key: "recipientCount",
+                width: 11,
+                formatter: (v) => String(v),
+            },
+            {
+                header: "Delivered",
+                key: "deliveredCount",
+                width: 10,
+                formatter: (v, row) => {
+                    const campaign = row;
+                    if (campaign.status === "sent" || campaign.status === "sending") {
+                        return `${v}/${campaign.recipientCount}`;
+                    }
+                    return "-";
+                },
+            },
+            {
+                header: "Created",
+                key: "createdAt",
+                width: 12,
+                formatter: (v) => formatRelativeTime(String(v)),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.js","sourceRoot":"","sources":["../../../src/commands/campaigns/list.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  table,\n  json,\n  info,\n  formatRelativeTime,\n  colors,\n  isJsonMode,\n} from \"../../lib/output.js\";\n\ninterface Campaign {\n  id: string;\n  name: string;\n  text: string;\n  status: string;\n  recipientCount: number;\n  sentCount: number;\n  deliveredCount: number;\n  failedCount: number;\n  estimatedCredits: number;\n  scheduledAt?: string;\n  createdAt: string;\n}\n\ninterface ListCampaignsResponse {\n  campaigns: Campaign[];\n  total: number;\n  limit: number;\n  offset: number;\n}\n\nfunction formatCampaignStatus(status: string): string {\n  switch (status) {\n    case \"draft\":\n      return colors.dim(\"draft\");\n    case \"scheduled\":\n      return colors.warning(\"scheduled\");\n    case \"sending\":\n      return colors.info(\"sending\");\n    case \"sent\":\n      return colors.success(\"sent\");\n    case \"paused\":\n      return colors.warning(\"paused\");\n    case \"cancelled\":\n      return colors.dim(\"cancelled\");\n    case \"failed\":\n      return colors.error(\"failed\");\n    default:\n      return status;\n  }\n}\n\nexport default class CampaignsList extends AuthenticatedCommand {\n  static description = \"List campaigns\";\n\n  static examples = [\n    \"<%= config.bin %> campaigns list\",\n    \"<%= config.bin %> campaigns list --status draft\",\n    \"<%= config.bin %> campaigns list --limit 10\",\n    \"<%= config.bin %> campaigns list --json\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    limit: Flags.integer({\n      char: \"l\",\n      description: \"Number of campaigns to show\",\n      default: 20,\n    }),\n    offset: Flags.integer({\n      description: \"Offset for pagination\",\n      default: 0,\n    }),\n    status: Flags.string({\n      char: \"s\",\n      description: \"Filter by status (draft, scheduled, sending, sent, cancelled)\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(CampaignsList);\n\n    const response = await apiClient.get<ListCampaignsResponse>(\n      \"/api/v1/campaigns\",\n      {\n        limit: flags.limit,\n        offset: flags.offset,\n        ...(flags.status && { status: flags.status }),\n      },\n    );\n\n    if (isJsonMode()) {\n      json(response);\n      return;\n    }\n\n    if (response.campaigns.length === 0) {\n      info(\"No campaigns found\");\n      return;\n    }\n\n    console.log();\n    console.log(\n      colors.dim(`Showing ${response.campaigns.length} of ${response.total} campaigns`),\n    );\n    console.log();\n\n    table(response.campaigns, [\n      {\n        header: \"ID\",\n        key: \"id\",\n        width: 18,\n        formatter: (v) => colors.dim(String(v).slice(0, 15) + \"...\"),\n      },\n      {\n        header: \"Name\",\n        key: \"name\",\n        width: 20,\n        formatter: (v) => {\n          const name = String(v);\n          return name.length > 18 ? name.slice(0, 18) + \"...\" : name;\n        },\n      },\n      {\n        header: \"Status\",\n        key: \"status\",\n        width: 11,\n        formatter: (v) => formatCampaignStatus(String(v)),\n      },\n      {\n        header: \"Recipients\",\n        key: \"recipientCount\",\n        width: 11,\n        formatter: (v) => String(v),\n      },\n      {\n        header: \"Delivered\",\n        key: \"deliveredCount\",\n        width: 10,\n        formatter: (v, row) => {\n          const campaign = row as Campaign;\n          if (campaign.status === \"sent\" || campaign.status === \"sending\") {\n            return `${v}/${campaign.recipientCount}`;\n          }\n          return \"-\";\n        },\n      },\n      {\n        header: \"Created\",\n        key: \"createdAt\",\n        width: 12,\n        formatter: (v) => formatRelativeTime(String(v)),\n      },\n    ]);\n  }\n}\n"]}

package/dist/commands/campaigns/preview.d.ts

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

@@ -0,0 +1,60 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, colors, isJsonMode, keyValue, warn } from "../../lib/output.js";
+export default class CampaignsPreview extends AuthenticatedCommand {
+    static description = "Preview campaign cost and recipients";
+    static examples = [
+        "<%= config.bin %> campaigns preview cmp_xxx",
+        "<%= config.bin %> campaigns preview cmp_xxx --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Campaign ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(CampaignsPreview);
+        const preview = await apiClient.get(`/api/v1/campaigns/${args.id}/preview`);
+        if (isJsonMode()) {
+            json(preview);
+            return;
+        }
+        console.log();
+        console.log(colors.bold("Campaign Preview"));
+        console.log();
+        keyValue([
+            ["Recipients", String(preview.recipientCount)],
+            ["Segments per message", String(preview.estimatedSegments)],
+            ["Estimated Credits", colors.bold(String(preview.estimatedCredits))],
+            ["Your Balance", String(preview.currentBalance)],
+            [
+                "Status",
+                preview.hasEnoughCredits
+                    ? colors.success("Ready to send")
+                    : colors.error("Insufficient credits"),
+            ],
+        ]);
+        if (!preview.hasEnoughCredits) {
+            console.log();
+            warn(`You need ${preview.estimatedCredits - preview.currentBalance} more credits to send this campaign.`);
+            console.log(colors.dim(`  Top up at: https://sendly.live/billing`));
+        }
+        if (preview.breakdown && preview.breakdown.length > 0) {
+            console.log();
+            console.log(colors.dim("Cost breakdown by country:"));
+            console.log();
+            for (const item of preview.breakdown) {
+                console.log(`  ${item.country.padEnd(20)} ${String(item.count).padStart(6)} recipients × ${item.creditsPerMessage} = ${colors.bold(String(item.totalCredits))} credits`);
+            }
+        }
+        console.log();
+        console.log(colors.dim("To send this campaign:"));
+        console.log(`  ${colors.code(`sendly campaigns send ${args.id}`)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,15 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class CampaignsSchedule 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: {
+        at: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        timezone: 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>;
+}