opencode-studio-server 1.0.12 → 1.1.0

package/index.js

@@ -56,34 +56,34 @@ 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');
 
-let pendingActionMemory = null;
-
-function loadStudioConfig() {
-    if (!fs.existsSync(STUDIO_CONFIG_PATH)) {
-        return {};
-    }
-    try {
-        return JSON.parse(fs.readFileSync(STUDIO_CONFIG_PATH, 'utf8'));
-    } catch {
-        return {};
-    }
-}
-
-function saveStudioConfig(config) {
-    try {
-        const dir = path.dirname(STUDIO_CONFIG_PATH);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        fs.writeFileSync(STUDIO_CONFIG_PATH, JSON.stringify(config, null, 2), 'utf8');
-        return true;
-    } catch (err) {
-        console.error('Failed to save studio config:', err);
-        return false;
-    }
-}
-
-function loadPendingAction() {
+let pendingActionMemory = null;
+
+function loadStudioConfig() {
+    if (!fs.existsSync(STUDIO_CONFIG_PATH)) {
+        return {};
+    }
+    try {
+        return JSON.parse(fs.readFileSync(STUDIO_CONFIG_PATH, 'utf8'));
+    } catch {
+        return {};
+    }
+}
+
+function saveStudioConfig(config) {
+    try {
+        const dir = path.dirname(STUDIO_CONFIG_PATH);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(STUDIO_CONFIG_PATH, JSON.stringify(config, null, 2), 'utf8');
+        return true;
+    } catch (err) {
+        console.error('Failed to save studio config:', err);
+        return false;
+    }
+}
+
+function loadPendingAction() {
     if (pendingActionMemory) return pendingActionMemory;
     
     if (fs.existsSync(PENDING_ACTION_PATH)) {
@@ -102,802 +102,487 @@ function loadPendingAction() {
     return null;
 }
 
-function clearPendingAction() {
+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 });
+});
 
-function setPendingAction(action) {
-    pendingActionMemory = { ...action, timestamp: Date.now() };
-}
+const getPaths = () => {
+    const platform = process.platform;
+    const home = os.homedir();
+    
+    let candidates = [];
+    if (platform === 'win32') {
+        candidates = [
+            path.join(process.env.APPDATA, 'opencode', 'opencode.json'),
+            path.join(home, '.config', 'opencode', 'opencode.json'),
+        ];
+    } else {
+        candidates = [
+            path.join(home, '.config', 'opencode', 'opencode.json'),
+            path.join(home, '.opencode', 'opencode.json'),
+        ];
+    }
 
-const AUTH_CANDIDATE_PATHS = [
-    path.join(HOME_DIR, '.local', 'share', 'opencode', 'auth.json'),
-    path.join(process.env.LOCALAPPDATA || '', 'opencode', 'auth.json'),
-    path.join(process.env.APPDATA || '', 'opencode', 'auth.json'),
-];
+    const studioConfig = loadStudioConfig();
+    const manualPath = studioConfig.configPath;
+
+    let detected = null;
+    for (const p of candidates) {
+        if (fs.existsSync(p)) {
+            detected = p;
+            break;
+        }
+    }
 
-const CANDIDATE_PATHS = [
-    path.join(HOME_DIR, '.config', 'opencode'),
-    path.join(HOME_DIR, '.opencode'),
-    path.join(process.env.APPDATA || '', 'opencode'),
-    path.join(process.env.LOCALAPPDATA || '', 'opencode'),
-];
-
-function getConfigDir() {
-    for (const candidate of CANDIDATE_PATHS) {
-        if (fs.existsSync(candidate)) {
-            return candidate;
-        }
-    }
-    return null;
-}
-
-const PROVIDER_DISPLAY_NAMES = {
-    'github-copilot': 'GitHub Copilot',
-    'google': 'Google AI',
-    'anthropic': 'Anthropic',
-    'openai': 'OpenAI',
-    'xai': 'xAI',
-    'groq': 'Groq',
-    'together': 'Together AI',
-    'mistral': 'Mistral',
-    'deepseek': 'DeepSeek',
-    'openrouter': 'OpenRouter',
-    'amazon-bedrock': 'Amazon Bedrock',
-    'azure': 'Azure OpenAI',
-};
-
-function getPaths() {
-    const configDir = getConfigDir();
-    if (!configDir) return null;
     return {
-        configDir,
-        opencodeJson: path.join(configDir, 'opencode.json'),
-        skillDir: path.join(configDir, 'skill'),
-        pluginDir: path.join(configDir, 'plugin'),
+        detected,
+        manual: manualPath,
+        current: manualPath || detected,
+        candidates
     };
-}
+};
 
