@sendly/cli 3.37.1 → 3.39.0

package/dist/commands/sms/send.js

@@ -37,6 +37,9 @@ export default class SmsSend extends AuthenticatedCommand {
             description: "Media URL to attach (MMS). Can be specified multiple times.",
             multiple: true,
         }),
+        "idempotency-key": Flags.string({
+            description: "Idempotency key (1-255 printable ASCII characters). Re-running with the same key within 24 hours returns the original result instead of sending again.",
+        }),
     };
     async run() {
         const { flags } = await this.parse(SmsSend);
@@ -111,7 +114,7 @@ export default class SmsSend extends AuthenticatedCommand {
                 ...(text && { text }),
                 ...(flags.from && { from: flags.from }),
                 ...(hasMedia && { mediaUrls }),
-            });
+            }, true, { idempotencyKey: flags["idempotency-key"] });
             spin.stop();
             if (isJsonMode()) {
                 json(response);
@@ -138,4 +141,4 @@ export default class SmsSend extends AuthenticatedCommand {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"send.js","sourceRoot":"","sources":["../../../src/commands/sms/send.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  success,\n  error,\n  spinner,\n  colors,\n  formatStatus,\n  formatCredits,\n  json,\n  isJsonMode,\n} from \"../../lib/output.js\";\nimport inquirer from \"inquirer\";\n\ninterface SendMessageResponse {\n  id: string;\n  to: string;\n  from: string;\n  text: string;\n  status: string;\n  segments: number;\n  creditsUsed: number;\n  createdAt: string;\n  mediaUrls?: string[];\n}\n\nexport default class SmsSend extends AuthenticatedCommand {\n  static description = \"Send an SMS or MMS message\";\n\n  static examples = [\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\"',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\" --from \"Sendly\"',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\" --type transactional',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\" --json',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Check this out\" --media-url https://example.com/image.jpg',\n    '<%= config.bin %> sms send --to +15551234567 --media-url https://example.com/image.jpg',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Two images\" --media-url https://example.com/a.jpg --media-url https://example.com/b.jpg',\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    to: Flags.string({\n      char: \"t\",\n      description: \"Recipient phone number (E.164 format)\",\n    }),\n    text: Flags.string({\n      char: \"m\",\n      description: \"Message text (optional when --media-url is provided)\",\n    }),\n    from: Flags.string({\n      char: \"f\",\n      description: \"Sender ID or phone number\",\n    }),\n    type: Flags.string({\n      description: \"Message type: marketing (default) or transactional\",\n      options: [\"marketing\", \"transactional\"],\n      default: \"marketing\",\n    }),\n    \"media-url\": Flags.string({\n      description: \"Media URL to attach (MMS). Can be specified multiple times.\",\n      multiple: true,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(SmsSend);\n    const mediaUrls = flags[\"media-url\"];\n    const hasMedia = mediaUrls && mediaUrls.length > 0;\n\n    let to = flags.to;\n    let text = flags.text;\n\n    if (!to) {\n      if (process.stdin.isTTY) {\n        const answers = await inquirer.prompt([\n          {\n            type: \"input\",\n            name: \"to\",\n            message: \"Recipient phone number (E.164):\",\n            validate: (input: string) => {\n              if (!input) return \"Phone number is required\";\n              if (!/^\\+[1-9]\\d{1,14}$/.test(input)) {\n                return \"Invalid format. Use E.164: +15551234567\";\n              }\n              return true;\n            },\n          },\n        ]);\n        to = answers.to;\n      } else {\n        error(\"Missing required flag: --to\", {\n          hint: \"Use --to +15551234567\",\n        });\n        this.exit(1);\n      }\n    }\n\n    if (!text && !hasMedia) {\n      if (process.stdin.isTTY) {\n        const answers = await inquirer.prompt([\n          {\n            type: \"input\",\n            name: \"text\",\n            message: \"Message text:\",\n            validate: (input: string) => {\n              if (!input.trim()) return \"Message text cannot be empty\";\n              return true;\n            },\n          },\n        ]);\n        text = answers.text;\n      } else {\n        error(\"Either --text or --media-url is required\");\n        this.exit(1);\n      }\n    }\n\n    if (!/^\\+[1-9]\\d{1,14}$/.test(to!)) {\n      error(\"Invalid phone number format\", {\n        hint: \"Use E.164 format: +15551234567\",\n      });\n      this.exit(1);\n    }\n\n    if (text && !text.trim()) {\n      error(\"Message text cannot be empty\");\n      this.exit(1);\n    }\n\n    const messageLabel = hasMedia ? \"MMS\" : \"SMS\";\n    const spin = spinner(`Sending ${messageLabel} message...`);\n    spin.start();\n\n    try {\n      const response = await apiClient.post<SendMessageResponse>(\n        \"/api/v1/messages\",\n        {\n          to,\n          messageType: flags.type,\n          ...(text && { text }),\n          ...(flags.from && { from: flags.from }),\n          ...(hasMedia && { mediaUrls }),\n        },\n      );\n\n      spin.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      success(`${messageLabel} sent`, {\n        ID: response.id,\n        To: response.to,\n        Type: messageLabel,\n        Status: formatStatus(response.status),\n        ...(response.segments != null && { Segments: response.segments }),\n        Credits: formatCredits(response.creditsUsed),\n        ...(hasMedia && { Media: `${mediaUrls.length} attachment${mediaUrls.length > 1 ? \"s\" : \"\"}` }),\n      });\n\n      if (hasMedia && !isJsonMode()) {\n        for (const url of mediaUrls) {\n          console.log(`  ${colors.dim(\"Media:\")} ${url}`);\n        }\n      }\n    } catch (err) {\n      spin.stop();\n      throw err;\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"send.js","sourceRoot":"","sources":["../../../src/commands/sms/send.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  success,\n  error,\n  spinner,\n  colors,\n  formatStatus,\n  formatCredits,\n  json,\n  isJsonMode,\n} from \"../../lib/output.js\";\nimport inquirer from \"inquirer\";\n\ninterface SendMessageResponse {\n  id: string;\n  to: string;\n  from: string;\n  text: string;\n  status: string;\n  segments: number;\n  creditsUsed: number;\n  createdAt: string;\n  mediaUrls?: string[];\n}\n\nexport default class SmsSend extends AuthenticatedCommand {\n  static description = \"Send an SMS or MMS message\";\n\n  static examples = [\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\"',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\" --from \"Sendly\"',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\" --type transactional',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Hello!\" --json',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Check this out\" --media-url https://example.com/image.jpg',\n    '<%= config.bin %> sms send --to +15551234567 --media-url https://example.com/image.jpg',\n    '<%= config.bin %> sms send --to +15551234567 --text \"Two images\" --media-url https://example.com/a.jpg --media-url https://example.com/b.jpg',\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    to: Flags.string({\n      char: \"t\",\n      description: \"Recipient phone number (E.164 format)\",\n    }),\n    text: Flags.string({\n      char: \"m\",\n      description: \"Message text (optional when --media-url is provided)\",\n    }),\n    from: Flags.string({\n      char: \"f\",\n      description: \"Sender ID or phone number\",\n    }),\n    type: Flags.string({\n      description: \"Message type: marketing (default) or transactional\",\n      options: [\"marketing\", \"transactional\"],\n      default: \"marketing\",\n    }),\n    \"media-url\": Flags.string({\n      description: \"Media URL to attach (MMS). Can be specified multiple times.\",\n      multiple: true,\n    }),\n    \"idempotency-key\": Flags.string({\n      description:\n        \"Idempotency key (1-255 printable ASCII characters). Re-running with the same key within 24 hours returns the original result instead of sending again.\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(SmsSend);\n    const mediaUrls = flags[\"media-url\"];\n    const hasMedia = mediaUrls && mediaUrls.length > 0;\n\n    let to = flags.to;\n    let text = flags.text;\n\n    if (!to) {\n      if (process.stdin.isTTY) {\n        const answers = await inquirer.prompt([\n          {\n            type: \"input\",\n            name: \"to\",\n            message: \"Recipient phone number (E.164):\",\n            validate: (input: string) => {\n              if (!input) return \"Phone number is required\";\n              if (!/^\\+[1-9]\\d{1,14}$/.test(input)) {\n                return \"Invalid format. Use E.164: +15551234567\";\n              }\n              return true;\n            },\n          },\n        ]);\n        to = answers.to;\n      } else {\n        error(\"Missing required flag: --to\", {\n          hint: \"Use --to +15551234567\",\n        });\n        this.exit(1);\n      }\n    }\n\n    if (!text && !hasMedia) {\n      if (process.stdin.isTTY) {\n        const answers = await inquirer.prompt([\n          {\n            type: \"input\",\n            name: \"text\",\n            message: \"Message text:\",\n            validate: (input: string) => {\n              if (!input.trim()) return \"Message text cannot be empty\";\n              return true;\n            },\n          },\n        ]);\n        text = answers.text;\n      } else {\n        error(\"Either --text or --media-url is required\");\n        this.exit(1);\n      }\n    }\n\n    if (!/^\\+[1-9]\\d{1,14}$/.test(to!)) {\n      error(\"Invalid phone number format\", {\n        hint: \"Use E.164 format: +15551234567\",\n      });\n      this.exit(1);\n    }\n\n    if (text && !text.trim()) {\n      error(\"Message text cannot be empty\");\n      this.exit(1);\n    }\n\n    const messageLabel = hasMedia ? \"MMS\" : \"SMS\";\n    const spin = spinner(`Sending ${messageLabel} message...`);\n    spin.start();\n\n    try {\n      const response = await apiClient.post<SendMessageResponse>(\n        \"/api/v1/messages\",\n        {\n          to,\n          messageType: flags.type,\n          ...(text && { text }),\n          ...(flags.from && { from: flags.from }),\n          ...(hasMedia && { mediaUrls }),\n        },\n        true,\n        { idempotencyKey: flags[\"idempotency-key\"] },\n      );\n\n      spin.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      success(`${messageLabel} sent`, {\n        ID: response.id,\n        To: response.to,\n        Type: messageLabel,\n        Status: formatStatus(response.status),\n        ...(response.segments != null && { Segments: response.segments }),\n        Credits: formatCredits(response.creditsUsed),\n        ...(hasMedia && { Media: `${mediaUrls.length} attachment${mediaUrls.length > 1 ? \"s\" : \"\"}` }),\n      });\n\n      if (hasMedia && !isJsonMode()) {\n        for (const url of mediaUrls) {\n          console.log(`  ${colors.dim(\"Media:\")} ${url}`);\n        }\n      }\n    } catch (err) {\n      spin.stop();\n      throw err;\n    }\n  }\n}\n"]}

