@sendly/cli 1.0.0

package/dist/lib/config.js

@@ -0,0 +1,182 @@
+/**
+ * CLI Configuration Management
+ * Stores user preferences and credentials in ~/.sendly/
+ *
+ * Environment Variables (take precedence over config file):
+ * - SENDLY_API_KEY: API key for authentication
+ * - SENDLY_BASE_URL: Custom API endpoint
+ * - SENDLY_OUTPUT_FORMAT: Default output format (human/json)
+ * - SENDLY_NO_COLOR: Disable colored output (any value)
+ * - SENDLY_TIMEOUT: Request timeout in ms (default: 30000)
+ * - SENDLY_MAX_RETRIES: Max retry attempts (default: 3)
+ * - CI: Auto-detect CI mode (disables interactive prompts)
+ */
+import Conf from "conf";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+/**
+ * Check if running in CI environment
+ */
+export function isCI() {
+    return !!(process.env.CI ||
+        process.env.CONTINUOUS_INTEGRATION ||
+        process.env.GITHUB_ACTIONS ||
+        process.env.GITLAB_CI ||
+        process.env.CIRCLECI ||
+        process.env.TRAVIS ||
+        process.env.BUILDKITE);
+}
+/**
+ * Check if color output is disabled
+ */
+export function isColorDisabled() {
+    return !!(process.env.SENDLY_NO_COLOR ||
+        process.env.NO_COLOR ||
+        process.env.TERM === "dumb");
+}
+const CONFIG_DIR = path.join(os.homedir(), ".sendly");
+const CONFIG_FILE = "config.json";
+// Ensure config directory exists
+if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+}
+const config = new Conf({
+    projectName: "sendly",
+    cwd: CONFIG_DIR,
+    configName: "config",
+    defaults: {
+        environment: "test",
+        baseUrl: "https://sendly.live",
+        defaultFormat: "human",
+        colorEnabled: true,
+        timeout: 30000,
+        maxRetries: 3,
+    },
+    // Encrypt sensitive data
+    encryptionKey: process.env.SENDLY_CONFIG_KEY || "sendly-cli-default-key-v1",
+});
+/**
+ * Get effective config value with environment variable override
+ * Priority: env var > config file > default
+ */
+export function getEffectiveValue(key) {
+    // Environment variable overrides
+    switch (key) {
+        case "apiKey":
+            if (process.env.SENDLY_API_KEY) {
+                return process.env.SENDLY_API_KEY;
+            }
+            break;
+        case "baseUrl":
+            if (process.env.SENDLY_BASE_URL) {
+                return process.env.SENDLY_BASE_URL;
+            }
+            break;
+        case "defaultFormat":
+            if (process.env.SENDLY_OUTPUT_FORMAT) {
+                const format = process.env.SENDLY_OUTPUT_FORMAT.toLowerCase();
+                if (format === "json" || format === "human") {
+                    return format;
+                }
+            }
+            break;
+        case "colorEnabled":
+            if (isColorDisabled()) {
+                return false;
+            }
+            break;
+        case "timeout":
+            if (process.env.SENDLY_TIMEOUT) {
+                const timeout = parseInt(process.env.SENDLY_TIMEOUT, 10);
+                if (!isNaN(timeout) && timeout > 0) {
+                    return timeout;
+                }
+            }
+            break;
+        case "maxRetries":
+            if (process.env.SENDLY_MAX_RETRIES) {
+                const retries = parseInt(process.env.SENDLY_MAX_RETRIES, 10);
+                if (!isNaN(retries) && retries >= 0) {
+                    return retries;
+                }
+            }
+            break;
+    }
+    // Fall back to config file value
+    return config.get(key);
+}
+export function getConfig() {
+    return config.store;
+}
+export function setConfig(key, value) {
+    config.set(key, value);
+}
+export function getConfigValue(key) {
+    return config.get(key);
+}
+export function clearConfig() {
+    config.clear();
+}
+export function clearAuth() {
+    config.delete("apiKey");
+    config.delete("accessToken");
+    config.delete("refreshToken");
+    config.delete("tokenExpiresAt");
+    config.delete("userId");
+    config.delete("email");
+}
+export function isAuthenticated() {
+    // Check env var first
+    if (process.env.SENDLY_API_KEY)
+        return true;
+    const apiKey = config.get("apiKey");
+    const accessToken = config.get("accessToken");
+    return !!(apiKey || accessToken);
+}
+export function getAuthToken() {
+    // Environment variable takes highest precedence
+    if (process.env.SENDLY_API_KEY) {
+        return process.env.SENDLY_API_KEY;
+    }
+    // Then stored API key
+    const apiKey = config.get("apiKey");
+    if (apiKey)
+        return apiKey;
+    // Finally, access token (if not expired)
+    const accessToken = config.get("accessToken");
+    const expiresAt = config.get("tokenExpiresAt");
+    if (accessToken && expiresAt && Date.now() < expiresAt) {
+        return accessToken;
+    }
+    return undefined;
+}
+export function setApiKey(apiKey) {
+    // Validate API key format
+    if (!/^sk_(test|live)_v1_[a-zA-Z0-9_-]+$/.test(apiKey)) {
+        throw new Error("Invalid API key format. Expected sk_test_v1_xxx or sk_live_v1_xxx");
+    }
+    config.set("apiKey", apiKey);
+    // Set environment based on key type
+    if (apiKey.startsWith("sk_test_")) {
+        config.set("environment", "test");
+    }
+    else {
+        config.set("environment", "live");
+    }
+}
+export function setAuthTokens(accessToken, refreshToken, expiresIn, userId, email) {
+    config.set("accessToken", accessToken);
+    config.set("refreshToken", refreshToken);
+    config.set("tokenExpiresAt", Date.now() + expiresIn * 1000);
+    config.set("userId", userId);
+    config.set("email", email);
+}
+export function getConfigPath() {
+    return path.join(CONFIG_DIR, CONFIG_FILE);
+}
+export function getConfigDir() {
+    return CONFIG_DIR;
+}
+export { config };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CLI Configuration Management\n * Stores user preferences and credentials in ~/.sendly/\n *\n * Environment Variables (take precedence over config file):\n * - SENDLY_API_KEY: API key for authentication\n * - SENDLY_BASE_URL: Custom API endpoint\n * - SENDLY_OUTPUT_FORMAT: Default output format (human/json)\n * - SENDLY_NO_COLOR: Disable colored output (any value)\n * - SENDLY_TIMEOUT: Request timeout in ms (default: 30000)\n * - SENDLY_MAX_RETRIES: Max retry attempts (default: 3)\n * - CI: Auto-detect CI mode (disables interactive prompts)\n */\n\nimport Conf from \"conf\";\nimport * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport * as os from \"node:os\";\n\nexport interface SendlyConfig {\n  // Authentication\n  apiKey?: string;\n  accessToken?: string;\n  refreshToken?: string;\n  tokenExpiresAt?: number;\n  userId?: string;\n  email?: string;\n\n  // Environment\n  environment: \"test\" | \"live\";\n  baseUrl: string;\n\n  // Preferences\n  defaultFormat: \"human\" | \"json\";\n  colorEnabled: boolean;\n\n  // Network\n  timeout: number;\n  maxRetries: number;\n}\n\n/**\n * Check if running in CI environment\n */\nexport function isCI(): boolean {\n  return !!(\n    process.env.CI ||\n    process.env.CONTINUOUS_INTEGRATION ||\n    process.env.GITHUB_ACTIONS ||\n    process.env.GITLAB_CI ||\n    process.env.CIRCLECI ||\n    process.env.TRAVIS ||\n    process.env.BUILDKITE\n  );\n}\n\n/**\n * Check if color output is disabled\n */\nexport function isColorDisabled(): boolean {\n  return !!(\n    process.env.SENDLY_NO_COLOR ||\n    process.env.NO_COLOR ||\n    process.env.TERM === \"dumb\"\n  );\n}\n\nconst CONFIG_DIR = path.join(os.homedir(), \".sendly\");\nconst CONFIG_FILE = \"config.json\";\n\n// Ensure config directory exists\nif (!fs.existsSync(CONFIG_DIR)) {\n  fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });\n}\n\nconst config = new Conf<SendlyConfig>({\n  projectName: \"sendly\",\n  cwd: CONFIG_DIR,\n  configName: \"config\",\n  defaults: {\n    environment: \"test\",\n    baseUrl: \"https://sendly.live\",\n    defaultFormat: \"human\",\n    colorEnabled: true,\n    timeout: 30000,\n    maxRetries: 3,\n  },\n  // Encrypt sensitive data\n  encryptionKey: process.env.SENDLY_CONFIG_KEY || \"sendly-cli-default-key-v1\",\n});\n\n/**\n * Get effective config value with environment variable override\n * Priority: env var > config file > default\n */\nexport function getEffectiveValue<K extends keyof SendlyConfig>(\n  key: K,\n): SendlyConfig[K] {\n  // Environment variable overrides\n  switch (key) {\n    case \"apiKey\":\n      if (process.env.SENDLY_API_KEY) {\n        return process.env.SENDLY_API_KEY as SendlyConfig[K];\n      }\n      break;\n    case \"baseUrl\":\n      if (process.env.SENDLY_BASE_URL) {\n        return process.env.SENDLY_BASE_URL as SendlyConfig[K];\n      }\n      break;\n    case \"defaultFormat\":\n      if (process.env.SENDLY_OUTPUT_FORMAT) {\n        const format = process.env.SENDLY_OUTPUT_FORMAT.toLowerCase();\n        if (format === \"json\" || format === \"human\") {\n          return format as SendlyConfig[K];\n        }\n      }\n      break;\n    case \"colorEnabled\":\n      if (isColorDisabled()) {\n        return false as SendlyConfig[K];\n      }\n      break;\n    case \"timeout\":\n      if (process.env.SENDLY_TIMEOUT) {\n        const timeout = parseInt(process.env.SENDLY_TIMEOUT, 10);\n        if (!isNaN(timeout) && timeout > 0) {\n          return timeout as SendlyConfig[K];\n        }\n      }\n      break;\n    case \"maxRetries\":\n      if (process.env.SENDLY_MAX_RETRIES) {\n        const retries = parseInt(process.env.SENDLY_MAX_RETRIES, 10);\n        if (!isNaN(retries) && retries >= 0) {\n          return retries as SendlyConfig[K];\n        }\n      }\n      break;\n  }\n\n  // Fall back to config file value\n  return config.get(key);\n}\n\nexport function getConfig(): SendlyConfig {\n  return config.store;\n}\n\nexport function setConfig<K extends keyof SendlyConfig>(\n  key: K,\n  value: SendlyConfig[K],\n): void {\n  config.set(key, value);\n}\n\nexport function getConfigValue<K extends keyof SendlyConfig>(\n  key: K,\n): SendlyConfig[K] {\n  return config.get(key);\n}\n\nexport function clearConfig(): void {\n  config.clear();\n}\n\nexport function clearAuth(): void {\n  config.delete(\"apiKey\");\n  config.delete(\"accessToken\");\n  config.delete(\"refreshToken\");\n  config.delete(\"tokenExpiresAt\");\n  config.delete(\"userId\");\n  config.delete(\"email\");\n}\n\nexport function isAuthenticated(): boolean {\n  // Check env var first\n  if (process.env.SENDLY_API_KEY) return true;\n\n  const apiKey = config.get(\"apiKey\");\n  const accessToken = config.get(\"accessToken\");\n  return !!(apiKey || accessToken);\n}\n\nexport function getAuthToken(): string | undefined {\n  // Environment variable takes highest precedence\n  if (process.env.SENDLY_API_KEY) {\n    return process.env.SENDLY_API_KEY;\n  }\n\n  // Then stored API key\n  const apiKey = config.get(\"apiKey\");\n  if (apiKey) return apiKey;\n\n  // Finally, access token (if not expired)\n  const accessToken = config.get(\"accessToken\");\n  const expiresAt = config.get(\"tokenExpiresAt\");\n\n  if (accessToken && expiresAt && Date.now() < expiresAt) {\n    return accessToken;\n  }\n\n  return undefined;\n}\n\nexport function setApiKey(apiKey: string): void {\n  // Validate API key format\n  if (!/^sk_(test|live)_v1_[a-zA-Z0-9_-]+$/.test(apiKey)) {\n    throw new Error(\n      \"Invalid API key format. Expected sk_test_v1_xxx or sk_live_v1_xxx\",\n    );\n  }\n\n  config.set(\"apiKey\", apiKey);\n\n  // Set environment based on key type\n  if (apiKey.startsWith(\"sk_test_\")) {\n    config.set(\"environment\", \"test\");\n  } else {\n    config.set(\"environment\", \"live\");\n  }\n}\n\nexport function setAuthTokens(\n  accessToken: string,\n  refreshToken: string,\n  expiresIn: number,\n  userId: string,\n  email: string,\n): void {\n  config.set(\"accessToken\", accessToken);\n  config.set(\"refreshToken\", refreshToken);\n  config.set(\"tokenExpiresAt\", Date.now() + expiresIn * 1000);\n  config.set(\"userId\", userId);\n  config.set(\"email\", email);\n}\n\nexport function getConfigPath(): string {\n  return path.join(CONFIG_DIR, CONFIG_FILE);\n}\n\nexport function getConfigDir(): string {\n  return CONFIG_DIR;\n}\n\nexport { config };\n"]}

