opencode-studio-server 1.3.6 → 1.3.8

package/index.js

@@ -69,6 +69,158 @@ 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();
 
 let pendingActionMemory = null;
 
@@ -576,6 +728,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 +799,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 || {};
@@ -681,8 +835,25 @@ app.post('/api/auth/profiles/:provider', (req, res) => {
     const dir = path.join(AUTH_PROFILES_DIR, namespace);
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
     
-    const profilePath = path.join(dir, `${name || Date.now()}.json`);
+    if (!auth[provider]) {
+        return res.status(400).json({ error: 'No current auth for provider' });
+    }
+
+    const profileName = name || auth[provider].email || `profile-${Date.now()}`;
+    const profilePath = path.join(dir, `${profileName}.json`);
     atomicWriteFileSync(profilePath, JSON.stringify(auth[provider], null, 2));
+
+    const metadata = loadPoolMetadata();
+    if (!metadata[namespace]) metadata[namespace] = {};
+    metadata[namespace][profileName] = {
+        ...(metadata[namespace][profileName] || {}),
+        email: auth[provider].email || metadata[namespace][profileName]?.email || null,
+        createdAt: metadata[namespace][profileName]?.createdAt || Date.now(),
+        lastUsed: Date.now(),
+        usageCount: metadata[namespace][profileName]?.usageCount || 0
+    };
+    savePoolMetadata(metadata);
+
     res.json({ success: true, name: path.basename(profilePath, '.json') });
 });
 
@@ -714,6 +885,22 @@ app.post('/api/auth/profiles/:provider/:name/activate', (req, res) => {
     const cp = getConfigPath();
     const ap = path.join(path.dirname(cp), 'auth.json');
     atomicWriteFileSync(ap, JSON.stringify(authCfg, null, 2));
+
+    const metadata = loadPoolMetadata();
+    if (!metadata[namespace]) metadata[namespace] = {};
+    metadata[namespace][name] = {
+        ...(metadata[namespace][name] || {}),
+        email: profileData.email || metadata[namespace][name]?.email || null,
+        createdAt: metadata[namespace][name]?.createdAt || Date.now(),
+        lastUsed: Date.now(),
+        usageCount: (metadata[namespace][name]?.usageCount || 0) + 1
+    };
+    if (!metadata._quota) metadata._quota = {};
+    if (!metadata._quota[namespace]) metadata._quota[namespace] = {};
+    const today = new Date().toISOString().split('T')[0];
+    metadata._quota[namespace][today] = (metadata._quota[namespace][today] || 0) + 1;
+    savePoolMetadata(metadata);
+
     res.json({ success: true });
 });
 
@@ -726,6 +913,30 @@ app.delete('/api/auth/profiles/:provider/:name', (req, res) => {
     
     const profilePath = path.join(AUTH_PROFILES_DIR, namespace, `${name}.json`);
     if (fs.existsSync(profilePath)) fs.unlinkSync(profilePath);
+
+    const studio = loadStudioConfig();
+    if (studio.activeProfiles && studio.activeProfiles[provider] === name) {
+        delete studio.activeProfiles[provider];
+        saveStudioConfig(studio);
+
+        const authCfg = loadAuthConfig() || {};
+        delete authCfg[provider];
+        if (provider === 'google') {
+            const key = activePlugin === 'antigravity' ? 'google.antigravity' : 'google.gemini';
+            delete authCfg.google;
+            delete authCfg[key];
+        }
+        const cp = getConfigPath();
+        const ap = path.join(path.dirname(cp), 'auth.json');
+        atomicWriteFileSync(ap, JSON.stringify(authCfg, null, 2));
+    }
+
+    const metadata = loadPoolMetadata();
+    if (metadata[namespace]?.[name]) {
+        delete metadata[namespace][name];
+        savePoolMetadata(metadata);
+    }
+
     res.json({ success: true });
 });
 
