@sendly/cli 3.35.0 → 3.37.0

package/dist/commands/keys/rotate.js

@@ -20,7 +20,7 @@ export default class KeysRotate extends AuthenticatedCommand {
         ...AuthenticatedCommand.baseFlags,
         "grace-period": Flags.integer({
             char: "g",
-            description: "Hours to keep old key active (0 = immediate revocation)",
+            description: "Hours to keep the old key active during rotation (24-168, default 24)",
         }),
         yes: Flags.boolean({
             char: "y",
@@ -51,24 +51,19 @@ export default class KeysRotate extends AuthenticatedCommand {
             }
             const response = await apiClient.post(`/api/v1/account/keys/${args.keyId}/rotate`, body);
             if (isJsonMode()) {
-                json({
-                    success: true,
-                    newKeyId: response.newKey.id,
-                    key: response.key,
-                    oldKeyExpiresAt: response.oldKeyExpiresAt,
-                });
+                json(response);
                 return;
             }
             success("API key rotated", {
                 "New Key ID": response.newKey.id,
-                "New Key": colors.highlight(response.key),
+                "New Key": colors.highlight(response.newKey.key),
                 Name: response.newKey.name,
-                ...(response.oldKeyExpiresAt && {
-                    "Old Key Expires": new Date(response.oldKeyExpiresAt).toLocaleString(),
+                ...(response.oldKey?.expiresAt && {
+                    "Old Key Expires": new Date(response.oldKey.expiresAt).toLocaleString(),
                 }),
             });
             this.log("");
-            this.log(colors.warning("Save this key - it won't be shown again!"));
+            this.log(colors.warning(response.newKey.warning || "Save this key - it won't be shown again!"));
         }
         catch (err) {
             if (err.message?.includes("not_found") || err.message?.includes("404")) {
@@ -79,4 +74,4 @@ export default class KeysRotate extends AuthenticatedCommand {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm90YXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbW1hbmRzL2tleXMvcm90YXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQzFDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNwRCxPQUFPLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQy9FLE9BQU8sUUFBUSxNQUFNLFVBQVUsQ0FBQztBQXNCaEMsTUFBTSxDQUFDLE9BQU8sT0FBTyxVQUFXLFNBQVEsb0JBQW9CO0lBQzFELE1BQU0sQ0FBQyxXQUFXLEdBQUcsc0VBQXNFLENBQUM7SUFFNUYsTUFBTSxDQUFDLFFBQVEsR0FBRztRQUNoQiwwQ0FBMEM7UUFDMUMsNERBQTREO1FBQzVELGdEQUFnRDtLQUNqRCxDQUFDO0lBRUYsTUFBTSxDQUFDLElBQUksR0FBRztRQUNaLEtBQUssRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDO1lBQ2pCLFdBQVcsRUFBRSxxQ0FBcUM7WUFDbEQsUUFBUSxFQUFFLElBQUk7U0FDZixDQUFDO0tBQ0gsQ0FBQztJQUVGLE1BQU0sQ0FBQyxLQUFLLEdBQUc7UUFDYixHQUFHLG9CQUFvQixDQUFDLFNBQVM7UUFDakMsY0FBYyxFQUFFLEtBQUssQ0FBQyxPQUFPLENBQUM7WUFDNUIsSUFBSSxFQUFFLEdBQUc7WUFDVCxXQUFXLEVBQ1QsdUVBQXVFO1NBQzFFLENBQUM7UUFDRixHQUFHLEVBQUUsS0FBSyxDQUFDLE9BQU8sQ0FBQztZQUNqQixJQUFJLEVBQUUsR0FBRztZQUNULFdBQVcsRUFBRSwwQkFBMEI7WUFDdkMsT0FBTyxFQUFFLEtBQUs7U0FDZixDQUFDO0tBQ0gsQ0FBQztJQUVGLEtBQUssQ0FBQyxHQUFHO1FBQ1AsTUFBTSxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsR0FBRyxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQUM7UUFFckQsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUNmLE1BQU0sRUFBRSxPQUFPLEVBQUUsR0FBRyxNQUFNLFFBQVEsQ0FBQyxNQUFNLENBQUM7Z0JBQ3hDO29CQUNFLElBQUksRUFBRSxTQUFTO29CQUNmLElBQUksRUFBRSxTQUFTO29CQUNmLE9BQU8sRUFBRSxtQ0FBbUMsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLGdDQUFnQztvQkFDbkcsT0FBTyxFQUFFLEtBQUs7aUJBQ2Y7YUFDRixDQUFDLENBQUM7WUFFSCxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7Z0JBQ2IsS0FBSyxDQUFDLG9CQUFvQixDQUFDLENBQUM7Z0JBQzVCLE9BQU87WUFDVCxDQUFDO1FBQ0gsQ0FBQztRQUVELElBQUksQ0FBQztZQUNILE1BQU0sSUFBSSxHQUF3QixFQUFFLENBQUM7WUFDckMsSUFBSSxLQUFLLENBQUMsY0FBYyxDQUFDLEtBQUssU0FBUyxFQUFFLENBQUM7Z0JBQ3hDLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxLQUFLLENBQUMsY0FBYyxDQUFDLENBQUM7WUFDaEQsQ0FBQztZQUVELE1BQU0sUUFBUSxHQUFHLE1BQU0sU0FBUyxDQUFDLElBQUksQ0FDbkMsd0JBQXdCLElBQUksQ0FBQyxLQUFLLFNBQVMsRUFDM0MsSUFBSSxDQUNMLENBQUM7WUFFRixJQUFJLFVBQVUsRUFBRSxFQUFFLENBQUM7Z0JBQ2pCLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztnQkFDZixPQUFPO1lBQ1QsQ0FBQztZQUVELE9BQU8sQ0FBQyxpQkFBaUIsRUFBRTtnQkFDekIsWUFBWSxFQUFFLFFBQVEsQ0FBQyxNQUFNLENBQUMsRUFBRTtnQkFDaEMsU0FBUyxFQUFFLE1BQU0sQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUM7Z0JBQ2hELElBQUksRUFBRSxRQUFRLENBQUMsTUFBTSxDQUFDLElBQUk7Z0JBQzFCLEdBQUcsQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLFNBQVMsSUFBSTtvQkFDaEMsaUJBQWlCLEVBQUUsSUFBSSxJQUFJLENBQ3pCLFFBQVEsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUMxQixDQUFDLGNBQWMsRUFBRTtpQkFDbkIsQ0FBQzthQUNILENBQUMsQ0FBQztZQUVILElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7WUFDYixJQUFJLENBQUMsR0FBRyxDQUNOLE1BQU0sQ0FBQyxPQUFPLENBQ1osUUFBUSxDQUFDLE1BQU0sQ0FBQyxPQUFPLElBQUksMENBQTBDLENBQ3RFLENBQ0YsQ0FBQztRQUNKLENBQUM7UUFBQyxPQUFPLEdBQVEsRUFBRSxDQUFDO1lBQ2xCLElBQUksR0FBRyxDQUFDLE9BQU8sRUFBRSxRQUFRLENBQUMsV0FBVyxDQUFDLElBQUksR0FBRyxDQUFDLE9BQU8sRUFBRSxRQUFRLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztnQkFDdkUsS0FBSyxDQUFDLGtCQUFrQixJQUFJLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQztnQkFDdEMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUNmLENBQUM7WUFDRCxNQUFNLEdBQUcsQ0FBQztRQUNaLENBQUM7SUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXJncywgRmxhZ3MgfSBmcm9tIFwiQG9jbGlmL2NvcmVcIjtcbmltcG9ydCB7IEF1dGhlbnRpY2F0ZWRDb21tYW5kIH0gZnJvbSBcIi4uLy4uL2xpYi9iYXNlLWNvbW1hbmQuanNcIjtcbmltcG9ydCB7IGFwaUNsaWVudCB9IGZyb20gXCIuLi8uLi9saWIvYXBpLWNsaWVudC5qc1wiO1xuaW1wb3J0IHsgc3VjY2VzcywgZXJyb3IsIGpzb24sIGNvbG9ycywgaXNKc29uTW9kZSB9IGZyb20gXCIuLi8uLi9saWIvb3V0cHV0LmpzXCI7XG5pbXBvcnQgaW5xdWlyZXIgZnJvbSBcImlucXVpcmVyXCI7XG5cbmludGVyZmFjZSBSb3RhdGVSZXNwb25zZSB7XG4gIG5ld0tleToge1xuICAgIGlkOiBzdHJpbmc7XG4gICAgbmFtZTogc3RyaW5nO1xuICAgIHR5cGU/OiBcInRlc3RcIiB8IFwibGl2ZVwiO1xuICAgIHNjb3Blcz86IHN0cmluZ1tdO1xuICAgIGlzQWN0aXZlPzogYm9vbGVhbjtcbiAgICBjcmVhdGVkQXQ/OiBzdHJpbmc7XG4gICAgZXhwaXJlc0F0Pzogc3RyaW5nIHwgbnVsbDtcbiAgICAvLyBUaGUgcmF3IGBza1/igKZgIHNlY3JldCDigJQgc2hvd24gb25seSBvbiB0aGlzIHJlc3BvbnNlLCBuZXZlciBhZ2Fpbi5cbiAgICBrZXk6IHN0cmluZztcbiAgICB3YXJuaW5nOiBzdHJpbmc7XG4gIH07XG4gIG9sZEtleToge1xuICAgIGlkOiBzdHJpbmc7XG4gICAgZXhwaXJlc0F0Pzogc3RyaW5nIHwgbnVsbDtcbiAgfTtcbiAgbWVzc2FnZTogc3RyaW5nO1xufVxuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBLZXlzUm90YXRlIGV4dGVuZHMgQXV0aGVudGljYXRlZENvbW1hbmQge1xuICBzdGF0aWMgZGVzY3JpcHRpb24gPSBcIlJvdGF0ZSBhbiBBUEkga2V5IChnZW5lcmF0ZSBuZXcga2V5LCBvcHRpb25hbGx5IGtlZXAgb2xkIG9uZSBhY3RpdmUpXCI7XG5cbiAgc3RhdGljIGV4YW1wbGVzID0gW1xuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4ga2V5cyByb3RhdGUga2V5X2FiYzEyM1wiLFxuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4ga2V5cyByb3RhdGUga2V5X2FiYzEyMyAtLWdyYWNlLXBlcmlvZCAyNFwiLFxuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4ga2V5cyByb3RhdGUga2V5X2FiYzEyMyAtLXllc1wiLFxuICBdO1xuXG4gIHN0YXRpYyBhcmdzID0ge1xuICAgIGtleUlkOiBBcmdzLnN0cmluZyh7XG4gICAgICBkZXNjcmlwdGlvbjogXCJLZXkgSUQgdG8gcm90YXRlIChlLmcuLCBrZXlfYWJjMTIzKVwiLFxuICAgICAgcmVxdWlyZWQ6IHRydWUsXG4gICAgfSksXG4gIH07XG5cbiAgc3RhdGljIGZsYWdzID0ge1xuICAgIC4uLkF1dGhlbnRpY2F0ZWRDb21tYW5kLmJhc2VGbGFncyxcbiAgICBcImdyYWNlLXBlcmlvZFwiOiBGbGFncy5pbnRlZ2VyKHtcbiAgICAgIGNoYXI6IFwiZ1wiLFxuICAgICAgZGVzY3JpcHRpb246XG4gICAgICAgIFwiSG91cnMgdG8ga2VlcCB0aGUgb2xkIGtleSBhY3RpdmUgZHVyaW5nIHJvdGF0aW9uICgyNC0xNjgsIGRlZmF1bHQgMjQpXCIsXG4gICAgfSksXG4gICAgeWVzOiBGbGFncy5ib29sZWFuKHtcbiAgICAgIGNoYXI6IFwieVwiLFxuICAgICAgZGVzY3JpcHRpb246IFwiU2tpcCBjb25maXJtYXRpb24gcHJvbXB0XCIsXG4gICAgICBkZWZhdWx0OiBmYWxzZSxcbiAgICB9KSxcbiAgfTtcblxuICBhc3luYyBydW4oKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgY29uc3QgeyBhcmdzLCBmbGFncyB9ID0gYXdhaXQgdGhpcy5wYXJzZShLZXlzUm90YXRlKTtcblxuICAgIGlmICghZmxhZ3MueWVzKSB7XG4gICAgICBjb25zdCB7IGNvbmZpcm0gfSA9IGF3YWl0IGlucXVpcmVyLnByb21wdChbXG4gICAgICAgIHtcbiAgICAgICAgICB0eXBlOiBcImNvbmZpcm1cIixcbiAgICAgICAgICBuYW1lOiBcImNvbmZpcm1cIixcbiAgICAgICAgICBtZXNzYWdlOiBgQXJlIHlvdSBzdXJlIHlvdSB3YW50IHRvIHJvdGF0ZSAke2NvbG9ycy5jb2RlKGFyZ3Mua2V5SWQpfT8gQSBuZXcga2V5IHdpbGwgYmUgZ2VuZXJhdGVkLmAsXG4gICAgICAgICAgZGVmYXVsdDogZmFsc2UsXG4gICAgICAgIH0sXG4gICAgICBdKTtcblxuICAgICAgaWYgKCFjb25maXJtKSB7XG4gICAgICAgIGVycm9yKFwiUm90YXRpb24gY2FuY2VsbGVkXCIpO1xuICAgICAgICByZXR1cm47XG4gICAgICB9XG4gICAgfVxuXG4gICAgdHJ5IHtcbiAgICAgIGNvbnN0IGJvZHk6IFJlY29yZDxzdHJpbmcsIGFueT4gPSB7fTtcbiAgICAgIGlmIChmbGFnc1tcImdyYWNlLXBlcmlvZFwiXSAhPT0gdW5kZWZpbmVkKSB7XG4gICAgICAgIGJvZHkuZ3JhY2VQZXJpb2RIb3VycyA9IGZsYWdzW1wiZ3JhY2UtcGVyaW9kXCJdO1xuICAgICAgfVxuXG4gICAgICBjb25zdCByZXNwb25zZSA9IGF3YWl0IGFwaUNsaWVudC5wb3N0PFJvdGF0ZVJlc3BvbnNlPihcbiAgICAgICAgYC9hcGkvdjEvYWNjb3VudC9rZXlzLyR7YXJncy5rZXlJZH0vcm90YXRlYCxcbiAgICAgICAgYm9keSxcbiAgICAgICk7XG5cbiAgICAgIGlmIChpc0pzb25Nb2RlKCkpIHtcbiAgICAgICAganNvbihyZXNwb25zZSk7XG4gICAgICAgIHJldHVybjtcbiAgICAgIH1cblxuICAgICAgc3VjY2VzcyhcIkFQSSBrZXkgcm90YXRlZFwiLCB7XG4gICAgICAgIFwiTmV3IEtleSBJRFwiOiByZXNwb25zZS5uZXdLZXkuaWQsXG4gICAgICAgIFwiTmV3IEtleVwiOiBjb2xvcnMuaGlnaGxpZ2h0KHJlc3BvbnNlLm5ld0tleS5rZXkpLFxuICAgICAgICBOYW1lOiByZXNwb25zZS5uZXdLZXkubmFtZSxcbiAgICAgICAgLi4uKHJlc3BvbnNlLm9sZEtleT8uZXhwaXJlc0F0ICYmIHtcbiAgICAgICAgICBcIk9sZCBLZXkgRXhwaXJlc1wiOiBuZXcgRGF0ZShcbiAgICAgICAgICAgIHJlc3BvbnNlLm9sZEtleS5leHBpcmVzQXQsXG4gICAgICAgICAgKS50b0xvY2FsZVN0cmluZygpLFxuICAgICAgICB9KSxcbiAgICAgIH0pO1xuXG4gICAgICB0aGlzLmxvZyhcIlwiKTtcbiAgICAgIHRoaXMubG9nKFxuICAgICAgICBjb2xvcnMud2FybmluZyhcbiAgICAgICAgICByZXNwb25zZS5uZXdLZXkud2FybmluZyB8fCBcIlNhdmUgdGhpcyBrZXkgLSBpdCB3b24ndCBiZSBzaG93biBhZ2FpbiFcIixcbiAgICAgICAgKSxcbiAgICAgICk7XG4gICAgfSBjYXRjaCAoZXJyOiBhbnkpIHtcbiAgICAgIGlmIChlcnIubWVzc2FnZT8uaW5jbHVkZXMoXCJub3RfZm91bmRcIikgfHwgZXJyLm1lc3NhZ2U/LmluY2x1ZGVzKFwiNDA0XCIpKSB7XG4gICAgICAgIGVycm9yKGBLZXkgbm90IGZvdW5kOiAke2FyZ3Mua2V5SWR9YCk7XG4gICAgICAgIHRoaXMuZXhpdCgxKTtcbiAgICAgIH1cbiAgICAgIHRocm93IGVycjtcbiAgICB9XG4gIH1cbn1cbiJdfQ==

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