@sendly/cli 1.0.0

package/dist/commands/keys/list.js

@@ -0,0 +1,65 @@
+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 KeysList extends AuthenticatedCommand {
+    static description = "List your API keys";
+    static examples = [
+        "<%= config.bin %> keys list",
+        "<%= config.bin %> keys list --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const keys = await apiClient.get("/api/keys");
+        if (isJsonMode()) {
+            json(keys);
+            return;
+        }
+        if (keys.length === 0) {
+            info("No API keys found");
+            console.log();
+            console.log(`  Create one with ${colors.code("sendly keys create")}`);
+            return;
+        }
+        console.log();
+        table(keys, [
+            {
+                header: "Name",
+                key: "name",
+                width: 20,
+            },
+            {
+                header: "Key ID",
+                key: "keyId",
+                width: 18,
+                formatter: (v) => colors.dim(String(v)),
+            },
+            {
+                header: "Prefix",
+                key: "keyPrefix",
+                width: 16,
+                formatter: (v) => colors.code(String(v) + "..."),
+            },
+            {
+                header: "Type",
+                key: "type",
+                width: 8,
+                formatter: (v) => v === "test" ? colors.warning("test") : colors.success("live"),
+            },
+            {
+                header: "Status",
+                key: "isActive",
+                width: 10,
+                formatter: (v) => v ? colors.success("active") : colors.error("revoked"),
+            },
+            {
+                header: "Last Used",
+                key: "lastUsedAt",
+                width: 12,
+                formatter: (v) => (v ? formatRelativeTime(String(v)) : colors.dim("never")),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,15 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class KeysRevoke 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: {
+        reason: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | 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/revoke.js

@@ -0,0 +1,68 @@
+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 KeysRevoke extends AuthenticatedCommand {
+    static description = "Revoke an API key";
+    static examples = [
+        "<%= config.bin %> keys revoke key_abc123",
+        '<%= config.bin %> keys revoke key_abc123 --reason "Compromised"',
+        "<%= config.bin %> keys revoke key_abc123 --yes",
+    ];
+    static args = {
+        keyId: Args.string({
+            description: "Key ID to revoke (e.g., key_abc123)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        reason: Flags.string({
+            char: "r",
+            description: "Reason for revoking the key",
+        }),
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(KeysRevoke);
+        // Confirm revocation
+        if (!flags.yes) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Are you sure you want to revoke ${colors.code(args.keyId)}? This cannot be undone.`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                error("Revocation cancelled");
+                return;
+            }
+        }
+        // Find the key by keyId to get its internal id
+        const keys = await apiClient.get("/api/keys");
+        const key = keys.find((k) => k.keyId === args.keyId);
+        if (!key) {
+            error(`Key not found: ${args.keyId}`);
+            this.exit(1);
+        }
+        await apiClient.patch(`/api/keys/${key.id}/revoke`, {
+            reason: flags.reason || "Revoked via CLI",
+        });
+        if (isJsonMode()) {
+            json({ success: true, keyId: args.keyId, revoked: true });
+            return;
+        }
+        success("API key revoked", {
+            "Key ID": args.keyId,
+            Reason: flags.reason || "Revoked via CLI",
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV2b2tlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbW1hbmRzL2tleXMvcmV2b2tlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQzFDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNwRCxPQUFPLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQy9FLE9BQU8sUUFBUSxNQUFNLFVBQVUsQ0FBQztBQUVoQyxNQUFNLENBQUMsT0FBTyxPQUFPLFVBQVcsU0FBUSxvQkFBb0I7SUFDMUQsTUFBTSxDQUFDLFdBQVcsR0FBRyxtQkFBbUIsQ0FBQztJQUV6QyxNQUFNLENBQUMsUUFBUSxHQUFHO1FBQ2hCLDBDQUEwQztRQUMxQyxpRUFBaUU7UUFDakUsZ0RBQWdEO0tBQ2pELENBQUM7SUFFRixNQUFNLENBQUMsSUFBSSxHQUFHO1FBQ1osS0FBSyxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUM7WUFDakIsV0FBVyxFQUFFLHFDQUFxQztZQUNsRCxRQUFRLEVBQUUsSUFBSTtTQUNmLENBQUM7S0FDSCxDQUFDO0lBRUYsTUFBTSxDQUFDLEtBQUssR0FBRztRQUNiLEdBQUcsb0JBQW9CLENBQUMsU0FBUztRQUNqQyxNQUFNLEVBQUUsS0FBSyxDQUFDLE1BQU0sQ0FBQztZQUNuQixJQUFJLEVBQUUsR0FBRztZQUNULFdBQVcsRUFBRSw2QkFBNkI7U0FDM0MsQ0FBQztRQUNGLEdBQUcsRUFBRSxLQUFLLENBQUMsT0FBTyxDQUFDO1lBQ2pCLElBQUksRUFBRSxHQUFHO1lBQ1QsV0FBVyxFQUFFLDBCQUEwQjtZQUN2QyxPQUFPLEVBQUUsS0FBSztTQUNmLENBQUM7S0FDSCxDQUFDO0lBRUYsS0FBSyxDQUFDLEdBQUc7UUFDUCxNQUFNLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxHQUFHLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUVyRCxxQkFBcUI7UUFDckIsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUNmLE1BQU0sRUFBRSxPQUFPLEVBQUUsR0FBRyxNQUFNLFFBQVEsQ0FBQyxNQUFNLENBQUM7Z0JBQ3hDO29CQUNFLElBQUksRUFBRSxTQUFTO29CQUNmLElBQUksRUFBRSxTQUFTO29CQUNmLE9BQU8sRUFBRSxtQ0FBbUMsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLDBCQUEwQjtvQkFDN0YsT0FBTyxFQUFFLEtBQUs7aUJBQ2Y7YUFDRixDQUFDLENBQUM7WUFFSCxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7Z0JBQ2IsS0FBSyxDQUFDLHNCQUFzQixDQUFDLENBQUM7Z0JBQzlCLE9BQU87WUFDVCxDQUFDO1FBQ0gsQ0FBQztRQUVELCtDQUErQztRQUMvQyxNQUFNLElBQUksR0FBRyxNQUFNLFNBQVMsQ0FBQyxHQUFHLENBQzlCLFdBQVcsQ0FDWixDQUFDO1FBQ0YsTUFBTSxHQUFHLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLEtBQUssS0FBSyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7UUFFckQsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1lBQ1QsS0FBSyxDQUFDLGtCQUFrQixJQUFJLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQztZQUN0QyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ2YsQ0FBQztRQUVELE1BQU0sU0FBUyxDQUFDLEtBQUssQ0FBQyxhQUFhLEdBQUcsQ0FBQyxFQUFFLFNBQVMsRUFBRTtZQUNsRCxNQUFNLEVBQUUsS0FBSyxDQUFDLE1BQU0sSUFBSSxpQkFBaUI7U0FDMUMsQ0FBQyxDQUFDO1FBRUgsSUFBSSxVQUFVLEVBQUUsRUFBRSxDQUFDO1lBQ2pCLElBQUksQ0FBQyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLElBQUksQ0FBQyxLQUFLLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7WUFDMUQsT0FBTztRQUNULENBQUM7UUFFRCxPQUFPLENBQUMsaUJBQWlCLEVBQUU7WUFDekIsUUFBUSxFQUFFLElBQUksQ0FBQyxLQUFLO1lBQ3BCLE1BQU0sRUFBRSxLQUFLLENBQUMsTUFBTSxJQUFJLGlCQUFpQjtTQUMxQyxDQUFDLENBQUM7SUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXJncywgRmxhZ3MgfSBmcm9tIFwiQG9jbGlmL2NvcmVcIjtcbmltcG9ydCB7IEF1dGhlbnRpY2F0ZWRDb21tYW5kIH0gZnJvbSBcIi4uLy4uL2xpYi9iYXNlLWNvbW1hbmQuanNcIjtcbmltcG9ydCB7IGFwaUNsaWVudCB9IGZyb20gXCIuLi8uLi9saWIvYXBpLWNsaWVudC5qc1wiO1xuaW1wb3J0IHsgc3VjY2VzcywgZXJyb3IsIGpzb24sIGNvbG9ycywgaXNKc29uTW9kZSB9IGZyb20gXCIuLi8uLi9saWIvb3V0cHV0LmpzXCI7XG5pbXBvcnQgaW5xdWlyZXIgZnJvbSBcImlucXVpcmVyXCI7XG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEtleXNSZXZva2UgZXh0ZW5kcyBBdXRoZW50aWNhdGVkQ29tbWFuZCB7XG4gIHN0YXRpYyBkZXNjcmlwdGlvbiA9IFwiUmV2b2tlIGFuIEFQSSBrZXlcIjtcblxuICBzdGF0aWMgZXhhbXBsZXMgPSBbXG4gICAgXCI8JT0gY29uZmlnLmJpbiAlPiBrZXlzIHJldm9rZSBrZXlfYWJjMTIzXCIsXG4gICAgJzwlPSBjb25maWcuYmluICU+IGtleXMgcmV2b2tlIGtleV9hYmMxMjMgLS1yZWFzb24gXCJDb21wcm9taXNlZFwiJyxcbiAgICBcIjwlPSBjb25maWcuYmluICU+IGtleXMgcmV2b2tlIGtleV9hYmMxMjMgLS15ZXNcIixcbiAgXTtcblxuICBzdGF0aWMgYXJncyA9IHtcbiAgICBrZXlJZDogQXJncy5zdHJpbmcoe1xuICAgICAgZGVzY3JpcHRpb246IFwiS2V5IElEIHRvIHJldm9rZSAoZS5nLiwga2V5X2FiYzEyMylcIixcbiAgICAgIHJlcXVpcmVkOiB0cnVlLFxuICAgIH0pLFxuICB9O1xuXG4gIHN0YXRpYyBmbGFncyA9IHtcbiAgICAuLi5BdXRoZW50aWNhdGVkQ29tbWFuZC5iYXNlRmxhZ3MsXG4gICAgcmVhc29uOiBGbGFncy5zdHJpbmcoe1xuICAgICAgY2hhcjogXCJyXCIsXG4gICAgICBkZXNjcmlwdGlvbjogXCJSZWFzb24gZm9yIHJldm9raW5nIHRoZSBrZXlcIixcbiAgICB9KSxcbiAgICB5ZXM6IEZsYWdzLmJvb2xlYW4oe1xuICAgICAgY2hhcjogXCJ5XCIsXG4gICAgICBkZXNjcmlwdGlvbjogXCJTa2lwIGNvbmZpcm1hdGlvbiBwcm9tcHRcIixcbiAgICAgIGRlZmF1bHQ6IGZhbHNlLFxuICAgIH0pLFxuICB9O1xuXG4gIGFzeW5jIHJ1bigpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBjb25zdCB7IGFyZ3MsIGZsYWdzIH0gPSBhd2FpdCB0aGlzLnBhcnNlKEtleXNSZXZva2UpO1xuXG4gICAgLy8gQ29uZmlybSByZXZvY2F0aW9uXG4gICAgaWYgKCFmbGFncy55ZXMpIHtcbiAgICAgIGNvbnN0IHsgY29uZmlybSB9ID0gYXdhaXQgaW5xdWlyZXIucHJvbXB0KFtcbiAgICAgICAge1xuICAgICAgICAgIHR5cGU6IFwiY29uZmlybVwiLFxuICAgICAgICAgIG5hbWU6IFwiY29uZmlybVwiLFxuICAgICAgICAgIG1lc3NhZ2U6IGBBcmUgeW91IHN1cmUgeW91IHdhbnQgdG8gcmV2b2tlICR7Y29sb3JzLmNvZGUoYXJncy5rZXlJZCl9PyBUaGlzIGNhbm5vdCBiZSB1bmRvbmUuYCxcbiAgICAgICAgICBkZWZhdWx0OiBmYWxzZSxcbiAgICAgICAgfSxcbiAgICAgIF0pO1xuXG4gICAgICBpZiAoIWNvbmZpcm0pIHtcbiAgICAgICAgZXJyb3IoXCJSZXZvY2F0aW9uIGNhbmNlbGxlZFwiKTtcbiAgICAgICAgcmV0dXJuO1xuICAgICAgfVxuICAgIH1cblxuICAgIC8vIEZpbmQgdGhlIGtleSBieSBrZXlJZCB0byBnZXQgaXRzIGludGVybmFsIGlkXG4gICAgY29uc3Qga2V5cyA9IGF3YWl0IGFwaUNsaWVudC5nZXQ8QXJyYXk8eyBpZDogc3RyaW5nOyBrZXlJZDogc3RyaW5nIH0+PihcbiAgICAgIFwiL2FwaS9rZXlzXCJcbiAgICApO1xuICAgIGNvbnN0IGtleSA9IGtleXMuZmluZCgoaykgPT4gay5rZXlJZCA9PT0gYXJncy5rZXlJZCk7XG5cbiAgICBpZiAoIWtleSkge1xuICAgICAgZXJyb3IoYEtleSBub3QgZm91bmQ6ICR7YXJncy5rZXlJZH1gKTtcbiAgICAgIHRoaXMuZXhpdCgxKTtcbiAgICB9XG5cbiAgICBhd2FpdCBhcGlDbGllbnQucGF0Y2goYC9hcGkva2V5cy8ke2tleS5pZH0vcmV2b2tlYCwge1xuICAgICAgcmVhc29uOiBmbGFncy5yZWFzb24gfHwgXCJSZXZva2VkIHZpYSBDTElcIixcbiAgICB9KTtcblxuICAgIGlmIChpc0pzb25Nb2RlKCkpIHtcbiAgICAgIGpzb24oeyBzdWNjZXNzOiB0cnVlLCBrZXlJZDogYXJncy5rZXlJZCwgcmV2b2tlZDogdHJ1ZSB9KTtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBzdWNjZXNzKFwiQVBJIGtleSByZXZva2VkXCIsIHtcbiAgICAgIFwiS2V5IElEXCI6IGFyZ3Mua2V5SWQsXG4gICAgICBSZWFzb246IGZsYWdzLnJlYXNvbiB8fCBcIlJldm9rZWQgdmlhIENMSVwiLFxuICAgIH0pO1xuICB9XG59XG4iXX0=

package/dist/commands/login.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../lib/base-command.js";
+export default class Login extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        "api-key": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        interactive: 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/login.js

@@ -0,0 +1,114 @@
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../lib/base-command.js";
+import { browserLogin, apiKeyLogin } from "../lib/auth.js";
+import { success, error, info } from "../lib/output.js";
+import { isAuthenticated } from "../lib/config.js";
+import inquirer from "inquirer";
+export default class Login extends BaseCommand {
+    static description = "Authenticate with Sendly";
+    static examples = [
+        "<%= config.bin %> login",
+        "<%= config.bin %> login --api-key sk_test_v1_xxx",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        "api-key": Flags.string({
+            char: "k",
+            description: "API key to use for authentication",
+        }),
+        interactive: Flags.boolean({
+            char: "i",
+            description: "Force interactive mode",
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Login);
+        // Check if already logged in
+        if (isAuthenticated() && !flags["api-key"]) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: "You are already logged in. Do you want to re-authenticate?",
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                info("Login cancelled");
+                return;
+            }
+        }
+        // API key login
+        if (flags["api-key"]) {
+            try {
+                await apiKeyLogin(flags["api-key"]);
+                const keyType = flags["api-key"].startsWith("sk_test_") ? "test" : "live";
+                success("Logged in with API key", {
+                    environment: keyType,
+                });
+                return;
+            }
+            catch (err) {
+                error(err.message);
+                this.exit(1);
+            }
+        }
+        // Interactive mode - ask user what they want
+        if (flags.interactive || process.stdin.isTTY) {
+            const { method } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "method",
+                    message: "How would you like to authenticate?",
+                    choices: [
+                        { name: "Login with browser (recommended)", value: "browser" },
+                        { name: "Enter API key", value: "apikey" },
+                    ],
+                },
+            ]);
+            if (method === "apikey") {
+                const { apiKey } = await inquirer.prompt([
+                    {
+                        type: "password",
+                        name: "apiKey",
+                        message: "Enter your API key:",
+                        mask: "*",
+                        validate: (input) => {
+                            if (!input)
+                                return "API key is required";
+                            if (!/^sk_(test|live)_v1_/.test(input)) {
+                                return "Invalid API key format. Expected sk_test_v1_xxx or sk_live_v1_xxx";
+                            }
+                            return true;
+                        },
+                    },
+                ]);
+                try {
+                    await apiKeyLogin(apiKey);
+                    const keyType = apiKey.startsWith("sk_test_") ? "test" : "live";
+                    success("Logged in with API key", {
+                        environment: keyType,
+                    });
+                    return;
+                }
+                catch (err) {
+                    error(err.message);
+                    this.exit(1);
+                }
+            }
+        }
+        // Browser login (default)
+        try {
+            const result = await browserLogin();
+            success("Logged in successfully", {
+                email: result.email,
+            });
+        }
+        catch (err) {
+            error(err.message);
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"login.js","sourceRoot":"","sources":["../../src/commands/login.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { BaseCommand } from \"../lib/base-command.js\";\nimport { browserLogin, apiKeyLogin } from \"../lib/auth.js\";\nimport { success, error, colors, info } from \"../lib/output.js\";\nimport { isAuthenticated } from \"../lib/config.js\";\nimport inquirer from \"inquirer\";\n\nexport default class Login extends BaseCommand {\n  static description = \"Authenticate with Sendly\";\n\n  static examples = [\n    \"<%= config.bin %> login\",\n    \"<%= config.bin %> login --api-key sk_test_v1_xxx\",\n  ];\n\n  static flags = {\n    ...BaseCommand.baseFlags,\n    \"api-key\": Flags.string({\n      char: \"k\",\n      description: \"API key to use for authentication\",\n    }),\n    interactive: Flags.boolean({\n      char: \"i\",\n      description: \"Force interactive mode\",\n      default: false,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(Login);\n\n    // Check if already logged in\n    if (isAuthenticated() && !flags[\"api-key\"]) {\n      const { confirm } = await inquirer.prompt([\n        {\n          type: \"confirm\",\n          name: \"confirm\",\n          message: \"You are already logged in. Do you want to re-authenticate?\",\n          default: false,\n        },\n      ]);\n\n      if (!confirm) {\n        info(\"Login cancelled\");\n        return;\n      }\n    }\n\n    // API key login\n    if (flags[\"api-key\"]) {\n      try {\n        await apiKeyLogin(flags[\"api-key\"]);\n        const keyType = flags[\"api-key\"].startsWith(\"sk_test_\") ? \"test\" : \"live\";\n        success(\"Logged in with API key\", {\n          environment: keyType,\n        });\n        return;\n      } catch (err) {\n        error((err as Error).message);\n        this.exit(1);\n      }\n    }\n\n    // Interactive mode - ask user what they want\n    if (flags.interactive || process.stdin.isTTY) {\n      const { method } = await inquirer.prompt([\n        {\n          type: \"list\",\n          name: \"method\",\n          message: \"How would you like to authenticate?\",\n          choices: [\n            { name: \"Login with browser (recommended)\", value: \"browser\" },\n            { name: \"Enter API key\", value: \"apikey\" },\n          ],\n        },\n      ]);\n\n      if (method === \"apikey\") {\n        const { apiKey } = await inquirer.prompt([\n          {\n            type: \"password\",\n            name: \"apiKey\",\n            message: \"Enter your API key:\",\n            mask: \"*\",\n            validate: (input: string) => {\n              if (!input) return \"API key is required\";\n              if (!/^sk_(test|live)_v1_/.test(input)) {\n                return \"Invalid API key format. Expected sk_test_v1_xxx or sk_live_v1_xxx\";\n              }\n              return true;\n            },\n          },\n        ]);\n\n        try {\n          await apiKeyLogin(apiKey);\n          const keyType = apiKey.startsWith(\"sk_test_\") ? \"test\" : \"live\";\n          success(\"Logged in with API key\", {\n            environment: keyType,\n          });\n          return;\n        } catch (err) {\n          error((err as Error).message);\n          this.exit(1);\n        }\n      }\n    }\n\n    // Browser login (default)\n    try {\n      const result = await browserLogin();\n      success(\"Logged in successfully\", {\n        email: result.email,\n      });\n    } catch (err) {\n      error((err as Error).message);\n      this.exit(1);\n    }\n  }\n}\n"]}

package/dist/commands/logout.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from "../lib/base-command.js";
+export default class Logout extends BaseCommand {
+    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/logout.js

@@ -0,0 +1,20 @@
+import { BaseCommand } from "../lib/base-command.js";
+import { logout } from "../lib/auth.js";
+import { success, info } from "../lib/output.js";
+import { isAuthenticated } from "../lib/config.js";
+export default class Logout extends BaseCommand {
+    static description = "Log out of Sendly";
+    static examples = ["<%= config.bin %> logout"];
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        if (!isAuthenticated()) {
+            info("Not currently logged in");
+            return;
+        }
+        logout();
+        success("Logged out successfully");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nb3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbW1hbmRzL2xvZ291dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3hDLE9BQU8sRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDakQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRW5ELE1BQU0sQ0FBQyxPQUFPLE9BQU8sTUFBTyxTQUFRLFdBQVc7SUFDN0MsTUFBTSxDQUFDLFdBQVcsR0FBRyxtQkFBbUIsQ0FBQztJQUV6QyxNQUFNLENBQUMsUUFBUSxHQUFHLENBQUMsMEJBQTBCLENBQUMsQ0FBQztJQUUvQyxNQUFNLENBQUMsS0FBSyxHQUFHO1FBQ2IsR0FBRyxXQUFXLENBQUMsU0FBUztLQUN6QixDQUFDO0lBRUYsS0FBSyxDQUFDLEdBQUc7UUFDUCxJQUFJLENBQUMsZUFBZSxFQUFFLEVBQUUsQ0FBQztZQUN2QixJQUFJLENBQUMseUJBQXlCLENBQUMsQ0FBQztZQUNoQyxPQUFPO1FBQ1QsQ0FBQztRQUVELE1BQU0sRUFBRSxDQUFDO1FBQ1QsT0FBTyxDQUFDLHlCQUF5QixDQUFDLENBQUM7SUFDckMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VDb21tYW5kIH0gZnJvbSBcIi4uL2xpYi9iYXNlLWNvbW1hbmQuanNcIjtcbmltcG9ydCB7IGxvZ291dCB9IGZyb20gXCIuLi9saWIvYXV0aC5qc1wiO1xuaW1wb3J0IHsgc3VjY2VzcywgaW5mbyB9IGZyb20gXCIuLi9saWIvb3V0cHV0LmpzXCI7XG5pbXBvcnQgeyBpc0F1dGhlbnRpY2F0ZWQgfSBmcm9tIFwiLi4vbGliL2NvbmZpZy5qc1wiO1xuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBMb2dvdXQgZXh0ZW5kcyBCYXNlQ29tbWFuZCB7XG4gIHN0YXRpYyBkZXNjcmlwdGlvbiA9IFwiTG9nIG91dCBvZiBTZW5kbHlcIjtcblxuICBzdGF0aWMgZXhhbXBsZXMgPSBbXCI8JT0gY29uZmlnLmJpbiAlPiBsb2dvdXRcIl07XG5cbiAgc3RhdGljIGZsYWdzID0ge1xuICAgIC4uLkJhc2VDb21tYW5kLmJhc2VGbGFncyxcbiAgfTtcblxuICBhc3luYyBydW4oKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgaWYgKCFpc0F1dGhlbnRpY2F0ZWQoKSkge1xuICAgICAgaW5mbyhcIk5vdCBjdXJyZW50bHkgbG9nZ2VkIGluXCIpO1xuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIGxvZ291dCgpO1xuICAgIHN1Y2Nlc3MoXCJMb2dnZWQgb3V0IHN1Y2Nlc3NmdWxseVwiKTtcbiAgfVxufVxuIl19

package/dist/commands/logs/tail.d.ts

@@ -0,0 +1,17 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class LogsTail extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        status: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        since: 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 | 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>;
+    private fetchAndDisplayLogs;
+    private displayLog;
+    private getTypeLabel;
+    private parseSince;
+}

package/dist/commands/logs/tail.js

@@ -0,0 +1,183 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { colors, info, } from "../../lib/output.js";
+export default class LogsTail extends AuthenticatedCommand {
+    static description = "Tail logs in real-time (like stripe logs tail)";
+    static examples = [
+        "<%= config.bin %> logs tail",
+        "<%= config.bin %> logs tail --status failed",
+        "<%= config.bin %> logs tail --since 1h",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        status: Flags.string({
+            char: "s",
+            description: "Filter by status (sent, delivered, failed)",
+        }),
+        since: Flags.string({
+            description: "Show logs since (e.g., 1h, 30m, 1d)",
+            default: "1h",
+        }),
+        type: Flags.string({
+            char: "t",
+            description: "Filter by type (message, api_call, webhook)",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(LogsTail);
+        console.log();
+        console.log(colors.bold(colors.primary("Sendly Logs")));
+        console.log(colors.dim("─".repeat(60)));
+        console.log();
+        console.log(colors.dim("Streaming logs in real-time. Press Ctrl+C to stop."));
+        console.log();
+        const since = this.parseSince(flags.since);
+        // Initial fetch of recent logs
+        await this.fetchAndDisplayLogs(since, flags.status, flags.type);
+        // Poll for new logs
+        let lastTimestamp = new Date().toISOString();
+        const pollInterval = setInterval(async () => {
+            try {
+                const logs = await apiClient.get("/api/logs", {
+                    since: lastTimestamp,
+                    status: flags.status,
+                    type: flags.type,
+                    limit: 50,
+                });
+                for (const log of logs) {
+                    this.displayLog(log);
+                    lastTimestamp = log.timestamp;
+                }
+            }
+            catch {
+                // Ignore polling errors
+            }
+        }, 2000);
+        // Handle graceful shutdown
+        process.on("SIGINT", () => {
+            clearInterval(pollInterval);
+            console.log();
+            info("Log streaming stopped");
+            process.exit(0);
+        });
+        // Keep process alive
+        await new Promise(() => { });
+    }
+    async fetchAndDisplayLogs(since, status, type) {
+        try {
+            const logs = await apiClient.get("/api/logs", {
+                since: since.toISOString(),
+                status,
+                type,
+                limit: 50,
+            });
+            if (logs.length === 0) {
+                info("No recent logs found");
+                console.log();
+                return;
+            }
+            // Display logs in reverse chronological order
+            for (const log of logs.reverse()) {
+                this.displayLog(log);
+            }
+        }
+        catch (err) {
+            // If endpoint doesn't exist, show friendly message
+            info("Fetching message history...");
+            // Fallback to messages endpoint
+            try {
+                const messages = await apiClient.get("/api/v1/messages", {
+                    limit: 20,
+                });
+                for (const msg of messages.data.reverse()) {
+                    this.displayLog({
+                        id: msg.id,
+                        type: "message",
+                        status: msg.status,
+                        to: msg.to,
+                        messageId: msg.id,
+                        timestamp: msg.createdAt,
+                    });
+                }
+            }
+            catch {
+                info("No logs available");
+            }
+        }
+    }
+    displayLog(log) {
+        const timestamp = new Date(log.timestamp).toLocaleTimeString();
+        let icon = "•";
+        let statusColor = colors.dim;
+        switch (log.status) {
+            case "delivered":
+            case "success":
+                icon = "✓";
+                statusColor = colors.success;
+                break;
+            case "failed":
+            case "error":
+                icon = "✗";
+                statusColor = colors.error;
+                break;
+            case "queued":
+            case "pending":
+                icon = "○";
+                statusColor = colors.warning;
+                break;
+            case "sent":
+                icon = "→";
+                statusColor = colors.info;
+                break;
+        }
+        const typeLabel = this.getTypeLabel(log.type);
+        console.log(`${colors.dim(timestamp)} ${statusColor(icon)} ${typeLabel} ${statusColor(log.status)}`);
+        // Additional details
+        if (log.to) {
+            console.log(`  ${colors.dim("to:")} ${log.to}`);
+        }
+        if (log.endpoint) {
+            console.log(`  ${colors.dim("endpoint:")} ${log.method || "GET"} ${log.endpoint}`);
+        }
+        if (log.messageId) {
+            console.log(`  ${colors.dim("id:")} ${log.messageId}`);
+        }
+        if (log.error) {
+            console.log(`  ${colors.error("error:")} ${log.error}`);
+        }
+        console.log();
+    }
+    getTypeLabel(type) {
+        switch (type) {
+            case "message":
+                return colors.primary("[SMS]");
+            case "api_call":
+                return colors.code("[API]");
+            case "webhook":
+                return colors.warning("[HOOK]");
+            default:
+                return colors.dim(`[${type.toUpperCase()}]`);
+        }
+    }
+    parseSince(since) {
+        const match = since.match(/^(\d+)([hdm])$/);
+        if (!match) {
+            return new Date(Date.now() - 60 * 60 * 1000); // Default 1 hour
+        }
+        const value = parseInt(match[1], 10);
+        const unit = match[2];
+        const now = Date.now();
+        switch (unit) {
+            case "h":
+                return new Date(now - value * 60 * 60 * 1000);
+            case "d":
+                return new Date(now - value * 24 * 60 * 60 * 1000);
+            case "m":
+                return new Date(now - value * 60 * 1000);
+            default:
+                return new Date(now - 60 * 60 * 1000);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tail.js","sourceRoot":"","sources":["../../../src/commands/logs/tail.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport {\n  colors,\n  formatRelativeTime,\n  info,\n  json as jsonOutput,\n  isJsonMode,\n} from \"../../lib/output.js\";\nimport { getConfigValue } from \"../../lib/config.js\";\n\ninterface LogEntry {\n  id: string;\n  type: \"message\" | \"api_call\" | \"webhook\";\n  status: string;\n  endpoint?: string;\n  method?: string;\n  statusCode?: number;\n  to?: string;\n  messageId?: string;\n  error?: string;\n  timestamp: string;\n}\n\nexport default class LogsTail extends AuthenticatedCommand {\n  static description = \"Tail logs in real-time (like stripe logs tail)\";\n\n  static examples = [\n    \"<%= config.bin %> logs tail\",\n    \"<%= config.bin %> logs tail --status failed\",\n    \"<%= config.bin %> logs tail --since 1h\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    status: Flags.string({\n      char: \"s\",\n      description: \"Filter by status (sent, delivered, failed)\",\n    }),\n    since: Flags.string({\n      description: \"Show logs since (e.g., 1h, 30m, 1d)\",\n      default: \"1h\",\n    }),\n    type: Flags.string({\n      char: \"t\",\n      description: \"Filter by type (message, api_call, webhook)\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(LogsTail);\n\n    console.log();\n    console.log(colors.bold(colors.primary(\"Sendly Logs\")));\n    console.log(colors.dim(\"─\".repeat(60)));\n    console.log();\n    console.log(colors.dim(\"Streaming logs in real-time. Press Ctrl+C to stop.\"));\n    console.log();\n\n    const since = this.parseSince(flags.since);\n\n    // Initial fetch of recent logs\n    await this.fetchAndDisplayLogs(since, flags.status, flags.type);\n\n    // Poll for new logs\n    let lastTimestamp = new Date().toISOString();\n\n    const pollInterval = setInterval(async () => {\n      try {\n        const logs = await apiClient.get<LogEntry[]>(\"/api/logs\", {\n          since: lastTimestamp,\n          status: flags.status,\n          type: flags.type,\n          limit: 50,\n        });\n\n        for (const log of logs) {\n          this.displayLog(log);\n          lastTimestamp = log.timestamp;\n        }\n      } catch {\n        // Ignore polling errors\n      }\n    }, 2000);\n\n    // Handle graceful shutdown\n    process.on(\"SIGINT\", () => {\n      clearInterval(pollInterval);\n      console.log();\n      info(\"Log streaming stopped\");\n      process.exit(0);\n    });\n\n    // Keep process alive\n    await new Promise(() => {});\n  }\n\n  private async fetchAndDisplayLogs(\n    since: Date,\n    status?: string,\n    type?: string\n  ): Promise<void> {\n    try {\n      const logs = await apiClient.get<LogEntry[]>(\"/api/logs\", {\n        since: since.toISOString(),\n        status,\n        type,\n        limit: 50,\n      });\n\n      if (logs.length === 0) {\n        info(\"No recent logs found\");\n        console.log();\n        return;\n      }\n\n      // Display logs in reverse chronological order\n      for (const log of logs.reverse()) {\n        this.displayLog(log);\n      }\n    } catch (err) {\n      // If endpoint doesn't exist, show friendly message\n      info(\"Fetching message history...\");\n\n      // Fallback to messages endpoint\n      try {\n        const messages = await apiClient.get<{ data: any[] }>(\"/api/v1/messages\", {\n          limit: 20,\n        });\n\n        for (const msg of messages.data.reverse()) {\n          this.displayLog({\n            id: msg.id,\n            type: \"message\",\n            status: msg.status,\n            to: msg.to,\n            messageId: msg.id,\n            timestamp: msg.createdAt,\n          });\n        }\n      } catch {\n        info(\"No logs available\");\n      }\n    }\n  }\n\n  private displayLog(log: LogEntry): void {\n    const timestamp = new Date(log.timestamp).toLocaleTimeString();\n\n    let icon = \"•\";\n    let statusColor = colors.dim;\n\n    switch (log.status) {\n      case \"delivered\":\n      case \"success\":\n        icon = \"✓\";\n        statusColor = colors.success;\n        break;\n      case \"failed\":\n      case \"error\":\n        icon = \"✗\";\n        statusColor = colors.error;\n        break;\n      case \"queued\":\n      case \"pending\":\n        icon = \"○\";\n        statusColor = colors.warning;\n        break;\n      case \"sent\":\n        icon = \"→\";\n        statusColor = colors.info;\n        break;\n    }\n\n    const typeLabel = this.getTypeLabel(log.type);\n\n    console.log(\n      `${colors.dim(timestamp)} ${statusColor(icon)} ${typeLabel} ${statusColor(log.status)}`\n    );\n\n    // Additional details\n    if (log.to) {\n      console.log(`  ${colors.dim(\"to:\")} ${log.to}`);\n    }\n    if (log.endpoint) {\n      console.log(\n        `  ${colors.dim(\"endpoint:\")} ${log.method || \"GET\"} ${log.endpoint}`\n      );\n    }\n    if (log.messageId) {\n      console.log(`  ${colors.dim(\"id:\")} ${log.messageId}`);\n    }\n    if (log.error) {\n      console.log(`  ${colors.error(\"error:\")} ${log.error}`);\n    }\n    console.log();\n  }\n\n  private getTypeLabel(type: string): string {\n    switch (type) {\n      case \"message\":\n        return colors.primary(\"[SMS]\");\n      case \"api_call\":\n        return colors.code(\"[API]\");\n      case \"webhook\":\n        return colors.warning(\"[HOOK]\");\n      default:\n        return colors.dim(`[${type.toUpperCase()}]`);\n    }\n  }\n\n  private parseSince(since: string): Date {\n    const match = since.match(/^(\\d+)([hdm])$/);\n    if (!match) {\n      return new Date(Date.now() - 60 * 60 * 1000); // Default 1 hour\n    }\n\n    const value = parseInt(match[1], 10);\n    const unit = match[2];\n\n    const now = Date.now();\n    switch (unit) {\n      case \"h\":\n        return new Date(now - value * 60 * 60 * 1000);\n      case \"d\":\n        return new Date(now - value * 24 * 60 * 60 * 1000);\n      case \"m\":\n        return new Date(now - value * 60 * 1000);\n      default:\n        return new Date(now - 60 * 60 * 1000);\n    }\n  }\n}\n"]}

package/dist/commands/sms/batch.d.ts

@@ -0,0 +1,16 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class SmsBatch extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        file: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        to: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        text: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        from: 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>;
+    private parseMessagesFromFile;
+    private parseMessagesFromFlags;
+}