@sendly/cli 3.12.3 → 3.13.0

package/dist/commands/campaigns/schedule.js

@@ -0,0 +1,59 @@
+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.recipientCount)],
+            ["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,78 @@
+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 (!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 campaign = await apiClient.post(`/api/v1/campaigns/${args.id}/send`);
+        if (isJsonMode()) {
+            json(campaign);
+            return;
+        }
+        success(`Campaign is now sending!`);
+        console.log();
+        keyValue([
+            ["Campaign", campaign.name],
+            ["Status", colors.info("sending")],
+            ["Recipients", String(campaign.recipientCount)],
+        ]);
+        console.log();
+        console.log(colors.dim("Check status:"));
+        console.log(`  ${colors.code(`sendly campaigns get ${campaign.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 { json, success, colors, isJsonMode, keyValue, warn } from \"../../lib/output.js\";\nimport * as readline from \"readline\";\n\ninterface Campaign {\n  id: string;\n  name: string;\n  status: string;\n  recipientCount: number;\n  estimatedCredits: number;\n}\n\ninterface CampaignPreview {\n  recipientCount: number;\n  estimatedCredits: number;\n  currentBalance: number;\n  hasEnoughCredits: boolean;\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 (!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 campaign = await apiClient.post<Campaign>(\n      `/api/v1/campaigns/${args.id}/send`,\n    );\n\n    if (isJsonMode()) {\n      json(campaign);\n      return;\n    }\n\n    success(`Campaign is now sending!`);\n    console.log();\n\n    keyValue([\n      [\"Campaign\", campaign.name],\n      [\"Status\", colors.info(\"sending\")],\n      [\"Recipients\", String(campaign.recipientCount)],\n    ]);\n\n    console.log();\n    console.log(colors.dim(\"Check status:\"));\n    console.log(`  ${colors.code(`sendly campaigns get ${campaign.id}`)}`);\n  }\n}\n"]}

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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

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

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

@@ -0,0 +1,101 @@
+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";
+export default class ContactsList extends AuthenticatedCommand {
+    static description = "List contacts";
+    static examples = [
+        "<%= config.bin %> contacts list",
+        "<%= config.bin %> contacts list --search john",
+        "<%= config.bin %> contacts list --list lst_xxx",
+        "<%= config.bin %> contacts list --limit 50",
+        "<%= config.bin %> contacts list --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        limit: Flags.integer({
+            char: "l",
+            description: "Number of contacts to show",
+            default: 50,
+        }),
+        offset: Flags.integer({
+            description: "Offset for pagination",
+            default: 0,
+        }),
+        search: Flags.string({
+            char: "s",
+            description: "Search by name, phone, or email",
+        }),
+        list: Flags.string({
+            description: "Filter by contact list ID",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ContactsList);
+        const response = await apiClient.get("/api/v1/contacts", {
+            limit: flags.limit,
+            offset: flags.offset,
+            ...(flags.search && { search: flags.search }),
+            ...(flags.list && { list_id: flags.list }),
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (response.contacts.length === 0) {
+            info("No contacts found");
+            return;
+        }
+        console.log();
+        console.log(colors.dim(`Showing ${response.contacts.length} of ${response.total} contacts`));
+        console.log();
+        table(response.contacts, [
+            {
+                header: "ID",
+                key: "id",
+                width: 18,
+                formatter: (v) => colors.dim(String(v).slice(0, 15) + "..."),
+            },
+            {
+                header: "Phone",
+                key: "phone_number",
+                width: 16,
+            },
+            {
+                header: "Name",
+                key: "name",
+                width: 20,
+                formatter: (v) => {
+                    if (!v)
+                        return colors.dim("-");
+                    const name = String(v);
+                    return name.length > 18 ? name.slice(0, 18) + "..." : name;
+                },
+            },
+            {
+                header: "Email",
+                key: "email",
+                width: 24,
+                formatter: (v) => {
+                    if (!v)
+                        return colors.dim("-");
+                    const email = String(v);
+                    return email.length > 22 ? email.slice(0, 22) + "..." : email;
+                },
+            },
+            {
+                header: "Status",
+                key: "opted_out",
+                width: 10,
+                formatter: (v) => v ? colors.error("opted-out") : colors.success("active"),
+            },
+            {
+                header: "Created",
+                key: "created_at",
+                width: 12,
+                formatter: (v) => formatRelativeTime(String(v)),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.js","sourceRoot":"","sources":["../../../src/commands/contacts/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 Contact {\n  id: string;\n  phone_number: string;\n  name?: string;\n  email?: string;\n  opted_out?: boolean;\n  created_at: string;\n}\n\ninterface ListContactsResponse {\n  contacts: Contact[];\n  total: number;\n  limit: number;\n  offset: number;\n}\n\nexport default class ContactsList extends AuthenticatedCommand {\n  static description = \"List contacts\";\n\n  static examples = [\n    \"<%= config.bin %> contacts list\",\n    \"<%= config.bin %> contacts list --search john\",\n    \"<%= config.bin %> contacts list --list lst_xxx\",\n    \"<%= config.bin %> contacts list --limit 50\",\n    \"<%= config.bin %> contacts list --json\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    limit: Flags.integer({\n      char: \"l\",\n      description: \"Number of contacts to show\",\n      default: 50,\n    }),\n    offset: Flags.integer({\n      description: \"Offset for pagination\",\n      default: 0,\n    }),\n    search: Flags.string({\n      char: \"s\",\n      description: \"Search by name, phone, or email\",\n    }),\n    list: Flags.string({\n      description: \"Filter by contact list ID\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(ContactsList);\n\n    const response = await apiClient.get<ListContactsResponse>(\n      \"/api/v1/contacts\",\n      {\n        limit: flags.limit,\n        offset: flags.offset,\n        ...(flags.search && { search: flags.search }),\n        ...(flags.list && { list_id: flags.list }),\n      },\n    );\n\n    if (isJsonMode()) {\n      json(response);\n      return;\n    }\n\n    if (response.contacts.length === 0) {\n      info(\"No contacts found\");\n      return;\n    }\n\n    console.log();\n    console.log(\n      colors.dim(`Showing ${response.contacts.length} of ${response.total} contacts`),\n    );\n    console.log();\n\n    table(response.contacts, [\n      {\n        header: \"ID\",\n        key: \"id\",\n        width: 18,\n        formatter: (v) => colors.dim(String(v).slice(0, 15) + \"...\"),\n      },\n      {\n        header: \"Phone\",\n        key: \"phone_number\",\n        width: 16,\n      },\n      {\n        header: \"Name\",\n        key: \"name\",\n        width: 20,\n        formatter: (v) => {\n          if (!v) return colors.dim(\"-\");\n          const name = String(v);\n          return name.length > 18 ? name.slice(0, 18) + \"...\" : name;\n        },\n      },\n      {\n        header: \"Email\",\n        key: \"email\",\n        width: 24,\n        formatter: (v) => {\n          if (!v) return colors.dim(\"-\");\n          const email = String(v);\n          return email.length > 22 ? email.slice(0, 22) + \"...\" : email;\n        },\n      },\n      {\n        header: \"Status\",\n        key: \"opted_out\",\n        width: 10,\n        formatter: (v) => v ? colors.error(\"opted-out\") : colors.success(\"active\"),\n      },\n      {\n        header: \"Created\",\n        key: \"created_at\",\n        width: 12,\n        formatter: (v) => formatRelativeTime(String(v)),\n      },\n    ]);\n  }\n}\n"]}

package/dist/commands/contacts/lists/add.d.ts

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class ContactsListsAdd extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        listId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        contacts: 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/contacts/lists/add.js

@@ -0,0 +1,40 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, json, isJsonMode } from "../../../lib/output.js";
+export default class ContactsListsAdd extends AuthenticatedCommand {
+    static description = "Add contacts to a list";
+    static examples = [
+        "<%= config.bin %> contacts lists add lst_xxx --contacts cnt_abc,cnt_def",
+        "<%= config.bin %> contacts lists add lst_xxx --contacts cnt_abc --contacts cnt_def",
+    ];
+    static args = {
+        listId: Args.string({
+            description: "Contact list ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        contacts: Flags.string({
+            char: "c",
+            description: "Contact IDs to add (comma-separated or multiple flags)",
+            required: true,
+            multiple: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ContactsListsAdd);
+        const contactIds = flags.contacts.flatMap((c) => c.split(",").map((id) => id.trim()));
+        const response = await apiClient.post(`/api/v1/contact-lists/${args.listId}/contacts`, { contact_ids: contactIds });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success("Contacts added to list", {
+            "List ID": args.listId,
+            "Added Count": response.added_count,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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