waba-toolkit 0.2.0 → 0.3.1

package/dist/index.cli.js

@@ -0,0 +1,863 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/index.ts
+var import_commander = require("commander");
+var import_node_fs3 = require("fs");
+var import_node_path2 = require("path");
+
+// src/cli/commands/configure.ts
+var import_inquirer = __toESM(require("inquirer"));
+
+// src/cli/config-manager.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+
+// src/errors.ts
+var WABAError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "WABAError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var WABANetworkError = class extends WABAError {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "WABANetworkError";
+    this.cause = cause;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var WABAConfigError = class extends WABAError {
+  constructor(message, field) {
+    super(message);
+    this.field = field;
+    this.name = "WABAConfigError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var WABAAuthError = class extends WABAError {
+  constructor(message, statusCode) {
+    super(message, statusCode);
+    this.statusCode = statusCode;
+    this.name = "WABAAuthError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var WABASendError = class extends WABAError {
+  constructor(message, statusCode, errorPayload) {
+    super(message, statusCode, errorPayload);
+    this.statusCode = statusCode;
+    this.errorPayload = errorPayload;
+    this.name = "WABASendError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/cli/config-manager.ts
+var CONFIG_FILE = (0, import_node_path.join)((0, import_node_os.homedir)(), ".waba-toolkit");
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 16;
+function getMachineKey() {
+  const host = (0, import_node_os.hostname)();
+  let macAddress = "";
+  const interfaces = (0, import_node_os.networkInterfaces)();
+  for (const name of Object.keys(interfaces)) {
+    const iface = interfaces[name];
+    if (!iface) continue;
+    for (const addr of iface) {
+      if (!addr.internal && addr.mac && addr.mac !== "00:00:00:00:00:00") {
+        macAddress = addr.mac;
+        break;
+      }
+    }
+    if (macAddress) break;
+  }
+  const keySource = macAddress ? `${host}:${macAddress}` : host;
+  return (0, import_node_crypto.createHash)("sha256").update(keySource).digest();
+}
+function encryptConfig(config) {
+  const key = getMachineKey();
+  const iv = (0, import_node_crypto.randomBytes)(IV_LENGTH);
+  const cipher = (0, import_node_crypto.createCipheriv)(ALGORITHM, key, iv);
+  const plaintext = JSON.stringify(config);
+  let encrypted = cipher.update(plaintext, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const authTag = cipher.getAuthTag();
+  const result = {
+    iv: iv.toString("hex"),
+    authTag: authTag.toString("hex"),
+    data: encrypted
+  };
+  return JSON.stringify(result);
+}
+function decryptConfig(encrypted) {
+  try {
+    const { iv, authTag, data } = JSON.parse(encrypted);
+    const key = getMachineKey();
+    const decipher = (0, import_node_crypto.createDecipheriv)(
+      ALGORITHM,
+      key,
+      Buffer.from(iv, "hex")
+    );
+    decipher.setAuthTag(Buffer.from(authTag, "hex"));
+    let decrypted = decipher.update(data, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return JSON.parse(decrypted);
+  } catch (error) {
+    throw new WABAConfigError(
+      "Failed to decrypt config file. This may happen if:\n  - Config was created on a different machine\n  - System hostname or network configuration changed\n  - Config file is corrupted"
+    );
+  }
+}
+function backupConfig() {
+  if (!(0, import_node_fs.existsSync)(CONFIG_FILE)) return;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").replace(/\..+/, "");
+  const backupPath = `${CONFIG_FILE}.backup.${timestamp}`;
+  try {
+    (0, import_node_fs.renameSync)(CONFIG_FILE, backupPath);
+    console.log(`\u2713 Old config backed up to: ${backupPath}`);
+  } catch (error) {
+    console.error(`\u2717 Failed to backup config: ${error}`);
+  }
+}
+function loadConfig() {
+  if (!(0, import_node_fs.existsSync)(CONFIG_FILE)) {
+    return null;
+  }
+  try {
+    const encrypted = (0, import_node_fs.readFileSync)(CONFIG_FILE, "utf8");
+    return decryptConfig(encrypted);
+  } catch (error) {
+    if (error instanceof WABAConfigError) {
+      console.error(`\u2717 ${error.message}
+`);
+      backupConfig();
+      return null;
+    }
+    throw error;
+  }
+}
+function saveConfig(config) {
+  try {
+    const encrypted = encryptConfig(config);
+    (0, import_node_fs.writeFileSync)(CONFIG_FILE, encrypted, { mode: 384 });
+  } catch (error) {
+    throw new WABAConfigError(
+      `Failed to save config: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+function updateConfigField(field, value) {
+  const config = loadConfig() || { accessToken: "" };
+  config[field] = value;
+  saveConfig(config);
+}
+function getConfig() {
+  const fileConfig = loadConfig() || {};
+  return {
+    accessToken: process.env.WABA_TOOLKIT_ACCESS_TOKEN || fileConfig.accessToken,
+    defaultPhoneNumberId: process.env.WABA_TOOLKIT_PHONE_NUMBER_ID || fileConfig.defaultPhoneNumberId,
+    apiVersion: process.env.WABA_TOOLKIT_API_VERSION || fileConfig.apiVersion || "v22.0",
+    wabaId: process.env.WABA_TOOLKIT_WABA_ID || fileConfig.wabaId,
+    businessId: process.env.WABA_TOOLKIT_BUSINESS_ID || fileConfig.businessId
+  };
+}
+function resolvePhoneNumberId(flagValue) {
+  const phoneNumberId = flagValue || process.env.WABA_TOOLKIT_PHONE_NUMBER_ID || loadConfig()?.defaultPhoneNumberId;
+  if (!phoneNumberId) {
+    throw new WABAConfigError(
+      "No phone number ID specified\n\nYou must either:\n  1. Set a default: waba-toolkit config set-default-phone <phone-number-id>\n  2. Use environment variable: WABA_TOOLKIT_PHONE_NUMBER_ID=<id>\n  3. Specify with flag: --bpid <phone-number-id>",
+      "phoneNumberId"
+    );
+  }
+  return phoneNumberId;
+}
+function resolveWabaId(flagValue) {
+  const wabaId = flagValue || process.env.WABA_TOOLKIT_WABA_ID || loadConfig()?.wabaId;
+  if (!wabaId) {
+    throw new WABAConfigError(
+      "No WABA ID specified\n\nYou must either:\n  1. Set in config: waba-toolkit config set waba-id <id>\n  2. Use environment variable: WABA_TOOLKIT_WABA_ID=<id>\n  3. Specify with flag: --waba-id <id>",
+      "wabaId"
+    );
+  }
+  return wabaId;
+}
+function resolveAccessToken() {
+  const accessToken = process.env.WABA_TOOLKIT_ACCESS_TOKEN || loadConfig()?.accessToken;
+  if (!accessToken) {
+    throw new WABAConfigError(
+      "Access token not found\n\nYou must either:\n  1. Run: waba-toolkit configure\n  2. Use environment variable: WABA_TOOLKIT_ACCESS_TOKEN=<token>\n  3. Update config: waba-toolkit config set access-token <token>",
+      "accessToken"
+    );
+  }
+  return accessToken;
+}
+
+// src/cli/utils.ts
+function maskValue(value) {
+  if (value.length <= 6) {
+    return "***";
+  }
+  const first = value.slice(0, 3);
+  const last = value.slice(-3);
+  return `${first}...****...${last}`;
+}
+function formatError(message, payload) {
+  let output = `\u2717 ${message}`;
+  if (payload) {
+    output += "\n\n" + JSON.stringify(payload, null, 2);
+  }
+  return output;
+}
+function formatSuccess(message) {
+  return `\u2713 ${message}`;
+}
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function handleError(error) {
+  if (error instanceof Error) {
+    console.error(formatError(error.message));
+  } else {
+    console.error(formatError("Unknown error occurred"));
+  }
+  process.exit(1);
+}
+
+// src/cli/commands/configure.ts
+async function configure() {
+  try {
+    console.log("WhatsApp Business API Toolkit - Configuration\n");
+    const answers = await import_inquirer.default.prompt([
+      {
+        type: "input",
+        name: "accessToken",
+        message: "Access token (required):",
+        validate: (input) => {
+          if (!input || input.trim().length === 0) {
+            return "Access token is required";
+          }
+          return true;
+        }
+      },
+      {
+        type: "input",
+        name: "defaultPhoneNumberId",
+        message: "Default phone number ID (optional):"
+      },
+      {
+        type: "input",
+        name: "apiVersion",
+        message: "API version (optional):",
+        default: "v22.0"
+      },
+      {
+        type: "input",
+        name: "wabaId",
+        message: "WhatsApp Business Account ID (optional):"
+      },
+      {
+        type: "input",
+        name: "businessId",
+        message: "Business Portfolio ID (optional):"
+      }
+    ]);
+    const config = {
+      accessToken: answers.accessToken
+    };
+    if (answers.defaultPhoneNumberId?.trim()) {
+      config.defaultPhoneNumberId = answers.defaultPhoneNumberId.trim();
+    }
+    if (answers.apiVersion?.trim()) {
+      config.apiVersion = answers.apiVersion.trim();
+    }
+    if (answers.wabaId?.trim()) {
+      config.wabaId = answers.wabaId.trim();
+    }
+    if (answers.businessId?.trim()) {
+      config.businessId = answers.businessId.trim();
+    }
+    saveConfig(config);
+    console.log("\n" + formatSuccess("Configuration saved successfully"));
+    console.log("\nConfig is encrypted and stored at: ~/.waba-toolkit");
+    console.log("The config is machine-locked and cannot be moved between systems.");
+  } catch (error) {
+    handleError(error);
+  }
+}
+
+// src/cli/commands/config.ts
+function showConfig() {
+  try {
+    const config = loadConfig();
+    if (!config) {
+      console.log("No configuration found. Run: waba-toolkit configure");
+      return;
+    }
+    console.log("Current Configuration:\n");
+    console.log(`Access Token: ${maskValue(config.accessToken)}`);
+    console.log(`Default Phone Number ID: ${config.defaultPhoneNumberId || "(not set)"}`);
+    console.log(`API Version: ${config.apiVersion || "v22.0"}`);
+    console.log(`WABA ID: ${config.wabaId || "(not set)"}`);
+    console.log(`Business ID: ${config.businessId || "(not set)"}`);
+    console.log("\nConfig file: ~/.waba-toolkit");
+  } catch (error) {
+    handleError(error);
+  }
+}
+function setDefaultPhone(phoneNumberId) {
+  try {
+    if (!phoneNumberId || phoneNumberId.trim().length === 0) {
+      throw new Error("Phone number ID is required");
+    }
+    updateConfigField("defaultPhoneNumberId", phoneNumberId.trim());
+    console.log(formatSuccess(`Default phone number ID set to: ${phoneNumberId.trim()}`));
+  } catch (error) {
+    handleError(error);
+  }
+}
+function setConfigField(field, value) {
+  try {
+    if (!value || value.trim().length === 0) {
+      throw new Error(`Value for ${field} is required`);
+    }
+    const validFields = [
+      "accessToken",
+      "defaultPhoneNumberId",
+      "apiVersion",
+      "wabaId",
+      "businessId"
+    ];
+    const camelField = field.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+    if (!validFields.includes(camelField)) {
+      throw new Error(
+        `Invalid field: ${field}
+
+Valid fields: ${validFields.join(", ")}`
+      );
+    }
+    updateConfigField(camelField, value.trim());
+    console.log(formatSuccess(`${field} updated successfully`));
+  } catch (error) {
+    handleError(error);
+  }
+}
+
+// src/api/client.ts
+var DEFAULT_API_VERSION = "v22.0";
+var DEFAULT_BASE_URL = "https://graph.facebook.com";
+var WABAApiClient = class {
+  accessToken;
+  phoneNumberId;
+  apiVersion;
+  baseUrl;
+  constructor(options) {
+    this.accessToken = options.accessToken;
+    this.phoneNumberId = options.phoneNumberId;
+    this.apiVersion = options.apiVersion ?? DEFAULT_API_VERSION;
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+  }
+  /**
+   * Register phone number with WhatsApp Business API.
+   *
+   * @throws {WABAAuthError} - Authentication failure (invalid token)
+   * @throws {WABASendError} - Registration failure
+   * @throws {WABANetworkError} - Network/connection failures
+   */
+  async registerPhone(pin) {
+    const url = `${this.baseUrl}/${this.apiVersion}/${this.phoneNumberId}/register`;
+    const payload = {
+      messaging_product: "whatsapp",
+      pin
+    };
+    return this.makeRequest(url, "POST", payload);
+  }
+  /**
+   * Deregister phone number from WhatsApp Business API.
+   *
+   * @throws {WABAAuthError} - Authentication failure (invalid token)
+   * @throws {WABASendError} - Deregistration failure
+   * @throws {WABANetworkError} - Network/connection failures
+   */
+  async deregisterPhone() {
+    const url = `${this.baseUrl}/${this.apiVersion}/${this.phoneNumberId}/deregister`;
+    const payload = {
+      messaging_product: "whatsapp"
+    };
+    return this.makeRequest(url, "POST", payload);
+  }
+  /**
+   * List all phone numbers in a WhatsApp Business Account.
+   *
+   * @param wabaId - WhatsApp Business Account ID
+   * @throws {WABAAuthError} - Authentication failure (invalid token)
+   * @throws {WABASendError} - Request failure
+   * @throws {WABANetworkError} - Network/connection failures
+   */
+  async listPhoneNumbers(wabaId) {
+    const url = `${this.baseUrl}/${this.apiVersion}/${wabaId}/phone_numbers`;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.accessToken}`
+        }
+      });
+    } catch (error) {
+      throw new WABANetworkError(
+        `Failed to make request: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (response.ok) {
+      return await response.json();
+    }
+    const errorBody = await response.json().catch(() => null);
+    if (response.status === 401 || response.status === 403) {
+      throw new WABAAuthError(
+        `Authentication failed: ${response.status} ${response.statusText}`,
+        response.status
+      );
+    }
+    throw new WABASendError(
+      `Request failed: ${response.status} ${response.statusText}`,
+      response.status,
+      errorBody
+    );
+  }
+  /**
+   * Send text message.
+   *
+   * @throws {WABAAuthError} - Authentication failure (invalid token)
+   * @throws {WABASendError} - Message sending failure
+   * @throws {WABANetworkError} - Network/connection failures
+   */
+  async sendTextMessage(to, text, options) {
+    const url = `${this.baseUrl}/${this.apiVersion}/${this.phoneNumberId}/messages`;
+    const payload = {
+      messaging_product: "whatsapp",
+      to,
+      type: "text",
+      text: {
+        body: text,
+        preview_url: options?.previewUrl ?? false
+      }
+    };
+    if (options?.context) {
+      payload.context = options.context;
+    }
+    return this.makeRequest(url, "POST", payload);
+  }
+  /**
+   * Send template message.
+   *
+   * @throws {WABAAuthError} - Authentication failure (invalid token)
+   * @throws {WABASendError} - Message sending failure
+   * @throws {WABANetworkError} - Network/connection failures
+   */
+  async sendTemplateMessage(to, template) {
+    const url = `${this.baseUrl}/${this.apiVersion}/${this.phoneNumberId}/messages`;
+    const payload = {
+      messaging_product: "whatsapp",
+      to,
+      type: "template",
+      template
+    };
+    return this.makeRequest(url, "POST", payload);
+  }
+  /**
+   * Send generic message (accepts full message payload).
+   * Useful for sending any message type (image, video, document, interactive, etc.).
+   *
+   * @throws {WABAAuthError} - Authentication failure (invalid token)
+   * @throws {WABASendError} - Message sending failure
+   * @throws {WABANetworkError} - Network/connection failures
+   */
+  async sendMessage(payload) {
+    const url = `${this.baseUrl}/${this.apiVersion}/${this.phoneNumberId}/messages`;
+    return this.makeRequest(url, "POST", payload);
+  }
+  async makeRequest(url, method, body) {
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+    } catch (error) {
+      throw new WABANetworkError(
+        `Failed to make request: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (response.ok) {
+      return await response.json();
+    }
+    const errorBody = await response.json().catch(() => null);
+    if (response.status === 401 || response.status === 403) {
+      throw new WABAAuthError(
+        `Authentication failed: ${response.status} ${response.statusText}`,
+        response.status
+      );
+    }
+    throw new WABASendError(
+      `Request failed: ${response.status} ${response.statusText}`,
+      response.status,
+      errorBody
+    );
+  }
+};
+
+// src/cli/commands/register.ts
+async function registerPhone(options) {
+  try {
+    const accessToken = resolveAccessToken();
+    const phoneNumberId = resolvePhoneNumberId(options.bpid || options.phoneNumberId);
+    const config = getConfig();
+    const client = new WABAApiClient({
+      accessToken,
+      phoneNumberId,
+      apiVersion: config.apiVersion
+    });
+    const response = await client.registerPhone(options.pin);
+    printJson(response);
+  } catch (error) {
+    if (error instanceof WABASendError) {
+      console.error(formatError("Phone registration failed", error.errorPayload));
+    } else {
+      handleError(error);
+    }
+    process.exit(1);
+  }
+}
+async function deregisterPhone(options) {
+  try {
+    const accessToken = resolveAccessToken();
+    const phoneNumberId = resolvePhoneNumberId(options.bpid || options.phoneNumberId);
+    const config = getConfig();
+    const client = new WABAApiClient({
+      accessToken,
+      phoneNumberId,
+      apiVersion: config.apiVersion
+    });
+    const response = await client.deregisterPhone();
+    printJson(response);
+  } catch (error) {
+    if (error instanceof WABASendError) {
+      console.error(formatError("Phone deregistration failed", error.errorPayload));
+    } else {
+      handleError(error);
+    }
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/send.ts
+var import_node_fs2 = require("fs");
+async function sendText(options) {
+  try {
+    const accessToken = resolveAccessToken();
+    const phoneNumberId = resolvePhoneNumberId(options.bpid || options.phoneNumberId);
+    const config = getConfig();
+    const client = new WABAApiClient({
+      accessToken,
+      phoneNumberId,
+      apiVersion: config.apiVersion
+    });
+    const context = options.replyTo ? { message_id: options.replyTo } : void 0;
+    const response = await client.sendTextMessage(options.to, options.message, {
+      previewUrl: options.previewUrl,
+      context
+    });
+    printJson(response);
+  } catch (error) {
+    if (error instanceof WABASendError) {
+      console.error(formatError("Message failed to send", error.errorPayload));
+    } else {
+      handleError(error);
+    }
+    process.exit(1);
+  }
+}
+async function sendTemplate(options) {
+  try {
+    const accessToken = resolveAccessToken();
+    const phoneNumberId = resolvePhoneNumberId(options.bpid || options.phoneNumberId);
+    const config = getConfig();
+    let templateData;
+    try {
+      const fileContent = (0, import_node_fs2.readFileSync)(options.file, "utf8");
+      templateData = JSON.parse(fileContent);
+    } catch (error) {
+      throw new Error(
+        `Failed to read template file: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+    const client = new WABAApiClient({
+      accessToken,
+      phoneNumberId,
+      apiVersion: config.apiVersion
+    });
+    const response = await client.sendTemplateMessage(options.to, templateData);
+    printJson(response);
+  } catch (error) {
+    if (error instanceof WABASendError) {
+      console.error(formatError("Template message failed to send", error.errorPayload));
+    } else {
+      handleError(error);
+    }
+    process.exit(1);
+  }
+}
+async function sendFile(options) {
+  try {
+    const accessToken = resolveAccessToken();
+    const phoneNumberId = resolvePhoneNumberId(options.bpid || options.phoneNumberId);
+    const config = getConfig();
+    let payload;
+    try {
+      const fileContent = (0, import_node_fs2.readFileSync)(options.payload, "utf8");
+      payload = JSON.parse(fileContent);
+    } catch (error) {
+      throw new Error(
+        `Failed to read payload file: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+    const client = new WABAApiClient({
+      accessToken,
+      phoneNumberId,
+      apiVersion: config.apiVersion
+    });
+    const response = await client.sendMessage(payload);
+    printJson(response);
+  } catch (error) {
+    if (error instanceof WABASendError) {
+      console.error(formatError("Message failed to send", error.errorPayload));
+    } else {
+      handleError(error);
+    }
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/list-phones.ts
+async function listPhones(options) {
+  try {
+    const accessToken = resolveAccessToken();
+    const wabaId = resolveWabaId(options.wabaId);
+    const config = getConfig();
+    const client = new WABAApiClient({
+      accessToken,
+      phoneNumberId: "",
+      // Not needed for listPhoneNumbers
+      apiVersion: config.apiVersion
+    });
+    const response = await client.listPhoneNumbers(wabaId);
+    printJson(response);
+  } catch (error) {
+    if (error instanceof WABASendError) {
+      console.error(formatError("Failed to list phone numbers", error.errorPayload));
+    } else {
+      handleError(error);
+    }
+    process.exit(1);
+  }
+}
+
+// src/cli/index.ts
+var packageJson = JSON.parse(
+  (0, import_node_fs3.readFileSync)((0, import_node_path2.join)(__dirname, "../package.json"), "utf8")
+);
+var program = new import_commander.Command();
+program.name("waba-toolkit").description("WhatsApp Business API Toolkit - CLI for webhooks, media, and messaging").version(packageJson.version).addHelpText("after", `
+Examples:
+  $ waba-toolkit configure                    # Set up configuration interactively
+  $ waba-toolkit config show                  # View current configuration
+  $ waba-toolkit list-phones --waba-id 123    # List phone numbers
+  $ waba-toolkit send text --to 1234567890 --message "Hello"
+  $ waba-toolkit register --pin 123456
+
+Environment Variables:
+  WABA_TOOLKIT_ACCESS_TOKEN       Access token for WhatsApp API
+  WABA_TOOLKIT_PHONE_NUMBER_ID    Default phone number ID
+  WABA_TOOLKIT_WABA_ID            WhatsApp Business Account ID
+  WABA_TOOLKIT_API_VERSION        API version (default: v22.0)
+
+Configuration:
+  Config is stored at ~/.waba-toolkit (encrypted, machine-locked)
+  Priority: CLI flags > environment variables > config file
+`);
+program.command("configure").description("Interactive configuration wizard").addHelpText("after", `
+Examples:
+  $ waba-toolkit configure
+
+  This will prompt you for:
+  - Access token (required)
+  - Default phone number ID (optional)
+  - API version (optional, default: v22.0)
+  - WABA ID (optional)
+  - Business ID (optional)
+`).action(configure);
+var configCommand = program.command("config").description("Manage configuration");
+configCommand.command("show").description("Show current configuration (sensitive values masked)").addHelpText("after", `
+Examples:
+  $ waba-toolkit config show
+`).action(showConfig);
+configCommand.command("set-default-phone <phone-number-id>").description("Set default phone number ID").addHelpText("after", `
+Examples:
+  $ waba-toolkit config set-default-phone 1234567890
+`).action(setDefaultPhone);
+configCommand.command("set <field> <value>").description("Update specific configuration value").addHelpText("after", `
+Examples:
+  $ waba-toolkit config set access-token EAABsbCS...
+  $ waba-toolkit config set waba-id 1234567890
+  $ waba-toolkit config set api-version v22.0
+
+Valid fields:
+  - access-token
+  - default-phone-number-id
+  - api-version
+  - waba-id
+  - business-id
+`).action(setConfigField);
+program.command("register").description("Register phone number with WhatsApp Business API").option("--bpid <phone-number-id>", "Phone number ID (overrides default)").option("--phone-number-id <id>", "Phone number ID (alias for --bpid)").requiredOption("--pin <pin>", "Six-digit PIN for registration").addHelpText("after", `
+Examples:
+  $ waba-toolkit register --pin 123456
+  $ waba-toolkit register --bpid 1234567890 --pin 123456
+`).action(async (options) => {
+  await registerPhone({
+    bpid: options.bpid,
+    phoneNumberId: options.phoneNumberId,
+    pin: options.pin
+  });
+});
+program.command("deregister").description("Deregister phone number from WhatsApp Business API").option("--bpid <phone-number-id>", "Phone number ID (overrides default)").option("--phone-number-id <id>", "Phone number ID (alias for --bpid)").addHelpText("after", `
+Examples:
+  $ waba-toolkit deregister
+  $ waba-toolkit deregister --bpid 1234567890
+`).action(async (options) => {
+  await deregisterPhone({
+    bpid: options.bpid,
+    phoneNumberId: options.phoneNumberId
+  });
+});
+program.command("list-phones").description("List all phone numbers for a WhatsApp Business Account").option("--waba-id <id>", "WhatsApp Business Account ID (overrides default)").addHelpText("after", `
+Examples:
+  $ waba-toolkit list-phones --waba-id 1234567890
+  $ WABA_TOOLKIT_WABA_ID=1234567890 waba-toolkit list-phones
+
+Output:
+  Returns JSON with phone numbers, quality ratings, and verified names
+`).action(async (options) => {
+  await listPhones({
+    wabaId: options.wabaId
+  });
+});
+var sendCommand = program.command("send").description("Send messages via WhatsApp Business API");
+sendCommand.command("text").description("Send text message").option("--bpid <phone-number-id>", "Phone number ID (overrides default)").option("--phone-number-id <id>", "Phone number ID (alias for --bpid)").requiredOption("--to <recipient>", "Recipient phone number").requiredOption("--message <text>", "Message text").option("--preview-url", "Enable URL preview").option("--reply-to <message-id>", "Reply to specific message ID").addHelpText("after", `
+Examples:
+  $ waba-toolkit send text --to 1234567890 --message "Hello World"
+  $ waba-toolkit send text --to 1234567890 --message "Check this out: https://example.com" --preview-url
+  $ waba-toolkit send text --to 1234567890 --message "Reply" --reply-to wamid.abc123
+`).action(async (options) => {
+  await sendText({
+    bpid: options.bpid,
+    phoneNumberId: options.phoneNumberId,
+    to: options.to,
+    message: options.message,
+    previewUrl: options.previewUrl,
+    replyTo: options.replyTo
+  });
+});
+sendCommand.command("template").description("Send template message from JSON file").option("--bpid <phone-number-id>", "Phone number ID (overrides default)").option("--phone-number-id <id>", "Phone number ID (alias for --bpid)").requiredOption("--to <recipient>", "Recipient phone number").requiredOption("--file <path>", "Path to template JSON file").addHelpText("after", `
+Examples:
+  $ waba-toolkit send template --to 1234567890 --file template.json
+
+Template JSON format:
+  {
+    "name": "hello_world",
+    "language": {
+      "code": "en_US"
+    },
+    "components": [
+      {
+        "type": "body",
+        "parameters": [
+          { "type": "text", "text": "John" }
+        ]
+      }
+    ]
+  }
+`).action(async (options) => {
+  await sendTemplate({
+    bpid: options.bpid,
+    phoneNumberId: options.phoneNumberId,
+    to: options.to,
+    file: options.file
+  });
+});
+sendCommand.command("file").description("Send message from JSON payload file").option("--bpid <phone-number-id>", "Phone number ID (overrides default)").option("--phone-number-id <id>", "Phone number ID (alias for --bpid)").requiredOption("--payload <path>", "Path to message payload JSON file").addHelpText("after", `
+Examples:
+  $ waba-toolkit send file --payload message.json
+
+Payload JSON format (text message):
+  {
+    "messaging_product": "whatsapp",
+    "to": "1234567890",
+    "type": "text",
+    "text": {
+      "body": "Hello World"
+    }
+  }
+
+Payload JSON format (image message):
+  {
+    "messaging_product": "whatsapp",
+    "to": "1234567890",
+    "type": "image",
+    "image": {
+      "link": "https://example.com/image.jpg"
+    }
+  }
+`).action(async (options) => {
+  await sendFile({
+    bpid: options.bpid,
+    phoneNumberId: options.phoneNumberId,
+    payload: options.payload
+  });
+});
+program.parse();