@sendly/cli 1.0.0

package/dist/commands/credits/history.js

@@ -0,0 +1,88 @@
+import { Flags } from "@oclif/core";
+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 CreditsHistory extends AuthenticatedCommand {
+    static description = "View credit transaction history";
+    static examples = [
+        "<%= config.bin %> credits history",
+        "<%= config.bin %> credits history --limit 10",
+        "<%= config.bin %> credits history --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        limit: Flags.integer({
+            char: "l",
+            description: "Number of transactions to show",
+            default: 20,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(CreditsHistory);
+        const response = await apiClient.get("/api/credits/transactions", { limit: flags.limit });
+        if (isJsonMode()) {
+            json(response.transactions);
+            return;
+        }
+        if (response.transactions.length === 0) {
+            info("No transactions found");
+            return;
+        }
+        console.log();
+        table(response.transactions, [
+            {
+                header: "Type",
+                key: "type",
+                width: 10,
+                formatter: (v) => {
+                    switch (v) {
+                        case "purchase":
+                            return colors.success("purchase");
+                        case "usage":
+                            return colors.warning("usage");
+                        case "bonus":
+                            return colors.primary("bonus");
+                        case "refund":
+                            return colors.info("refund");
+                        default:
+                            return String(v);
+                    }
+                },
+            },
+            {
+                header: "Amount",
+                key: "amount",
+                width: 12,
+                formatter: (v) => {
+                    const num = v;
+                    if (num > 0) {
+                        return colors.success(`+${num.toLocaleString()}`);
+                    }
+                    return colors.error(num.toLocaleString());
+                },
+            },
+            {
+                header: "Balance",
+                key: "balanceAfter",
+                width: 12,
+                formatter: (v) => `${v.toLocaleString()}`,
+            },
+            {
+                header: "Description",
+                key: "description",
+                width: 35,
+                formatter: (v) => {
+                    const desc = String(v);
+                    return desc.length > 32 ? desc.slice(0, 32) + "..." : desc;
+                },
+            },
+            {
+                header: "When",
+                key: "createdAt",
+                width: 12,
+                formatter: (v) => formatRelativeTime(String(v)),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/doctor.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Sendly Doctor Command
+ * Diagnoses CLI setup and connectivity issues
+ */
+import { BaseCommand } from "../lib/base-command.js";
+export default class Doctor 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>;
+    };
+    private results;
+    run(): Promise<void>;
+    private addResult;
+    private checkApiKey;
+    private checkNetwork;
+    private checkClockSkew;
+    private checkCredits;
+    private checkEnvironment;
+    private checkConfig;
+    private generateReport;
+}

package/dist/commands/doctor.js

@@ -0,0 +1,336 @@
+/**
+ * Sendly Doctor Command
+ * Diagnoses CLI setup and connectivity issues
+ */
+import { BaseCommand } from "../lib/base-command.js";
+import { isAuthenticated, getAuthToken, getConfigPath, getConfigDir, getEffectiveValue, isCI, isColorDisabled, } from "../lib/config.js";
+import { success, error, warn, json, colors } from "../lib/output.js";
+import * as fs from "node:fs";
+export default class Doctor extends BaseCommand {
+    static description = "Diagnose CLI setup and connectivity issues";
+    static examples = [
+        "<%= config.bin %> doctor",
+        "<%= config.bin %> doctor --json",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    results = [];
+    async run() {
+        const { flags } = await this.parse(Doctor);
+        if (!flags.json) {
+            console.log();
+            console.log(colors.primary("Sendly CLI Diagnostics"));
+            console.log();
+        }
+        // Run all diagnostics
+        await this.checkApiKey();
+        await this.checkNetwork();
+        await this.checkClockSkew();
+        await this.checkCredits();
+        await this.checkEnvironment();
+        await this.checkConfig();
+        // Generate report
+        const report = this.generateReport();
+        if (flags.json) {
+            json(report);
+            return;
+        }
+        // Print summary
+        console.log();
+        if (report.summary.errors > 0) {
+            error(`${report.summary.errors} issue(s) found. Please resolve before using the CLI.`);
+            this.exit(1);
+        }
+        else if (report.summary.warnings > 0) {
+            warn(`${report.summary.warnings} warning(s). CLI should work but may have issues.`);
+        }
+        else {
+            success("All systems operational!");
+        }
+    }
+    addResult(result) {
+        this.results.push(result);
+        // Print result immediately (unless in JSON mode)
+        const { flags } = this;
+        if (flags?.json)
+            return;
+        const icon = result.status === "ok"
+            ? colors.success("\u2714")
+            : result.status === "warning"
+                ? colors.warning("\u26A0")
+                : colors.error("\u2718");
+        console.log(`${icon} ${result.name}: ${result.message}`);
+        if (result.details) {
+            console.log(colors.dim(`   ${result.details}`));
+        }
+    }
+    async checkApiKey() {
+        const token = getAuthToken();
+        const fromEnv = !!process.env.SENDLY_API_KEY;
+        if (!token) {
+            this.addResult({
+                name: "API Key",
+                status: "error",
+                message: "Not configured",
+                details: "Run 'sendly login' or set SENDLY_API_KEY environment variable",
+            });
+            return;
+        }
+        // Check key format
+        const isTestKey = token.startsWith("sk_test_");
+        const isLiveKey = token.startsWith("sk_live_");
+        if (!isTestKey && !isLiveKey) {
+            this.addResult({
+                name: "API Key",
+                status: "error",
+                message: "Invalid format",
+                details: "API key should start with sk_test_ or sk_live_",
+            });
+            return;
+        }
+        const keyType = isTestKey ? "test" : "live";
+        const source = fromEnv ? "environment variable" : "config file";
+        this.addResult({
+            name: "API Key",
+            status: "ok",
+            message: `Valid (${keyType} mode, from ${source})`,
+        });
+    }
+    async checkNetwork() {
+        const baseUrl = getEffectiveValue("baseUrl");
+        const startTime = Date.now();
+        try {
+            const response = await fetch(`${baseUrl}/health`, {
+                method: "GET",
+                signal: AbortSignal.timeout(10000),
+            });
+            const latency = Date.now() - startTime;
+            if (response.ok) {
+                this.addResult({
+                    name: "Network",
+                    status: "ok",
+                    message: `Connected to ${new URL(baseUrl).host} (${latency}ms)`,
+                });
+            }
+            else {
+                this.addResult({
+                    name: "Network",
+                    status: "warning",
+                    message: `API returned ${response.status}`,
+                    details: `Endpoint: ${baseUrl}/health`,
+                });
+            }
+        }
+        catch (err) {
+            this.addResult({
+                name: "Network",
+                status: "error",
+                message: "Cannot reach API",
+                details: err.message || "Check your internet connection",
+            });
+        }
+    }
+    async checkClockSkew() {
+        const baseUrl = getEffectiveValue("baseUrl");
+        try {
+            const response = await fetch(`${baseUrl}/health`, {
+                method: "GET",
+                signal: AbortSignal.timeout(5000),
+            });
+            const serverDate = response.headers.get("date");
+            if (!serverDate) {
+                this.addResult({
+                    name: "Clock",
+                    status: "warning",
+                    message: "Could not verify (no server date header)",
+                });
+                return;
+            }
+            const serverTime = new Date(serverDate).getTime();
+            const localTime = Date.now();
+            const skewSeconds = Math.abs(serverTime - localTime) / 1000;
+            if (skewSeconds > 300) {
+                // 5 minutes
+                this.addResult({
+                    name: "Clock",
+                    status: "error",
+                    message: `Significant drift detected (${skewSeconds.toFixed(0)}s)`,
+                    details: "This may cause webhook signature verification to fail",
+                });
+            }
+            else if (skewSeconds > 30) {
+                this.addResult({
+                    name: "Clock",
+                    status: "warning",
+                    message: `Minor drift detected (${skewSeconds.toFixed(1)}s)`,
+                });
+            }
+            else {
+                this.addResult({
+                    name: "Clock",
+                    status: "ok",
+                    message: `Synchronized (drift: ${skewSeconds.toFixed(1)}s)`,
+                });
+            }
+        }
+        catch {
+            this.addResult({
+                name: "Clock",
+                status: "warning",
+                message: "Could not verify (network error)",
+            });
+        }
+    }
+    async checkCredits() {
+        if (!isAuthenticated()) {
+            this.addResult({
+                name: "Credits",
+                status: "warning",
+                message: "Cannot check (not authenticated)",
+            });
+            return;
+        }
+        const baseUrl = getEffectiveValue("baseUrl");
+        const token = getAuthToken();
+        try {
+            const response = await fetch(`${baseUrl}/api/credits`, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                },
+                signal: AbortSignal.timeout(10000),
+            });
+            if (response.ok) {
+                const data = (await response.json());
+                const balance = data.balance || 0;
+                if (balance === 0) {
+                    this.addResult({
+                        name: "Credits",
+                        status: "warning",
+                        message: "0 available",
+                        details: "Add credits to send messages",
+                    });
+                }
+                else {
+                    this.addResult({
+                        name: "Credits",
+                        status: "ok",
+                        message: `${balance.toLocaleString()} available`,
+                    });
+                }
+            }
+            else if (response.status === 401) {
+                this.addResult({
+                    name: "Credits",
+                    status: "error",
+                    message: "API key invalid or expired",
+                });
+            }
+            else {
+                this.addResult({
+                    name: "Credits",
+                    status: "warning",
+                    message: `Could not fetch (HTTP ${response.status})`,
+                });
+            }
+        }
+        catch (err) {
+            this.addResult({
+                name: "Credits",
+                status: "warning",
+                message: "Could not fetch",
+                details: err.message,
+            });
+        }
+    }
+    async checkEnvironment() {
+        const checks = [];
+        if (isCI()) {
+            checks.push("CI mode detected");
+        }
+        if (isColorDisabled()) {
+            checks.push("color disabled");
+        }
+        if (process.env.SENDLY_API_KEY) {
+            checks.push("using SENDLY_API_KEY env var");
+        }
+        if (process.env.SENDLY_BASE_URL) {
+            checks.push(`custom base URL: ${process.env.SENDLY_BASE_URL}`);
+        }
+        this.addResult({
+            name: "Environment",
+            status: "ok",
+            message: checks.length > 0 ? checks.join(", ") : "Standard terminal mode",
+        });
+    }
+    async checkConfig() {
+        const configPath = getConfigPath();
+        const configDir = getConfigDir();
+        // Check if config directory exists
+        if (!fs.existsSync(configDir)) {
+            this.addResult({
+                name: "Config",
+                status: "warning",
+                message: "Config directory not found",
+                details: `Expected: ${configDir}`,
+            });
+            return;
+        }
+        // Check if config file exists
+        if (!fs.existsSync(configPath)) {
+            this.addResult({
+                name: "Config",
+                status: "warning",
+                message: "Config file not found (using defaults)",
+                details: configPath,
+            });
+            return;
+        }
+        // Check file permissions (should be readable only by owner)
+        try {
+            const stats = fs.statSync(configPath);
+            const mode = stats.mode & 0o777;
+            if (mode & 0o077) {
+                // Group or others have access
+                this.addResult({
+                    name: "Config",
+                    status: "warning",
+                    message: "Config file has loose permissions",
+                    details: `${configPath} (mode: ${mode.toString(8)})`,
+                });
+            }
+            else {
+                this.addResult({
+                    name: "Config",
+                    status: "ok",
+                    message: configPath,
+                });
+            }
+        }
+        catch {
+            this.addResult({
+                name: "Config",
+                status: "ok",
+                message: configPath,
+            });
+        }
+    }
+    generateReport() {
+        const passed = this.results.filter((r) => r.status === "ok").length;
+        const warnings = this.results.filter((r) => r.status === "warning").length;
+        const errors = this.results.filter((r) => r.status === "error").length;
+        return {
+            timestamp: new Date().toISOString(),
+            version: "1.0.0",
+            results: this.results,
+            summary: {
+                passed,
+                warnings,
+                errors,
+            },
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"doctor.js","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Sendly Doctor Command\n * Diagnoses CLI setup and connectivity issues\n */\n\nimport { BaseCommand } from \"../lib/base-command.js\";\nimport {\n  isAuthenticated,\n  getAuthToken,\n  getConfigPath,\n  getConfigDir,\n  getEffectiveValue,\n  isCI,\n  isColorDisabled,\n} from \"../lib/config.js\";\nimport { success, error, warn, info, json, colors } from \"../lib/output.js\";\nimport * as fs from \"node:fs\";\nimport * as path from \"node:path\";\n\ninterface DiagnosticResult {\n  name: string;\n  status: \"ok\" | \"warning\" | \"error\";\n  message: string;\n  details?: string;\n}\n\ninterface DoctorReport {\n  timestamp: string;\n  version: string;\n  results: DiagnosticResult[];\n  summary: {\n    passed: number;\n    warnings: number;\n    errors: number;\n  };\n}\n\nexport default class Doctor extends BaseCommand {\n  static description = \"Diagnose CLI setup and connectivity issues\";\n\n  static examples = [\n    \"<%= config.bin %> doctor\",\n    \"<%= config.bin %> doctor --json\",\n  ];\n\n  static flags = {\n    ...BaseCommand.baseFlags,\n  };\n\n  private results: DiagnosticResult[] = [];\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(Doctor);\n\n    if (!flags.json) {\n      console.log();\n      console.log(colors.primary(\"Sendly CLI Diagnostics\"));\n      console.log();\n    }\n\n    // Run all diagnostics\n    await this.checkApiKey();\n    await this.checkNetwork();\n    await this.checkClockSkew();\n    await this.checkCredits();\n    await this.checkEnvironment();\n    await this.checkConfig();\n\n    // Generate report\n    const report = this.generateReport();\n\n    if (flags.json) {\n      json(report);\n      return;\n    }\n\n    // Print summary\n    console.log();\n    if (report.summary.errors > 0) {\n      error(\n        `${report.summary.errors} issue(s) found. Please resolve before using the CLI.`,\n      );\n      this.exit(1);\n    } else if (report.summary.warnings > 0) {\n      warn(\n        `${report.summary.warnings} warning(s). CLI should work but may have issues.`,\n      );\n    } else {\n      success(\"All systems operational!\");\n    }\n  }\n\n  private addResult(result: DiagnosticResult): void {\n    this.results.push(result);\n\n    // Print result immediately (unless in JSON mode)\n    const { flags } = this as any;\n    if (flags?.json) return;\n\n    const icon =\n      result.status === \"ok\"\n        ? colors.success(\"\\u2714\")\n        : result.status === \"warning\"\n          ? colors.warning(\"\\u26A0\")\n          : colors.error(\"\\u2718\");\n\n    console.log(`${icon} ${result.name}: ${result.message}`);\n    if (result.details) {\n      console.log(colors.dim(`   ${result.details}`));\n    }\n  }\n\n  private async checkApiKey(): Promise<void> {\n    const token = getAuthToken();\n    const fromEnv = !!process.env.SENDLY_API_KEY;\n\n    if (!token) {\n      this.addResult({\n        name: \"API Key\",\n        status: \"error\",\n        message: \"Not configured\",\n        details:\n          \"Run 'sendly login' or set SENDLY_API_KEY environment variable\",\n      });\n      return;\n    }\n\n    // Check key format\n    const isTestKey = token.startsWith(\"sk_test_\");\n    const isLiveKey = token.startsWith(\"sk_live_\");\n\n    if (!isTestKey && !isLiveKey) {\n      this.addResult({\n        name: \"API Key\",\n        status: \"error\",\n        message: \"Invalid format\",\n        details: \"API key should start with sk_test_ or sk_live_\",\n      });\n      return;\n    }\n\n    const keyType = isTestKey ? \"test\" : \"live\";\n    const source = fromEnv ? \"environment variable\" : \"config file\";\n\n    this.addResult({\n      name: \"API Key\",\n      status: \"ok\",\n      message: `Valid (${keyType} mode, from ${source})`,\n    });\n  }\n\n  private async checkNetwork(): Promise<void> {\n    const baseUrl = getEffectiveValue(\"baseUrl\");\n    const startTime = Date.now();\n\n    try {\n      const response = await fetch(`${baseUrl}/health`, {\n        method: \"GET\",\n        signal: AbortSignal.timeout(10000),\n      });\n\n      const latency = Date.now() - startTime;\n\n      if (response.ok) {\n        this.addResult({\n          name: \"Network\",\n          status: \"ok\",\n          message: `Connected to ${new URL(baseUrl).host} (${latency}ms)`,\n        });\n      } else {\n        this.addResult({\n          name: \"Network\",\n          status: \"warning\",\n          message: `API returned ${response.status}`,\n          details: `Endpoint: ${baseUrl}/health`,\n        });\n      }\n    } catch (err: any) {\n      this.addResult({\n        name: \"Network\",\n        status: \"error\",\n        message: \"Cannot reach API\",\n        details: err.message || \"Check your internet connection\",\n      });\n    }\n  }\n\n  private async checkClockSkew(): Promise<void> {\n    const baseUrl = getEffectiveValue(\"baseUrl\");\n\n    try {\n      const response = await fetch(`${baseUrl}/health`, {\n        method: \"GET\",\n        signal: AbortSignal.timeout(5000),\n      });\n\n      const serverDate = response.headers.get(\"date\");\n      if (!serverDate) {\n        this.addResult({\n          name: \"Clock\",\n          status: \"warning\",\n          message: \"Could not verify (no server date header)\",\n        });\n        return;\n      }\n\n      const serverTime = new Date(serverDate).getTime();\n      const localTime = Date.now();\n      const skewSeconds = Math.abs(serverTime - localTime) / 1000;\n\n      if (skewSeconds > 300) {\n        // 5 minutes\n        this.addResult({\n          name: \"Clock\",\n          status: \"error\",\n          message: `Significant drift detected (${skewSeconds.toFixed(0)}s)`,\n          details: \"This may cause webhook signature verification to fail\",\n        });\n      } else if (skewSeconds > 30) {\n        this.addResult({\n          name: \"Clock\",\n          status: \"warning\",\n          message: `Minor drift detected (${skewSeconds.toFixed(1)}s)`,\n        });\n      } else {\n        this.addResult({\n          name: \"Clock\",\n          status: \"ok\",\n          message: `Synchronized (drift: ${skewSeconds.toFixed(1)}s)`,\n        });\n      }\n    } catch {\n      this.addResult({\n        name: \"Clock\",\n        status: \"warning\",\n        message: \"Could not verify (network error)\",\n      });\n    }\n  }\n\n  private async checkCredits(): Promise<void> {\n    if (!isAuthenticated()) {\n      this.addResult({\n        name: \"Credits\",\n        status: \"warning\",\n        message: \"Cannot check (not authenticated)\",\n      });\n      return;\n    }\n\n    const baseUrl = getEffectiveValue(\"baseUrl\");\n    const token = getAuthToken();\n\n    try {\n      const response = await fetch(`${baseUrl}/api/credits`, {\n        method: \"GET\",\n        headers: {\n          Authorization: `Bearer ${token}`,\n          \"Content-Type\": \"application/json\",\n        },\n        signal: AbortSignal.timeout(10000),\n      });\n\n      if (response.ok) {\n        const data = (await response.json()) as { balance?: number };\n        const balance = data.balance || 0;\n\n        if (balance === 0) {\n          this.addResult({\n            name: \"Credits\",\n            status: \"warning\",\n            message: \"0 available\",\n            details: \"Add credits to send messages\",\n          });\n        } else {\n          this.addResult({\n            name: \"Credits\",\n            status: \"ok\",\n            message: `${balance.toLocaleString()} available`,\n          });\n        }\n      } else if (response.status === 401) {\n        this.addResult({\n          name: \"Credits\",\n          status: \"error\",\n          message: \"API key invalid or expired\",\n        });\n      } else {\n        this.addResult({\n          name: \"Credits\",\n          status: \"warning\",\n          message: `Could not fetch (HTTP ${response.status})`,\n        });\n      }\n    } catch (err: any) {\n      this.addResult({\n        name: \"Credits\",\n        status: \"warning\",\n        message: \"Could not fetch\",\n        details: err.message,\n      });\n    }\n  }\n\n  private async checkEnvironment(): Promise<void> {\n    const checks: string[] = [];\n\n    if (isCI()) {\n      checks.push(\"CI mode detected\");\n    }\n\n    if (isColorDisabled()) {\n      checks.push(\"color disabled\");\n    }\n\n    if (process.env.SENDLY_API_KEY) {\n      checks.push(\"using SENDLY_API_KEY env var\");\n    }\n\n    if (process.env.SENDLY_BASE_URL) {\n      checks.push(`custom base URL: ${process.env.SENDLY_BASE_URL}`);\n    }\n\n    this.addResult({\n      name: \"Environment\",\n      status: \"ok\",\n      message: checks.length > 0 ? checks.join(\", \") : \"Standard terminal mode\",\n    });\n  }\n\n  private async checkConfig(): Promise<void> {\n    const configPath = getConfigPath();\n    const configDir = getConfigDir();\n\n    // Check if config directory exists\n    if (!fs.existsSync(configDir)) {\n      this.addResult({\n        name: \"Config\",\n        status: \"warning\",\n        message: \"Config directory not found\",\n        details: `Expected: ${configDir}`,\n      });\n      return;\n    }\n\n    // Check if config file exists\n    if (!fs.existsSync(configPath)) {\n      this.addResult({\n        name: \"Config\",\n        status: \"warning\",\n        message: \"Config file not found (using defaults)\",\n        details: configPath,\n      });\n      return;\n    }\n\n    // Check file permissions (should be readable only by owner)\n    try {\n      const stats = fs.statSync(configPath);\n      const mode = stats.mode & 0o777;\n\n      if (mode & 0o077) {\n        // Group or others have access\n        this.addResult({\n          name: \"Config\",\n          status: \"warning\",\n          message: \"Config file has loose permissions\",\n          details: `${configPath} (mode: ${mode.toString(8)})`,\n        });\n      } else {\n        this.addResult({\n          name: \"Config\",\n          status: \"ok\",\n          message: configPath,\n        });\n      }\n    } catch {\n      this.addResult({\n        name: \"Config\",\n        status: \"ok\",\n        message: configPath,\n      });\n    }\n  }\n\n  private generateReport(): DoctorReport {\n    const passed = this.results.filter((r) => r.status === \"ok\").length;\n    const warnings = this.results.filter((r) => r.status === \"warning\").length;\n    const errors = this.results.filter((r) => r.status === \"error\").length;\n\n    return {\n      timestamp: new Date().toISOString(),\n      version: \"1.0.0\",\n      results: this.results,\n      summary: {\n        passed,\n        warnings,\n        errors,\n      },\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,12 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class KeysCreate extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: 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>;
+        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/create.js

@@ -0,0 +1,47 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, warn, json, colors, codeBlock, isJsonMode, } from "../../lib/output.js";
+export default class KeysCreate extends AuthenticatedCommand {
+    static description = "Create a new API key";
+    static examples = [
+        '<%= config.bin %> keys create --name "Production"',
+        '<%= config.bin %> keys create --name "CI Testing" --type test',
+        '<%= config.bin %> keys create --name "Backend" --type live --json',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "Name for the API key",
+            required: true,
+        }),
+        type: Flags.string({
+            char: "t",
+            description: "Key type (test or live)",
+            options: ["test", "live"],
+            default: "test",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(KeysCreate);
+        const response = await apiClient.post("/api/keys", {
+            name: flags.name,
+            type: flags.type,
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success("API key created", {
+            Name: response.name,
+            "Key ID": response.keyId,
+            Type: flags.type === "test" ? colors.warning("test") : colors.success("live"),
+        });
+        console.log();
+        warn("Copy your API key now. You won't be able to see it again!");
+        codeBlock(response.key);
+        console.log(colors.dim("Store this key securely. It provides access to your Sendly account."));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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