@@ -741,6 +952,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) {
@@ -770,10 +988,13 @@ app.post('/api/auth/login', (req, res) => {
     let cmd = 'opencode auth login';
     if (provider) cmd += ` ${provider}`;
     
+    const cp = getConfigPath();
+    const configDir = cp ? path.dirname(cp) : process.cwd();
+    const safeDir = configDir.replace(/"/g, '\\"');
     const platform = process.platform;
     
     if (platform === 'win32') {
-        const terminalCmd = `start "" cmd /c "call ${cmd} || pause"`;
+        const terminalCmd = `start "" /d "${safeDir}" cmd /c "call ${cmd} || pause"`;
         console.log('Executing terminal command:', terminalCmd);
         exec(terminalCmd, (err) => {
             if (err) {
@@ -783,7 +1004,7 @@ app.post('/api/auth/login', (req, res) => {
             res.json({ success: true, message: 'Terminal opened', note: 'Complete login in the terminal window' });
         });
     } else if (platform === 'darwin') {
-        const terminalCmd = `osascript -e 'tell application "Terminal" to do script "${cmd}"'`;
+        const terminalCmd = `osascript -e 'tell application "Terminal" to do script "cd ${safeDir} && ${cmd}"'`;
         console.log('Executing terminal command:', terminalCmd);
         exec(terminalCmd, (err) => {
             if (err) {
@@ -794,11 +1015,11 @@ app.post('/api/auth/login', (req, res) => {
         });
     } else {
         const linuxTerminals = [
-            { name: 'x-terminal-emulator', cmd: `x-terminal-emulator -e "${cmd}"` },
-            { name: 'gnome-terminal', cmd: `gnome-terminal -- bash -c "${cmd}; read -p 'Press Enter to close...'"` },
-            { name: 'konsole', cmd: `konsole -e bash -c "${cmd}; read -p 'Press Enter to close...'"` },
-            { name: 'xfce4-terminal', cmd: `xfce4-terminal -e "bash -c \\"${cmd}; read -p 'Press Enter to close...'\\"" ` },
-            { name: 'xterm', cmd: `xterm -e "bash -c '${cmd}; read -p Press_Enter_to_close...'"` }
+            { name: 'x-terminal-emulator', cmd: `x-terminal-emulator -e "bash -c 'cd ${safeDir} && ${cmd}'"` },
+            { name: 'gnome-terminal', cmd: `gnome-terminal -- bash -c "cd ${safeDir} && ${cmd}; read -p 'Press Enter to close...'"` },
+            { name: 'konsole', cmd: `konsole -e bash -c "cd ${safeDir} && ${cmd}; read -p 'Press Enter to close...'"` },
+            { name: 'xfce4-terminal', cmd: `xfce4-terminal -e "bash -c \"cd ${safeDir} && ${cmd}; read -p 'Press Enter to close...'\"" ` },
+            { name: 'xterm', cmd: `xterm -e "bash -c 'cd ${safeDir} && ${cmd}; read -p Press_Enter_to_close...'"` }
         ];
         
         const tryTerminal = (index) => {
@@ -828,18 +1049,57 @@ app.post('/api/auth/login', (req, res) => {
     }
 });
 
+
 app.delete('/api/auth/:provider', (req, res) => {
     const { provider } = req.params;
     const authCfg = loadAuthConfig() || {};
-    delete authCfg[provider];
+    const studio = loadStudioConfig();
+    const activePlugin = studio.activeGooglePlugin;
+
+    if (provider === 'google') {
+        delete authCfg.google;
+        delete authCfg['google.gemini'];
+        delete authCfg['google.antigravity'];
+
+        if (studio.activeProfiles) delete studio.activeProfiles.google;
+        saveStudioConfig(studio);
+
+        const geminiDir = path.join(AUTH_PROFILES_DIR, 'google.gemini');
+        const antiDir = path.join(AUTH_PROFILES_DIR, 'google.antigravity');
+        [geminiDir, antiDir].forEach(dir => {
+            if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true, force: true });
+        });
+
+        const metadata = loadPoolMetadata();
+        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];
+        saveStudioConfig(studio);
+
+        const providerDir = path.join(AUTH_PROFILES_DIR, provider);
+        if (fs.existsSync(providerDir)) fs.rmSync(providerDir, { recursive: true, force: true });
+
+        const metadata = loadPoolMetadata();
+        delete metadata[provider];
+        savePoolMetadata(metadata);
+    }
+
+    if (provider === 'google' && activePlugin) {
+        const key = activePlugin === 'antigravity' ? 'google.antigravity' : 'google.gemini';
+        delete authCfg[key];
+    }
+
     const cp = getConfigPath();
     const ap = path.join(path.dirname(cp), 'auth.json');
     atomicWriteFileSync(ap, JSON.stringify(authCfg, null, 2));
-    
-    const studio = loadStudioConfig();
-    if (studio.activeProfiles) delete studio.activeProfiles[provider];
-    saveStudioConfig(studio);
-    
+
     res.json({ success: true });
 });
 
@@ -864,6 +1124,74 @@ 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 getAccountStatus(meta, now) {
     if (!meta) return 'ready';
     if (meta.cooldownUntil && meta.cooldownUntil > now) return 'cooldown';
@@ -892,11 +1220,18 @@ function buildAccountPool(provider) {
         files.forEach(file => {
             const name = file.replace('.json', '');
             const meta = providerMeta[name] || {};
-            const status = name === activeProfile ? 'active' : getAccountStatus(meta, now);
+            let profileEmail = null;
+            try {
+                const raw = fs.readFileSync(path.join(profileDir, file), 'utf8');
+                const parsed = JSON.parse(raw);
+                profileEmail = parsed?.email || null;
+            } catch {}
+            let status = getAccountStatus(meta, now);
+            if (name === activeProfile && status === 'ready') status = 'active';
             
             profiles.push({
                 name,
-                email: meta.email || null,
+                email: meta.email || profileEmail || null,
                 status,
                 lastUsed: meta.lastUsed || 0,
                 usageCount: meta.usageCount || 0,
@@ -927,12 +1262,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'
@@ -948,7 +1278,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,
@@ -961,7 +1291,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 });
 });
 
@@ -1022,8 +1359,15 @@ app.post('/api/auth/pool/rotate', (req, res) => {
     if (!metadata[namespace]) metadata[namespace] = {};
     metadata[namespace][next.name] = {
         ...metadata[namespace][next.name],
-        lastUsed: now
+        lastUsed: now,
+        usageCount: (metadata[namespace][next.name]?.usageCount || 0) + 1
     };
+
+    if (!metadata._quota) metadata._quota = {};
+    if (!metadata._quota[namespace]) metadata._quota[namespace] = {};
+    const today = new Date().toISOString().split('T')[0];
+    metadata._quota[namespace][today] = (metadata._quota[namespace][today] || 0) + 1;
+
     savePoolMetadata(metadata);
     
     res.json({
@@ -1034,6 +1378,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;
@@ -1374,6 +1743,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",
@@ -1399,14 +1776,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(' '));
@@ -1440,7 +1822,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',
@@ -1471,8 +1853,8 @@ app.post('/api/auth/google/start', async (req, res) => {
             const ap = path.join(path.dirname(cp), 'auth.json');
             const authCfg = fs.existsSync(ap) ? JSON.parse(fs.readFileSync(ap, 'utf8')) : {};
             
-            const studio = loadStudioConfig();
-            const activePlugin = studio.activeGooglePlugin || 'gemini';
+            const studioConfig = loadStudioConfig();
+            const activePlugin = studioConfig.activeGooglePlugin || 'gemini';
             const namespace = activePlugin === 'antigravity' ? 'google.antigravity' : 'google.gemini';
             
             const credentials = {
@@ -1486,6 +1868,27 @@ app.post('/api/auth/google/start', async (req, res) => {
             authCfg[namespace] = credentials;
             
             atomicWriteFileSync(ap, JSON.stringify(authCfg, null, 2));
+
+            const profileDir = path.join(AUTH_PROFILES_DIR, namespace);
+            if (!fs.existsSync(profileDir)) fs.mkdirSync(profileDir, { recursive: true });
+            const profileName = email || `google-${Date.now()}`;
+            const profilePath = path.join(profileDir, `${profileName}.json`);
+            atomicWriteFileSync(profilePath, JSON.stringify(credentials, null, 2));
+
+            const metadata = loadPoolMetadata();
+            if (!metadata[namespace]) metadata[namespace] = {};
+            metadata[namespace][profileName] = {
+                ...(metadata[namespace][profileName] || {}),
+                email: email || null,
+                createdAt: metadata[namespace][profileName]?.createdAt || Date.now(),
+                lastUsed: Date.now(),
+                usageCount: metadata[namespace][profileName]?.usageCount || 0
+            };
+            savePoolMetadata(metadata);
+
+            if (!studioConfig.activeProfiles) studioConfig.activeProfiles = {};
+            studioConfig.activeProfiles.google = profileName;
+            saveStudioConfig(studioConfig);
             
             pendingOAuthState = { ...pendingOAuthState, status: 'success', email };
             

package/package.json

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