@sendly/cli 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Sendly CLI
+ *
+ * The official command-line interface for Sendly SMS API.
+ *
+ * @example
+ * ```bash
+ * # Install
+ * npm install -g @sendly/cli
+ *
+ * # Login
+ * sendly login
+ *
+ * # Send an SMS
+ * sendly sms send --to +15551234567 --text "Hello from Sendly!"
+ *
+ * # List messages
+ * sendly sms list
+ *
+ * # Listen for webhooks locally
+ * sendly webhooks listen --forward http://localhost:3000/webhook
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { run } from "@oclif/core";

package/dist/index.js

@@ -0,0 +1,27 @@
+/**
+ * Sendly CLI
+ *
+ * The official command-line interface for Sendly SMS API.
+ *
+ * @example
+ * ```bash
+ * # Install
+ * npm install -g @sendly/cli
+ *
+ * # Login
+ * sendly login
+ *
+ * # Send an SMS
+ * sendly sms send --to +15551234567 --text "Hello from Sendly!"
+ *
+ * # List messages
+ * sendly sms list
+ *
+ * # Listen for webhooks locally
+ * sendly webhooks listen --forward http://localhost:3000/webhook
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { run } from "@oclif/core";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXdCRztBQUVILE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFNlbmRseSBDTElcbiAqXG4gKiBUaGUgb2ZmaWNpYWwgY29tbWFuZC1saW5lIGludGVyZmFjZSBmb3IgU2VuZGx5IFNNUyBBUEkuXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYGJhc2hcbiAqICMgSW5zdGFsbFxuICogbnBtIGluc3RhbGwgLWcgQHNlbmRseS9jbGlcbiAqXG4gKiAjIExvZ2luXG4gKiBzZW5kbHkgbG9naW5cbiAqXG4gKiAjIFNlbmQgYW4gU01TXG4gKiBzZW5kbHkgc21zIHNlbmQgLS10byArMTU1NTEyMzQ1NjcgLS10ZXh0IFwiSGVsbG8gZnJvbSBTZW5kbHkhXCJcbiAqXG4gKiAjIExpc3QgbWVzc2FnZXNcbiAqIHNlbmRseSBzbXMgbGlzdFxuICpcbiAqICMgTGlzdGVuIGZvciB3ZWJob29rcyBsb2NhbGx5XG4gKiBzZW5kbHkgd2ViaG9va3MgbGlzdGVuIC0tZm9yd2FyZCBodHRwOi8vbG9jYWxob3N0OjMwMDAvd2ViaG9va1xuICogYGBgXG4gKlxuICogQHBhY2thZ2VEb2N1bWVudGF0aW9uXG4gKi9cblxuZXhwb3J0IHsgcnVuIH0gZnJvbSBcIkBvY2xpZi9jb3JlXCI7XG4iXX0=

package/dist/lib/api-client.d.ts

@@ -0,0 +1,52 @@
+/**
+ * API Client for Sendly CLI
+ * Handles all HTTP requests to the Sendly API
+ */
+export interface ApiResponse<T> {
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+}
+export interface RateLimitInfo {
+    limit: number;
+    remaining: number;
+    reset: number;
+}
+export declare class ApiError extends Error {
+    code: string;
+    statusCode: number;
+    details?: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, statusCode: number, details?: Record<string, unknown> | undefined);
+}
+export declare class AuthenticationError extends ApiError {
+    constructor(message?: string);
+}
+export declare class RateLimitError extends ApiError {
+    retryAfter: number;
+    constructor(retryAfter: number, message?: string);
+}
+export declare class InsufficientCreditsError extends ApiError {
+    constructor(message?: string);
+}
+declare class ApiClient {
+    private rateLimitInfo?;
+    private getBaseUrl;
+    private getHeaders;
+    request<T>(method: string, path: string, options?: {
+        body?: Record<string, unknown>;
+        query?: Record<string, string | number | boolean | undefined>;
+        requireAuth?: boolean;
+    }): Promise<T>;
+    private updateRateLimitInfo;
+    private handleError;
+    getRateLimitInfo(): RateLimitInfo | undefined;
+    get<T>(path: string, query?: Record<string, string | number | boolean | undefined>, requireAuth?: boolean): Promise<T>;
+    post<T>(path: string, body?: Record<string, unknown>, requireAuth?: boolean): Promise<T>;
+    patch<T>(path: string, body?: Record<string, unknown>, requireAuth?: boolean): Promise<T>;
+    delete<T>(path: string, requireAuth?: boolean): Promise<T>;
+}
+export declare const apiClient: ApiClient;
+export {};

