@sendly/cli 3.35.0 → 3.36.0

package/dist/commands/enterprise/verification/submit.js

@@ -0,0 +1,212 @@
+import { Args, Flags } from "@oclif/core";
+import * as fs from "node:fs";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, json, isJsonMode, spinner, colors, keyValue, } from "../../../lib/output.js";
+export default class EnterpriseVerificationSubmit extends AuthenticatedCommand {
+    static description = "Submit (or resubmit) a verification for an enterprise workspace. Partial-update friendly: only the fields you pass are changed.";
+    static examples = [
+        '<%= config.bin %> enterprise verification submit org_abc123 --data ./verification.json',
+        '<%= config.bin %> enterprise verification submit org_abc123 --business-name "Acme LLC" --website https://acme.com --use-case "Insurance Services"',
+        '<%= config.bin %> enterprise verification submit org_abc123 --contact-email new@acme.com',
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        data: Flags.string({
+            char: "d",
+            description: "Path to a JSON file containing the verification payload",
+        }),
+        "business-name": Flags.string({
+            description: "Legal business name",
+        }),
+        "doing-business-as": Flags.string({
+            description: "DBA / trading name",
+        }),
+        website: Flags.string({
+            description: "Business website URL",
+        }),
+        "entity-type": Flags.string({
+            description: "Entity type (SOLE_PROPRIETOR | PRIVATE_PROFIT | PUBLIC_PROFIT | NON_PROFIT | GOVERNMENT)",
+            options: [
+                "SOLE_PROPRIETOR",
+                "PRIVATE_PROFIT",
+                "PUBLIC_PROFIT",
+                "NON_PROFIT",
+                "GOVERNMENT",
+            ],
+        }),
+        "address-street": Flags.string({ description: "Street address" }),
+        "address-city": Flags.string({ description: "City" }),
+        "address-state": Flags.string({ description: "State / region" }),
+        "address-zip": Flags.string({ description: "ZIP / postal code" }),
+        "address-country": Flags.string({ description: "Country code (e.g. US)" }),
+        "contact-first-name": Flags.string({ description: "Contact first name" }),
+        "contact-last-name": Flags.string({ description: "Contact last name" }),
+        "contact-email": Flags.string({ description: "Contact email address" }),
+        "contact-phone": Flags.string({
+            description: "Contact phone number (E.164)",
+        }),
+        brn: Flags.string({
+            description: "Business registration number (omit for sole proprietors; server will strip)",
+        }),
+        "brn-type": Flags.string({
+            description: "BRN type (EIN | SSN | DUNS | CRA | VAT | LEI | OTHER)",
+            options: ["EIN", "SSN", "DUNS", "CRA", "VAT", "LEI", "OTHER"],
+        }),
+        "brn-country": Flags.string({
+            description: "BRN country code (e.g. US)",
+        }),
+        "use-case": Flags.string({
+            description: "Use case (Telnyx use-case enum value)",
+        }),
+        "use-case-summary": Flags.string({
+            description: "Use case summary",
+        }),
+        "sample-messages": Flags.string({
+            description: "Sample messages",
+        }),
+        "opt-in-workflow": Flags.string({
+            description: "Opt-in workflow description",
+        }),
+        "opt-in-image-urls": Flags.string({
+            description: "Opt-in image URLs (newline or comma separated)",
+        }),
+        "monthly-volume": Flags.string({
+            description: "Estimated monthly message volume",
+        }),
+        "additional-information": Flags.string({
+            description: "Additional information for the carrier",
+        }),
+        "age-gated-content": Flags.boolean({
+            description: "Mark traffic as age-gated content",
+            allowNo: true,
+        }),
+        "isv-reseller": Flags.string({
+            description: "ISV / reseller name (if applicable)",
+        }),
+        "privacy-url": Flags.string({ description: "Privacy policy URL" }),
+        "terms-url": Flags.string({ description: "Terms of service URL" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnterpriseVerificationSubmit);
+        await submitVerification(args.workspaceId, flags, "Submitting verification...");
+    }
+}
+export async function submitVerification(workspaceId, flags, spinnerText) {
+    const payload = buildPayload(flags);
+    if (Object.keys(payload).length === 0) {
+        throw new Error("No fields provided. Pass --data <file> or one or more --* field flags.");
+    }
+    const spin = spinner(spinnerText);
+    spin.start();
+    let response;
+    try {
+        response = await apiClient.post(`/api/v1/enterprise/workspaces/${encodeURIComponent(workspaceId)}/verification/submit`, payload);
+    }
+    catch (err) {
+        spin.fail("Verification submit failed");
+        throw err;
+    }
+    spin.succeed("Verification submitted");
+    if (isJsonMode()) {
+        json(response);
+        return;
+    }
+    const status = response.status ||
+        response.verification?.status ||
+        "submitted";
+    const id = response.id || response.verification?.id;
+    const details = {
+        Workspace: workspaceId,
+        Status: colors.primary(status),
+    };
+    if (id)
+        details["Verification ID"] = id;
+    success("Verification submitted", details);
+    if (Object.keys(response).length > 0 && !id) {
+        keyValue(response);
+    }
+}
+export function buildPayload(flags) {
+    let payload = {};
+    const dataFlag = flags.data;
+    if (dataFlag) {
+        if (!fs.existsSync(dataFlag)) {
+            throw new Error(`File not found: ${dataFlag}`);
+        }
+        const content = fs.readFileSync(dataFlag, "utf-8");
+        try {
+            payload = JSON.parse(content);
+        }
+        catch {
+            throw new Error(`Invalid JSON in ${dataFlag}. Expected a verification payload object.`);
+        }
+    }
+    const setIf = (key, value) => {
+        if (value !== undefined) {
+            payload[key] = value;
+        }
+    };
+    setIf("businessName", flags["business-name"]);
+    setIf("doingBusinessAs", flags["doing-business-as"]);
+    setIf("website", flags.website);
+    setIf("entityType", flags["entity-type"]);
+    setIf("brn", flags.brn);
+    setIf("brnType", flags["brn-type"]);
+    setIf("brnCountry", flags["brn-country"]);
+    setIf("useCase", flags["use-case"]);
+    setIf("useCaseSummary", flags["use-case-summary"]);
+    setIf("sampleMessages", flags["sample-messages"]);
+    setIf("optInWorkflow", flags["opt-in-workflow"]);
+    setIf("optInImageUrls", flags["opt-in-image-urls"]);
+    setIf("monthlyVolume", flags["monthly-volume"]);
+    setIf("additionalInformation", flags["additional-information"]);
+    setIf("isvReseller", flags["isv-reseller"]);
+    setIf("privacyUrl", flags["privacy-url"]);
+    setIf("termsUrl", flags["terms-url"]);
+    if (flags["age-gated-content"] !== undefined) {
+        payload.ageGatedContent = flags["age-gated-content"];
+    }
+    const address = {
+        ...(payload.address || {}),
+        ...stripUndefined({
+            street: flags["address-street"],
+            city: flags["address-city"],
+            state: flags["address-state"],
+            zip: flags["address-zip"],
+            country: flags["address-country"],
+        }),
+    };
+    if (Object.keys(address).length > 0) {
+        payload.address = address;
+    }
+    const contact = {
+        ...(payload.contact || {}),
+        ...stripUndefined({
+            firstName: flags["contact-first-name"],
+            lastName: flags["contact-last-name"],
+            email: flags["contact-email"],
+            phone: flags["contact-phone"],
+        }),
+    };
+    if (Object.keys(contact).length > 0) {
+        payload.contact = contact;
+    }
+    return payload;
+}
+function stripUndefined(obj) {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        if (v !== undefined) {
+            out[k] = v;
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"submit.js","sourceRoot":"","sources":["../../../../src/commands/enterprise/verification/submit.ts"],"names":[],"mappings":"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","sourcesContent":["import { Args, Flags } from \"@oclif/core\";\nimport * as fs from \"node:fs\";\nimport { AuthenticatedCommand } from \"../../../lib/base-command.js\";\nimport { apiClient } from \"../../../lib/api-client.js\";\nimport {\n  success,\n  json,\n  isJsonMode,\n  spinner,\n  colors,\n  keyValue,\n} from \"../../../lib/output.js\";\n\ninterface VerificationSubmitInput {\n  businessName?: string;\n  doingBusinessAs?: string;\n  website?: string;\n  address?: {\n    street?: string;\n    city?: string;\n    state?: string;\n    zip?: string;\n    country?: string;\n  };\n  contact?: {\n    firstName?: string;\n    lastName?: string;\n    email?: string;\n    phone?: string;\n  };\n  brn?: string | null;\n  brnType?: string | null;\n  brnCountry?: string | null;\n  entityType?: string;\n  useCase?: string;\n  useCaseSummary?: string;\n  sampleMessages?: string;\n  optInWorkflow?: string;\n  optInImageUrls?: string;\n  monthlyVolume?: string;\n  additionalInformation?: string;\n  ageGatedContent?: boolean;\n  isvReseller?: string;\n  privacyUrl?: string;\n  termsUrl?: string;\n}\n\ninterface SubmitResponse {\n  status?: string;\n  verification?: { id?: string; status?: string };\n  id?: string;\n  [key: string]: unknown;\n}\n\nexport default class EnterpriseVerificationSubmit extends AuthenticatedCommand {\n  static description =\n    \"Submit (or resubmit) a verification for an enterprise workspace. Partial-update friendly: only the fields you pass are changed.\";\n\n  static examples = [\n    '<%= config.bin %> enterprise verification submit org_abc123 --data ./verification.json',\n    '<%= config.bin %> enterprise verification submit org_abc123 --business-name \"Acme LLC\" --website https://acme.com --use-case \"Insurance Services\"',\n    '<%= config.bin %> enterprise verification submit org_abc123 --contact-email new@acme.com',\n  ];\n\n  static args = {\n    workspaceId: Args.string({\n      description: \"Workspace ID\",\n      required: true,\n    }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    data: Flags.string({\n      char: \"d\",\n      description: \"Path to a JSON file containing the verification payload\",\n    }),\n    \"business-name\": Flags.string({\n      description: \"Legal business name\",\n    }),\n    \"doing-business-as\": Flags.string({\n      description: \"DBA / trading name\",\n    }),\n    website: Flags.string({\n      description: \"Business website URL\",\n    }),\n    \"entity-type\": Flags.string({\n      description:\n        \"Entity type (SOLE_PROPRIETOR | PRIVATE_PROFIT | PUBLIC_PROFIT | NON_PROFIT | GOVERNMENT)\",\n      options: [\n        \"SOLE_PROPRIETOR\",\n        \"PRIVATE_PROFIT\",\n        \"PUBLIC_PROFIT\",\n        \"NON_PROFIT\",\n        \"GOVERNMENT\",\n      ],\n    }),\n    \"address-street\": Flags.string({ description: \"Street address\" }),\n    \"address-city\": Flags.string({ description: \"City\" }),\n    \"address-state\": Flags.string({ description: \"State / region\" }),\n    \"address-zip\": Flags.string({ description: \"ZIP / postal code\" }),\n    \"address-country\": Flags.string({ description: \"Country code (e.g. US)\" }),\n    \"contact-first-name\": Flags.string({ description: \"Contact first name\" }),\n    \"contact-last-name\": Flags.string({ description: \"Contact last name\" }),\n    \"contact-email\": Flags.string({ description: \"Contact email address\" }),\n    \"contact-phone\": Flags.string({\n      description: \"Contact phone number (E.164)\",\n    }),\n    brn: Flags.string({\n      description:\n        \"Business registration number (omit for sole proprietors; server will strip)\",\n    }),\n    \"brn-type\": Flags.string({\n      description: \"BRN type (EIN | SSN | DUNS | CRA | VAT | LEI | OTHER)\",\n      options: [\"EIN\", \"SSN\", \"DUNS\", \"CRA\", \"VAT\", \"LEI\", \"OTHER\"],\n    }),\n    \"brn-country\": Flags.string({\n      description: \"BRN country code (e.g. US)\",\n    }),\n    \"use-case\": Flags.string({\n      description: \"Use case (Telnyx use-case enum value)\",\n    }),\n    \"use-case-summary\": Flags.string({\n      description: \"Use case summary\",\n    }),\n    \"sample-messages\": Flags.string({\n      description: \"Sample messages\",\n    }),\n    \"opt-in-workflow\": Flags.string({\n      description: \"Opt-in workflow description\",\n    }),\n    \"opt-in-image-urls\": Flags.string({\n      description: \"Opt-in image URLs (newline or comma separated)\",\n    }),\n    \"monthly-volume\": Flags.string({\n      description: \"Estimated monthly message volume\",\n    }),\n    \"additional-information\": Flags.string({\n      description: \"Additional information for the carrier\",\n    }),\n    \"age-gated-content\": Flags.boolean({\n      description: \"Mark traffic as age-gated content\",\n      allowNo: true,\n    }),\n    \"isv-reseller\": Flags.string({\n      description: \"ISV / reseller name (if applicable)\",\n    }),\n    \"privacy-url\": Flags.string({ description: \"Privacy policy URL\" }),\n    \"terms-url\": Flags.string({ description: \"Terms of service URL\" }),\n  };\n\n  async run(): Promise<void> {\n    const { args, flags } = await this.parse(EnterpriseVerificationSubmit);\n    await submitVerification(args.workspaceId, flags, \"Submitting verification...\");\n  }\n}\n\nexport async function submitVerification(\n  workspaceId: string,\n  flags: Record<string, unknown>,\n  spinnerText: string,\n): Promise<void> {\n  const payload = buildPayload(flags);\n\n  if (Object.keys(payload).length === 0) {\n    throw new Error(\n      \"No fields provided. Pass --data <file> or one or more --* field flags.\",\n    );\n  }\n\n  const spin = spinner(spinnerText);\n  spin.start();\n\n  let response: SubmitResponse;\n  try {\n    response = await apiClient.post<SubmitResponse>(\n      `/api/v1/enterprise/workspaces/${encodeURIComponent(workspaceId)}/verification/submit`,\n      payload as unknown as Record<string, unknown>,\n    );\n  } catch (err) {\n    spin.fail(\"Verification submit failed\");\n    throw err;\n  }\n\n  spin.succeed(\"Verification submitted\");\n\n  if (isJsonMode()) {\n    json(response);\n    return;\n  }\n\n  const status =\n    response.status ||\n    response.verification?.status ||\n    \"submitted\";\n  const id = response.id || response.verification?.id;\n\n  const details: Record<string, string> = {\n    Workspace: workspaceId,\n    Status: colors.primary(status),\n  };\n  if (id) details[\"Verification ID\"] = id;\n\n  success(\"Verification submitted\", details);\n\n  if (Object.keys(response).length > 0 && !id) {\n    keyValue(response as Record<string, unknown>);\n  }\n}\n\nexport function buildPayload(\n  flags: Record<string, unknown>,\n): VerificationSubmitInput {\n  let payload: VerificationSubmitInput = {};\n\n  const dataFlag = flags.data as string | undefined;\n  if (dataFlag) {\n    if (!fs.existsSync(dataFlag)) {\n      throw new Error(`File not found: ${dataFlag}`);\n    }\n    const content = fs.readFileSync(dataFlag, \"utf-8\");\n    try {\n      payload = JSON.parse(content) as VerificationSubmitInput;\n    } catch {\n      throw new Error(\n        `Invalid JSON in ${dataFlag}. Expected a verification payload object.`,\n      );\n    }\n  }\n\n  const setIf = <K extends keyof VerificationSubmitInput>(\n    key: K,\n    value: VerificationSubmitInput[K] | undefined,\n  ): void => {\n    if (value !== undefined) {\n      payload[key] = value;\n    }\n  };\n\n  setIf(\"businessName\", flags[\"business-name\"] as string | undefined);\n  setIf(\"doingBusinessAs\", flags[\"doing-business-as\"] as string | undefined);\n  setIf(\"website\", flags.website as string | undefined);\n  setIf(\"entityType\", flags[\"entity-type\"] as string | undefined);\n  setIf(\"brn\", flags.brn as string | undefined);\n  setIf(\"brnType\", flags[\"brn-type\"] as string | undefined);\n  setIf(\"brnCountry\", flags[\"brn-country\"] as string | undefined);\n  setIf(\"useCase\", flags[\"use-case\"] as string | undefined);\n  setIf(\"useCaseSummary\", flags[\"use-case-summary\"] as string | undefined);\n  setIf(\"sampleMessages\", flags[\"sample-messages\"] as string | undefined);\n  setIf(\"optInWorkflow\", flags[\"opt-in-workflow\"] as string | undefined);\n  setIf(\"optInImageUrls\", flags[\"opt-in-image-urls\"] as string | undefined);\n  setIf(\"monthlyVolume\", flags[\"monthly-volume\"] as string | undefined);\n  setIf(\n    \"additionalInformation\",\n    flags[\"additional-information\"] as string | undefined,\n  );\n  setIf(\"isvReseller\", flags[\"isv-reseller\"] as string | undefined);\n  setIf(\"privacyUrl\", flags[\"privacy-url\"] as string | undefined);\n  setIf(\"termsUrl\", flags[\"terms-url\"] as string | undefined);\n\n  if (flags[\"age-gated-content\"] !== undefined) {\n    payload.ageGatedContent = flags[\"age-gated-content\"] as boolean;\n  }\n\n  const address = {\n    ...(payload.address || {}),\n    ...stripUndefined({\n      street: flags[\"address-street\"] as string | undefined,\n      city: flags[\"address-city\"] as string | undefined,\n      state: flags[\"address-state\"] as string | undefined,\n      zip: flags[\"address-zip\"] as string | undefined,\n      country: flags[\"address-country\"] as string | undefined,\n    }),\n  };\n  if (Object.keys(address).length > 0) {\n    payload.address = address;\n  }\n\n  const contact = {\n    ...(payload.contact || {}),\n    ...stripUndefined({\n      firstName: flags[\"contact-first-name\"] as string | undefined,\n      lastName: flags[\"contact-last-name\"] as string | undefined,\n      email: flags[\"contact-email\"] as string | undefined,\n      phone: flags[\"contact-phone\"] as string | undefined,\n    }),\n  };\n  if (Object.keys(contact).length > 0) {\n    payload.contact = contact;\n  }\n\n  return payload;\n}\n\nfunction stripUndefined<T extends Record<string, unknown>>(obj: T): Partial<T> {\n  const out: Partial<T> = {};\n  for (const [k, v] of Object.entries(obj)) {\n    if (v !== undefined) {\n      (out as Record<string, unknown>)[k] = v;\n    }\n  }\n  return out;\n}\n"]}

package/dist/commands/numbers/buy.d.ts

@@ -0,0 +1,31 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class NumbersBuy extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        country: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        number: 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>;
+    /**
+     * Resolve which number to buy. If --number is given we trust it (and
+     * still need its monthlyCost, so we look it up among available numbers).
+     * Otherwise we search and prompt the user to pick one.
+     */
+    private resolveNumber;
+    /**
+     * Drive a hosted document-upload / payment action: print the link + code,
+     * auto-open it, wire press-[c]-to-copy / [q] to cancel, then poll until
+     * the action completes (resolves true) or expires (resolves false).
+     */
+    private runHostedAction;
+    /**
+     * Poll the owned-numbers list until the just-ordered number reports
+     * `active`. Returns the active record, or undefined if it hasn't
+     * activated within the polling window.
+     */
+    private waitForActive;
+}

package/dist/commands/numbers/buy.js

@@ -0,0 +1,252 @@
+import { Flags } from "@oclif/core";
+import open from "open";
+import inquirer from "inquirer";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient, NotFoundError } from "../../lib/api-client.js";
+import { json, success, info, warn, error, colors, spinner, isJsonMode, } from "../../lib/output.js";
+import { attachLoginKeypressHandler } from "../../lib/keypress.js";
+const ACTION_POLL_INTERVAL = 2000; // 2 seconds
+const ACTION_MAX_ATTEMPTS = 600; // ~20 minutes
+const PROVISION_POLL_INTERVAL = 3000; // 3 seconds
+const PROVISION_MAX_ATTEMPTS = 60; // ~3 minutes
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export default class NumbersBuy extends AuthenticatedCommand {
+    static description = "Buy a phone number. Handles document/payment steps interactively when a country requires them.";
+    static examples = [
+        "<%= config.bin %> numbers buy --country GB --type mobile",
+        "<%= config.bin %> numbers buy --country US --type local --number +15551234567",
+        "<%= config.bin %> numbers buy --country GB --type mobile --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        country: Flags.string({
+            char: "c",
+            description: "ISO country code (e.g. GB, US)",
+            required: true,
+        }),
+        type: Flags.string({
+            char: "t",
+            description: "Number type (e.g. mobile, local, toll-free)",
+            required: true,
+        }),
+        number: Flags.string({
+            char: "n",
+            description: "Specific number to buy in E.164 format (skips selection)",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(NumbersBuy);
+        const selected = await this.resolveNumber(flags);
+        if (!selected)
+            return;
+        // The buy body is reused verbatim across every re-POST; only actionCode
+        // is added once a hosted action (docs/payment) has completed.
+        const buyBody = {
+            phoneNumber: selected.phoneNumber,
+            countryCode: flags.country,
+            phoneNumberType: flags.type,
+            monthlyCost: selected.monthlyCost,
+        };
+        let response = await apiClient.post("/api/v1/numbers/buy", buyBody);
+        // Drive the action loop until the carrier accepts the order (provisioning).
+        while (response.status === "documents_required" ||
+            response.status === "payment_required") {
+            const action = response.action;
+            if (!action) {
+                // Backend says docs/payment required but gave us nowhere to send the
+                // user — nothing the CLI can do.
+                if (isJsonMode()) {
+                    json(response);
+                    return;
+                }
+                error(`This number needs ${response.status === "payment_required" ? "payment" : "documents"} but no action link was returned.`, {
+                    hint: "Try again, or complete this number from the Sendly dashboard.",
+                });
+                this.exit(1);
+            }
+            if (isJsonMode()) {
+                // Non-interactive: surface the action so the caller can drive it.
+                json(response);
+                return;
+            }
+            const completed = await this.runHostedAction(response.status, action);
+            if (!completed)
+                return; // expired / cancelled — already messaged
+            // Re-buy with the action identifier (actionCode), NOT the display userCode.
+            buyBody.actionCode = action.actionCode;
+            response = await apiClient.post("/api/v1/numbers/buy", buyBody);
+        }
+        // status === "provisioning"
+        if (isJsonMode()) {
+            // Wait for activation then emit the final number record.
+            const active = await this.waitForActive(selected.phoneNumber);
+            json(active ?? response);
+            return;
+        }
+        info(`Order accepted for ${colors.code(selected.phoneNumber)} — provisioning...`);
+        const active = await this.waitForActive(selected.phoneNumber);
+        if (active) {
+            success("Number is active", {
+                number: active.phoneNumber,
+                id: active.id,
+                country: active.countryCode,
+                type: active.phoneNumberType,
+            });
+        }
+        else {
+            warn("Number is still provisioning. It usually activates within a few minutes — check `sendly numbers list`.");
+        }
+    }
+    /**
+     * Resolve which number to buy. If --number is given we trust it (and
+     * still need its monthlyCost, so we look it up among available numbers).
+     * Otherwise we search and prompt the user to pick one.
+     */
+    async resolveNumber(flags) {
+        const spin = spinner("Finding available numbers...");
+        spin.start();
+        let available;
+        try {
+            const search = await apiClient.get("/api/v1/numbers/available", {
+                country: flags.country,
+                type: flags.type,
+                ...(flags.number && { contains: flags.number.replace(/^\+/, "") }),
+            });
+            available = search.numbers ?? [];
+            spin.stop();
+        }
+        catch (err) {
+            spin.fail("Could not load available numbers");
+            throw err;
+        }
+        if (flags.number) {
+            const match = available.find((n) => n.phoneNumber === flags.number);
+            if (!match) {
+                error(`${flags.number} is not available for purchase.`, {
+                    hint: `Run: sendly numbers search --country ${flags.country} --type ${flags.type}`,
+                });
+                this.exit(1);
+            }
+            return match;
+        }
+        if (available.length === 0) {
+            info(`No available numbers found for ${flags.country} (${flags.type}).`);
+            return undefined;
+        }
+        // Non-interactive (no TTY / json): take the first result.
+        if (isJsonMode() || !process.stdout.isTTY) {
+            return available[0];
+        }
+        const { choice } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "choice",
+                message: `Choose a number to buy (${flags.country}, ${flags.type}):`,
+                choices: available.slice(0, 25).map((n) => ({
+                    name: `${n.phoneNumber}  —  ${n.monthlyCost} ${n.currency}/mo`,
+                    value: n.phoneNumber,
+                })),
+            },
+        ]);
+        return available.find((n) => n.phoneNumber === choice);
+    }
+    /**
+     * Drive a hosted document-upload / payment action: print the link + code,
+     * auto-open it, wire press-[c]-to-copy / [q] to cancel, then poll until
+     * the action completes (resolves true) or expires (resolves false).
+     */
+    async runHostedAction(kind, action) {
+        const label = kind === "payment_required" ? "Payment required" : "Documents required";
+        console.log();
+        console.log(colors.bold(label));
+        console.log();
+        console.log(kind === "payment_required"
+            ? "This number needs a payment to complete. Open this secure page:"
+            : "This number needs documents before it can be activated. Open this secure page:");
+        console.log(colors.primary(`  ${action.url}`));
+        console.log();
+        console.log("Confirmation code (shown so you can verify this is your session):");
+        console.log(colors.bold(colors.primary(`  ${action.code}`)));
+        console.log();
+        try {
+            await open(action.url);
+            console.log(colors.dim("Browser opened automatically"));
+        }
+        catch {
+            console.log(colors.dim("Please open the URL manually"));
+        }
+        const keypressCleanup = attachLoginKeypressHandler(action.url);
+        console.log();
+        const spin = spinner("Waiting for you to finish on the secure page...");
+        spin.start();
+        let attempts = 0;
+        while (attempts < ACTION_MAX_ATTEMPTS) {
+            await sleep(ACTION_POLL_INTERVAL);
+            attempts++;
+            let status;
+            try {
+                status = await apiClient.get(`/api/cli/action/${encodeURIComponent(action.actionCode)}`);
+            }
+            catch (err) {
+                if (err instanceof NotFoundError) {
+                    // The action is gone (expired/cleaned up) — terminal, not transient.
+                    spin.fail("This step expired");
+                    keypressCleanup();
+                    warn("The secure page expired before it was completed. Re-run `sendly numbers buy` to start over.");
+                    return false;
+                }
+                // Transient error — keep polling.
+                continue;
+            }
+            if (status.status === "completed") {
+                spin.succeed("Completed");
+                keypressCleanup();
+                return true;
+            }
+            if (status.status === "expired") {
+                spin.fail("This step expired");
+                keypressCleanup();
+                warn("The secure page expired before it was completed. Re-run `sendly numbers buy` to start over.");
+                return false;
+            }
+            // pending / authorized — keep polling
+        }
+        spin.fail("Timed out waiting for completion");
+        keypressCleanup();
+        warn("We stopped waiting. If you finished on the page, re-run `sendly numbers buy` and we'll pick up where you left off.");
+        return false;
+    }
+    /**
+     * Poll the owned-numbers list until the just-ordered number reports
+     * `active`. Returns the active record, or undefined if it hasn't
+     * activated within the polling window.
+     */
+    async waitForActive(phoneNumber) {
+        const spin = spinner("Activating number...");
+        spin.start();
+        let attempts = 0;
+        while (attempts < PROVISION_MAX_ATTEMPTS) {
+            let list;
+            try {
+                list = await apiClient.get("/api/v1/numbers");
+            }
+            catch {
+                await sleep(PROVISION_POLL_INTERVAL);
+                attempts++;
+                continue;
+            }
+            const found = (list.numbers ?? []).find((n) => n.phoneNumber === phoneNumber);
+            if (found && found.status === "active") {
+                spin.succeed("Active");
+                return found;
+            }
+            await sleep(PROVISION_POLL_INTERVAL);
+            attempts++;
+        }
+        spin.stop();
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"buy.js","sourceRoot":"","sources":["../../../src/commands/numbers/buy.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport open from \"open\";\nimport inquirer from \"inquirer\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient, NotFoundError } from \"../../lib/api-client.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 AvailableNumber {\n  phoneNumber: string;\n  country: string;\n  numberType: string;\n  monthlyCost: string;\n  currency: string;\n}\n\ninterface SearchNumbersResponse {\n  numbers: AvailableNumber[];\n}\n\ninterface BuyAction {\n  url: string;\n  // actionCode (32-hex) identifies the action — used to POLL and to RE-BUY.\n  actionCode: string;\n  // code (8-char userCode) is shown to the human to type on the hosted page\n  // to prove terminal access. DISPLAY only — never used as actionCode.\n  code: string;\n  expiresAt: number;\n}\n\ninterface OwnedNumber {\n  id: string;\n  phoneNumber: string;\n  status: string;\n  source: string;\n  countryCode: string;\n  phoneNumberType: string;\n  monthlyCostCents: number;\n}\n\ninterface BuyResponse {\n  status: \"provisioning\" | \"documents_required\" | \"payment_required\";\n  number?: OwnedNumber;\n  requirements?: unknown;\n  action?: BuyAction;\n}\n\ninterface ListNumbersResponse {\n  numbers: OwnedNumber[];\n}\n\ninterface ActionStatusResponse {\n  status: \"pending\" | \"authorized\" | \"completed\" | \"expired\";\n  actionType: string;\n  result?: unknown;\n  expiresAt: string;\n}\n\nconst ACTION_POLL_INTERVAL = 2000; // 2 seconds\nconst ACTION_MAX_ATTEMPTS = 600; // ~20 minutes\nconst PROVISION_POLL_INTERVAL = 3000; // 3 seconds\nconst PROVISION_MAX_ATTEMPTS = 60; // ~3 minutes\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nexport default class NumbersBuy extends AuthenticatedCommand {\n  static description =\n    \"Buy a phone number. Handles document/payment steps interactively when a country requires them.\";\n\n  static examples = [\n    \"<%= config.bin %> numbers buy --country GB --type mobile\",\n    \"<%= config.bin %> numbers buy --country US --type local --number +15551234567\",\n    \"<%= config.bin %> numbers buy --country GB --type mobile --json\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    country: Flags.string({\n      char: \"c\",\n      description: \"ISO country code (e.g. GB, US)\",\n      required: true,\n    }),\n    type: Flags.string({\n      char: \"t\",\n      description: \"Number type (e.g. mobile, local, toll-free)\",\n      required: true,\n    }),\n    number: Flags.string({\n      char: \"n\",\n      description: \"Specific number to buy in E.164 format (skips selection)\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(NumbersBuy);\n\n    const selected = await this.resolveNumber(flags);\n    if (!selected) return;\n\n    // The buy body is reused verbatim across every re-POST; only actionCode\n    // is added once a hosted action (docs/payment) has completed.\n    const buyBody: Record<string, unknown> = {\n      phoneNumber: selected.phoneNumber,\n      countryCode: flags.country,\n      phoneNumberType: flags.type,\n      monthlyCost: selected.monthlyCost,\n    };\n\n    let response = await apiClient.post<BuyResponse>(\n      \"/api/v1/numbers/buy\",\n      buyBody,\n    );\n\n    // Drive the action loop until the carrier accepts the order (provisioning).\n    while (\n      response.status === \"documents_required\" ||\n      response.status === \"payment_required\"\n    ) {\n      const action = response.action;\n      if (!action) {\n        // Backend says docs/payment required but gave us nowhere to send the\n        // user — nothing the CLI can do.\n        if (isJsonMode()) {\n          json(response);\n          return;\n        }\n        error(\n          `This number needs ${response.status === \"payment_required\" ? \"payment\" : \"documents\"} but no action link was returned.`,\n          {\n            hint: \"Try again, or complete this number from the Sendly dashboard.\",\n          },\n        );\n        this.exit(1);\n      }\n\n      if (isJsonMode()) {\n        // Non-interactive: surface the action so the caller can drive it.\n        json(response);\n        return;\n      }\n\n      const completed = await this.runHostedAction(response.status, action);\n      if (!completed) return; // expired / cancelled — already messaged\n\n      // Re-buy with the action identifier (actionCode), NOT the display userCode.\n      buyBody.actionCode = action.actionCode;\n      response = await apiClient.post<BuyResponse>(\n        \"/api/v1/numbers/buy\",\n        buyBody,\n      );\n    }\n\n    // status === \"provisioning\"\n    if (isJsonMode()) {\n      // Wait for activation then emit the final number record.\n      const active = await this.waitForActive(selected.phoneNumber);\n      json(active ?? response);\n      return;\n    }\n\n    info(`Order accepted for ${colors.code(selected.phoneNumber)} — provisioning...`);\n    const active = await this.waitForActive(selected.phoneNumber);\n\n    if (active) {\n      success(\"Number is active\", {\n        number: active.phoneNumber,\n        id: active.id,\n        country: active.countryCode,\n        type: active.phoneNumberType,\n      });\n    } else {\n      warn(\n        \"Number is still provisioning. It usually activates within a few minutes — check `sendly numbers list`.\",\n      );\n    }\n  }\n\n  /**\n   * Resolve which number to buy. If --number is given we trust it (and\n   * still need its monthlyCost, so we look it up among available numbers).\n   * Otherwise we search and prompt the user to pick one.\n   */\n  private async resolveNumber(flags: {\n    country: string;\n    type: string;\n    number?: string;\n  }): Promise<AvailableNumber | undefined> {\n    const spin = spinner(\"Finding available numbers...\");\n    spin.start();\n\n    let available: AvailableNumber[];\n    try {\n      const search = await apiClient.get<SearchNumbersResponse>(\n        \"/api/v1/numbers/available\",\n        {\n          country: flags.country,\n          type: flags.type,\n          ...(flags.number && { contains: flags.number.replace(/^\\+/, \"\") }),\n        },\n      );\n      available = search.numbers ?? [];\n      spin.stop();\n    } catch (err) {\n      spin.fail(\"Could not load available numbers\");\n      throw err;\n    }\n\n    if (flags.number) {\n      const match = available.find((n) => n.phoneNumber === flags.number);\n      if (!match) {\n        error(`${flags.number} is not available for purchase.`, {\n          hint: `Run: sendly numbers search --country ${flags.country} --type ${flags.type}`,\n        });\n        this.exit(1);\n      }\n      return match;\n    }\n\n    if (available.length === 0) {\n      info(`No available numbers found for ${flags.country} (${flags.type}).`);\n      return undefined;\n    }\n\n    // Non-interactive (no TTY / json): take the first result.\n    if (isJsonMode() || !process.stdout.isTTY) {\n      return available[0];\n    }\n\n    const { choice } = await inquirer.prompt([\n      {\n        type: \"list\",\n        name: \"choice\",\n        message: `Choose a number to buy (${flags.country}, ${flags.type}):`,\n        choices: available.slice(0, 25).map((n) => ({\n          name: `${n.phoneNumber}  —  ${n.monthlyCost} ${n.currency}/mo`,\n          value: n.phoneNumber,\n        })),\n      },\n    ]);\n\n    return available.find((n) => n.phoneNumber === choice);\n  }\n\n  /**\n   * Drive a hosted document-upload / payment action: print the link + code,\n   * auto-open it, wire press-[c]-to-copy / [q] to cancel, then poll until\n   * the action completes (resolves true) or expires (resolves false).\n   */\n  private async runHostedAction(\n    kind: \"documents_required\" | \"payment_required\",\n    action: BuyAction,\n  ): Promise<boolean> {\n    const label =\n      kind === \"payment_required\" ? \"Payment required\" : \"Documents required\";\n\n    console.log();\n    console.log(colors.bold(label));\n    console.log();\n    console.log(\n      kind === \"payment_required\"\n        ? \"This number needs a payment to complete. Open this secure page:\"\n        : \"This number needs documents before it can be activated. Open this secure page:\",\n    );\n    console.log(colors.primary(`  ${action.url}`));\n    console.log();\n    console.log(\"Confirmation code (shown so you can verify this is your session):\");\n    console.log(colors.bold(colors.primary(`  ${action.code}`)));\n    console.log();\n\n    try {\n      await open(action.url);\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(action.url);\n    console.log();\n\n    const spin = spinner(\"Waiting for you to finish on the secure page...\");\n    spin.start();\n\n    let attempts = 0;\n    while (attempts < ACTION_MAX_ATTEMPTS) {\n      await sleep(ACTION_POLL_INTERVAL);\n      attempts++;\n\n      let status: ActionStatusResponse;\n      try {\n        status = await apiClient.get<ActionStatusResponse>(\n          `/api/cli/action/${encodeURIComponent(action.actionCode)}`,\n        );\n      } catch (err) {\n        if (err instanceof NotFoundError) {\n          // The action is gone (expired/cleaned up) — terminal, not transient.\n          spin.fail(\"This step expired\");\n          keypressCleanup();\n          warn(\n            \"The secure page expired before it was completed. Re-run `sendly numbers buy` to start over.\",\n          );\n          return false;\n        }\n        // Transient error — keep polling.\n        continue;\n      }\n\n      if (status.status === \"completed\") {\n        spin.succeed(\"Completed\");\n        keypressCleanup();\n        return true;\n      }\n\n      if (status.status === \"expired\") {\n        spin.fail(\"This step expired\");\n        keypressCleanup();\n        warn(\n          \"The secure page expired before it was completed. Re-run `sendly numbers buy` to start over.\",\n        );\n        return false;\n      }\n      // pending / authorized — keep polling\n    }\n\n    spin.fail(\"Timed out waiting for completion\");\n    keypressCleanup();\n    warn(\n      \"We stopped waiting. If you finished on the page, re-run `sendly numbers buy` and we'll pick up where you left off.\",\n    );\n    return false;\n  }\n\n  /**\n   * Poll the owned-numbers list until the just-ordered number reports\n   * `active`. Returns the active record, or undefined if it hasn't\n   * activated within the polling window.\n   */\n  private async waitForActive(\n    phoneNumber: string,\n  ): Promise<OwnedNumber | undefined> {\n    const spin = spinner(\"Activating number...\");\n    spin.start();\n\n    let attempts = 0;\n    while (attempts < PROVISION_MAX_ATTEMPTS) {\n      let list: ListNumbersResponse;\n      try {\n        list = await apiClient.get<ListNumbersResponse>(\"/api/v1/numbers\");\n      } catch {\n        await sleep(PROVISION_POLL_INTERVAL);\n        attempts++;\n        continue;\n      }\n\n      const found = (list.numbers ?? []).find(\n        (n) => n.phoneNumber === phoneNumber,\n      );\n      if (found && found.status === \"active\") {\n        spin.succeed(\"Active\");\n        return found;\n      }\n\n      await sleep(PROVISION_POLL_INTERVAL);\n      attempts++;\n    }\n\n    spin.stop();\n    return undefined;\n  }\n}\n"]}

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

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