@sendly/cli 3.12.3 → 3.13.1

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":"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","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/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>;
+}

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

@@ -0,0 +1,40 @@
+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 ContactsListsCreate extends AuthenticatedCommand {
+    static description = "Create a new contact list";
+    static examples = [
+        '<%= config.bin %> contacts lists create --name "VIP Customers"',
+        '<%= config.bin %> contacts lists create --name "Newsletter" --description "Weekly newsletter subscribers"',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "List name",
+            required: true,
+        }),
+        description: Flags.string({
+            char: "d",
+            description: "List description",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ContactsListsCreate);
+        const list = await apiClient.post("/api/v1/contact-lists", {
+            name: flags.name,
+            description: flags.description,
+        });
+        if (isJsonMode()) {
+            json(list);
+            return;
+        }
+        success("Contact list created", {
+            ID: list.id,
+            Name: list.name,
+            Description: list.description || colors.dim("(none)"),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,10 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class ContactsListsList extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    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>;
+}