opencode-studio-server 1.3.7 → 1.3.9

package/index.js

@@ -69,6 +69,159 @@ app.use(bodyParser.urlencoded({ limit: '50mb', extended: true }));
 const HOME_DIR = os.homedir();
 const STUDIO_CONFIG_PATH = path.join(HOME_DIR, '.config', 'opencode-studio', 'studio.json');
 const PENDING_ACTION_PATH = path.join(HOME_DIR, '.config', 'opencode-studio', 'pending-action.json');
+const ANTIGRAVITY_ACCOUNTS_PATH = path.join(HOME_DIR, '.config', 'opencode', 'antigravity-accounts.json');
+const LOG_DIR = path.join(HOME_DIR, '.local', 'share', 'opencode', 'log');
+
+let logWatcher = null;
+let currentLogFile = null;
+let logReadStream = null;
+
+function setupLogWatcher() {
+    if (!fs.existsSync(LOG_DIR)) return;
+
+    // Find latest log file
+    const getLatestLog = () => {
+        try {
+            const files = fs.readdirSync(LOG_DIR)
+                .filter(f => f.endsWith('.log'))
+                .map(f => ({ name: f, time: fs.statSync(path.join(LOG_DIR, f)).mtime.getTime() }))
+                .sort((a, b) => b.time - a.time);
+            return files[0] ? path.join(LOG_DIR, files[0].name) : null;
+        } catch {
+            return null;
+        }
+    };
+
+    const startTailing = (filePath) => {
+        if (currentLogFile === filePath) return;
+        if (logReadStream) logReadStream.destroy();
+        
+        currentLogFile = filePath;
+        console.log(`Watching log file: ${filePath}`);
+        
+        let fileSize = 0;
+        try {
+            fileSize = fs.statSync(filePath).size;
+        } catch {}
+
+        // Tail from end initially
+        let start = Math.max(0, fileSize - 10000); 
+        
+        const checkFile = () => {
+            try {
+                const stat = fs.statSync(filePath);
+                if (stat.size > fileSize) {
+                    const stream = fs.createReadStream(filePath, { 
+                        start: fileSize, 
+                        end: stat.size,
+                        encoding: 'utf8' 
+                    });
+                    
+                    stream.on('data', (chunk) => {
+                        const lines = chunk.split('\n');
+                        lines.forEach(processLogLine);
+                    });
+                    
+                    fileSize = stat.size;
+                }
+            } catch (e) {
+                // File might be rotated/deleted
+                if (e.code === 'ENOENT') {
+                    clearInterval(tailInterval);
+                    const newLog = getLatestLog();
+                    if (newLog && newLog !== currentLogFile) startTailing(newLog);
+                }
+            }
+        };
+
+        const tailInterval = setInterval(checkFile, 2000);
+        logWatcher = tailInterval;
+    };
+
+    const initialLog = getLatestLog();
+    if (initialLog) startTailing(initialLog);
+
+    // Watch dir for new logs
+    fs.watch(LOG_DIR, (eventType, filename) => {
+        if (filename && filename.endsWith('.log')) {
+            const latest = getLatestLog();
+            if (latest && latest !== currentLogFile) {
+                if (logWatcher) clearInterval(logWatcher);
+                startTailing(latest);
+            }
+        }
+    });
+}
+
+function processLogLine(line) {
+    // Detect LLM usage: service=llm providerID=... modelID=...
+    // Example: service=llm providerID=openai modelID=gpt-5.2-codex sessionID=...
+    const isUsage = line.includes('service=llm') && line.includes('stream');
+    const isError = line.includes('service=llm') && (line.includes('error=') || line.includes('status=429'));
+    
+    if (!isUsage && !isError) return;
+
+    const providerMatch = line.match(/providerID=([^\s]+)/);
+    const modelMatch = line.match(/modelID=([^\s]+)/);
+    
+    if (providerMatch) {
+        const provider = providerMatch[1];
+        const model = modelMatch ? modelMatch[1] : 'unknown';
+        
+        // Map provider to pool namespace
+        let namespace = provider;
+        if (provider === 'google') {
+            const activePlugin = getActiveGooglePlugin();
+            namespace = activePlugin === 'antigravity' ? 'google.antigravity' : 'google.gemini';
+        }
+
+        const metadata = loadPoolMetadata();
+        if (!metadata._quota) metadata._quota = {};
+        if (!metadata._quota[namespace]) metadata._quota[namespace] = {};
+        
+        const today = new Date().toISOString().split('T')[0];
+
+        if (isUsage) {
+            // Increment usage
+            metadata._quota[namespace][today] = (metadata._quota[namespace][today] || 0) + 1;
+            
+            // Also update active account usage if possible
+            const studio = loadStudioConfig();
+            const activeProfile = studio.activeProfiles?.[provider];
+            if (activeProfile && metadata[namespace]?.[activeProfile]) {
+                metadata[namespace][activeProfile].usageCount = (metadata[namespace][activeProfile].usageCount || 0) + 1;
+                metadata[namespace][activeProfile].lastUsed = Date.now();
+            }
+        } else if (isError) {
+            // Check for quota exhaustion patterns
+            const errorMsg = line.match(/error=(.+)/)?.[1] || '';
+            const isQuotaError = line.includes('status=429') || 
+                               errorMsg.toLowerCase().includes('quota') || 
+                               errorMsg.toLowerCase().includes('rate limit');
+                               
+            if (isQuotaError) {
+                console.log(`[LogWatcher] Detected quota exhaustion for ${namespace}`);
+                // Mark exhausted for today
+                metadata._quota[namespace].exhausted = true;
+                metadata._quota[namespace].exhaustedDate = today;
+                
+                // Adaptive limit learning: if we hit a limit, maybe that's the ceiling?
+                // Only update if we have meaningful usage (>5) to avoid false positives on glitches
+                const currentUsage = metadata._quota[namespace][today] || 0;
+                if (currentUsage > 5) {
+                    // Update daily limit to current usage (maybe round up)
+                    metadata._quota[namespace].dailyLimit = currentUsage;
+                }
+            }
+        }
+
+        savePoolMetadata(metadata);
+    }
+}
+
+// Start watcher on server start
+setupLogWatcher();
+importExistingAuth();
 
 let pendingActionMemory = null;
 
