@sendly/cli 3.13.0 → 3.13.1

package/dist/commands/campaigns/send.js

@@ -1,7 +1,7 @@
 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 { json, success, colors, isJsonMode, keyValue, warn, } from "../../lib/output.js";
 import * as readline from "readline";
 async function confirm(message) {
     const rl = readline.createInterface({
@@ -43,6 +43,23 @@ export default class CampaignsSend extends AuthenticatedCommand {
             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"));
@@ -58,21 +75,22 @@ export default class CampaignsSend extends AuthenticatedCommand {
                 return;
             }
         }
-        const campaign = await apiClient.post(`/api/v1/campaigns/${args.id}/send`);
+        const result = await apiClient.post(`/api/v1/campaigns/${args.id}/send`);
         if (isJsonMode()) {
-            json(campaign);
+            json(result);
             return;
         }
-        success(`Campaign is now sending!`);
+        success(`Campaign sent!`);
         console.log();
         keyValue([
-            ["Campaign", campaign.name],
-            ["Status", colors.info("sending")],
-            ["Recipients", String(campaign.recipientCount)],
+            ["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 ${campaign.id}`)}`);
+        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 { 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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"send.js","sourceRoot":"","sources":["../../../src/commands/campaigns/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EACL,IAAI,EACJ,OAAO,EACP,MAAM,EACN,UAAU,EACV,QAAQ,EACR,IAAI,GACL,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAqBrC,KAAK,UAAU,OAAO,CAAC,OAAe;IACpC,MAAM,EAAE,GAAG,QAAQ,CAAC,eAAe,CAAC;QAClC,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,MAAM,EAAE,OAAO,CAAC,MAAM;KACvB,CAAC,CAAC;IAEH,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,EAAE,CAAC,QAAQ,CAAC,GAAG,OAAO,SAAS,EAAE,CAAC,MAAM,EAAE,EAAE;YAC1C,EAAE,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,KAAK,GAAG,IAAI,MAAM,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC,CAAC;QAC1E,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,oBAAoB;IAC7D,MAAM,CAAC,WAAW,GAAG,6BAA6B,CAAC;IAEnD,MAAM,CAAC,QAAQ,GAAG;QAChB,0CAA0C;QAC1C,gDAAgD;KACjD,CAAC;IAEF,MAAM,CAAC,IAAI,GAAG;QACZ,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC;YACd,WAAW,EAAE,aAAa;YAC1B,QAAQ,EAAE,IAAI;SACf,CAAC;KACH,CAAC;IAEF,MAAM,CAAC,KAAK,GAAG;QACb,GAAG,oBAAoB,CAAC,SAAS;QACjC,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC;YACjB,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,0BAA0B;YACvC,OAAO,EAAE,KAAK;SACf,CAAC;KACH,CAAC;IAEF,KAAK,CAAC,GAAG;QACP,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;QAExD,MAAM,OAAO,GAAG,MAAM,SAAS,CAAC,GAAG,CACjC,qBAAqB,IAAI,CAAC,EAAE,UAAU,CACvC,CAAC;QAEF,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC;YAC9B,IAAI,CACF,YAAY,OAAO,CAAC,gBAAgB,GAAG,OAAO,CAAC,cAAc,sCAAsC,CACpG,CAAC;YACF,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,0CAA0C,CAAC,CAAC,CAAC;YACpE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QAED,IAAI,OAAO,CAAC,aAAa,KAAK,CAAC,EAAE,CAAC;YAChC,IAAI,CAAC,8DAA8D,CAAC,CAAC;YACrE,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;gBACrB,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;oBACjC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACV,CAAC;YACH,CAAC;YACD,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QAED,IAAI,OAAO,CAAC,YAAY,IAAI,OAAO,CAAC,YAAY,GAAG,CAAC,EAAE,CAAC;YACrD,IAAI,CACF,GAAG,OAAO,CAAC,YAAY,OAAO,OAAO,CAAC,cAAc,+DAA+D,CACpH,CAAC;QACJ,CAAC;QAED,IAAI,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpD,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;gBACjC,IAAI,CAAC,CAAC,CAAC,CAAC;YACV,CAAC;QACH,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;YAChC,OAAO,CAAC,GAAG,EAAE,CAAC;YACd,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC;YAC7C,OAAO,CAAC,GAAG,EAAE,CAAC;YACd,QAAQ,CAAC;gBACP,CAAC,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;gBAC9C,CAAC,gBAAgB,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC;aAClE,CAAC,CAAC;YACH,OAAO,CAAC,GAAG,EAAE,CAAC;YAEd,MAAM,SAAS,GAAG,MAAM,OAAO,CAC7B,MAAM,CAAC,OAAO,CAAC,yBAAyB,CAAC,CAC1C,CAAC;YACF,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC;gBACrC,OAAO;YACT,CAAC;QACH,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,IAAI,CACjC,qBAAqB,IAAI,CAAC,EAAE,OAAO,CACpC,CAAC;QAEF,IAAI,UAAU,EAAE,EAAE,CAAC;YACjB,IAAI,CAAC,MAAM,CAAC,CAAC;YACb,OAAO;QACT,CAAC;QAED,OAAO,CAAC,gBAAgB,CAAC,CAAC;QAC1B,OAAO,CAAC,GAAG,EAAE,CAAC;QAEd,QAAQ,CAAC;YACP,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC/B,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;YAC7C,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;YACzE,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;SAC7C,CAAC,CAAC;QAEH,OAAO,CAAC,GAAG,EAAE,CAAC;QACd,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC;QACzC,OAAO,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,IAAI,CAAC,wBAAwB,IAAI,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;IACrE,CAAC","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,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

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

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

@@ -0,0 +1,132 @@
+import { Args, Flags } from "@oclif/core";
+import { readFileSync } from "node:fs";
+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";
+function normalizePhone(raw) {
+    let phone = raw.replace(/[\s\-\(\)\.\+]/g, "");
+    if (/^\d{10}$/.test(phone)) {
+        phone = "1" + phone;
+    }
+    if (/^\d{11}$/.test(phone) && phone.startsWith("1")) {
+        return "+" + phone;
+    }
+    if (/^\d{7,15}$/.test(phone)) {
+        return "+" + phone;
+    }
+    if (raw.startsWith("+")) {
+        return "+" + phone;
+    }
+    return raw.trim();
+}
+function parseCsv(content) {
+    const lines = content.split(/\r?\n/).filter((l) => l.trim());
+    if (lines.length < 2)
+        return [];
+    const headers = lines[0].split(",").map((h) => h.trim().toLowerCase());
+    const rows = [];
+    for (let i = 1; i < lines.length; i++) {
+        const values = lines[i].split(",").map((v) => v.trim());
+        const row = {};
+        for (let j = 0; j < headers.length; j++) {
+            row[headers[j]] = values[j] || "";
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+function detectPhoneColumn(headers) {
+    const candidates = [
+        "phone",
+        "phonenumber",
+        "phone_number",
+        "to",
+        "number",
+        "mobile",
+        "cell",
+    ];
+    for (const h of headers) {
+        if (candidates.includes(h.toLowerCase()))
+            return h;
+    }
+    return null;
+}
+export default class ContactsImport extends AuthenticatedCommand {
+    static description = "Import contacts from a CSV file";
+    static examples = [
+        "<%= config.bin %> contacts import contacts.csv",
+        "<%= config.bin %> contacts import contacts.csv --list lst_xxx",
+        "<%= config.bin %> contacts import contacts.csv --list lst_xxx --json",
+    ];
+    static args = {
+        file: Args.string({
+            description: "Path to CSV file (columns: phone, name, email)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        list: Flags.string({
+            char: "l",
+            description: "Contact list ID to add imported contacts to",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ContactsImport);
+        let content;
+        try {
+            content = readFileSync(args.file, "utf-8");
+        }
+        catch {
+            this.error(`Cannot read file: ${args.file}`);
+        }
+        const rows = parseCsv(content);
+        if (rows.length === 0) {
+            this.error("CSV file is empty or has no data rows");
+        }
+        const headers = Object.keys(rows[0]);
+        const phoneCol = detectPhoneColumn(headers);
+        if (!phoneCol) {
+            this.error(`No phone column found. Expected one of: phone, phoneNumber, to, number, mobile`);
+        }
+        const contacts = rows.map((row) => ({
+            phone: normalizePhone(row[phoneCol] || ""),
+            name: row["name"] || row["fullname"] || row["full_name"] || undefined,
+            email: row["email"] || row["e-mail"] || undefined,
+        }));
+        if (!isJsonMode()) {
+            console.log();
+            console.log(colors.dim(`Importing ${contacts.length} contacts from ${args.file}`));
+            if (flags.list) {
+                console.log(colors.dim(`Adding to list: ${flags.list}`));
+            }
+            console.log();
+        }
+        const result = await apiClient.post("/api/v1/contacts/import", {
+            contacts,
+            listId: flags.list,
+        });
+        if (isJsonMode()) {
+            json(result);
+            return;
+        }
+        success(`Import complete`);
+        console.log();
+        keyValue([
+            ["Imported", colors.success(String(result.imported))],
+            ["Skipped (duplicates)", String(result.skippedDuplicates)],
+            ["Errors", result.totalErrors > 0 ? colors.error(String(result.totalErrors)) : "0"],
+        ]);
+        if (result.totalErrors > 0 && result.errors.length > 0) {
+            console.log();
+            warn(`${result.totalErrors} contacts had errors:`);
+            for (const err of result.errors.slice(0, 10)) {
+                console.log(colors.dim(`  Row ${err.index + 1}: ${err.phone || "(empty)"} - ${err.error}`));
+            }
+            if (result.totalErrors > 10) {
+                console.log(colors.dim(`  ... and ${result.totalErrors - 10} more`));
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"import.js","sourceRoot":"","sources":["../../../src/commands/contacts/import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EACL,IAAI,EACJ,OAAO,EACP,MAAM,EACN,UAAU,EACV,QAAQ,EACR,IAAI,GACL,MAAM,qBAAqB,CAAC;AAS7B,SAAS,cAAc,CAAC,GAAW;IACjC,IAAI,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,iBAAiB,EAAE,EAAE,CAAC,CAAC;IAC/C,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3B,KAAK,GAAG,GAAG,GAAG,KAAK,CAAC;IACtB,CAAC;IACD,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QACpD,OAAO,GAAG,GAAG,KAAK,CAAC;IACrB,CAAC;IACD,IAAI,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,OAAO,GAAG,GAAG,KAAK,CAAC;IACrB,CAAC;IACD,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QACxB,OAAO,GAAG,GAAG,KAAK,CAAC;IACrB,CAAC;IACD,OAAO,GAAG,CAAC,IAAI,EAAE,CAAC;AACpB,CAAC;AAED,SAAS,QAAQ,CAAC,OAAe;IAC/B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;IAC7D,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,EAAE,CAAC;IAEhC,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;IACvE,MAAM,IAAI,GAAkC,EAAE,CAAC;IAE/C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QACxD,MAAM,GAAG,GAA2B,EAAE,CAAC;QACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACpC,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACjB,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,iBAAiB,CAAC,OAAiB;IAC1C,MAAM,UAAU,GAAG;QACjB,OAAO;QACP,aAAa;QACb,cAAc;QACd,IAAI;QACJ,QAAQ;QACR,QAAQ;QACR,MAAM;KACP,CAAC;IACF,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,IAAI,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;YAAE,OAAO,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,oBAAoB;IAC9D,MAAM,CAAC,WAAW,GAAG,iCAAiC,CAAC;IAEvD,MAAM,CAAC,QAAQ,GAAG;QAChB,gDAAgD;QAChD,+DAA+D;QAC/D,sEAAsE;KACvE,CAAC;IAEF,MAAM,CAAC,IAAI,GAAG;QACZ,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC;YAChB,WAAW,EAAE,gDAAgD;YAC7D,QAAQ,EAAE,IAAI;SACf,CAAC;KACH,CAAC;IAEF,MAAM,CAAC,KAAK,GAAG;QACb,GAAG,oBAAoB,CAAC,SAAS;QACjC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC;YACjB,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,6CAA6C;SAC3D,CAAC;KACH,CAAC;IAEF,KAAK,CAAC,GAAG;QACP,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QAEzD,IAAI,OAAe,CAAC;QACpB,IAAI,CAAC;YACH,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC7C,CAAC;QAAC,MAAM,CAAC;YACP,IAAI,CAAC,KAAK,CAAC,qBAAqB,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QAC/C,CAAC;QAED,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;QAC/B,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,IAAI,CAAC,KAAK,CAAC,uCAAuC,CAAC,CAAC;QACtD,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACrC,MAAM,QAAQ,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,IAAI,CAAC,KAAK,CACR,gFAAgF,CACjF,CAAC;QACJ,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;YAClC,KAAK,EAAE,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;YAC1C,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,GAAG,CAAC,WAAW,CAAC,IAAI,SAAS;YACrE,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,IAAI,SAAS;SAClD,CAAC,CAAC,CAAC;QAEJ,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;YAClB,OAAO,CAAC,GAAG,EAAE,CAAC;YACd,OAAO,CAAC,GAAG,CACT,MAAM,CAAC,GAAG,CAAC,aAAa,QAAQ,CAAC,MAAM,kBAAkB,IAAI,CAAC,IAAI,EAAE,CAAC,CACtE,CAAC;YACF,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;gBACf,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,mBAAmB,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;YAC3D,CAAC;YACD,OAAO,CAAC,GAAG,EAAE,CAAC;QAChB,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,IAAI,CACjC,yBAAyB,EACzB;YACE,QAAQ;YACR,MAAM,EAAE,KAAK,CAAC,IAAI;SACnB,CACF,CAAC;QAEF,IAAI,UAAU,EAAE,EAAE,CAAC;YACjB,IAAI,CAAC,MAAM,CAAC,CAAC;YACb,OAAO;QACT,CAAC;QAED,OAAO,CAAC,iBAAiB,CAAC,CAAC;QAC3B,OAAO,CAAC,GAAG,EAAE,CAAC;QAEd,QAAQ,CAAC;YACP,CAAC,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrD,CAAC,sBAAsB,EAAE,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;YAC1D,CAAC,QAAQ,EAAE,MAAM,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;SACpF,CAAC,CAAC;QAEH,IAAI,MAAM,CAAC,WAAW,GAAG,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvD,OAAO,CAAC,GAAG,EAAE,CAAC;YACd,IAAI,CAAC,GAAG,MAAM,CAAC,WAAW,uBAAuB,CAAC,CAAC;YACnD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;gBAC7C,OAAO,CAAC,GAAG,CACT,MAAM,CAAC,GAAG,CAAC,SAAS,GAAG,CAAC,KAAK,GAAG,CAAC,KAAK,GAAG,CAAC,KAAK,IAAI,SAAS,MAAM,GAAG,CAAC,KAAK,EAAE,CAAC,CAC/E,CAAC;YACJ,CAAC;YACD,IAAI,MAAM,CAAC,WAAW,GAAG,EAAE,EAAE,CAAC;gBAC5B,OAAO,CAAC,GAAG,CACT,MAAM,CAAC,GAAG,CAAC,aAAa,MAAM,CAAC,WAAW,GAAG,EAAE,OAAO,CAAC,CACxD,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC","sourcesContent":["import { Args, Flags } from \"@oclif/core\";\nimport { readFileSync } from \"node:fs\";\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\";\n\ninterface ImportResponse {\n  imported: number;\n  skippedDuplicates: number;\n  errors: Array<{ index: number; phone: string; error: string }>;\n  totalErrors: number;\n}\n\nfunction normalizePhone(raw: string): string {\n  let phone = raw.replace(/[\\s\\-\\(\\)\\.\\+]/g, \"\");\n  if (/^\\d{10}$/.test(phone)) {\n    phone = \"1\" + phone;\n  }\n  if (/^\\d{11}$/.test(phone) && phone.startsWith(\"1\")) {\n    return \"+\" + phone;\n  }\n  if (/^\\d{7,15}$/.test(phone)) {\n    return \"+\" + phone;\n  }\n  if (raw.startsWith(\"+\")) {\n    return \"+\" + phone;\n  }\n  return raw.trim();\n}\n\nfunction parseCsv(content: string): Array<Record<string, string>> {\n  const lines = content.split(/\\r?\\n/).filter((l) => l.trim());\n  if (lines.length < 2) return [];\n\n  const headers = lines[0].split(\",\").map((h) => h.trim().toLowerCase());\n  const rows: Array<Record<string, string>> = [];\n\n  for (let i = 1; i < lines.length; i++) {\n    const values = lines[i].split(\",\").map((v) => v.trim());\n    const row: Record<string, string> = {};\n    for (let j = 0; j < headers.length; j++) {\n      row[headers[j]] = values[j] || \"\";\n    }\n    rows.push(row);\n  }\n\n  return rows;\n}\n\nfunction detectPhoneColumn(headers: string[]): string | null {\n  const candidates = [\n    \"phone\",\n    \"phonenumber\",\n    \"phone_number\",\n    \"to\",\n    \"number\",\n    \"mobile\",\n    \"cell\",\n  ];\n  for (const h of headers) {\n    if (candidates.includes(h.toLowerCase())) return h;\n  }\n  return null;\n}\n\nexport default class ContactsImport extends AuthenticatedCommand {\n  static description = \"Import contacts from a CSV file\";\n\n  static examples = [\n    \"<%= config.bin %> contacts import contacts.csv\",\n    \"<%= config.bin %> contacts import contacts.csv --list lst_xxx\",\n    \"<%= config.bin %> contacts import contacts.csv --list lst_xxx --json\",\n  ];\n\n  static args = {\n    file: Args.string({\n      description: \"Path to CSV file (columns: phone, name, email)\",\n      required: true,\n    }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    list: Flags.string({\n      char: \"l\",\n      description: \"Contact list ID to add imported contacts to\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { args, flags } = await this.parse(ContactsImport);\n\n    let content: string;\n    try {\n      content = readFileSync(args.file, \"utf-8\");\n    } catch {\n      this.error(`Cannot read file: ${args.file}`);\n    }\n\n    const rows = parseCsv(content);\n    if (rows.length === 0) {\n      this.error(\"CSV file is empty or has no data rows\");\n    }\n\n    const headers = Object.keys(rows[0]);\n    const phoneCol = detectPhoneColumn(headers);\n    if (!phoneCol) {\n      this.error(\n        `No phone column found. Expected one of: phone, phoneNumber, to, number, mobile`,\n      );\n    }\n\n    const contacts = rows.map((row) => ({\n      phone: normalizePhone(row[phoneCol] || \"\"),\n      name: row[\"name\"] || row[\"fullname\"] || row[\"full_name\"] || undefined,\n      email: row[\"email\"] || row[\"e-mail\"] || undefined,\n    }));\n\n    if (!isJsonMode()) {\n      console.log();\n      console.log(\n        colors.dim(`Importing ${contacts.length} contacts from ${args.file}`),\n      );\n      if (flags.list) {\n        console.log(colors.dim(`Adding to list: ${flags.list}`));\n      }\n      console.log();\n    }\n\n    const result = await apiClient.post<ImportResponse>(\n      \"/api/v1/contacts/import\",\n      {\n        contacts,\n        listId: flags.list,\n      },\n    );\n\n    if (isJsonMode()) {\n      json(result);\n      return;\n    }\n\n    success(`Import complete`);\n    console.log();\n\n    keyValue([\n      [\"Imported\", colors.success(String(result.imported))],\n      [\"Skipped (duplicates)\", String(result.skippedDuplicates)],\n      [\"Errors\", result.totalErrors > 0 ? colors.error(String(result.totalErrors)) : \"0\"],\n    ]);\n\n    if (result.totalErrors > 0 && result.errors.length > 0) {\n      console.log();\n      warn(`${result.totalErrors} contacts had errors:`);\n      for (const err of result.errors.slice(0, 10)) {\n        console.log(\n          colors.dim(`  Row ${err.index + 1}: ${err.phone || \"(empty)\"} - ${err.error}`),\n        );\n      }\n      if (result.totalErrors > 10) {\n        console.log(\n          colors.dim(`  ... and ${result.totalErrors - 10} more`),\n        );\n      }\n    }\n  }\n}\n"]}

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

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

@@ -0,0 +1,63 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, colors, isJsonMode, keyValue, table, } from "../../../lib/output.js";
+export default class ContactsListsGet extends AuthenticatedCommand {
+    static description = "Get contact list details";
+    static examples = [
+        "<%= config.bin %> contacts lists get lst_xxx",
+        "<%= config.bin %> contacts lists get lst_xxx --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Contact list ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(ContactsListsGet);
+        const list = await apiClient.get(`/api/v1/contact-lists/${args.id}`, { includeContacts: "true", limit: "10" });
+        if (isJsonMode()) {
+            json(list);
+            return;
+        }
+        console.log();
+        console.log(colors.bold(list.name));
+        console.log();
+        keyValue([
+            ["ID", list.id],
+            ["Description", list.description || colors.dim("(none)")],
+            ["Contacts", String(list.contact_count)],
+            ["Created", new Date(list.created_at).toLocaleString()],
+            ["Updated", new Date(list.updated_at).toLocaleString()],
+        ]);
+        if (list.contacts && list.contacts.length > 0) {
+            console.log();
+            console.log(colors.dim("Contacts:"));
+            console.log();
+            table(list.contacts, [
+                { header: "Phone", key: "phone_number", width: 18 },
+                {
+                    header: "Name",
+                    key: "name",
+                    width: 20,
+                    formatter: (v) => String(v || colors.dim("-")),
+                },
+                {
+                    header: "Email",
+                    key: "email",
+                    width: 25,
+                    formatter: (v) => String(v || colors.dim("-")),
+                },
+            ]);
+            if (list.contact_count > 10) {
+                console.log();
+                console.log(colors.dim(`  Showing 10 of ${list.contact_count} contacts`));
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/dist/commands/contacts/lists/update.js

@@ -0,0 +1,51 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, success, isJsonMode } from "../../../lib/output.js";
+export default class ContactsListsUpdate extends AuthenticatedCommand {
+    static description = "Update a contact list";
+    static examples = [
+        '<%= config.bin %> contacts lists update lst_xxx --name "VIP Customers"',
+        '<%= config.bin %> contacts lists update lst_xxx --description "Updated desc"',
+    ];
+    static args = {
+        id: Args.string({
+            description: "Contact list ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "List name",
+        }),
+        description: Flags.string({
+            char: "d",
+            description: "List description",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ContactsListsUpdate);
+        if (!flags.name && !flags.description) {
+            this.error("At least one of --name or --description is required");
+        }
+        const body = {};
+        if (flags.name !== undefined)
+            body.name = flags.name;
+        if (flags.description !== undefined)
+            body.description = flags.description;
+        const list = await apiClient.patch(`/api/v1/contact-lists/${args.id}`, body);
+        if (isJsonMode()) {
+            json(list);
+            return;
+        }
+        success("Contact list updated", {
+            ID: list.id,
+            Name: list.name,
+            Description: list.description || "(none)",
+            Contacts: String(list.contact_count),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,15 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ContactsUpdate 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>;
+        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/update.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 { json, success, isJsonMode } from "../../lib/output.js";
+export default class ContactsUpdate extends AuthenticatedCommand {
+    static description = "Update a contact";
+    static examples = [
+        '<%= config.bin %> contacts update cnt_xxx --name "John Doe"',
+        "<%= config.bin %> contacts update cnt_xxx --email john@example.com",
+        '<%= config.bin %> contacts update cnt_xxx --name "John" --email john@example.com',
+    ];
+    static args = {
+        id: Args.string({
+            description: "Contact ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "Contact name",
+        }),
+        email: Flags.string({
+            char: "e",
+            description: "Contact email",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ContactsUpdate);
+        if (!flags.name && !flags.email) {
+            this.error("At least one of --name or --email is required");
+        }
+        const body = {};
+        if (flags.name !== undefined)
+            body.name = flags.name;
+        if (flags.email !== undefined)
+            body.email = flags.email;
+        const contact = await apiClient.patch(`/api/v1/contacts/${args.id}`, body);
+        if (isJsonMode()) {
+            json(contact);
+            return;
+        }
+        success("Contact updated", {
+            ID: contact.id,
+            Phone: contact.phone_number,
+            Name: contact.name || "(none)",
+            Email: contact.email || "(none)",
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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