package/dist/lib/api-client.js

@@ -0,0 +1,129 @@
+/**
+ * API Client for Sendly CLI
+ * Handles all HTTP requests to the Sendly API
+ */
+import { getAuthToken, getConfigValue } from "./config.js";
+export class ApiError extends Error {
+    code;
+    statusCode;
+    details;
+    constructor(code, message, statusCode, details) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+        this.name = "ApiError";
+    }
+}
+export class AuthenticationError extends ApiError {
+    constructor(message = "Not authenticated. Run 'sendly login' first.") {
+        super("authentication_error", message, 401);
+        this.name = "AuthenticationError";
+    }
+}
+export class RateLimitError extends ApiError {
+    retryAfter;
+    constructor(retryAfter, message = "Rate limit exceeded") {
+        super("rate_limit_exceeded", message, 429);
+        this.retryAfter = retryAfter;
+        this.name = "RateLimitError";
+    }
+}
+export class InsufficientCreditsError extends ApiError {
+    constructor(message = "Insufficient credits") {
+        super("insufficient_credits", message, 402);
+        this.name = "InsufficientCreditsError";
+    }
+}
+class ApiClient {
+    rateLimitInfo;
+    getBaseUrl() {
+        return getConfigValue("baseUrl") || "https://sendly.live";
+    }
+    getHeaders(requireAuth = true) {
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "User-Agent": "@sendly/cli/1.0.0",
+        };
+        if (requireAuth) {
+            const token = getAuthToken();
+            if (!token) {
+                throw new AuthenticationError();
+            }
+            headers["Authorization"] = `Bearer ${token}`;
+        }
+        return headers;
+    }
+    async request(method, path, options = {}) {
+        const { body, query, requireAuth = true } = options;
+        const url = new URL(`${this.getBaseUrl()}${path}`);
+        if (query) {
+            Object.entries(query).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    url.searchParams.append(key, String(value));
+                }
+            });
+        }
+        const response = await fetch(url.toString(), {
+            method,
+            headers: this.getHeaders(requireAuth),
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        // Update rate limit info
+        this.updateRateLimitInfo(response.headers);
+        // Parse response
+        const data = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            this.handleError(response.status, data);
+        }
+        return data;
+    }
+    updateRateLimitInfo(headers) {
+        const limit = headers.get("X-RateLimit-Limit");
+        const remaining = headers.get("X-RateLimit-Remaining");
+        const reset = headers.get("X-RateLimit-Reset");
+        if (limit && remaining && reset) {
+            this.rateLimitInfo = {
+                limit: parseInt(limit, 10),
+                remaining: parseInt(remaining, 10),
+                reset: parseInt(reset, 10),
+            };
+        }
+    }
+    handleError(statusCode, data) {
+        const error = data?.error || "unknown_error";
+        const message = data?.message || `HTTP ${statusCode}`;
+        const details = data?.details;
+        switch (statusCode) {
+            case 401:
+            case 403:
+                throw new AuthenticationError(message);
+            case 402:
+                throw new InsufficientCreditsError(message);
+            case 429:
+                const retryAfter = data?.retryAfter || 60;
+                throw new RateLimitError(retryAfter, message);
+            default:
+                throw new ApiError(error, message, statusCode, details);
+        }
+    }
+    getRateLimitInfo() {
+        return this.rateLimitInfo;
+    }
+    // Convenience methods
+    async get(path, query, requireAuth = true) {
+        return this.request("GET", path, { query, requireAuth });
+    }
+    async post(path, body, requireAuth = true) {
+        return this.request("POST", path, { body, requireAuth });
+    }
+    async patch(path, body, requireAuth = true) {
+        return this.request("PATCH", path, { body, requireAuth });
+    }
+    async delete(path, requireAuth = true) {
+        return this.request("DELETE", path, { requireAuth });
+    }
+}
+export const apiClient = new ApiClient();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-client.js","sourceRoot":"","sources":["../../src/lib/api-client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * API Client for Sendly CLI\n * Handles all HTTP requests to the Sendly API\n */\n\nimport { getAuthToken, getConfigValue } from \"./config.js\";\n\nexport interface ApiResponse<T> {\n  data?: T;\n  error?: {\n    code: string;\n    message: string;\n    details?: Record<string, unknown>;\n  };\n}\n\nexport interface RateLimitInfo {\n  limit: number;\n  remaining: number;\n  reset: number;\n}\n\nexport class ApiError extends Error {\n  constructor(\n    public code: string,\n    message: string,\n    public statusCode: number,\n    public details?: Record<string, unknown>\n  ) {\n    super(message);\n    this.name = \"ApiError\";\n  }\n}\n\nexport class AuthenticationError extends ApiError {\n  constructor(message: string = \"Not authenticated. Run 'sendly login' first.\") {\n    super(\"authentication_error\", message, 401);\n    this.name = \"AuthenticationError\";\n  }\n}\n\nexport class RateLimitError extends ApiError {\n  constructor(\n    public retryAfter: number,\n    message: string = \"Rate limit exceeded\"\n  ) {\n    super(\"rate_limit_exceeded\", message, 429);\n    this.name = \"RateLimitError\";\n  }\n}\n\nexport class InsufficientCreditsError extends ApiError {\n  constructor(message: string = \"Insufficient credits\") {\n    super(\"insufficient_credits\", message, 402);\n    this.name = \"InsufficientCreditsError\";\n  }\n}\n\nclass ApiClient {\n  private rateLimitInfo?: RateLimitInfo;\n\n  private getBaseUrl(): string {\n    return getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n  }\n\n  private getHeaders(requireAuth: boolean = true): Record<string, string> {\n    const headers: Record<string, string> = {\n      \"Content-Type\": \"application/json\",\n      Accept: \"application/json\",\n      \"User-Agent\": \"@sendly/cli/1.0.0\",\n    };\n\n    if (requireAuth) {\n      const token = getAuthToken();\n      if (!token) {\n        throw new AuthenticationError();\n      }\n      headers[\"Authorization\"] = `Bearer ${token}`;\n    }\n\n    return headers;\n  }\n\n  async request<T>(\n    method: string,\n    path: string,\n    options: {\n      body?: Record<string, unknown>;\n      query?: Record<string, string | number | boolean | undefined>;\n      requireAuth?: boolean;\n    } = {}\n  ): Promise<T> {\n    const { body, query, requireAuth = true } = options;\n\n    const url = new URL(`${this.getBaseUrl()}${path}`);\n    if (query) {\n      Object.entries(query).forEach(([key, value]) => {\n        if (value !== undefined) {\n          url.searchParams.append(key, String(value));\n        }\n      });\n    }\n\n    const response = await fetch(url.toString(), {\n      method,\n      headers: this.getHeaders(requireAuth),\n      body: body ? JSON.stringify(body) : undefined,\n    });\n\n    // Update rate limit info\n    this.updateRateLimitInfo(response.headers);\n\n    // Parse response\n    const data = await response.json().catch(() => ({}));\n\n    if (!response.ok) {\n      this.handleError(response.status, data);\n    }\n\n    return data as T;\n  }\n\n  private updateRateLimitInfo(headers: Headers): void {\n    const limit = headers.get(\"X-RateLimit-Limit\");\n    const remaining = headers.get(\"X-RateLimit-Remaining\");\n    const reset = headers.get(\"X-RateLimit-Reset\");\n\n    if (limit && remaining && reset) {\n      this.rateLimitInfo = {\n        limit: parseInt(limit, 10),\n        remaining: parseInt(remaining, 10),\n        reset: parseInt(reset, 10),\n      };\n    }\n  }\n\n  private handleError(statusCode: number, data: any): never {\n    const error = data?.error || \"unknown_error\";\n    const message = data?.message || `HTTP ${statusCode}`;\n    const details = data?.details;\n\n    switch (statusCode) {\n      case 401:\n      case 403:\n        throw new AuthenticationError(message);\n      case 402:\n        throw new InsufficientCreditsError(message);\n      case 429:\n        const retryAfter = data?.retryAfter || 60;\n        throw new RateLimitError(retryAfter, message);\n      default:\n        throw new ApiError(error, message, statusCode, details);\n    }\n  }\n\n  getRateLimitInfo(): RateLimitInfo | undefined {\n    return this.rateLimitInfo;\n  }\n\n  // Convenience methods\n  async get<T>(\n    path: string,\n    query?: Record<string, string | number | boolean | undefined>,\n    requireAuth: boolean = true\n  ): Promise<T> {\n    return this.request<T>(\"GET\", path, { query, requireAuth });\n  }\n\n  async post<T>(\n    path: string,\n    body?: Record<string, unknown>,\n    requireAuth: boolean = true\n  ): Promise<T> {\n    return this.request<T>(\"POST\", path, { body, requireAuth });\n  }\n\n  async patch<T>(\n    path: string,\n    body?: Record<string, unknown>,\n    requireAuth: boolean = true\n  ): Promise<T> {\n    return this.request<T>(\"PATCH\", path, { body, requireAuth });\n  }\n\n  async delete<T>(path: string, requireAuth: boolean = true): Promise<T> {\n    return this.request<T>(\"DELETE\", path, { requireAuth });\n  }\n}\n\nexport const apiClient = new ApiClient();\n"]}