package/dist/lib/output.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Output Formatting Utilities
+ * Handles human-readable and JSON output modes
+ */
+import { type Ora } from "ora";
+export type OutputFormat = "human" | "json";
+export declare function setOutputFormat(format: OutputFormat): void;
+export declare function setQuietMode(quiet: boolean): void;
+export declare function getOutputFormat(): OutputFormat;
+export declare function isJsonMode(): boolean;
+export declare function isQuietMode(): boolean;
+export declare const colors: {
+    primary: import("chalk").ChalkInstance;
+    success: import("chalk").ChalkInstance;
+    error: import("chalk").ChalkInstance;
+    warning: import("chalk").ChalkInstance;
+    info: import("chalk").ChalkInstance;
+    dim: import("chalk").ChalkInstance;
+    bold: import("chalk").ChalkInstance;
+    code: import("chalk").ChalkInstance;
+};
+export declare function success(message: string, data?: Record<string, unknown>): void;
+export declare function error(message: string, details?: Record<string, unknown>): void;
+export declare function warn(message: string): void;
+export declare function info(message: string): void;
+export declare function json(data: unknown): void;
+export interface TableColumn {
+    header: string;
+    key: string;
+    width?: number;
+    formatter?: (value: unknown) => string;
+}
+export declare function table(data: Array<Record<string, any>>, columns: TableColumn[]): void;
+export declare function spinner(text: string): Ora;
+export declare function formatStatus(status: string): string;
+export declare function formatDate(date: string | Date | number): string;
+export declare function formatRelativeTime(date: string | Date | number): string;
+export declare function formatCredits(credits: number): string;
+export declare function formatPhone(phone: string): string;
+export declare function header(title: string): void;
+export declare function divider(): void;
+export declare function keyValue(data: Record<string, unknown>): void;
+export declare function codeBlock(code: string, language?: string): void;

