@sendly/cli 3.36.0 → 3.37.0

package/dist/commands/links/create.d.ts

@@ -0,0 +1,24 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+/**
+ * `sendly links create <url>` — mint a branded short link.
+ *
+ * Wraps `POST /api/v1/links`. Uses your workspace's brand slug when one is
+ * configured. Branded, owned-domain short links improve deliverability
+ * (carriers filter public shorteners) and give you click analytics.
+ *
+ * Gated behind the `url_shortener` rollout flag — until it's enabled for your
+ * account the server returns `404 not_found` and this command surfaces it.
+ */
+export default class LinksCreate extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        url: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        url: 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/links/create.js

@@ -0,0 +1,71 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, spinner, colors, json, isJsonMode, } from "../../lib/output.js";
+/**
+ * `sendly links create <url>` — mint a branded short link.
+ *
+ * Wraps `POST /api/v1/links`. Uses your workspace's brand slug when one is
+ * configured. Branded, owned-domain short links improve deliverability
+ * (carriers filter public shorteners) and give you click analytics.
+ *
+ * Gated behind the `url_shortener` rollout flag — until it's enabled for your
+ * account the server returns `404 not_found` and this command surfaces it.
+ */
+export default class LinksCreate extends AuthenticatedCommand {
+    static description = "Shorten a URL into a branded short link. Requires the url_shortener feature to be enabled for your account.";
+    static examples = [
+        "<%= config.bin %> links create https://example.com/spring-sale",
+        '<%= config.bin %> links create --url "https://example.com/welcome?utm_source=sms"',
+        "<%= config.bin %> links create https://example.com/welcome --json",
+    ];
+    static args = {
+        url: Args.string({
+            description: "Destination URL to shorten (http/https, alternative to --url)",
+            required: false,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        url: Flags.string({
+            char: "u",
+            description: "Destination URL to shorten (http/https)",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(LinksCreate);
+        const url = flags.url ?? args.url;
+        if (!url) {
+            error("A destination URL is required", {
+                hint: "Pass a URL: sendly links create https://example.com",
+            });
+            this.exit(1);
+        }
+        if (!/^https?:\/\//i.test(url)) {
+            error("URL must start with http:// or https://");
+            this.exit(1);
+        }
+        const spin = spinner("Shortening URL...");
+        spin.start();
+        try {
+            const response = await apiClient.post("/api/v1/links", {
+                url,
+            });
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Short link created", {
+                Code: response.code,
+                "Short URL": colors.code(response.shortUrl),
+                Destination: response.destinationUrl,
+            });
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/links/disable.d.ts

@@ -0,0 +1,21 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+/**
+ * `sendly links disable <code>` — the per-link kill switch. A disabled link's
+ * redirect returns 404 until it is re-enabled. Pass `--enable` to re-enable.
+ *
+ * Wraps `PATCH /api/v1/links/:code`. Gated behind the `url_shortener` rollout
+ * flag — until it's enabled the server returns `404 not_found`.
+ */
+export default class LinksDisable extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        code: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        enable: 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/links/disable.js

@@ -0,0 +1,55 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, spinner, json, isJsonMode } from "../../lib/output.js";
+/**
+ * `sendly links disable <code>` — the per-link kill switch. A disabled link's
+ * redirect returns 404 until it is re-enabled. Pass `--enable` to re-enable.
+ *
+ * Wraps `PATCH /api/v1/links/:code`. Gated behind the `url_shortener` rollout
+ * flag — until it's enabled the server returns `404 not_found`.
+ */
+export default class LinksDisable extends AuthenticatedCommand {
+    static description = "Disable a short link so its redirect returns 404 (use --enable to re-enable)";
+    static examples = [
+        "<%= config.bin %> links disable Ab3xY7",
+        "<%= config.bin %> links disable Ab3xY7 --enable",
+        "<%= config.bin %> links disable Ab3xY7 --json",
+    ];
+    static args = {
+        code: Args.string({
+            description: "Short link code (the segment after the domain)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        enable: Flags.boolean({
+            description: "Re-enable the link instead of disabling it",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(LinksDisable);
+        const disabled = !flags.enable;
+        const spin = spinner(disabled ? "Disabling link..." : "Re-enabling link...");
+        spin.start();
+        try {
+            const response = await apiClient.patch(`/api/v1/links/${encodeURIComponent(args.code)}`, { disabled });
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success(response.disabled ? "Link disabled" : "Link re-enabled", {
+                Code: response.code,
+                State: response.disabled ? "disabled" : "active",
+            });
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,19 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+/**
+ * `sendly links list` — list the branded short links your workspace has
+ * created, newest first, with click counts.
+ *
+ * Wraps `GET /api/v1/links`. Gated behind the `url_shortener` rollout flag —
+ * until it's enabled the server returns `404 not_found`.
+ */
+export default class LinksList extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        limit: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        offset: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        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/links/list.js

@@ -0,0 +1,85 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { table, json, info, colors, formatRelativeTime, isJsonMode, } from "../../lib/output.js";
+/**
+ * `sendly links list` — list the branded short links your workspace has
+ * created, newest first, with click counts.
+ *
+ * Wraps `GET /api/v1/links`. Gated behind the `url_shortener` rollout flag —
+ * until it's enabled the server returns `404 not_found`.
+ */
+export default class LinksList extends AuthenticatedCommand {
+    static description = "List your branded short links with click counts";
+    static examples = [
+        "<%= config.bin %> links list",
+        "<%= config.bin %> links list --limit 20",
+        "<%= config.bin %> links list --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        limit: Flags.integer({
+            char: "l",
+            description: "Maximum number of links to return (1-200)",
+            default: 50,
+        }),
+        offset: Flags.integer({
+            description: "Number of links to skip for pagination",
+            default: 0,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(LinksList);
+        const response = await apiClient.get("/api/v1/links", {
+            limit: flags.limit,
+            offset: flags.offset,
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (!response.links || response.links.length === 0) {
+            info("No short links yet. Create one with: sendly links create <url>");
+            return;
+        }
+        console.log();
+        console.log(colors.dim(`Showing ${response.links.length} of ${response.total} links`));
+        console.log();
+        table(response.links, [
+            {
+                header: "Short URL",
+                key: "shortUrl",
+                width: 34,
+                formatter: (v) => colors.code(String(v)),
+            },
+            {
+                header: "Destination",
+                key: "destinationUrl",
+                width: 34,
+                formatter: (v) => {
+                    const text = String(v ?? "-");
+                    return text.length > 31 ? text.slice(0, 31) + "..." : text;
+                },
+            },
+            {
+                header: "Clicks",
+                key: "clickCount",
+                width: 8,
+                formatter: (v) => String(v ?? 0),
+            },
+            {
+                header: "State",
+                key: "disabled",
+                width: 10,
+                formatter: (v) => (v ? colors.error("disabled") : colors.success("active")),
+            },
+            {
+                header: "Last click",
+                key: "lastClickedAt",
+                width: 14,
+                formatter: (v) => (v ? formatRelativeTime(String(v)) : colors.dim("never")),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/numbers/buy.js

@@ -78,6 +78,20 @@ export default class NumbersBuy extends AuthenticatedCommand {
             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.
@@ -249,4 +263,4 @@ export default class NumbersBuy extends AuthenticatedCommand {
         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"]}
+//# 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.js

@@ -47,7 +47,24 @@ export default class NumbersList extends AuthenticatedCommand {
                 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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
+//# 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>;
+}