package/dist/lib/auth.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Authentication utilities for CLI
+ * Handles browser-based login flow and API key authentication
+ */
+export interface DeviceCodeResponse {
+    deviceCode: string;
+    userCode: string;
+    verificationUrl: string;
+    expiresIn: number;
+    interval: number;
+}
+export interface TokenResponse {
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    userId: string;
+    email: string;
+}
+/**
+ * Generate a device code for browser-based authentication
+ */
+export declare function generateDeviceCode(): string;
+/**
+ * Generate a secure device code for the auth flow
+ */
+export declare function generateSecureCode(): string;
+/**
+ * Start the browser-based login flow
+ */
+export declare function browserLogin(): Promise<TokenResponse>;
+/**
+ * Login with an API key directly
+ */
+export declare function apiKeyLogin(apiKey: string): Promise<void>;
+/**
+ * Logout - clear all stored credentials
+ */
+export declare function logout(): void;
+/**
+ * Check if currently authenticated
+ */
+export declare function checkAuth(): boolean;
+/**
+ * Get current auth info for display
+ */
+export declare function getAuthInfo(): Promise<{
+    authenticated: boolean;
+    email?: string;
+    userId?: string;
+    environment: string;
+    keyType?: string;
+}>;

package/dist/lib/auth.js

@@ -0,0 +1,171 @@
+/**
+ * Authentication utilities for CLI
+ * Handles browser-based login flow and API key authentication
+ */
+import open from "open";
+import * as crypto from "node:crypto";
+import { setAuthTokens, setApiKey, clearAuth, getConfigValue, isAuthenticated, getAuthToken, } from "./config.js";
+import { colors, spinner } from "./output.js";
+const DEVICE_CODE_LENGTH = 8;
+const POLL_INTERVAL = 2000; // 2 seconds
+const MAX_POLL_ATTEMPTS = 150; // 5 minutes max
+/**
+ * Generate a device code for browser-based authentication
+ */
+export function generateDeviceCode() {
+    return crypto.randomBytes(4).toString("hex").toUpperCase();
+}
+/**
+ * Generate a secure device code for the auth flow
+ */
+export function generateSecureCode() {
+    const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"; // Exclude confusing chars
+    let code = "";
+    const bytes = crypto.randomBytes(DEVICE_CODE_LENGTH);
+    for (let i = 0; i < DEVICE_CODE_LENGTH; i++) {
+        code += chars[bytes[i] % chars.length];
+    }
+    return code;
+}
+/**
+ * Start the browser-based login flow
+ */
+export async function browserLogin() {
+    const baseUrl = getConfigValue("baseUrl") || "https://sendly.live";
+    const deviceCode = generateSecureCode();
+    const userCode = `${deviceCode.slice(0, 4)}-${deviceCode.slice(4)}`;
+    // Request device code from server
+    const response = await fetch(`${baseUrl}/api/cli/auth/device-code`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ deviceCode }),
+    });
+    if (!response.ok) {
+        const error = (await response.json().catch(() => ({})));
+        throw new Error(error.message || "Failed to initiate login");
+    }
+    const data = (await response.json());
+    // Display instructions to user
+    console.log();
+    console.log(colors.bold("Login to Sendly"));
+    console.log();
+    console.log(`Open this URL in your browser:`);
+    console.log(colors.primary(`  ${data.verificationUrl}`));
+    console.log();
+    console.log(`And enter this code:`);
+    console.log(colors.bold(colors.primary(`  ${userCode}`)));
+    console.log();
+    // Try to open browser automatically
+    try {
+        await open(data.verificationUrl);
+        console.log(colors.dim("Browser opened automatically"));
+    }
+    catch {
+        console.log(colors.dim("Please open the URL manually"));
+    }
+    console.log();
+    // Poll for token
+    const spin = spinner("Waiting for authorization...");
+    spin.start();
+    let attempts = 0;
+    while (attempts < MAX_POLL_ATTEMPTS) {
+        await sleep(data.interval * 1000 || POLL_INTERVAL);
+        attempts++;
+        try {
+            const tokenResponse = await fetch(`${baseUrl}/api/cli/auth/token`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ deviceCode }),
+            });
+            if (tokenResponse.ok) {
+                const tokens = (await tokenResponse.json());
+                spin.succeed("Logged in successfully!");
+                // Store tokens
+                setAuthTokens(tokens.accessToken, tokens.refreshToken, tokens.expiresIn, tokens.userId, tokens.email);
+                return tokens;
+            }
+            const errorData = (await tokenResponse.json().catch(() => ({})));
+            if (errorData.error === "authorization_pending") {
+                // Still waiting, continue polling
+                continue;
+            }
+            if (errorData.error === "expired_token") {
+                spin.fail("Login request expired. Please try again.");
+                throw new Error("Login request expired");
+            }
+            if (errorData.error === "access_denied") {
+                spin.fail("Login was denied");
+                throw new Error("Login was denied");
+            }
+        }
+        catch (error) {
+            if (error.message.includes("expired") ||
+                error.message.includes("denied")) {
+                throw error;
+            }
+            // Network error, continue polling
+        }
+    }
+    spin.fail("Login timed out. Please try again.");
+    throw new Error("Login timed out");
+}
+/**
+ * Login with an API key directly
+ */
+export async function apiKeyLogin(apiKey) {
+    const baseUrl = getConfigValue("baseUrl") || "https://sendly.live";
+    // Validate the API key with the server
+    const response = await fetch(`${baseUrl}/api/cli/auth/verify-key`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        },
+    });
+    if (!response.ok) {
+        const error = (await response.json().catch(() => ({})));
+        throw new Error(error.message || "Invalid API key");
+    }
+    // Store the API key
+    setApiKey(apiKey);
+}
+/**
+ * Logout - clear all stored credentials
+ */
+export function logout() {
+    clearAuth();
+}
+/**
+ * Check if currently authenticated
+ */
+export function checkAuth() {
+    return isAuthenticated();
+}
+/**
+ * Get current auth info for display
+ */
+export async function getAuthInfo() {
+    const token = getAuthToken();
+    const email = getConfigValue("email");
+    const userId = getConfigValue("userId");
+    const apiKey = getConfigValue("apiKey");
+    const environment = getConfigValue("environment");
+    if (!token && !apiKey) {
+        return { authenticated: false, environment };
+    }
+    let keyType;
+    if (apiKey) {
+        keyType = apiKey.startsWith("sk_test_") ? "test" : "live";
+    }
+    return {
+        authenticated: true,
+        email,
+        userId,
+        environment,
+        keyType,
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/lib/auth.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Authentication utilities for CLI\n * Handles browser-based login flow and API key authentication\n */\n\nimport open from \"open\";\nimport * as http from \"node:http\";\nimport * as crypto from \"node:crypto\";\nimport {\n  setAuthTokens,\n  setApiKey,\n  clearAuth,\n  getConfigValue,\n  isAuthenticated,\n  getAuthToken,\n} from \"./config.js\";\nimport { colors, spinner } from \"./output.js\";\n\nconst DEVICE_CODE_LENGTH = 8;\nconst POLL_INTERVAL = 2000; // 2 seconds\nconst MAX_POLL_ATTEMPTS = 150; // 5 minutes max\n\nexport interface DeviceCodeResponse {\n  deviceCode: string;\n  userCode: string;\n  verificationUrl: string;\n  expiresIn: number;\n  interval: number;\n}\n\nexport interface TokenResponse {\n  accessToken: string;\n  refreshToken: string;\n  expiresIn: number;\n  userId: string;\n  email: string;\n}\n\n/**\n * Generate a device code for browser-based authentication\n */\nexport function generateDeviceCode(): string {\n  return crypto.randomBytes(4).toString(\"hex\").toUpperCase();\n}\n\n/**\n * Generate a secure device code for the auth flow\n */\nexport function generateSecureCode(): string {\n  const chars = \"ABCDEFGHJKLMNPQRSTUVWXYZ23456789\"; // Exclude confusing chars\n  let code = \"\";\n  const bytes = crypto.randomBytes(DEVICE_CODE_LENGTH);\n  for (let i = 0; i < DEVICE_CODE_LENGTH; i++) {\n    code += chars[bytes[i] % chars.length];\n  }\n  return code;\n}\n\n/**\n * Start the browser-based login flow\n */\nexport async function browserLogin(): Promise<TokenResponse> {\n  const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n  const deviceCode = generateSecureCode();\n  const userCode = `${deviceCode.slice(0, 4)}-${deviceCode.slice(4)}`;\n\n  // Request device code from server\n  const response = await fetch(`${baseUrl}/api/cli/auth/device-code`, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/json\" },\n    body: JSON.stringify({ deviceCode }),\n  });\n\n  if (!response.ok) {\n    const error = (await response.json().catch(() => ({}))) as {\n      message?: string;\n    };\n    throw new Error(error.message || \"Failed to initiate login\");\n  }\n\n  const data = (await response.json()) as DeviceCodeResponse;\n\n  // Display instructions to user\n  console.log();\n  console.log(colors.bold(\"Login to Sendly\"));\n  console.log();\n  console.log(`Open this URL in your browser:`);\n  console.log(colors.primary(`  ${data.verificationUrl}`));\n  console.log();\n  console.log(`And enter this code:`);\n  console.log(colors.bold(colors.primary(`  ${userCode}`)));\n  console.log();\n\n  // Try to open browser automatically\n  try {\n    await open(data.verificationUrl);\n    console.log(colors.dim(\"Browser opened automatically\"));\n  } catch {\n    console.log(colors.dim(\"Please open the URL manually\"));\n  }\n\n  console.log();\n\n  // Poll for token\n  const spin = spinner(\"Waiting for authorization...\");\n  spin.start();\n\n  let attempts = 0;\n  while (attempts < MAX_POLL_ATTEMPTS) {\n    await sleep(data.interval * 1000 || POLL_INTERVAL);\n    attempts++;\n\n    try {\n      const tokenResponse = await fetch(`${baseUrl}/api/cli/auth/token`, {\n        method: \"POST\",\n        headers: { \"Content-Type\": \"application/json\" },\n        body: JSON.stringify({ deviceCode }),\n      });\n\n      if (tokenResponse.ok) {\n        const tokens = (await tokenResponse.json()) as TokenResponse;\n        spin.succeed(\"Logged in successfully!\");\n\n        // Store tokens\n        setAuthTokens(\n          tokens.accessToken,\n          tokens.refreshToken,\n          tokens.expiresIn,\n          tokens.userId,\n          tokens.email,\n        );\n\n        return tokens;\n      }\n\n      const errorData = (await tokenResponse.json().catch(() => ({}))) as {\n        error?: string;\n      };\n\n      if (errorData.error === \"authorization_pending\") {\n        // Still waiting, continue polling\n        continue;\n      }\n\n      if (errorData.error === \"expired_token\") {\n        spin.fail(\"Login request expired. Please try again.\");\n        throw new Error(\"Login request expired\");\n      }\n\n      if (errorData.error === \"access_denied\") {\n        spin.fail(\"Login was denied\");\n        throw new Error(\"Login was denied\");\n      }\n    } catch (error) {\n      if (\n        (error as Error).message.includes(\"expired\") ||\n        (error as Error).message.includes(\"denied\")\n      ) {\n        throw error;\n      }\n      // Network error, continue polling\n    }\n  }\n\n  spin.fail(\"Login timed out. Please try again.\");\n  throw new Error(\"Login timed out\");\n}\n\n/**\n * Login with an API key directly\n */\nexport async function apiKeyLogin(apiKey: string): Promise<void> {\n  const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n\n  // Validate the API key with the server\n  const response = await fetch(`${baseUrl}/api/cli/auth/verify-key`, {\n    method: \"POST\",\n    headers: {\n      \"Content-Type\": \"application/json\",\n      Authorization: `Bearer ${apiKey}`,\n    },\n  });\n\n  if (!response.ok) {\n    const error = (await response.json().catch(() => ({}))) as {\n      message?: string;\n    };\n    throw new Error(error.message || \"Invalid API key\");\n  }\n\n  // Store the API key\n  setApiKey(apiKey);\n}\n\n/**\n * Logout - clear all stored credentials\n */\nexport function logout(): void {\n  clearAuth();\n}\n\n/**\n * Check if currently authenticated\n */\nexport function checkAuth(): boolean {\n  return isAuthenticated();\n}\n\n/**\n * Get current auth info for display\n */\nexport async function getAuthInfo(): Promise<{\n  authenticated: boolean;\n  email?: string;\n  userId?: string;\n  environment: string;\n  keyType?: string;\n}> {\n  const token = getAuthToken();\n  const email = getConfigValue(\"email\");\n  const userId = getConfigValue(\"userId\");\n  const apiKey = getConfigValue(\"apiKey\");\n  const environment = getConfigValue(\"environment\");\n\n  if (!token && !apiKey) {\n    return { authenticated: false, environment };\n  }\n\n  let keyType: string | undefined;\n  if (apiKey) {\n    keyType = apiKey.startsWith(\"sk_test_\") ? \"test\" : \"live\";\n  }\n\n  return {\n    authenticated: true,\n    email,\n    userId,\n    environment,\n    keyType,\n  };\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"]}

