commons-proxy 2.0.0

package/src/index.js

@@ -0,0 +1,148 @@
+/**
+ * CommonsProxy
+ * Entry point - starts the proxy server
+ * Universal proxy for Claude Code CLI with multi-provider support
+ */
+
+import app, { accountManager } from './server.js';
+import { DEFAULT_PORT } from './constants.js';
+import { logger } from './utils/logger.js';
+import { config } from './config.js';
+import { getStrategyLabel, STRATEGY_NAMES, DEFAULT_STRATEGY } from './account-manager/strategies/index.js';
+import path from 'path';
+import os from 'os';
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const isDebug = args.includes('--debug') || process.env.DEBUG === 'true';
+const isFallbackEnabled = args.includes('--fallback') || process.env.FALLBACK === 'true';
+
+// Parse --strategy flag (format: --strategy=sticky or --strategy sticky)
+let strategyOverride = null;
+for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith('--strategy=')) {
+        strategyOverride = args[i].split('=')[1];
+    } else if (args[i] === '--strategy' && args[i + 1]) {
+        strategyOverride = args[i + 1];
+    }
+}
+// Validate strategy
+if (strategyOverride && !STRATEGY_NAMES.includes(strategyOverride.toLowerCase())) {
+    logger.warn(`[Startup] Invalid strategy "${strategyOverride}". Valid options: ${STRATEGY_NAMES.join(', ')}. Using default.`);
+    strategyOverride = null;
+}
+
+// Initialize logger
+logger.setDebug(isDebug);
+
+if (isDebug) {
+    logger.debug('Debug mode enabled');
+}
+
+if (isFallbackEnabled) {
+    logger.info('Model fallback mode enabled');
+}
+
+// Export fallback flag for server to use
+export const FALLBACK_ENABLED = isFallbackEnabled;
+
+const PORT = process.env.PORT || DEFAULT_PORT;
+
+// Home directory for account storage
+const HOME_DIR = os.homedir();
+const CONFIG_DIR = path.join(HOME_DIR, '.config/commons-proxy');
+
+const server = app.listen(PORT, () => {
+    // Clear console for a clean start
+    console.clear();
+
+    const border = '║';
+    // align for 2-space indent (60 chars), align4 for 4-space indent (58 chars)
+    const align = (text) => text + ' '.repeat(Math.max(0, 60 - text.length));
+    const align4 = (text) => text + ' '.repeat(Math.max(0, 58 - text.length));
+    
+    // Build Control section dynamically
+    const strategyOptions = `(${STRATEGY_NAMES.join('/')})`;
+    const strategyLine2 = '                       ' + strategyOptions;
+    let controlSection = '║  Control:                                                    ║\n';
+    controlSection += '║    --strategy=<s>     Set account selection strategy         ║\n';
+    controlSection += `${border}  ${align(strategyLine2)}${border}\n`;
+    if (!isDebug) {
+        controlSection += '║    --debug            Enable debug logging                   ║\n';
+    }
+    if (!isFallbackEnabled) {
+        controlSection += '║    --fallback         Enable model fallback on quota exhaust ║\n';
+    }
+    controlSection += '║    Ctrl+C             Stop server                            ║';
+
+    // Get the strategy label (accountManager will be initialized by now)
+    const strategyLabel = accountManager.getStrategyLabel();
+
+    // Build status section - always show strategy, plus any active modes
+    let statusSection = '║                                                              ║\n';
+    statusSection += '║  Active Modes:                                               ║\n';
+    statusSection += `${border}    ${align4(`✓ Strategy: ${strategyLabel}`)}${border}\n`;
+    if (isDebug) {
+        statusSection += '║    ✓ Debug mode enabled                                      ║\n';
+    }
+    if (isFallbackEnabled) {
+        statusSection += '║    ✓ Model fallback enabled                                  ║\n';
+    }
+
+    logger.log(`
+╔══════════════════════════════════════════════════════════════╗
+║              CommonsProxy Server                             ║
+╠══════════════════════════════════════════════════════════════╣
+║                                                              ║
+${border}  ${align(`Server and WebUI running at: http://localhost:${PORT}`)}${border}
+${statusSection}║                                                              ║
+${controlSection}
+║                                                              ║
+║  Endpoints:                                                  ║
+║    POST /v1/messages         - Anthropic Messages API        ║
+║    GET  /v1/models           - List available models         ║
+║    GET  /health              - Health check                  ║
+║    GET  /account-limits      - Account status & quotas       ║
+║    POST /refresh-token       - Force token refresh           ║
+║                                                              ║
+${border}  ${align(`Configuration:`)}${border}
+${border}    ${align4(`Storage: ${CONFIG_DIR}`)}${border}
+║                                                              ║
+║  Usage with Claude Code:                                     ║
+${border}    ${align4(`export ANTHROPIC_BASE_URL=http://localhost:${PORT}`)}${border}
+${border}    ${align4(`export ANTHROPIC_API_KEY=${config.apiKey || 'dummy'}`)}${border}
+║    claude                                                    ║
+║                                                              ║
+║  Add Google accounts:                                        ║
+║    npm run accounts                                          ║
+║                                                              ║
+║  Prerequisites (if no accounts configured):                  ║
+║    - Windsurf/Cursor IDE must be running                     ║
+║    - Have a chat panel open in the IDE                       ║
+║                                                              ║
+╚══════════════════════════════════════════════════════════════╝
+  `);
+    
+    logger.success(`Server started successfully on port ${PORT}`);
+    if (isDebug) {
+        logger.warn('Running in DEBUG mode - verbose logs enabled');
+    }
+});
+
+// Graceful shutdown
+const shutdown = () => {
+    logger.info('Shutting down server...');
+    server.close(() => {
+        logger.success('Server stopped');
+        process.exit(0);
+    });
+
+    // Force close if it takes too long
+    setTimeout(() => {
+        logger.error('Could not close connections in time, forcefully shutting down');
+        process.exit(1);
+    }, 10000);
+};
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);

package/src/modules/usage-stats.js

@@ -0,0 +1,205 @@
+import fs from 'fs';
+import path from 'path';
+
+import { USAGE_HISTORY_PATH } from '../constants.js';
+
+// Persistence path
+const HISTORY_FILE = USAGE_HISTORY_PATH;
+const DATA_DIR = path.dirname(HISTORY_FILE);
+const OLD_DATA_DIR = path.join(process.cwd(), 'data');
+const OLD_HISTORY_FILE = path.join(OLD_DATA_DIR, 'usage-history.json');
+
+// In-memory storage
+// Structure: { "YYYY-MM-DDTHH:00:00.000Z": { "claude": { "model-name": count, "_subtotal": count }, "_total": count } }
+let history = {};
+let isDirty = false;
+
+/**
+ * Extract model family from model ID
+ * @param {string} modelId - The model identifier (e.g., "claude-opus-4-5-thinking")
+ * @returns {string} The family name (claude, gemini, or other)
+ */
+function getFamily(modelId) {
+    const lower = (modelId || '').toLowerCase();
+    if (lower.includes('claude')) return 'claude';
+    if (lower.includes('gemini')) return 'gemini';
+    return 'other';
+}
+
+/**
+ * Extract short model name (without family prefix)
+ * @param {string} modelId - The model identifier
+ * @param {string} family - The model family
+ * @returns {string} Short model name
+ */
+function getShortName(modelId, family) {
+    if (family === 'other') return modelId;
+    // Remove family prefix (e.g., "claude-opus-4-5" -> "opus-4-5")
+    return modelId.replace(new RegExp(`^${family}-`, 'i'), '');
+}
+
+/**
+ * Ensure data directory exists and load history.
+ * Includes migration from legacy local data directory.
+ */
+function load() {
+    try {
+        // Migration logic: if old file exists and new one doesn't
+        if (fs.existsSync(OLD_HISTORY_FILE) && !fs.existsSync(HISTORY_FILE)) {
+            console.log('[UsageStats] Migrating legacy usage data...');
+            if (!fs.existsSync(DATA_DIR)) {
+                fs.mkdirSync(DATA_DIR, { recursive: true });
+            }
+            fs.copyFileSync(OLD_HISTORY_FILE, HISTORY_FILE);
+            // We keep the old file for safety initially, but could delete it
+            console.log(`[UsageStats] Migration complete: ${OLD_HISTORY_FILE} -> ${HISTORY_FILE}`);
+        }
+
+        if (!fs.existsSync(DATA_DIR)) {
+            fs.mkdirSync(DATA_DIR, { recursive: true });
+        }
+        if (fs.existsSync(HISTORY_FILE)) {
+            const data = fs.readFileSync(HISTORY_FILE, 'utf8');
+            history = JSON.parse(data);
+        }
+    } catch (err) {
+        console.error('[UsageStats] Failed to load history:', err);
+        history = {};
+    }
+}
+
+/**
+ * Save history to disk
+ */
+function save() {
+    if (!isDirty) return;
+    try {
+        fs.writeFileSync(HISTORY_FILE, JSON.stringify(history, null, 2));
+        isDirty = false;
+    } catch (err) {
+        console.error('[UsageStats] Failed to save history:', err);
+    }
+}
+
+/**
+ * Prune old data (keep last 30 days)
+ */
+function prune() {
+    const now = new Date();
+    const cutoff = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+
+    let pruned = false;
+    Object.keys(history).forEach(key => {
+        if (new Date(key) < cutoff) {
+            delete history[key];
+            pruned = true;
+        }
+    });
+
+    if (pruned) isDirty = true;
+}
+
+/**
+ * Track a request by model ID using hierarchical structure
+ * @param {string} modelId - The specific model identifier
+ */
+function track(modelId) {
+    const now = new Date();
+    // Round down to nearest hour
+    now.setMinutes(0, 0, 0);
+    const key = now.toISOString();
+
+    if (!history[key]) {
+        history[key] = { _total: 0 };
+    }
+
+    const hourData = history[key];
+    const family = getFamily(modelId);
+    const shortName = getShortName(modelId, family);
+
+    // Initialize family object if needed
+    if (!hourData[family]) {
+        hourData[family] = { _subtotal: 0 };
+    }
+
+    // Increment model-specific count
+    hourData[family][shortName] = (hourData[family][shortName] || 0) + 1;
+
+    // Increment family subtotal
+    hourData[family]._subtotal = (hourData[family]._subtotal || 0) + 1;
+
+    // Increment global total
+    hourData._total = (hourData._total || 0) + 1;
+
+    isDirty = true;
+}
+
+/**
+ * Setup Express Middleware
+ * @param {import('express').Application} app
+ */
+function setupMiddleware(app) {
+    load();
+
+    // Auto-save every minute
+    setInterval(() => {
+        save();
+        prune();
+    }, 60 * 1000);
+
+    // Save on exit
+    process.on('SIGINT', () => { save(); process.exit(); });
+    process.on('SIGTERM', () => { save(); process.exit(); });
+
+    // Request interceptor
+    // Track both Anthropic (/v1/messages) and OpenAI compatible (/v1/chat/completions) endpoints
+    const TRACKED_PATHS = ['/v1/messages', '/v1/chat/completions'];
+
+    app.use((req, res, next) => {
+        if (req.method === 'POST' && TRACKED_PATHS.includes(req.path)) {
+            const model = req.body?.model;
+            if (model) {
+                track(model);
+            }
+        }
+        next();
+    });
+}
+
+/**
+ * Setup API Routes
+ * @param {import('express').Application} app
+ */
+function setupRoutes(app) {
+    app.get('/api/stats/history', (req, res) => {
+        // Sort keys to ensure chronological order
+        const sortedKeys = Object.keys(history).sort();
+        const sortedData = {};
+        sortedKeys.forEach(key => {
+            sortedData[key] = history[key];
+        });
+        res.json(sortedData);
+    });
+}
+
+/**
+ * Get usage history data
+ * @returns {object} History data sorted by timestamp
+ */
+function getHistory() {
+    const sortedKeys = Object.keys(history).sort();
+    const sortedData = {};
+    sortedKeys.forEach(key => {
+        sortedData[key] = history[key];
+    });
+    return sortedData;
+}
+
+export default {
+    setupMiddleware,
+    setupRoutes,
+    track,
+    getFamily,
+    getShortName,
+    getHistory
+};

package/src/providers/anthropic-provider.js

@@ -0,0 +1,258 @@
+/**
+ * Anthropic API Provider
+ *
+ * Implements authentication via Anthropic API keys.
+ * Supports Claude models via direct Anthropic API.
+ */
+
+import BaseProvider from './base-provider.js';
+
+export class AnthropicProvider extends BaseProvider {
+    constructor(config = {}) {
+        super('anthropic', 'Anthropic', {
+            apiEndpoint: config.apiEndpoint || 'https://api.anthropic.com',
+            apiVersion: config.apiVersion || '2023-06-01',
+            ...config
+        });
+    }
+
+    /**
+     * Validate Anthropic API key
+     *
+     * @param {Object} account - Account with apiKey
+     * @returns {Promise<{valid: boolean, error?: string, email?: string}>}
+     */
+    async validateCredentials(account) {
+        if (!account.apiKey) {
+            return { valid: false, error: 'Missing API key' };
+        }
+
+        try {
+            // Test API key by fetching model list
+            const endpoint = account.customApiEndpoint || this.config.apiEndpoint;
+            const response = await fetch(`${endpoint}/v1/models`, {
+                method: 'GET',
+                headers: {
+                    'x-api-key': account.apiKey,
+                    'anthropic-version': this.config.apiVersion
+                }
+            });
+
+            if (!response.ok) {
+                const error = await response.text();
+                return { valid: false, error: `API key validation failed: ${error}` };
+            }
+
+            // Anthropic doesn't provide email in API, use a placeholder
+            const email = account.email || `anthropic-${account.apiKey.slice(0, 8)}`;
+
+            return { valid: true, email };
+        } catch (error) {
+            this.error('Credential validation failed', error);
+            return { valid: false, error: error.message };
+        }
+    }
+
+    /**
+     * Get API key (for Anthropic, API key IS the access token)
+     *
+     * @param {Object} account - Account with apiKey
+     * @returns {Promise<string>} API key
+     */
+    async getAccessToken(account) {
+        if (!account.apiKey) {
+            throw new Error('Account missing API key');
+        }
+        return account.apiKey;
+    }
+
+    /**
+     * Fetch usage/quota information from Anthropic API
+     * Note: Anthropic doesn't expose quota via API, so we track usage client-side
+     *
+     * @param {Object} account - Account object
+     * @param {string} token - API key
+     * @returns {Promise<Object>} Quota data (estimated based on usage tracking)
+     */
+    async getQuotas(account, token) {
+        try {
+            const endpoint = account.customApiEndpoint || this.config.apiEndpoint;
+
+            // Anthropic doesn't have a direct quota API yet
+            // We'll attempt to fetch models to check if key is active
+            const response = await fetch(`${endpoint}/v1/models`, {
+                method: 'GET',
+                headers: {
+                    'x-api-key': token,
+                    'anthropic-version': this.config.apiVersion
+                }
+            });
+
+            if (!response.ok) {
+                throw new Error(`Failed to fetch models: ${response.status}`);
+            }
+
+            const data = await response.json();
+            const models = {};
+
+            // Create default quota entries for available models
+            if (data.data && Array.isArray(data.data)) {
+                data.data.forEach(model => {
+                    models[model.id] = {
+                        remainingFraction: 1.0, // Default: full quota (no API to check actual)
+                        resetTime: null // Unknown
+                    };
+                });
+            } else {
+                // Fallback: Common Claude models
+                const commonModels = [
+                    'claude-3-opus-20240229',
+                    'claude-3-sonnet-20240229',
+                    'claude-3-haiku-20240307',
+                    'claude-opus-4-5-thinking',
+                    'claude-sonnet-4-5-thinking'
+                ];
+                commonModels.forEach(modelId => {
+                    models[modelId] = {
+                        remainingFraction: 1.0,
+                        resetTime: null
+                    };
+                });
+            }
+
+            return { models };
+        } catch (error) {
+            this.error('Failed to fetch quotas', error);
+            // Return default quota on error
+            return {
+                models: {
+                    'claude-opus-4-5-thinking': { remainingFraction: 1.0, resetTime: null },
+                    'claude-sonnet-4-5-thinking': { remainingFraction: 1.0, resetTime: null }
+                }
+            };
+        }
+    }
+
+    /**
+     * Get subscription tier (Anthropic uses usage-based pricing)
+     *
+     * @param {Object} account - Account object
+     * @param {string} token - API key
+     * @returns {Promise<{tier: string, projectId: null}>}
+     */
+    async getSubscriptionTier(account, token) {
+        // Anthropic uses usage-based pricing, no fixed tiers
+        // We can check the organization if the API supports it in the future
+        return { tier: 'usage-based', projectId: null };
+    }
+
+    /**
+     * Get available Claude models
+     *
+     * @param {Object} account - Account object
+     * @param {string} token - API key
+     * @returns {Promise<Array>} List of available models
+     */
+    async getAvailableModels(account, token) {
+        try {
+            const endpoint = account.customApiEndpoint || this.config.apiEndpoint;
+            const response = await fetch(`${endpoint}/v1/models`, {
+                method: 'GET',
+                headers: {
+                    'x-api-key': token,
+                    'anthropic-version': this.config.apiVersion
+                }
+            });
+
+            if (!response.ok) {
+                throw new Error(`Failed to fetch models: ${response.status}`);
+            }
+
+            const data = await response.json();
+            if (data.data && Array.isArray(data.data)) {
+                return data.data.map(model => ({
+                    id: model.id,
+                    name: model.display_name || model.id,
+                    family: 'claude'
+                }));
+            }
+
+            return [];
+        } catch (error) {
+            this.error('Failed to fetch available models', error);
+            return [];
+        }
+    }
+
+    /**
+     * Parse Anthropic rate limit headers
+     *
+     * @param {Response} response - Fetch response
+     * @param {Object} errorData - Error data from response body
+     * @returns {Object|null} Rate limit info
+     */
+    parseRateLimitInfo(response, errorData = null) {
+        // Anthropic uses these headers:
+        // - anthropic-ratelimit-requests-limit
+        // - anthropic-ratelimit-requests-remaining
+        // - anthropic-ratelimit-requests-reset
+        // - anthropic-ratelimit-tokens-limit
+        // - anthropic-ratelimit-tokens-remaining
+        // - anthropic-ratelimit-tokens-reset
+        // - retry-after
+
+        const retryAfter = response.headers.get('retry-after');
+        const requestsReset = response.headers.get('anthropic-ratelimit-requests-reset');
+        const tokensReset = response.headers.get('anthropic-ratelimit-tokens-reset');
+
+        if (retryAfter) {
+            const retrySeconds = parseInt(retryAfter, 10);
+            return {
+                resetTime: new Date(Date.now() + retrySeconds * 1000),
+                retryAfter: retrySeconds
+            };
+        }
+
+        // Use the later of requests or tokens reset time
+        const resets = [requestsReset, tokensReset].filter(Boolean);
+        if (resets.length > 0) {
+            const resetDates = resets.map(r => new Date(r));
+            const latestReset = new Date(Math.max(...resetDates));
+            return {
+                resetTime: latestReset,
+                retryAfter: Math.max(0, Math.floor((latestReset - Date.now()) / 1000))
+            };
+        }
+
+        // Check error response for rate limit info
+        if (errorData?.error?.type === 'rate_limit_error') {
+            // Anthropic may include reset time in error message
+            return {
+                resetTime: new Date(Date.now() + 60000), // Default: 1 minute
+                retryAfter: 60
+            };
+        }
+
+        return null;
+    }
+
+    /**
+     * Check if error indicates invalid API key
+     *
+     * @param {Error} error - Error object
+     * @returns {boolean}
+     */
+    shouldInvalidateCredentials(error) {
+        if (error.message && (
+            error.message.includes('invalid_api_key') ||
+            error.message.includes('authentication_error') ||
+            error.message.includes('Invalid API Key')
+        )) {
+            return true;
+        }
+
+        return super.shouldInvalidateCredentials(error);
+    }
+}
+
+export default AnthropicProvider;