opencode-studio-server 1.1.3 → 1.2.1

package/index.js

@@ -4,17 +4,15 @@ const bodyParser = require('body-parser');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { exec, spawn } = require('child_process');
+const { spawn, exec } = require('child_process');
 
 const app = express();
 const PORT = 3001;
 const IDLE_TIMEOUT_MS = 30 * 60 * 1000; 
 
-let lastActivityTime = Date.now();
 let idleTimer = null;
 
 function resetIdleTimer() {
-    lastActivityTime = Date.now();
     if (idleTimer) clearTimeout(idleTimer);
     idleTimer = setTimeout(() => {
         console.log('Server idle for 30 minutes, shutting down...');
@@ -59,22 +57,155 @@ const PENDING_ACTION_PATH = path.join(HOME_DIR, '.config', 'opencode-studio', 'p
 let pendingActionMemory = null;
 
 function loadStudioConfig() {
-    if (!fs.existsSync(STUDIO_CONFIG_PATH)) {
-        return {};
-    }
+    const defaultConfig = {
+        disabledSkills: [],
+        disabledPlugins: [],
+        activeProfiles: {},
+        activeGooglePlugin: 'gemini',
+        availableGooglePlugins: [],
+        pluginModels: {
+            gemini: {
+                "gemini-3-pro-preview": {
+                    "id": "gemini-3-pro-preview",
+                    "name": "3 Pro (Gemini CLI)",
+                    "reasoning": true,
+                    "options": { "thinkingConfig": { "thinkingLevel": "high", "includeThoughts": true } }
+                },
+                "gemini-2.5-flash": {
+                    "id": "gemini-2.5-flash",
+                    "name": "2.5 Flash (Gemini CLI)",
+                    "reasoning": true,
+                    "options": { "thinkingConfig": { "thinkingBudget": 8192, "includeThoughts": true } }
+                },
+                "gemini-2.0-flash": {
+                    "id": "gemini-2.0-flash",
+                    "name": "2.0 Flash (Free)",
+                    "reasoning": false
+                },
+                "gemini-1.5-flash": {
+                    "id": "gemini-1.5-flash",
+                    "name": "1.5 Flash (Free)",
+                    "reasoning": false
+                }
+            },
+            antigravity: {
+                "gemini-3-pro-preview": {
+                    "id": "gemini-3-pro-preview",
+                    "name": "3 Pro",
+                    "release_date": "2025-11-18",
+                    "reasoning": true,
+                    "limit": { "context": 1000000, "output": 64000 },
+                    "cost": { "input": 2, "output": 12, "cache_read": 0.2 },
+                    "modalities": {
+                        "input": ["text", "image", "video", "audio", "pdf"],
+                        "output": ["text"]
+                    },
+                    "variants": {
+                        "low": { "options": { "thinkingConfig": { "thinkingLevel": "low", "includeThoughts": true } } },
+                        "medium": { "options": { "thinkingConfig": { "thinkingLevel": "medium", "includeThoughts": true } } },
+                        "high": { "options": { "thinkingConfig": { "thinkingLevel": "high", "includeThoughts": true } } }
+                    }
+                },
+                "gemini-3-flash": {
+                    "id": "gemini-3-flash",
+                    "name": "3 Flash",
+                    "release_date": "2025-12-17",
+                    "reasoning": true,
+                    "limit": { "context": 1048576, "output": 65536 },
+                    "cost": { "input": 0.5, "output": 3, "cache_read": 0.05 },
+                    "modalities": {
+                        "input": ["text", "image", "video", "audio", "pdf"],
+                        "output": ["text"]
+                    },
+                    "variants": {
+                        "minimal": { "options": { "thinkingConfig": { "thinkingLevel": "minimal", "includeThoughts": true } } },
+                        "low": { "options": { "thinkingConfig": { "thinkingLevel": "low", "includeThoughts": true } } },
+                        "medium": { "options": { "thinkingConfig": { "thinkingLevel": "medium", "includeThoughts": true } } },
+                        "high": { "options": { "thinkingConfig": { "thinkingLevel": "high", "includeThoughts": true } } }
+                    }
+                },
+                "gemini-2.5-flash-lite": {
+                    "id": "gemini-2.5-flash-lite",
+                    "name": "2.5 Flash Lite",
+                    "reasoning": false
+                },
+                "google/gemini-3-flash": {
+                    "id": "google/gemini-3-flash",
+                    "name": "3 Flash (Google)",
+                    "reasoning": true,
+                    "limit": { "context": 1048576, "output": 65536 },
+                    "cost": { "input": 0.5, "output": 3, "cache_read": 0.05 },
+                    "modalities": {
+                        "input": ["text", "image", "video", "audio", "pdf"],
+                        "output": ["text"]
+                    },
+                    "variants": {
+                        "minimal": { "options": { "thinkingConfig": { "thinkingLevel": "minimal", "includeThoughts": true } } },
+                        "low": { "options": { "thinkingConfig": { "thinkingLevel": "low", "includeThoughts": true } } },
+                        "medium": { "options": { "thinkingConfig": { "thinkingLevel": "medium", "includeThoughts": true } } },
+                        "high": { "options": { "thinkingConfig": { "thinkingLevel": "high", "includeThoughts": true } } }
+                    }
+                },
+                "opencode/glm-4.7-free": {
+                    "id": "opencode/glm-4.7-free",
+                    "name": "GLM 4.7 Free",
+                    "reasoning": false,
+                    "limit": { "context": 128000, "output": 4096 },
+                    "cost": { "input": 0, "output": 0 },
+                    "modalities": {
+                        "input": ["text"],
+                        "output": ["text"]
+                    }
+                },
+                "gemini-claude-sonnet-4-5-thinking": {
+                    "id": "gemini-claude-sonnet-4-5-thinking",
+                    "name": "Sonnet 4.5",
+                    "reasoning": true,
+                    "limit": { "context": 200000, "output": 64000 },
+                    "modalities": {
+                        "input": ["text", "image", "pdf"],
+                        "output": ["text"]
+                    },
+                    "variants": {
+                        "none": { "reasoning": false, "options": { "thinkingConfig": { "includeThoughts": false } } },
+                        "low": { "options": { "thinkingConfig": { "thinkingBudget": 4000, "includeThoughts": true } } },
+                        "medium": { "options": { "thinkingConfig": { "thinkingBudget": 16000, "includeThoughts": true } } },
+                        "high": { "options": { "thinkingConfig": { "thinkingBudget": 32000, "includeThoughts": true } } }
+                    }
+                },
+                "gemini-claude-opus-4-5-thinking": {
+                    "id": "gemini-claude-opus-4-5-thinking",
+                    "name": "Opus 4.5",
+                    "release_date": "2025-11-24",
+                    "reasoning": true,
+                    "limit": { "context": 200000, "output": 64000 },
+                    "modalities": {
+                        "input": ["text", "image", "pdf"],
+                        "output": ["text"]
+                    },
+                    "variants": {
+                        "low": { "options": { "thinkingConfig": { "thinkingBudget": 4000, "includeThoughts": true } } },
+                        "medium": { "options": { "thinkingConfig": { "thinkingBudget": 16000, "includeThoughts": true } } },
+                        "high": { "options": { "thinkingConfig": { "thinkingBudget": 32000, "includeThoughts": true } } }
+                    }
+                }
+            }
+        }
+    };
+
+    if (!fs.existsSync(STUDIO_CONFIG_PATH)) return defaultConfig;
     try {
-        return JSON.parse(fs.readFileSync(STUDIO_CONFIG_PATH, 'utf8'));
+        const config = JSON.parse(fs.readFileSync(STUDIO_CONFIG_PATH, 'utf8'));
+        return { ...defaultConfig, ...config };
     } catch {
-        return {};
+        return defaultConfig;
     }
 }
 
 function saveStudioConfig(config) {
     try {
         const dir = path.dirname(STUDIO_CONFIG_PATH);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
         fs.writeFileSync(STUDIO_CONFIG_PATH, JSON.stringify(config, null, 2), 'utf8');
         return true;
     } catch (err) {
@@ -83,55 +214,16 @@ function saveStudioConfig(config) {
     }
 }
 
-function loadPendingAction() {
-    if (pendingActionMemory) return pendingActionMemory;
-    
-    if (fs.existsSync(PENDING_ACTION_PATH)) {
-        try {
-            const action = JSON.parse(fs.readFileSync(PENDING_ACTION_PATH, 'utf8'));
-            if (action.timestamp && Date.now() - action.timestamp < 60000) {
-                pendingActionMemory = action;
-                fs.unlinkSync(PENDING_ACTION_PATH);
-                return action;
-            }
-            fs.unlinkSync(PENDING_ACTION_PATH);
-        } catch {
-            try { fs.unlinkSync(PENDING_ACTION_PATH); } catch {}
-        }
-    }
-    return null;
-}
-
-app.get('/api/pending-action', (req, res) => {
-    const action = loadPendingAction();
-    res.json({ action });
-});
-
-app.delete('/api/pending-action', (req, res) => {
-    pendingActionMemory = null;
-    if (fs.existsSync(PENDING_ACTION_PATH)) {
-        try { fs.unlinkSync(PENDING_ACTION_PATH); } catch {}
-    }
-    res.json({ success: true });
-});
-
 const getPaths = () => {
     const platform = process.platform;
     const home = os.homedir();
-    
-    let candidates = [];
+    let candidates = [
+        path.join(home, '.config', 'opencode', 'opencode.json'),
+        path.join(home, '.local', 'share', 'opencode', 'opencode.json'),
+        path.join(home, '.opencode', 'opencode.json'),
+    ];
     if (platform === 'win32') {
-        candidates = [
-            path.join(process.env.APPDATA, 'opencode', 'opencode.json'),
-            path.join(home, '.config', 'opencode', 'opencode.json'),
-            path.join(home, '.local', 'share', 'opencode', 'opencode.json'),
-        ];
-    } else {
-        candidates = [
-            path.join(home, '.config', 'opencode', 'opencode.json'),
-            path.join(home, '.opencode', 'opencode.json'),
-            path.join(home, '.local', 'share', 'opencode', 'opencode.json'),
-        ];
+        candidates.push(path.join(process.env.APPDATA, 'opencode', 'opencode.json'));
     }
 
     const studioConfig = loadStudioConfig();
@@ -149,22 +241,22 @@ const getPaths = () => {
         detected,
         manual: manualPath,
         current: manualPath || detected,
-        candidates
+        candidates: [...new Set(candidates)]
     };
 };
 
-const getConfigPath = () => {
-    const paths = getPaths();
-    return paths.current;
-};
+const getConfigPath = () => getPaths().current;
 
 const loadConfig = () => {
     const configPath = getConfigPath();
-    if (!configPath || !fs.existsSync(configPath)) {
-        return null;
-    }
+    if (!configPath || !fs.existsSync(configPath)) return null;
     try {
-        return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        const studioConfig = loadStudioConfig();
+        if (studioConfig.activeGooglePlugin === 'antigravity' && !config.small_model) {
+            config.small_model = "google/gemini-3-flash";
+        }
+        return config;
     } catch {
         return null;
     }
@@ -172,28 +264,20 @@ const loadConfig = () => {
 
 const saveConfig = (config) => {
     const configPath = getConfigPath();
-    if (!configPath) {
-        throw new Error('No config path found');
-    }
+    if (!configPath) throw new Error('No config path found');
     const dir = path.dirname(configPath);
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
 };
 
-app.get('/api/health', (req, res) => {
-    res.json({ status: 'ok' });
-});
+app.get('/api/health', (req, res) => res.json({ status: 'ok' }));
 
 app.post('/api/shutdown', (req, res) => {
     res.json({ success: true });
     setTimeout(() => process.exit(0), 100);
 });
 
-app.get('/api/paths', (req, res) => {
-    res.json(getPaths());
-});
+app.get('/api/paths', (req, res) => res.json(getPaths()));
 
 app.post('/api/paths', (req, res) => {
     const { configPath } = req.body;
@@ -205,16 +289,13 @@ app.post('/api/paths', (req, res) => {
 
 app.get('/api/config', (req, res) => {
     const config = loadConfig();
-    if (!config) {
-        return res.status(404).json({ error: 'Config not found' });
-    }
+    if (!config) return res.status(404).json({ error: 'Config not found' });
     res.json(config);
 });
 
 app.post('/api/config', (req, res) => {
-    const config = req.body;
     try {
-        saveConfig(config);
+        saveConfig(req.body);
         res.json({ success: true });
     } catch (err) {
         res.status(500).json({ error: err.message });
@@ -222,905 +303,609 @@ app.post('/api/config', (req, res) => {
 });
 
 const getSkillDir = () => {
-    const configPath = getConfigPath();
-    if (!configPath) return null;
-    return path.join(path.dirname(configPath), 'skill');
+    const cp = getConfigPath();
+    return cp ? path.join(path.dirname(cp), 'skill') : null;
 };
 
 app.get('/api/skills', (req, res) => {
-    const skillDir = getSkillDir();
-    if (!skillDir || !fs.existsSync(skillDir)) {
-        return res.json([]);
-    }
-    
-    const skills = [];
-    const entries = fs.readdirSync(skillDir, { withFileTypes: true });
-    
-    for (const entry of entries) {
-        if (entry.isDirectory()) {
-            const skillPath = path.join(skillDir, entry.name, 'SKILL.md');
-            if (fs.existsSync(skillPath)) {
-                skills.push({
-                    name: entry.name,
-                    path: skillPath,
-                    enabled: !entry.name.endsWith('.disabled')
-                });
-            }
-        }
-    }
+    const sd = getSkillDir();
+    if (!sd || !fs.existsSync(sd)) return res.json([]);
+    const skills = fs.readdirSync(sd, { withFileTypes: true })
+        .filter(e => e.isDirectory() && fs.existsSync(path.join(sd, e.name, 'SKILL.md')))
+        .map(e => ({ name: e.name, path: path.join(sd, e.name, 'SKILL.md'), enabled: !e.name.endsWith('.disabled') }));
     res.json(skills);
 });
 
 app.get('/api/skills/:name', (req, res) => {
-    const skillDir = getSkillDir();
-    if (!skillDir) return res.status(404).json({ error: 'No config' });
-    
-    const name = req.params.name;
-    const skillPath = path.join(skillDir, name, 'SKILL.md');
-    
-    if (!fs.existsSync(skillPath)) {
-        return res.status(404).json({ error: 'Skill not found' });
-    }
-    
-    const content = fs.readFileSync(skillPath, 'utf8');
-    res.json({ name, content });
+    const sd = getSkillDir();
+    const p = sd ? path.join(sd, req.params.name, 'SKILL.md') : null;
+    if (!p || !fs.existsSync(p)) return res.status(404).json({ error: 'Not found' });
+    res.json({ name: req.params.name, content: fs.readFileSync(p, 'utf8') });
 });
 
 app.post('/api/skills/:name', (req, res) => {
-    const skillDir = getSkillDir();
-    if (!skillDir) return res.status(404).json({ error: 'No config' });
-    
-    const name = req.params.name;
-    const { content } = req.body;
-    const dirPath = path.join(skillDir, name);
-    
-    if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true });
-    }
-    
-    fs.writeFileSync(path.join(dirPath, 'SKILL.md'), content, 'utf8');
+    const sd = getSkillDir();
+    if (!sd) return res.status(404).json({ error: 'No config' });
+    const dp = path.join(sd, req.params.name);
+    if (!fs.existsSync(dp)) fs.mkdirSync(dp, { recursive: true });
+    fs.writeFileSync(path.join(dp, 'SKILL.md'), req.body.content, 'utf8');
     res.json({ success: true });
 });
 
 app.delete('/api/skills/:name', (req, res) => {
-    const skillDir = getSkillDir();
-    if (!skillDir) return res.status(404).json({ error: 'No config' });
-    
-    const name = req.params.name;
-    const dirPath = path.join(skillDir, name);
-    
-    if (fs.existsSync(dirPath)) {
-        fs.rmSync(dirPath, { recursive: true, force: true });
-    }
+    const sd = getSkillDir();
+    const dp = sd ? path.join(sd, req.params.name) : null;
+    if (dp && fs.existsSync(dp)) fs.rmSync(dp, { recursive: true, force: true });
     res.json({ success: true });
 });
 
-app.post('/api/skills/:name/toggle', (req, res) => {
-    res.json({ success: true, enabled: true }); 
-});
-
 const getPluginDir = () => {
-    const configPath = getConfigPath();
-    if (!configPath) return null;
-    return path.join(path.dirname(configPath), 'plugin');
+    const cp = getConfigPath();
+    return cp ? path.join(path.dirname(cp), 'plugin') : null;
 };
 
 app.get('/api/plugins', (req, res) => {
-    const pluginDir = getPluginDir();
-    const configPath = getConfigPath();
-    const configRoot = configPath ? path.dirname(configPath) : null;
-    
+    const pd = getPluginDir();
+    const cp = getConfigPath();
+    const cr = cp ? path.dirname(cp) : null;
     const plugins = [];
-    
-    const addPlugin = (name, p, enabled = true) => {
-        if (!plugins.some(pl => pl.name === name)) {
-            plugins.push({ name, path: p, enabled });
-        }
+    const add = (name, p, enabled = true) => {
+        if (!plugins.some(pl => pl.name === name)) plugins.push({ name, path: p, enabled });
     };
 
-    if (pluginDir && fs.existsSync(pluginDir)) {
-        const entries = fs.readdirSync(pluginDir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path.join(pluginDir, entry.name);
-            const stats = fs.lstatSync(fullPath);
-            if (stats.isDirectory()) {
-                const jsPath = path.join(fullPath, 'index.js');
-                const tsPath = path.join(fullPath, 'index.ts');
-                if (fs.existsSync(jsPath) || fs.existsSync(tsPath)) {
-                    addPlugin(entry.name, fs.existsSync(jsPath) ? jsPath : tsPath);
-                }
-            } else if ((stats.isFile() || stats.isSymbolicLink()) && (entry.name.endsWith('.js') || entry.name.endsWith('.ts'))) {
-                addPlugin(entry.name.replace(/\.(js|ts)$/, ''), fullPath);
+    if (pd && fs.existsSync(pd)) {
+        fs.readdirSync(pd, { withFileTypes: true }).forEach(e => {
+            const fp = path.join(pd, e.name);
+            const st = fs.lstatSync(fp);
+            if (st.isDirectory()) {
+                const j = path.join(fp, 'index.js'), t = path.join(fp, 'index.ts');
+                if (fs.existsSync(j) || fs.existsSync(t)) add(e.name, fs.existsSync(j) ? j : t);
+            } else if ((st.isFile() || st.isSymbolicLink()) && /\.(js|ts)$/.test(e.name)) {
+                add(e.name.replace(/\.(js|ts)$/, ''), fp);
             }
-        }
+        });
     }
 
-    if (configRoot && fs.existsSync(configRoot)) {
-        const rootEntries = fs.readdirSync(configRoot, { withFileTypes: true });
-        const knownPlugins = ['oh-my-opencode', 'superpowers', 'opencode-gemini-auth'];
-        
-        for (const entry of rootEntries) {
-            if (knownPlugins.includes(entry.name) && entry.isDirectory()) {
-                const fullPath = path.join(configRoot, entry.name);
-                addPlugin(entry.name, fullPath);
-            }
-        }
+    if (cr && fs.existsSync(cr)) {
+        ['oh-my-opencode', 'superpowers', 'opencode-gemini-auth'].forEach(n => {
+            const fp = path.join(cr, n);
+            if (fs.existsSync(fp) && fs.statSync(fp).isDirectory()) add(n, fp);
+        });
     }
 
+    const cfg = loadConfig();
+    if (cfg && Array.isArray(cfg.plugin)) {
+        cfg.plugin.forEach(n => {
+            if (!n.includes('/') && !n.includes('\\') && !/\.(js|ts)$/.test(n)) add(n, 'npm');
+        });
+    }
     res.json(plugins);
 });
 
-app.get('/api/plugins/:name', (req, res) => {
-    const pluginDir = getPluginDir();
-    if (!pluginDir) return res.status(404).json({ error: 'No config' });
-    
-    const name = req.params.name;
-    const dirPath = path.join(pluginDir, name);
-    
-    let content = '';
-    let filename = '';
-    
-    if (fs.existsSync(path.join(dirPath, 'index.js'))) {
-        content = fs.readFileSync(path.join(dirPath, 'index.js'), 'utf8');
-        filename = 'index.js';
-    } else if (fs.existsSync(path.join(dirPath, 'index.ts'))) {
-        content = fs.readFileSync(path.join(dirPath, 'index.ts'), 'utf8');
-        filename = 'index.ts';
-    } else if (fs.existsSync(path.join(pluginDir, name + '.js'))) {
-        content = fs.readFileSync(path.join(pluginDir, name + '.js'), 'utf8');
-        filename = name + '.js';
-    } else if (fs.existsSync(path.join(pluginDir, name + '.ts'))) {
-        content = fs.readFileSync(path.join(pluginDir, name + '.ts'), 'utf8');
-        filename = name + '.ts';
-    } else {
-        return res.status(404).json({ error: 'Plugin not found' });
-    }
-    
-    res.json({ name, content, filename });
-});
+const getActiveGooglePlugin = () => {
+    const studio = loadStudioConfig();
+    return studio.activeGooglePlugin || null;
+};
 
-app.post('/api/plugins/:name', (req, res) => {
-    const pluginDir = getPluginDir();
-    if (!pluginDir) return res.status(404).json({ error: 'No config' });
-    
-    const name = req.params.name;
-    const { content } = req.body;
-    const dirPath = path.join(pluginDir, name);
-    
-    if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true });
-    }
+function loadAuthConfig() {
+    const paths = getPaths();
+    const allAuthConfigs = [];
     
-    const filePath = path.join(dirPath, 'index.js');
-    fs.writeFileSync(filePath, content, 'utf8');
-    res.json({ success: true });
-});
+    // Check all candidate directories for auth.json
+    paths.candidates.forEach(p => {
+        const ap = path.join(path.dirname(p), 'auth.json');
+        if (fs.existsSync(ap)) {
+            try {
+                allAuthConfigs.push(JSON.parse(fs.readFileSync(ap, 'utf8')));
+            } catch {}
+        }
+    });
 
-app.delete('/api/plugins/:name', (req, res) => {
-    const pluginDir = getPluginDir();
-    if (!pluginDir) return res.status(404).json({ error: 'No config' });
-    
-    const name = req.params.name;
-    const dirPath = path.join(pluginDir, name);
-    
-    if (fs.existsSync(dirPath)) {
-        fs.rmSync(dirPath, { recursive: true, force: true });
-    } else if (fs.existsSync(path.join(pluginDir, name + '.js'))) {
-        fs.unlinkSync(path.join(pluginDir, name + '.js'));
-    } else if (fs.existsSync(path.join(pluginDir, name + '.ts'))) {
-        fs.unlinkSync(path.join(pluginDir, name + '.ts'));
+    // Also check current active directory if not in candidates
+    if (paths.current) {
+        const ap = path.join(path.dirname(paths.current), 'auth.json');
+        if (fs.existsSync(ap)) {
+            try {
+                allAuthConfigs.push(JSON.parse(fs.readFileSync(ap, 'utf8')));
+            } catch {}
+        }
     }
-    res.json({ success: true });
-});
 
-app.post('/api/plugins/:name/toggle', (req, res) => {
-    res.json({ success: true, enabled: true });
-});
+    if (allAuthConfigs.length === 0) return null;
 
-app.post('/api/fetch-url', async (req, res) => {
-    const { url } = req.body;
-    if (!url) return res.status(400).json({ error: 'URL required' });
+    // Merge all configs, later ones (priority) overwrite earlier ones
+    const cfg = Object.assign({}, ...allAuthConfigs);
     
-    try {
-        const fetch = (await import('node-fetch')).default;
-        const response = await fetch(url);
-        if (!response.ok) throw new Error(`Failed to fetch: ${response.statusText}`);
-        const content = await response.text();
-        const filename = path.basename(new URL(url).pathname) || 'file.txt';
+    try { 
+        const activePlugin = getActiveGooglePlugin();
         
-        res.json({ content, filename, url });
-    } catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-
-app.post('/api/bulk-fetch', async (req, res) => {
-    const { urls } = req.body;
-    if (!Array.isArray(urls)) return res.status(400).json({ error: 'URLs array required' });
-    
-    const fetch = (await import('node-fetch')).default;
-    const results = [];
-    
-    for (const url of urls) {
-        try {
-            const response = await fetch(url);
-            if (!response.ok) throw new Error(`Failed to fetch: ${response.statusText}`);
-            const content = await response.text();
-            const filename = path.basename(new URL(url).pathname) || 'file.txt';
-            
-            results.push({
-                url,
-                success: true,
-                content,
-                filename,
-                name: filename.replace(/\.(md|js|ts)$/, ''),
-            });
-        } catch (err) {
-            results.push({
-                url,
-                success: false,
-                error: err.message
-            });
+        // Find if any google auth exists in any merged config
+        const anyGoogleAuth = cfg.google || cfg['google.gemini'] || cfg['google.antigravity'];
+        
+        if (anyGoogleAuth) {
+            // Ensure all 3 keys have at least some valid google auth data
+            const baseAuth = cfg.google || cfg['google.antigravity'] || cfg['google.gemini'];
+            if (!cfg.google) cfg.google = { ...baseAuth };
+            if (!cfg['google.antigravity']) cfg['google.antigravity'] = { ...baseAuth };
+            if (!cfg['google.gemini']) cfg['google.gemini'] = { ...baseAuth };
         }
-    }
-    
-    res.json({ results });
-});
 
-app.get('/api/backup', (req, res) => {
-    const studioConfig = loadStudioConfig();
-    const opencodeConfig = loadConfig();
-    
-    const skills = [];
-    const skillDir = getSkillDir();
-    if (skillDir && fs.existsSync(skillDir)) {
-        const entries = fs.readdirSync(skillDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                const p = path.join(skillDir, entry.name, 'SKILL.md');
-                if (fs.existsSync(p)) {
-                    skills.push({ name: entry.name, content: fs.readFileSync(p, 'utf8') });
-                }
-            }
-        }
-    }
-    
-    const plugins = [];
-    const pluginDir = getPluginDir();
-    if (pluginDir && fs.existsSync(pluginDir)) {
-        const entries = fs.readdirSync(pluginDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                const p = path.join(pluginDir, entry.name, 'index.js');
-                if (fs.existsSync(p)) {
-                    plugins.push({ name: entry.name, content: fs.readFileSync(p, 'utf8') });
-                }
-            }
+        // Always ensure the main 'google' key reflects the active plugin if it exists
+        if (activePlugin === 'antigravity' && cfg['google.antigravity']) {
+            cfg.google = { ...cfg['google.antigravity'] };
+        } else if (activePlugin === 'gemini' && cfg['google.gemini']) {
+            cfg.google = { ...cfg['google.gemini'] };
         }
-    }
-    
-    res.json({
-        version: 1,
-        timestamp: new Date().toISOString(),
-        studioConfig,
-        opencodeConfig,
-        skills,
-        plugins
-    });
-});
+        
+        return cfg;
+    } catch { return cfg; }
+}
 
-app.post('/api/restore', (req, res) => {
-    const backup = req.body;
-    
-    if (backup.studioConfig) {
-        saveStudioConfig(backup.studioConfig);
-    }
-    
-    if (backup.opencodeConfig) {
-        saveConfig(backup.opencodeConfig);
-    }
-    
-    if (Array.isArray(backup.skills)) {
-        const skillDir = getSkillDir();
-        if (skillDir) {
-            if (!fs.existsSync(skillDir)) fs.mkdirSync(skillDir, { recursive: true });
-            for (const skill of backup.skills) {
-                const dir = path.join(skillDir, skill.name);
-                if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-                fs.writeFileSync(path.join(dir, 'SKILL.md'), skill.content, 'utf8');
-            }
-        }
-    }
-    
-    if (Array.isArray(backup.plugins)) {
-        const pluginDir = getPluginDir();
-        if (pluginDir) {
-            if (!fs.existsSync(pluginDir)) fs.mkdirSync(pluginDir, { recursive: true });
-            for (const plugin of backup.plugins) {
-                const dir = path.join(pluginDir, plugin.name);
-                if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-                fs.writeFileSync(path.join(dir, 'index.js'), plugin.content, 'utf8');
-            }
-        }
+const AUTH_PROFILES_DIR = path.join(HOME_DIR, '.config', 'opencode-studio', 'auth-profiles');
+const listAuthProfiles = (p, activePlugin) => {
+    let ns = p;
+    if (p === 'google') {
+        ns = activePlugin === 'antigravity' ? 'google.antigravity' : 'google.gemini';
     }
     
-    res.json({ success: true });
-});
+    const d = path.join(AUTH_PROFILES_DIR, ns);
+    if (!fs.existsSync(d)) return [];
+    try { return fs.readdirSync(d).filter(f => f.endsWith('.json')).map(f => f.replace('.json', '')); } catch { return []; }
+};
 
-function loadAuthConfig() {
-    const configPath = getConfigPath();
-    if (!configPath) return null;
-    
-    const authPath = path.join(path.dirname(configPath), 'auth.json');
-    if (!fs.existsSync(authPath)) return null;
-    try {
-        return JSON.parse(fs.readFileSync(authPath, 'utf8'));
-    } catch {
-        return null;
-    }
-}
+app.get('/api/auth/providers', (req, res) => {
+    const providers = [
+        { id: 'google', name: 'Google', type: 'oauth', description: 'Google Gemini API' },
+        { id: 'anthropic', name: 'Anthropic', type: 'api', description: 'Claude models' },
+        { id: 'openai', name: 'OpenAI', type: 'api', description: 'GPT models' },
+        { id: 'xai', name: 'xAI', type: 'api', description: 'Grok models' },
+        { id: 'openrouter', name: 'OpenRouter', type: 'api', description: 'Unified LLM API' },
+        { id: 'github-copilot', name: 'GitHub Copilot', type: 'api', description: 'Copilot models' }
+    ];
+    res.json(providers);
+});
 
 app.get('/api/auth', (req, res) => {
-    const authConfig = loadAuthConfig() || {};
-    const activeProfiles = getActiveProfiles();
-    
+    const authCfg = loadAuthConfig() || {};
+    const studio = loadStudioConfig();
+    const ac = studio.activeProfiles || {};
     const credentials = [];
+    const activePlugin = studio.activeGooglePlugin;
+    
+    // DEBUG LOGGING
+    console.log('--- Auth Debug ---');
+    console.log('Active Google Plugin:', activePlugin);
+    console.log('Found keys in authCfg:', Object.keys(authCfg));
+    if (authCfg.google) console.log('Google Auth found!');
+    if (authCfg['google.antigravity']) console.log('google.antigravity found!');
+    if (authCfg['google.gemini']) console.log('google.gemini found!');
+    
     const providers = [
-        { id: 'google', name: 'Google AI', type: 'oauth' },
+        { id: 'google', name: 'Google', type: 'oauth' },
         { id: 'anthropic', name: 'Anthropic', type: 'api' },
         { id: 'openai', name: 'OpenAI', type: 'api' },
         { id: 'xai', name: 'xAI', type: 'api' },
-        { id: 'groq', name: 'Groq', type: 'api' },
-        { id: 'together', name: 'Together AI', type: 'api' },
-        { id: 'mistral', name: 'Mistral', type: 'api' },
-        { id: 'deepseek', name: 'DeepSeek', type: 'api' },
         { id: 'openrouter', name: 'OpenRouter', type: 'api' },
-        { id: 'amazon-bedrock', name: 'Amazon Bedrock', type: 'api' },
-        { id: 'azure', name: 'Azure OpenAI', type: 'api' },
         { id: 'github-copilot', name: 'GitHub Copilot', type: 'api' }
     ];
 
+    const opencodeCfg = loadConfig();
+    const currentPlugins = opencodeCfg?.plugin || [];
+    
+    let studioChanged = false;
+    if (!studio.availableGooglePlugins) studio.availableGooglePlugins = [];
+    
+    if (currentPlugins.some(p => p.includes('gemini-auth')) && !studio.availableGooglePlugins.includes('gemini')) {
+        studio.availableGooglePlugins.push('gemini');
+        studioChanged = true;
+    }
+    if (currentPlugins.some(p => p.includes('antigravity-auth')) && !studio.availableGooglePlugins.includes('antigravity')) {
+        studio.availableGooglePlugins.push('antigravity');
+        studioChanged = true;
+    }
+
+    const geminiProfiles = path.join(AUTH_PROFILES_DIR, 'google.gemini');
+    const antiProfiles = path.join(AUTH_PROFILES_DIR, 'google.antigravity');
+    
+    if (fs.existsSync(geminiProfiles) && !studio.availableGooglePlugins.includes('gemini')) {
+        studio.availableGooglePlugins.push('gemini');
+        studioChanged = true;
+    }
+    if (fs.existsSync(antiProfiles) && !studio.availableGooglePlugins.includes('antigravity')) {
+        studio.availableGooglePlugins.push('antigravity');
+        studioChanged = true;
+    }
+    
+    if (studioChanged) saveStudioConfig(studio);
+
     providers.forEach(p => {
-        const profileInfo = listAuthProfiles(p.id);
-        const hasCurrent = !!authConfig[p.id];
-        const hasProfiles = profileInfo.length > 0;
-
-        if (hasCurrent || hasProfiles) {
-            credentials.push({
-                ...p,
-                active: activeProfiles[p.id] || (hasCurrent ? 'current' : null)
-            });
+        const saved = listAuthProfiles(p.id, activePlugin);
+        let curr = !!authCfg[p.id];
+        if (p.id === 'google') {
+            const key = activePlugin === 'antigravity' ? 'google.antigravity' : 'google.gemini';
+            curr = !!authCfg[key] || !!authCfg.google;
         }
+        credentials.push({ ...p, active: ac[p.id] || (curr ? 'current' : null), profiles: saved, hasCurrentAuth: curr });
     });
-
-    res.json({
-        ...authConfig,
-        credentials,
-        authFile: path.join(path.dirname(getConfigPath() || ''), 'auth.json'),
-        hasGeminiAuthPlugin: true 
+    res.json({ 
+        ...authCfg, 
+        credentials, 
+        installedGooglePlugins: studio.availableGooglePlugins || [], 
+        activeGooglePlugin: activePlugin 
     });
 });
 
-app.post('/api/auth/login', (req, res) => {
-    const { provider } = req.body;
-    const cmd = process.platform === 'win32' ? 'opencode.cmd' : 'opencode';
+app.get('/api/auth/profiles', (req, res) => {
+    const authCfg = loadAuthConfig() || {};
+    const studio = loadStudioConfig();
+    const ac = studio.activeProfiles || {};
+    const activePlugin = studio.activeGooglePlugin;
+    const profiles = {};
+    const providers = ['google', 'anthropic', 'openai', 'xai', 'openrouter', 'together', 'mistral', 'deepseek', 'amazon-bedrock', 'azure', 'github-copilot'];
     
-    const child = spawn(cmd, ['auth', 'login', provider], {
-        stdio: 'inherit',
-        shell: true
+    providers.forEach(p => {
+        const saved = listAuthProfiles(p, activePlugin);
+        // Correct current auth check: handle google vs google.gemini/antigravity
+        let curr = !!authCfg[p];
+        if (p === 'google') {
+            const key = activePlugin === 'antigravity' ? 'google.antigravity' : 'google.gemini';
+            curr = !!authCfg[key] || !!authCfg.google;
+        }
+        
+        if (saved.length > 0 || curr) {
+            profiles[p] = { active: ac[p], profiles: saved, hasCurrentAuth: !!curr };
+        }
     });
-    
-    res.json({ success: true, message: 'Launched auth flow', note: 'Please check the terminal window where the server is running' });
+    res.json(profiles);
 });
 
-app.delete('/api/auth/:provider', (req, res) => {
+app.post('/api/auth/profiles/:provider', (req, res) => {
     const { provider } = req.params;
-    const cmd = process.platform === 'win32' ? 'opencode.cmd' : 'opencode';
+    const { name } = req.body;
+    const activePlugin = getActiveGooglePlugin();
+    const namespace = provider === 'google' 
+        ? (activePlugin === 'antigravity' ? 'google.antigravity' : 'google.gemini')
+        : provider;
     
-    spawn(cmd, ['auth', 'logout', provider], {
-        stdio: 'inherit',
-        shell: true
-    });
+    const auth = loadAuthConfig() || {};
+    const dir = path.join(AUTH_PROFILES_DIR, namespace);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
     
-    res.json({ success: true });
-});
-
-app.get('/api/auth/providers', (req, res) => {
-    const providers = [
-        { id: 'google', name: 'Google AI', type: 'oauth', description: 'Use Google Gemini models' },
-        { id: 'anthropic', name: 'Anthropic', type: 'api', description: 'Use Claude models' },
-        { id: 'openai', name: 'OpenAI', type: 'api', description: 'Use GPT models' },
-        { id: 'xai', name: 'xAI', type: 'api', description: 'Use Grok models' },
-        { id: 'groq', name: 'Groq', type: 'api', description: 'Fast inference' },
-        { id: 'together', name: 'Together AI', type: 'api', description: 'Open source models' },
-        { id: 'mistral', name: 'Mistral', type: 'api', description: 'Mistral models' },
-        { id: 'deepseek', name: 'DeepSeek', type: 'api', description: 'DeepSeek models' },
-        { id: 'openrouter', name: 'OpenRouter', type: 'api', description: 'Multiple providers' },
-        { id: 'amazon-bedrock', name: 'Amazon Bedrock', type: 'api', description: 'AWS models' },
-        { id: 'azure', name: 'Azure OpenAI', type: 'api', description: 'Azure GPT models' },
-    ];
-    res.json(providers);
+    const profilePath = path.join(dir, `${name || Date.now()}.json`);
+    fs.writeFileSync(profilePath, JSON.stringify(auth[provider], null, 2), 'utf8');
+    res.json({ success: true, name: path.basename(profilePath, '.json') });
 });
 
-const AUTH_PROFILES_DIR = path.join(HOME_DIR, '.config', 'opencode-studio', 'auth-profiles');
-
-function ensureAuthProfilesDir() {
-    if (!fs.existsSync(AUTH_PROFILES_DIR)) {
-        fs.mkdirSync(AUTH_PROFILES_DIR, { recursive: true });
-    }
-}
-
-function getProviderProfilesDir(provider) {
-    return path.join(AUTH_PROFILES_DIR, provider);
-}
-
-function listAuthProfiles(provider) {
-    const dir = getProviderProfilesDir(provider);
-    if (!fs.existsSync(dir)) return [];
+app.post('/api/auth/profiles/:provider/:name/activate', (req, res) => {
+    const { provider, name } = req.params;
+    const activePlugin = getActiveGooglePlugin();
+    const namespace = provider === 'google' 
+        ? (activePlugin === 'antigravity' ? 'google.antigravity' : 'google.gemini')
+        : provider;
     
-    try {
-        return fs.readdirSync(dir)
-            .filter(f => f.endsWith('.json'))
-            .map(f => f.replace('.json', ''));
-    } catch {
-        return [];
-    }
-}
-
-function getNextProfileName(provider) {
-    const existing = listAuthProfiles(provider);
-    let num = 1;
-    while (existing.includes(`account-${num}`)) {
-        num++;
+    const profilePath = path.join(AUTH_PROFILES_DIR, namespace, `${name}.json`);
+    if (!fs.existsSync(profilePath)) return res.status(404).json({ error: 'Profile not found' });
+    
+    const profileData = JSON.parse(fs.readFileSync(profilePath, 'utf8'));
+    const studio = loadStudioConfig();
+    if (!studio.activeProfiles) studio.activeProfiles = {};
+    studio.activeProfiles[provider] = name;
+    saveStudioConfig(studio);
+    
+    const authCfg = loadAuthConfig() || {};
+    authCfg[provider] = profileData;
+    
+    // Save both to persistent namespaced key and the shared 'google' key
+    if (provider === 'google') {
+        const key = activePlugin === 'antigravity' ? 'google.antigravity' : 'google.gemini';
+        authCfg[key] = profileData;
     }
-    return `account-${num}`;
-}
+    
+    const cp = getConfigPath();
+    const ap = path.join(path.dirname(cp), 'auth.json');
+    fs.writeFileSync(ap, JSON.stringify(authCfg, null, 2), 'utf8');
+    res.json({ success: true });
+});
 
-function saveAuthProfile(provider, profileName, data) {
-    ensureAuthProfilesDir();
-    const dir = getProviderProfilesDir(provider);
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-    const filePath = path.join(dir, `${profileName}.json`);
-    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
-    return true;
-}
+app.delete('/api/auth/profiles/:provider/:name', (req, res) => {
+    const { provider, name } = req.params;
+    const activePlugin = getActiveGooglePlugin();
+    const namespace = provider === 'google' 
+        ? (activePlugin === 'antigravity' ? 'google.antigravity' : 'google.gemini')
+        : provider;
+    
+    const profilePath = path.join(AUTH_PROFILES_DIR, namespace, `${name}.json`);
+    if (fs.existsSync(profilePath)) fs.unlinkSync(profilePath);
+    res.json({ success: true });
+});
 
-function loadAuthProfile(provider, profileName) {
-    const filePath = path.join(getProviderProfilesDir(provider), `${profileName}.json`);
-    if (!fs.existsSync(filePath)) return null;
-    try {
-        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    } catch {
-        return null;
-    }
-}
+app.put('/api/auth/profiles/:provider/:name', (req, res) => {
+    const { provider, name } = req.params;
+    const { newName } = req.body;
+    const activePlugin = getActiveGooglePlugin();
+    const namespace = provider === 'google' 
+        ? (activePlugin === 'antigravity' ? 'google.antigravity' : 'google.gemini')
+        : provider;
+    
+    const oldPath = path.join(AUTH_PROFILES_DIR, namespace, `${name}.json`);
+    const newPath = path.join(AUTH_PROFILES_DIR, namespace, `${newName}.json`);
+    if (fs.existsSync(oldPath)) fs.renameSync(oldPath, newPath);
 
-function deleteAuthProfile(provider, profileName) {
-    const filePath = path.join(getProviderProfilesDir(provider), `${profileName}.json`);
-    if (fs.existsSync(filePath)) {
-        fs.unlinkSync(filePath);
-        return true;
+    // Update active profile name if it was the one renamed
+    const studio = loadStudioConfig();
+    if (studio.activeProfiles && studio.activeProfiles[provider] === name) {
+        studio.activeProfiles[provider] = newName;
+        saveStudioConfig(studio);
     }
-    return false;
-}
-
-function getActiveProfiles() {
-    const studioConfig = loadStudioConfig();
-    return studioConfig.activeProfiles || {};
-}
 
-function setActiveProfile(provider, profileName) {
-    const studioConfig = loadStudioConfig();
-    studioConfig.activeProfiles = studioConfig.activeProfiles || {};
-    studioConfig.activeProfiles[provider] = profileName;
-    saveStudioConfig(studioConfig);
-}
-
-function verifyActiveProfile(p, n, c) { console.log("Verifying:", p, n); if (!n || !c) return false; const d = loadAuthProfile(p, n); if (d && c) { console.log("Profile refresh:", d.refresh); console.log("Current refresh:", c.refresh); } if (!d) return false; return JSON.stringify(d) === JSON.stringify(c); }
+    res.json({ success: true, name: newName });
+});
 
-app.get('/api/auth/profiles', (req, res) => {
-    ensureAuthProfilesDir();
-    const activeProfiles = getActiveProfiles();
-    const authConfig = loadAuthConfig() || {};
+app.post('/api/auth/login', (req, res) => {
+    let { provider } = req.body;
+    if (typeof provider !== 'string') provider = "";
     
-    const profiles = {};
+    let cmd = 'opencode auth login';
+    if (provider) cmd += ` ${provider}`;
     
-    const savedProviders = fs.existsSync(AUTH_PROFILES_DIR) ? fs.readdirSync(AUTH_PROFILES_DIR) : [];
+    const platform = process.platform;
+    let terminalCmd;
+    if (platform === 'win32') {
+        terminalCmd = `start "" cmd /c "call ${cmd} || pause"`;
+    } else if (platform === 'darwin') {
+        terminalCmd = `osascript -e 'tell application "Terminal" to do script "${cmd}"'`;
+    } else {
+        terminalCmd = `x-terminal-emulator -e "${cmd}"`;
+    }
     
-    const standardProviders = [
-        'google', 'anthropic', 'openai', 'xai', 'groq', 
-        'together', 'mistral', 'deepseek', 'openrouter', 
-        'amazon-bedrock', 'azure', 'github-copilot'
-    ];
-
-    const allProviders = [...new Set([...savedProviders, ...standardProviders])];
-
-    allProviders.forEach(p => {
-        const saved = listAuthProfiles(p);
-        const active = activeProfiles[p];
-        const current = authConfig[p];
-
-        if (saved.length > 0 || current) {
-            profiles[p] = {
-                active: active,
-                profiles: saved, 
-                saved: saved,
-                hasCurrent: !!current,
-                hasCurrentAuth: !!current
-            };
+    console.log('Executing terminal command:', terminalCmd);
+    
+    exec(terminalCmd, (err) => {
+        if (err) {
+            console.error('Failed to open terminal:', err);
+            return res.status(500).json({ error: 'Failed to open terminal', details: err.message });
         }
+        res.json({ success: true, message: 'Terminal opened', note: 'Complete login in the terminal window' });
     });
-    
-    res.json(profiles);
 });
 
-app.get('/api/debug/paths', (req, res) => {
-    const home = os.homedir();
-    const candidatePaths = [
-        process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'opencode', 'storage', 'message') : null,
-        path.join(home, '.local', 'share', 'opencode', 'storage', 'message'),
-        path.join(home, '.opencode', 'storage', 'message')
-    ].filter(p => p);
-
-    const results = candidatePaths.map(p => ({
-        path: p,
-        exists: fs.existsSync(p),
-        isDirectory: fs.existsSync(p) && fs.statSync(p).isDirectory(),
-        fileCount: (fs.existsSync(p) && fs.statSync(p).isDirectory()) ? fs.readdirSync(p).length : 0
-    }));
-
-    res.json({
-        home,
-        platform: process.platform,
-        candidates: results
-    });
+app.delete('/api/auth/:provider', (req, res) => {
+    const { provider } = req.params;
+    const authCfg = loadAuthConfig() || {};
+    delete authCfg[provider];
+    const cp = getConfigPath();
+    const ap = path.join(path.dirname(cp), 'auth.json');
+    fs.writeFileSync(ap, JSON.stringify(authCfg, null, 2), 'utf8');
+    
+    const studio = loadStudioConfig();
+    if (studio.activeProfiles) delete studio.activeProfiles[provider];
+    saveStudioConfig(studio);
+    
+    res.json({ success: true });
 });
 
 app.get('/api/usage', async (req, res) => {
     try {
-        const { projectId: filterProjectId, granularity = 'daily', range = '30d' } = req.query;
+        const {projectId: fid, granularity = 'daily', range = '30d'} = req.query;
+        const cp = getConfigPath();
+        if (!cp) return res.json({ totalCost: 0, totalTokens: 0, byModel: [], byDay: [], byProject: [] });
+        
         const home = os.homedir();
-        const candidatePaths = [
-            process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'opencode', 'storage', 'message') : null,
-            path.join(home, '.local', 'share', 'opencode', 'storage', 'message'),
-            path.join(home, '.opencode', 'storage', 'message')
-        ].filter(p => p && fs.existsSync(p));
-
-        const getSessionDir = (messageDir) => {
-            return path.join(path.dirname(messageDir), 'session');
-        };
+        const dataCandidates = [
+            path.dirname(cp),
+            path.join(home, '.local', 'share', 'opencode'),
+            path.join(home, '.opencode'),
+            process.env.APPDATA ? path.join(process.env.APPDATA, 'opencode') : null,
+            path.join(home, 'AppData', 'Local', 'opencode')
+        ].filter(Boolean);
+
+        let md = null;
+        let sd = null;
+
+        for (const d of dataCandidates) {
+            const mdp = path.join(d, 'storage', 'message');
+            const sdp = path.join(d, 'storage', 'session');
+            if (fs.existsSync(mdp)) {
+                md = mdp;
+                sd = sdp;
+                break;
+            }
+        }
 
-        const sessionProjectMap = new Map();
+        if (!md) return res.json({ totalCost: 0, totalTokens: 0, byModel: [], byDay: [], byProject: [] });
 
-        const loadProjects = (messageDir) => {
-            const sessionDir = getSessionDir(messageDir);
-            if (!fs.existsSync(sessionDir)) return;
 
-            try {
-                const projectDirs = fs.readdirSync(sessionDir);
-                
-                for (const projDir of projectDirs) {
-                    const fullProjPath = path.join(sessionDir, projDir);
-                    if (!fs.statSync(fullProjPath).isDirectory()) continue;
-
-                    const files = fs.readdirSync(fullProjPath);
-                    for (const file of files) {
-                        if (file.startsWith('ses_') && file.endsWith('.json')) {
-                            const sessionId = file.replace('.json', '');
+        const pmap = new Map();
+        if (fs.existsSync(sd)) {
+            fs.readdirSync(sd).forEach(d => {
+                const fp = path.join(sd, d);
+                if (fs.statSync(fp).isDirectory()) {
+                    fs.readdirSync(fp).forEach(f => {
+                        if (f.startsWith('ses_') && f.endsWith('.json')) {
                             try {
-                                const meta = JSON.parse(fs.readFileSync(path.join(fullProjPath, file), 'utf8'));
-                                let projectName = 'Unknown Project';
-                                if (meta.directory) {
-                                    projectName = path.basename(meta.directory);
-                                } else if (meta.projectID) {
-                                    projectName = meta.projectID.substring(0, 8);
-                                }
-                                sessionProjectMap.set(sessionId, { name: projectName, id: meta.projectID || projDir });
-                            } catch (e) {}
+                                const m = JSON.parse(fs.readFileSync(path.join(fp, f), 'utf8'));
+                                pmap.set(f.replace('.json', ''), { name: m.directory ? path.basename(m.directory) : (m.projectID ? m.projectID.substring(0, 8) : 'Unknown'), id: m.projectID || d });
+                            } catch {}
                         }
-                    }
+                    });
                 }
-            } catch (e) {
-                console.error('Error loading projects:', e);
-            }
-        };
-
-        for (const logDir of candidatePaths) {
-            loadProjects(logDir);
+            });
         }
 
-        const stats = {
-            totalCost: 0,
-            totalTokens: 0,
-            byModel: {},
-            byTime: {}, 
-            byProject: {} 
-        };
-
-        const processedFiles = new Set();
+        const stats = { totalCost: 0, totalTokens: 0, byModel: {}, byTime: {}, byProject: {} };
+        const seen = new Set();
         const now = Date.now();
-        let minTimestamp = 0;
-        
-        if (range === '24h') minTimestamp = now - 24 * 60 * 60 * 1000;
-        else if (range === '7d') minTimestamp = now - 7 * 24 * 60 * 60 * 1000;
-        else if (range === '30d') minTimestamp = now - 30 * 24 * 60 * 60 * 1000;
-
-        const processMessage = (filePath, sessionId) => {
-            if (processedFiles.has(filePath)) return;
-            processedFiles.add(filePath);
-
-            try {
-                const content = fs.readFileSync(filePath, 'utf8');
-                const msg = JSON.parse(content);
-                
-                const model = msg.modelID || (msg.model && (msg.model.modelID || msg.model.id)) || 'unknown';
-                const projectInfo = sessionProjectMap.get(sessionId) || { name: 'Unassigned', id: 'unknown' };
-                const projectId = projectInfo.id || 'unknown';
-
-                if (filterProjectId && filterProjectId !== 'all' && projectId !== filterProjectId) {
-                    return;
-                }
-
-                if (minTimestamp > 0 && msg.time.created < minTimestamp) {
-                    return;
-                }
-                
-                if (msg.role === 'assistant' && msg.tokens) {
-                    const cost = msg.cost || 0;
-                    const inputTokens = msg.tokens.input || 0;
-                    const outputTokens = msg.tokens.output || 0;
-                    const tokens = inputTokens + outputTokens;
-                    
-                    const timestamp = msg.time.created;
-                    const dateObj = new Date(timestamp);
-                    let timeKey;
-                    
-                    if (granularity === 'hourly') {
-                        timeKey = dateObj.toISOString().substring(0, 13) + ':00:00Z';
-                    } else if (granularity === 'weekly') {
-                        const day = dateObj.getDay();
-                        const diff = dateObj.getDate() - day + (day === 0 ? -6 : 1);
-                        const monday = new Date(dateObj.setDate(diff));
-                        timeKey = monday.toISOString().split('T')[0];
-                    } else if (granularity === 'monthly') {
-                        timeKey = dateObj.toISOString().substring(0, 7) + '-01';
-                    } else {
-                        timeKey = dateObj.toISOString().split('T')[0];
-                    }
-
-                    if (tokens > 0) {
-                        stats.totalCost += cost;
-                        stats.totalTokens += tokens;
-
-                        if (!stats.byModel[model]) {
-                            stats.byModel[model] = { name: model, cost: 0, tokens: 0, inputTokens: 0, outputTokens: 0 };
-                        }
-                        stats.byModel[model].cost += cost;
-                        stats.byModel[model].tokens += tokens;
-                        stats.byModel[model].inputTokens += inputTokens;
-                        stats.byModel[model].outputTokens += outputTokens;
-
-                        if (!stats.byTime[timeKey]) {
-                            stats.byTime[timeKey] = { date: timeKey, cost: 0, tokens: 0, inputTokens: 0, outputTokens: 0 };
-                        }
-                        stats.byTime[timeKey].cost += cost;
-                        stats.byTime[timeKey].tokens += tokens;
-                        stats.byTime[timeKey].inputTokens += inputTokens;
-                        stats.byTime[timeKey].outputTokens += outputTokens;
-
-                        const projectName = projectInfo.name;
-                        if (!stats.byProject[projectId]) {
-                            stats.byProject[projectId] = { id: projectId, name: projectName, cost: 0, tokens: 0, inputTokens: 0, outputTokens: 0 };
-                        }
-                        stats.byProject[projectId].cost += cost;
-                        stats.byProject[projectId].tokens += tokens;
-                        stats.byProject[projectId].inputTokens += inputTokens;
-                        stats.byProject[projectId].outputTokens += outputTokens;
-                    }
-                }
-            } catch (err) {
-            }
-        };
-
-        for (const logDir of candidatePaths) {
-            try {
-                const sessions = fs.readdirSync(logDir);
-                for (const session of sessions) {
-                    if (!session.startsWith('ses_')) continue;
-                    
-                    const sessionDir = path.join(logDir, session);
-                    if (fs.statSync(sessionDir).isDirectory()) {
-                        const messages = fs.readdirSync(sessionDir);
-                        for (const msgFile of messages) {
-                            if (msgFile.endsWith('.json')) {
-                                processMessage(path.join(sessionDir, msgFile), session);
-                            }
+        let min = 0;
+        if (range === '24h') min = now - 86400000;
+        else if (range === '7d') min = now - 604800000;
+        else if (range === '30d') min = now - 2592000000;
+        else if (range === '1y') min = now - 31536000000;
+
+        fs.readdirSync(md).forEach(s => {
+            if (!s.startsWith('ses_')) return;
+            const sp = path.join(md, s);
+            if (fs.statSync(sp).isDirectory()) {
+                fs.readdirSync(sp).forEach(f => {
+                    if (!f.endsWith('.json') || seen.has(path.join(sp, f))) return;
+                    seen.add(path.join(sp, f));
+                    try {
+                        const msg = JSON.parse(fs.readFileSync(path.join(sp, f), 'utf8'));
+                        const pid = pmap.get(s)?.id || 'unknown';
+                        if (fid && fid !== 'all' && pid !== fid) return;
+                        if (min > 0 && msg.time.created < min) return;
+                        if (msg.role === 'assistant' && msg.tokens) {
+                            const c = msg.cost || 0, it = msg.tokens.input || 0, ot = msg.tokens.output || 0, t = it + ot;
+                            const d = new Date(msg.time.created);
+                            let tk;
+                            if (granularity === 'hourly') tk = d.toISOString().substring(0, 13) + ':00:00Z';
+                            else if (granularity === 'weekly') {
+                                const day = d.getDay(), diff = d.getDate() - day + (day === 0 ? -6 : 1);
+                                tk = new Date(d.setDate(diff)).toISOString().split('T')[0];
+                            } else if (granularity === 'monthly') tk = d.toISOString().substring(0, 7) + '-01';
+                            else tk = d.toISOString().split('T')[0];
+
+                            const mid = msg.modelID || (msg.model && (msg.model.modelID || msg.model.id)) || 'unknown';
+                            stats.totalCost += c; stats.totalTokens += t;
+                            [stats.byModel, stats.byProject].forEach((obj, i) => {
+                                const key = i === 0 ? mid : pid;
+                                if (!obj[key]) obj[key] = { name: key, id: key, cost: 0, tokens: 0, inputTokens: 0, outputTokens: 0 };
+                                if (i === 1) obj[key].name = pmap.get(s)?.name || 'Unassigned';
+                                obj[key].cost += c; obj[key].tokens += t; obj[key].inputTokens += it; obj[key].outputTokens += ot;
+                            });
+
+                            if (!stats.byTime[tk]) stats.byTime[tk] = { date: tk, name: tk, id: tk, cost: 0, tokens: 0, inputTokens: 0, outputTokens: 0 };
+                            const te = stats.byTime[tk];
+                            te.cost += c; te.tokens += t; te.inputTokens += it; te.outputTokens += ot;
+                            if (!te[mid]) te[mid] = 0;
+                            te[mid] += c;
+                            
+                            const kIn = `${mid}_input`, kOut = `${mid}_output`;
+                            te[kIn] = (te[kIn] || 0) + it;
+                            te[kOut] = (te[kOut] || 0) + ot;
                         }
-                    }
-                }
-            } catch (err) {
-                console.error(`Error reading log dir ${logDir}:`, err);
+                    } catch {}
+                });
             }
-        }
+        });
 
-        const response = {
+        res.json({
             totalCost: stats.totalCost,
             totalTokens: stats.totalTokens,
             byModel: Object.values(stats.byModel).sort((a, b) => b.cost - a.cost),
-            byDay: Object.values(stats.byTime).sort((a, b) => a.date.localeCompare(b.date)),
+            byDay: Object.values(stats.byTime).sort((a, b) => a.name.localeCompare(b.name)).map(v => ({ ...v, date: v.name })),
             byProject: Object.values(stats.byProject).sort((a, b) => b.cost - a.cost)
-        };
-
-        res.json(response);
+        });
     } catch (error) {
-        console.error('Error fetching usage stats:', error);
-        res.status(500).json({ error: 'Failed to fetch usage stats' });
+        res.status(500).json({ error: 'Failed' });
     }
 });
 
-app.get('/api/auth/profiles/:provider', (req, res) => {
-    const { provider } = req.params;
-    const providerProfiles = listAuthProfiles(provider);
-    const activeProfiles = getActiveProfiles();
-    const authConfig = loadAuthConfig() || {};
-    
-    res.json({
-        profiles: providerProfiles,
-        active: (activeProfiles[provider] && verifyActiveProfile(provider, activeProfiles[provider], authConfig[provider])) ? activeProfiles[provider] : null,
-        hasCurrentAuth: !!authConfig[provider],
-    });
-});
-
-app.post('/api/auth/profiles/:provider', (req, res) => {
-    const { provider } = req.params;
-    const { name } = req.body;
-    
-    const authConfig = loadAuthConfig();
-    if (!authConfig || !authConfig[provider]) {
-        return res.status(400).json({ error: `No active auth for ${provider} to save` });
-    }
-    
-    const profileName = name || getNextProfileName(provider);
-    const data = authConfig[provider];
+app.post('/api/auth/google/plugin', (req, res) => {
+    const { plugin } = req.body;
+    const studio = loadStudioConfig();
+    studio.activeGooglePlugin = plugin;
+    saveStudioConfig(studio);
     
     try {
-        saveAuthProfile(provider, profileName, data);
-        setActiveProfile(provider, profileName);
-        res.json({ success: true, name: profileName });
-    } catch (err) {
-        res.status(500).json({ error: 'Failed to save profile', details: err.message });
-    }
-});
+        const opencode = loadConfig();
+        if (opencode) {
+            if (opencode.provider?.google) {
+                const models = studio.pluginModels[plugin];
+                if (models) {
+                    opencode.provider.google.models = models;
+                }
+            }
 
-app.post('/api/auth/profiles/:provider/:name/activate', (req, res) => {
-    const { provider, name } = req.params;
-    
-    const profileData = loadAuthProfile(provider, name);
-    if (!profileData) {
-        return res.status(404).json({ error: 'Profile not found' });
-    }
-    
-    const authConfig = loadAuthConfig() || {};
-    authConfig[provider] = profileData;
-    
-    const configPath = getConfigPath();
-    if (configPath) {
-        const authPath = path.join(path.dirname(configPath), 'auth.json');
-        try {
-            fs.writeFileSync(authPath, JSON.stringify(authConfig, null, 2), 'utf8');
-            setActiveProfile(provider, name);
-            res.json({ success: true });
-        } catch (err) {
-            res.status(500).json({ error: 'Failed to write auth config', details: err.message });
+            if (!opencode.plugin) opencode.plugin = [];
+            const geminiPlugin = 'opencode-gemini-auth@latest';
+            const antigravityPlugin = 'opencode-google-antigravity-auth';
+            
+            opencode.plugin = opencode.plugin.filter(p => 
+                !p.includes('gemini-auth') && 
+                !p.includes('antigravity-auth')
+            );
+            
+            if (plugin === 'gemini') {
+                opencode.plugin.push(geminiPlugin);
+            } else if (plugin === 'antigravity') {
+                opencode.plugin.push(antigravityPlugin);
+            }
+            
+            saveConfig(opencode);
         }
-    } else {
-        res.status(500).json({ error: 'Config path not found' });
-    }
-});
 
-app.delete('/api/auth/profiles/:provider/:name', (req, res) => {
-    const { provider, name } = req.params;
-    const success = deleteAuthProfile(provider, name);
-    if (success) {
-        const activeProfiles = getActiveProfiles();
-        if (activeProfiles[provider] === name) {
-            const studioConfig = loadStudioConfig();
-            if (studioConfig.activeProfiles) {
-                delete studioConfig.activeProfiles[provider];
-                saveStudioConfig(studioConfig);
+        const cp = getConfigPath();
+        if (cp) {
+            const ap = path.join(path.dirname(cp), 'auth.json');
+            if (fs.existsSync(ap)) {
+                const authCfg = JSON.parse(fs.readFileSync(ap, 'utf8'));
+                if (plugin === 'antigravity' && authCfg['google.antigravity']) {
+                    authCfg.google = { ...authCfg['google.antigravity'] };
+                } else if (plugin === 'gemini' && authCfg['google.gemini']) {
+                    authCfg.google = { ...authCfg['google.gemini'] };
+                }
+                fs.writeFileSync(ap, JSON.stringify(authCfg, null, 2), 'utf8');
             }
         }
-        res.json({ success: true });
-    } else {
-        res.status(404).json({ error: 'Profile not found' });
+    } catch (err) {
+        console.error(err);
     }
+    
+    res.json({ success: true, activePlugin: plugin });
 });
 
-app.put('/api/auth/profiles/:provider/:name', (req, res) => {
-    const { provider, name } = req.params;
-    const { newName } = req.body;
-    
-    if (!newName) return res.status(400).json({ error: 'New name required' });
-    
-    const profileData = loadAuthProfile(provider, name);
-    if (!profileData) return res.status(404).json({ error: 'Profile not found' });
-    
-    const success = saveAuthProfile(provider, newName, profileData);
-    if (success) {
-        deleteAuthProfile(provider, name);
-        
-        const activeProfiles = getActiveProfiles();
-        if (activeProfiles[provider] === name) {
-            setActiveProfile(provider, newName);
-        }
-        
-        res.json({ success: true, name: newName });
-    } else {
-        res.status(500).json({ error: 'Failed to rename profile' });
-    }
+app.get('/api/auth/google/plugin', (req, res) => {
+    const studio = loadStudioConfig();
+    res.json({ activePlugin: studio.activeGooglePlugin || null });
 });
 
-app.post('/api/plugins/config/add', (req, res) => {
-    const { plugins } = req.body;
-    if (!Array.isArray(plugins) || plugins.length === 0) {
-        return res.status(400).json({ error: 'Plugins array required' });
+app.get('/api/pending-action', (req, res) => {
+    if (pendingActionMemory) return res.json({ action: pendingActionMemory });
+    if (fs.existsSync(PENDING_ACTION_PATH)) {
+        try {
+            const action = JSON.parse(fs.readFileSync(PENDING_ACTION_PATH, 'utf8'));
+            return res.json({ action });
+        } catch {}
     }
+    res.json({ action: null });
+});
 
-    const config = loadConfig();
-    if (!config) return res.status(404).json({ error: 'Config not found' });
-
-    if (!config.plugins) config.plugins = {};
-
-    const result = {
-        added: [],
-        skipped: []
-    };
-
-    for (const pluginName of plugins) {
-        const pluginDir = getPluginDir();
-        const dirPath = path.join(pluginDir, pluginName);
-        const hasJs = fs.existsSync(path.join(dirPath, 'index.js'));
-        const hasTs = fs.existsSync(path.join(dirPath, 'index.ts'));
-
-        if (!hasJs && !hasTs) {
-            result.skipped.push(`${pluginName} (not found)`);
-            continue;
-        }
+app.delete('/api/pending-action', (req, res) => {
+    pendingActionMemory = null;
+    if (fs.existsSync(PENDING_ACTION_PATH)) fs.unlinkSync(PENDING_ACTION_PATH);
+    res.json({ success: true });
+});
 
-        if (config.plugins[pluginName]) {
-            result.skipped.push(`${pluginName} (already configured)`);
+app.post('/api/plugins/config/add', (req, res) => {
+    const { plugins } = req.body;
+    const opencode = loadConfig();
+    if (!opencode) return res.status(404).json({ error: 'Config not found' });
+    
+    if (!opencode.plugin) opencode.plugin = [];
+    const added = [];
+    const skipped = [];
+    
+    plugins.forEach(p => {
+        if (!opencode.plugin.includes(p)) {
+            opencode.plugin.push(p);
+            added.push(p);
+            
+            const studio = loadStudioConfig();
+            if (p.includes('gemini-auth') && !studio.availableGooglePlugins.includes('gemini')) {
+                studio.availableGooglePlugins.push('gemini');
+                saveStudioConfig(studio);
+            }
+            if (p.includes('antigravity-auth') && !studio.availableGooglePlugins.includes('antigravity')) {
+                studio.availableGooglePlugins.push('antigravity');
+                saveStudioConfig(studio);
+            }
         } else {
-            config.plugins[pluginName] = { enabled: true };
-            result.added.push(pluginName);
+            skipped.push(p);
         }
-    }
-
-    if (result.added.length > 0) {
-        saveConfig(config);
-    }
-
-    res.json(result);
-});
-
-app.delete('/api/plugins/config/:name', (req, res) => {
-    const pluginName = decodeURIComponent(req.params.name);
-    const config = loadConfig();
+    });
     
-    if (!config || !config.plugins) {
-        return res.status(404).json({ error: 'Config not found or no plugins' });
-    }
-
-    if (config.plugins[pluginName]) {
-        delete config.plugins[pluginName];
-        saveConfig(config);
-        res.json({ success: true });
-    } else {
-        res.status(404).json({ error: 'Plugin not in config' });
-    }
+    saveConfig(opencode);
+    res.json({ added, skipped });
 });
 
-app.listen(PORT, () => {
-    console.log(`Server running at http://localhost:${PORT}`);
-});
+app.listen(PORT, () => console.log(`Server running at http://localhost:${PORT}`));