@sendly/cli 3.12.3 → 3.13.1

package/dist/commands/campaigns/preview.js

@@ -0,0 +1,71 @@
+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)],
+            ["Sendable", String(preview.sendableCount ?? preview.recipientCount)],
+            ["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.blockedCount && preview.blockedCount > 0) {
+            console.log();
+            warn(`${preview.blockedCount} of ${preview.recipientCount} recipients cannot be reached with your current verification.`);
+        }
+        if (preview.warnings && preview.warnings.length > 0) {
+            console.log();
+            for (const w of preview.warnings) {
+                warn(w);
+            }
+        }
+        if (preview.byCountry && Object.keys(preview.byCountry).length > 0) {
+            console.log();
+            console.log(colors.dim("Cost breakdown by country:"));
+            console.log();
+            for (const [country, info] of Object.entries(preview.byCountry)) {
+                const status = info.allowed ? "" : colors.dim(" (blocked)");
+                console.log(`  ${country.padEnd(6)} ${String(info.count).padStart(4)} recipients  ${colors.bold(String(info.credits))} credits${status}`);
+            }
+        }
+        console.log();
+        console.log(colors.dim("To send this campaign:"));
+        console.log(`  ${colors.code(`sendly campaigns send ${args.id}`)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preview.js","sourceRoot":"","sources":["../../../src/commands/campaigns/preview.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, warn } from \"../../lib/output.js\";\n\ninterface CampaignPreview {\n  recipientCount: number;\n  estimatedCredits: number;\n  currentBalance: number;\n  hasEnoughCredits: boolean;\n  blockedCount?: number;\n  sendableCount?: number;\n  byCountry?: Record<\n    string,\n    {\n      count: number;\n      credits: number;\n      allowed: boolean;\n      blockedReason?: string;\n    }\n  >;\n  warnings?: string[];\n}\n\nexport default class CampaignsPreview extends AuthenticatedCommand {\n  static description = \"Preview campaign cost and recipients\";\n\n  static examples = [\n    \"<%= config.bin %> campaigns preview cmp_xxx\",\n    \"<%= config.bin %> campaigns preview 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(CampaignsPreview);\n\n    const preview = await apiClient.get<CampaignPreview>(\n      `/api/v1/campaigns/${args.id}/preview`,\n    );\n\n    if (isJsonMode()) {\n      json(preview);\n      return;\n    }\n\n    console.log();\n    console.log(colors.bold(\"Campaign Preview\"));\n    console.log();\n\n    keyValue([\n      [\"Recipients\", String(preview.recipientCount)],\n      [\"Sendable\", String(preview.sendableCount ?? preview.recipientCount)],\n      [\"Estimated Credits\", colors.bold(String(preview.estimatedCredits))],\n      [\"Your Balance\", String(preview.currentBalance)],\n      [\n        \"Status\",\n        preview.hasEnoughCredits\n          ? colors.success(\"Ready to send\")\n          : colors.error(\"Insufficient credits\"),\n      ],\n    ]);\n\n    if (!preview.hasEnoughCredits) {\n      console.log();\n      warn(\n        `You need ${preview.estimatedCredits - preview.currentBalance} more credits to send this campaign.`,\n      );\n      console.log(colors.dim(`  Top up at: https://sendly.live/billing`));\n    }\n\n    if (preview.blockedCount && preview.blockedCount > 0) {\n      console.log();\n      warn(\n        `${preview.blockedCount} of ${preview.recipientCount} recipients cannot be reached with your current verification.`,\n      );\n    }\n\n    if (preview.warnings && preview.warnings.length > 0) {\n      console.log();\n      for (const w of preview.warnings) {\n        warn(w);\n      }\n    }\n\n    if (preview.byCountry && Object.keys(preview.byCountry).length > 0) {\n      console.log();\n      console.log(colors.dim(\"Cost breakdown by country:\"));\n      console.log();\n\n      for (const [country, info] of Object.entries(preview.byCountry)) {\n        const status = info.allowed ? \"\" : colors.dim(\" (blocked)\");\n        console.log(\n          `  ${country.padEnd(6)} ${String(info.count).padStart(4)} recipients  ${colors.bold(String(info.credits))} credits${status}`,\n        );\n      }\n    }\n\n    console.log();\n    console.log(colors.dim(\"To send this campaign:\"));\n    console.log(`  ${colors.code(`sendly campaigns send ${args.id}`)}`);\n  }\n}\n"]}

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

package/dist/commands/campaigns/schedule.js

@@ -0,0 +1,61 @@
+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 CampaignsSchedule extends AuthenticatedCommand {
+    static description = "Schedule a campaign for later";
+    static examples = [
+        '<%= config.bin %> campaigns schedule cmp_xxx --at "2024-01-15T10:00:00Z"',
+        '<%= config.bin %> campaigns schedule cmp_xxx --at "2024-01-15T10:00:00" --timezone "America/New_York"',
+    ];
+    static args = {
+        id: Args.string({
+            description: "Campaign ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        at: Flags.string({
+            description: "When to send (ISO 8601 datetime)",
+            required: true,
+        }),
+        timezone: Flags.string({
+            char: "z",
+            description: 'Timezone (e.g., "America/New_York")',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(CampaignsSchedule);
+        const scheduledAt = new Date(flags.at);
+        if (isNaN(scheduledAt.getTime())) {
+            this.error("Invalid date format. Use ISO 8601 format (e.g., 2024-01-15T10:00:00Z)");
+        }
+        if (scheduledAt <= new Date()) {
+            this.error("Scheduled time must be in the future");
+        }
+        const campaign = await apiClient.post(`/api/v1/campaigns/${args.id}/schedule`, {
+            scheduledAt: flags.at,
+            timezone: flags.timezone,
+        });
+        if (isJsonMode()) {
+            json(campaign);
+            return;
+        }
+        success(`Campaign scheduled!`);
+        console.log();
+        keyValue([
+            ["Campaign", campaign.name],
+            ["Status", colors.warning("scheduled")],
+            ["Recipients", String(campaign.totalRecipients)],
+            ["Scheduled For", new Date(campaign.scheduledAt).toLocaleString()],
+            ...(campaign.timezone
+                ? [["Timezone", campaign.timezone]]
+                : []),
+        ]);
+        console.log();
+        console.log(colors.dim("To cancel:"));
+        console.log(`  ${colors.code(`sendly campaigns cancel ${campaign.id}`)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

@@ -0,0 +1,96 @@
+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, 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 CampaignsSend extends AuthenticatedCommand {
+    static description = "Send a campaign immediately";
+    static examples = [
+        "<%= config.bin %> campaigns send cmp_xxx",
+        "<%= config.bin %> campaigns send 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(CampaignsSend);
+        const preview = await apiClient.get(`/api/v1/campaigns/${args.id}/preview`);
+        if (!preview.hasEnoughCredits) {
+            warn(`You need ${preview.estimatedCredits - preview.currentBalance} more credits to send this campaign.`);
+            console.log(colors.dim(`  Top up at: https://sendly.live/billing`));
+            this.exit(1);
+        }
+        if (preview.sendableCount === 0) {
+            warn("No recipients can be reached with your current verification.");
+            if (preview.warnings) {
+                for (const w of preview.warnings) {
+                    warn(w);
+                }
+            }
+            this.exit(1);
+        }
+        if (preview.blockedCount && preview.blockedCount > 0) {
+            warn(`${preview.blockedCount} of ${preview.recipientCount} recipients cannot be reached with your current verification.`);
+        }
+        if (preview.warnings && preview.warnings.length > 0) {
+            for (const w of preview.warnings) {
+                warn(w);
+            }
+        }
+        if (!flags.yes && !isJsonMode()) {
+            console.log();
+            console.log(colors.bold("Campaign Summary"));
+            console.log();
+            keyValue([
+                ["Recipients", String(preview.recipientCount)],
+                ["Credits to use", colors.bold(String(preview.estimatedCredits))],
+            ]);
+            console.log();
+            const confirmed = await confirm(colors.warning("Send this campaign now?"));
+            if (!confirmed) {
+                console.log(colors.dim("Cancelled"));
+                return;
+            }
+        }
+        const result = await apiClient.post(`/api/v1/campaigns/${args.id}/send`);
+        if (isJsonMode()) {
+            json(result);
+            return;
+        }
+        success(`Campaign sent!`);
+        console.log();
+        keyValue([
+            ["Total", String(result.total)],
+            ["Sent", colors.success(String(result.sent))],
+            ["Failed", result.failed > 0 ? colors.error(String(result.failed)) : "0"],
+            ["Credits Used", String(result.creditsUsed)],
+        ]);
+        console.log();
+        console.log(colors.dim("Check status:"));
+        console.log(`  ${colors.code(`sendly campaigns get ${args.id}`)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"send.js","sourceRoot":"","sources":["../../../src/commands/campaigns/send.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  json,\n  success,\n  colors,\n  isJsonMode,\n  keyValue,\n  warn,\n} from \"../../lib/output.js\";\nimport * as readline from \"readline\";\n\ninterface BatchResult {\n  batchId: string;\n  status: string;\n  total: number;\n  sent: number;\n  failed: number;\n  creditsUsed: number;\n}\n\ninterface CampaignPreview {\n  recipientCount: number;\n  estimatedCredits: number;\n  currentBalance: number;\n  hasEnoughCredits: boolean;\n  blockedCount?: number;\n  sendableCount?: number;\n  warnings?: string[];\n}\n\nasync function confirm(message: string): Promise<boolean> {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n\n  return new Promise((resolve) => {\n    rl.question(`${message} (y/N) `, (answer) => {\n      rl.close();\n      resolve(answer.toLowerCase() === \"y\" || answer.toLowerCase() === \"yes\");\n    });\n  });\n}\n\nexport default class CampaignsSend extends AuthenticatedCommand {\n  static description = \"Send a campaign immediately\";\n\n  static examples = [\n    \"<%= config.bin %> campaigns send cmp_xxx\",\n    \"<%= config.bin %> campaigns send cmp_xxx --yes\",\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    yes: Flags.boolean({\n      char: \"y\",\n      description: \"Skip confirmation prompt\",\n      default: false,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { args, flags } = await this.parse(CampaignsSend);\n\n    const preview = await apiClient.get<CampaignPreview>(\n      `/api/v1/campaigns/${args.id}/preview`,\n    );\n\n    if (!preview.hasEnoughCredits) {\n      warn(\n        `You need ${preview.estimatedCredits - preview.currentBalance} more credits to send this campaign.`,\n      );\n      console.log(colors.dim(`  Top up at: https://sendly.live/billing`));\n      this.exit(1);\n    }\n\n    if (preview.sendableCount === 0) {\n      warn(\"No recipients can be reached with your current verification.\");\n      if (preview.warnings) {\n        for (const w of preview.warnings) {\n          warn(w);\n        }\n      }\n      this.exit(1);\n    }\n\n    if (preview.blockedCount && preview.blockedCount > 0) {\n      warn(\n        `${preview.blockedCount} of ${preview.recipientCount} recipients cannot be reached with your current verification.`,\n      );\n    }\n\n    if (preview.warnings && preview.warnings.length > 0) {\n      for (const w of preview.warnings) {\n        warn(w);\n      }\n    }\n\n    if (!flags.yes && !isJsonMode()) {\n      console.log();\n      console.log(colors.bold(\"Campaign Summary\"));\n      console.log();\n      keyValue([\n        [\"Recipients\", String(preview.recipientCount)],\n        [\"Credits to use\", colors.bold(String(preview.estimatedCredits))],\n      ]);\n      console.log();\n\n      const confirmed = await confirm(\n        colors.warning(\"Send this campaign now?\"),\n      );\n      if (!confirmed) {\n        console.log(colors.dim(\"Cancelled\"));\n        return;\n      }\n    }\n\n    const result = await apiClient.post<BatchResult>(\n      `/api/v1/campaigns/${args.id}/send`,\n    );\n\n    if (isJsonMode()) {\n      json(result);\n      return;\n    }\n\n    success(`Campaign sent!`);\n    console.log();\n\n    keyValue([\n      [\"Total\", String(result.total)],\n      [\"Sent\", colors.success(String(result.sent))],\n      [\"Failed\", result.failed > 0 ? colors.error(String(result.failed)) : \"0\"],\n      [\"Credits Used\", String(result.creditsUsed)],\n    ]);\n\n    console.log();\n    console.log(colors.dim(\"Check status:\"));\n    console.log(`  ${colors.code(`sendly campaigns get ${args.id}`)}`);\n  }\n}\n"]}

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

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

@@ -0,0 +1,66 @@
+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 CampaignsUpdate extends AuthenticatedCommand {
+    static description = "Update a campaign";
+    static examples = [
+        '<%= config.bin %> campaigns update cmp_xxx --name "New Name"',
+        '<%= config.bin %> campaigns update cmp_xxx --text "Updated message"',
+        "<%= config.bin %> campaigns update cmp_xxx --list lst_xxx",
+        '<%= config.bin %> campaigns update cmp_xxx --name "Sale" --text "50% off!"',
+    ];
+    static args = {
+        id: Args.string({
+            description: "Campaign ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "Campaign name",
+        }),
+        text: Flags.string({
+            char: "t",
+            description: "Message text (supports {{variables}})",
+        }),
+        list: Flags.string({
+            char: "l",
+            description: "Contact list ID",
+        }),
+        template: Flags.string({
+            description: "Template ID",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(CampaignsUpdate);
+        if (!flags.name && !flags.text && !flags.list && !flags.template) {
+            this.error("At least one of --name, --text, --list, or --template is required");
+        }
+        const body = {};
+        if (flags.name !== undefined)
+            body.name = flags.name;
+        if (flags.text !== undefined)
+            body.messageText = flags.text;
+        if (flags.list !== undefined)
+            body.targetListId = flags.list;
+        if (flags.template !== undefined)
+            body.templateId = flags.template;
+        const campaign = await apiClient.patch(`/api/v1/campaigns/${args.id}`, body);
+        if (isJsonMode()) {
+            json(campaign);
+            return;
+        }
+        success(`Campaign updated: ${campaign.id}`);
+        console.log();
+        keyValue([
+            ["Name", campaign.name],
+            ["Status", colors.dim(campaign.status)],
+            ["Message", campaign.messageText],
+            ["Recipients", String(campaign.totalRecipients)],
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbW1hbmRzL2NhbXBhaWducy91cGRhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDMUMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDakUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3BELE9BQU8sRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFhbEYsTUFBTSxDQUFDLE9BQU8sT0FBTyxlQUFnQixTQUFRLG9CQUFvQjtJQUMvRCxNQUFNLENBQUMsV0FBVyxHQUFHLG1CQUFtQixDQUFDO0lBRXpDLE1BQU0sQ0FBQyxRQUFRLEdBQUc7UUFDaEIsOERBQThEO1FBQzlELHFFQUFxRTtRQUNyRSwyREFBMkQ7UUFDM0QsNEVBQTRFO0tBQzdFLENBQUM7SUFFRixNQUFNLENBQUMsSUFBSSxHQUFHO1FBQ1osRUFBRSxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUM7WUFDZCxXQUFXLEVBQUUsYUFBYTtZQUMxQixRQUFRLEVBQUUsSUFBSTtTQUNmLENBQUM7S0FDSCxDQUFDO0lBRUYsTUFBTSxDQUFDLEtBQUssR0FBRztRQUNiLEdBQUcsb0JBQW9CLENBQUMsU0FBUztRQUNqQyxJQUFJLEVBQUUsS0FBSyxDQUFDLE1BQU0sQ0FBQztZQUNqQixJQUFJLEVBQUUsR0FBRztZQUNULFdBQVcsRUFBRSxlQUFlO1NBQzdCLENBQUM7UUFDRixJQUFJLEVBQUUsS0FBSyxDQUFDLE1BQU0sQ0FBQztZQUNqQixJQUFJLEVBQUUsR0FBRztZQUNULFdBQVcsRUFBRSx1Q0FBdUM7U0FDckQsQ0FBQztRQUNGLElBQUksRUFBRSxLQUFLLENBQUMsTUFBTSxDQUFDO1lBQ2pCLElBQUksRUFBRSxHQUFHO1lBQ1QsV0FBVyxFQUFFLGlCQUFpQjtTQUMvQixDQUFDO1FBQ0YsUUFBUSxFQUFFLEtBQUssQ0FBQyxNQUFNLENBQUM7WUFDckIsV0FBVyxFQUFFLGFBQWE7U0FDM0IsQ0FBQztLQUNILENBQUM7SUFFRixLQUFLLENBQUMsR0FBRztRQUNQLE1BQU0sRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLEdBQUcsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBRTFELElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDakUsSUFBSSxDQUFDLEtBQUssQ0FDUixtRUFBbUUsQ0FDcEUsQ0FBQztRQUNKLENBQUM7UUFFRCxNQUFNLElBQUksR0FBNEIsRUFBRSxDQUFDO1FBQ3pDLElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxTQUFTO1lBQUUsSUFBSSxDQUFDLElBQUksR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDO1FBQ3JELElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxTQUFTO1lBQUUsSUFBSSxDQUFDLFdBQVcsR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDO1FBQzVELElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxTQUFTO1lBQUUsSUFBSSxDQUFDLFlBQVksR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDO1FBQzdELElBQUksS0FBSyxDQUFDLFFBQVEsS0FBSyxTQUFTO1lBQUUsSUFBSSxDQUFDLFVBQVUsR0FBRyxLQUFLLENBQUMsUUFBUSxDQUFDO1FBRW5FLE1BQU0sUUFBUSxHQUFHLE1BQU0sU0FBUyxDQUFDLEtBQUssQ0FDcEMscUJBQXFCLElBQUksQ0FBQyxFQUFFLEVBQUUsRUFDOUIsSUFBSSxDQUNMLENBQUM7UUFFRixJQUFJLFVBQVUsRUFBRSxFQUFFLENBQUM7WUFDakIsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQ2YsT0FBTztRQUNULENBQUM7UUFFRCxPQUFPLENBQUMscUJBQXFCLFFBQVEsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQzVDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUVkLFFBQVEsQ0FBQztZQUNQLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxJQUFJLENBQUM7WUFDdkIsQ0FBQyxRQUFRLEVBQUUsTUFBTSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDdkMsQ0FBQyxTQUFTLEVBQUUsUUFBUSxDQUFDLFdBQVcsQ0FBQztZQUNqQyxDQUFDLFlBQVksRUFBRSxNQUFNLENBQUMsUUFBUSxDQUFDLGVBQWUsQ0FBQyxDQUFDO1NBQ2pELENBQUMsQ0FBQztJQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBcmdzLCBGbGFncyB9IGZyb20gXCJAb2NsaWYvY29yZVwiO1xuaW1wb3J0IHsgQXV0aGVudGljYXRlZENvbW1hbmQgfSBmcm9tIFwiLi4vLi4vbGliL2Jhc2UtY29tbWFuZC5qc1wiO1xuaW1wb3J0IHsgYXBpQ2xpZW50IH0gZnJvbSBcIi4uLy4uL2xpYi9hcGktY2xpZW50LmpzXCI7XG5pbXBvcnQgeyBqc29uLCBzdWNjZXNzLCBjb2xvcnMsIGlzSnNvbk1vZGUsIGtleVZhbHVlIH0gZnJvbSBcIi4uLy4uL2xpYi9vdXRwdXQuanNcIjtcblxuaW50ZXJmYWNlIENhbXBhaWduIHtcbiAgaWQ6IHN0cmluZztcbiAgbmFtZTogc3RyaW5nO1xuICBtZXNzYWdlVGV4dDogc3RyaW5nO1xuICBzdGF0dXM6IHN0cmluZztcbiAgdGFyZ2V0TGlzdElkPzogc3RyaW5nO1xuICB0b3RhbFJlY2lwaWVudHM6IG51bWJlcjtcbiAgZXN0aW1hdGVkQ3JlZGl0czogbnVtYmVyO1xuICB1cGRhdGVkQXQ6IHN0cmluZztcbn1cblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQ2FtcGFpZ25zVXBkYXRlIGV4dGVuZHMgQXV0aGVudGljYXRlZENvbW1hbmQge1xuICBzdGF0aWMgZGVzY3JpcHRpb24gPSBcIlVwZGF0ZSBhIGNhbXBhaWduXCI7XG5cbiAgc3RhdGljIGV4YW1wbGVzID0gW1xuICAgICc8JT0gY29uZmlnLmJpbiAlPiBjYW1wYWlnbnMgdXBkYXRlIGNtcF94eHggLS1uYW1lIFwiTmV3IE5hbWVcIicsXG4gICAgJzwlPSBjb25maWcuYmluICU+IGNhbXBhaWducyB1cGRhdGUgY21wX3h4eCAtLXRleHQgXCJVcGRhdGVkIG1lc3NhZ2VcIicsXG4gICAgXCI8JT0gY29uZmlnLmJpbiAlPiBjYW1wYWlnbnMgdXBkYXRlIGNtcF94eHggLS1saXN0IGxzdF94eHhcIixcbiAgICAnPCU9IGNvbmZpZy5iaW4gJT4gY2FtcGFpZ25zIHVwZGF0ZSBjbXBfeHh4IC0tbmFtZSBcIlNhbGVcIiAtLXRleHQgXCI1MCUgb2ZmIVwiJyxcbiAgXTtcblxuICBzdGF0aWMgYXJncyA9IHtcbiAgICBpZDogQXJncy5zdHJpbmcoe1xuICAgICAgZGVzY3JpcHRpb246IFwiQ2FtcGFpZ24gSURcIixcbiAgICAgIHJlcXVpcmVkOiB0cnVlLFxuICAgIH0pLFxuICB9O1xuXG4gIHN0YXRpYyBmbGFncyA9IHtcbiAgICAuLi5BdXRoZW50aWNhdGVkQ29tbWFuZC5iYXNlRmxhZ3MsXG4gICAgbmFtZTogRmxhZ3Muc3RyaW5nKHtcbiAgICAgIGNoYXI6IFwiblwiLFxuICAgICAgZGVzY3JpcHRpb246IFwiQ2FtcGFpZ24gbmFtZVwiLFxuICAgIH0pLFxuICAgIHRleHQ6IEZsYWdzLnN0cmluZyh7XG4gICAgICBjaGFyOiBcInRcIixcbiAgICAgIGRlc2NyaXB0aW9uOiBcIk1lc3NhZ2UgdGV4dCAoc3VwcG9ydHMge3t2YXJpYWJsZXN9fSlcIixcbiAgICB9KSxcbiAgICBsaXN0OiBGbGFncy5zdHJpbmcoe1xuICAgICAgY2hhcjogXCJsXCIsXG4gICAgICBkZXNjcmlwdGlvbjogXCJDb250YWN0IGxpc3QgSURcIixcbiAgICB9KSxcbiAgICB0ZW1wbGF0ZTogRmxhZ3Muc3RyaW5nKHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcIlRlbXBsYXRlIElEXCIsXG4gICAgfSksXG4gIH07XG5cbiAgYXN5bmMgcnVuKCk6IFByb21pc2U8dm9pZD4ge1xuICAgIGNvbnN0IHsgYXJncywgZmxhZ3MgfSA9IGF3YWl0IHRoaXMucGFyc2UoQ2FtcGFpZ25zVXBkYXRlKTtcblxuICAgIGlmICghZmxhZ3MubmFtZSAmJiAhZmxhZ3MudGV4dCAmJiAhZmxhZ3MubGlzdCAmJiAhZmxhZ3MudGVtcGxhdGUpIHtcbiAgICAgIHRoaXMuZXJyb3IoXG4gICAgICAgIFwiQXQgbGVhc3Qgb25lIG9mIC0tbmFtZSwgLS10ZXh0LCAtLWxpc3QsIG9yIC0tdGVtcGxhdGUgaXMgcmVxdWlyZWRcIixcbiAgICAgICk7XG4gICAgfVxuXG4gICAgY29uc3QgYm9keTogUmVjb3JkPHN0cmluZywgdW5rbm93bj4gPSB7fTtcbiAgICBpZiAoZmxhZ3MubmFtZSAhPT0gdW5kZWZpbmVkKSBib2R5Lm5hbWUgPSBmbGFncy5uYW1lO1xuICAgIGlmIChmbGFncy50ZXh0ICE9PSB1bmRlZmluZWQpIGJvZHkubWVzc2FnZVRleHQgPSBmbGFncy50ZXh0O1xuICAgIGlmIChmbGFncy5saXN0ICE9PSB1bmRlZmluZWQpIGJvZHkudGFyZ2V0TGlzdElkID0gZmxhZ3MubGlzdDtcbiAgICBpZiAoZmxhZ3MudGVtcGxhdGUgIT09IHVuZGVmaW5lZCkgYm9keS50ZW1wbGF0ZUlkID0gZmxhZ3MudGVtcGxhdGU7XG5cbiAgICBjb25zdCBjYW1wYWlnbiA9IGF3YWl0IGFwaUNsaWVudC5wYXRjaDxDYW1wYWlnbj4oXG4gICAgICBgL2FwaS92MS9jYW1wYWlnbnMvJHthcmdzLmlkfWAsXG4gICAgICBib2R5LFxuICAgICk7XG5cbiAgICBpZiAoaXNKc29uTW9kZSgpKSB7XG4gICAgICBqc29uKGNhbXBhaWduKTtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBzdWNjZXNzKGBDYW1wYWlnbiB1cGRhdGVkOiAke2NhbXBhaWduLmlkfWApO1xuICAgIGNvbnNvbGUubG9nKCk7XG5cbiAgICBrZXlWYWx1ZShbXG4gICAgICBbXCJOYW1lXCIsIGNhbXBhaWduLm5hbWVdLFxuICAgICAgW1wiU3RhdHVzXCIsIGNvbG9ycy5kaW0oY2FtcGFpZ24uc3RhdHVzKV0sXG4gICAgICBbXCJNZXNzYWdlXCIsIGNhbXBhaWduLm1lc3NhZ2VUZXh0XSxcbiAgICAgIFtcIlJlY2lwaWVudHNcIiwgU3RyaW5nKGNhbXBhaWduLnRvdGFsUmVjaXBpZW50cyldLFxuICAgIF0pO1xuICB9XG59XG4iXX0=

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

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

@@ -0,0 +1,48 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, colors, isJsonMode } from "../../lib/output.js";
+export default class ContactsCreate extends AuthenticatedCommand {
+    static description = "Create a new contact";
+    static examples = [
+        "<%= config.bin %> contacts create --phone +15551234567",
+        '<%= config.bin %> contacts create --phone +15551234567 --name "John Doe"',
+        '<%= config.bin %> contacts create --phone +15551234567 --name "John" --email john@example.com',
+        "<%= config.bin %> contacts create --phone +15551234567 --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        phone: Flags.string({
+            char: "p",
+            description: "Phone number in E.164 format (e.g., +15551234567)",
+            required: true,
+        }),
+        name: Flags.string({
+            char: "n",
+            description: "Contact name",
+        }),
+        email: Flags.string({
+            char: "e",
+            description: "Contact email",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ContactsCreate);
+        const contact = await apiClient.post("/api/v1/contacts", {
+            phone_number: flags.phone,
+            name: flags.name,
+            email: flags.email,
+        });
+        if (isJsonMode()) {
+            json(contact);
+            return;
+        }
+        success("Contact created", {
+            ID: contact.id,
+            Phone: contact.phone_number,
+            Name: contact.name || colors.dim("(none)"),
+            Email: contact.email || colors.dim("(none)"),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

@@ -0,0 +1,52 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, json, colors, isJsonMode } from "../../lib/output.js";
+import inquirer from "inquirer";
+export default class ContactsDelete extends AuthenticatedCommand {
+    static description = "Delete a contact";
+    static examples = [
+        "<%= config.bin %> contacts delete cnt_xxx",
+        "<%= config.bin %> contacts delete cnt_xxx --yes",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Contact ID to delete",
+            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(ContactsDelete);
+        if (!flags.yes) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Are you sure you want to delete contact ${colors.code(args.id)}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                error("Deletion cancelled");
+                return;
+            }
+        }
+        await apiClient.delete(`/api/v1/contacts/${args.id}`);
+        if (isJsonMode()) {
+            json({ success: true, deletedId: args.id });
+            return;
+        }
+        success("Contact deleted", {
+            ID: args.id,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ContactsGet 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/contacts/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 { detail, json, colors, isJsonMode } from "../../lib/output.js";
+export default class ContactsGet extends AuthenticatedCommand {
+    static description = "Get contact details";
+    static examples = [
+        "<%= config.bin %> contacts get cnt_xxx",
+        "<%= config.bin %> contacts get cnt_xxx --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Contact ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(ContactsGet);
+        const contact = await apiClient.get(`/api/v1/contacts/${args.id}`);
+        if (isJsonMode()) {
+            json(contact);
+            return;
+        }
+        console.log();
+        detail("Contact Details", {
+            ID: contact.id,
+            Phone: contact.phone_number,
+            Name: contact.name || colors.dim("(none)"),
+            Email: contact.email || colors.dim("(none)"),
+            Status: contact.opted_out ? colors.error("Opted Out") : colors.success("Active"),
+            Lists: contact.lists?.length
+                ? contact.lists.map((l) => l.name).join(", ")
+                : colors.dim("(none)"),
+            Created: new Date(contact.created_at).toLocaleString(),
+            ...(contact.updated_at && {
+                Updated: new Date(contact.updated_at).toLocaleString(),
+            }),
+        });
+        if (contact.metadata && Object.keys(contact.metadata).length > 0) {
+            console.log();
+            console.log(colors.bold("Metadata:"));
+            for (const [key, value] of Object.entries(contact.metadata)) {
+                console.log(`  ${key}: ${JSON.stringify(value)}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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