@sendly/cli 3.12.2 → 3.13.0

package/dist/commands/contacts/lists/create.js

@@ -0,0 +1,40 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, json, colors, isJsonMode } from "../../../lib/output.js";
+export default class ContactsListsCreate extends AuthenticatedCommand {
+    static description = "Create a new contact list";
+    static examples = [
+        '<%= config.bin %> contacts lists create --name "VIP Customers"',
+        '<%= config.bin %> contacts lists create --name "Newsletter" --description "Weekly newsletter subscribers"',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "List name",
+            required: true,
+        }),
+        description: Flags.string({
+            char: "d",
+            description: "List description",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ContactsListsCreate);
+        const list = await apiClient.post("/api/v1/contact-lists", {
+            name: flags.name,
+            description: flags.description,
+        });
+        if (isJsonMode()) {
+            json(list);
+            return;
+        }
+        success("Contact list created", {
+            ID: list.id,
+            Name: list.name,
+            Description: list.description || colors.dim("(none)"),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2NvbW1hbmRzL2NvbnRhY3RzL2xpc3RzL2NyZWF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ3BDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ3BFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFVM0UsTUFBTSxDQUFDLE9BQU8sT0FBTyxtQkFBb0IsU0FBUSxvQkFBb0I7SUFDbkUsTUFBTSxDQUFDLFdBQVcsR0FBRywyQkFBMkIsQ0FBQztJQUVqRCxNQUFNLENBQUMsUUFBUSxHQUFHO1FBQ2hCLGdFQUFnRTtRQUNoRSwyR0FBMkc7S0FDNUcsQ0FBQztJQUVGLE1BQU0sQ0FBQyxLQUFLLEdBQUc7UUFDYixHQUFHLG9CQUFvQixDQUFDLFNBQVM7UUFDakMsSUFBSSxFQUFFLEtBQUssQ0FBQyxNQUFNLENBQUM7WUFDakIsSUFBSSxFQUFFLEdBQUc7WUFDVCxXQUFXLEVBQUUsV0FBVztZQUN4QixRQUFRLEVBQUUsSUFBSTtTQUNmLENBQUM7UUFDRixXQUFXLEVBQUUsS0FBSyxDQUFDLE1BQU0sQ0FBQztZQUN4QixJQUFJLEVBQUUsR0FBRztZQUNULFdBQVcsRUFBRSxrQkFBa0I7U0FDaEMsQ0FBQztLQUNILENBQUM7SUFFRixLQUFLLENBQUMsR0FBRztRQUNQLE1BQU0sRUFBRSxLQUFLLEVBQUUsR0FBRyxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsbUJBQW1CLENBQUMsQ0FBQztRQUV4RCxNQUFNLElBQUksR0FBRyxNQUFNLFNBQVMsQ0FBQyxJQUFJLENBQWMsdUJBQXVCLEVBQUU7WUFDdEUsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJO1lBQ2hCLFdBQVcsRUFBRSxLQUFLLENBQUMsV0FBVztTQUMvQixDQUFDLENBQUM7UUFFSCxJQUFJLFVBQVUsRUFBRSxFQUFFLENBQUM7WUFDakIsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQ1gsT0FBTztRQUNULENBQUM7UUFFRCxPQUFPLENBQUMsc0JBQXNCLEVBQUU7WUFDOUIsRUFBRSxFQUFFLElBQUksQ0FBQyxFQUFFO1lBQ1gsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJO1lBQ2YsV0FBVyxFQUFFLElBQUksQ0FBQyxXQUFXLElBQUksTUFBTSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUM7U0FDdEQsQ0FBQyxDQUFDO0lBQ0wsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZsYWdzIH0gZnJvbSBcIkBvY2xpZi9jb3JlXCI7XG5pbXBvcnQgeyBBdXRoZW50aWNhdGVkQ29tbWFuZCB9IGZyb20gXCIuLi8uLi8uLi9saWIvYmFzZS1jb21tYW5kLmpzXCI7XG5pbXBvcnQgeyBhcGlDbGllbnQgfSBmcm9tIFwiLi4vLi4vLi4vbGliL2FwaS1jbGllbnQuanNcIjtcbmltcG9ydCB7IHN1Y2Nlc3MsIGpzb24sIGNvbG9ycywgaXNKc29uTW9kZSB9IGZyb20gXCIuLi8uLi8uLi9saWIvb3V0cHV0LmpzXCI7XG5cbmludGVyZmFjZSBDb250YWN0TGlzdCB7XG4gIGlkOiBzdHJpbmc7XG4gIG5hbWU6IHN0cmluZztcbiAgZGVzY3JpcHRpb24/OiBzdHJpbmc7XG4gIGNvbnRhY3RfY291bnQ6IG51bWJlcjtcbiAgY3JlYXRlZF9hdDogc3RyaW5nO1xufVxuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBDb250YWN0c0xpc3RzQ3JlYXRlIGV4dGVuZHMgQXV0aGVudGljYXRlZENvbW1hbmQge1xuICBzdGF0aWMgZGVzY3JpcHRpb24gPSBcIkNyZWF0ZSBhIG5ldyBjb250YWN0IGxpc3RcIjtcblxuICBzdGF0aWMgZXhhbXBsZXMgPSBbXG4gICAgJzwlPSBjb25maWcuYmluICU+IGNvbnRhY3RzIGxpc3RzIGNyZWF0ZSAtLW5hbWUgXCJWSVAgQ3VzdG9tZXJzXCInLFxuICAgICc8JT0gY29uZmlnLmJpbiAlPiBjb250YWN0cyBsaXN0cyBjcmVhdGUgLS1uYW1lIFwiTmV3c2xldHRlclwiIC0tZGVzY3JpcHRpb24gXCJXZWVrbHkgbmV3c2xldHRlciBzdWJzY3JpYmVyc1wiJyxcbiAgXTtcblxuICBzdGF0aWMgZmxhZ3MgPSB7XG4gICAgLi4uQXV0aGVudGljYXRlZENvbW1hbmQuYmFzZUZsYWdzLFxuICAgIG5hbWU6IEZsYWdzLnN0cmluZyh7XG4gICAgICBjaGFyOiBcIm5cIixcbiAgICAgIGRlc2NyaXB0aW9uOiBcIkxpc3QgbmFtZVwiLFxuICAgICAgcmVxdWlyZWQ6IHRydWUsXG4gICAgfSksXG4gICAgZGVzY3JpcHRpb246IEZsYWdzLnN0cmluZyh7XG4gICAgICBjaGFyOiBcImRcIixcbiAgICAgIGRlc2NyaXB0aW9uOiBcIkxpc3QgZGVzY3JpcHRpb25cIixcbiAgICB9KSxcbiAgfTtcblxuICBhc3luYyBydW4oKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgY29uc3QgeyBmbGFncyB9ID0gYXdhaXQgdGhpcy5wYXJzZShDb250YWN0c0xpc3RzQ3JlYXRlKTtcblxuICAgIGNvbnN0IGxpc3QgPSBhd2FpdCBhcGlDbGllbnQucG9zdDxDb250YWN0TGlzdD4oXCIvYXBpL3YxL2NvbnRhY3QtbGlzdHNcIiwge1xuICAgICAgbmFtZTogZmxhZ3MubmFtZSxcbiAgICAgIGRlc2NyaXB0aW9uOiBmbGFncy5kZXNjcmlwdGlvbixcbiAgICB9KTtcblxuICAgIGlmIChpc0pzb25Nb2RlKCkpIHtcbiAgICAgIGpzb24obGlzdCk7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgc3VjY2VzcyhcIkNvbnRhY3QgbGlzdCBjcmVhdGVkXCIsIHtcbiAgICAgIElEOiBsaXN0LmlkLFxuICAgICAgTmFtZTogbGlzdC5uYW1lLFxuICAgICAgRGVzY3JpcHRpb246IGxpc3QuZGVzY3JpcHRpb24gfHwgY29sb3JzLmRpbShcIihub25lKVwiKSxcbiAgICB9KTtcbiAgfVxufVxuIl19

package/dist/commands/contacts/lists/delete.d.ts

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class ContactsListsDelete extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/contacts/lists/delete.js

@@ -0,0 +1,52 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, error, json, colors, isJsonMode } from "../../../lib/output.js";
+import inquirer from "inquirer";
+export default class ContactsListsDelete extends AuthenticatedCommand {
+    static description = "Delete a contact list (does not delete the contacts)";
+    static examples = [
+        "<%= config.bin %> contacts lists delete lst_xxx",
+        "<%= config.bin %> contacts lists delete lst_xxx --yes",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Contact list ID to delete",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ContactsListsDelete);
+        if (!flags.yes) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Are you sure you want to delete list ${colors.code(args.id)}? Contacts will NOT be deleted.`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                error("Deletion cancelled");
+                return;
+            }
+        }
+        await apiClient.delete(`/api/v1/contact-lists/${args.id}`);
+        if (isJsonMode()) {
+            json({ success: true, deletedId: args.id });
+            return;
+        }
+        success("Contact list deleted", {
+            ID: args.id,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/contacts/lists/index.d.ts

@@ -0,0 +1,10 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class ContactsListsList extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/contacts/lists/index.js

@@ -0,0 +1,68 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { table, json, info, formatRelativeTime, colors, isJsonMode, } from "../../../lib/output.js";
+export default class ContactsListsList extends AuthenticatedCommand {
+    static description = "List all contact lists";
+    static examples = [
+        "<%= config.bin %> contacts lists",
+        "<%= config.bin %> contacts lists --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        await this.parse(ContactsListsList);
+        const response = await apiClient.get("/api/v1/contact-lists");
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (response.lists.length === 0) {
+            info("No contact lists found");
+            return;
+        }
+        console.log();
+        console.log(colors.dim(`${response.lists.length} contact lists`));
+        console.log();
+        table(response.lists, [
+            {
+                header: "ID",
+                key: "id",
+                width: 18,
+                formatter: (v) => colors.dim(String(v).slice(0, 15) + "..."),
+            },
+            {
+                header: "Name",
+                key: "name",
+                width: 24,
+                formatter: (v) => {
+                    const name = String(v);
+                    return name.length > 22 ? name.slice(0, 22) + "..." : name;
+                },
+            },
+            {
+                header: "Description",
+                key: "description",
+                width: 28,
+                formatter: (v) => {
+                    if (!v)
+                        return colors.dim("-");
+                    const desc = String(v);
+                    return desc.length > 26 ? desc.slice(0, 26) + "..." : desc;
+                },
+            },
+            {
+                header: "Contacts",
+                key: "contact_count",
+                width: 10,
+            },
+            {
+                header: "Created",
+                key: "created_at",
+                width: 12,
+                formatter: (v) => formatRelativeTime(String(v)),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/contacts/lists/remove.d.ts

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class ContactsListsRemove extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        listId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+        contactId: 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/contacts/lists/remove.js

@@ -0,0 +1,36 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, json, isJsonMode } from "../../../lib/output.js";
+export default class ContactsListsRemove extends AuthenticatedCommand {
+    static description = "Remove a contact from a list";
+    static examples = [
+        "<%= config.bin %> contacts lists remove lst_xxx cnt_abc",
+    ];
+    static args = {
+        listId: Args.string({
+            description: "Contact list ID",
+            required: true,
+        }),
+        contactId: Args.string({
+            description: "Contact ID to remove",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(ContactsListsRemove);
+        await apiClient.delete(`/api/v1/contact-lists/${args.listId}/contacts/${args.contactId}`);
+        if (isJsonMode()) {
+            json({ success: true, listId: args.listId, contactId: args.contactId });
+            return;
+        }
+        success("Contact removed from list", {
+            "List ID": args.listId,
+            "Contact ID": args.contactId,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/keys/get.d.ts

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

@@ -0,0 +1,53 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, formatRelativeTime, colors, isJsonMode, } from "../../lib/output.js";
+export default class KeysGet extends AuthenticatedCommand {
+    static description = "Get details of a specific API key";
+    static examples = [
+        "<%= config.bin %> keys get KEY_ID",
+        "<%= config.bin %> keys get KEY_ID --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "API key ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(KeysGet);
+        const response = await apiClient.get(`/api/v1/account/keys/${args.id}`);
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        const typeDisplay = response.type === "test"
+            ? colors.warning("test")
+            : colors.success("live");
+        const statusDisplay = response.isActive
+            ? colors.success("active")
+            : colors.error("revoked");
+        success("API Key Details", {
+            ID: response.id,
+            Name: response.name,
+            Prefix: colors.code(response.prefix),
+            Type: typeDisplay,
+            Status: statusDisplay,
+            Scopes: response.scopes.length > 0 ? response.scopes.join(", ") : "all",
+            Created: formatRelativeTime(response.createdAt),
+            "Last Used": response.lastUsedAt
+                ? formatRelativeTime(response.lastUsedAt)
+                : colors.dim("never"),
+            ...(response.expiresAt && {
+                Expires: formatRelativeTime(response.expiresAt),
+            }),
+            ...(response.revokedAt && {
+                "Revoked At": formatRelativeTime(response.revokedAt),
+            }),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/keys/rename.d.ts

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class KeysRename extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        keyId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, 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/keys/rename.js

@@ -0,0 +1,53 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, json, isJsonMode } from "../../lib/output.js";
+export default class KeysRename extends AuthenticatedCommand {
+    static description = "Rename an API key";
+    static examples = [
+        '<%= config.bin %> keys rename key_abc123 --name "Production Key"',
+        '<%= config.bin %> keys rename key_abc123 -n "Staging"',
+    ];
+    static args = {
+        keyId: Args.string({
+            description: "Key ID to rename (e.g., key_abc123)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "New name for the API key",
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(KeysRename);
+        try {
+            const response = await apiClient.patch(`/api/v1/account/keys/${args.keyId}/rename`, {
+                name: flags.name,
+            });
+            if (isJsonMode()) {
+                json({
+                    success: true,
+                    keyId: response.id,
+                    name: response.name,
+                });
+                return;
+            }
+            success("API key renamed", {
+                "Key ID": response.id,
+                Name: response.name,
+            });
+        }
+        catch (err) {
+            if (err.message?.includes("not_found") || err.message?.includes("404")) {
+                error(`Key not found: ${args.keyId}`);
+                this.exit(1);
+            }
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/keys/rotate.d.ts

@@ -0,0 +1,15 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class KeysRotate extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        keyId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        "grace-period": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/keys/rotate.js

@@ -0,0 +1,82 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, json, colors, isJsonMode } from "../../lib/output.js";
+import inquirer from "inquirer";
+export default class KeysRotate extends AuthenticatedCommand {
+    static description = "Rotate an API key (generate new key, optionally keep old one active)";
+    static examples = [
+        "<%= config.bin %> keys rotate key_abc123",
+        "<%= config.bin %> keys rotate key_abc123 --grace-period 24",
+        "<%= config.bin %> keys rotate key_abc123 --yes",
+    ];
+    static args = {
+        keyId: Args.string({
+            description: "Key ID to rotate (e.g., key_abc123)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        "grace-period": Flags.integer({
+            char: "g",
+            description: "Hours to keep old key active (0 = immediate revocation)",
+        }),
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(KeysRotate);
+        if (!flags.yes) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Are you sure you want to rotate ${colors.code(args.keyId)}? A new key will be generated.`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                error("Rotation cancelled");
+                return;
+            }
+        }
+        try {
+            const body = {};
+            if (flags["grace-period"] !== undefined) {
+                body.gracePeriodHours = flags["grace-period"];
+            }
+            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,
+                });
+                return;
+            }
+            success("API key rotated", {
+                "New Key ID": response.newKey.id,
+                "New Key": colors.highlight(response.key),
+                Name: response.newKey.name,
+                ...(response.oldKeyExpiresAt && {
+                    "Old Key Expires": new Date(response.oldKeyExpiresAt).toLocaleString(),
+                }),
+            });
+            this.log("");
+            this.log(colors.warning("Save this key - it won't be shown again!"));
+        }
+        catch (err) {
+            if (err.message?.includes("not_found") || err.message?.includes("404")) {
+                error(`Key not found: ${args.keyId}`);
+                this.exit(1);
+            }
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/keys/usage.d.ts

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