@kamel-ahmed/proxy-claude 1.0.0

package/src/index.js

@@ -0,0 +1,146 @@
+/**
+ * Antigravity Claude Proxy
+ * Entry point - starts the proxy server
+ */
+
+import app, { accountManager } from './server.js';
+import { DEFAULT_PORT } from './constants.js';
+import { logger } from './utils/logger.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, '.antigravity-claude-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(`
+╔══════════════════════════════════════════════════════════════╗
+║           Antigravity Claude Proxy 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}
+║    export ANTHROPIC_API_KEY=dummy                            ║
+║    claude                                                    ║
+║                                                              ║
+║  Add Google accounts:                                        ║
+║    npm run accounts                                          ║
+║                                                              ║
+║  Prerequisites (if no accounts configured):                  ║
+║    - Antigravity must be running                             ║
+║    - Have a chat panel open in Antigravity                   ║
+║                                                              ║
+╚══════════════════════════════════════════════════════════════╝
+  `);
+    
+    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
+};