commons-proxy 2.0.0

package/bin/cli.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { readFileSync } from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Read package.json for version
+const packageJson = JSON.parse(
+  readFileSync(join(__dirname, '..', 'package.json'), 'utf-8')
+);
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+function showHelp() {
+  console.log(`
+CommonsProxy v${packageJson.version}
+
+Universal proxy server for Claude Code CLI - supports multiple AI providers.
+
+USAGE:
+  commons-proxy <command> [options]
+
+COMMANDS:
+  start                 Start the proxy server (default port: 8080)
+  accounts              Manage accounts (interactive)
+  accounts add          Add a new account (prompts for provider)
+  accounts list         List all configured accounts
+  accounts remove       Remove accounts interactively
+  accounts verify       Verify account tokens are valid
+  accounts clear        Remove all accounts
+
+OPTIONS:
+  --help, -h            Show this help message
+  --version, -v         Show version number
+  --strategy=<type>     Account selection strategy (sticky|round-robin|hybrid)
+  --fallback            Enable model fallback when quota exhausted
+  --debug               Enable debug logging
+  --no-browser          Use manual code input for OAuth (headless servers)
+
+ENVIRONMENT:
+  PORT                  Server port (default: 8080)
+  WEBUI_PASSWORD        Password protect WebUI (optional)
+  STRATEGY              Account selection strategy (default: hybrid)
+  FALLBACK              Enable model fallback (true|false)
+  DEBUG                 Enable debug logging (true|false)
+
+PROVIDERS:
+  🔵 Google Cloud Code  OAuth 2.0 flow for Claude & Gemini models
+  🟠 Anthropic          Direct API access via API key
+  🟢 OpenAI             GPT models via API key (supports Azure)
+  🟣 GitHub Models      GitHub marketplace access via Personal Access Token
+  🟧 GitHub Copilot     Device authorization flow for Copilot models
+  🟪 OpenRouter          Unified API for 100+ models via API key
+
+EXAMPLES:
+  # Start server with default settings
+  commons-proxy start
+  
+  # Start with custom port and strategy
+  PORT=3000 commons-proxy start --strategy=round-robin
+  
+  # Start with model fallback enabled
+  commons-proxy start --fallback --debug
+  
+  # Add accounts from different providers
+  commons-proxy accounts add              # Interactive (prompts for provider)
+  commons-proxy accounts add --no-browser # Manual OAuth code input
+  
+  # List and verify accounts
+  commons-proxy accounts list
+  commons-proxy accounts verify
+
+CONFIGURATION:
+  Claude Code CLI (~/.claude/settings.json):
+    {
+      "env": {
+        "ANTHROPIC_BASE_URL": "http://localhost:8080"
+      }
+    }
+  
+  Web Interface:
+    http://localhost:8080 - Manage accounts, view stats, configure settings
+
+DOCUMENTATION:
+  Getting Started:  docs/PROVIDERS.md - Setup guides for all providers
+  Contributing:     CONTRIBUTING.md - Developer onboarding guide
+  GitHub:           https://github.com/AryanVBW/CommonsProxy
+  npm:              https://www.npmjs.com/package/commons-proxy
+`);
+}
+
+function showVersion() {
+  console.log(packageJson.version);
+}
+
+async function main() {
+  // Handle flags
+  if (args.includes('--help') || args.includes('-h')) {
+    showHelp();
+    process.exit(0);
+  }
+
+  if (args.includes('--version') || args.includes('-v')) {
+    showVersion();
+    process.exit(0);
+  }
+
+  // Handle commands
+  switch (command) {
+    case 'start':
+    case undefined:
+      // Default to starting the server
+      await import('../src/index.js');
+      break;
+
+    case 'accounts': {
+      // Pass remaining args to accounts CLI
+      const subCommand = args[1] || 'add';
+      process.argv = ['node', 'accounts-cli.js', subCommand, ...args.slice(2)];
+      await import('../src/cli/accounts.js');
+      break;
+    }
+
+    case 'help':
+      showHelp();
+      break;
+
+    case 'version':
+      showVersion();
+      break;
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.error('Run "commons-proxy --help" for usage information.');
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "commons-proxy",
+  "version": "2.0.0",
+  "description": "Universal AI proxy server with multi-provider support (Google Cloud Code, Anthropic, OpenAI, GitHub Models, GitHub Copilot, OpenRouter) - Anthropic-compatible API for Claude Code CLI",
+  "main": "src/index.js",
+  "type": "module",
+  "bin": {
+    "commons-proxy": "bin/cli.js"
+  },
+  "files": [
+    "src",
+    "bin",
+    "public"
+  ],
+  "scripts": {
+    "build:css": "tailwindcss -i ./public/css/src/input.css -o ./public/css/style.css --minify",
+    "watch:css": "tailwindcss -i ./public/css/src/input.css -o ./public/css/style.css --watch",
+    "prepare": "npm run build:css",
+    "prepare-release": "npm run build:css && npm test",
+    "start": "node src/index.js",
+    "dev": "node --watch src/index.js",
+    "dev:full": "concurrently \"npm run watch:css\" \"npm run dev\"",
+    "accounts": "node src/cli/accounts.js",
+    "accounts:add": "node src/cli/accounts.js add",
+    "accounts:list": "node src/cli/accounts.js list",
+    "accounts:remove": "node src/cli/accounts.js remove",
+    "accounts:verify": "node src/cli/accounts.js verify",
+    "test": "node tests/run-all.cjs",
+    "test:signatures": "node tests/test-thinking-signatures.cjs",
+    "test:multiturn": "node tests/test-multiturn-thinking-tools.cjs",
+    "test:streaming": "node tests/test-multiturn-thinking-tools-streaming.cjs",
+    "test:interleaved": "node tests/test-interleaved-thinking.cjs",
+    "test:images": "node tests/test-images.cjs",
+    "test:caching": "node tests/test-caching-streaming.cjs",
+    "test:crossmodel": "node tests/test-cross-model-thinking.cjs",
+    "test:oauth": "node tests/test-oauth-no-browser.cjs",
+    "test:emptyretry": "node tests/test-empty-response-retry.cjs",
+    "test:sanitizer": "node tests/test-schema-sanitizer.cjs",
+    "test:strategies": "node tests/test-strategies.cjs",
+    "test:cache-control": "node tests/test-cache-control.cjs"
+  },
+  "keywords": [
+    "claude",
+    "anthropic",
+    "openai",
+    "github-models",
+    "github-copilot",
+    "openrouter",
+    "commons",
+    "ai-proxy",
+    "ai-gateway",
+    "multi-provider",
+    "llm-proxy",
+    "llm",
+    "copilot",
+    "proxy",
+    "vertex-ai",
+    "gemini",
+    "gpt",
+    "load-balancer",
+    "api-gateway"
+  ],
+  "author": "Badri Narayanan S <badrinarayanans@gmail.com>",
+  "contributors": [
+    "AryanVBW"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AryanVBW/CommonsProxy.git"
+  },
+  "homepage": "https://github.com/AryanVBW/CommonsProxy#readme",
+  "bugs": {
+    "url": "https://github.com/AryanVBW/CommonsProxy/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "async-mutex": "^0.5.0",
+    "better-sqlite3": "^12.5.0",
+    "cors": "^2.8.5",
+    "express": "^4.18.2"
+  },
+  "devDependencies": {
+    "@tailwindcss/forms": "^0.5.7",
+    "autoprefixer": "^10.4.16",
+    "concurrently": "^8.2.2",
+    "daisyui": "^4.12.14",
+    "postcss": "^8.4.32",
+    "tailwindcss": "^3.4.0"
+  }
+}

package/public/app.js

@@ -0,0 +1,229 @@
+/**
+ * Antigravity Console - Main Entry
+ *
+ * This file orchestrates Alpine.js initialization.
+ * Components are loaded via separate script files that register themselves
+ * to window.Components before this script runs.
+ */
+
+document.addEventListener('alpine:init', () => {
+    // Register Components (loaded from separate files via window.Components)
+    Alpine.data('dashboard', window.Components.dashboard);
+    Alpine.data('models', window.Components.models);
+    Alpine.data('accountManager', window.Components.accountManager);
+    Alpine.data('claudeConfig', window.Components.claudeConfig);
+    Alpine.data('logsViewer', window.Components.logsViewer);
+    Alpine.data('addAccountModal', window.Components.addAccountModal);
+
+    // View Loader Directive
+    Alpine.directive('load-view', (el, { expression }, { evaluate }) => {
+        if (!window.viewCache) window.viewCache = new Map();
+
+        // Evaluate the expression to get the actual view name (removes quotes)
+        const viewName = evaluate(expression);
+
+        if (window.viewCache.has(viewName)) {
+            el.innerHTML = window.viewCache.get(viewName);
+            Alpine.initTree(el);
+            return;
+        }
+
+        fetch(`views/${viewName}.html?t=${Date.now()}`)
+            .then(response => {
+                if (!response.ok) throw new Error(`HTTP ${response.status}`);
+                return response.text();
+            })
+            .then(html => {
+                // Update cache (optional, or remove if we want always-fresh)
+                // keeping cache for session performance, but initial load will now bypass browser cache
+                window.viewCache.set(viewName, html);
+                el.innerHTML = html;
+                Alpine.initTree(el);
+            })
+            .catch(err => {
+                console.error('Failed to load view:', viewName, err);
+                el.innerHTML = `<div class="p-4 border border-red-500/50 bg-red-500/10 rounded-lg text-red-400 font-mono text-sm">
+                    Error loading view: ${viewName}<br>
+                    <span class="text-xs opacity-75">${err.message}</span>
+                </div>`;
+            });
+    });
+
+    // Main App Controller
+    Alpine.data('app', () => ({
+        get connectionStatus() {
+            return Alpine.store('data')?.connectionStatus || 'connecting';
+        },
+        get loading() {
+            return Alpine.store('data')?.loading || false;
+        },
+
+        sidebarOpen: window.innerWidth >= 1024,
+        toggleSidebar() {
+            this.sidebarOpen = !this.sidebarOpen;
+        },
+
+        init() {
+            console.log('App controller initialized');
+
+            // Handle responsive sidebar transitions
+            let lastWidth = window.innerWidth;
+            let resizeTimeout = null;
+            
+            window.addEventListener('resize', () => {
+                if (resizeTimeout) clearTimeout(resizeTimeout);
+                
+                resizeTimeout = setTimeout(() => {
+                    const currentWidth = window.innerWidth;
+                    const lgBreakpoint = 1024;
+                    
+                    // Desktop -> Mobile: Auto-close sidebar to prevent overlay blocking screen
+                    if (lastWidth >= lgBreakpoint && currentWidth < lgBreakpoint) {
+                        this.sidebarOpen = false;
+                    }
+                    
+                    // Mobile -> Desktop: Auto-open sidebar (restore standard desktop layout)
+                    if (lastWidth < lgBreakpoint && currentWidth >= lgBreakpoint) {
+                        this.sidebarOpen = true;
+                    }
+                    
+                    lastWidth = currentWidth;
+                }, 150);
+            });
+
+            // Theme setup
+            document.documentElement.setAttribute('data-theme', 'black');
+            document.documentElement.classList.add('dark');
+
+            // Chart Defaults
+            if (typeof Chart !== 'undefined') {
+                Chart.defaults.color = window.utils.getThemeColor('--color-text-dim');
+                Chart.defaults.borderColor = window.utils.getThemeColor('--color-space-border');
+                Chart.defaults.font.family = '"JetBrains Mono", monospace';
+            }
+
+            // Start Data Polling
+            this.startAutoRefresh();
+            document.addEventListener('refresh-interval-changed', () => this.startAutoRefresh());
+
+            // Initial Fetch
+            Alpine.store('data').fetchData();
+        },
+
+        refreshTimer: null,
+
+        fetchData() {
+            Alpine.store('data').fetchData();
+        },
+
+        startAutoRefresh() {
+            if (this.refreshTimer) clearInterval(this.refreshTimer);
+            const interval = parseInt(Alpine.store('settings')?.refreshInterval || 60);
+            if (interval > 0) {
+                this.refreshTimer = setInterval(() => Alpine.store('data').fetchData(), interval * 1000);
+            }
+        },
+
+        t(key) {
+            return Alpine.store('global')?.t(key) || key;
+        },
+
+        async addAccountWeb(reAuthEmail = null) {
+            const password = Alpine.store('global').webuiPassword;
+            try {
+                const urlPath = reAuthEmail
+                    ? `/api/auth/url?email=${encodeURIComponent(reAuthEmail)}`
+                    : '/api/auth/url';
+
+                const { response, newPassword } = await window.utils.request(urlPath, {}, password);
+                if (newPassword) Alpine.store('global').webuiPassword = newPassword;
+
+                const data = await response.json();
+
+                if (data.status === 'ok') {
+                    // Show info toast that OAuth is in progress
+                    Alpine.store('global').showToast(Alpine.store('global').t('oauthInProgress'), 'info');
+
+                    // Open OAuth window
+                    const oauthWindow = window.open(data.url, 'google_oauth', 'width=600,height=700,scrollbars=yes');
+
+                    // Poll for account changes instead of relying on postMessage
+                    // (since OAuth callback is now on port 51121, not this server)
+                    const initialAccountCount = Alpine.store('data').accounts.length;
+                    let pollCount = 0;
+                    const maxPolls = 60; // 2 minutes (2 second intervals)
+                    let cancelled = false;
+
+                    // Show progress modal
+                    Alpine.store('global').oauthProgress = {
+                        active: true,
+                        current: 0,
+                        max: maxPolls,
+                        cancel: () => {
+                            cancelled = true;
+                            clearInterval(pollInterval);
+                            Alpine.store('global').oauthProgress.active = false;
+                            Alpine.store('global').showToast(Alpine.store('global').t('oauthCancelled'), 'info');
+                            if (oauthWindow && !oauthWindow.closed) {
+                                oauthWindow.close();
+                            }
+                        }
+                    };
+
+                    const pollInterval = setInterval(async () => {
+                        if (cancelled) {
+                            clearInterval(pollInterval);
+                            return;
+                        }
+
+                        pollCount++;
+                        Alpine.store('global').oauthProgress.current = pollCount;
+
+                        // Check if OAuth window was closed manually
+                        if (oauthWindow && oauthWindow.closed && !cancelled) {
+                            clearInterval(pollInterval);
+                            Alpine.store('global').oauthProgress.active = false;
+                            Alpine.store('global').showToast(Alpine.store('global').t('oauthWindowClosed'), 'warning');
+                            return;
+                        }
+
+                        // Refresh account list
+                        await Alpine.store('data').fetchData();
+
+                        // Check if new account was added
+                        const currentAccountCount = Alpine.store('data').accounts.length;
+                        if (currentAccountCount > initialAccountCount) {
+                            clearInterval(pollInterval);
+                            Alpine.store('global').oauthProgress.active = false;
+
+                            const actionKey = reAuthEmail ? 'accountReauthSuccess' : 'accountAddedSuccess';
+                            Alpine.store('global').showToast(
+                                Alpine.store('global').t(actionKey),
+                                'success'
+                            );
+                            document.getElementById('add_account_modal')?.close();
+
+                            if (oauthWindow && !oauthWindow.closed) {
+                                oauthWindow.close();
+                            }
+                        }
+
+                        // Stop polling after max attempts
+                        if (pollCount >= maxPolls) {
+                            clearInterval(pollInterval);
+                            Alpine.store('global').oauthProgress.active = false;
+                            Alpine.store('global').showToast(
+                                Alpine.store('global').t('oauthTimeout'),
+                                'warning'
+                            );
+                        }
+                    }, 2000); // Poll every 2 seconds
+                } else {
+                    Alpine.store('global').showToast(data.error || Alpine.store('global').t('failedToGetAuthUrl'), 'error');
+                }
+            } catch (e) {
+                Alpine.store('global').showToast(Alpine.store('global').t('failedToStartOAuth') + ': ' + e.message, 'error');
+            }
+        }
+    }));
+});