package/dist/lib/base-command.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Base Command class for all Sendly CLI commands
+ * Provides common functionality and flags
+ */
+import { Command } from "@oclif/core";
+export declare abstract class BaseCommand extends Command {
+    static baseFlags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    protected init(): Promise<void>;
+    protected catch(err: Error): Promise<void>;
+    protected requireAuth(): void;
+}
+export declare abstract class AuthenticatedCommand extends BaseCommand {
+    protected init(): Promise<void>;
+}

package/dist/lib/base-command.js

@@ -0,0 +1,60 @@
+/**
+ * Base Command class for all Sendly CLI commands
+ * Provides common functionality and flags
+ */
+import { Command, Flags } from "@oclif/core";
+import { setOutputFormat, setQuietMode, error } from "./output.js";
+import { isAuthenticated } from "./config.js";
+import { ApiError, AuthenticationError } from "./api-client.js";
+export class BaseCommand extends Command {
+    static baseFlags = {
+        json: Flags.boolean({
+            description: "Output in JSON format",
+            default: false,
+        }),
+        quiet: Flags.boolean({
+            char: "q",
+            description: "Minimal output",
+            default: false,
+        }),
+    };
+    async init() {
+        await super.init();
+        const { flags } = await this.parse(this.constructor);
+        if (flags.json) {
+            setOutputFormat("json");
+        }
+        if (flags.quiet) {
+            setQuietMode(true);
+        }
+    }
+    async catch(err) {
+        if (err instanceof AuthenticationError) {
+            error("Not authenticated", {
+                hint: "Run 'sendly login' to authenticate",
+            });
+            this.exit(1);
+        }
+        if (err instanceof ApiError) {
+            error(err.message, {
+                code: err.code,
+                ...(err.details || {}),
+            });
+            this.exit(1);
+        }
+        error(err.message);
+        this.exit(1);
+    }
+    requireAuth() {
+        if (!isAuthenticated()) {
+            throw new AuthenticationError();
+        }
+    }
+}
+export class AuthenticatedCommand extends BaseCommand {
+    async init() {
+        await super.init();
+        this.requireAuth();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/config.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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";
+export interface SendlyConfig {
+    apiKey?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    tokenExpiresAt?: number;
+    userId?: string;
+    email?: string;
+    environment: "test" | "live";
+    baseUrl: string;
+    defaultFormat: "human" | "json";
+    colorEnabled: boolean;
+    timeout: number;
+    maxRetries: number;
+}
+/**
+ * Check if running in CI environment
+ */
+export declare function isCI(): boolean;
+/**
+ * Check if color output is disabled
+ */
+export declare function isColorDisabled(): boolean;
+declare const config: Conf<SendlyConfig>;
+/**
+ * Get effective config value with environment variable override
+ * Priority: env var > config file > default
+ */
+export declare function getEffectiveValue<K extends keyof SendlyConfig>(key: K): SendlyConfig[K];
+export declare function getConfig(): SendlyConfig;
+export declare function setConfig<K extends keyof SendlyConfig>(key: K, value: SendlyConfig[K]): void;
+export declare function getConfigValue<K extends keyof SendlyConfig>(key: K): SendlyConfig[K];
+export declare function clearConfig(): void;
+export declare function clearAuth(): void;
+export declare function isAuthenticated(): boolean;
+export declare function getAuthToken(): string | undefined;
+export declare function setApiKey(apiKey: string): void;
+export declare function setAuthTokens(accessToken: string, refreshToken: string, expiresIn: number, userId: string, email: string): void;
+export declare function getConfigPath(): string;
+export declare function getConfigDir(): string;
+export { config };