@sendly/cli 3.34.0 → 3.36.0

package/dist/commands/numbers/list.js

@@ -0,0 +1,53 @@
+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,
+            },
+        ]);
+    }
+}
+//# 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>;
+}

package/dist/commands/numbers/search.js

@@ -0,0 +1,78 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { table, json, info, colors, isJsonMode } from "../../lib/output.js";
+export default class NumbersSearch extends AuthenticatedCommand {
+    static description = "Search for available phone numbers to buy in a country";
+    static examples = [
+        "<%= config.bin %> numbers search --country GB --type mobile",
+        "<%= config.bin %> numbers search --country US --type local --contains 555",
+        "<%= config.bin %> numbers search --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,
+        }),
+        contains: Flags.string({
+            description: "Only return numbers containing this digit pattern",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(NumbersSearch);
+        const response = await apiClient.get("/api/v1/numbers/available", {
+            country: flags.country,
+            type: flags.type,
+            ...(flags.contains && { contains: flags.contains }),
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (!response.numbers || response.numbers.length === 0) {
+            info(`No available numbers found for ${flags.country} (${flags.type})${flags.contains ? ` matching "${flags.contains}"` : ""}`);
+            return;
+        }
+        console.log();
+        console.log(colors.dim(`${response.numbers.length} available numbers for ${flags.country} (${flags.type})`));
+        console.log();
+        table(response.numbers, [
+            {
+                header: "Number",
+                key: "phoneNumber",
+                width: 18,
+                formatter: (v) => colors.code(String(v)),
+            },
+            {
+                header: "Country",
+                key: "country",
+                width: 9,
+            },
+            {
+                header: "Type",
+                key: "numberType",
+                width: 12,
+            },
+            {
+                header: "Monthly",
+                key: "monthlyCost",
+                width: 14,
+                formatter: (v, row) => `${v} ${row?.currency ?? ""}`.trim(),
+            },
+        ]);
+        console.log();
+        console.log(colors.dim("Buy one with: sendly numbers buy --country " +
+            flags.country +
+            " --type " +
+            flags.type +
+            " --number <number>"));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/webhooks/backfill.js

@@ -55,6 +55,7 @@ export default class WebhooksBackfill extends AuthenticatedCommand {
                 .map(([k, v]) => `${k}=${v}`)
                 .join(", ");
             success(result.message || "Backfill complete", {
+                ...(result.run_id ? { "Run ID": result.run_id } : {}),
                 Synthesized: String(result.synthesized),
                 "By Type": byType || "(none)",
                 "Candidates Scanned": String(result.candidates_scanned),
@@ -70,4 +71,4 @@ export default class WebhooksBackfill extends AuthenticatedCommand {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFja2ZpbGwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29tbWFuZHMvd2ViaG9va3MvYmFja2ZpbGwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDMUMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDakUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3BELE9BQU8sRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFjaEYsTUFBTSxDQUFDLE9BQU8sT0FBTyxnQkFBaUIsU0FBUSxvQkFBb0I7SUFDaEUsTUFBTSxDQUFDLFdBQVcsR0FDaEIsMEdBQTBHLENBQUM7SUFFN0csTUFBTSxDQUFDLFFBQVEsR0FBRztRQUNoQixnREFBZ0Q7UUFDaEQsMEZBQTBGO1FBQzFGLCtGQUErRjtLQUNoRyxDQUFDO0lBRUYsTUFBTSxDQUFDLElBQUksR0FBRztRQUNaLEVBQUUsRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsV0FBVyxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLENBQUM7S0FDL0QsQ0FBQztJQUVGLE1BQU0sQ0FBQyxLQUFLLEdBQUc7UUFDYixHQUFHLG9CQUFvQixDQUFDLFNBQVM7UUFDakMsS0FBSyxFQUFFLEtBQUssQ0FBQyxNQUFNLENBQUM7WUFDbEIsV0FBVyxFQUFFLHVEQUF1RDtTQUNyRSxDQUFDO1FBQ0YsS0FBSyxFQUFFLEtBQUssQ0FBQyxNQUFNLENBQUM7WUFDbEIsV0FBVyxFQUFFLCtDQUErQztTQUM3RCxDQUFDO1FBQ0YsYUFBYSxFQUFFLEtBQUssQ0FBQyxNQUFNLENBQUM7WUFDMUIsV0FBVyxFQUNULDJGQUEyRjtTQUM5RixDQUFDO1FBQ0YsS0FBSyxFQUFFLEtBQUssQ0FBQyxPQUFPLENBQUM7WUFDbkIsV0FBVyxFQUFFLDBDQUEwQztZQUN2RCxPQUFPLEVBQUUsSUFBSTtTQUNkLENBQUM7S0FDSCxDQUFDO0lBRUYsS0FBSyxDQUFDLEdBQUc7UUFDUCxNQUFNLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxHQUFHLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO1FBRTNELE1BQU0sSUFBSSxHQUE0QixFQUFFLENBQUM7UUFDekMsSUFBSSxLQUFLLENBQUMsS0FBSztZQUFFLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDLEtBQUssQ0FBQztRQUMxQyxJQUFJLEtBQUssQ0FBQyxLQUFLO1lBQUUsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUMsS0FBSyxDQUFDO1FBQzFDLElBQUksS0FBSyxDQUFDLGFBQWEsQ0FBQztZQUN0QixJQUFJLENBQUMsV0FBVyxHQUFHLEtBQUssQ0FBQyxhQUFhLENBQUM7aUJBQ3BDLEtBQUssQ0FBQyxHQUFHLENBQUM7aUJBQ1YsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUM7aUJBQ3BCLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNyQixJQUFJLEtBQUssQ0FBQyxLQUFLLEtBQUssU0FBUztZQUFFLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDLEtBQUssQ0FBQztRQUV4RCxNQUFNLEVBQUUsR0FBRyxPQUFPLENBQUMsbUNBQW1DLENBQUMsQ0FBQztRQUN4RCxFQUFFLENBQUMsS0FBSyxFQUFFLENBQUM7UUFFWCxJQUFJLENBQUM7WUFDSCxNQUFNLE1BQU0sR0FBRyxNQUFNLFNBQVMsQ0FBQyxJQUFJLENBQ2pDLG9CQUFvQixJQUFJLENBQUMsRUFBRSxXQUFXLEVBQ3RDLElBQUksQ0FDTCxDQUFDO1lBRUYsRUFBRSxDQUFDLElBQUksRUFBRSxDQUFDO1lBRVYsSUFBSSxVQUFVLEVBQUUsRUFBRSxDQUFDO2dCQUNqQixJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7Z0JBQ2IsT0FBTztZQUNULENBQUM7WUFFRCxNQUFNLE1BQU0sR0FBRyxNQUFNLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxPQUFPLElBQUksRUFBRSxDQUFDO2lCQUNoRCxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7aUJBQzVCLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUVkLE9BQU8sQ0FBQyxNQUFNLENBQUMsT0FBTyxJQUFJLG1CQUFtQixFQUFFO2dCQUM3QyxXQUFXLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUM7Z0JBQ3ZDLFNBQVMsRUFBRSxNQUFNLElBQUksUUFBUTtnQkFDN0Isb0JBQW9CLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQyxrQkFBa0IsQ0FBQztnQkFDdkQsU0FBUyxFQUFFLE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLGdDQUFnQyxDQUFDLENBQUMsQ0FBQyxJQUFJO2dCQUNyRSxNQUFNLEVBQUUsR0FBRyxNQUFNLENBQUMsS0FBSyxNQUFNLE1BQU0sQ0FBQyxLQUFLLEVBQUU7Z0JBQzNDLEtBQUssRUFBRSxNQUFNLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQzthQUM1QixDQUFDLENBQUM7UUFDTCxDQUFDO1FBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztZQUNiLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUNWLEtBQUssQ0FDSCx1QkFBdUIsR0FBRyxZQUFZLEtBQUssQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQzFFLENBQUM7WUFDRixJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ2YsQ0FBQztJQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBcmdzLCBGbGFncyB9IGZyb20gXCJAb2NsaWYvY29yZVwiO1xuaW1wb3J0IHsgQXV0aGVudGljYXRlZENvbW1hbmQgfSBmcm9tIFwiLi4vLi4vbGliL2Jhc2UtY29tbWFuZC5qc1wiO1xuaW1wb3J0IHsgYXBpQ2xpZW50IH0gZnJvbSBcIi4uLy4uL2xpYi9hcGktY2xpZW50LmpzXCI7XG5pbXBvcnQgeyBzdWNjZXNzLCBlcnJvciwgc3Bpbm5lciwganNvbiwgaXNKc29uTW9kZSB9IGZyb20gXCIuLi8uLi9saWIvb3V0cHV0LmpzXCI7XG5cbmludGVyZmFjZSBCYWNrZmlsbFJlc3BvbnNlIHtcbiAgbWVzc2FnZTogc3RyaW5nO1xuICBzeW50aGVzaXplZDogbnVtYmVyO1xuICBieV90eXBlOiBSZWNvcmQ8c3RyaW5nLCBudW1iZXI+O1xuICB0cnVuY2F0ZWQ6IGJvb2xlYW47XG4gIGNhbmRpZGF0ZXNfc2Nhbm5lZDogbnVtYmVyO1xuICBkZWxpdmVyeV9pZHM6IHN0cmluZ1tdO1xuICBzaW5jZTogc3RyaW5nO1xuICB1bnRpbDogc3RyaW5nO1xuICBsaW1pdDogbnVtYmVyO1xufVxuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBXZWJob29rc0JhY2tmaWxsIGV4dGVuZHMgQXV0aGVudGljYXRlZENvbW1hbmQge1xuICBzdGF0aWMgZGVzY3JpcHRpb24gPVxuICAgIFwiU3ludGhlc2l6ZSBtaXNzZWQgd2ViaG9vayBldmVudHMgZnJvbSB0aGUgbWVzc2FnZSBsb2cuIFVzZSB3aGVuIGFuIG91dGFnZSBsZWZ0IGV2ZW50cyB3aXRoIG5vIGF1ZGl0IHJvdy5cIjtcblxuICBzdGF0aWMgZXhhbXBsZXMgPSBbXG4gICAgXCI8JT0gY29uZmlnLmJpbiAlPiB3ZWJob29rcyBiYWNrZmlsbCB3aGtfYWJjMTIzXCIsXG4gICAgXCI8JT0gY29uZmlnLmJpbiAlPiB3ZWJob29rcyBiYWNrZmlsbCB3aGtfYWJjMTIzIC0tc2luY2UgMjAyNi0wNS0wMVQwMDowMDowMFogLS1saW1pdCA1MDAwXCIsXG4gICAgXCI8JT0gY29uZmlnLmJpbiAlPiB3ZWJob29rcyBiYWNrZmlsbCB3aGtfYWJjMTIzIC0tZXZlbnQtdHlwZXMgbWVzc2FnZS5kZWxpdmVyZWQsbWVzc2FnZS5mYWlsZWRcIixcbiAgXTtcblxuICBzdGF0aWMgYXJncyA9IHtcbiAgICBpZDogQXJncy5zdHJpbmcoeyBkZXNjcmlwdGlvbjogXCJXZWJob29rIElEXCIsIHJlcXVpcmVkOiB0cnVlIH0pLFxuICB9O1xuXG4gIHN0YXRpYyBmbGFncyA9IHtcbiAgICAuLi5BdXRoZW50aWNhdGVkQ29tbWFuZC5iYXNlRmxhZ3MsXG4gICAgc2luY2U6IEZsYWdzLnN0cmluZyh7XG4gICAgICBkZXNjcmlwdGlvbjogXCJFYXJsaWVzdCBtZXNzYWdlIHRpbWUgKElTTy04NjAxKS4gRGVmYXVsdDogbm93IOKIkiAyNGguXCIsXG4gICAgfSksXG4gICAgdW50aWw6IEZsYWdzLnN0cmluZyh7XG4gICAgICBkZXNjcmlwdGlvbjogXCJMYXRlc3QgbWVzc2FnZSB0aW1lIChJU08tODYwMSkuIERlZmF1bHQ6IG5vdy5cIixcbiAgICB9KSxcbiAgICBcImV2ZW50LXR5cGVzXCI6IEZsYWdzLnN0cmluZyh7XG4gICAgICBkZXNjcmlwdGlvbjpcbiAgICAgICAgXCJDb21tYS1zZXBhcmF0ZWQgZXZlbnQgdHlwZXMgdG8gYmFja2ZpbGwgKG1lc3NhZ2Uuc2VudCwgbWVzc2FnZS5kZWxpdmVyZWQsIG1lc3NhZ2UuZmFpbGVkKVwiLFxuICAgIH0pLFxuICAgIGxpbWl0OiBGbGFncy5pbnRlZ2VyKHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcIk1heGltdW0gZXZlbnRzIHRvIHN5bnRoZXNpemUgKG1heCAxMDAwMClcIixcbiAgICAgIGRlZmF1bHQ6IDEwMDAsXG4gICAgfSksXG4gIH07XG5cbiAgYXN5bmMgcnVuKCk6IFByb21pc2U8dm9pZD4ge1xuICAgIGNvbnN0IHsgYXJncywgZmxhZ3MgfSA9IGF3YWl0IHRoaXMucGFyc2UoV2ViaG9va3NCYWNrZmlsbCk7XG5cbiAgICBjb25zdCBib2R5OiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPiA9IHt9O1xuICAgIGlmIChmbGFncy5zaW5jZSkgYm9keS5zaW5jZSA9IGZsYWdzLnNpbmNlO1xuICAgIGlmIChmbGFncy51bnRpbCkgYm9keS51bnRpbCA9IGZsYWdzLnVudGlsO1xuICAgIGlmIChmbGFnc1tcImV2ZW50LXR5cGVzXCJdKVxuICAgICAgYm9keS5ldmVudF90eXBlcyA9IGZsYWdzW1wiZXZlbnQtdHlwZXNcIl1cbiAgICAgICAgLnNwbGl0KFwiLFwiKVxuICAgICAgICAubWFwKChzKSA9PiBzLnRyaW0oKSlcbiAgICAgICAgLmZpbHRlcihCb29sZWFuKTtcbiAgICBpZiAoZmxhZ3MubGltaXQgIT09IHVuZGVmaW5lZCkgYm9keS5saW1pdCA9IGZsYWdzLmxpbWl0O1xuXG4gICAgY29uc3Qgc3AgPSBzcGlubmVyKFwiU3ludGhlc2l6aW5nIG1pc3NlZCBkZWxpdmVyaWVzLi4uXCIpO1xuICAgIHNwLnN0YXJ0KCk7XG5cbiAgICB0cnkge1xuICAgICAgY29uc3QgcmVzdWx0ID0gYXdhaXQgYXBpQ2xpZW50LnBvc3Q8QmFja2ZpbGxSZXNwb25zZT4oXG4gICAgICAgIGAvYXBpL3YxL3dlYmhvb2tzLyR7YXJncy5pZH0vYmFja2ZpbGxgLFxuICAgICAgICBib2R5LFxuICAgICAgKTtcblxuICAgICAgc3Auc3RvcCgpO1xuXG4gICAgICBpZiAoaXNKc29uTW9kZSgpKSB7XG4gICAgICAgIGpzb24ocmVzdWx0KTtcbiAgICAgICAgcmV0dXJuO1xuICAgICAgfVxuXG4gICAgICBjb25zdCBieVR5cGUgPSBPYmplY3QuZW50cmllcyhyZXN1bHQuYnlfdHlwZSA/PyB7fSlcbiAgICAgICAgLm1hcCgoW2ssIHZdKSA9PiBgJHtrfT0ke3Z9YClcbiAgICAgICAgLmpvaW4oXCIsIFwiKTtcblxuICAgICAgc3VjY2VzcyhyZXN1bHQubWVzc2FnZSB8fCBcIkJhY2tmaWxsIGNvbXBsZXRlXCIsIHtcbiAgICAgICAgU3ludGhlc2l6ZWQ6IFN0cmluZyhyZXN1bHQuc3ludGhlc2l6ZWQpLFxuICAgICAgICBcIkJ5IFR5cGVcIjogYnlUeXBlIHx8IFwiKG5vbmUpXCIsXG4gICAgICAgIFwiQ2FuZGlkYXRlcyBTY2FubmVkXCI6IFN0cmluZyhyZXN1bHQuY2FuZGlkYXRlc19zY2FubmVkKSxcbiAgICAgICAgVHJ1bmNhdGVkOiByZXN1bHQudHJ1bmNhdGVkID8gXCJ5ZXMgKG1vcmUgZWxpZ2libGUgdGhhbiBsaW1pdClcIiA6IFwibm9cIixcbiAgICAgICAgV2luZG93OiBgJHtyZXN1bHQuc2luY2V9IOKGkiAke3Jlc3VsdC51bnRpbH1gLFxuICAgICAgICBMaW1pdDogU3RyaW5nKHJlc3VsdC5saW1pdCksXG4gICAgICB9KTtcbiAgICB9IGNhdGNoIChlcnIpIHtcbiAgICAgIHNwLnN0b3AoKTtcbiAgICAgIGVycm9yKFxuICAgICAgICBgRmFpbGVkIHRvIGJhY2tmaWxsOiAke2VyciBpbnN0YW5jZW9mIEVycm9yID8gZXJyLm1lc3NhZ2UgOiBTdHJpbmcoZXJyKX1gLFxuICAgICAgKTtcbiAgICAgIHRoaXMuZXhpdCgxKTtcbiAgICB9XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"backfill.js","sourceRoot":"","sources":["../../../src/commands/webhooks/backfill.ts"],"names":[],"mappings":"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","sourcesContent":["import { Args, Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport { success, error, spinner, json, isJsonMode } from \"../../lib/output.js\";\n\ninterface BackfillResponse {\n  message: string;\n  run_id?: string;\n  synthesized: number;\n  by_type: Record<string, number>;\n  truncated: boolean;\n  candidates_scanned: number;\n  delivery_ids: string[];\n  since: string;\n  until: string;\n  limit: number;\n}\n\nexport default class WebhooksBackfill extends AuthenticatedCommand {\n  static description =\n    \"Synthesize missed webhook events from the message log. Use when an outage left events with no audit row.\";\n\n  static examples = [\n    \"<%= config.bin %> webhooks backfill whk_abc123\",\n    \"<%= config.bin %> webhooks backfill whk_abc123 --since 2026-05-01T00:00:00Z --limit 5000\",\n    \"<%= config.bin %> webhooks backfill whk_abc123 --event-types message.delivered,message.failed\",\n  ];\n\n  static args = {\n    id: Args.string({ description: \"Webhook ID\", required: true }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    since: Flags.string({\n      description: \"Earliest message time (ISO-8601). Default: now − 24h.\",\n    }),\n    until: Flags.string({\n      description: \"Latest message time (ISO-8601). Default: now.\",\n    }),\n    \"event-types\": Flags.string({\n      description:\n        \"Comma-separated event types to backfill (message.sent, message.delivered, message.failed)\",\n    }),\n    limit: Flags.integer({\n      description: \"Maximum events to synthesize (max 10000)\",\n      default: 1000,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { args, flags } = await this.parse(WebhooksBackfill);\n\n    const body: Record<string, unknown> = {};\n    if (flags.since) body.since = flags.since;\n    if (flags.until) body.until = flags.until;\n    if (flags[\"event-types\"])\n      body.event_types = flags[\"event-types\"]\n        .split(\",\")\n        .map((s) => s.trim())\n        .filter(Boolean);\n    if (flags.limit !== undefined) body.limit = flags.limit;\n\n    const sp = spinner(\"Synthesizing missed deliveries...\");\n    sp.start();\n\n    try {\n      const result = await apiClient.post<BackfillResponse>(\n        `/api/v1/webhooks/${args.id}/backfill`,\n        body,\n      );\n\n      sp.stop();\n\n      if (isJsonMode()) {\n        json(result);\n        return;\n      }\n\n      const byType = Object.entries(result.by_type ?? {})\n        .map(([k, v]) => `${k}=${v}`)\n        .join(\", \");\n\n      success(result.message || \"Backfill complete\", {\n        ...(result.run_id ? { \"Run ID\": result.run_id } : {}),\n        Synthesized: String(result.synthesized),\n        \"By Type\": byType || \"(none)\",\n        \"Candidates Scanned\": String(result.candidates_scanned),\n        Truncated: result.truncated ? \"yes (more eligible than limit)\" : \"no\",\n        Window: `${result.since} → ${result.until}`,\n        Limit: String(result.limit),\n      });\n    } catch (err) {\n      sp.stop();\n      error(\n        `Failed to backfill: ${err instanceof Error ? err.message : String(err)}`,\n      );\n      this.exit(1);\n    }\n  }\n}\n"]}

package/dist/commands/webhooks/redeliver.js

@@ -60,6 +60,7 @@ export default class WebhooksRedeliver extends AuthenticatedCommand {
                 return;
             }
             success(result.message || "Redeliver complete", {
+                ...(result.run_id ? { "Run ID": result.run_id } : {}),
                 Requeued: String(result.requeued),
                 Skipped: String(result.skipped),
                 Truncated: result.truncated ? "yes (window larger than limit)" : "no",
@@ -75,4 +76,4 @@ export default class WebhooksRedeliver extends AuthenticatedCommand {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redeliver.js","sourceRoot":"","sources":["../../../src/commands/webhooks/redeliver.ts"],"names":[],"mappings":"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","sourcesContent":["import { Args, Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport { success, error, spinner, json, isJsonMode } from \"../../lib/output.js\";\n\ninterface RedeliverResponse {\n  message: string;\n  requeued: number;\n  skipped: number;\n  truncated: boolean;\n  window_size: number;\n  delivery_ids: string[];\n  since: string;\n  until: string;\n  limit: number;\n}\n\nexport default class WebhooksRedeliver extends AuthenticatedCommand {\n  static description =\n    \"Replay failed or cancelled webhook deliveries from the audit log. Reset the circuit first if it's open.\";\n\n  static examples = [\n    \"<%= config.bin %> webhooks redeliver whk_abc123\",\n    \"<%= config.bin %> webhooks redeliver whk_abc123 --since 2026-05-01T00:00:00Z --limit 5000\",\n    \"<%= config.bin %> webhooks redeliver whk_abc123 --event-types message.delivered,message.failed\",\n  ];\n\n  static args = {\n    id: Args.string({ description: \"Webhook ID\", required: true }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    since: Flags.string({\n      description: \"Earliest delivery time (ISO-8601). Default: now − 24h.\",\n    }),\n    until: Flags.string({\n      description: \"Latest delivery time (ISO-8601). Default: now.\",\n    }),\n    \"event-types\": Flags.string({\n      description: \"Comma-separated event types to filter on\",\n    }),\n    statuses: Flags.string({\n      description:\n        \"Comma-separated delivery statuses to replay. Default: failed,cancelled\",\n    }),\n    limit: Flags.integer({\n      description: \"Maximum deliveries to requeue (max 10000)\",\n      default: 1000,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { args, flags } = await this.parse(WebhooksRedeliver);\n\n    const body: Record<string, unknown> = {};\n    if (flags.since) body.since = flags.since;\n    if (flags.until) body.until = flags.until;\n    if (flags[\"event-types\"])\n      body.event_types = flags[\"event-types\"]\n        .split(\",\")\n        .map((s) => s.trim())\n        .filter(Boolean);\n    if (flags.statuses)\n      body.statuses = flags.statuses\n        .split(\",\")\n        .map((s) => s.trim())\n        .filter(Boolean);\n    if (flags.limit !== undefined) body.limit = flags.limit;\n\n    const sp = spinner(\"Requeuing deliveries...\");\n    sp.start();\n\n    try {\n      const result = await apiClient.post<RedeliverResponse>(\n        `/api/v1/webhooks/${args.id}/redeliver`,\n        body,\n      );\n\n      sp.stop();\n\n      if (isJsonMode()) {\n        json(result);\n        return;\n      }\n\n      success(result.message || \"Redeliver complete\", {\n        Requeued: String(result.requeued),\n        Skipped: String(result.skipped),\n        Truncated: result.truncated ? \"yes (window larger than limit)\" : \"no\",\n        \"Window Size\": String(result.window_size),\n        Window: `${result.since} → ${result.until}`,\n        Limit: String(result.limit),\n      });\n    } catch (err) {\n      sp.stop();\n      error(\n        `Failed to redeliver: ${err instanceof Error ? err.message : String(err)}`,\n      );\n      this.exit(1);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redeliver.js","sourceRoot":"","sources":["../../../src/commands/webhooks/redeliver.ts"],"names":[],"mappings":"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","sourcesContent":["import { Args, Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport { success, error, spinner, json, isJsonMode } from \"../../lib/output.js\";\n\ninterface RedeliverResponse {\n  message: string;\n  run_id?: string;\n  requeued: number;\n  skipped: number;\n  truncated: boolean;\n  window_size: number;\n  delivery_ids: string[];\n  since: string;\n  until: string;\n  limit: number;\n}\n\nexport default class WebhooksRedeliver extends AuthenticatedCommand {\n  static description =\n    \"Replay failed or cancelled webhook deliveries from the audit log. Reset the circuit first if it's open.\";\n\n  static examples = [\n    \"<%= config.bin %> webhooks redeliver whk_abc123\",\n    \"<%= config.bin %> webhooks redeliver whk_abc123 --since 2026-05-01T00:00:00Z --limit 5000\",\n    \"<%= config.bin %> webhooks redeliver whk_abc123 --event-types message.delivered,message.failed\",\n  ];\n\n  static args = {\n    id: Args.string({ description: \"Webhook ID\", required: true }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    since: Flags.string({\n      description: \"Earliest delivery time (ISO-8601). Default: now − 24h.\",\n    }),\n    until: Flags.string({\n      description: \"Latest delivery time (ISO-8601). Default: now.\",\n    }),\n    \"event-types\": Flags.string({\n      description: \"Comma-separated event types to filter on\",\n    }),\n    statuses: Flags.string({\n      description:\n        \"Comma-separated delivery statuses to replay. Default: failed,cancelled\",\n    }),\n    limit: Flags.integer({\n      description: \"Maximum deliveries to requeue (max 10000)\",\n      default: 1000,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { args, flags } = await this.parse(WebhooksRedeliver);\n\n    const body: Record<string, unknown> = {};\n    if (flags.since) body.since = flags.since;\n    if (flags.until) body.until = flags.until;\n    if (flags[\"event-types\"])\n      body.event_types = flags[\"event-types\"]\n        .split(\",\")\n        .map((s) => s.trim())\n        .filter(Boolean);\n    if (flags.statuses)\n      body.statuses = flags.statuses\n        .split(\",\")\n        .map((s) => s.trim())\n        .filter(Boolean);\n    if (flags.limit !== undefined) body.limit = flags.limit;\n\n    const sp = spinner(\"Requeuing deliveries...\");\n    sp.start();\n\n    try {\n      const result = await apiClient.post<RedeliverResponse>(\n        `/api/v1/webhooks/${args.id}/redeliver`,\n        body,\n      );\n\n      sp.stop();\n\n      if (isJsonMode()) {\n        json(result);\n        return;\n      }\n\n      success(result.message || \"Redeliver complete\", {\n        ...(result.run_id ? { \"Run ID\": result.run_id } : {}),\n        Requeued: String(result.requeued),\n        Skipped: String(result.skipped),\n        Truncated: result.truncated ? \"yes (window larger than limit)\" : \"no\",\n        \"Window Size\": String(result.window_size),\n        Window: `${result.since} → ${result.until}`,\n        Limit: String(result.limit),\n      });\n    } catch (err) {\n      sp.stop();\n      error(\n        `Failed to redeliver: ${err instanceof Error ? err.message : String(err)}`,\n      );\n      this.exit(1);\n    }\n  }\n}\n"]}

package/dist/lib/auth.js

@@ -6,6 +6,7 @@ import open from "open";
 import * as crypto from "node:crypto";
 import { setAuthTokens, setApiKey, clearAuth, getConfigValue, isAuthenticated, getAuthToken, } from "./config.js";
 import { colors, spinner } from "./output.js";
+import { attachLoginKeypressHandler } from "./keypress.js";
 const USER_CODE_LENGTH = 8;
 const POLL_INTERVAL = 2000; // 2 seconds
 const MAX_POLL_ATTEMPTS = 150; // 5 minutes max
@@ -135,99 +136,6 @@ export async function browserLogin() {
     keypressCleanup();
     process.exit(1);
 }
-/**
- * Wire up the copy-URL / cancel keybindings during the device-code
- * polling loop. Only active on a real interactive TTY — in CI, piped
- * stdin, or when stdin.setRawMode is missing we no-op and return a
- * cleanup that also no-ops.
- *
- * Returns a cleanup function that the caller MUST invoke on every exit
- * path (success, timeout, error) so the terminal doesn't stay in raw
- * mode. Calling cleanup twice is safe.
- */
-function attachLoginKeypressHandler(urlToCopy) {
-    const stdin = process.stdin;
-    if (!stdin.isTTY || typeof stdin.setRawMode !== "function") {
-        return () => { };
-    }
-    let cleaned = false;
-    const previousRawMode = stdin.isRaw;
-    console.log(colors.dim("Press [c] to copy URL to clipboard · [q] or Ctrl-C to cancel"));
-    const onData = (key) => {
-        const k = typeof key === "string" ? key : key.toString("utf8");
-        if (k === "c" || k === "C") {
-            copyToClipboard(urlToCopy)
-                .then((ok) => {
-                if (ok) {
-                    // Overwrite the hint line with a transient confirmation.
-                    process.stdout.write("\r" + " ".repeat(70) + "\r" + colors.success("  ✓ URL copied to clipboard\n"));
-                }
-                else {
-                    process.stdout.write("\r" + colors.warning("  ✗ Could not copy — copy the URL manually\n"));
-                }
-            })
-                .catch(() => { });
-            return;
-        }
-        if (k === "q" || k === "Q" || k === "\u0003") {
-            cleanup();
-            console.log(colors.warning("\n  Login cancelled."));
-            process.exit(130);
-        }
-    };
-    stdin.setRawMode(true);
-    stdin.resume();
-    stdin.setEncoding("utf8");
-    stdin.on("data", onData);
-    const cleanup = () => {
-        if (cleaned)
-            return;
-        cleaned = true;
-        try {
-            stdin.removeListener("data", onData);
-            stdin.setRawMode(previousRawMode);
-            stdin.pause();
-        }
-        catch {
-            /* no-op */
-        }
-    };
-    return cleanup;
-}
-/**
- * Copy text to the system clipboard via the OS's native tool. Returns
- * true if the write succeeded. Does not throw. Shells out rather than
- * adding a native clipboard dep — the three commands (pbcopy / clip /
- * xclip / wl-copy) cover every platform the CLI runs on.
- */
-async function copyToClipboard(text) {
-    const { spawn } = await import("node:child_process");
-    const candidates = process.platform === "darwin"
-        ? [["pbcopy", []]]
-        : process.platform === "win32"
-            ? [["clip", []]]
-            : [
-                ["wl-copy", []],
-                ["xclip", ["-selection", "clipboard"]],
-                ["xsel", ["--clipboard", "--input"]],
-            ];
-    for (const [cmd, args] of candidates) {
-        try {
-            const ok = await new Promise((resolve) => {
-                const child = spawn(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
-                child.on("error", () => resolve(false));
-                child.on("exit", (code) => resolve(code === 0));
-                child.stdin.end(text);
-            });
-            if (ok)
-                return true;
-        }
-        catch {
-            // try next candidate
-        }
-    }
-    return false;
-}
 /**
  * Login with an API key directly
  */
@@ -287,4 +195,4 @@ export async function getAuthInfo() {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/lib/auth.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Authentication utilities for CLI\n * Handles browser-based login flow and API key authentication\n */\n\nimport open from \"open\";\nimport * as http from \"node:http\";\nimport * as crypto from \"node:crypto\";\nimport {\n  setAuthTokens,\n  setApiKey,\n  clearAuth,\n  getConfigValue,\n  isAuthenticated,\n  getAuthToken,\n} from \"./config.js\";\nimport { colors, spinner } from \"./output.js\";\n\nconst USER_CODE_LENGTH = 8;\nconst POLL_INTERVAL = 2000; // 2 seconds\nconst MAX_POLL_ATTEMPTS = 150; // 5 minutes max\n\nexport interface DeviceCodeResponse {\n  deviceCode: string;\n  userCode: string;\n  verificationUrl: string;\n  expiresIn: number;\n  interval: number;\n}\n\nexport interface TokenResponse {\n  accessToken: string;\n  refreshToken: string;\n  expiresIn: number;\n  userId: string;\n  email: string;\n}\n\n/**\n * Generate a long random device code for URL (session identifier)\n * This goes in the URL and identifies which CLI session is waiting\n */\nexport function generateDeviceCode(): string {\n  return crypto.randomBytes(16).toString(\"hex\"); // 32 chars, not guessable\n}\n\n/**\n * Generate a short human-readable user code for terminal display\n * This is what the user types to prove they have terminal access\n * Uses characters that are easy to read and type (no 0/O, 1/I/L confusion)\n */\nexport function generateUserCode(): string {\n  const chars = \"ABCDEFGHJKLMNPQRSTUVWXYZ23456789\"; // Exclude confusing chars\n  let code = \"\";\n  const bytes = crypto.randomBytes(USER_CODE_LENGTH);\n  for (let i = 0; i < USER_CODE_LENGTH; i++) {\n    code += chars[bytes[i] % chars.length];\n  }\n  return code;\n}\n\n/**\n * Start the browser-based login flow\n *\n * Security model:\n * - deviceCode: Long random token in URL, identifies CLI session (not secret)\n * - userCode: Short code shown ONLY in terminal, proves user has terminal access\n *\n * The userCode is NEVER in the URL - this is critical for security.\n * Anyone with the URL can't authorize without also seeing the terminal.\n */\nexport async function browserLogin(): Promise<TokenResponse> {\n  const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n\n  // Generate TWO SEPARATE codes for security\n  const deviceCode = generateDeviceCode(); // Long random, goes in URL\n  const userCode = generateUserCode(); // Short readable, shown in terminal only\n\n  // Request device code registration from server\n  const response = await fetch(`${baseUrl}/api/cli/auth/device-code`, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/json\" },\n    body: JSON.stringify({ deviceCode, userCode }), // Send both to server\n  });\n\n  if (!response.ok) {\n    const error = (await response.json().catch(() => ({}))) as {\n      message?: string;\n    };\n    throw new Error(error.message || \"Failed to initiate login\");\n  }\n\n  const data = (await response.json()) as DeviceCodeResponse;\n\n  // Format user code with hyphen for readability (e.g., \"ABCD-EFGH\")\n  const displayUserCode = `${userCode.slice(0, 4)}-${userCode.slice(4)}`;\n\n  // Display instructions to user\n  console.log();\n  console.log(colors.bold(\"Login to Sendly\"));\n  console.log();\n  console.log(`Open this URL in your browser:`);\n  console.log(colors.primary(`  ${data.verificationUrl}`));\n  console.log();\n  console.log(`And enter this code:`);\n  console.log(colors.bold(colors.primary(`  ${displayUserCode}`)));\n  console.log();\n\n  // Try to open browser automatically\n  try {\n    await open(data.verificationUrl);\n    console.log(colors.dim(\"Browser opened automatically\"));\n  } catch {\n    console.log(colors.dim(\"Please open the URL manually\"));\n  }\n\n  // Enable press-to-copy UX while we poll. Only wire this when we have a\n  // real interactive TTY — in CI or piped stdin there's nothing to read\n  // from and setRawMode throws. The keypress listener is detached on any\n  // exit path (success, timeout, error) so we don't leave the terminal in\n  // raw mode.\n  const keypressCleanup = attachLoginKeypressHandler(data.verificationUrl);\n\n  console.log();\n\n  // Poll for token\n  const spin = spinner(\"Waiting for authorization...\");\n  spin.start();\n\n  let attempts = 0;\n  while (attempts < MAX_POLL_ATTEMPTS) {\n    await sleep(data.interval * 1000 || POLL_INTERVAL);\n    attempts++;\n\n    try {\n      const tokenResponse = await fetch(`${baseUrl}/api/cli/auth/token`, {\n        method: \"POST\",\n        headers: { \"Content-Type\": \"application/json\" },\n        body: JSON.stringify({ deviceCode }),\n      });\n\n      if (tokenResponse.ok) {\n        const tokens = (await tokenResponse.json()) as TokenResponse;\n        spin.succeed(\"Authorized\");\n        keypressCleanup();\n\n        // Store tokens\n        setAuthTokens(\n          tokens.accessToken,\n          tokens.refreshToken,\n          tokens.expiresIn,\n          tokens.userId,\n          tokens.email,\n        );\n\n        // Check if new user needs quick-start (only for CLI sessions)\n        if (tokens.accessToken.startsWith(\"cli_\")) {\n          const { shouldOfferQuickStart, offerQuickStart } =\n            await import(\"./onboarding.js\");\n\n          if (await shouldOfferQuickStart()) {\n            await offerQuickStart();\n          }\n        }\n\n        return tokens;\n      }\n\n      const errorData = (await tokenResponse.json().catch(() => ({}))) as {\n        error?: string;\n      };\n\n      if (errorData.error === \"authorization_pending\") {\n        // Still waiting, continue polling\n        continue;\n      }\n\n      if (errorData.error === \"expired_token\") {\n        spin.fail(\"Login request expired\");\n        keypressCleanup();\n        process.exit(1);\n      }\n\n      if (errorData.error === \"access_denied\") {\n        spin.fail(\"Login was denied\");\n        keypressCleanup();\n        process.exit(1);\n      }\n    } catch (error) {\n      // Network error, continue polling\n    }\n  }\n\n  spin.fail(\"Login timed out\");\n  keypressCleanup();\n  process.exit(1);\n}\n\n/**\n * Wire up the copy-URL / cancel keybindings during the device-code\n * polling loop. Only active on a real interactive TTY — in CI, piped\n * stdin, or when stdin.setRawMode is missing we no-op and return a\n * cleanup that also no-ops.\n *\n * Returns a cleanup function that the caller MUST invoke on every exit\n * path (success, timeout, error) so the terminal doesn't stay in raw\n * mode. Calling cleanup twice is safe.\n */\nfunction attachLoginKeypressHandler(urlToCopy: string): () => void {\n  const stdin = process.stdin;\n  if (!stdin.isTTY || typeof stdin.setRawMode !== \"function\") {\n    return () => {};\n  }\n\n  let cleaned = false;\n  const previousRawMode = stdin.isRaw;\n\n  console.log(\n    colors.dim(\n      \"Press [c] to copy URL to clipboard · [q] or Ctrl-C to cancel\",\n    ),\n  );\n\n  const onData = (key: Buffer | string): void => {\n    const k = typeof key === \"string\" ? key : key.toString(\"utf8\");\n    if (k === \"c\" || k === \"C\") {\n      copyToClipboard(urlToCopy)\n        .then((ok) => {\n          if (ok) {\n            // Overwrite the hint line with a transient confirmation.\n            process.stdout.write(\n              \"\\r\" + \" \".repeat(70) + \"\\r\" + colors.success(\"  ✓ URL copied to clipboard\\n\"),\n            );\n          } else {\n            process.stdout.write(\n              \"\\r\" + colors.warning(\"  ✗ Could not copy — copy the URL manually\\n\"),\n            );\n          }\n        })\n        .catch(() => {});\n      return;\n    }\n    if (k === \"q\" || k === \"Q\" || k === \"\\u0003\") {\n      cleanup();\n      console.log(colors.warning(\"\\n  Login cancelled.\"));\n      process.exit(130);\n    }\n  };\n\n  stdin.setRawMode(true);\n  stdin.resume();\n  stdin.setEncoding(\"utf8\");\n  stdin.on(\"data\", onData);\n\n  const cleanup = (): void => {\n    if (cleaned) return;\n    cleaned = true;\n    try {\n      stdin.removeListener(\"data\", onData);\n      stdin.setRawMode(previousRawMode);\n      stdin.pause();\n    } catch {\n      /* no-op */\n    }\n  };\n\n  return cleanup;\n}\n\n/**\n * Copy text to the system clipboard via the OS's native tool. Returns\n * true if the write succeeded. Does not throw. Shells out rather than\n * adding a native clipboard dep — the three commands (pbcopy / clip /\n * xclip / wl-copy) cover every platform the CLI runs on.\n */\nasync function copyToClipboard(text: string): Promise<boolean> {\n  const { spawn } = await import(\"node:child_process\");\n  const candidates: Array<[string, string[]]> =\n    process.platform === \"darwin\"\n      ? [[\"pbcopy\", []]]\n      : process.platform === \"win32\"\n        ? [[\"clip\", []]]\n        : [\n            [\"wl-copy\", []],\n            [\"xclip\", [\"-selection\", \"clipboard\"]],\n            [\"xsel\", [\"--clipboard\", \"--input\"]],\n          ];\n\n  for (const [cmd, args] of candidates) {\n    try {\n      const ok = await new Promise<boolean>((resolve) => {\n        const child = spawn(cmd, args, { stdio: [\"pipe\", \"ignore\", \"ignore\"] });\n        child.on(\"error\", () => resolve(false));\n        child.on(\"exit\", (code) => resolve(code === 0));\n        child.stdin.end(text);\n      });\n      if (ok) return true;\n    } catch {\n      // try next candidate\n    }\n  }\n  return false;\n}\n\n/**\n * Login with an API key directly\n */\nexport async function apiKeyLogin(apiKey: string): Promise<void> {\n  const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n\n  // Validate the API key with the server\n  const response = await fetch(`${baseUrl}/api/cli/auth/verify-key`, {\n    method: \"POST\",\n    headers: {\n      \"Content-Type\": \"application/json\",\n      Authorization: `Bearer ${apiKey}`,\n    },\n  });\n\n  if (!response.ok) {\n    const error = (await response.json().catch(() => ({}))) as {\n      message?: string;\n    };\n    throw new Error(error.message || \"Invalid API key\");\n  }\n\n  // Store the API key\n  setApiKey(apiKey);\n}\n\n/**\n * Logout - clear all stored credentials\n */\nexport function logout(): void {\n  clearAuth();\n}\n\n/**\n * Check if currently authenticated\n */\nexport function checkAuth(): boolean {\n  return isAuthenticated();\n}\n\n/**\n * Get current auth info for display\n */\nexport async function getAuthInfo(): Promise<{\n  authenticated: boolean;\n  email?: string;\n  userId?: string;\n  environment: string;\n  keyType?: string;\n}> {\n  const token = getAuthToken();\n  const email = getConfigValue(\"email\");\n  const userId = getConfigValue(\"userId\");\n  const apiKey = getConfigValue(\"apiKey\");\n  const environment = getConfigValue(\"environment\");\n\n  if (!token && !apiKey) {\n    return { authenticated: false, environment };\n  }\n\n  let keyType: string | undefined;\n  if (apiKey) {\n    keyType = apiKey.startsWith(\"sk_test_\") ? \"test\" : \"live\";\n  }\n\n  return {\n    authenticated: true,\n    email,\n    userId,\n    environment,\n    keyType,\n  };\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/lib/auth.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Authentication utilities for CLI\n * Handles browser-based login flow and API key authentication\n */\n\nimport open from \"open\";\nimport * as http from \"node:http\";\nimport * as crypto from \"node:crypto\";\nimport {\n  setAuthTokens,\n  setApiKey,\n  clearAuth,\n  getConfigValue,\n  isAuthenticated,\n  getAuthToken,\n} from \"./config.js\";\nimport { colors, spinner } from \"./output.js\";\nimport { attachLoginKeypressHandler } from \"./keypress.js\";\n\nconst USER_CODE_LENGTH = 8;\nconst POLL_INTERVAL = 2000; // 2 seconds\nconst MAX_POLL_ATTEMPTS = 150; // 5 minutes max\n\nexport interface DeviceCodeResponse {\n  deviceCode: string;\n  userCode: string;\n  verificationUrl: string;\n  expiresIn: number;\n  interval: number;\n}\n\nexport interface TokenResponse {\n  accessToken: string;\n  refreshToken: string;\n  expiresIn: number;\n  userId: string;\n  email: string;\n}\n\n/**\n * Generate a long random device code for URL (session identifier)\n * This goes in the URL and identifies which CLI session is waiting\n */\nexport function generateDeviceCode(): string {\n  return crypto.randomBytes(16).toString(\"hex\"); // 32 chars, not guessable\n}\n\n/**\n * Generate a short human-readable user code for terminal display\n * This is what the user types to prove they have terminal access\n * Uses characters that are easy to read and type (no 0/O, 1/I/L confusion)\n */\nexport function generateUserCode(): string {\n  const chars = \"ABCDEFGHJKLMNPQRSTUVWXYZ23456789\"; // Exclude confusing chars\n  let code = \"\";\n  const bytes = crypto.randomBytes(USER_CODE_LENGTH);\n  for (let i = 0; i < USER_CODE_LENGTH; i++) {\n    code += chars[bytes[i] % chars.length];\n  }\n  return code;\n}\n\n/**\n * Start the browser-based login flow\n *\n * Security model:\n * - deviceCode: Long random token in URL, identifies CLI session (not secret)\n * - userCode: Short code shown ONLY in terminal, proves user has terminal access\n *\n * The userCode is NEVER in the URL - this is critical for security.\n * Anyone with the URL can't authorize without also seeing the terminal.\n */\nexport async function browserLogin(): Promise<TokenResponse> {\n  const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n\n  // Generate TWO SEPARATE codes for security\n  const deviceCode = generateDeviceCode(); // Long random, goes in URL\n  const userCode = generateUserCode(); // Short readable, shown in terminal only\n\n  // Request device code registration from server\n  const response = await fetch(`${baseUrl}/api/cli/auth/device-code`, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/json\" },\n    body: JSON.stringify({ deviceCode, userCode }), // Send both to server\n  });\n\n  if (!response.ok) {\n    const error = (await response.json().catch(() => ({}))) as {\n      message?: string;\n    };\n    throw new Error(error.message || \"Failed to initiate login\");\n  }\n\n  const data = (await response.json()) as DeviceCodeResponse;\n\n  // Format user code with hyphen for readability (e.g., \"ABCD-EFGH\")\n  const displayUserCode = `${userCode.slice(0, 4)}-${userCode.slice(4)}`;\n\n  // Display instructions to user\n  console.log();\n  console.log(colors.bold(\"Login to Sendly\"));\n  console.log();\n  console.log(`Open this URL in your browser:`);\n  console.log(colors.primary(`  ${data.verificationUrl}`));\n  console.log();\n  console.log(`And enter this code:`);\n  console.log(colors.bold(colors.primary(`  ${displayUserCode}`)));\n  console.log();\n\n  // Try to open browser automatically\n  try {\n    await open(data.verificationUrl);\n    console.log(colors.dim(\"Browser opened automatically\"));\n  } catch {\n    console.log(colors.dim(\"Please open the URL manually\"));\n  }\n\n  // Enable press-to-copy UX while we poll. Only wire this when we have a\n  // real interactive TTY — in CI or piped stdin there's nothing to read\n  // from and setRawMode throws. The keypress listener is detached on any\n  // exit path (success, timeout, error) so we don't leave the terminal in\n  // raw mode.\n  const keypressCleanup = attachLoginKeypressHandler(data.verificationUrl);\n\n  console.log();\n\n  // Poll for token\n  const spin = spinner(\"Waiting for authorization...\");\n  spin.start();\n\n  let attempts = 0;\n  while (attempts < MAX_POLL_ATTEMPTS) {\n    await sleep(data.interval * 1000 || POLL_INTERVAL);\n    attempts++;\n\n    try {\n      const tokenResponse = await fetch(`${baseUrl}/api/cli/auth/token`, {\n        method: \"POST\",\n        headers: { \"Content-Type\": \"application/json\" },\n        body: JSON.stringify({ deviceCode }),\n      });\n\n      if (tokenResponse.ok) {\n        const tokens = (await tokenResponse.json()) as TokenResponse;\n        spin.succeed(\"Authorized\");\n        keypressCleanup();\n\n        // Store tokens\n        setAuthTokens(\n          tokens.accessToken,\n          tokens.refreshToken,\n          tokens.expiresIn,\n          tokens.userId,\n          tokens.email,\n        );\n\n        // Check if new user needs quick-start (only for CLI sessions)\n        if (tokens.accessToken.startsWith(\"cli_\")) {\n          const { shouldOfferQuickStart, offerQuickStart } =\n            await import(\"./onboarding.js\");\n\n          if (await shouldOfferQuickStart()) {\n            await offerQuickStart();\n          }\n        }\n\n        return tokens;\n      }\n\n      const errorData = (await tokenResponse.json().catch(() => ({}))) as {\n        error?: string;\n      };\n\n      if (errorData.error === \"authorization_pending\") {\n        // Still waiting, continue polling\n        continue;\n      }\n\n      if (errorData.error === \"expired_token\") {\n        spin.fail(\"Login request expired\");\n        keypressCleanup();\n        process.exit(1);\n      }\n\n      if (errorData.error === \"access_denied\") {\n        spin.fail(\"Login was denied\");\n        keypressCleanup();\n        process.exit(1);\n      }\n    } catch (error) {\n      // Network error, continue polling\n    }\n  }\n\n  spin.fail(\"Login timed out\");\n  keypressCleanup();\n  process.exit(1);\n}\n\n/**\n * Login with an API key directly\n */\nexport async function apiKeyLogin(apiKey: string): Promise<void> {\n  const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n\n  // Validate the API key with the server\n  const response = await fetch(`${baseUrl}/api/cli/auth/verify-key`, {\n    method: \"POST\",\n    headers: {\n      \"Content-Type\": \"application/json\",\n      Authorization: `Bearer ${apiKey}`,\n    },\n  });\n\n  if (!response.ok) {\n    const error = (await response.json().catch(() => ({}))) as {\n      message?: string;\n    };\n    throw new Error(error.message || \"Invalid API key\");\n  }\n\n  // Store the API key\n  setApiKey(apiKey);\n}\n\n/**\n * Logout - clear all stored credentials\n */\nexport function logout(): void {\n  clearAuth();\n}\n\n/**\n * Check if currently authenticated\n */\nexport function checkAuth(): boolean {\n  return isAuthenticated();\n}\n\n/**\n * Get current auth info for display\n */\nexport async function getAuthInfo(): Promise<{\n  authenticated: boolean;\n  email?: string;\n  userId?: string;\n  environment: string;\n  keyType?: string;\n}> {\n  const token = getAuthToken();\n  const email = getConfigValue(\"email\");\n  const userId = getConfigValue(\"userId\");\n  const apiKey = getConfigValue(\"apiKey\");\n  const environment = getConfigValue(\"environment\");\n\n  if (!token && !apiKey) {\n    return { authenticated: false, environment };\n  }\n\n  let keyType: string | undefined;\n  if (apiKey) {\n    keyType = apiKey.startsWith(\"sk_test_\") ? \"test\" : \"live\";\n  }\n\n  return {\n    authenticated: true,\n    email,\n    userId,\n    environment,\n    keyType,\n  };\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"]}