package/dist/commands/whatsapp/connect.d.ts

@@ -0,0 +1,17 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WhatsappConnect extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        number: 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>;
+    /**
+     * Poll the signup until it goes terminal (active / failed / expired).
+     * Mirrors the numbers-buy hosted-action poll: a human is completing a
+     * browser step (the Facebook sign-in) while we wait.
+     */
+    private pollSignup;
+}

package/dist/commands/whatsapp/connect.js

@@ -0,0 +1,166 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Flags } from "@oclif/core";
+import open from "open";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient, NotFoundError } from "../../lib/api-client.js";
+import { getConfigDir } from "../../lib/config.js";
+import { json, success, warn, error, colors, spinner, isJsonMode, } from "../../lib/output.js";
+import { attachLoginKeypressHandler } from "../../lib/keypress.js";
+const SIGNUP_POLL_INTERVAL = 5000; // 5 seconds
+const SIGNUP_MAX_ATTEMPTS = 240; // ~20 minutes
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Remember the most recent signup so `sendly whatsapp status` works with no
+ * argument. Best effort — the id is also printed, so losing this is harmless.
+ */
+function rememberSignup(id, phoneNumber) {
+    try {
+        fs.writeFileSync(path.join(getConfigDir(), "whatsapp-signup.json"), JSON.stringify({ id, phoneNumber, createdAt: new Date().toISOString() }), { mode: 0o600 });
+    }
+    catch {
+        // non-fatal
+    }
+}
+export default class WhatsappConnect extends AuthenticatedCommand {
+    static description = "Connect one of your numbers to WhatsApp. Prints a secure link a person must open and sign in with Facebook to finish; the command then waits until the sender is active. One-time $19 connection fee — no monthly fee.";
+    static examples = [
+        "<%= config.bin %> whatsapp connect --number +15551234567",
+        "<%= config.bin %> whatsapp connect --number +15551234567 --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        number: Flags.string({
+            char: "n",
+            description: "Number on your workspace to connect (E.164 format)",
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WhatsappConnect);
+        const startSpinner = spinner("Starting WhatsApp connection...");
+        if (!isJsonMode()) {
+            startSpinner.start();
+        }
+        let response;
+        try {
+            response = await apiClient.post("/api/v1/whatsapp/signup", { phoneNumber: flags.number });
+            startSpinner.stop();
+        }
+        catch (err) {
+            startSpinner.stop();
+            if (err instanceof NotFoundError && err.message === "Resource not found") {
+                error("WhatsApp isn't available on your workspace yet.", {
+                    hint: "WhatsApp is rolling out gradually — contact support@sendly.live for early access.",
+                });
+                this.exit(1);
+            }
+            throw err;
+        }
+        rememberSignup(response.id, flags.number);
+        if (isJsonMode()) {
+            // Non-interactive: surface the link so the caller can hand it to a
+            // person, then poll with `sendly whatsapp status <id>`.
+            json(response);
+            return;
+        }
+        console.log();
+        console.log(colors.bold("Finish connecting on the web"));
+        console.log();
+        console.log("Open this link and sign in with Facebook to finish connecting your number to WhatsApp:");
+        console.log(colors.bold(colors.primary(`  ${response.connectUrl}`)));
+        console.log();
+        console.log(colors.dim(`Signup id: ${response.id}`));
+        console.log();
+        try {
+            await open(response.connectUrl);
+            console.log(colors.dim("Browser opened automatically"));
+        }
+        catch {
+            console.log(colors.dim("Please open the URL manually"));
+        }
+        const keypressCleanup = attachLoginKeypressHandler(response.connectUrl);
+        console.log();
+        const final = await this.pollSignup(response.id);
+        keypressCleanup();
+        if (final === "timeout") {
+            warn("We stopped waiting. Finish the Facebook sign-in in your browser, then check `sendly whatsapp status`.");
+            return;
+        }
+        if (final === "gone") {
+            warn("This connection attempt is no longer available. Re-run `sendly whatsapp connect` to start over.");
+            return;
+        }
+        if (final.status === "active") {
+            success("WhatsApp sender connected", {
+                number: final.phoneNumber,
+                "business account": final.businessAccountId ?? "—",
+            });
+            console.log();
+            console.log(colors.dim(`Send with: ${colors.code(`sendly whatsapp send --from ${final.phoneNumber} --to +15551230000 --text "Hello!"`)}`));
+            return;
+        }
+        if (final.status === "expired") {
+            error("The connect link expired before signup finished.", {
+                hint: "Run `sendly whatsapp connect` again to get a fresh link.",
+            });
+            this.exit(1);
+        }
+        // failed
+        error("WhatsApp connection failed.", {
+            ...(final.failureReasons?.length && {
+                reasons: final.failureReasons.join("; "),
+            }),
+            hint: "Re-run `sendly whatsapp connect` to try again.",
+        });
+        this.exit(1);
+    }
+    /**
+     * Poll the signup until it goes terminal (active / failed / expired).
+     * Mirrors the numbers-buy hosted-action poll: a human is completing a
+     * browser step (the Facebook sign-in) while we wait.
+     */
+    async pollSignup(id) {
+        const spin = spinner("Waiting for you to finish signing in with Facebook...");
+        spin.start();
+        let attempts = 0;
+        while (attempts < SIGNUP_MAX_ATTEMPTS) {
+            await sleep(SIGNUP_POLL_INTERVAL);
+            attempts++;
+            let status;
+            try {
+                status = await apiClient.get(`/api/v1/whatsapp/signup/${encodeURIComponent(id)}`);
+            }
+            catch (err) {
+                if (err instanceof NotFoundError) {
+                    spin.fail("Connection attempt no longer exists");
+                    return "gone";
+                }
+                // Transient error — keep polling.
+                continue;
+            }
+            if (status.status === "registering") {
+                spin.text =
+                    "Facebook sign-in complete — activating your number on WhatsApp...";
+            }
+            if (status.status === "active") {
+                spin.succeed("Connected");
+                return status;
+            }
+            if (status.status === "failed") {
+                spin.fail("Connection failed");
+                return status;
+            }
+            if (status.status === "expired") {
+                spin.fail("Connect link expired");
+                return status;
+            }
+            // initiated / registering — keep polling
+        }
+        spin.stop();
+        return "timeout";
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connect.js","sourceRoot":"","sources":["../../../src/commands/whatsapp/connect.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"node:fs\";\nimport path from \"node:path\";\nimport { Flags } from \"@oclif/core\";\nimport open from \"open\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient, NotFoundError } from \"../../lib/api-client.js\";\nimport { getConfigDir } from \"../../lib/config.js\";\nimport {\n  json,\n  success,\n  info,\n  warn,\n  error,\n  colors,\n  spinner,\n  isJsonMode,\n} from \"../../lib/output.js\";\nimport { attachLoginKeypressHandler } from \"../../lib/keypress.js\";\n\ninterface SignupStartResponse {\n  id: string;\n  connectUrl: string;\n  status: string;\n}\n\ninterface SignupStatusResponse {\n  id: string;\n  status: string;\n  phoneNumber: string;\n  businessAccountId: string | null;\n  failureReasons: string[] | null;\n  updatedAt: string;\n}\n\nconst SIGNUP_POLL_INTERVAL = 5000; // 5 seconds\nconst SIGNUP_MAX_ATTEMPTS = 240; // ~20 minutes\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Remember the most recent signup so `sendly whatsapp status` works with no\n * argument. Best effort — the id is also printed, so losing this is harmless.\n */\nfunction rememberSignup(id: string, phoneNumber: string): void {\n  try {\n    fs.writeFileSync(\n      path.join(getConfigDir(), \"whatsapp-signup.json\"),\n      JSON.stringify({ id, phoneNumber, createdAt: new Date().toISOString() }),\n      { mode: 0o600 },\n    );\n  } catch {\n    // non-fatal\n  }\n}\n\nexport default class WhatsappConnect extends AuthenticatedCommand {\n  static description =\n    \"Connect one of your numbers to WhatsApp. Prints a secure link a person must open and sign in with Facebook to finish; the command then waits until the sender is active. One-time $19 connection fee — no monthly fee.\";\n\n  static examples = [\n    \"<%= config.bin %> whatsapp connect --number +15551234567\",\n    \"<%= config.bin %> whatsapp connect --number +15551234567 --json\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    number: Flags.string({\n      char: \"n\",\n      description: \"Number on your workspace to connect (E.164 format)\",\n      required: true,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(WhatsappConnect);\n\n    const startSpinner = spinner(\"Starting WhatsApp connection...\");\n    if (!isJsonMode()) {\n      startSpinner.start();\n    }\n\n    let response: SignupStartResponse;\n    try {\n      response = await apiClient.post<SignupStartResponse>(\n        \"/api/v1/whatsapp/signup\",\n        { phoneNumber: flags.number },\n      );\n      startSpinner.stop();\n    } catch (err: any) {\n      startSpinner.stop();\n      if (err instanceof NotFoundError && err.message === \"Resource not found\") {\n        error(\"WhatsApp isn't available on your workspace yet.\", {\n          hint: \"WhatsApp is rolling out gradually — contact support@sendly.live for early access.\",\n        });\n        this.exit(1);\n      }\n      throw err;\n    }\n\n    rememberSignup(response.id, flags.number);\n\n    if (isJsonMode()) {\n      // Non-interactive: surface the link so the caller can hand it to a\n      // person, then poll with `sendly whatsapp status <id>`.\n      json(response);\n      return;\n    }\n\n    console.log();\n    console.log(colors.bold(\"Finish connecting on the web\"));\n    console.log();\n    console.log(\n      \"Open this link and sign in with Facebook to finish connecting your number to WhatsApp:\",\n    );\n    console.log(colors.bold(colors.primary(`  ${response.connectUrl}`)));\n    console.log();\n    console.log(colors.dim(`Signup id: ${response.id}`));\n    console.log();\n\n    try {\n      await open(response.connectUrl);\n      console.log(colors.dim(\"Browser opened automatically\"));\n    } catch {\n      console.log(colors.dim(\"Please open the URL manually\"));\n    }\n\n    const keypressCleanup = attachLoginKeypressHandler(response.connectUrl);\n    console.log();\n\n    const final = await this.pollSignup(response.id);\n    keypressCleanup();\n\n    if (final === \"timeout\") {\n      warn(\n        \"We stopped waiting. Finish the Facebook sign-in in your browser, then check `sendly whatsapp status`.\",\n      );\n      return;\n    }\n\n    if (final === \"gone\") {\n      warn(\n        \"This connection attempt is no longer available. Re-run `sendly whatsapp connect` to start over.\",\n      );\n      return;\n    }\n\n    if (final.status === \"active\") {\n      success(\"WhatsApp sender connected\", {\n        number: final.phoneNumber,\n        \"business account\": final.businessAccountId ?? \"—\",\n      });\n      console.log();\n      console.log(\n        colors.dim(\n          `Send with: ${colors.code(`sendly whatsapp send --from ${final.phoneNumber} --to +15551230000 --text \"Hello!\"`)}`,\n        ),\n      );\n      return;\n    }\n\n    if (final.status === \"expired\") {\n      error(\"The connect link expired before signup finished.\", {\n        hint: \"Run `sendly whatsapp connect` again to get a fresh link.\",\n      });\n      this.exit(1);\n    }\n\n    // failed\n    error(\"WhatsApp connection failed.\", {\n      ...(final.failureReasons?.length && {\n        reasons: final.failureReasons.join(\"; \"),\n      }),\n      hint: \"Re-run `sendly whatsapp connect` to try again.\",\n    });\n    this.exit(1);\n  }\n\n  /**\n   * Poll the signup until it goes terminal (active / failed / expired).\n   * Mirrors the numbers-buy hosted-action poll: a human is completing a\n   * browser step (the Facebook sign-in) while we wait.\n   */\n  private async pollSignup(\n    id: string,\n  ): Promise<SignupStatusResponse | \"timeout\" | \"gone\"> {\n    const spin = spinner(\"Waiting for you to finish signing in with Facebook...\");\n    spin.start();\n\n    let attempts = 0;\n    while (attempts < SIGNUP_MAX_ATTEMPTS) {\n      await sleep(SIGNUP_POLL_INTERVAL);\n      attempts++;\n\n      let status: SignupStatusResponse;\n      try {\n        status = await apiClient.get<SignupStatusResponse>(\n          `/api/v1/whatsapp/signup/${encodeURIComponent(id)}`,\n        );\n      } catch (err) {\n        if (err instanceof NotFoundError) {\n          spin.fail(\"Connection attempt no longer exists\");\n          return \"gone\";\n        }\n        // Transient error — keep polling.\n        continue;\n      }\n\n      if (status.status === \"registering\") {\n        spin.text =\n          \"Facebook sign-in complete — activating your number on WhatsApp...\";\n      }\n\n      if (status.status === \"active\") {\n        spin.succeed(\"Connected\");\n        return status;\n      }\n      if (status.status === \"failed\") {\n        spin.fail(\"Connection failed\");\n        return status;\n      }\n      if (status.status === \"expired\") {\n        spin.fail(\"Connect link expired\");\n        return status;\n      }\n      // initiated / registering — keep polling\n    }\n\n    spin.stop();\n    return \"timeout\";\n  }\n}\n"]}

