@sendly/cli 3.35.0 → 3.37.0

package/dist/commands/numbers/buy.js

@@ -0,0 +1,266 @@
+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);
+        }
+        // Document-required country: details submitted, number reserved + under
+        // review. No carrier order is placed until our team verifies + registers
+        // it, so there's nothing to poll for here.
+        if (response.status === "under_review") {
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Number reserved — your details are under review", {
+                number: response.number?.phoneNumber,
+                note: "We verify your documents and register the number, usually within a few business days. It can't send until it's active — check `sendly numbers list`.",
+            });
+            return;
+        }
+        // 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:\n    | \"provisioning\"\n    | \"documents_required\"\n    | \"under_review\"\n    | \"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    // Document-required country: details submitted, number reserved + under\n    // review. No carrier order is placed until our team verifies + registers\n    // it, so there's nothing to poll for here.\n    if (response.status === \"under_review\") {\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n      success(\"Number reserved — your details are under review\", {\n        number: response.number?.phoneNumber,\n        note: \"We verify your documents and register the number, usually within a few business days. It can't send until it's active — check `sendly numbers list`.\",\n      });\n      return;\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/get.d.ts

@@ -0,0 +1,20 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+/**
+ * `sendly numbers get <id>` — show one phone number you own, including whether
+ * it's the workspace default sender.
+ *
+ * Wraps `GET /api/v1/numbers/:id`. Returns 404 when the id isn't one of your
+ * numbers.
+ */
+export default class NumbersGet extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/numbers/get.js

@@ -0,0 +1,52 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, colors, formatStatus, formatRelativeTime, isJsonMode, } from "../../lib/output.js";
+/**
+ * `sendly numbers get <id>` — show one phone number you own, including whether
+ * it's the workspace default sender.
+ *
+ * Wraps `GET /api/v1/numbers/:id`. Returns 404 when the id isn't one of your
+ * numbers.
+ */
+export default class NumbersGet extends AuthenticatedCommand {
+    static description = "Show details for one phone number you own";
+    static examples = [
+        "<%= config.bin %> numbers get num_abc123",
+        "<%= config.bin %> numbers get num_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Phone number ID (from `sendly numbers list`)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(NumbersGet);
+        const number = await apiClient.get(`/api/v1/numbers/${encodeURIComponent(args.id)}`);
+        if (isJsonMode()) {
+            json(number);
+            return;
+        }
+        success("Number details", {
+            ID: number.id,
+            Number: colors.code(number.phoneNumber),
+            Status: formatStatus(number.status),
+            Country: number.countryCode,
+            Type: number.phoneNumberType,
+            Source: number.source,
+            Default: number.isDefault ? colors.success("yes") : "no",
+            "Monthly cost": `$${(number.monthlyCostCents / 100).toFixed(2)}`,
+            ...(number.pendingCancellation && {
+                "Pending release": colors.warning("yes"),
+            }),
+            ...(number.scheduledReleaseAt && {
+                "Scheduled release": formatRelativeTime(number.scheduledReleaseAt),
+            }),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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>;
+}

package/dist/commands/numbers/list.js

@@ -0,0 +1,70 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { table, json, info, formatStatus, colors, isJsonMode, } from "../../lib/output.js";
+export default class NumbersList extends AuthenticatedCommand {
+    static description = "List the phone numbers on your account";
+    static examples = [
+        "<%= config.bin %> numbers list",
+        "<%= config.bin %> numbers list --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        await this.parse(NumbersList);
+        const response = await apiClient.get("/api/v1/numbers");
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (!response.numbers || response.numbers.length === 0) {
+            info("No phone numbers on your account yet. Buy one with: sendly numbers buy");
+            return;
+        }
+        console.log();
+        console.log(colors.dim(`Showing ${response.numbers.length} numbers`));
+        console.log();
+        table(response.numbers, [
+            {
+                header: "Number",
+                key: "phoneNumber",
+                width: 18,
+                formatter: (v) => colors.code(String(v)),
+            },
+            {
+                header: "Status",
+                key: "status",
+                width: 14,
+                formatter: (v) => formatStatus(String(v)),
+            },
+            {
+                header: "Country",
+                key: "countryCode",
+                width: 9,
+            },
+            {
+                header: "Type",
+                key: "phoneNumberType",
+                width: 12,
+            },
+            {
+                header: "Source",
+                key: "source",
+                width: 12,
+                formatter: (v) => {
+                    const s = String(v);
+                    return s === "purchased"
+                        ? "Bought"
+                        : s === "ported_hosted_sms"
+                            ? "Hosted SMS"
+                            : s === "ported_full"
+                                ? "Ported"
+                                : s === "provisioned"
+                                    ? "Provisioned"
+                                    : s;
+                },
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,23 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+/**
+ * `sendly numbers release <id>` — give up a number you own. A live paid
+ * purchase is scheduled to release at the end of the current billing period
+ * (undo with `sendly numbers update <id> --keep`); anything else is released at
+ * the carrier immediately.
+ *
+ * Wraps `DELETE /api/v1/numbers/:id`. Prompts for confirmation unless --yes is
+ * passed. Returns 404 when the id isn't one of your numbers.
+ */
+export default class NumbersRelease extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/numbers/release.js

@@ -0,0 +1,67 @@
+import { Args, Flags } from "@oclif/core";
+import inquirer from "inquirer";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, info, json, colors, isJsonMode } from "../../lib/output.js";
+/**
+ * `sendly numbers release <id>` — give up a number you own. A live paid
+ * purchase is scheduled to release at the end of the current billing period
+ * (undo with `sendly numbers update <id> --keep`); anything else is released at
+ * the carrier immediately.
+ *
+ * Wraps `DELETE /api/v1/numbers/:id`. Prompts for confirmation unless --yes is
+ * passed. Returns 404 when the id isn't one of your numbers.
+ */
+export default class NumbersRelease extends AuthenticatedCommand {
+    static description = "Release a number you own (paid purchases release at period end, others immediately)";
+    static examples = [
+        "<%= config.bin %> numbers release num_abc123",
+        "<%= config.bin %> numbers release num_abc123 --yes",
+        "<%= config.bin %> numbers release num_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Phone number ID (from `sendly numbers list`)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(NumbersRelease);
+        if (!flags.yes && !isJsonMode() && process.stdin.isTTY) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Release ${colors.code(args.id)}? Paid numbers release at the end of the billing period; everything else releases immediately.`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                info("Release cancelled");
+                return;
+            }
+        }
+        const response = await apiClient.delete(`/api/v1/numbers/${encodeURIComponent(args.id)}`);
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (response.scheduled && response.scheduledReleaseAt) {
+            success("Number scheduled for release", {
+                Releases: new Date(response.scheduledReleaseAt).toLocaleDateString(),
+                Note: `It stays active until then. Undo with: sendly numbers update ${args.id} --keep`,
+            });
+            return;
+        }
+        success("Number released");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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