@sendly/cli 3.12.3 → 3.13.1

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/clone.d.ts

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

@@ -0,0 +1,47 @@
+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, keyValue } from "../../lib/output.js";
+export default class CampaignsClone extends AuthenticatedCommand {
+    static description = "Clone an existing campaign";
+    static examples = [
+        "<%= config.bin %> campaigns clone cmp_xxx",
+        '<%= config.bin %> campaigns clone cmp_xxx --name "Copy of Sale"',
+    ];
+    static args = {
+        id: Args.string({
+            description: "Campaign ID to clone",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "Name for the cloned campaign",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(CampaignsClone);
+        const body = {};
+        if (flags.name)
+            body.name = flags.name;
+        const campaign = await apiClient.post(`/api/v1/campaigns/${args.id}/clone`, body);
+        if (isJsonMode()) {
+            json(campaign);
+            return;
+        }
+        success(`Campaign cloned: ${campaign.id}`);
+        console.log();
+        keyValue([
+            ["Name", campaign.name],
+            ["Status", colors.dim("draft")],
+            ["Message", campaign.messageText],
+        ]);
+        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}`)}`);
+    }
+}
+//# 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,64 @@
+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,
+            messageText: flags.text,
+            templateId: flags.template,
+            targetType: "contact_list",
+            targetListId: flags.list[0],
+        });
+        if (isJsonMode()) {
+            json(campaign);
+            return;
+        }
+        success(`Campaign created: ${campaign.id}`);
+        console.log();
+        keyValue([
+            ["Name", campaign.name],
+            ["Status", colors.dim("draft")],
+            ["Recipients", String(campaign.totalRecipients)],
+            ["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 (campaign.status === "sending") {
+            warn(`Cannot delete a campaign that is currently sending.`);
+            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,101 @@
+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 "completed":
+            return colors.success("Completed");
+        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.totalRecipients)],
+            ...(campaign.status === "completed" || 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.sentAt
+                ? [
+                    ["Started", new Date(campaign.sentAt).toLocaleString()],
+                ]
+                : []),
+            ...(campaign.completedAt
+                ? [
+                    ["Completed", new Date(campaign.completedAt).toLocaleString()],
+                ]
+                : []),
+        ]);
+        console.log();
+        console.log(colors.dim("Message:"));
+        console.log(`  ${campaign.messageText}`);
+        if (campaign.targetListId) {
+            console.log();
+            console.log(colors.dim("Contact List:"));
+            console.log(`  ${campaign.targetListId}`);
+        }
+    }
+}
+//# 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  messageText: string;\n  targetType: string;\n  targetListId?: string;\n  status: string;\n  totalRecipients: number;\n  sentCount: number;\n  deliveredCount: number;\n  failedCount: number;\n  estimatedCredits: number;\n  creditsUsed: number;\n  scheduledAt?: string;\n  timezone?: string;\n  sentAt?: 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 \"completed\":\n      return colors.success(\"Completed\");\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.totalRecipients)],\n      ...(campaign.status === \"completed\" || campaign.status === \"sending\"\n        ? [\n            [\"Sent\", String(campaign.sentCount)] as [string, string],\n            [\"Delivered\", colors.success(String(campaign.deliveredCount))] as [\n              string,\n              string,\n            ],\n            [\n              \"Failed\",\n              campaign.failedCount > 0\n                ? colors.error(String(campaign.failedCount))\n                : \"0\",\n            ] 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        ? [\n            [\n              \"Scheduled For\",\n              new Date(campaign.scheduledAt).toLocaleString(),\n            ] as [string, string],\n          ]\n        : []),\n      ...(campaign.timezone\n        ? [[\"Timezone\", campaign.timezone] as [string, string]]\n        : []),\n      [\"Created\", new Date(campaign.createdAt).toLocaleString()],\n      ...(campaign.sentAt\n        ? [\n            [\"Started\", new Date(campaign.sentAt).toLocaleString()] as [\n              string,\n              string,\n            ],\n          ]\n        : []),\n      ...(campaign.completedAt\n        ? [\n            [\"Completed\", new Date(campaign.completedAt).toLocaleString()] as [\n              string,\n              string,\n            ],\n          ]\n        : []),\n    ]);\n\n    console.log();\n    console.log(colors.dim(\"Message:\"));\n    console.log(`  ${campaign.messageText}`);\n\n    if (campaign.targetListId) {\n      console.log();\n      console.log(colors.dim(\"Contact List:\"));\n      console.log(`  ${campaign.targetListId}`);\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,115 @@
+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 "completed":
+            return colors.success("completed");
+        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: "totalRecipients",
+                width: 11,
+                formatter: (v) => String(v),
+            },
+            {
+                header: "Delivered",
+                key: "deliveredCount",
+                width: 10,
+                formatter: (v, row) => {
+                    const campaign = row;
+                    if (campaign.status === "completed" ||
+                        campaign.status === "sending") {
+                        return `${v}/${campaign.totalRecipients}`;
+                    }
+                    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  messageText: string;\n  status: string;\n  totalRecipients: 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 \"completed\":\n      return colors.success(\"completed\");\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:\n        \"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(\n        `Showing ${response.campaigns.length} of ${response.total} campaigns`,\n      ),\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: \"totalRecipients\",\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 (\n            campaign.status === \"completed\" ||\n            campaign.status === \"sending\"\n          ) {\n            return `${v}/${campaign.totalRecipients}`;\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>;
+}