opencode-studio-server 2.0.0 → 2.1.0

package/AGENTS.md

@@ -1,6 +1,6 @@
 # SERVER LAYER
 
-Express API backend (port 3001). Single-file architecture.
+Express API backend (port 1920). Single-file architecture.
 
 ## STRUCTURE
 

package/README.md

@@ -24,7 +24,7 @@ Start the server manually:
 opencode-studio-server
 ```
 
-The server runs on port **3001** and provides an API for managing your local OpenCode configuration.
+The server runs on port **1920** (auto-detects next available) and provides an API for managing your local OpenCode configuration.
 
 ## Features
 

package/index.js

@@ -5,7 +5,8 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
-const { spawn, exec } = require('child_process');
+const { spawn, exec, execSync } = require('child_process');
+const yaml = require('js-yaml');
 
 const pkg = require('./package.json');
 const profileManager = require('./profile-manager');
@@ -40,23 +41,23 @@ const atomicWriteFileSync = (filePath, data, options = 'utf8') => {
     }
 };
 
-const app = express();
-const DEFAULT_PORT = 1920;
-const IDLE_TIMEOUT_MS = 30 * 60 * 1000;
-
-function findAvailablePort(startPort) {
-    const net = require('net');
-    return new Promise((resolve) => {
-        const server = net.createServer();
-        server.listen(startPort, () => {
-            server.once('close', () => resolve(startPort));
-            server.close();
-        });
-        server.on('error', () => {
-            findAvailablePort(startPort + 1).then(resolve);
-        });
-    });
-}
+const app = express();
+const DEFAULT_PORT = 1920;
+const IDLE_TIMEOUT_MS = 30 * 60 * 1000;
+
+function findAvailablePort(startPort) {
+    const net = require('net');
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.listen(startPort, () => {
+            server.once('close', () => resolve(startPort));
+            server.close();
+        });
+        server.on('error', () => {
+            findAvailablePort(startPort + 1).then(resolve);
+        });
+    });
+}
 
 let idleTimer = null;
 
@@ -75,17 +76,17 @@ app.use((req, res, next) => {
     next();
 });
 
-const ALLOWED_ORIGINS = [
-    'http://localhost:1080',
-    'http://127.0.0.1:1080',
-    /^http:\/\/localhost:108\d$/,
-    /^http:\/\/127\.0\.0\.1:108\d$/,
-    'https://opencode-studio.vercel.app',
-    'https://opencode.micr.dev',
-    'https://opencode-studio.micr.dev',
-    /\.vercel\.app$/,
-    /\.micr\.dev$/,
-];
+const ALLOWED_ORIGINS = [
+    'http://localhost:1080',
+    'http://127.0.0.1:1080',
+    /^http:\/\/localhost:108\d$/,
+    /^http:\/\/127\.0\.0\.1:108\d$/,
+    'https://opencode-studio.vercel.app',
+    'https://opencode.micr.dev',
+    'https://opencode-studio.micr.dev',
+    /\.vercel\.app$/,
+    /\.micr\.dev$/,
+];
 
 app.use(cors({
     origin: (origin, callback) => {
@@ -101,15 +102,47 @@ app.use(bodyParser.json({ limit: '50mb' }));
 app.use(bodyParser.urlencoded({ limit: '50mb', extended: true }));
 app.use(bodyParser.text({ type: ['text/*', 'application/yaml'], limit: '50mb' }));
 
-const HOME_DIR = os.homedir();
-const STUDIO_CONFIG_PATH = path.join(HOME_DIR, '.config', 'opencode-studio', 'studio.json');
-const PENDING_ACTION_PATH = path.join(HOME_DIR, '.config', 'opencode-studio', 'pending-action.json');
-const ANTIGRAVITY_ACCOUNTS_PATH = path.join(HOME_DIR, '.config', 'opencode', 'antigravity-accounts.json');
-const LOG_DIR = path.join(HOME_DIR, '.local', 'share', 'opencode', 'log');
+const HOME_DIR = os.homedir();
+const STUDIO_CONFIG_PATH = path.join(HOME_DIR, '.config', 'opencode-studio', 'studio.json');
+const PENDING_ACTION_PATH = path.join(HOME_DIR, '.config', 'opencode-studio', 'pending-action.json');
+const ANTIGRAVITY_ACCOUNTS_PATH = path.join(HOME_DIR, '.config', 'opencode', 'antigravity-accounts.json');
+const LOG_DIR = path.join(HOME_DIR, '.local', 'share', 'opencode', 'log');
+
+const LOG_BUFFER_SIZE = 100;
+const logBuffer = [];
+const logSubscribers = new Set();
 
-let logWatcher = null;
-let currentLogFile = null;
-let logReadStream = null;
+let logWatcher = null;
+let currentLogFile = null;
+let logReadStream = null;
+
+function enqueueLogLine(line) {
+    const entry = { timestamp: Date.now(), line };
+    logBuffer.push(entry);
+    if (logBuffer.length > LOG_BUFFER_SIZE) logBuffer.shift();
+
+    for (const sub of logSubscribers) {
+        sub.queue.push(`data: ${JSON.stringify(entry)}\n\n`);
+        flushSubscriber(sub);
+    }
+}
+
+function flushSubscriber(sub) {
+    if (sub.draining || sub.closed) return;
+    while (sub.queue.length > 0) {
+        const chunk = sub.queue[0];
+        const ok = sub.res.write(chunk);
+        if (!ok) {
+            sub.draining = true;
+            sub.res.once('drain', () => {
+                sub.draining = false;
+                flushSubscriber(sub);
+            });
+            return;
+        }
+        sub.queue.shift();
+    }
+}
 
 function setupLogWatcher() {
     if (!fs.existsSync(LOG_DIR)) return;
@@ -188,11 +221,12 @@ function setupLogWatcher() {
     });
 }
 
-function processLogLine(line) {
-    // Detect LLM usage: service=llm providerID=... modelID=...
-    // Example: service=llm providerID=openai modelID=gpt-5.2-codex sessionID=...
-    const isUsage = line.includes('service=llm') && line.includes('stream');
-    const isError = line.includes('service=llm') && (line.includes('error=') || line.includes('status=429'));
+function processLogLine(line) {
+    enqueueLogLine(line);
+    // Detect LLM usage: service=llm providerID=... modelID=...
+    // Example: service=llm providerID=openai modelID=gpt-5.2-codex sessionID=...
+    const isUsage = line.includes('service=llm') && line.includes('stream');
+    const isError = line.includes('service=llm') && (line.includes('error=') || line.includes('status=429'));
     
     if (!isUsage && !isError) return;
 
@@ -304,12 +338,13 @@ function processLogLine(line) {
 
 let pendingActionMemory = null;
 
-function loadStudioConfig() {
-    const defaultConfig = {
-        disabledSkills: [],
-        disabledPlugins: [],
-        activeProfiles: {},
-        activeGooglePlugin: 'gemini',
+function loadStudioConfig() {
+    const defaultConfig = {
+        disabledSkills: [],
+        disabledPlugins: [],
+        disabledAgents: [],
+        activeProfiles: {},
+        activeGooglePlugin: 'gemini',
         availableGooglePlugins: [],
         presets: [],
         githubRepo: null,
@@ -357,9 +392,9 @@ function loadStudioConfig() {
                     "variants": {
                         "low": { "options": { "thinkingConfig": { "thinkingLevel": "low", "includeThoughts": true } } },
                         "medium": { "options": { "thinkingConfig": { "thinkingLevel": "medium", "includeThoughts": true } } },
-                        "high": { "options": { "thinkingConfig": { "thinkingLevel": "high", "includeThoughts": true } } },
-                        "xhigh": { "options": { "thinkingConfig": { "thinkingLevel": "xhigh", "includeThoughts": true } } }
-                    }
+                        "high": { "options": { "thinkingConfig": { "thinkingLevel": "high", "includeThoughts": true } } },
+                        "xhigh": { "options": { "thinkingConfig": { "thinkingLevel": "xhigh", "includeThoughts": true } } }
+                    }
                 },
                 "gemini-3-flash": {
                     "id": "gemini-3-flash",
@@ -376,9 +411,9 @@ function loadStudioConfig() {
                         "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 } } },
-                        "xhigh": { "options": { "thinkingConfig": { "thinkingLevel": "xhigh", "includeThoughts": true } } }
-                    }
+                        "high": { "options": { "thinkingConfig": { "thinkingLevel": "high", "includeThoughts": true } } },
+                        "xhigh": { "options": { "thinkingConfig": { "thinkingLevel": "xhigh", "includeThoughts": true } } }
+                    }
                 },
                 "gemini-2.5-flash-lite": {
                     "id": "gemini-2.5-flash-lite",
@@ -399,9 +434,9 @@ function loadStudioConfig() {
                         "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 } } },
-                        "xhigh": { "options": { "thinkingConfig": { "thinkingLevel": "xhigh", "includeThoughts": true } } }
-                    }
+                        "high": { "options": { "thinkingConfig": { "thinkingLevel": "high", "includeThoughts": true } } },
+                        "xhigh": { "options": { "thinkingConfig": { "thinkingLevel": "xhigh", "includeThoughts": true } } }
+                    }
                 },
                 "opencode/glm-4.7-free": {
                     "id": "opencode/glm-4.7-free",
@@ -427,9 +462,9 @@ function loadStudioConfig() {
                         "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 } } },
-                        "xhigh": { "options": { "thinkingConfig": { "thinkingBudget": 64000, "includeThoughts": true } } }
-                    }
+                        "high": { "options": { "thinkingConfig": { "thinkingBudget": 32000, "includeThoughts": true } } },
+                        "xhigh": { "options": { "thinkingConfig": { "thinkingBudget": 64000, "includeThoughts": true } } }
+                    }
                 },
                 "gemini-claude-opus-4-5-thinking": {
                     "id": "gemini-claude-opus-4-5-thinking",
@@ -444,9 +479,9 @@ function loadStudioConfig() {
                     "variants": {
                         "low": { "options": { "thinkingConfig": { "thinkingBudget": 4000, "includeThoughts": true } } },
                         "medium": { "options": { "thinkingConfig": { "thinkingBudget": 16000, "includeThoughts": true } } },
-                        "high": { "options": { "thinkingConfig": { "thinkingBudget": 32000, "includeThoughts": true } } },
-                        "xhigh": { "options": { "thinkingConfig": { "thinkingBudget": 64000, "includeThoughts": true } } }
-                    }
+                        "high": { "options": { "thinkingConfig": { "thinkingBudget": 32000, "includeThoughts": true } } },
+                        "xhigh": { "options": { "thinkingConfig": { "thinkingBudget": 64000, "includeThoughts": true } } }
+                    }
                 }
             }
         }
@@ -511,15 +546,15 @@ const getPaths = () => {
         }
     }
 
-    const studioConfig = loadStudioConfig();
-    let manualPath = studioConfig.configPath;
-
-    if (manualPath && fs.existsSync(manualPath) && fs.statSync(manualPath).isDirectory()) {
-        const potentialFile = path.join(manualPath, 'opencode.json');
-        if (fs.existsSync(potentialFile)) {
-            manualPath = potentialFile;
-        }
-    }
+    const studioConfig = loadStudioConfig();
+    let manualPath = studioConfig.configPath;
+
+    if (manualPath && fs.existsSync(manualPath) && fs.statSync(manualPath).isDirectory()) {
+        const potentialFile = path.join(manualPath, 'opencode.json');
+        if (fs.existsSync(potentialFile)) {
+            manualPath = potentialFile;
+        }
+    }
 
     let detected = null;
     for (const p of candidates) {
@@ -543,7 +578,101 @@ const getOhMyOpenCodeConfigPath = () => {
     return path.join(path.dirname(cp), 'oh-my-opencode.json');
 };
 
-const getConfigPath = () => getPaths().current;
+const getConfigPath = () => getPaths().current;
+
+const getAgentDirs = () => {
+    const dirs = [];
+    const configPath = getConfigPath();
+    const configDir = configPath ? path.dirname(configPath) : null;
+
+    if (configDir) {
+        dirs.push(path.join(configDir, '.opencode', 'agents'));
+        dirs.push(path.join(configDir, '.opencode', 'agent'));
+    }
+
+    const xdg = process.env.XDG_CONFIG_HOME;
+    if (xdg) {
+        dirs.push(path.join(xdg, 'opencode', 'agents'));
+        dirs.push(path.join(xdg, 'opencode', 'agent'));
+    }
+
+    dirs.push(path.join(HOME_DIR, '.config', 'opencode', 'agents'));
+    dirs.push(path.join(HOME_DIR, '.config', 'opencode', 'agent'));
+
+    return [...new Set(dirs)];
+};
+
+const parseAgentMarkdown = (content) => {
+    const match = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?([\s\S]*)$/);
+    if (!match) return { data: {}, body: content };
+    let data = {};
+    try {
+        data = yaml.load(match[1]) || {};
+    } catch {
+        data = {};
+    }
+    return { data, body: match[2] || '' };
+};
+
+const buildAgentMarkdown = (frontmatter, body) => {
+    const yamlText = yaml.dump(frontmatter, { lineWidth: 120, noRefs: true, quotingType: '"' });
+    const content = body || '';
+    return `---\n${yamlText}---\n\n${content}`;
+};
+
+const validatePermissionValue = (value) => {
+    const allowed = ['ask', 'allow', 'deny'];
+    if (value === undefined || value === null) return true;
+    if (typeof value === 'string') return allowed.includes(value);
+    if (typeof value !== 'object') return false;
+
+    const keys = Object.keys(value);
+    const isAllowDeny = keys.every((k) => k === 'allow' || k === 'deny');
+    if (isAllowDeny) {
+        return (!value.allow || Array.isArray(value.allow)) && (!value.deny || Array.isArray(value.deny));
+    }
+
+    for (const v of Object.values(value)) {
+        if (typeof v === 'string') {
+            if (!allowed.includes(v)) return false;
+        } else if (typeof v === 'object') {
+            if (!validatePermissionValue(v)) return false;
+        } else if (v !== undefined && v !== null) {
+            return false;
+        }
+    }
+    return true;
+};
+
+const findRulesFile = () => {
+    const configPath = getConfigPath();
+    if (!configPath) return { path: null, source: 'none' };
+
+    let dir = path.dirname(configPath);
+    let last = null;
+    while (dir && dir !== last) {
+        const agentsPath = path.join(dir, 'AGENTS.md');
+        if (fs.existsSync(agentsPath)) return { path: agentsPath, source: 'AGENTS.md' };
+        const claudePath = path.join(dir, 'CLAUDE.md');
+        if (fs.existsSync(claudePath)) return { path: claudePath, source: 'CLAUDE.md' };
+        last = dir;
+        dir = path.dirname(dir);
+    }
+
+    return { path: null, source: 'none' };
+};
+
+const detectTool = (tool) => {
+    const command = process.platform === 'win32' ? `where ${tool}` : `which ${tool}`;
+    try {
+        const output = execSync(command, { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+        if (!output) return { name: tool, available: false };
+        const first = output.split(/\r?\n/)[0];
+        return { name: tool, available: true, path: first };
+    } catch {
+        return { name: tool, available: false };
+    }
+};
 
 const loadConfig = () => {
     const configPath = getConfigPath();
@@ -625,20 +754,20 @@ app.get('/api/debug/auth', (req, res) => {
     });
 });
 
-app.post('/api/paths', (req, res) => {
-    const { configPath } = req.body;
-    const studioConfig = loadStudioConfig();
-    
-    if (configPath && fs.existsSync(configPath) && fs.statSync(configPath).isDirectory()) {
-        const potentialFile = path.join(configPath, 'opencode.json');
-        studioConfig.configPath = potentialFile;
-    } else {
-        studioConfig.configPath = configPath;
-    }
-    
-    saveStudioConfig(studioConfig);
-    res.json({ success: true, current: getConfigPath() });
-});
+app.post('/api/paths', (req, res) => {
+    const { configPath } = req.body;
+    const studioConfig = loadStudioConfig();
+    
+    if (configPath && fs.existsSync(configPath) && fs.statSync(configPath).isDirectory()) {
+        const potentialFile = path.join(configPath, 'opencode.json');
+        studioConfig.configPath = potentialFile;
+    } else {
+        studioConfig.configPath = configPath;
+    }
+    
+    saveStudioConfig(studioConfig);
+    res.json({ success: true, current: getConfigPath() });
+});
 
 app.get('/api/config', (req, res) => {
     const config = loadConfig();
@@ -648,6 +777,9 @@ app.get('/api/config', (req, res) => {
 
 app.post('/api/config', (req, res) => {
     try {
+        if (!validatePermissionValue(req.body?.permission)) {
+            return res.status(400).json({ error: 'Invalid permission value. Must be ask, allow, or deny.' });
+        }
         saveConfig(req.body);
         triggerGitHubAutoSync();
         res.json({ success: true });
@@ -655,6 +787,286 @@ app.post('/api/config', (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
+
+app.get('/api/agents', (req, res) => {
+    try {
+        const config = loadConfig() || {};
+        const studio = loadStudioConfig();
+        const disabledAgents = studio.disabledAgents || [];
+        const agentMap = new Map();
+
+        const configAgents = config.agent || {};
+        for (const [name, agentConfig] of Object.entries(configAgents)) {
+            agentMap.set(name, {
+                name,
+                source: 'json',
+                disabled: disabledAgents.includes(name),
+                ...agentConfig,
+                permission: agentConfig.permission || agentConfig.permissions,
+                permissions: agentConfig.permission || agentConfig.permissions
+            });
+        }
+
+        for (const dir of getAgentDirs()) {
+            if (!fs.existsSync(dir)) continue;
+            const files = fs.readdirSync(dir).filter((f) => f.endsWith('.md'));
+            files.forEach((file) => {
+                const fp = path.join(dir, file);
+                const content = fs.readFileSync(fp, 'utf8');
+                const { data, body } = parseAgentMarkdown(content);
+                const name = path.basename(file, '.md');
+                agentMap.set(name, {
+                    name,
+                    source: 'markdown',
+                    disabled: disabledAgents.includes(name),
+                    description: data.description,
+                    mode: data.mode,
+                    model: data.model,
+                    temperature: data.temperature,
+                    tools: data.tools,
+                    permission: data.permission,
+                    permissions: data.permission,
+                    maxSteps: data.maxSteps,
+                    disable: data.disable,
+                    hidden: data.hidden,
+                    prompt: body
+                });
+            });
+        }
+
+        ['build', 'plan'].forEach((name) => {
+            if (!agentMap.has(name)) {
+                agentMap.set(name, { name, source: 'builtin', mode: 'primary', disabled: disabledAgents.includes(name) });
+            }
+        });
+
+        res.json({ agents: Array.from(agentMap.values()) });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+app.post('/api/agents', (req, res) => {
+    try {
+        const { name, config: agentConfig, source, scope } = req.body || {};
+        if (!name || typeof name !== 'string') return res.status(400).json({ error: 'Missing agent name' });
+        if (!/^[a-zA-Z0-9 _-]+$/.test(name)) return res.status(400).json({ error: 'Invalid agent name' });
+
+        const config = loadConfig() || {};
+        if (!config.agent) config.agent = {};
+
+        const normalizedConfig = { ...(agentConfig || {}) };
+        if (normalizedConfig.permissions && !normalizedConfig.permission) {
+            normalizedConfig.permission = normalizedConfig.permissions;
+            delete normalizedConfig.permissions;
+        }
+
+        const shouldWriteMarkdown = source === 'markdown' || !!normalizedConfig?.mode;
+        if (shouldWriteMarkdown) {
+            const configPath = getConfigPath();
+            const baseDir = configPath ? path.dirname(configPath) : HOME_DIR;
+            const projectDir = path.join(baseDir, '.opencode', 'agents');
+            const globalDir = path.join(HOME_DIR, '.config', 'opencode', 'agents');
+            const targetDir = scope === 'project' ? projectDir : globalDir;
+            if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
+
+            const frontmatter = {
+                description: normalizedConfig?.description,
+                mode: normalizedConfig?.mode,
+                model: normalizedConfig?.model,
+                temperature: normalizedConfig?.temperature,
+                tools: normalizedConfig?.tools,
+                permission: normalizedConfig?.permission,
+                maxSteps: normalizedConfig?.maxSteps,
+                disable: normalizedConfig?.disable,
+                hidden: normalizedConfig?.hidden
+            };
+
+            const markdown = buildAgentMarkdown(frontmatter, normalizedConfig?.prompt || '');
+            atomicWriteFileSync(path.join(targetDir, `${name}.md`), markdown);
+
+            if (config.agent[name]) {
+                delete config.agent[name];
+                saveConfig(config);
+            }
+        } else {
+            config.agent[name] = normalizedConfig;
+            saveConfig(config);
+        }
+
+        triggerGitHubAutoSync();
+        res.json({ success: true });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+app.put('/api/agents/:name', (req, res) => {
+    try {
+        const { name } = req.params;
+        const { config: agentConfig } = req.body || {};
+
+        const normalizedConfig = { ...(agentConfig || {}) };
+        if (normalizedConfig.permissions && !normalizedConfig.permission) {
+            normalizedConfig.permission = normalizedConfig.permissions;
+            delete normalizedConfig.permissions;
+        }
+
+        const config = loadConfig() || {};
+        if (!config.agent) config.agent = {};
+
+        const markdownDirs = getAgentDirs().filter((d) => fs.existsSync(d));
+        const markdownPath = markdownDirs
+            .map((d) => path.join(d, `${name}.md`))
+            .find((p) => fs.existsSync(p));
+
+        if (markdownPath) {
+            const frontmatter = {
+                description: normalizedConfig?.description,
+                mode: normalizedConfig?.mode,
+                model: normalizedConfig?.model,
+                temperature: normalizedConfig?.temperature,
+                tools: normalizedConfig?.tools,
+                permission: normalizedConfig?.permission,
+                maxSteps: normalizedConfig?.maxSteps,
+                disable: normalizedConfig?.disable,
+                hidden: normalizedConfig?.hidden
+            };
+            const markdown = buildAgentMarkdown(frontmatter, normalizedConfig?.prompt || '');
+            atomicWriteFileSync(markdownPath, markdown);
+        } else {
+            config.agent[name] = normalizedConfig;
+            saveConfig(config);
+        }
+
+        triggerGitHubAutoSync();
+        res.json({ success: true });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+app.delete('/api/agents/:name', (req, res) => {
+    try {
+        const { name } = req.params;
+        const config = loadConfig() || {};
+
+        if (config.agent && config.agent[name]) {
+            delete config.agent[name];
+            saveConfig(config);
+        }
+
+        for (const dir of getAgentDirs()) {
+            const fp = path.join(dir, `${name}.md`);
+            if (fs.existsSync(fp)) fs.unlinkSync(fp);
+        }
+
+        triggerGitHubAutoSync();
+        res.json({ success: true });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+app.post('/api/agents/:name/toggle', (req, res) => {
+    try {
+        const { name } = req.params;
+        const studio = loadStudioConfig();
+        const disabled = new Set(studio.disabledAgents || []);
+        if (disabled.has(name)) disabled.delete(name); else disabled.add(name);
+        studio.disabledAgents = Array.from(disabled);
+        saveStudioConfig(studio);
+        res.json({ success: true, disabled: studio.disabledAgents.includes(name) });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+app.get('/api/logs/stream', (req, res) => {
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    if (res.flushHeaders) res.flushHeaders();
+
+    setupLogWatcher();
+
+    const sub = { res, queue: [], draining: false, closed: false };
+    logSubscribers.add(sub);
+
+    logBuffer.forEach((entry) => {
+        sub.queue.push(`data: ${JSON.stringify(entry)}\n\n`);
+    });
+    flushSubscriber(sub);
+
+    const keepalive = setInterval(() => {
+        if (sub.closed) return;
+        res.write(': keepalive\n\n');
+    }, 20000);
+
+    req.on('close', () => {
+        sub.closed = true;
+        clearInterval(keepalive);
+        logSubscribers.delete(sub);
+        try { res.end(); } catch {}
+    });
+});
+
+app.get('/api/system/tools', (req, res) => {
+    const knownTools = [
+        'go', 'gofmt', 'gopls',
+        'rust-analyzer', 'rustfmt',
+        'prettier', 'eslint',
+        'typescript-language-server', 'tsserver',
+        'pyright', 'ruff', 'python',
+        'clangd', 'clang-format',
+        'dart', 'jdtls',
+        'kotlin-language-server', 'ktlint',
+        'deno', 'lua-language-server',
+        'ocamllsp', 'nixd',
+        'swift', 'sourcekit-lsp'
+    ];
+
+    const tools = knownTools.map((tool) => detectTool(tool));
+    res.json(tools);
+});
+
+app.get('/api/project/rules', (req, res) => {
+    try {
+        const found = findRulesFile();
+        if (!found.path) return res.json({ content: '', source: 'none', path: null });
+        const content = fs.readFileSync(found.path, 'utf8');
+        res.json({ content, source: found.source, path: found.path });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+app.post('/api/project/rules', (req, res) => {
+    try {
+        const { content, source } = req.body || {};
+        const configPath = getConfigPath();
+        if (!configPath) return res.status(400).json({ error: 'No config path found' });
+
+        const targetName = source === 'CLAUDE.md' ? 'CLAUDE.md' : 'AGENTS.md';
+        const found = findRulesFile();
+
+        let targetPath = null;
+        if (found.path && path.basename(found.path) === targetName) {
+            targetPath = found.path;
+        }
+
+        if (!targetPath) {
+            const baseDir = path.dirname(configPath);
+            targetPath = path.join(baseDir, targetName);
+        }
+
+        atomicWriteFileSync(targetPath, content || '');
+        res.json({ success: true, path: targetPath, source: targetName });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
 
 app.get('/api/backup', (req, res) => {
     try {
@@ -1110,11 +1522,11 @@ app.post('/api/ohmyopencode', (req, res) => {
         
         saveOhMyOpenCodeConfig(currentConfig);
         
-        const ohMyPath = getOhMyOpenCodeConfigPath();
-        triggerGitHubAutoSync();
-        res.json({ 
-            success: true, 
-            path: ohMyPath,
+        const ohMyPath = getOhMyOpenCodeConfigPath();
+        triggerGitHubAutoSync();
+        res.json({ 
+            success: true, 
+            path: ohMyPath,
             exists: true, 
             config: currentConfig, 
             preferences, 
@@ -1218,107 +1630,107 @@ function execPromise(cmd, opts = {}) {
     });
 }
 
-
-let autoSyncTimer = null;
-
-async function performGitHubBackup(options = {}) {
-    const { owner, repo, branch } = options;
-    let tempDir = null;
-    try {
-        const token = await getGitHubToken();
-        if (!token) throw new Error('Not logged in to gh CLI. Run: gh auth login');
-        
-        const user = await getGitHubUser(token);
-        if (!user) throw new Error('Failed to get GitHub user');
-        
-        const studio = loadStudioConfig();
-        
-        const finalOwner = owner || studio.githubBackup?.owner || user.login;
-        const finalRepo = repo || studio.githubBackup?.repo;
-        const finalBranch = branch || studio.githubBackup?.branch || 'main';
-        
-        if (!finalRepo) throw new Error('No repo name provided');
-        
-        const repoName = `${finalOwner}/${finalRepo}`;
-        
-        await ensureGitHubRepo(token, repoName);
-        
-        const opencodeConfig = getConfigPath();
-        if (!opencodeConfig) throw new Error('No opencode config path found');
-        
-        const opencodeDir = path.dirname(opencodeConfig);
-        const studioDir = path.join(HOME_DIR, '.config', 'opencode-studio');
-        
-        tempDir = path.join(os.tmpdir(), `opencode-backup-${Date.now()}`);
-        fs.mkdirSync(tempDir, { recursive: true });
-        
-        // Clone or init
-        try {
-            await execPromise(`git clone --depth 1 https://x-access-token:${token}@github.com/${repoName}.git .`, { cwd: tempDir });
-        } catch (e) {
-            // If clone fails (empty repo?), try init
-            await execPromise('git init', { cwd: tempDir });
-            await execPromise(`git remote add origin https://x-access-token:${token}@github.com/${repoName}.git`, { cwd: tempDir });
-            await execPromise(`git checkout -b ${finalBranch}`, { cwd: tempDir });
-        }
-        
-        const backupOpencodeDir = path.join(tempDir, 'opencode');
-        const backupStudioDir = path.join(tempDir, 'opencode-studio');
-        
-        if (fs.existsSync(backupOpencodeDir)) fs.rmSync(backupOpencodeDir, { recursive: true });
-        if (fs.existsSync(backupStudioDir)) fs.rmSync(backupStudioDir, { recursive: true });
-        
-        copyDirContents(opencodeDir, backupOpencodeDir);
-        copyDirContents(studioDir, backupStudioDir);
-        
-        await execPromise('git add -A', { cwd: tempDir });
-        
-        const timestamp = new Date().toISOString();
-        const commitMessage = `OpenCode Studio backup ${timestamp}`;
-        
-        let result = { success: true, timestamp, url: `https://github.com/${repoName}` };
-        
-        try {
-            await execPromise(`git commit -m "${commitMessage}"`, { cwd: tempDir });
-            await execPromise(`git push origin ${finalBranch}`, { cwd: tempDir });
-        } catch (e) {
-            if (e.message.includes('nothing to commit')) {
-                result.message = 'No changes to backup';
-            } else {
-                throw e;
-            }
-        }
-        
-        studio.githubBackup = { owner: finalOwner, repo: finalRepo, branch: finalBranch };
-        studio.lastGithubBackup = timestamp;
-        saveStudioConfig(studio);
-        
-        return result;
-    } finally {
-        if (tempDir && fs.existsSync(tempDir)) {
-            try { fs.rmSync(tempDir, { recursive: true }); } catch (e) {}
-        }
-    }
-}
-
-function triggerGitHubAutoSync() {
-    const studio = loadStudioConfig();
-    if (!studio.githubAutoSync) return;
-
-    if (autoSyncTimer) clearTimeout(autoSyncTimer);
-    
-    console.log('[AutoSync] Change detected, scheduling GitHub backup in 15s...');
-    autoSyncTimer = setTimeout(async () => {
-        console.log('[AutoSync] Starting GitHub backup...');
-        try {
-            const result = await performGitHubBackup();
-            console.log(`[AutoSync] Backup completed: ${result.message || 'Pushed to GitHub'}`);
-        } catch (err) {
-            console.error('[AutoSync] Backup failed:', err.message);
-        }
-    }, 15000); // 15s debounce
-}
-
+
+let autoSyncTimer = null;
+
+async function performGitHubBackup(options = {}) {
+    const { owner, repo, branch } = options;
+    let tempDir = null;
+    try {
+        const token = await getGitHubToken();
+        if (!token) throw new Error('Not logged in to gh CLI. Run: gh auth login');
+        
+        const user = await getGitHubUser(token);
+        if (!user) throw new Error('Failed to get GitHub user');
+        
+        const studio = loadStudioConfig();
+        
+        const finalOwner = owner || studio.githubBackup?.owner || user.login;
+        const finalRepo = repo || studio.githubBackup?.repo;
+        const finalBranch = branch || studio.githubBackup?.branch || 'main';
+        
+        if (!finalRepo) throw new Error('No repo name provided');
+        
+        const repoName = `${finalOwner}/${finalRepo}`;
+        
+        await ensureGitHubRepo(token, repoName);
+        
+        const opencodeConfig = getConfigPath();
+        if (!opencodeConfig) throw new Error('No opencode config path found');
+        
+        const opencodeDir = path.dirname(opencodeConfig);
+        const studioDir = path.join(HOME_DIR, '.config', 'opencode-studio');
+        
+        tempDir = path.join(os.tmpdir(), `opencode-backup-${Date.now()}`);
+        fs.mkdirSync(tempDir, { recursive: true });
+        
+        // Clone or init
+        try {
+            await execPromise(`git clone --depth 1 https://x-access-token:${token}@github.com/${repoName}.git .`, { cwd: tempDir });
+        } catch (e) {
+            // If clone fails (empty repo?), try init
+            await execPromise('git init', { cwd: tempDir });
+            await execPromise(`git remote add origin https://x-access-token:${token}@github.com/${repoName}.git`, { cwd: tempDir });
+            await execPromise(`git checkout -b ${finalBranch}`, { cwd: tempDir });
+        }
+        
+        const backupOpencodeDir = path.join(tempDir, 'opencode');
+        const backupStudioDir = path.join(tempDir, 'opencode-studio');
+        
+        if (fs.existsSync(backupOpencodeDir)) fs.rmSync(backupOpencodeDir, { recursive: true });
+        if (fs.existsSync(backupStudioDir)) fs.rmSync(backupStudioDir, { recursive: true });
+        
+        copyDirContents(opencodeDir, backupOpencodeDir);
+        copyDirContents(studioDir, backupStudioDir);
+        
+        await execPromise('git add -A', { cwd: tempDir });
+        
+        const timestamp = new Date().toISOString();
+        const commitMessage = `OpenCode Studio backup ${timestamp}`;
+        
+        let result = { success: true, timestamp, url: `https://github.com/${repoName}` };
+        
+        try {
+            await execPromise(`git commit -m "${commitMessage}"`, { cwd: tempDir });
+            await execPromise(`git push origin ${finalBranch}`, { cwd: tempDir });
+        } catch (e) {
+            if (e.message.includes('nothing to commit')) {
+                result.message = 'No changes to backup';
+            } else {
+                throw e;
+            }
+        }
+        
+        studio.githubBackup = { owner: finalOwner, repo: finalRepo, branch: finalBranch };
+        studio.lastGithubBackup = timestamp;
+        saveStudioConfig(studio);
+        
+        return result;
+    } finally {
+        if (tempDir && fs.existsSync(tempDir)) {
+            try { fs.rmSync(tempDir, { recursive: true }); } catch (e) {}
+        }
+    }
+}
+
+function triggerGitHubAutoSync() {
+    const studio = loadStudioConfig();
+    if (!studio.githubAutoSync) return;
+
+    if (autoSyncTimer) clearTimeout(autoSyncTimer);
+    
+    console.log('[AutoSync] Change detected, scheduling GitHub backup in 15s...');
+    autoSyncTimer = setTimeout(async () => {
+        console.log('[AutoSync] Starting GitHub backup...');
+        try {
+            const result = await performGitHubBackup();
+            console.log(`[AutoSync] Backup completed: ${result.message || 'Pushed to GitHub'}`);
+        } catch (err) {
+            console.error('[AutoSync] Backup failed:', err.message);
+        }
+    }, 15000); // 15s debounce
+}
+
 app.get('/api/github/backup/status', async (req, res) => {
     try {
         const token = await getGitHubToken();
@@ -1350,15 +1762,15 @@ app.get('/api/github/backup/status', async (req, res) => {
     }
 });
 
-app.post('/api/github/backup', async (req, res) => {
-    try {
-        const result = await performGitHubBackup(req.body);
-        res.json(result);
-    } catch (err) {
-        console.error('GitHub backup error:', err);
-        res.status(500).json({ error: err.message });
-    }
-});
+app.post('/api/github/backup', async (req, res) => {
+    try {
+        const result = await performGitHubBackup(req.body);
+        res.json(result);
+    } catch (err) {
+        console.error('GitHub backup error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
 
 app.post('/api/github/restore', async (req, res) => {
     let tempDir = null;
@@ -1417,10 +1829,10 @@ app.post('/api/github/restore', async (req, res) => {
 app.post('/api/github/autosync', async (req, res) => {
     const studio = loadStudioConfig();
     const enabled = req.body.enabled;
-    studio.githubAutoSync = enabled;
-    saveStudioConfig(studio);
-    if (enabled) triggerGitHubAutoSync();
-    res.json({ success: true, enabled });
+    studio.githubAutoSync = enabled;
+    saveStudioConfig(studio);
+    if (enabled) triggerGitHubAutoSync();
+    res.json({ success: true, enabled });
 });
 
 const getSkillDir = () => {
@@ -1457,9 +1869,9 @@ app.post('/api/skills/:name', (req, res) => {
     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');
-    triggerGitHubAutoSync();
-    res.json({ success: true });
+    fs.writeFileSync(path.join(dp, 'SKILL.md'), req.body.content, 'utf8');
+    triggerGitHubAutoSync();
+    res.json({ success: true });
 });
 
 app.delete('/api/skills/:name', (req, res) => {
@@ -1468,9 +1880,9 @@ app.delete('/api/skills/:name', (req, res) => {
     }
     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 });
-    triggerGitHubAutoSync();
-    res.json({ success: true });
+    if (dp && fs.existsSync(dp)) fs.rmSync(dp, { recursive: true, force: true });
+    triggerGitHubAutoSync();
+    res.json({ success: true });
 });
 
 app.post('/api/skills/:name/toggle', (req, res) => {
@@ -1484,9 +1896,9 @@ app.post('/api/skills/:name/toggle', (req, res) => {
         studio.disabledSkills.push(name);
     }
     
-    saveStudioConfig(studio);
-    triggerGitHubAutoSync();
-    res.json({ success: true, enabled: !studio.disabledSkills.includes(name) });
+    saveStudioConfig(studio);
+    triggerGitHubAutoSync();
+    res.json({ success: true, enabled: !studio.disabledSkills.includes(name) });
 });
 
 const getPluginDir = () => {
@@ -1563,10 +1975,10 @@ app.post('/api/plugins/:name', (req, res) => {
     if (!fs.existsSync(pd)) fs.mkdirSync(pd, { recursive: true });
     
     // Default to .js if new
-    const filePath = path.join(pd, name.endsWith('.js') || name.endsWith('.ts') ? name : name + '.js');
-    atomicWriteFileSync(filePath, content);
-    triggerGitHubAutoSync();
-    res.json({ success: true });
+    const filePath = path.join(pd, name.endsWith('.js') || name.endsWith('.ts') ? name : name + '.js');
+    atomicWriteFileSync(filePath, content);
+    triggerGitHubAutoSync();
+    res.json({ success: true });
 });
 
 app.delete('/api/plugins/:name', (req, res) => {
@@ -1591,10 +2003,10 @@ app.delete('/api/plugins/:name', (req, res) => {
         }
     }
     
-    if (deleted) {
-        triggerGitHubAutoSync();
-        res.json({ success: true });
-    } else res.status(404).json({ error: 'Plugin not found' });
+    if (deleted) {
+        triggerGitHubAutoSync();
+        res.json({ success: true });
+    } else res.status(404).json({ error: 'Plugin not found' });
 });
 
 app.post('/api/plugins/:name/toggle', (req, res) => {
@@ -1608,9 +2020,9 @@ app.post('/api/plugins/:name/toggle', (req, res) => {
         studio.disabledPlugins.push(name);
     }
     
-    saveStudioConfig(studio);
-    triggerGitHubAutoSync();
-    res.json({ success: true, enabled: !studio.disabledPlugins.includes(name) });
+    saveStudioConfig(studio);
+    triggerGitHubAutoSync();
+    res.json({ success: true, enabled: !studio.disabledPlugins.includes(name) });
 });
 
 const getActiveGooglePlugin = () => {
@@ -3504,23 +3916,23 @@ app.post('/api/presets/:id/apply', (req, res) => {
     res.json({ success: true });
 });
 
-// Start watcher on server start
-async function startServer() {
-    ['google', 'anthropic', 'openai', 'xai', 'openrouter', 'together', 'mistral', 'deepseek', 'amazon-bedrock', 'azure', 'github-copilot'].forEach(p => importCurrentAuthToPool(p));
-
-    const port = await findAvailablePort(DEFAULT_PORT);
-    app.listen(port, () => {
-        console.log(`Server running at http://localhost:${port}`);
-        // Initial sync on startup if enabled
-        setTimeout(() => {
-            const studio = loadStudioConfig();
-            if (studio.githubAutoSync) {
-                console.log('[AutoSync] Triggering initial sync...');
-                triggerGitHubAutoSync();
-            }
-        }, 5000);
-    });
-}
+// Start watcher on server start
+async function startServer() {
+    ['google', 'anthropic', 'openai', 'xai', 'openrouter', 'together', 'mistral', 'deepseek', 'amazon-bedrock', 'azure', 'github-copilot'].forEach(p => importCurrentAuthToPool(p));
+
+    const port = await findAvailablePort(DEFAULT_PORT);
+    app.listen(port, () => {
+        console.log(`Server running at http://localhost:${port}`);
+        // Initial sync on startup if enabled
+        setTimeout(() => {
+            const studio = loadStudioConfig();
+            if (studio.githubAutoSync) {
+                console.log('[AutoSync] Triggering initial sync...');
+                triggerGitHubAutoSync();
+            }
+        }, 5000);
+    });
+}
 
 if (require.main === module) {
     startServer();

package/package.json

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