learn-secrets-sdk 1.4.0 → 1.5.0

package/dist/cli/utils/env-parser.d.ts

@@ -1,19 +0,0 @@
-export interface EnvVariable {
-    key: string;
-    value: string;
-}
-/**
- * Parse a .env file into key-value pairs
- * Supports:
- * - KEY=value
- * - KEY="value"
- * - KEY='value'
- * - # comments
- * - Empty lines
- */
-export declare function parseEnvFile(filePath: string): EnvVariable[];
-/**
- * Load environment variables from a .env file
- * Returns a Map for easy lookup
- */
-export declare function loadEnvFile(filePath: string): Map<string, string>;

package/dist/cli/utils/env-parser.js

@@ -1,47 +0,0 @@
-import { readFileSync, existsSync } from 'fs';
-import { resolve } from 'path';
-/**
- * Parse a .env file into key-value pairs
- * Supports:
- * - KEY=value
- * - KEY="value"
- * - KEY='value'
- * - # comments
- * - Empty lines
- */
-export function parseEnvFile(filePath) {
-    const resolvedPath = resolve(filePath);
-    if (!existsSync(resolvedPath)) {
-        throw new Error(`File not found: ${resolvedPath}`);
-    }
-    const content = readFileSync(resolvedPath, 'utf-8');
-    const lines = content.split('\n');
-    const variables = [];
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Skip empty lines and comments
-        if (!trimmed || trimmed.startsWith('#')) {
-            continue;
-        }
-        // Match KEY=value, KEY="value", or KEY='value'
-        const match = trimmed.match(/^([A-Z0-9_]+)\s*=\s*(['"]?)(.+?)\2$/i);
-        if (match) {
-            const key = match[1];
-            const value = match[3];
-            variables.push({ key, value });
-        }
-    }
-    return variables;
-}
-/**
- * Load environment variables from a .env file
- * Returns a Map for easy lookup
- */
-export function loadEnvFile(filePath) {
-    const variables = parseEnvFile(filePath);
-    const map = new Map();
-    for (const { key, value } of variables) {
-        map.set(key, value);
-    }
-    return map;
-}

package/dist/cli/utils/key-detector.d.ts

@@ -1,33 +0,0 @@
-import type { SecretConfig } from '../../types.js';
-import type { EnvVariable } from './env-parser.js';
-interface ProviderPattern {
-    pattern: RegExp;
-    provider: string;
-    baseUrl?: string;
-    authHeader?: string;
-    authPrefix?: string;
-}
-/**
- * Detect if an environment variable is likely an API key
- */
-export declare function isLikelyApiKey(key: string, value: string): boolean;
-/**
- * Detect provider from environment variable name
- */
-export declare function detectProvider(key: string): ProviderPattern | null;
-/**
- * Convert environment variable to secret name
- * OPENAI_API_KEY -> openai
- * MY_API_KEY -> my-api
- */
-export declare function envKeyToSecretName(key: string): string;
-/**
- * Detect API keys from environment variables
- * Returns SecretConfig array ready for import
- */
-export declare function detectApiKeys(envVars: EnvVariable[]): SecretConfig[];
-/**
- * Display detected secrets summary (for user confirmation)
- */
-export declare function summarizeDetectedSecrets(secrets: SecretConfig[]): string;
-export {};

package/dist/cli/utils/key-detector.js

@@ -1,153 +0,0 @@
-/**
- * Common API key patterns and their providers
- */
-const PROVIDER_PATTERNS = [
-    {
-        pattern: /^OPENAI_API_KEY$/i,
-        provider: 'openai',
-        baseUrl: 'https://api.openai.com',
-        authHeader: 'Authorization',
-        authPrefix: 'Bearer '
-    },
-    {
-        pattern: /^ANTHROPIC_API_KEY$/i,
-        provider: 'anthropic',
-        baseUrl: 'https://api.anthropic.com',
-        authHeader: 'x-api-key',
-        authPrefix: ''
-    },
-    {
-        pattern: /^STRIPE_(SECRET_)?KEY$/i,
-        provider: 'stripe',
-        baseUrl: 'https://api.stripe.com',
-        authHeader: 'Authorization',
-        authPrefix: 'Bearer '
-    },
-    {
-        pattern: /^GITHUB_TOKEN$/i,
-        provider: 'github',
-        baseUrl: 'https://api.github.com',
-        authHeader: 'Authorization',
-        authPrefix: 'Bearer '
-    },
-    {
-        pattern: /^GOOGLE_API_KEY$/i,
-        provider: 'google',
-        baseUrl: 'https://www.googleapis.com',
-        authHeader: 'Authorization',
-        authPrefix: 'Bearer '
-    }
-];
-/**
- * Detect if an environment variable is likely an API key
- */
-export function isLikelyApiKey(key, value) {
-    // Check common patterns
-    const keyPatterns = [
-        /_API_KEY$/i,
-        /_SECRET$/i,
-        /_TOKEN$/i,
-        /^API_KEY_/i,
-        /^SECRET_/i,
-        /^TOKEN_/i
-    ];
-    for (const pattern of keyPatterns) {
-        if (pattern.test(key)) {
-            return true;
-        }
-    }
-    // Check value patterns (looks like a key/token)
-    const valuePatterns = [
-        /^sk-[a-zA-Z0-9_-]+$/, // OpenAI, Stripe
-        /^sk-ant-[a-zA-Z0-9_-]+$/, // Anthropic
-        /^ghp_[a-zA-Z0-9]+$/, // GitHub
-        /^ya29\.[a-zA-Z0-9_-]+$/, // Google OAuth
-        /^[a-f0-9]{32}$/, // 32-char hex
-        /^[a-f0-9]{40}$/, // 40-char hex (like GitHub)
-        /^[a-zA-Z0-9_-]{40,}$/ // Long random string
-    ];
-    for (const pattern of valuePatterns) {
-        if (pattern.test(value)) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Detect provider from environment variable name
- */
-export function detectProvider(key) {
-    for (const pattern of PROVIDER_PATTERNS) {
-        if (pattern.pattern.test(key)) {
-            return pattern;
-        }
-    }
-    return null;
-}
-/**
- * Convert environment variable to secret name
- * OPENAI_API_KEY -> openai
- * MY_API_KEY -> my-api
- */
-export function envKeyToSecretName(key) {
-    return key
-        .toLowerCase()
-        .replace(/_api_key$/i, '')
-        .replace(/_secret$/i, '')
-        .replace(/_token$/i, '')
-        .replace(/_key$/i, '')
-        .replace(/_/g, '-');
-}
-/**
- * Detect API keys from environment variables
- * Returns SecretConfig array ready for import
- */
-export function detectApiKeys(envVars) {
-    const secrets = [];
-    for (const { key, value } of envVars) {
-        // Skip if doesn't look like an API key
-        if (!isLikelyApiKey(key, value)) {
-            continue;
-        }
-        // Detect provider
-        const providerInfo = detectProvider(key);
-        const secretName = envKeyToSecretName(key);
-        if (providerInfo) {
-            // Known provider
-            secrets.push({
-                name: secretName,
-                provider: providerInfo.provider,
-                api_key: value,
-                base_url: providerInfo.baseUrl,
-                auth_header: providerInfo.authHeader,
-                auth_prefix: providerInfo.authPrefix
-            });
-        }
-        else {
-            // Custom/unknown provider
-            secrets.push({
-                name: secretName,
-                provider: 'custom',
-                api_key: value,
-                base_url: '', // User must configure
-                auth_header: 'Authorization',
-                auth_prefix: 'Bearer '
-            });
-        }
-    }
-    return secrets;
-}
-/**
- * Display detected secrets summary (for user confirmation)
- */
-export function summarizeDetectedSecrets(secrets) {
-    if (secrets.length === 0) {
-        return 'No API keys detected in .env file';
-    }
-    const lines = ['Detected API keys:'];
-    for (const secret of secrets) {
-        const masked = secret.api_key.substring(0, 8) + '...';
-        lines.push(`  - ${secret.name} (${secret.provider}): ${masked}`);
-    }
-    return lines.join('\n');
-}

package/dist/client.d.ts

@@ -1,65 +0,0 @@
-import type { SecretsSDKOptions, ProxyRequest, RateLimitInfo } from './types.js';
-export declare class SecretsSDK {
-    private appId;
-    private token;
-    private baseUrl;
-    private timeout;
-    private retryOn429;
-    private rateLimitInfo;
-    private zeroConfigMode;
-    /**
-     * Create a new SecretsSDK instance
-     *
-     * Zero-config mode (recommended for static sites):
-     *   const sdk = new SecretsSDK();
-     *   // Origin header is used for authentication
-     *
-     * Token mode (for backward compatibility):
-     *   const sdk = new SecretsSDK({ appId: '...', token: 'sk_live_...' });
-     */
-    constructor(options?: SecretsSDKOptions);
-    /**
-     * Get current rate limit information
-     */
-    getUsage(): RateLimitInfo | null;
-    /**
-     * Parse rate limit headers from response
-     */
-    private parseRateLimitHeaders;
-    /**
-     * Sleep utility for retry backoff
-     */
-    private sleep;
-    /**
-     * Make fetch request with timeout
-     */
-    private fetchWithTimeout;
-    /**
-     * Call an external API securely through the proxy
-     * @param keyName - Name of the API key to use
-     * @param endpoint - API endpoint path (e.g., '/v1/chat/completions')
-     * @param options - Request options (method, body, headers)
-     * @returns Promise with the API response
-     */
-    call<T = any>(keyName: string, endpoint: string, options?: Omit<ProxyRequest, 'keyName' | 'endpoint'>): Promise<T>;
-    /**
-     * Make a GET request
-     */
-    get<T = any>(keyName: string, endpoint: string, headers?: Record<string, string>): Promise<T>;
-    /**
-     * Make a POST request
-     */
-    post<T = any>(keyName: string, endpoint: string, body: any, headers?: Record<string, string>): Promise<T>;
-    /**
-     * Make a PUT request
-     */
-    put<T = any>(keyName: string, endpoint: string, body: any, headers?: Record<string, string>): Promise<T>;
-    /**
-     * Make a DELETE request
-     */
-    delete<T = any>(keyName: string, endpoint: string, headers?: Record<string, string>): Promise<T>;
-    /**
-     * Make a PATCH request
-     */
-    patch<T = any>(keyName: string, endpoint: string, body: any, headers?: Record<string, string>): Promise<T>;
-}

package/dist/client.js

@@ -1,172 +0,0 @@
-import { SecretsSDKError, OriginMismatchError, RateLimitError, InvalidTokenError } from './types.js';
-export class SecretsSDK {
-    /**
-     * Create a new SecretsSDK instance
-     *
-     * Zero-config mode (recommended for static sites):
-     *   const sdk = new SecretsSDK();
-     *   // Origin header is used for authentication
-     *
-     * Token mode (for backward compatibility):
-     *   const sdk = new SecretsSDK({ appId: '...', token: 'sk_live_...' });
-     */
-    constructor(options = {}) {
-        this.rateLimitInfo = null;
-        this.appId = options.appId || null;
-        this.token = options.token || options.sessionToken || null;
-        this.baseUrl = options.baseUrl || 'https://ctklearn.carsontkempf.workers.dev';
-        this.timeout = options.timeout || 30000;
-        this.retryOn429 = options.retryOn429 !== undefined ? options.retryOn429 : true;
-        // Zero-config mode: no appId or token required
-        // Authentication is based on Origin header
-        this.zeroConfigMode = !this.appId && !this.token;
-    }
-    /**
-     * Get current rate limit information
-     */
-    getUsage() {
-        return this.rateLimitInfo;
-    }
-    /**
-     * Parse rate limit headers from response
-     */
-    parseRateLimitHeaders(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),
-                remaining: parseInt(remaining),
-                reset: parseInt(reset)
-            };
-        }
-    }
-    /**
-     * Sleep utility for retry backoff
-     */
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    /**
-     * Make fetch request with timeout
-     */
-    async fetchWithTimeout(url, options, timeout) {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const response = await fetch(url, {
-                ...options,
-                signal: controller.signal
-            });
-            return response;
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Call an external API securely through the proxy
-     * @param keyName - Name of the API key to use
-     * @param endpoint - API endpoint path (e.g., '/v1/chat/completions')
-     * @param options - Request options (method, body, headers)
-     * @returns Promise with the API response
-     */
-    async call(keyName, endpoint, options = {}) {
-        let retries = 0;
-        const maxRetries = this.retryOn429 ? 3 : 0;
-        while (true) {
-            try {
-                // Build URL based on mode
-                const proxyUrl = this.zeroConfigMode
-                    ? `${this.baseUrl}/api/sdk/proxy`
-                    : `${this.baseUrl}/api/sdk/${this.appId}/proxy`;
-                // Build headers based on mode
-                const requestHeaders = {
-                    'Content-Type': 'application/json'
-                };
-                if (!this.zeroConfigMode && this.token) {
-                    requestHeaders['Authorization'] = `Bearer ${this.token}`;
-                }
-                const response = await this.fetchWithTimeout(proxyUrl, {
-                    method: 'POST',
-                    headers: requestHeaders,
-                    body: JSON.stringify({
-                        keyName,
-                        endpoint,
-                        method: options.method || 'GET',
-                        body: options.body,
-                        headers: options.headers
-                    })
-                }, this.timeout);
-                this.parseRateLimitHeaders(response.headers);
-                const result = await response.json();
-                if (!response.ok) {
-                    const errorMessage = result.data?.message ||
-                        result?.message ||
-                        `Request failed with status ${response.status}`;
-                    if (response.status === 403 && errorMessage.includes('Origin')) {
-                        throw new OriginMismatchError(errorMessage);
-                    }
-                    if (response.status === 401) {
-                        throw new InvalidTokenError(errorMessage);
-                    }
-                    if (response.status === 429) {
-                        const retryAfter = this.rateLimitInfo
-                            ? this.rateLimitInfo.reset - Math.floor(Date.now() / 1000)
-                            : 60;
-                        const error = new RateLimitError(errorMessage, retryAfter, this.rateLimitInfo?.remaining || 0, this.rateLimitInfo?.limit || 100);
-                        if (this.retryOn429 && retries < maxRetries) {
-                            retries++;
-                            const backoffMs = Math.min(1000 * Math.pow(2, retries - 1), 8000);
-                            await this.sleep(backoffMs);
-                            continue;
-                        }
-                        throw error;
-                    }
-                    throw new SecretsSDKError(errorMessage, response.status, result);
-                }
-                return result.data;
-            }
-            catch (err) {
-                if (err instanceof SecretsSDKError) {
-                    throw err;
-                }
-                if (err instanceof Error && err.name === 'AbortError') {
-                    throw new SecretsSDKError('Request timeout', 408);
-                }
-                throw new SecretsSDKError(err instanceof Error ? err.message : 'Unknown error occurred', 500);
-            }
-        }
-    }
-    /**
-     * Make a GET request
-     */
-    async get(keyName, endpoint, headers) {
-        return this.call(keyName, endpoint, { method: 'GET', headers });
-    }
-    /**
-     * Make a POST request
-     */
-    async post(keyName, endpoint, body, headers) {
-        return this.call(keyName, endpoint, { method: 'POST', body, headers });
-    }
-    /**
-     * Make a PUT request
-     */
-    async put(keyName, endpoint, body, headers) {
-        return this.call(keyName, endpoint, { method: 'PUT', body, headers });
-    }
-    /**
-     * Make a DELETE request
-     */
-    async delete(keyName, endpoint, headers) {
-        return this.call(keyName, endpoint, { method: 'DELETE', headers });
-    }
-    /**
-     * Make a PATCH request
-     */
-    async patch(keyName, endpoint, body, headers) {
-        return this.call(keyName, endpoint, { method: 'PATCH', body, headers });
-    }
-}

package/dist/credentials.d.ts

@@ -1,24 +0,0 @@
-import type { CLICredentials } from './types.js';
-/**
- * Get the path to the credentials file
- * Defaults to ~/.learn/credentials.json
- */
-export declare function getCredentialsPath(): string;
-/**
- * Read credentials from file
- * Returns null if file doesn't exist or is invalid
- */
-export declare function readCredentials(): CLICredentials | null;
-/**
- * Write credentials to file
- * Creates ~/.learn directory if it doesn't exist
- */
-export declare function writeCredentials(creds: CLICredentials): void;
-/**
- * Delete credentials file
- */
-export declare function deleteCredentials(): void;
-/**
- * Check if credentials exist and are not expired
- */
-export declare function hasValidCredentials(): boolean;

package/dist/credentials.js

@@ -1,86 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-/**
- * Get the path to the credentials file
- * Defaults to ~/.learn/credentials.json
- */
-export function getCredentialsPath() {
-    const homeDir = os.homedir();
-    const learnDir = path.join(homeDir, '.learn');
-    return path.join(learnDir, 'credentials.json');
-}
-/**
- * Ensure the ~/.learn directory exists
- */
-function ensureLearnDir() {
-    const homeDir = os.homedir();
-    const learnDir = path.join(homeDir, '.learn');
-    if (!fs.existsSync(learnDir)) {
-        fs.mkdirSync(learnDir, { recursive: true, mode: 0o700 }); // Owner-only permissions
-    }
-}
-/**
- * Read credentials from file
- * Returns null if file doesn't exist or is invalid
- */
-export function readCredentials() {
-    try {
-        const credPath = getCredentialsPath();
-        if (!fs.existsSync(credPath)) {
-            return null;
-        }
-        const data = fs.readFileSync(credPath, 'utf-8');
-        const creds = JSON.parse(data);
-        // Validate required fields
-        if (!creds.access_token ||
-            !creds.refresh_token ||
-            !creds.expires_at ||
-            !creds.user_id) {
-            return null;
-        }
-        return creds;
-    }
-    catch (err) {
-        // Invalid JSON or read error
-        return null;
-    }
-}
-/**
- * Write credentials to file
- * Creates ~/.learn directory if it doesn't exist
- */
-export function writeCredentials(creds) {
-    ensureLearnDir();
-    const credPath = getCredentialsPath();
-    const data = JSON.stringify(creds, null, 2);
-    // Write with owner-only permissions
-    fs.writeFileSync(credPath, data, { mode: 0o600 });
-}
-/**
- * Delete credentials file
- */
-export function deleteCredentials() {
-    try {
-        const credPath = getCredentialsPath();
-        if (fs.existsSync(credPath)) {
-            fs.unlinkSync(credPath);
-        }
-    }
-    catch (err) {
-        // Ignore errors (file might not exist)
-    }
-}
-/**
- * Check if credentials exist and are not expired
- */
-export function hasValidCredentials() {
-    const creds = readCredentials();
-    if (!creds) {
-        return false;
-    }
-    // Check if expired
-    const expiresAt = new Date(creds.expires_at);
-    const now = new Date();
-    return expiresAt > now;
-}

package/dist/env-resolver.d.ts

@@ -1,23 +0,0 @@
-import type { SecretConfig } from './types.js';
-/**
- * Resolve environment variable references in a string
- * Supports ${VAR} and $VAR syntax
- */
-export declare function resolveEnvString(value: string): string;
-/**
- * Resolve environment variables in a single secret config
- */
-export declare function resolveEnvInSecret(secret: SecretConfig): SecretConfig;
-/**
- * Resolve environment variables in an array of secrets
- */
-export declare function resolveEnvInSecrets(secrets: SecretConfig[]): SecretConfig[];
-/**
- * Load and parse a secrets config file
- * Resolves environment variables in the config
- */
-export declare function loadSecretsConfig(configPath: string): {
-    version: string;
-    project: string;
-    secrets: SecretConfig[];
-};