package/dist/commands/whatsapp/profile/get.d.ts

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

@@ -0,0 +1,67 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient, NotFoundError } from "../../../lib/api-client.js";
+import { success, error, json, colors, spinner, isJsonMode, } from "../../../lib/output.js";
+export default class WhatsappProfileGet extends AuthenticatedCommand {
+    static description = "Show the WhatsApp business profile customers see for one of your connected numbers";
+    static examples = [
+        "<%= config.bin %> whatsapp profile get +15551234567",
+        "<%= config.bin %> whatsapp profile get +15551234567 --json",
+    ];
+    static args = {
+        number: Args.string({
+            description: "WhatsApp-connected sender number (E.164 format)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(WhatsappProfileGet);
+        const profileSpinner = spinner("Fetching WhatsApp profile...");
+        if (!isJsonMode()) {
+            profileSpinner.start();
+        }
+        let response;
+        try {
+            response = await apiClient.get(`/api/v1/whatsapp/senders/${encodeURIComponent(args.number)}/profile`);
+            profileSpinner.stop();
+        }
+        catch (err) {
+            profileSpinner.stop();
+            if (err instanceof NotFoundError &&
+                err.message.includes("connected to WhatsApp")) {
+                error(err.message, {
+                    hint: `Connect it first: sendly whatsapp connect --number ${args.number}`,
+                });
+                this.exit(1);
+            }
+            if (err instanceof NotFoundError) {
+                error("WhatsApp isn't available on your workspace yet.", {
+                    hint: "WhatsApp is rolling out gradually — contact support@sendly.live for early access.",
+                });
+                this.exit(1);
+            }
+            throw err;
+        }
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success("WhatsApp sender profile", {
+            Number: response.phoneNumber,
+            "Display name": response.displayName ?? colors.dim("—"),
+            About: response.about ?? colors.dim("—"),
+            Description: response.description ?? colors.dim("—"),
+            Category: response.category ?? colors.dim("—"),
+            Email: response.email ?? colors.dim("—"),
+            Website: response.website ?? colors.dim("—"),
+            Address: response.address ?? colors.dim("—"),
+            Photo: response.profilePhotoUrl ?? colors.dim("—"),
+        });
+        console.log();
+        console.log(colors.dim(`Update it with: ${colors.code(`sendly whatsapp profile update ${response.phoneNumber} --about "..."`)}`));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/whatsapp/profile/update.d.ts

@@ -0,0 +1,20 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class WhatsappProfileUpdate extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        number: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        "display-name": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        about: 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>;
+        category: 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>;
+        website: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        address: 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/whatsapp/profile/update.js

@@ -0,0 +1,109 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient, NotFoundError } from "../../../lib/api-client.js";
+import { success, error, json, colors, spinner, isJsonMode, } from "../../../lib/output.js";
+export default class WhatsappProfileUpdate extends AuthenticatedCommand {
+    static description = "Update the WhatsApp business profile customers see for one of your connected numbers";
+    static examples = [
+        '<%= config.bin %> whatsapp profile update +15551234567 --about "Family-run bakery in Austin"',
+        '<%= config.bin %> whatsapp profile update +15551234567 --website https://example.com --email hello@example.com',
+    ];
+    static args = {
+        number: Args.string({
+            description: "WhatsApp-connected sender number (E.164 format)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        "display-name": Flags.string({
+            description: "Business name shown to customers",
+        }),
+        about: Flags.string({
+            description: "Short about line (max 139 characters)",
+        }),
+        description: Flags.string({
+            description: "Longer business description (max 512 characters)",
+        }),
+        category: Flags.string({
+            description: "Business category",
+        }),
+        email: Flags.string({
+            description: "Contact email shown on the profile",
+        }),
+        website: Flags.string({
+            description: "Website URL shown on the profile",
+        }),
+        address: Flags.string({
+            description: "Business address shown on the profile",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WhatsappProfileUpdate);
+        if (flags["display-name"] === undefined &&
+            flags.about === undefined &&
+            flags.description === undefined &&
+            flags.category === undefined &&
+            flags.email === undefined &&
+            flags.website === undefined &&
+            flags.address === undefined) {
+            error("Nothing to update", {
+                hint: "Pass at least one of --display-name, --about, --description, --category, --email, --website, --address",
+            });
+            this.exit(1);
+        }
+        const updateSpinner = spinner("Updating WhatsApp profile...");
+        if (!isJsonMode()) {
+            updateSpinner.start();
+        }
+        try {
+            const response = await apiClient.patch(`/api/v1/whatsapp/senders/${encodeURIComponent(args.number)}/profile`, {
+                ...(flags["display-name"] !== undefined && {
+                    displayName: flags["display-name"],
+                }),
+                ...(flags.about !== undefined && { about: flags.about }),
+                ...(flags.description !== undefined && {
+                    description: flags.description,
+                }),
+                ...(flags.category !== undefined && { category: flags.category }),
+                ...(flags.email !== undefined && { email: flags.email }),
+                ...(flags.website !== undefined && { website: flags.website }),
+                ...(flags.address !== undefined && { address: flags.address }),
+            });
+            updateSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("WhatsApp sender profile updated", {
+                Number: response.phoneNumber,
+                "Display name": response.displayName ?? colors.dim("—"),
+                About: response.about ?? colors.dim("—"),
+                Description: response.description ?? colors.dim("—"),
+                Category: response.category ?? colors.dim("—"),
+                Email: response.email ?? colors.dim("—"),
+                Website: response.website ?? colors.dim("—"),
+                Address: response.address ?? colors.dim("—"),
+            });
+        }
+        catch (err) {
+            updateSpinner.stop();
+            if (err instanceof NotFoundError &&
+                err.message.includes("connected to WhatsApp")) {
+                error(err.message, {
+                    hint: `Connect it first: sendly whatsapp connect --number ${args.number}`,
+                });
+            }
+            else if (err instanceof NotFoundError) {
+                error("WhatsApp isn't available on your workspace yet.", {
+                    hint: "WhatsApp is rolling out gradually — contact support@sendly.live for early access.",
+                });
+            }
+            else {
+                throw err;
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"update.js","sourceRoot":"","sources":["../../../../src/commands/whatsapp/profile/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EACL,OAAO,EACP,KAAK,EACL,IAAI,EACJ,MAAM,EACN,OAAO,EACP,UAAU,GACX,MAAM,wBAAwB,CAAC;AAchC,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,oBAAoB;IACrE,MAAM,CAAC,WAAW,GAChB,sFAAsF,CAAC;IAEzF,MAAM,CAAC,QAAQ,GAAG;QAChB,8FAA8F;QAC9F,gHAAgH;KACjH,CAAC;IAEF,MAAM,CAAC,IAAI,GAAG;QACZ,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC;YAClB,WAAW,EAAE,iDAAiD;YAC9D,QAAQ,EAAE,IAAI;SACf,CAAC;KACH,CAAC;IAEF,MAAM,CAAC,KAAK,GAAG;QACb,GAAG,oBAAoB,CAAC,SAAS;QACjC,cAAc,EAAE,KAAK,CAAC,MAAM,CAAC;YAC3B,WAAW,EAAE,kCAAkC;SAChD,CAAC;QACF,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC;YAClB,WAAW,EAAE,uCAAuC;SACrD,CAAC;QACF,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC;YACxB,WAAW,EAAE,kDAAkD;SAChE,CAAC;QACF,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC;YACrB,WAAW,EAAE,mBAAmB;SACjC,CAAC;QACF,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC;YAClB,WAAW,EAAE,oCAAoC;SAClD,CAAC;QACF,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC;YACpB,WAAW,EAAE,kCAAkC;SAChD,CAAC;QACF,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC;YACpB,WAAW,EAAE,uCAAuC;SACrD,CAAC;KACH,CAAC;IAEF,KAAK,CAAC,GAAG;QACP,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;QAEhE,IACE,KAAK,CAAC,cAAc,CAAC,KAAK,SAAS;YACnC,KAAK,CAAC,KAAK,KAAK,SAAS;YACzB,KAAK,CAAC,WAAW,KAAK,SAAS;YAC/B,KAAK,CAAC,QAAQ,KAAK,SAAS;YAC5B,KAAK,CAAC,KAAK,KAAK,SAAS;YACzB,KAAK,CAAC,OAAO,KAAK,SAAS;YAC3B,KAAK,CAAC,OAAO,KAAK,SAAS,EAC3B,CAAC;YACD,KAAK,CAAC,mBAAmB,EAAE;gBACzB,IAAI,EAAE,wGAAwG;aAC/G,CAAC,CAAC;YACH,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;QAED,MAAM,aAAa,GAAG,OAAO,CAAC,8BAA8B,CAAC,CAAC;QAC9D,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;YAClB,aAAa,CAAC,KAAK,EAAE,CAAC;QACxB,CAAC;QAED,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,KAAK,CACpC,4BAA4B,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EACrE;gBACE,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC,KAAK,SAAS,IAAI;oBACzC,WAAW,EAAE,KAAK,CAAC,cAAc,CAAC;iBACnC,CAAC;gBACF,GAAG,CAAC,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;gBACxD,GAAG,CAAC,KAAK,CAAC,WAAW,KAAK,SAAS,IAAI;oBACrC,WAAW,EAAE,KAAK,CAAC,WAAW;iBAC/B,CAAC;gBACF,GAAG,CAAC,KAAK,CAAC,QAAQ,KAAK,SAAS,IAAI,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC;gBACjE,GAAG,CAAC,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;gBACxD,GAAG,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;gBAC9D,GAAG,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;aAC/D,CACF,CAAC;YAEF,aAAa,CAAC,IAAI,EAAE,CAAC;YAErB,IAAI,UAAU,EAAE,EAAE,CAAC;gBACjB,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACf,OAAO;YACT,CAAC;YAED,OAAO,CAAC,iCAAiC,EAAE;gBACzC,MAAM,EAAE,QAAQ,CAAC,WAAW;gBAC5B,cAAc,EAAE,QAAQ,CAAC,WAAW,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;gBACvD,KAAK,EAAE,QAAQ,CAAC,KAAK,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;gBACxC,WAAW,EAAE,QAAQ,CAAC,WAAW,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;gBACpD,QAAQ,EAAE,QAAQ,CAAC,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;gBAC9C,KAAK,EAAE,QAAQ,CAAC,KAAK,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;gBACxC,OAAO,EAAE,QAAQ,CAAC,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;gBAC5C,OAAO,EAAE,QAAQ,CAAC,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;aAC7C,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,GAAQ,EAAE,CAAC;YAClB,aAAa,CAAC,IAAI,EAAE,CAAC;YAErB,IACE,GAAG,YAAY,aAAa;gBAC5B,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAC,EAC7C,CAAC;gBACD,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE;oBACjB,IAAI,EAAE,sDAAsD,IAAI,CAAC,MAAM,EAAE;iBAC1E,CAAC,CAAC;YACL,CAAC;iBAAM,IAAI,GAAG,YAAY,aAAa,EAAE,CAAC;gBACxC,KAAK,CAAC,iDAAiD,EAAE;oBACvD,IAAI,EAAE,mFAAmF;iBAC1F,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,MAAM,GAAG,CAAC;YACZ,CAAC;YACD,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf,CAAC;IACH,CAAC","sourcesContent":["import { Args, Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../../lib/base-command.js\";\nimport { apiClient, NotFoundError } from \"../../../lib/api-client.js\";\nimport {\n  success,\n  error,\n  json,\n  colors,\n  spinner,\n  isJsonMode,\n} from \"../../../lib/output.js\";\n\ninterface WhatsappSenderProfile {\n  phoneNumber: string;\n  displayName: string | null;\n  profilePhotoUrl: string | null;\n  category: string | null;\n  about: string | null;\n  description: string | null;\n  email: string | null;\n  website: string | null;\n  address: string | null;\n}\n\nexport default class WhatsappProfileUpdate extends AuthenticatedCommand {\n  static description =\n    \"Update the WhatsApp business profile customers see for one of your connected numbers\";\n\n  static examples = [\n    '<%= config.bin %> whatsapp profile update +15551234567 --about \"Family-run bakery in Austin\"',\n    '<%= config.bin %> whatsapp profile update +15551234567 --website https://example.com --email hello@example.com',\n  ];\n\n  static args = {\n    number: Args.string({\n      description: \"WhatsApp-connected sender number (E.164 format)\",\n      required: true,\n    }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    \"display-name\": Flags.string({\n      description: \"Business name shown to customers\",\n    }),\n    about: Flags.string({\n      description: \"Short about line (max 139 characters)\",\n    }),\n    description: Flags.string({\n      description: \"Longer business description (max 512 characters)\",\n    }),\n    category: Flags.string({\n      description: \"Business category\",\n    }),\n    email: Flags.string({\n      description: \"Contact email shown on the profile\",\n    }),\n    website: Flags.string({\n      description: \"Website URL shown on the profile\",\n    }),\n    address: Flags.string({\n      description: \"Business address shown on the profile\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { args, flags } = await this.parse(WhatsappProfileUpdate);\n\n    if (\n      flags[\"display-name\"] === undefined &&\n      flags.about === undefined &&\n      flags.description === undefined &&\n      flags.category === undefined &&\n      flags.email === undefined &&\n      flags.website === undefined &&\n      flags.address === undefined\n    ) {\n      error(\"Nothing to update\", {\n        hint: \"Pass at least one of --display-name, --about, --description, --category, --email, --website, --address\",\n      });\n      this.exit(1);\n    }\n\n    const updateSpinner = spinner(\"Updating WhatsApp profile...\");\n    if (!isJsonMode()) {\n      updateSpinner.start();\n    }\n\n    try {\n      const response = await apiClient.patch<WhatsappSenderProfile>(\n        `/api/v1/whatsapp/senders/${encodeURIComponent(args.number)}/profile`,\n        {\n          ...(flags[\"display-name\"] !== undefined && {\n            displayName: flags[\"display-name\"],\n          }),\n          ...(flags.about !== undefined && { about: flags.about }),\n          ...(flags.description !== undefined && {\n            description: flags.description,\n          }),\n          ...(flags.category !== undefined && { category: flags.category }),\n          ...(flags.email !== undefined && { email: flags.email }),\n          ...(flags.website !== undefined && { website: flags.website }),\n          ...(flags.address !== undefined && { address: flags.address }),\n        },\n      );\n\n      updateSpinner.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      success(\"WhatsApp sender profile updated\", {\n        Number: response.phoneNumber,\n        \"Display name\": response.displayName ?? colors.dim(\"—\"),\n        About: response.about ?? colors.dim(\"—\"),\n        Description: response.description ?? colors.dim(\"—\"),\n        Category: response.category ?? colors.dim(\"—\"),\n        Email: response.email ?? colors.dim(\"—\"),\n        Website: response.website ?? colors.dim(\"—\"),\n        Address: response.address ?? colors.dim(\"—\"),\n      });\n    } catch (err: any) {\n      updateSpinner.stop();\n\n      if (\n        err instanceof NotFoundError &&\n        err.message.includes(\"connected to WhatsApp\")\n      ) {\n        error(err.message, {\n          hint: `Connect it first: sendly whatsapp connect --number ${args.number}`,\n        });\n      } else if (err instanceof NotFoundError) {\n        error(\"WhatsApp isn't available on your workspace yet.\", {\n          hint: \"WhatsApp is rolling out gradually — contact support@sendly.live for early access.\",\n        });\n      } else {\n        throw err;\n      }\n      this.exit(1);\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,17 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WhatsappSend extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        to: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        from: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, 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>;
+        template: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        language: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        var: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "idempotency-key": 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>;
+}