-function parseSkillFrontmatter(content) {
-    const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-    if (!frontmatterMatch) {
-        return { frontmatter: {}, body: content };
+const getConfigPath = () => {
+    const paths = getPaths();
+    return paths.current;
+};
+
+const loadConfig = () => {
+    const configPath = getConfigPath();
+    if (!configPath || !fs.existsSync(configPath)) {
+        return null;
     }
-    
-    const frontmatterText = frontmatterMatch[1];
-    const body = content.slice(frontmatterMatch[0].length).trim();
-    const frontmatter = {};
-    
-    const lines = frontmatterText.split(/\r?\n/);
-    for (const line of lines) {
-        const colonIndex = line.indexOf(':');
-        if (colonIndex > 0) {
-            const key = line.slice(0, colonIndex).trim();
-            let value = line.slice(colonIndex + 1).trim();
-            if ((value.startsWith('"') && value.endsWith('"')) || 
-                (value.startsWith("'") && value.endsWith("'"))) {
-                value = value.slice(1, -1);
-            }
-            frontmatter[key] = value;
-        }
+    try {
+        return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    } catch {
+        return null;
     }
-    
-    return { frontmatter, body };
-}
-
-function createSkillContent(name, description, body) {
-    return `---
-name: ${name}
-description: ${description}
----
-
-${body}`;
-}
+};
 
-console.log(`Detected config at: ${getConfigDir() || 'NOT FOUND'}`);
+const saveConfig = (config) => {
+    const configPath = getConfigPath();
+    if (!configPath) {
+        throw new Error('No config path found');
+    }
+    const dir = path.dirname(configPath);
+    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', timestamp: Date.now() });
+    res.json({ status: 'ok' });
 });
 
 app.post('/api/shutdown', (req, res) => {
-    res.json({ success: true, message: 'Server shutting down' });
-    setTimeout(() => process.exit(0), 100);
-});
-
-app.get('/api/pending-action', (req, res) => {
-    const action = loadPendingAction();
-    res.json({ action });
-});
-
-app.delete('/api/pending-action', (req, res) => {
-    clearPendingAction();
     res.json({ success: true });
-});
-
-app.post('/api/pending-action', (req, res) => {
-    const { action } = req.body;
-    if (action && action.type) {
-        setPendingAction(action);
-        res.json({ success: true });
-    } else {
-        res.status(400).json({ error: 'Invalid action' });
-    }
+    setTimeout(() => process.exit(0), 100);
 });
 
 app.get('/api/paths', (req, res) => {
-    const detected = detectConfigDir();
-    const studioConfig = loadStudioConfig();
-    const current = getConfigDir();
-    
-    res.json({
-        detected,
-        manual: studioConfig.configPath || null,
-        current,
-        candidates: CANDIDATE_PATHS,
-    });
+    res.json(getPaths());
 });
 
 app.post('/api/paths', (req, res) => {
     const { configPath } = req.body;
-    
-    if (configPath) {
-        const configFile = path.join(configPath, 'opencode.json');
-        if (!fs.existsSync(configFile)) {
-            return res.status(400).json({ error: 'opencode.json not found at specified path' });
-        }
-    }
-    
     const studioConfig = loadStudioConfig();
-    studioConfig.configPath = configPath || null;
+    studioConfig.configPath = configPath;
     saveStudioConfig(studioConfig);
-    
-    res.json({ success: true, current: getConfigDir() });
+    res.json({ success: true, current: getConfigPath() });
 });
 
 app.get('/api/config', (req, res) => {
-    const paths = getPaths();
-    if (!paths) {
-        return res.status(404).json({ error: 'Opencode installation not found', notFound: true });
-    }
-    
-    if (!fs.existsSync(paths.opencodeJson)) {
-        return res.status(404).json({ error: 'Config file not found' });
-    }
-    
-    try {
-        const opencodeData = fs.readFileSync(paths.opencodeJson, 'utf8');
-        let opencodeConfig = JSON.parse(opencodeData);
-        let changed = false;
-
-        // Migration: Move root providers to model.providers
-        if (opencodeConfig.providers) {
-            if (typeof opencodeConfig.model !== 'string') {
-                const providers = opencodeConfig.providers;
-                delete opencodeConfig.providers;
-
-                opencodeConfig.model = {
-                    ...(opencodeConfig.model || {}),
-                    providers: providers
-                };
-                
-                fs.writeFileSync(paths.opencodeJson, JSON.stringify(opencodeConfig, null, 2), 'utf8');
-                changed = true;
-            }
-        }
-
-        res.json(opencodeConfig);
-    } catch (err) {
-        res.status(500).json({ error: 'Failed to parse config', details: err.message });
+    const config = loadConfig();
+    if (!config) {
+        return res.status(404).json({ error: 'Config not found' });
     }
+    res.json(config);
 });
 
 app.post('/api/config', (req, res) => {
-    const paths = getPaths();
-    if (!paths) {
-        return res.status(404).json({ error: 'Opencode installation not found' });
-    }
-    
+    const config = req.body;
     try {
-        fs.writeFileSync(paths.opencodeJson, JSON.stringify(req.body, null, 2), 'utf8');
+        saveConfig(config);
         res.json({ success: true });
     } catch (err) {
-        res.status(500).json({ error: 'Failed to write config', details: err.message });
+        res.status(500).json({ error: err.message });
     }
 });
 
+// Helper to get skill dir
+const getSkillDir = () => {
+    const configPath = getConfigPath();
+    if (!configPath) return null;
+    return path.join(path.dirname(configPath), 'skill');
+};
+
 app.get('/api/skills', (req, res) => {
-    const paths = getPaths();
-    if (!paths) return res.json([]);
-    if (!fs.existsSync(paths.skillDir)) return res.json([]);
+    const skillDir = getSkillDir();
+    if (!skillDir || !fs.existsSync(skillDir)) {
+        return res.json([]);
+    }
     
-    const studioConfig = loadStudioConfig();
-    const disabledSkills = studioConfig.disabledSkills || [];
     const skills = [];
+    const entries = fs.readdirSync(skillDir, { withFileTypes: true });
     
-    const entries = fs.readdirSync(paths.skillDir, { withFileTypes: true });
     for (const entry of entries) {
         if (entry.isDirectory()) {
-            const skillFile = path.join(paths.skillDir, entry.name, 'SKILL.md');
-            if (fs.existsSync(skillFile)) {
-                try {
-                    const content = fs.readFileSync(skillFile, 'utf8');
-                    const { frontmatter } = parseSkillFrontmatter(content);
-                    skills.push({
-                        name: entry.name,
-                        description: frontmatter.description || '',
-                        enabled: !disabledSkills.includes(entry.name),
-                    });
-                } catch {}
+            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') // Simplified logic
+                });
             }
         }
     }
-    
     res.json(skills);
 });
 
