Merge pull request #47 from Wha1eChai/feature/webui
feat: Add Web UI for account and quota management
This commit is contained in:
Badri Narayanan S
@@ -71,6 +71,16 @@ export class AccountManager {
|
||||
this.#initialized = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reload accounts from disk (force re-initialization)
|
||||
* Useful when accounts.json is modified externally (e.g., by WebUI)
|
||||
*/
|
||||
async reload() {
|
||||
this.#initialized = false;
|
||||
await this.initialize();
|
||||
logger.info('[AccountManager] Accounts reloaded from disk');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the number of accounts
|
||||
* @returns {number} Number of configured accounts
|
||||
@@ -278,6 +288,8 @@ export class AccountManager {
|
||||
accounts: this.#accounts.map(a => ({
|
||||
email: a.email,
|
||||
source: a.source,
|
||||
enabled: a.enabled !== false, // Default to true if undefined
|
||||
projectId: a.projectId || null,
|
||||
modelRateLimits: a.modelRateLimits || {},
|
||||
isInvalid: a.isInvalid || false,
|
||||
invalidReason: a.invalidReason || null,
|
||||
|
||||
@@ -39,6 +39,9 @@ export function getAvailableAccounts(accounts, modelId = null) {
|
||||
return accounts.filter(acc => {
|
||||
if (acc.isInvalid) return false;
|
||||
|
||||
// WebUI: Skip disabled accounts
|
||||
if (acc.enabled === false) return false;
|
||||
|
||||
if (modelId && acc.modelRateLimits && acc.modelRateLimits[modelId]) {
|
||||
const limit = acc.modelRateLimits[modelId];
|
||||
if (limit.isRateLimited && limit.resetTime > Date.now()) {
|
||||
|
||||
@@ -19,6 +19,9 @@ import { clearExpiredLimits, getAvailableAccounts } from './rate-limits.js';
|
||||
function isAccountUsable(account, modelId) {
|
||||
if (!account || account.isInvalid) return false;
|
||||
|
||||
// WebUI: Skip disabled accounts
|
||||
if (account.enabled === false) return false;
|
||||
|
||||
if (modelId && account.modelRateLimits && account.modelRateLimits[modelId]) {
|
||||
const limit = account.modelRateLimits[modelId];
|
||||
if (limit.isRateLimited && limit.resetTime > Date.now()) {
|
||||
|
||||
@@ -27,10 +27,14 @@ export async function loadAccounts(configPath = ACCOUNT_CONFIG_PATH) {
|
||||
const accounts = (config.accounts || []).map(acc => ({
|
||||
...acc,
|
||||
lastUsed: acc.lastUsed || null,
|
||||
enabled: acc.enabled !== false, // Default to true if not specified
|
||||
// Reset invalid flag on startup - give accounts a fresh chance to refresh
|
||||
isInvalid: false,
|
||||
invalidReason: null,
|
||||
modelRateLimits: acc.modelRateLimits || {}
|
||||
modelRateLimits: acc.modelRateLimits || {},
|
||||
// New fields for subscription and quota tracking
|
||||
subscription: acc.subscription || { tier: 'unknown', projectId: null, detectedAt: null },
|
||||
quota: acc.quota || { models: {}, lastChecked: null }
|
||||
}));
|
||||
|
||||
const settings = config.settings || {};
|
||||
@@ -107,6 +111,7 @@ export async function saveAccounts(configPath, accounts, settings, activeIndex)
|
||||
accounts: accounts.map(acc => ({
|
||||
email: acc.email,
|
||||
source: acc.source,
|
||||
enabled: acc.enabled !== false, // Persist enabled state
|
||||
dbPath: acc.dbPath || null,
|
||||
refreshToken: acc.source === 'oauth' ? acc.refreshToken : undefined,
|
||||
apiKey: acc.source === 'manual' ? acc.apiKey : undefined,
|
||||
@@ -115,7 +120,10 @@ export async function saveAccounts(configPath, accounts, settings, activeIndex)
|
||||
isInvalid: acc.isInvalid || false,
|
||||
invalidReason: acc.invalidReason || null,
|
||||
modelRateLimits: acc.modelRateLimits || {},
|
||||
lastUsed: acc.lastUsed
|
||||
lastUsed: acc.lastUsed,
|
||||
// Persist subscription and quota data
|
||||
subscription: acc.subscription || { tier: 'unknown', projectId: null, detectedAt: null },
|
||||
quota: acc.quota || { models: {}, lastChecked: null }
|
||||
})),
|
||||
settings: settings,
|
||||
activeIndex: activeIndex
|
||||
|
||||
@@ -32,15 +32,16 @@ function generatePKCE() {
|
||||
* Generate authorization URL for Google OAuth
|
||||
* Returns the URL and the PKCE verifier (needed for token exchange)
|
||||
*
|
||||
* @param {string} [customRedirectUri] - Optional custom redirect URI (e.g. for WebUI)
|
||||
* @returns {{url: string, verifier: string, state: string}} Auth URL and PKCE data
|
||||
*/
|
||||
export function getAuthorizationUrl() {
|
||||
export function getAuthorizationUrl(customRedirectUri = null) {
|
||||
const { verifier, challenge } = generatePKCE();
|
||||
const state = crypto.randomBytes(16).toString('hex');
|
||||
|
||||
const params = new URLSearchParams({
|
||||
client_id: OAUTH_CONFIG.clientId,
|
||||
redirect_uri: OAUTH_REDIRECT_URI,
|
||||
redirect_uri: customRedirectUri || OAUTH_REDIRECT_URI,
|
||||
response_type: 'code',
|
||||
scope: OAUTH_CONFIG.scopes.join(' '),
|
||||
access_type: 'offline',
|
||||
|
||||
@@ -12,17 +12,18 @@
|
||||
// Re-export public API
|
||||
export { sendMessage } from './message-handler.js';
|
||||
export { sendMessageStream } from './streaming-handler.js';
|
||||
export { listModels, fetchAvailableModels, getModelQuotas } from './model-api.js';
|
||||
export { listModels, fetchAvailableModels, getModelQuotas, getSubscriptionTier } from './model-api.js';
|
||||
|
||||
// Default export for backwards compatibility
|
||||
import { sendMessage } from './message-handler.js';
|
||||
import { sendMessageStream } from './streaming-handler.js';
|
||||
import { listModels, fetchAvailableModels, getModelQuotas } from './model-api.js';
|
||||
import { listModels, fetchAvailableModels, getModelQuotas, getSubscriptionTier } from './model-api.js';
|
||||
|
||||
export default {
|
||||
sendMessage,
|
||||
sendMessageStream,
|
||||
listModels,
|
||||
fetchAvailableModels,
|
||||
getModelQuotas
|
||||
getModelQuotas,
|
||||
getSubscriptionTier
|
||||
};
|
||||
|
||||
@@ -110,3 +110,75 @@ export async function getModelQuotas(token) {
|
||||
|
||||
return quotas;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get subscription tier for an account
|
||||
* Calls loadCodeAssist API to discover project ID and subscription tier
|
||||
*
|
||||
* @param {string} token - OAuth access token
|
||||
* @returns {Promise<{tier: string, projectId: string|null}>} Subscription tier (free/pro/ultra) and project ID
|
||||
*/
|
||||
export async function getSubscriptionTier(token) {
|
||||
const headers = {
|
||||
'Authorization': `Bearer ${token}`,
|
||||
'Content-Type': 'application/json',
|
||||
...ANTIGRAVITY_HEADERS
|
||||
};
|
||||
|
||||
for (const endpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
|
||||
try {
|
||||
const url = `${endpoint}/v1internal:loadCodeAssist`;
|
||||
const response = await fetch(url, {
|
||||
method: 'POST',
|
||||
headers,
|
||||
body: JSON.stringify({
|
||||
metadata: {
|
||||
ideType: 'IDE_UNSPECIFIED',
|
||||
platform: 'PLATFORM_UNSPECIFIED',
|
||||
pluginType: 'GEMINI'
|
||||
}
|
||||
})
|
||||
});
|
||||
|
||||
if (!response.ok) {
|
||||
logger.warn(`[CloudCode] loadCodeAssist error at ${endpoint}: ${response.status}`);
|
||||
continue;
|
||||
}
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
// Extract project ID
|
||||
let projectId = null;
|
||||
if (typeof data.cloudaicompanionProject === 'string') {
|
||||
projectId = data.cloudaicompanionProject;
|
||||
} else if (data.cloudaicompanionProject?.id) {
|
||||
projectId = data.cloudaicompanionProject.id;
|
||||
}
|
||||
|
||||
// Extract subscription tier (priority: paidTier > currentTier)
|
||||
let tier = 'free';
|
||||
const tierId = data.paidTier?.id || data.currentTier?.id;
|
||||
|
||||
if (tierId) {
|
||||
const lowerTier = tierId.toLowerCase();
|
||||
if (lowerTier.includes('ultra')) {
|
||||
tier = 'ultra';
|
||||
} else if (lowerTier.includes('pro')) {
|
||||
tier = 'pro';
|
||||
} else {
|
||||
tier = 'free';
|
||||
}
|
||||
}
|
||||
|
||||
logger.debug(`[CloudCode] Subscription detected: ${tier}, Project: ${projectId}`);
|
||||
|
||||
return { tier, projectId };
|
||||
} catch (error) {
|
||||
logger.warn(`[CloudCode] loadCodeAssist failed at ${endpoint}:`, error.message);
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback: return default values if all endpoints fail
|
||||
logger.warn('[CloudCode] Failed to detect subscription tier from all endpoints. Defaulting to free.');
|
||||
return { tier: 'free', projectId: null };
|
||||
}
|
||||
|
||||
86
src/config.js
Normal file
86
src/config.js
Normal file
@@ -0,0 +1,86 @@
|
||||
import fs from 'fs';
|
||||
import path from 'path';
|
||||
import os from 'os';
|
||||
import { logger } from './utils/logger.js';
|
||||
|
||||
// Default config
|
||||
const DEFAULT_CONFIG = {
|
||||
webuiPassword: '',
|
||||
debug: false,
|
||||
logLevel: 'info',
|
||||
maxRetries: 5,
|
||||
retryBaseMs: 1000,
|
||||
retryMaxMs: 30000,
|
||||
persistTokenCache: false,
|
||||
defaultCooldownMs: 60000, // 1 minute
|
||||
maxWaitBeforeErrorMs: 120000, // 2 minutes
|
||||
modelMapping: {}
|
||||
};
|
||||
|
||||
// Config locations
|
||||
const HOME_DIR = os.homedir();
|
||||
const CONFIG_DIR = path.join(HOME_DIR, '.config', 'antigravity-proxy');
|
||||
const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
|
||||
|
||||
// Ensure config dir exists
|
||||
if (!fs.existsSync(CONFIG_DIR)) {
|
||||
try {
|
||||
fs.mkdirSync(CONFIG_DIR, { recursive: true });
|
||||
} catch (err) {
|
||||
// Ignore
|
||||
}
|
||||
}
|
||||
|
||||
// Load config
|
||||
let config = { ...DEFAULT_CONFIG };
|
||||
|
||||
function loadConfig() {
|
||||
try {
|
||||
// Env vars take precedence for initial defaults, but file overrides them if present?
|
||||
// Usually Env > File > Default.
|
||||
|
||||
if (fs.existsSync(CONFIG_FILE)) {
|
||||
const fileContent = fs.readFileSync(CONFIG_FILE, 'utf8');
|
||||
const userConfig = JSON.parse(fileContent);
|
||||
config = { ...DEFAULT_CONFIG, ...userConfig };
|
||||
} else {
|
||||
// Try looking in current dir for config.json as fallback
|
||||
const localConfigPath = path.resolve('config.json');
|
||||
if (fs.existsSync(localConfigPath)) {
|
||||
const fileContent = fs.readFileSync(localConfigPath, 'utf8');
|
||||
const userConfig = JSON.parse(fileContent);
|
||||
config = { ...DEFAULT_CONFIG, ...userConfig };
|
||||
}
|
||||
}
|
||||
|
||||
// Environment overrides
|
||||
if (process.env.WEBUI_PASSWORD) config.webuiPassword = process.env.WEBUI_PASSWORD;
|
||||
if (process.env.DEBUG === 'true') config.debug = true;
|
||||
|
||||
} catch (error) {
|
||||
console.error('[Config] Error loading config:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// Initial load
|
||||
loadConfig();
|
||||
|
||||
export function getPublicConfig() {
|
||||
return { ...config };
|
||||
}
|
||||
|
||||
export function saveConfig(updates) {
|
||||
try {
|
||||
// Apply updates
|
||||
config = { ...config, ...updates };
|
||||
|
||||
// Save to disk
|
||||
fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
|
||||
return true;
|
||||
} catch (error) {
|
||||
logger.error('[Config] Failed to save config:', error);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
export { config };
|
||||
@@ -5,6 +5,7 @@
|
||||
|
||||
import { homedir, platform, arch } from 'os';
|
||||
import { join } from 'path';
|
||||
import { config } from './config.js';
|
||||
|
||||
/**
|
||||
* Get the Antigravity database path based on the current platform.
|
||||
@@ -59,28 +60,35 @@ export const ANTIGRAVITY_HEADERS = {
|
||||
// Default project ID if none can be discovered
|
||||
export const DEFAULT_PROJECT_ID = 'rising-fact-p41fc';
|
||||
|
||||
export const TOKEN_REFRESH_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
|
||||
export const REQUEST_BODY_LIMIT = '50mb';
|
||||
// Configurable constants - values from config.json take precedence
|
||||
export const TOKEN_REFRESH_INTERVAL_MS = config?.tokenCacheTtlMs || (5 * 60 * 1000); // From config or 5 minutes
|
||||
export const REQUEST_BODY_LIMIT = config?.requestBodyLimit || '50mb';
|
||||
export const ANTIGRAVITY_AUTH_PORT = 9092;
|
||||
export const DEFAULT_PORT = 8080;
|
||||
export const DEFAULT_PORT = config?.port || 8080;
|
||||
|
||||
// Multi-account configuration
|
||||
export const ACCOUNT_CONFIG_PATH = join(
|
||||
export const ACCOUNT_CONFIG_PATH = config?.accountConfigPath || join(
|
||||
homedir(),
|
||||
'.config/antigravity-proxy/accounts.json'
|
||||
);
|
||||
|
||||
// Usage history persistence path
|
||||
export const USAGE_HISTORY_PATH = join(
|
||||
homedir(),
|
||||
'.config/antigravity-proxy/usage-history.json'
|
||||
);
|
||||
|
||||
// Antigravity app database path (for legacy single-account token extraction)
|
||||
// Uses platform-specific path detection
|
||||
export const ANTIGRAVITY_DB_PATH = getAntigravityDbPath();
|
||||
|
||||
export const DEFAULT_COOLDOWN_MS = 10 * 1000; // 10 second default cooldown
|
||||
export const MAX_RETRIES = 5; // Max retry attempts across accounts
|
||||
export const MAX_EMPTY_RESPONSE_RETRIES = 2; // Max retries for empty API responses
|
||||
export const MAX_ACCOUNTS = 10; // Maximum number of accounts allowed
|
||||
export const DEFAULT_COOLDOWN_MS = config?.defaultCooldownMs || (10 * 1000); // From config or 10 seconds
|
||||
export const MAX_RETRIES = config?.maxRetries || 5; // From config or 5
|
||||
export const MAX_EMPTY_RESPONSE_RETRIES = 2; // Max retries for empty API responses (from upstream)
|
||||
export const MAX_ACCOUNTS = config?.maxAccounts || 10; // From config or 10
|
||||
|
||||
// Rate limit wait thresholds
|
||||
export const MAX_WAIT_BEFORE_ERROR_MS = 120000; // 2 minutes - throw error if wait exceeds this
|
||||
export const MAX_WAIT_BEFORE_ERROR_MS = config?.maxWaitBeforeErrorMs || 120000; // From config or 2 minutes
|
||||
|
||||
// Thinking model constants
|
||||
export const MIN_SIGNATURE_LENGTH = 50; // Minimum valid thinking signature length
|
||||
|
||||
205
src/modules/usage-stats.js
Normal file
205
src/modules/usage-stats.js
Normal file
@@ -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
|
||||
};
|
||||
140
src/server.js
140
src/server.js
@@ -6,12 +6,20 @@
|
||||
|
||||
import express from 'express';
|
||||
import cors from 'cors';
|
||||
import { sendMessage, sendMessageStream, listModels, getModelQuotas } from './cloudcode/index.js';
|
||||
import path from 'path';
|
||||
import { fileURLToPath } from 'url';
|
||||
import { sendMessage, sendMessageStream, listModels, getModelQuotas, getSubscriptionTier } from './cloudcode/index.js';
|
||||
import { mountWebUI } from './webui/index.js';
|
||||
import { config } from './config.js';
|
||||
|
||||
const __filename = fileURLToPath(import.meta.url);
|
||||
const __dirname = path.dirname(__filename);
|
||||
import { forceRefresh } from './auth/token-extractor.js';
|
||||
import { REQUEST_BODY_LIMIT } from './constants.js';
|
||||
import { AccountManager } from './account-manager/index.js';
|
||||
import { formatDuration } from './utils/helpers.js';
|
||||
import { logger } from './utils/logger.js';
|
||||
import usageStats from './modules/usage-stats.js';
|
||||
|
||||
// Parse fallback flag directly from command line args to avoid circular dependency
|
||||
const args = process.argv.slice(2);
|
||||
@@ -57,6 +65,12 @@ async function ensureInitialized() {
|
||||
app.use(cors());
|
||||
app.use(express.json({ limit: REQUEST_BODY_LIMIT }));
|
||||
|
||||
// Setup usage statistics middleware
|
||||
usageStats.setupMiddleware(app);
|
||||
|
||||
// Mount WebUI (optional web interface for account management)
|
||||
mountWebUI(app, __dirname, accountManager);
|
||||
|
||||
/**
|
||||
* Parse error message to extract error type, status code, and user-friendly message
|
||||
*/
|
||||
@@ -123,11 +137,11 @@ app.get('/health', async (req, res) => {
|
||||
try {
|
||||
await ensureInitialized();
|
||||
const start = Date.now();
|
||||
|
||||
|
||||
// Get high-level status first
|
||||
const status = accountManager.getStatus();
|
||||
const allAccounts = accountManager.getAllAccounts();
|
||||
|
||||
|
||||
// Fetch quotas for each account in parallel to get detailed model info
|
||||
const accountDetails = await Promise.allSettled(
|
||||
allAccounts.map(async (account) => {
|
||||
@@ -235,6 +249,7 @@ app.get('/account-limits', async (req, res) => {
|
||||
await ensureInitialized();
|
||||
const allAccounts = accountManager.getAllAccounts();
|
||||
const format = req.query.format || 'json';
|
||||
const includeHistory = req.query.includeHistory === 'true';
|
||||
|
||||
// Fetch quotas for each account in parallel
|
||||
const results = await Promise.allSettled(
|
||||
@@ -251,11 +266,33 @@ app.get('/account-limits', async (req, res) => {
|
||||
|
||||
try {
|
||||
const token = await accountManager.getTokenForAccount(account);
|
||||
const quotas = await getModelQuotas(token);
|
||||
|
||||
// Fetch both quotas and subscription tier in parallel
|
||||
const [quotas, subscription] = await Promise.all([
|
||||
getModelQuotas(token),
|
||||
getSubscriptionTier(token)
|
||||
]);
|
||||
|
||||
// Update account object with fresh data
|
||||
account.subscription = {
|
||||
tier: subscription.tier,
|
||||
projectId: subscription.projectId,
|
||||
detectedAt: Date.now()
|
||||
};
|
||||
account.quota = {
|
||||
models: quotas,
|
||||
lastChecked: Date.now()
|
||||
};
|
||||
|
||||
// Save updated account data to disk (async, don't wait)
|
||||
accountManager.saveToDisk().catch(err => {
|
||||
logger.error('[Server] Failed to save account data:', err);
|
||||
});
|
||||
|
||||
return {
|
||||
email: account.email,
|
||||
status: 'ok',
|
||||
subscription: account.subscription,
|
||||
models: quotas
|
||||
};
|
||||
} catch (error) {
|
||||
@@ -263,6 +300,7 @@ app.get('/account-limits', async (req, res) => {
|
||||
email: account.email,
|
||||
status: 'error',
|
||||
error: error.message,
|
||||
subscription: account.subscription || { tier: 'unknown', projectId: null },
|
||||
models: {}
|
||||
};
|
||||
}
|
||||
@@ -409,32 +447,61 @@ app.get('/account-limits', async (req, res) => {
|
||||
return res.send(lines.join('\n'));
|
||||
}
|
||||
|
||||
// Default: JSON format
|
||||
res.json({
|
||||
// Get account metadata from AccountManager
|
||||
const accountStatus = accountManager.getStatus();
|
||||
const accountMetadataMap = new Map(
|
||||
accountStatus.accounts.map(a => [a.email, a])
|
||||
);
|
||||
|
||||
// Build response data
|
||||
const responseData = {
|
||||
timestamp: new Date().toLocaleString(),
|
||||
totalAccounts: allAccounts.length,
|
||||
models: sortedModels,
|
||||
accounts: accountLimits.map(acc => ({
|
||||
email: acc.email,
|
||||
status: acc.status,
|
||||
error: acc.error || null,
|
||||
limits: Object.fromEntries(
|
||||
sortedModels.map(modelId => {
|
||||
const quota = acc.models?.[modelId];
|
||||
if (!quota) {
|
||||
return [modelId, null];
|
||||
}
|
||||
return [modelId, {
|
||||
remaining: quota.remainingFraction !== null
|
||||
? `${Math.round(quota.remainingFraction * 100)}%`
|
||||
: 'N/A',
|
||||
remainingFraction: quota.remainingFraction,
|
||||
resetTime: quota.resetTime || null
|
||||
}];
|
||||
})
|
||||
)
|
||||
}))
|
||||
});
|
||||
modelConfig: config.modelMapping || {},
|
||||
accounts: accountLimits.map(acc => {
|
||||
// Merge quota data with account metadata
|
||||
const metadata = accountMetadataMap.get(acc.email) || {};
|
||||
return {
|
||||
email: acc.email,
|
||||
status: acc.status,
|
||||
error: acc.error || null,
|
||||
// Include metadata from AccountManager (WebUI needs these)
|
||||
source: metadata.source || 'unknown',
|
||||
enabled: metadata.enabled !== false,
|
||||
projectId: metadata.projectId || null,
|
||||
isInvalid: metadata.isInvalid || false,
|
||||
invalidReason: metadata.invalidReason || null,
|
||||
lastUsed: metadata.lastUsed || null,
|
||||
modelRateLimits: metadata.modelRateLimits || {},
|
||||
// Subscription data (new)
|
||||
subscription: acc.subscription || metadata.subscription || { tier: 'unknown', projectId: null },
|
||||
// Quota limits
|
||||
limits: Object.fromEntries(
|
||||
sortedModels.map(modelId => {
|
||||
const quota = acc.models?.[modelId];
|
||||
if (!quota) {
|
||||
return [modelId, null];
|
||||
}
|
||||
return [modelId, {
|
||||
remaining: quota.remainingFraction !== null
|
||||
? `${Math.round(quota.remainingFraction * 100)}%`
|
||||
: 'N/A',
|
||||
remainingFraction: quota.remainingFraction,
|
||||
resetTime: quota.resetTime || null
|
||||
}];
|
||||
})
|
||||
)
|
||||
};
|
||||
})
|
||||
};
|
||||
|
||||
// Optionally include usage history (for dashboard performance optimization)
|
||||
if (includeHistory) {
|
||||
responseData.history = usageStats.getHistory();
|
||||
}
|
||||
|
||||
res.json(responseData);
|
||||
} catch (error) {
|
||||
res.status(500).json({
|
||||
status: 'error',
|
||||
@@ -525,13 +592,12 @@ app.post('/v1/messages', async (req, res) => {
|
||||
// Ensure account manager is initialized
|
||||
await ensureInitialized();
|
||||
|
||||
|
||||
const {
|
||||
model,
|
||||
messages,
|
||||
max_tokens,
|
||||
stream,
|
||||
system,
|
||||
max_tokens,
|
||||
tools,
|
||||
tool_choice,
|
||||
thinking,
|
||||
@@ -540,9 +606,19 @@ app.post('/v1/messages', async (req, res) => {
|
||||
temperature
|
||||
} = req.body;
|
||||
|
||||
// Resolve model mapping if configured
|
||||
let requestedModel = model || 'claude-3-5-sonnet-20241022';
|
||||
const modelMapping = config.modelMapping || {};
|
||||
if (modelMapping[requestedModel] && modelMapping[requestedModel].mapping) {
|
||||
const targetModel = modelMapping[requestedModel].mapping;
|
||||
logger.info(`[Server] Mapping model ${requestedModel} -> ${targetModel}`);
|
||||
requestedModel = targetModel;
|
||||
}
|
||||
|
||||
const modelId = requestedModel;
|
||||
|
||||
// Optimistic Retry: If ALL accounts are rate-limited for this model, reset them to force a fresh check.
|
||||
// If we have some available accounts, we try them first.
|
||||
const modelId = model || 'claude-3-5-sonnet-20241022';
|
||||
if (accountManager.isAllRateLimited(modelId)) {
|
||||
logger.warn(`[Server] All accounts rate-limited for ${modelId}. Resetting state for optimistic retry.`);
|
||||
accountManager.resetAllRateLimits();
|
||||
@@ -561,7 +637,7 @@ app.post('/v1/messages', async (req, res) => {
|
||||
|
||||
// Build the request object
|
||||
const request = {
|
||||
model: model || 'claude-3-5-sonnet-20241022',
|
||||
model: modelId,
|
||||
messages,
|
||||
max_tokens: max_tokens || 4096,
|
||||
stream,
|
||||
@@ -667,6 +743,8 @@ app.post('/v1/messages', async (req, res) => {
|
||||
/**
|
||||
* Catch-all for unsupported endpoints
|
||||
*/
|
||||
usageStats.setupRoutes(app);
|
||||
|
||||
app.use('*', (req, res) => {
|
||||
if (logger.isDebugEnabled) {
|
||||
logger.debug(`[API] 404 Not Found: ${req.method} ${req.originalUrl}`);
|
||||
|
||||
111
src/utils/claude-config.js
Normal file
111
src/utils/claude-config.js
Normal file
@@ -0,0 +1,111 @@
|
||||
/**
|
||||
* Claude CLI Configuration Utility
|
||||
*
|
||||
* Handles reading and writing to the global Claude CLI settings file.
|
||||
* Location: ~/.claude/settings.json (Windows: %USERPROFILE%\.claude\settings.json)
|
||||
*/
|
||||
|
||||
import fs from 'fs/promises';
|
||||
import path from 'path';
|
||||
import os from 'os';
|
||||
import { logger } from './logger.js';
|
||||
|
||||
/**
|
||||
* Get the path to the global Claude CLI settings file
|
||||
* @returns {string} Absolute path to settings.json
|
||||
*/
|
||||
export function getClaudeConfigPath() {
|
||||
return path.join(os.homedir(), '.claude', 'settings.json');
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the global Claude CLI configuration
|
||||
* @returns {Promise<Object>} The configuration object or empty object if file missing
|
||||
*/
|
||||
export async function readClaudeConfig() {
|
||||
const configPath = getClaudeConfigPath();
|
||||
try {
|
||||
const content = await fs.readFile(configPath, 'utf8');
|
||||
if (!content.trim()) return { env: {} };
|
||||
return JSON.parse(content);
|
||||
} catch (error) {
|
||||
if (error.code === 'ENOENT') {
|
||||
logger.warn(`[ClaudeConfig] Config file not found at ${configPath}, returning empty default`);
|
||||
return { env: {} };
|
||||
}
|
||||
if (error instanceof SyntaxError) {
|
||||
logger.error(`[ClaudeConfig] Invalid JSON in config at ${configPath}. Returning safe default.`);
|
||||
return { env: {} };
|
||||
}
|
||||
logger.error(`[ClaudeConfig] Failed to read config at ${configPath}:`, error.message);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Update the global Claude CLI configuration
|
||||
* Performs a deep merge with existing configuration to avoid losing other settings.
|
||||
*
|
||||
* @param {Object} updates - The partial configuration to merge in
|
||||
* @returns {Promise<Object>} The updated full configuration
|
||||
*/
|
||||
export async function updateClaudeConfig(updates) {
|
||||
const configPath = getClaudeConfigPath();
|
||||
let currentConfig = {};
|
||||
|
||||
// 1. Read existing config
|
||||
try {
|
||||
currentConfig = await readClaudeConfig();
|
||||
} catch (error) {
|
||||
// Ignore ENOENT, otherwise rethrow
|
||||
if (error.code !== 'ENOENT') throw error;
|
||||
}
|
||||
|
||||
// 2. Deep merge updates
|
||||
const newConfig = deepMerge(currentConfig, updates);
|
||||
|
||||
// 3. Ensure .claude directory exists
|
||||
const configDir = path.dirname(configPath);
|
||||
try {
|
||||
await fs.mkdir(configDir, { recursive: true });
|
||||
} catch (error) {
|
||||
// Ignore if exists
|
||||
}
|
||||
|
||||
// 4. Write back to file
|
||||
try {
|
||||
await fs.writeFile(configPath, JSON.stringify(newConfig, null, 2), 'utf8');
|
||||
logger.info(`[ClaudeConfig] Updated config at ${configPath}`);
|
||||
return newConfig;
|
||||
} catch (error) {
|
||||
logger.error(`[ClaudeConfig] Failed to write config:`, error.message);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Simple deep merge for objects
|
||||
*/
|
||||
function deepMerge(target, source) {
|
||||
const output = { ...target };
|
||||
|
||||
if (isObject(target) && isObject(source)) {
|
||||
Object.keys(source).forEach(key => {
|
||||
if (isObject(source[key])) {
|
||||
if (!(key in target)) {
|
||||
Object.assign(output, { [key]: source[key] });
|
||||
} else {
|
||||
output[key] = deepMerge(target[key], source[key]);
|
||||
}
|
||||
} else {
|
||||
Object.assign(output, { [key]: source[key] });
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
function isObject(item) {
|
||||
return (item && typeof item === 'object' && !Array.isArray(item));
|
||||
}
|
||||
@@ -1,15 +1,18 @@
|
||||
/**
|
||||
* Logger Utility
|
||||
*
|
||||
*
|
||||
* Provides structured logging with colors and debug support.
|
||||
* Simple ANSI codes used to avoid dependencies.
|
||||
*/
|
||||
|
||||
import { EventEmitter } from 'events';
|
||||
import util from 'util';
|
||||
|
||||
const COLORS = {
|
||||
RESET: '\x1b[0m',
|
||||
BRIGHT: '\x1b[1m',
|
||||
DIM: '\x1b[2m',
|
||||
|
||||
|
||||
RED: '\x1b[31m',
|
||||
GREEN: '\x1b[32m',
|
||||
YELLOW: '\x1b[33m',
|
||||
@@ -20,14 +23,17 @@ const COLORS = {
|
||||
GRAY: '\x1b[90m'
|
||||
};
|
||||
|
||||
class Logger {
|
||||
class Logger extends EventEmitter {
|
||||
constructor() {
|
||||
super();
|
||||
this.isDebugEnabled = false;
|
||||
this.history = [];
|
||||
this.maxHistory = 1000;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set debug mode
|
||||
* @param {boolean} enabled
|
||||
* @param {boolean} enabled
|
||||
*/
|
||||
setDebug(enabled) {
|
||||
this.isDebugEnabled = !!enabled;
|
||||
@@ -40,19 +46,44 @@ class Logger {
|
||||
return new Date().toISOString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get log history
|
||||
*/
|
||||
getHistory() {
|
||||
return this.history;
|
||||
}
|
||||
|
||||
/**
|
||||
* Format and print a log message
|
||||
* @param {string} level
|
||||
* @param {string} color
|
||||
* @param {string} message
|
||||
* @param {...any} args
|
||||
* @param {string} level
|
||||
* @param {string} color
|
||||
* @param {string} message
|
||||
* @param {...any} args
|
||||
*/
|
||||
print(level, color, message, ...args) {
|
||||
// Format: [TIMESTAMP] [LEVEL] Message
|
||||
const timestamp = `${COLORS.GRAY}[${this.getTimestamp()}]${COLORS.RESET}`;
|
||||
const timestampStr = this.getTimestamp();
|
||||
const timestamp = `${COLORS.GRAY}[${timestampStr}]${COLORS.RESET}`;
|
||||
const levelTag = `${color}[${level}]${COLORS.RESET}`;
|
||||
|
||||
console.log(`${timestamp} ${levelTag} ${message}`, ...args);
|
||||
|
||||
// Format the message with args similar to console.log
|
||||
const formattedMessage = util.format(message, ...args);
|
||||
|
||||
console.log(`${timestamp} ${levelTag} ${formattedMessage}`);
|
||||
|
||||
// Store structured log
|
||||
const logEntry = {
|
||||
timestamp: timestampStr,
|
||||
level,
|
||||
message: formattedMessage
|
||||
};
|
||||
|
||||
this.history.push(logEntry);
|
||||
if (this.history.length > this.maxHistory) {
|
||||
this.history.shift();
|
||||
}
|
||||
|
||||
this.emit('log', logEntry);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -98,7 +129,7 @@ class Logger {
|
||||
log(message, ...args) {
|
||||
console.log(message, ...args);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Print a section header
|
||||
*/
|
||||
|
||||
161
src/utils/retry.js
Normal file
161
src/utils/retry.js
Normal file
@@ -0,0 +1,161 @@
|
||||
/**
|
||||
* Retry Utilities with Exponential Backoff
|
||||
*
|
||||
* Provides retry logic with exponential backoff and jitter
|
||||
* to prevent thundering herd and optimize API quota usage.
|
||||
*/
|
||||
|
||||
import { sleep } from './helpers.js';
|
||||
import { logger } from './logger.js';
|
||||
|
||||
/**
|
||||
* Calculate exponential backoff delay with jitter
|
||||
*
|
||||
* @param {number} attempt - Current attempt number (0-based)
|
||||
* @param {number} baseMs - Base delay in milliseconds
|
||||
* @param {number} maxMs - Maximum delay in milliseconds
|
||||
* @returns {number} Delay in milliseconds
|
||||
*/
|
||||
export function calculateBackoff(attempt, baseMs = 1000, maxMs = 30000) {
|
||||
// Exponential: baseMs * 2^attempt
|
||||
const exponential = baseMs * Math.pow(2, attempt);
|
||||
|
||||
// Cap at max
|
||||
const capped = Math.min(exponential, maxMs);
|
||||
|
||||
// Add random jitter (±25%) to prevent thundering herd
|
||||
const jitter = capped * 0.25 * (Math.random() * 2 - 1);
|
||||
|
||||
return Math.floor(capped + jitter);
|
||||
}
|
||||
|
||||
/**
|
||||
* Retry a function with exponential backoff
|
||||
*
|
||||
* @param {Function} fn - Async function to retry (receives attempt number)
|
||||
* @param {Object} options - Retry options
|
||||
* @param {number} options.maxAttempts - Maximum number of attempts (default: 5)
|
||||
* @param {number} options.baseMs - Base delay in milliseconds (default: 1000)
|
||||
* @param {number} options.maxMs - Maximum delay in milliseconds (default: 30000)
|
||||
* @param {Function} options.shouldRetry - Function to determine if error is retryable
|
||||
* @param {Function} options.onRetry - Callback before each retry (error, attempt, backoffMs)
|
||||
* @returns {Promise<any>} Result from fn
|
||||
* @throws {Error} Last error if all attempts fail
|
||||
*/
|
||||
export async function retryWithBackoff(fn, options = {}) {
|
||||
const {
|
||||
maxAttempts = 5,
|
||||
baseMs = 1000,
|
||||
maxMs = 30000,
|
||||
shouldRetry = () => true,
|
||||
onRetry = null
|
||||
} = options;
|
||||
|
||||
let lastError;
|
||||
|
||||
for (let attempt = 0; attempt < maxAttempts; attempt++) {
|
||||
try {
|
||||
return await fn(attempt);
|
||||
} catch (error) {
|
||||
lastError = error;
|
||||
|
||||
// Check if this is the last attempt
|
||||
if (attempt === maxAttempts - 1) {
|
||||
logger.debug(`[Retry] All ${maxAttempts} attempts exhausted`);
|
||||
throw error;
|
||||
}
|
||||
|
||||
// Check if error is retryable
|
||||
if (!shouldRetry(error, attempt)) {
|
||||
logger.debug(`[Retry] Error not retryable, aborting: ${error.message}`);
|
||||
throw error;
|
||||
}
|
||||
|
||||
// Calculate backoff
|
||||
const backoffMs = calculateBackoff(attempt, baseMs, maxMs);
|
||||
logger.debug(`[Retry] Attempt ${attempt + 1}/${maxAttempts} failed, retrying in ${backoffMs}ms`);
|
||||
|
||||
// Call onRetry callback
|
||||
if (onRetry) {
|
||||
await onRetry(error, attempt, backoffMs);
|
||||
}
|
||||
|
||||
// Wait before retrying
|
||||
await sleep(backoffMs);
|
||||
}
|
||||
}
|
||||
|
||||
// Should never reach here, but just in case
|
||||
throw lastError;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if an error is retryable (5xx errors or network issues)
|
||||
*
|
||||
* @param {Error} error - Error to check
|
||||
* @returns {boolean} True if error is retryable
|
||||
*/
|
||||
export function isRetryableError(error) {
|
||||
const message = error.message?.toLowerCase() || '';
|
||||
|
||||
// Network errors
|
||||
if (message.includes('econnrefused') ||
|
||||
message.includes('econnreset') ||
|
||||
message.includes('etimedout') ||
|
||||
message.includes('network') ||
|
||||
message.includes('fetch failed')) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// 5xx server errors
|
||||
if (message.includes('500') ||
|
||||
message.includes('502') ||
|
||||
message.includes('503') ||
|
||||
message.includes('504')) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// Rate limits (429) are retryable
|
||||
if (message.includes('429') || message.includes('rate limit')) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if an error is NOT retryable (4xx client errors except 429)
|
||||
*
|
||||
* @param {Error} error - Error to check
|
||||
* @returns {boolean} True if error should not be retried
|
||||
*/
|
||||
export function isNonRetryableError(error) {
|
||||
const message = error.message?.toLowerCase() || '';
|
||||
|
||||
// Authentication errors (401, 403)
|
||||
if (message.includes('401') ||
|
||||
message.includes('403') ||
|
||||
message.includes('unauthorized') ||
|
||||
message.includes('forbidden')) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// Bad request (400)
|
||||
if (message.includes('400') || message.includes('bad request')) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// Not found (404)
|
||||
if (message.includes('404') || message.includes('not found')) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
export default {
|
||||
calculateBackoff,
|
||||
retryWithBackoff,
|
||||
isRetryableError,
|
||||
isNonRetryableError
|
||||
};
|
||||
583
src/webui/index.js
Normal file
583
src/webui/index.js
Normal file
@@ -0,0 +1,583 @@
|
||||
/**
|
||||
* WebUI Module - Optional web interface for account management
|
||||
*
|
||||
* This module provides a web-based UI for:
|
||||
* - Dashboard with real-time model quota visualization
|
||||
* - Account management (add via OAuth, enable/disable, refresh, remove)
|
||||
* - Live server log streaming with filtering
|
||||
* - Claude CLI configuration editor
|
||||
*
|
||||
* Usage in server.js:
|
||||
* import { mountWebUI } from './webui/index.js';
|
||||
* mountWebUI(app, __dirname, accountManager);
|
||||
*/
|
||||
|
||||
import path from 'path';
|
||||
import express from 'express';
|
||||
import { getPublicConfig, saveConfig, config } from '../config.js';
|
||||
import { DEFAULT_PORT, ACCOUNT_CONFIG_PATH } from '../constants.js';
|
||||
import { readClaudeConfig, updateClaudeConfig, getClaudeConfigPath } from '../utils/claude-config.js';
|
||||
import { logger } from '../utils/logger.js';
|
||||
import { getAuthorizationUrl, completeOAuthFlow, startCallbackServer } from '../auth/oauth.js';
|
||||
import { loadAccounts, saveAccounts } from '../account-manager/storage.js';
|
||||
|
||||
// OAuth state storage (state -> { server, verifier, state, timestamp })
|
||||
// Maps state ID to active OAuth flow data
|
||||
const pendingOAuthFlows = new Map();
|
||||
|
||||
/**
|
||||
* WebUI Helper Functions - Direct account manipulation
|
||||
* These functions work around AccountManager's limited API by directly
|
||||
* manipulating the accounts.json config file (non-invasive approach for PR)
|
||||
*/
|
||||
|
||||
/**
|
||||
* Set account enabled/disabled state
|
||||
*/
|
||||
async function setAccountEnabled(email, enabled) {
|
||||
const { accounts, settings, activeIndex } = await loadAccounts(ACCOUNT_CONFIG_PATH);
|
||||
const account = accounts.find(a => a.email === email);
|
||||
if (!account) {
|
||||
throw new Error(`Account ${email} not found`);
|
||||
}
|
||||
account.enabled = enabled;
|
||||
await saveAccounts(ACCOUNT_CONFIG_PATH, accounts, settings, activeIndex);
|
||||
logger.info(`[WebUI] Account ${email} ${enabled ? 'enabled' : 'disabled'}`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove account from config
|
||||
*/
|
||||
async function removeAccount(email) {
|
||||
const { accounts, settings, activeIndex } = await loadAccounts(ACCOUNT_CONFIG_PATH);
|
||||
const index = accounts.findIndex(a => a.email === email);
|
||||
if (index === -1) {
|
||||
throw new Error(`Account ${email} not found`);
|
||||
}
|
||||
accounts.splice(index, 1);
|
||||
// Adjust activeIndex if needed
|
||||
const newActiveIndex = activeIndex >= accounts.length ? Math.max(0, accounts.length - 1) : activeIndex;
|
||||
await saveAccounts(ACCOUNT_CONFIG_PATH, accounts, settings, newActiveIndex);
|
||||
logger.info(`[WebUI] Account ${email} removed`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add new account to config
|
||||
*/
|
||||
async function addAccount(accountData) {
|
||||
const { accounts, settings, activeIndex } = await loadAccounts(ACCOUNT_CONFIG_PATH);
|
||||
|
||||
// Check if account already exists
|
||||
const existingIndex = accounts.findIndex(a => a.email === accountData.email);
|
||||
if (existingIndex !== -1) {
|
||||
// Update existing account
|
||||
accounts[existingIndex] = {
|
||||
...accounts[existingIndex],
|
||||
...accountData,
|
||||
enabled: true,
|
||||
isInvalid: false,
|
||||
invalidReason: null,
|
||||
addedAt: accounts[existingIndex].addedAt || new Date().toISOString()
|
||||
};
|
||||
logger.info(`[WebUI] Account ${accountData.email} updated`);
|
||||
} else {
|
||||
// Add new account
|
||||
accounts.push({
|
||||
...accountData,
|
||||
enabled: true,
|
||||
isInvalid: false,
|
||||
invalidReason: null,
|
||||
modelRateLimits: {},
|
||||
lastUsed: null,
|
||||
addedAt: new Date().toISOString()
|
||||
});
|
||||
logger.info(`[WebUI] Account ${accountData.email} added`);
|
||||
}
|
||||
|
||||
await saveAccounts(ACCOUNT_CONFIG_PATH, accounts, settings, activeIndex);
|
||||
}
|
||||
|
||||
/**
|
||||
* Auth Middleware - Optional password protection for WebUI
|
||||
* Password can be set via WEBUI_PASSWORD env var or config.json
|
||||
*/
|
||||
function createAuthMiddleware() {
|
||||
return (req, res, next) => {
|
||||
const password = config.webuiPassword;
|
||||
if (!password) return next();
|
||||
|
||||
// Determine if this path should be protected
|
||||
const isApiRoute = req.path.startsWith('/api/');
|
||||
const isException = req.path === '/api/auth/url' || req.path === '/api/config';
|
||||
const isProtected = (isApiRoute && !isException) || req.path === '/account-limits' || req.path === '/health';
|
||||
|
||||
if (isProtected) {
|
||||
const providedPassword = req.headers['x-webui-password'] || req.query.password;
|
||||
if (providedPassword !== password) {
|
||||
return res.status(401).json({ status: 'error', error: 'Unauthorized: Password required' });
|
||||
}
|
||||
}
|
||||
next();
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Mount WebUI routes and middleware on Express app
|
||||
* @param {Express} app - Express application instance
|
||||
* @param {string} dirname - __dirname of the calling module (for static file path)
|
||||
* @param {AccountManager} accountManager - Account manager instance
|
||||
*/
|
||||
export function mountWebUI(app, dirname, accountManager) {
|
||||
// Apply auth middleware
|
||||
app.use(createAuthMiddleware());
|
||||
|
||||
// Serve static files from public directory
|
||||
app.use(express.static(path.join(dirname, '../public')));
|
||||
|
||||
// ==========================================
|
||||
// Account Management API
|
||||
// ==========================================
|
||||
|
||||
/**
|
||||
* GET /api/accounts - List all accounts with status
|
||||
*/
|
||||
app.get('/api/accounts', async (req, res) => {
|
||||
try {
|
||||
const status = accountManager.getStatus();
|
||||
res.json({
|
||||
status: 'ok',
|
||||
accounts: status.accounts,
|
||||
summary: {
|
||||
total: status.total,
|
||||
available: status.available,
|
||||
rateLimited: status.rateLimited,
|
||||
invalid: status.invalid
|
||||
}
|
||||
});
|
||||
} catch (error) {
|
||||
res.status(500).json({ status: 'error', error: error.message });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* POST /api/accounts/:email/refresh - Refresh specific account token
|
||||
*/
|
||||
app.post('/api/accounts/:email/refresh', async (req, res) => {
|
||||
try {
|
||||
const { email } = req.params;
|
||||
accountManager.clearTokenCache(email);
|
||||
accountManager.clearProjectCache(email);
|
||||
res.json({
|
||||
status: 'ok',
|
||||
message: `Token cache cleared for ${email}`
|
||||
});
|
||||
} catch (error) {
|
||||
res.status(500).json({ status: 'error', error: error.message });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* POST /api/accounts/:email/toggle - Enable/disable account
|
||||
*/
|
||||
app.post('/api/accounts/:email/toggle', async (req, res) => {
|
||||
try {
|
||||
const { email } = req.params;
|
||||
const { enabled } = req.body;
|
||||
|
||||
if (typeof enabled !== 'boolean') {
|
||||
return res.status(400).json({ status: 'error', error: 'enabled must be a boolean' });
|
||||
}
|
||||
|
||||
await setAccountEnabled(email, enabled);
|
||||
|
||||
// Reload AccountManager to pick up changes
|
||||
await accountManager.reload();
|
||||
|
||||
res.json({
|
||||
status: 'ok',
|
||||
message: `Account ${email} ${enabled ? 'enabled' : 'disabled'}`
|
||||
});
|
||||
} catch (error) {
|
||||
res.status(500).json({ status: 'error', error: error.message });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* DELETE /api/accounts/:email - Remove account
|
||||
*/
|
||||
app.delete('/api/accounts/:email', async (req, res) => {
|
||||
try {
|
||||
const { email } = req.params;
|
||||
await removeAccount(email);
|
||||
|
||||
// Reload AccountManager to pick up changes
|
||||
await accountManager.reload();
|
||||
|
||||
res.json({
|
||||
status: 'ok',
|
||||
message: `Account ${email} removed`
|
||||
});
|
||||
} catch (error) {
|
||||
res.status(500).json({ status: 'error', error: error.message });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* POST /api/accounts/reload - Reload accounts from disk
|
||||
*/
|
||||
app.post('/api/accounts/reload', async (req, res) => {
|
||||
try {
|
||||
// Reload AccountManager from disk
|
||||
await accountManager.reload();
|
||||
|
||||
const status = accountManager.getStatus();
|
||||
res.json({
|
||||
status: 'ok',
|
||||
message: 'Accounts reloaded from disk',
|
||||
summary: status.summary
|
||||
});
|
||||
} catch (error) {
|
||||
res.status(500).json({ status: 'error', error: error.message });
|
||||
}
|
||||
});
|
||||
|
||||
// ==========================================
|
||||
// Configuration API
|
||||
// ==========================================
|
||||
|
||||
/**
|
||||
* GET /api/config - Get server configuration
|
||||
*/
|
||||
app.get('/api/config', (req, res) => {
|
||||
try {
|
||||
const publicConfig = getPublicConfig();
|
||||
res.json({
|
||||
status: 'ok',
|
||||
config: publicConfig,
|
||||
note: 'Edit ~/.config/antigravity-proxy/config.json or use env vars to change these values'
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('[WebUI] Error getting config:', error);
|
||||
res.status(500).json({ status: 'error', error: error.message });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* POST /api/config - Update server configuration
|
||||
*/
|
||||
app.post('/api/config', (req, res) => {
|
||||
try {
|
||||
const { debug, logLevel, maxRetries, retryBaseMs, retryMaxMs, persistTokenCache, defaultCooldownMs, maxWaitBeforeErrorMs } = req.body;
|
||||
|
||||
// Only allow updating specific fields (security)
|
||||
const updates = {};
|
||||
if (typeof debug === 'boolean') updates.debug = debug;
|
||||
if (logLevel && ['info', 'warn', 'error', 'debug'].includes(logLevel)) {
|
||||
updates.logLevel = logLevel;
|
||||
}
|
||||
if (typeof maxRetries === 'number' && maxRetries >= 1 && maxRetries <= 20) {
|
||||
updates.maxRetries = maxRetries;
|
||||
}
|
||||
if (typeof retryBaseMs === 'number' && retryBaseMs >= 100 && retryBaseMs <= 10000) {
|
||||
updates.retryBaseMs = retryBaseMs;
|
||||
}
|
||||
if (typeof retryMaxMs === 'number' && retryMaxMs >= 1000 && retryMaxMs <= 120000) {
|
||||
updates.retryMaxMs = retryMaxMs;
|
||||
}
|
||||
if (typeof persistTokenCache === 'boolean') {
|
||||
updates.persistTokenCache = persistTokenCache;
|
||||
}
|
||||
if (typeof defaultCooldownMs === 'number' && defaultCooldownMs >= 1000 && defaultCooldownMs <= 300000) {
|
||||
updates.defaultCooldownMs = defaultCooldownMs;
|
||||
}
|
||||
if (typeof maxWaitBeforeErrorMs === 'number' && maxWaitBeforeErrorMs >= 0 && maxWaitBeforeErrorMs <= 600000) {
|
||||
updates.maxWaitBeforeErrorMs = maxWaitBeforeErrorMs;
|
||||
}
|
||||
|
||||
if (Object.keys(updates).length === 0) {
|
||||
return res.status(400).json({
|
||||
status: 'error',
|
||||
error: 'No valid configuration updates provided'
|
||||
});
|
||||
}
|
||||
|
||||
const success = saveConfig(updates);
|
||||
|
||||
if (success) {
|
||||
res.json({
|
||||
status: 'ok',
|
||||
message: 'Configuration saved. Restart server to apply some changes.',
|
||||
updates: updates,
|
||||
config: getPublicConfig()
|
||||
});
|
||||
} else {
|
||||
res.status(500).json({
|
||||
status: 'error',
|
||||
error: 'Failed to save configuration file'
|
||||
});
|
||||
}
|
||||
} catch (error) {
|
||||
logger.error('[WebUI] Error updating config:', error);
|
||||
res.status(500).json({ status: 'error', error: error.message });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* POST /api/config/password - Change WebUI password
|
||||
*/
|
||||
app.post('/api/config/password', (req, res) => {
|
||||
try {
|
||||
const { oldPassword, newPassword } = req.body;
|
||||
|
||||
// Validate input
|
||||
if (!newPassword || typeof newPassword !== 'string') {
|
||||
return res.status(400).json({
|
||||
status: 'error',
|
||||
error: 'New password is required'
|
||||
});
|
||||
}
|
||||
|
||||
// If current password exists, verify old password
|
||||
if (config.webuiPassword && config.webuiPassword !== oldPassword) {
|
||||
return res.status(403).json({
|
||||
status: 'error',
|
||||
error: 'Invalid current password'
|
||||
});
|
||||
}
|
||||
|
||||
// Save new password
|
||||
const success = saveConfig({ webuiPassword: newPassword });
|
||||
|
||||
if (success) {
|
||||
// Update in-memory config
|
||||
config.webuiPassword = newPassword;
|
||||
res.json({
|
||||
status: 'ok',
|
||||
message: 'Password changed successfully'
|
||||
});
|
||||
} else {
|
||||
throw new Error('Failed to save password to config file');
|
||||
}
|
||||
} catch (error) {
|
||||
logger.error('[WebUI] Error changing password:', error);
|
||||
res.status(500).json({ status: 'error', error: error.message });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* GET /api/settings - Get runtime settings
|
||||
*/
|
||||
app.get('/api/settings', async (req, res) => {
|
||||
try {
|
||||
const settings = accountManager.getSettings ? accountManager.getSettings() : {};
|
||||
res.json({
|
||||
status: 'ok',
|
||||
settings: {
|
||||
...settings,
|
||||
port: process.env.PORT || DEFAULT_PORT
|
||||
}
|
||||
});
|
||||
} catch (error) {
|
||||
res.status(500).json({ status: 'error', error: error.message });
|
||||
}
|
||||
});
|
||||
|
||||
// ==========================================
|
||||
// Claude CLI Configuration API
|
||||
// ==========================================
|
||||
|
||||
/**
|
||||
* GET /api/claude/config - Get Claude CLI configuration
|
||||
*/
|
||||
app.get('/api/claude/config', async (req, res) => {
|
||||
try {
|
||||
const claudeConfig = await readClaudeConfig();
|
||||
res.json({
|
||||
status: 'ok',
|
||||
config: claudeConfig,
|
||||
path: getClaudeConfigPath()
|
||||
});
|
||||
} catch (error) {
|
||||
res.status(500).json({ status: 'error', error: error.message });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* POST /api/claude/config - Update Claude CLI configuration
|
||||
*/
|
||||
app.post('/api/claude/config', async (req, res) => {
|
||||
try {
|
||||
const updates = req.body;
|
||||
if (!updates || typeof updates !== 'object') {
|
||||
return res.status(400).json({ status: 'error', error: 'Invalid config updates' });
|
||||
}
|
||||
|
||||
const newConfig = await updateClaudeConfig(updates);
|
||||
res.json({
|
||||
status: 'ok',
|
||||
config: newConfig,
|
||||
message: 'Claude configuration updated'
|
||||
});
|
||||
} catch (error) {
|
||||
res.status(500).json({ status: 'error', error: error.message });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* POST /api/models/config - Update model configuration (hidden/pinned/alias)
|
||||
*/
|
||||
app.post('/api/models/config', (req, res) => {
|
||||
try {
|
||||
const { modelId, config: newModelConfig } = req.body;
|
||||
|
||||
if (!modelId || typeof newModelConfig !== 'object') {
|
||||
return res.status(400).json({ status: 'error', error: 'Invalid parameters' });
|
||||
}
|
||||
|
||||
// Load current config
|
||||
const currentMapping = config.modelMapping || {};
|
||||
|
||||
// Update specific model config
|
||||
currentMapping[modelId] = {
|
||||
...currentMapping[modelId],
|
||||
...newModelConfig
|
||||
};
|
||||
|
||||
// Save back to main config
|
||||
const success = saveConfig({ modelMapping: currentMapping });
|
||||
|
||||
if (success) {
|
||||
// Update in-memory config reference
|
||||
config.modelMapping = currentMapping;
|
||||
res.json({ status: 'ok', modelConfig: currentMapping[modelId] });
|
||||
} else {
|
||||
throw new Error('Failed to save configuration');
|
||||
}
|
||||
} catch (error) {
|
||||
res.status(500).json({ status: 'error', error: error.message });
|
||||
}
|
||||
});
|
||||
|
||||
// ==========================================
|
||||
// Logs API
|
||||
// ==========================================
|
||||
|
||||
/**
|
||||
* GET /api/logs - Get log history
|
||||
*/
|
||||
app.get('/api/logs', (req, res) => {
|
||||
res.json({
|
||||
status: 'ok',
|
||||
logs: logger.getHistory ? logger.getHistory() : []
|
||||
});
|
||||
});
|
||||
|
||||
/**
|
||||
* GET /api/logs/stream - Stream logs via SSE
|
||||
*/
|
||||
app.get('/api/logs/stream', (req, res) => {
|
||||
res.setHeader('Content-Type', 'text/event-stream');
|
||||
res.setHeader('Cache-Control', 'no-cache');
|
||||
res.setHeader('Connection', 'keep-alive');
|
||||
|
||||
const sendLog = (log) => {
|
||||
res.write(`data: ${JSON.stringify(log)}\n\n`);
|
||||
};
|
||||
|
||||
// Send recent history if requested
|
||||
if (req.query.history === 'true' && logger.getHistory) {
|
||||
const history = logger.getHistory();
|
||||
history.forEach(log => sendLog(log));
|
||||
}
|
||||
|
||||
// Subscribe to new logs
|
||||
if (logger.on) {
|
||||
logger.on('log', sendLog);
|
||||
}
|
||||
|
||||
// Cleanup on disconnect
|
||||
req.on('close', () => {
|
||||
if (logger.off) {
|
||||
logger.off('log', sendLog);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// ==========================================
|
||||
// OAuth API
|
||||
// ==========================================
|
||||
|
||||
/**
|
||||
* GET /api/auth/url - Get OAuth URL to start the flow
|
||||
* Uses CLI's OAuth flow (localhost:51121) instead of WebUI's port
|
||||
* to match Google OAuth Console's authorized redirect URIs
|
||||
*/
|
||||
app.get('/api/auth/url', async (req, res) => {
|
||||
try {
|
||||
// Clean up old flows (> 10 mins)
|
||||
const now = Date.now();
|
||||
for (const [key, val] of pendingOAuthFlows.entries()) {
|
||||
if (now - val.timestamp > 10 * 60 * 1000) {
|
||||
pendingOAuthFlows.delete(key);
|
||||
}
|
||||
}
|
||||
|
||||
// Generate OAuth URL using default redirect URI (localhost:51121)
|
||||
const { url, verifier, state } = getAuthorizationUrl();
|
||||
|
||||
// Start callback server on port 51121 (same as CLI)
|
||||
const serverPromise = startCallbackServer(state, 120000); // 2 min timeout
|
||||
|
||||
// Store the flow data
|
||||
pendingOAuthFlows.set(state, {
|
||||
serverPromise,
|
||||
verifier,
|
||||
state,
|
||||
timestamp: Date.now()
|
||||
});
|
||||
|
||||
// Start async handler for the OAuth callback
|
||||
serverPromise
|
||||
.then(async (code) => {
|
||||
try {
|
||||
logger.info('[WebUI] Received OAuth callback, completing flow...');
|
||||
const accountData = await completeOAuthFlow(code, verifier);
|
||||
|
||||
// Add or update the account
|
||||
await addAccount({
|
||||
email: accountData.email,
|
||||
refreshToken: accountData.refreshToken,
|
||||
projectId: accountData.projectId,
|
||||
source: 'oauth'
|
||||
});
|
||||
|
||||
// Reload AccountManager to pick up the new account
|
||||
await accountManager.reload();
|
||||
|
||||
logger.success(`[WebUI] Account ${accountData.email} added successfully`);
|
||||
} catch (err) {
|
||||
logger.error('[WebUI] OAuth flow completion error:', err);
|
||||
} finally {
|
||||
pendingOAuthFlows.delete(state);
|
||||
}
|
||||
})
|
||||
.catch((err) => {
|
||||
logger.error('[WebUI] OAuth callback server error:', err);
|
||||
pendingOAuthFlows.delete(state);
|
||||
});
|
||||
|
||||
res.json({ status: 'ok', url });
|
||||
} catch (error) {
|
||||
logger.error('[WebUI] Error generating auth URL:', error);
|
||||
res.status(500).json({ status: 'error', error: error.message });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Note: /oauth/callback route removed
|
||||
* OAuth callbacks are now handled by the temporary server on port 51121
|
||||
* (same as CLI) to match Google OAuth Console's authorized redirect URIs
|
||||
*/
|
||||
|
||||
logger.info('[WebUI] Mounted at /');
|
||||
}
|
||||
Reference in New Issue
Block a user