@@ -576,6 +729,7 @@ app.get('/api/auth/providers', (req, res) => {
 });
 
 app.get('/api/auth', (req, res) => {
+    syncAntigravityPool();
     const authCfg = loadAuthConfig() || {};
     const studio = loadStudioConfig();
     const ac = studio.activeProfiles || {};
@@ -646,6 +800,7 @@ app.get('/api/auth', (req, res) => {
 });
 
 app.get('/api/auth/profiles', (req, res) => {
+    syncAntigravityPool();
     const authCfg = loadAuthConfig() || {};
     const studio = loadStudioConfig();
     const ac = studio.activeProfiles || {};
@@ -798,6 +953,13 @@ app.put('/api/auth/profiles/:provider/:name', (req, res) => {
     const newPath = path.join(AUTH_PROFILES_DIR, namespace, `${newName}.json`);
     if (fs.existsSync(oldPath)) fs.renameSync(oldPath, newPath);
 
+    const metadata = loadPoolMetadata();
+    if (metadata[namespace]?.[name]) {
+        metadata[namespace][newName] = metadata[namespace][name];
+        delete metadata[namespace][name];
+        savePoolMetadata(metadata);
+    }
+
     // Update active profile name if it was the one renamed
     const studio = loadStudioConfig();
     if (studio.activeProfiles && studio.activeProfiles[provider] === name) {
@@ -913,6 +1075,10 @@ app.delete('/api/auth/:provider', (req, res) => {
         delete metadata['google.gemini'];
         delete metadata['google.antigravity'];
         savePoolMetadata(metadata);
+
+        if (activePlugin === 'antigravity' && fs.existsSync(ANTIGRAVITY_ACCOUNTS_PATH)) {
+            fs.rmSync(ANTIGRAVITY_ACCOUNTS_PATH, { force: true });
+        }
     } else {
         delete authCfg[provider];
         if (studio.activeProfiles) delete studio.activeProfiles[provider];
@@ -959,6 +1125,138 @@ function savePoolMetadata(metadata) {
     atomicWriteFileSync(POOL_METADATA_FILE, JSON.stringify(metadata, null, 2));
 }
 
+function loadAntigravityAccounts() {
+    if (!fs.existsSync(ANTIGRAVITY_ACCOUNTS_PATH)) return null;
+    try {
+        return JSON.parse(fs.readFileSync(ANTIGRAVITY_ACCOUNTS_PATH, 'utf8'));
+    } catch {
+        return null;
+    }
+}
+
+function listAntigravityAccounts() {
+    const data = loadAntigravityAccounts();
+    if (!data?.accounts || !Array.isArray(data.accounts)) return [];
+    return data.accounts.map(a => ({
+        email: a.email || null,
+        refreshToken: a.refreshToken || null
+    }));
+}
+
+function syncAntigravityPool() {
+    const accounts = listAntigravityAccounts();
+    const namespace = 'google.antigravity';
+    const profileDir = path.join(AUTH_PROFILES_DIR, namespace);
+
+    if (!accounts.length) {
+        if (fs.existsSync(profileDir)) fs.rmSync(profileDir, { recursive: true, force: true });
+        const metadata = loadPoolMetadata();
+        if (metadata[namespace]) {
+            delete metadata[namespace];
+            savePoolMetadata(metadata);
+        }
+        return;
+    }
+
+    if (!fs.existsSync(profileDir)) fs.mkdirSync(profileDir, { recursive: true });
+
+    const metadata = loadPoolMetadata();
+    if (!metadata[namespace]) metadata[namespace] = {};
+
+    const seen = new Set();
+    accounts.forEach((account, idx) => {
+        const name = account.email || `account-${idx + 1}`;
+        seen.add(name);
+        const profilePath = path.join(profileDir, `${name}.json`);
+        if (!fs.existsSync(profilePath)) {
+            atomicWriteFileSync(profilePath, JSON.stringify({ email: account.email }, null, 2));
+        }
+        if (!metadata[namespace][name]) {
+            metadata[namespace][name] = {
+                email: account.email || null,
+                createdAt: Date.now(),
+                lastUsed: 0,
+                usageCount: 0
+            };
+        }
+    });
+
+    const profileFiles = fs.existsSync(profileDir) ? fs.readdirSync(profileDir).filter(f => f.endsWith('.json')) : [];
+    profileFiles.forEach(file => {
+        const name = file.replace('.json', '');
+        if (!seen.has(name)) {
+            fs.unlinkSync(path.join(profileDir, file));
+            if (metadata[namespace]?.[name]) delete metadata[namespace][name];
+        }
+    });
+
+    savePoolMetadata(metadata);
+}
+
+function importExistingAuth() {
+    const authCfg = loadAuthConfig();
+    if (!authCfg) return;
+
+    const studio = loadStudioConfig();
+    const activeProfiles = studio.activeProfiles || {};
+    let changed = false;
+
+    // Standard providers to check
+    const providers = ['google', 'openai', 'anthropic', 'xai', 'openrouter', 'github-copilot', 'mistral', 'deepseek', 'amazon-bedrock', 'azure'];
+
+    providers.forEach(provider => {
+        if (!authCfg[provider]) return; // No creds for this provider
+
+        // Determine namespace
+        // For auto-import, we target the standard 'google' namespace unless antigravity plugin is active?
+        // Actually, auth.json 'google' key usually means Gemini/Vertex standard auth.
+        const namespace = provider === 'google' && studio.activeGooglePlugin === 'antigravity' 
+            ? 'google.antigravity' 
+            : (provider === 'google' ? 'google.gemini' : provider);
+
+        const profileDir = path.join(AUTH_PROFILES_DIR, namespace);
+        
+        // If we already have an active profile for this provider, skip import
+        if (activeProfiles[provider]) return;
+
+        // If directory exists and has files, check if empty
+        if (fs.existsSync(profileDir) && fs.readdirSync(profileDir).filter(f => f.endsWith('.json')).length > 0) {
+            return;
+        }
+
+        // Import!
+        if (!fs.existsSync(profileDir)) fs.mkdirSync(profileDir, { recursive: true });
+        
+        const email = authCfg[provider].email || null;
+        const name = email || `imported-${Date.now()}`;
+        const profilePath = path.join(profileDir, `${name}.json`);
+        
+        console.log(`[AutoImport] Importing existing ${provider} credentials as ${name}`);
+        atomicWriteFileSync(profilePath, JSON.stringify(authCfg[provider], null, 2));
+        
+        // Set as active
+        if (!studio.activeProfiles) studio.activeProfiles = {};
+        studio.activeProfiles[provider] = name;
+        changed = true;
+
+        // Update metadata
+        const metadata = loadPoolMetadata();
+        if (!metadata[namespace]) metadata[namespace] = {};
+        metadata[namespace][name] = {
+            email: email,
+            createdAt: Date.now(),
+            lastUsed: Date.now(),
+            usageCount: 0,
+            imported: true
+        };
+        savePoolMetadata(metadata);
+    });
+
+    if (changed) {
+        saveStudioConfig(studio);
+    }
+}
+
 function getAccountStatus(meta, now) {
     if (!meta) return 'ready';
     if (meta.cooldownUntil && meta.cooldownUntil > now) return 'cooldown';
@@ -1029,12 +1327,7 @@ function buildAccountPool(provider) {
     };
 }
 
-// GET /api/auth/pool - Get account pool for Google (or specified provider)
-app.get('/api/auth/pool', (req, res) => {
-    const provider = req.query.provider || 'google';
-    const pool = buildAccountPool(provider);
-    
-    // Also include quota estimate (local tracking)
+function getPoolQuota(provider, pool) {
     const metadata = loadPoolMetadata();
     const activePlugin = getActiveGooglePlugin();
     const namespace = provider === 'google'
@@ -1050,7 +1343,7 @@ app.get('/api/auth/pool', (req, res) => {
     const remaining = Math.max(0, dailyLimit - todayUsage);
     const percentage = Math.round((remaining / dailyLimit) * 100);
     
-    const quota = {
+    return {
         dailyLimit,
         remaining,
         used: todayUsage,
@@ -1063,7 +1356,14 @@ app.get('/api/auth/pool', (req, res) => {
             limit: Math.floor(dailyLimit / Math.max(1, pool.totalAccounts))
         }))
     };
-    
+}
+
+// GET /api/auth/pool - Get account pool for Google (or specified provider)
+app.get('/api/auth/pool', (req, res) => {
+    const provider = req.query.provider || 'google';
+    syncAntigravityPool();
+    const pool = buildAccountPool(provider);
+    const quota = getPoolQuota(provider, pool);
     res.json({ pool, quota });
 });
 
@@ -1143,6 +1443,31 @@ app.post('/api/auth/pool/rotate', (req, res) => {
     });
 });
 
+// POST /api/auth/pool/limit - Set daily quota limit
+app.post('/api/auth/pool/limit', (req, res) => {
+    const { provider, limit } = req.body;
+    
+    if (!provider || typeof limit !== 'number' || limit < 0) {
+        return res.status(400).json({ error: 'Invalid provider or limit' });
+    }
+
+    const activePlugin = getActiveGooglePlugin();
+    const namespace = provider === 'google'
+        ? (activePlugin === 'antigravity' ? 'google.antigravity' : 'google.gemini')
+        : provider;
+
+    const metadata = loadPoolMetadata();
+    if (!metadata._quota) metadata._quota = {};
+    if (!metadata._quota[namespace]) metadata._quota[namespace] = {};
+    
+    metadata._quota[namespace].dailyLimit = limit;
+    // Reset exhaustion if limit increased significantly? Maybe user wants to retry.
+    // For now, simple update.
+    
+    savePoolMetadata(metadata);
+    res.json({ success: true, limit });
+});
+
 // PUT /api/auth/pool/:name/cooldown - Mark account as in cooldown
 app.put('/api/auth/pool/:name/cooldown', (req, res) => {
     const { name } = req.params;
@@ -1483,6 +1808,14 @@ app.get('/api/auth/google/plugin', (req, res) => {
 
 const GEMINI_CLIENT_ID = process.env.GEMINI_CLIENT_ID || "";
 const GEMINI_CLIENT_SECRET = process.env.GEMINI_CLIENT_SECRET || "";
+
+function getGeminiClientId() {
+    if (GEMINI_CLIENT_ID) return GEMINI_CLIENT_ID;
+    const opencodeCfg = loadConfig();
+    const oauth = opencodeCfg?.mcp?.google?.oauth;
+    return oauth?.clientId || "";
+}
+
 const GEMINI_SCOPES = [
     "https://www.googleapis.com/auth/cloud-platform",
     "https://www.googleapis.com/auth/userinfo.email",
@@ -1508,14 +1841,19 @@ app.post('/api/auth/google/start', async (req, res) => {
     if (oauthCallbackServer) {
         return res.status(400).json({ error: 'OAuth flow already in progress' });
     }
-    
+
+    const clientId = getGeminiClientId();
+    if (!clientId) {
+        return res.status(400).json({ error: 'Missing Gemini OAuth client_id. Set GEMINI_CLIENT_ID or mcp.google.oauth.clientId.' });
+    }
+
     const { verifier, challenge } = generatePKCE();
     const state = encodeOAuthState({ verifier });
     
     pendingOAuthState = { verifier, status: 'pending', startedAt: Date.now() };
     
     const authUrl = new URL('https://accounts.google.com/o/oauth2/v2/auth');
-    authUrl.searchParams.set('client_id', GEMINI_CLIENT_ID);
+    authUrl.searchParams.set('client_id', clientId);
     authUrl.searchParams.set('response_type', 'code');
     authUrl.searchParams.set('redirect_uri', GEMINI_REDIRECT_URI);
     authUrl.searchParams.set('scope', GEMINI_SCOPES.join(' '));
@@ -1549,7 +1887,7 @@ app.post('/api/auth/google/start', async (req, res) => {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
                 body: new URLSearchParams({
-                    client_id: GEMINI_CLIENT_ID,
+                    client_id: clientId,
                     client_secret: GEMINI_CLIENT_SECRET,
                     code,
                     grant_type: 'authorization_code',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-studio-server",
-  "version": "1.3.7",
+  "version": "1.3.9",
   "description": "Backend server for OpenCode Studio - manages opencode configurations",
   "main": "index.js",
   "bin": {