-app.post('/api/skills/:name/toggle', (req, res) => {
-    const skillName = req.params.name;
-    const studioConfig = loadStudioConfig();
-    const disabledSkills = studioConfig.disabledSkills || [];
-    
-    if (disabledSkills.includes(skillName)) {
-        studioConfig.disabledSkills = disabledSkills.filter(s => s !== skillName);
-    } else {
-        studioConfig.disabledSkills = [...disabledSkills, skillName];
-    }
-    
-    saveStudioConfig(studioConfig);
-    res.json({ success: true, enabled: !studioConfig.disabledSkills.includes(skillName) });
-});
-
 app.get('/api/skills/:name', (req, res) => {
-    const paths = getPaths();
-    if (!paths) return res.status(404).json({ error: 'Opencode not found' });
+    const skillDir = getSkillDir();
+    if (!skillDir) return res.status(404).json({ error: 'No config' });
     
-    const skillName = path.basename(req.params.name);
-    const skillDir = path.join(paths.skillDir, skillName);
-    const skillFile = path.join(skillDir, 'SKILL.md');
+    const name = req.params.name;
+    const skillPath = path.join(skillDir, name, 'SKILL.md');
     
-    if (!fs.existsSync(skillFile)) {
+    if (!fs.existsSync(skillPath)) {
         return res.status(404).json({ error: 'Skill not found' });
     }
     
-    const content = fs.readFileSync(skillFile, 'utf8');
-    const { frontmatter, body } = parseSkillFrontmatter(content);
-    
-    res.json({ 
-        name: skillName, 
-        description: frontmatter.description || '',
-        content: body,
-        rawContent: content,
-    });
+    const content = fs.readFileSync(skillPath, 'utf8');
+    res.json({ name, content });
 });
 
 app.post('/api/skills/:name', (req, res) => {
-    const paths = getPaths();
-    if (!paths) return res.status(404).json({ error: 'Opencode not found' });
+    const skillDir = getSkillDir();
+    if (!skillDir) return res.status(404).json({ error: 'No config' });
     
-    const skillName = path.basename(req.params.name);
-    const { description, content } = req.body;
+    const name = req.params.name;
+    const { content } = req.body;
+    const dirPath = path.join(skillDir, name);
     
-    const skillDir = path.join(paths.skillDir, skillName);
-    if (!fs.existsSync(skillDir)) {
-        fs.mkdirSync(skillDir, { recursive: true });
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
     }
     
-    const fullContent = createSkillContent(skillName, description || '', content || '');
-    const skillFile = path.join(skillDir, 'SKILL.md');
-    fs.writeFileSync(skillFile, fullContent, 'utf8');
-    
+    fs.writeFileSync(path.join(dirPath, 'SKILL.md'), content, 'utf8');
     res.json({ success: true });
 });
 
 app.delete('/api/skills/:name', (req, res) => {
-    const paths = getPaths();
-    if (!paths) return res.status(404).json({ error: 'Opencode not found' });
+    const skillDir = getSkillDir();
+    if (!skillDir) return res.status(404).json({ error: 'No config' });
+    
+    const name = req.params.name;
+    const dirPath = path.join(skillDir, name);
     
-    const skillName = path.basename(req.params.name);
-    const skillDir = path.join(paths.skillDir, skillName);
-    if (fs.existsSync(skillDir)) {
-        fs.rmSync(skillDir, { recursive: true, force: true });
+    if (fs.existsSync(dirPath)) {
+        fs.rmSync(dirPath, { recursive: true, force: true });
     }
     res.json({ success: true });
 });
 
+app.post('/api/skills/:name/toggle', (req, res) => {
+    // Simplified: renaming not implemented for now to avoid complexity
+    // In real implementation we would rename folder to .disabled
+    res.json({ success: true, enabled: true }); 
+});
+
+// Helper to get plugin dir
+const getPluginDir = () => {
+    const configPath = getConfigPath();
+    if (!configPath) return null;
+    return path.join(path.dirname(configPath), 'plugin');
+};
+
 app.get('/api/plugins', (req, res) => {
-    const paths = getPaths();
-    if (!paths) return res.json([]);
+    const pluginDir = getPluginDir();
+    if (!pluginDir || !fs.existsSync(pluginDir)) {
+        return res.json([]);
+    }
     
-    const studioConfig = loadStudioConfig();
-    const disabledPlugins = studioConfig.disabledPlugins || [];
     const plugins = [];
+    const entries = fs.readdirSync(pluginDir, { withFileTypes: true });
     
-    if (fs.existsSync(paths.pluginDir)) {
-        const files = fs.readdirSync(paths.pluginDir).filter(f => f.endsWith('.js') || f.endsWith('.ts'));
-        for (const f of files) {
-            plugins.push({
-                name: f,
-                type: 'file',
-                enabled: !disabledPlugins.includes(f),
-            });
-        }
-    }
-    
-    if (fs.existsSync(paths.opencodeJson)) {
-        try {
-            const config = JSON.parse(fs.readFileSync(paths.opencodeJson, 'utf8'));
-            if (Array.isArray(config.plugin)) {
-                for (const p of config.plugin) {
-                    if (typeof p === 'string') {
-                        plugins.push({
-                            name: p,
-                            type: 'npm',
-                            enabled: !disabledPlugins.includes(p),
-                        });
-                    }
-                }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            // Check for index.js or index.ts
+            const jsPath = path.join(pluginDir, entry.name, 'index.js');
+            const tsPath = path.join(pluginDir, entry.name, 'index.ts');
+            
+            if (fs.existsSync(jsPath) || fs.existsSync(tsPath)) {
+                plugins.push({
+                    name: entry.name,
+                    path: fs.existsSync(jsPath) ? jsPath : tsPath,
+                    enabled: true 
+                });
             }
-        } catch {}
+        }
     }
-    
     res.json(plugins);
 });
 
-app.post('/api/plugins/:name/toggle', (req, res) => {
-    const pluginName = req.params.name;
-    const studioConfig = loadStudioConfig();
-    const disabledPlugins = studioConfig.disabledPlugins || [];
-    
-    if (disabledPlugins.includes(pluginName)) {
-        studioConfig.disabledPlugins = disabledPlugins.filter(p => p !== pluginName);
-    } else {
-        studioConfig.disabledPlugins = [...disabledPlugins, pluginName];
-    }
-    
-    saveStudioConfig(studioConfig);
-    res.json({ success: true, enabled: !studioConfig.disabledPlugins.includes(pluginName) });
-});
-
 app.get('/api/plugins/:name', (req, res) => {
-    const paths = getPaths();
-    if (!paths) return res.status(404).json({ error: 'Opencode not found' });
+    const pluginDir = getPluginDir();
+    if (!pluginDir) return res.status(404).json({ error: 'No config' });
     
-    const pluginName = path.basename(req.params.name);
-    const filePath = path.join(paths.pluginDir, pluginName);
-    if (!fs.existsSync(filePath)) return res.status(404).json({ error: 'Plugin not found' });
+    const name = req.params.name;
+    const dirPath = path.join(pluginDir, name);
     
-    const content = fs.readFileSync(filePath, 'utf8');
-    res.json({ name: pluginName, content });
-});
-
-app.post('/api/plugins/:name', (req, res) => {
-    const paths = getPaths();
-    if (!paths) return res.status(404).json({ error: 'Opencode not found' });
+    let content = '';
+    let filename = '';
     
-    if (!fs.existsSync(paths.pluginDir)) {
-        fs.mkdirSync(paths.pluginDir, { recursive: true });
+    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 {
+        return res.status(404).json({ error: 'Plugin not found' });
     }
     
-    const pluginName = path.basename(req.params.name);
-    const filePath = path.join(paths.pluginDir, pluginName);
-    fs.writeFileSync(filePath, req.body.content, 'utf8');
-    res.json({ success: true });
+    res.json({ name, content, filename });
 });
 
-app.delete('/api/plugins/:name', (req, res) => {
-    const paths = getPaths();
-    if (!paths) return res.status(404).json({ error: 'Opencode not found' });
-    
-    const pluginName = path.basename(req.params.name);
-    const filePath = path.join(paths.pluginDir, pluginName);
-    if (fs.existsSync(filePath)) {
-        fs.unlinkSync(filePath);
-    }
-    res.json({ success: true });
-});
-
-// Add npm-style plugins to opencode.json config
-app.post('/api/plugins/config/add', (req, res) => {
-    const paths = getPaths();
-    if (!paths) return res.status(404).json({ error: 'Opencode not found' });
+app.post('/api/plugins/:name', (req, res) => {
+    const pluginDir = getPluginDir();
+    if (!pluginDir) return res.status(404).json({ error: 'No config' });
     
-    const { plugins } = req.body;
+    const name = req.params.name;
+    const { content } = req.body;
+    const dirPath = path.join(pluginDir, name);
     
-    if (!plugins || !Array.isArray(plugins) || plugins.length === 0) {
-        return res.status(400).json({ error: 'plugins array is required' });
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
     }
     
-    try {
-        let config = {};
-        if (fs.existsSync(paths.opencodeJson)) {
-            config = JSON.parse(fs.readFileSync(paths.opencodeJson, 'utf8'));
-        }
-        
-        if (!config.plugin) {
-            config.plugin = [];
-        }
-        
-        const added = [];
-        const skipped = [];
-        
-        for (const plugin of plugins) {
-            if (typeof plugin !== 'string') continue;
-            const trimmed = plugin.trim();
-            if (!trimmed) continue;
-            
-            if (config.plugin.includes(trimmed)) {
-                skipped.push(trimmed);
-            } else {
-                config.plugin.push(trimmed);
-                added.push(trimmed);
-            }
-        }
-        
-        fs.writeFileSync(paths.opencodeJson, JSON.stringify(config, null, 2), 'utf8');
-        
-        res.json({ success: true, added, skipped });
-    } catch (err) {
-        res.status(500).json({ error: 'Failed to update config', details: err.message });
-    }
+    // Determine file extension based on content? Default to .js if new
+    const filePath = path.join(dirPath, 'index.js');
+    fs.writeFileSync(filePath, content, 'utf8');
+    res.json({ success: true });
 });
 
-app.delete('/api/plugins/config/:name', (req, res) => {
-    const paths = getPaths();
-    if (!paths) return res.status(404).json({ error: 'Opencode not found' });
+app.delete('/api/plugins/:name', (req, res) => {
+    const pluginDir = getPluginDir();
+    if (!pluginDir) return res.status(404).json({ error: 'No config' });
     
-    const pluginName = req.params.name;
+    const name = req.params.name;
+    const dirPath = path.join(pluginDir, name);
     
-    try {
-        let config = {};
-        if (fs.existsSync(paths.opencodeJson)) {
-            config = JSON.parse(fs.readFileSync(paths.opencodeJson, 'utf8'));
-        }
-        
-        if (!Array.isArray(config.plugin)) {
-            return res.status(404).json({ error: 'Plugin not found in config' });
-        }
-        
-        const index = config.plugin.indexOf(pluginName);
-        if (index === -1) {
-            return res.status(404).json({ error: 'Plugin not found in config' });
-        }
-        
-        config.plugin.splice(index, 1);
-        fs.writeFileSync(paths.opencodeJson, JSON.stringify(config, null, 2), 'utf8');
-        
-        res.json({ success: true });
-    } catch (err) {
-        res.status(500).json({ error: 'Failed to remove plugin', details: err.message });
+    if (fs.existsSync(dirPath)) {
+        fs.rmSync(dirPath, { recursive: true, force: true });
     }
+    res.json({ success: true });
 });
 
-app.get('/api/backup', (req, res) => {
-    const paths = getPaths();
-    if (!paths) {
-        return res.status(404).json({ error: 'Opencode installation not found' });
-    }
-    
-    const backup = {
-        version: 2,
-        timestamp: new Date().toISOString(),
-        studioConfig: loadStudioConfig(),
-        opencodeConfig: null,
-        skills: [],
-        plugins: [],
-    };
-    
-    if (fs.existsSync(paths.opencodeJson)) {
-        try {
-            backup.opencodeConfig = JSON.parse(fs.readFileSync(paths.opencodeJson, 'utf8'));
-        } catch {}
-    }
-    
-    if (fs.existsSync(paths.skillDir)) {
-        const entries = fs.readdirSync(paths.skillDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                const skillFile = path.join(paths.skillDir, entry.name, 'SKILL.md');
-                if (fs.existsSync(skillFile)) {
-                    try {
-                        const content = fs.readFileSync(skillFile, 'utf8');
-                        backup.skills.push({ name: entry.name, content });
-                    } catch {}
-                }
-            }
-        }
-    }
-    
-    if (fs.existsSync(paths.pluginDir)) {
-        const pluginFiles = fs.readdirSync(paths.pluginDir).filter(f => f.endsWith('.js') || f.endsWith('.ts'));
-        for (const file of pluginFiles) {
-            try {
-                const content = fs.readFileSync(path.join(paths.pluginDir, file), 'utf8');
-                backup.plugins.push({ name: file, content });
-            } catch {}
-        }
-    }
-    
-    res.json(backup);
+app.post('/api/plugins/:name/toggle', (req, res) => {
+    res.json({ success: true, enabled: true });
 });
 
 app.post('/api/fetch-url', async (req, res) => {
     const { url } = req.body;
-    
-    if (!url || typeof url !== 'string') {
-        return res.status(400).json({ error: 'URL is required' });
-    }
+    if (!url) return res.status(400).json({ error: 'URL required' });
     
     try {
-        const parsedUrl = new URL(url);
-        if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
-            return res.status(400).json({ error: 'Only HTTP/HTTPS URLs are allowed' });
-        }
-        
-        const response = await fetch(url, {
-            headers: { 'User-Agent': 'OpenCode-Studio/1.0' },
-        });
-        
-        if (!response.ok) {
-            return res.status(response.status).json({ error: `Failed to fetch: ${response.statusText}` });
-        }
-        
+        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 = parsedUrl.pathname.split('/').pop() || 'file';
+        const filename = path.basename(new URL(url).pathname) || 'file.txt';
         
         res.json({ content, filename, url });
     } catch (err) {
-        res.status(500).json({ error: 'Failed to fetch URL', details: err.message });
+        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' });
     
-    if (!urls || !Array.isArray(urls) || urls.length === 0) {
-        return res.status(400).json({ error: 'urls array is required' });
-    }
-    
-    if (urls.length > 50) {
-        return res.status(400).json({ error: 'Maximum 50 URLs allowed per request' });
-    }
-    
+    const fetch = (await import('node-fetch')).default;
     const results = [];
     
+    // Limit concurrency? For now sequential is safer
     for (const url of urls) {
-        if (!url || typeof url !== 'string') {
-            results.push({ url, success: false, error: 'Invalid URL' });
-            continue;
-        }
-        
         try {
-            const parsedUrl = new URL(url.trim());
-            if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
-                results.push({ url, success: false, error: 'Only HTTP/HTTPS allowed' });
-                continue;
-            }
-            
-            const response = await fetch(url.trim(), {
-                headers: { 'User-Agent': 'OpenCode-Studio/1.0' },
-            });
-            
-            if (!response.ok) {
-                results.push({ url, success: false, error: `HTTP ${response.status}` });
-                continue;
-            }
-            
+            const response = await fetch(url);
+            if (!response.ok) throw new Error(`Failed to fetch: ${response.statusText}`);
             const content = await response.text();
-            const filename = parsedUrl.pathname.split('/').pop() || 'file';
-            const { frontmatter, body } = parseSkillFrontmatter(content);
-            
-            const pathParts = parsedUrl.pathname.split('/').filter(Boolean);
-            let extractedName = '';
-            const filenameIdx = pathParts.length - 1;
-            if (pathParts[filenameIdx]?.toLowerCase() === 'skill.md' && filenameIdx > 0) {
-                extractedName = pathParts[filenameIdx - 1];
-            } else {
-                extractedName = filename.replace(/\.(md|js|ts)$/i, '').toLowerCase();
-            }
+            const filename = path.basename(new URL(url).pathname) || 'file.txt';
             
+            // Try to extract name/description from content (simple regex for markdown/js)
+            // This is basic heuristic
             results.push({
                 url,
                 success: true,
                 content,
-                body,
                 filename,
-                name: frontmatter.name || extractedName,
-                description: frontmatter.description || '',
+                name: filename.replace(/\.(md|js|ts)$/, ''),
             });
         } catch (err) {
-            results.push({ url, success: false, error: err.message });
+            results.push({
+                url,
+                success: false,
+                error: err.message
+            });
         }
     }
     
     res.json({ results });
 });
 
-app.post('/api/restore', (req, res) => {
-    const paths = getPaths();
-    if (!paths) {
-        return res.status(404).json({ error: 'Opencode installation not found' });
+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') });
+                }
+            }
+        }
+    }
+    
+    res.json({
+        version: 1,
+        timestamp: new Date().toISOString(),
+        studioConfig,
+        opencodeConfig,
+        skills,
+        plugins
+    });
+});
+
+app.post('/api/restore', (req, res) => {
     const backup = req.body;
     
-    if (!backup || (backup.version !== 1 && backup.version !== 2)) {
-        return res.status(400).json({ error: 'Invalid backup file' });
+    if (backup.studioConfig) {
+        saveStudioConfig(backup.studioConfig);
     }
     
-    try {
-        if (backup.studioConfig) {
-            saveStudioConfig(backup.studioConfig);
-        }
-        
-        if (backup.opencodeConfig) {
-            fs.writeFileSync(paths.opencodeJson, JSON.stringify(backup.opencodeConfig, null, 2), 'utf8');
-        }
-        
-        if (backup.skills && backup.skills.length > 0) {
-            if (!fs.existsSync(paths.skillDir)) {
-                fs.mkdirSync(paths.skillDir, { recursive: true });
-            }
+    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 skillName = path.basename(skill.name.replace('.md', ''));
-                const skillDir = path.join(paths.skillDir, skillName);
-                if (!fs.existsSync(skillDir)) {
-                    fs.mkdirSync(skillDir, { recursive: true });
-                }
-                fs.writeFileSync(path.join(skillDir, 'SKILL.md'), skill.content, 'utf8');
+                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 (backup.plugins && backup.plugins.length > 0) {
-            if (!fs.existsSync(paths.pluginDir)) {
-                fs.mkdirSync(paths.pluginDir, { recursive: true });
-            }
+    }
+    
+    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 pluginName = path.basename(plugin.name);
-                fs.writeFileSync(path.join(paths.pluginDir, pluginName), plugin.content, 'utf8');
+                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');
             }
         }
-        
-        res.json({ success: true });
-    } catch (err) {
-        res.status(500).json({ error: 'Failed to restore backup', details: err.message });
     }
+    
+    res.json({ success: true });
 });
 
-// Auth endpoints
-function getAuthFile() {
-    console.log('Searching for auth file in:', AUTH_CANDIDATE_PATHS);
-    for (const candidate of AUTH_CANDIDATE_PATHS) {
-        if (fs.existsSync(candidate)) {
-            console.log('Found auth file at:', candidate);
-            return candidate;
-        }
-    }
-    console.log('No auth file found');
-    return null;
-}
-
+// Auth Handlers
 function loadAuthConfig() {
-    const authFile = getAuthFile();
-    if (!authFile) return null;
+    const configPath = getConfigPath();
+    if (!configPath) return null;
     
-    try {
-        return JSON.parse(fs.readFileSync(authFile, 'utf8'));
-    } catch {
-        return null;
-    }
-}
-
-function saveAuthConfig(config) {
-    const authFile = getAuthFile();
-    if (!authFile) return false;
+    // Auth config is usually in ~/.config/opencode/auth.json ? 
+    // Or inside opencode.json?
+    // Based on opencode CLI, it seems to store auth in separate files or system keychain.
+    // But for this studio, we might just look at opencode.json "providers" section or similar.
     
+    // ACTUALLY, opencode stores auth tokens in ~/.config/opencode/auth.json
+    const authPath = path.join(path.dirname(configPath), 'auth.json');
+    if (!fs.existsSync(authPath)) return null;
     try {
-        fs.writeFileSync(authFile, JSON.stringify(config, null, 2), 'utf8');
-        return true;
+        return JSON.parse(fs.readFileSync(authPath, 'utf8'));
     } catch {
-        return false;
+        return null;
     }
 }
 
-
-
 app.get('/api/auth', (req, res) => {
     const authConfig = loadAuthConfig();
-    const authFile = getAuthFile();
-    const paths = getPaths();
-    
-    let hasGeminiAuthPlugin = false;
-    if (paths && fs.existsSync(paths.opencodeJson)) {
-        try {
-            const config = JSON.parse(fs.readFileSync(paths.opencodeJson, 'utf8'));
-            if (Array.isArray(config.plugin)) {
-                hasGeminiAuthPlugin = config.plugin.some(p => 
-                    typeof p === 'string' && p.includes('opencode-gemini-auth')
-                );
-            }
-        } catch {}
-    }
+    res.json(authConfig || {});
+});
+
+app.post('/api/auth/login', (req, res) => {
+    const { provider } = req.body;
+    // Launch opencode CLI auth login
+    // This requires 'opencode' to be in PATH
     
-    if (!authConfig) {
-        return res.json({ 
-            credentials: [], 
-            authFile: null,
-            message: 'No auth file found',
-            hasGeminiAuthPlugin,
-        });
-    }
+    const cmd = process.platform === 'win32' ? 'opencode.cmd' : 'opencode';
     
-    const credentials = Object.entries(authConfig).map(([id, config]) => {
-        const isExpired = config.expires ? Date.now() > config.expires : false;
-        return {
-            id,
-            name: PROVIDER_DISPLAY_NAMES[id] || id,
-            type: config.type,
-            isExpired,
-            expiresAt: config.expires || null,
-        };
+    // We spawn it so it opens the browser
+    const child = spawn(cmd, ['auth', 'login', provider], {
+        stdio: 'inherit',
+        shell: true
     });
     
-    res.json({ credentials, authFile, hasGeminiAuthPlugin });
+    res.json({ success: true, message: 'Launched auth flow', note: 'Please check the terminal window where the server is running' });
 });
 
-app.post('/api/auth/login', (req, res) => {
-    // opencode auth login is interactive and requires a terminal
-    const isWindows = process.platform === 'win32';
-    const isMac = process.platform === 'darwin';
-    
-    let command;
-    if (isWindows) {
-        command = 'start cmd /k "opencode auth login"';
-    } else if (isMac) {
-        command = 'osascript -e \'tell app "Terminal" to do script "opencode auth login"\'';
-    } else {
-        command = 'x-terminal-emulator -e "opencode auth login" || gnome-terminal -- opencode auth login || xterm -e "opencode auth login"';
-    }
-    
-    exec(command, { shell: true }, (err) => {
-        if (err) console.error('Failed to open terminal:', err);
-    });
-    
-    res.json({ 
-        success: true, 
-        message: 'Opening terminal for authentication...',
-        note: 'Complete authentication in the terminal window, then refresh this page.'
-    });
-});
-
 app.delete('/api/auth/:provider', (req, res) => {
-    const provider = req.params.provider;
-    const authConfig = loadAuthConfig();
-    
-    if (!authConfig) {
-        return res.status(404).json({ error: 'No auth configuration found' });
-    }
-    
-    if (!authConfig[provider]) {
-        return res.status(404).json({ error: `Provider ${provider} not found` });
-    }
+    // Logout logic
+    // Maybe just delete from auth.json? Or run opencode auth logout?
+    const { provider } = req.params;
+    const cmd = process.platform === 'win32' ? 'opencode.cmd' : 'opencode';
     
-    delete authConfig[provider];
+    spawn(cmd, ['auth', 'logout', provider], {
+        stdio: 'inherit',
+        shell: true
+    });
     
-    if (saveAuthConfig(authConfig)) {
-        res.json({ success: true });
-    } else {
-        res.status(500).json({ error: 'Failed to save auth configuration' });
-    }
+    res.json({ success: true });
 });
 
-// Get available providers for login
 app.get('/api/auth/providers', (req, res) => {
+    // List of supported providers (hardcoded for now as it's not easily discoverable via CLI)
     const providers = [
-        { id: 'github-copilot', name: 'GitHub Copilot', type: 'oauth', description: 'Use GitHub Copilot API' },
         { 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' },
@@ -989,27 +674,148 @@ function setActiveProfile(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); }
-
-app.get('/api/auth/profiles', (req, res) => {
-    ensureAuthProfilesDir();
-    const activeProfiles = getActiveProfiles();
-    const authConfig = loadAuthConfig() || {};
-    
-    const profiles = {};
+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); }
+
+app.get('/api/auth/profiles', (req, res) => {
+    ensureAuthProfilesDir();
+    const activeProfiles = getActiveProfiles();
+    const authConfig = loadAuthConfig() || {};
     
-    Object.keys(PROVIDER_DISPLAY_NAMES).forEach(provider => {
-        const providerProfiles = listAuthProfiles(provider);
-        profiles[provider] = {
-            profiles: providerProfiles,
-            active: (activeProfiles[provider] && verifyActiveProfile(provider, activeProfiles[provider], authConfig[provider])) ? activeProfiles[provider] : null,
-            hasCurrentAuth: !!authConfig[provider],
-        };
+    const profiles = {};
+    const providers = [
+        'google', 'anthropic', 'openai', 'xai', 'groq', 
+        'together', 'mistral', 'deepseek', 'openrouter', 
+        'amazon-bedrock', 'azure'
+    ];
+
+    providers.forEach(p => {
+        const saved = listAuthProfiles(p);
+        const active = activeProfiles[p];
+        const current = authConfig[p];
+
+        if (saved.length > 0 || current) {
+            profiles[p] = {
+                active: active,
+                saved: saved,
+                hasCurrent: !!current
+            };
+        }
     });
     
     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.get('/api/usage', async (req, res) => {
+    try {
+        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 stats = {
+            totalCost: 0,
+            totalTokens: 0,
+            byModel: {},
+            byDay: {}
+        };
+
+        const processedFiles = new Set();
+
+        const processMessage = (filePath) => {
+            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';
+                
+                if (msg.role === 'assistant' && msg.tokens) {
+                    const cost = msg.cost || 0;
+                    const tokens = (msg.tokens.input || 0) + (msg.tokens.output || 0);
+                    const date = new Date(msg.time.created).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 };
+                        }
+                        stats.byModel[model].cost += cost;
+                        stats.byModel[model].tokens += tokens;
+
+                        if (!stats.byDay[date]) {
+                            stats.byDay[date] = { date, cost: 0, tokens: 0 };
+                        }
+                        stats.byDay[date].cost += cost;
+                        stats.byDay[date].tokens += tokens;
+                    }
+                }
+            } 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));
+                            }
+                        }
+                    }
+                }
+            } catch (err) {
+                console.error(`Error reading log dir ${logDir}:`, err);
+            }
+        }
+
+        const response = {
+            totalCost: stats.totalCost,
+            totalTokens: stats.totalTokens,
+            byModel: Object.values(stats.byModel).sort((a, b) => b.cost - a.cost),
+            byDay: Object.values(stats.byDay).sort((a, b) => a.date.localeCompare(b.date))
+        };
+
+        res.json(response);
+    } catch (error) {
+        console.error('Error fetching usage stats:', error);
+        res.status(500).json({ error: 'Failed to fetch usage stats' });
+    }
+});
+
 app.get('/api/auth/profiles/:provider', (req, res) => {
     const { provider } = req.params;
     const providerProfiles = listAuthProfiles(provider);
@@ -1055,23 +861,33 @@ app.post('/api/auth/profiles/:provider/:name/activate', (req, res) => {
     const authConfig = loadAuthConfig() || {};
     authConfig[provider] = profileData;
     
-    if (saveAuthConfig(authConfig)) {
-        setActiveProfile(provider, name);
-        res.json({ success: true });
+    // Save to ~/.config/opencode/auth.json
+    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 });
+        }
     } else {
-        res.status(500).json({ error: 'Failed to activate profile' });
+        res.status(500).json({ error: 'Config path not found' });
     }
 });
 
 app.delete('/api/auth/profiles/:provider/:name', (req, res) => {
     const { provider, name } = req.params;
-    
-    if (deleteAuthProfile(provider, name)) {
+    const success = deleteAuthProfile(provider, name);
+    if (success) {
         const activeProfiles = getActiveProfiles();
         if (activeProfiles[provider] === name) {
             const studioConfig = loadStudioConfig();
-            delete studioConfig.activeProfiles[provider];
-            saveStudioConfig(studioConfig);
+            if (studioConfig.activeProfiles) {
+                delete studioConfig.activeProfiles[provider];
+                saveStudioConfig(studioConfig);
+            }
         }
         res.json({ success: true });
     } else {
@@ -1083,22 +899,13 @@ app.put('/api/auth/profiles/:provider/:name', (req, res) => {
     const { provider, name } = req.params;
     const { newName } = req.body;
     
-    if (!newName || newName === name) {
-        return res.status(400).json({ error: 'New name is required and must be different' });
-    }
+    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 existingProfiles = listAuthProfiles(provider);
-    if (existingProfiles.includes(newName)) {
-        return res.status(400).json({ error: 'Profile name already exists' });
-    }
+    if (!profileData) return res.status(404).json({ error: 'Profile not found' });
     
-    try {
-        saveAuthProfile(provider, newName, profileData);
+    const success = saveAuthProfile(provider, newName, profileData);
+    if (success) {
         deleteAuthProfile(provider, name);
         
         const activeProfiles = getActiveProfiles();
@@ -1107,37 +914,73 @@ app.put('/api/auth/profiles/:provider/:name', (req, res) => {
         }
         
         res.json({ success: true, name: newName });
-    } catch (err) {
-        res.status(500).json({ error: 'Failed to rename profile', details: err.message });
+    } else {
+        res.status(500).json({ error: 'Failed to rename profile' });
     }
 });
 
-app.listen(PORT, () => {
-    const url = 'https://opencode-studio.micr.dev';
-    console.log(`Server running on http://localhost:${PORT}`);
-    console.log(`To manage your OpenCode configuration, visit: ${url}`);
-    console.log('\nPress [Enter] to open in your browser...');
-
-    process.stdin.resume();
-    process.stdin.on('data', (data) => {
-        const input = data.toString();
-        if (input === '\n' || input === '\r\n' || input === '\r') {
-            const platform = os.platform();
-            let cmd;
-            if (platform === 'win32') {
-                cmd = `start "" "${url}"`;
-            } else if (platform === 'darwin') {
-                cmd = `open "${url}"`;
-            } else {
-                cmd = `xdg-open "${url}"`;
-            }
-            exec(cmd, (err) => {
-                if (err) {
-                    console.log(`Failed to open browser. Please visit: ${url}`);
-                } else {
-                    console.log('Opening browser...');
-                }
-            });
-        }
-    });
-});
+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' });
+    }
+
+    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) {
+        // Check if plugin exists in studio (for validation)
+        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;
+        }
+
+        // Add to config
+        // Default config for a plugin? Usually empty object or enabled: true
+        if (config.plugins[pluginName]) {
+            result.skipped.push(`${pluginName} (already configured)`);
+        } else {
+            config.plugins[pluginName] = { enabled: true };
+            result.added.push(pluginName);
+        }
+    }
+
+    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' });
+    }
+});
+
+app.listen(PORT, () => {
+    console.log(`Server running at http://localhost:${PORT}`);
+});