package/dist/lib/output.js

@@ -0,0 +1,222 @@
+/**
+ * Output Formatting Utilities
+ * Handles human-readable and JSON output modes
+ */
+import chalk from "chalk";
+import Table from "cli-table3";
+import ora from "ora";
+let currentFormat = "human";
+let quietMode = false;
+export function setOutputFormat(format) {
+    currentFormat = format;
+}
+export function setQuietMode(quiet) {
+    quietMode = quiet;
+}
+export function getOutputFormat() {
+    return currentFormat;
+}
+export function isJsonMode() {
+    return currentFormat === "json";
+}
+export function isQuietMode() {
+    return quietMode;
+}
+// Colors
+export const colors = {
+    primary: chalk.hex("#F59E0B"), // Amber/Orange - Sendly brand
+    success: chalk.green,
+    error: chalk.red,
+    warning: chalk.yellow,
+    info: chalk.blue,
+    dim: chalk.dim,
+    bold: chalk.bold,
+    code: chalk.cyan,
+};
+// Success output
+export function success(message, data) {
+    if (isJsonMode()) {
+        console.log(JSON.stringify({ success: true, message, ...data }, null, 2));
+        return;
+    }
+    if (quietMode) {
+        if (data?.id)
+            console.log(data.id);
+        return;
+    }
+    console.log(`${colors.success("✓")} ${message}`);
+    if (data) {
+        Object.entries(data).forEach(([key, value]) => {
+            console.log(`  ${colors.dim(key + ":")} ${value}`);
+        });
+    }
+}
+// Error output
+export function error(message, details) {
+    if (isJsonMode()) {
+        console.error(JSON.stringify({ error: true, message, ...details }, null, 2));
+        return;
+    }
+    console.error(`${colors.error("✗")} ${message}`);
+    if (details && !quietMode) {
+        Object.entries(details).forEach(([key, value]) => {
+            console.error(`  ${colors.dim(key + ":")} ${value}`);
+        });
+    }
+}
+// Warning output
+export function warn(message) {
+    if (isJsonMode())
+        return;
+    if (quietMode)
+        return;
+    console.log(`${colors.warning("⚠")} ${message}`);
+}
+// Info output
+export function info(message) {
+    if (isJsonMode())
+        return;
+    if (quietMode)
+        return;
+    console.log(`${colors.info("ℹ")} ${message}`);
+}
+// Print raw JSON
+export function json(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+export function table(data, columns) {
+    if (isJsonMode()) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    if (data.length === 0) {
+        info("No data to display");
+        return;
+    }
+    const t = new Table({
+        head: columns.map((c) => colors.bold(c.header)),
+        style: {
+            head: [],
+            border: [],
+        },
+        colWidths: columns.map((c) => c.width ?? null),
+    });
+    data.forEach((row) => {
+        t.push(columns.map((col) => {
+            const value = row[col.key];
+            if (col.formatter) {
+                return col.formatter(value);
+            }
+            return String(value ?? "-");
+        }));
+    });
+    console.log(t.toString());
+}
+// Spinner for long operations
+export function spinner(text) {
+    if (isJsonMode() || quietMode) {
+        return {
+            start: () => ({ stop: () => { }, succeed: () => { }, fail: () => { } }),
+            stop: () => { },
+            succeed: () => { },
+            fail: () => { },
+        };
+    }
+    return ora({
+        text,
+        color: "yellow",
+        spinner: "dots",
+    });
+}
+// Status formatters
+export function formatStatus(status) {
+    switch (status.toLowerCase()) {
+        case "delivered":
+        case "success":
+        case "active":
+        case "verified":
+            return colors.success(status);
+        case "failed":
+        case "error":
+        case "revoked":
+        case "rejected":
+            return colors.error(status);
+        case "queued":
+        case "pending":
+        case "processing":
+            return colors.warning(status);
+        case "sent":
+            return colors.info(status);
+        default:
+            return status;
+    }
+}
+// Format date
+export function formatDate(date) {
+    const d = new Date(date);
+    return d.toLocaleString();
+}
+// Format relative time
+export function formatRelativeTime(date) {
+    const d = new Date(date);
+    const now = new Date();
+    const diff = now.getTime() - d.getTime();
+    const seconds = Math.floor(diff / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ago`;
+    if (hours > 0)
+        return `${hours}h ago`;
+    if (minutes > 0)
+        return `${minutes}m ago`;
+    return `${seconds}s ago`;
+}
+// Format credits
+export function formatCredits(credits) {
+    return `${credits.toLocaleString()} credits`;
+}
+// Format phone number
+export function formatPhone(phone) {
+    return colors.code(phone);
+}
+// Header for commands
+export function header(title) {
+    if (isJsonMode() || quietMode)
+        return;
+    console.log();
+    console.log(colors.bold(colors.primary(title)));
+    console.log(colors.dim("─".repeat(40)));
+}
+// Divider
+export function divider() {
+    if (isJsonMode() || quietMode)
+        return;
+    console.log();
+}
+// Key-value display
+export function keyValue(data) {
+    if (isJsonMode()) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    const maxKeyLength = Math.max(...Object.keys(data).map((k) => k.length));
+    Object.entries(data).forEach(([key, value]) => {
+        const paddedKey = key.padEnd(maxKeyLength);
+        console.log(`  ${colors.dim(paddedKey)}  ${value}`);
+    });
+}
+// Code block
+export function codeBlock(code, language) {
+    if (isJsonMode()) {
+        console.log(JSON.stringify({ code, language }, null, 2));
+        return;
+    }
+    console.log();
+    console.log(colors.dim("```" + (language || "")));
+    console.log(colors.code(code));
+    console.log(colors.dim("```"));
+    console.log();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"output.js","sourceRoot":"","sources":["../../src/lib/output.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Output Formatting Utilities\n * Handles human-readable and JSON output modes\n */\n\nimport chalk from \"chalk\";\nimport Table from \"cli-table3\";\nimport ora, { type Ora } from \"ora\";\nimport { getConfigValue } from \"./config.js\";\n\nexport type OutputFormat = \"human\" | \"json\";\n\nlet currentFormat: OutputFormat = \"human\";\nlet quietMode = false;\n\nexport function setOutputFormat(format: OutputFormat): void {\n  currentFormat = format;\n}\n\nexport function setQuietMode(quiet: boolean): void {\n  quietMode = quiet;\n}\n\nexport function getOutputFormat(): OutputFormat {\n  return currentFormat;\n}\n\nexport function isJsonMode(): boolean {\n  return currentFormat === \"json\";\n}\n\nexport function isQuietMode(): boolean {\n  return quietMode;\n}\n\n// Colors\nexport const colors = {\n  primary: chalk.hex(\"#F59E0B\"), // Amber/Orange - Sendly brand\n  success: chalk.green,\n  error: chalk.red,\n  warning: chalk.yellow,\n  info: chalk.blue,\n  dim: chalk.dim,\n  bold: chalk.bold,\n  code: chalk.cyan,\n};\n\n// Success output\nexport function success(message: string, data?: Record<string, unknown>): void {\n  if (isJsonMode()) {\n    console.log(JSON.stringify({ success: true, message, ...data }, null, 2));\n    return;\n  }\n\n  if (quietMode) {\n    if (data?.id) console.log(data.id);\n    return;\n  }\n\n  console.log(`${colors.success(\"✓\")} ${message}`);\n  if (data) {\n    Object.entries(data).forEach(([key, value]) => {\n      console.log(`  ${colors.dim(key + \":\")} ${value}`);\n    });\n  }\n}\n\n// Error output\nexport function error(\n  message: string,\n  details?: Record<string, unknown>,\n): void {\n  if (isJsonMode()) {\n    console.error(\n      JSON.stringify({ error: true, message, ...details }, null, 2),\n    );\n    return;\n  }\n\n  console.error(`${colors.error(\"✗\")} ${message}`);\n  if (details && !quietMode) {\n    Object.entries(details).forEach(([key, value]) => {\n      console.error(`  ${colors.dim(key + \":\")} ${value}`);\n    });\n  }\n}\n\n// Warning output\nexport function warn(message: string): void {\n  if (isJsonMode()) return;\n  if (quietMode) return;\n  console.log(`${colors.warning(\"⚠\")} ${message}`);\n}\n\n// Info output\nexport function info(message: string): void {\n  if (isJsonMode()) return;\n  if (quietMode) return;\n  console.log(`${colors.info(\"ℹ\")} ${message}`);\n}\n\n// Print raw JSON\nexport function json(data: unknown): void {\n  console.log(JSON.stringify(data, null, 2));\n}\n\n// Print a table\nexport interface TableColumn {\n  header: string;\n  key: string;\n  width?: number;\n  formatter?: (value: unknown) => string;\n}\n\nexport function table(\n  data: Array<Record<string, any>>,\n  columns: TableColumn[],\n): void {\n  if (isJsonMode()) {\n    console.log(JSON.stringify(data, null, 2));\n    return;\n  }\n\n  if (data.length === 0) {\n    info(\"No data to display\");\n    return;\n  }\n\n  const t = new Table({\n    head: columns.map((c) => colors.bold(c.header)),\n    style: {\n      head: [],\n      border: [],\n    },\n    colWidths: columns.map((c) => c.width ?? null),\n  });\n\n  data.forEach((row) => {\n    t.push(\n      columns.map((col) => {\n        const value = row[col.key];\n        if (col.formatter) {\n          return col.formatter(value);\n        }\n        return String(value ?? \"-\");\n      }),\n    );\n  });\n\n  console.log(t.toString());\n}\n\n// Spinner for long operations\nexport function spinner(text: string): Ora {\n  if (isJsonMode() || quietMode) {\n    return {\n      start: () => ({ stop: () => {}, succeed: () => {}, fail: () => {} }),\n      stop: () => {},\n      succeed: () => {},\n      fail: () => {},\n    } as unknown as Ora;\n  }\n\n  return ora({\n    text,\n    color: \"yellow\",\n    spinner: \"dots\",\n  });\n}\n\n// Status formatters\nexport function formatStatus(status: string): string {\n  switch (status.toLowerCase()) {\n    case \"delivered\":\n    case \"success\":\n    case \"active\":\n    case \"verified\":\n      return colors.success(status);\n    case \"failed\":\n    case \"error\":\n    case \"revoked\":\n    case \"rejected\":\n      return colors.error(status);\n    case \"queued\":\n    case \"pending\":\n    case \"processing\":\n      return colors.warning(status);\n    case \"sent\":\n      return colors.info(status);\n    default:\n      return status;\n  }\n}\n\n// Format date\nexport function formatDate(date: string | Date | number): string {\n  const d = new Date(date);\n  return d.toLocaleString();\n}\n\n// Format relative time\nexport function formatRelativeTime(date: string | Date | number): string {\n  const d = new Date(date);\n  const now = new Date();\n  const diff = now.getTime() - d.getTime();\n\n  const seconds = Math.floor(diff / 1000);\n  const minutes = Math.floor(seconds / 60);\n  const hours = Math.floor(minutes / 60);\n  const days = Math.floor(hours / 24);\n\n  if (days > 0) return `${days}d ago`;\n  if (hours > 0) return `${hours}h ago`;\n  if (minutes > 0) return `${minutes}m ago`;\n  return `${seconds}s ago`;\n}\n\n// Format credits\nexport function formatCredits(credits: number): string {\n  return `${credits.toLocaleString()} credits`;\n}\n\n// Format phone number\nexport function formatPhone(phone: string): string {\n  return colors.code(phone);\n}\n\n// Header for commands\nexport function header(title: string): void {\n  if (isJsonMode() || quietMode) return;\n  console.log();\n  console.log(colors.bold(colors.primary(title)));\n  console.log(colors.dim(\"─\".repeat(40)));\n}\n\n// Divider\nexport function divider(): void {\n  if (isJsonMode() || quietMode) return;\n  console.log();\n}\n\n// Key-value display\nexport function keyValue(data: Record<string, unknown>): void {\n  if (isJsonMode()) {\n    console.log(JSON.stringify(data, null, 2));\n    return;\n  }\n\n  const maxKeyLength = Math.max(...Object.keys(data).map((k) => k.length));\n\n  Object.entries(data).forEach(([key, value]) => {\n    const paddedKey = key.padEnd(maxKeyLength);\n    console.log(`  ${colors.dim(paddedKey)}  ${value}`);\n  });\n}\n\n// Code block\nexport function codeBlock(code: string, language?: string): void {\n  if (isJsonMode()) {\n    console.log(JSON.stringify({ code, language }, null, 2));\n    return;\n  }\n\n  console.log();\n  console.log(colors.dim(\"```\" + (language || \"\")));\n  console.log(colors.code(code));\n  console.log(colors.dim(\"```\"));\n  console.log();\n}\n"]}