opencode-studio-server 1.26.0 → 1.28.0

package/AGENTS.md

@@ -7,7 +7,6 @@ Express API backend (port 3001). Single-file architecture.
 | File | Purpose |
 |------|---------|
 | `index.js` | All routes, config IO, auth, skills, plugins, usage stats |
-| `proxy-manager.js` | Manages CLIProxyAPI process and config |
 | `cli.js` | npm bin entry, protocol URL parser, pending action queue |
 | `register-protocol.js` | OS-specific `opencodestudio://` handler registration |
 

package/README.md

@@ -31,7 +31,6 @@ The server runs on port **3001** and provides an API for managing your local Ope
 - **Protocol Handler**: `opencodestudio://` support for one-click actions
 - **Config Management**: Reads/writes `~/.config/opencode/opencode.json`
 - **MCP Management**: Add/remove/toggle MCP servers
-- **Proxy Manager**: Manage CLIProxyAPI instance
 - **Auth**: Manage authentication profiles
 
 ## License

package/index.js

@@ -461,6 +461,16 @@ function saveStudioConfig(config) {
     }
 }
 
+const getWslDistributions = () => {
+    try {
+        const { execSync } = require('child_process');
+        const stdout = execSync('wsl.exe -l -q', { encoding: 'utf16le', stdio: ['ignore', 'pipe', 'pipe'], timeout: 1000 });
+        return stdout.trim().split('\n').filter(d => d.length > 0);
+    } catch {
+        return [];
+    }
+};
+
 const getPaths = () => {
     const platform = process.platform;
     const home = os.homedir();
@@ -473,6 +483,13 @@ const getPaths = () => {
         candidates.push(path.join(process.env.APPDATA, 'opencode', 'opencode.json'));
     }
 
+    if (platform === 'win32') {
+        const distros = getWslDistributions();
+        for (const distro of distros) {
+            candidates.push(`\\\\wsl$\\${distro}\\home\\${os.userInfo().username}\\.config\\opencode\\opencode.json`);
+        }
+    }
+
     const studioConfig = loadStudioConfig();
     const manualPath = studioConfig.configPath;
 
@@ -1020,56 +1037,56 @@ app.get('/api/ohmyopencode', (req, res) => {
     res.json({ path: ohMyPath, exists, config, preferences });
 });
 
-app.post('/api/ohmyopencode', (req, res) => {
-    try {
-        const { preferences } = req.body;
-        if (!preferences || !preferences.agents) {
-            return res.status(400).json({ error: 'Missing preferences.agents' });
-        }
-        
-        const studio = loadStudioConfig();
-        studio.ohmy = preferences;
-        saveStudioConfig(studio);
-        
-        const currentConfig = loadOhMyOpenCodeConfig() || {};
-        const warnings = [];
-        
-        for (const [agentName, agentPrefs] of Object.entries(preferences.agents)) {
-            const choices = agentPrefs.choices || [];
-            const available = choices.find(c => c.available);
-            if (available) {
-                if (!currentConfig.agents) currentConfig.agents = {};
-                const agentConfig = { model: available.model };
-                
-                if (available.thinking && available.thinking.type === 'enabled') {
-                    agentConfig.thinking = { type: 'enabled' };
-                }
-                
-                if (available.reasoning && available.reasoning.effort) {
-                    agentConfig.reasoning = { effort: available.reasoning.effort };
-                }
-                
-                currentConfig.agents[agentName] = agentConfig;
-            } else if (choices.length > 0) {
-                warnings.push(`No available model for agent "${agentName}"`);
-            }
-        }
-        
-        saveOhMyOpenCodeConfig(currentConfig);
-        
-        const ohMyPath = getOhMyOpenCodeConfigPath();
-        res.json({ 
-            success: true, 
-            path: ohMyPath, 
-            exists: true, 
-            config: currentConfig, 
-            preferences, 
-            warnings: warnings.length > 0 ? warnings : undefined 
-        });
-    } catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
+app.post('/api/ohmyopencode', (req, res) => {
+    try {
+        const { preferences } = req.body;
+        if (!preferences || !preferences.agents) {
+            return res.status(400).json({ error: 'Missing preferences.agents' });
+        }
+        
+        const studio = loadStudioConfig();
+        studio.ohmy = preferences;
+        saveStudioConfig(studio);
+        
+        const currentConfig = loadOhMyOpenCodeConfig() || {};
+        const warnings = [];
+        
+        for (const [agentName, agentPrefs] of Object.entries(preferences.agents)) {
+            const choices = agentPrefs.choices || [];
+            const available = choices.find(c => c.available);
+            if (available) {
+                if (!currentConfig.agents) currentConfig.agents = {};
+                const agentConfig = { model: available.model };
+                
+                if (available.thinking && available.thinking.type === 'enabled') {
+                    agentConfig.thinking = { type: 'enabled' };
+                }
+                
+                if (available.reasoning && available.reasoning.effort) {
+                    agentConfig.reasoning = { effort: available.reasoning.effort };
+                }
+                
+                currentConfig.agents[agentName] = agentConfig;
+            } else if (choices.length > 0) {
+                warnings.push(`No available model for agent "${agentName}"`);
+            }
+        }
+        
+        saveOhMyOpenCodeConfig(currentConfig);
+        
+        const ohMyPath = getOhMyOpenCodeConfigPath();
+        res.json({ 
+            success: true, 
+            path: ohMyPath, 
+            exists: true, 
+            config: currentConfig, 
+            preferences, 
+            warnings: warnings.length > 0 ? warnings : undefined 
+        });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
 
 // ============================================
 // GITHUB BACKUP
@@ -1095,74 +1112,74 @@ async function getGitHubUser(token) {
     return await response.json();
 }
 
-async function ensureGitHubRepo(token, repoName) {
-    const [owner, repo] = repoName.split('/');
-    
-    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
-        headers: { 'Authorization': `Bearer ${token}` }
-    });
-    
-    if (response.ok) {
-        return await response.json();
-    }
-    
-    if (response.status === 404) {
-        const createRes = await fetch(`https://api.github.com/user/repos`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${token}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({
-                name: repo,
-                private: true,
-                description: 'OpenCode Studio backup',
-                auto_init: true
-            })
-        });
-        
-        if (createRes.ok) {
-            await new Promise(r => setTimeout(r, 2000));
-            return await createRes.json();
-        }
-        
-        const err = await createRes.text();
-        throw new Error(`Failed to create repo: ${err}`);
-    }
-    
-    const err = await response.text();
-    throw new Error(`Failed to check repo: ${err}`);
-}
-
-function copyDirContents(src, dest) {
-    if (!fs.existsSync(src)) return;
-    fs.mkdirSync(dest, { recursive: true });
-    const SKIP_DIRS = ['node_modules', '.git', '.next', 'cache'];
-    const SKIP_EXT = ['.log', '.tmp', '.db', '.sqlite', '.cache', '.pack', '.idx'];
-    
-    for (const name of fs.readdirSync(src)) {
-        const srcPath = path.join(src, name);
-        const destPath = path.join(dest, name);
-        const stat = fs.statSync(srcPath);
-        
-        if (stat.isDirectory()) {
-            if (SKIP_DIRS.includes(name)) continue;
-            copyDirContents(srcPath, destPath);
-        } else {
-            if (SKIP_EXT.some(ext => name.endsWith(ext))) continue;
-            fs.copyFileSync(srcPath, destPath);
-        }
-    }
-}
-
-function execPromise(cmd, opts = {}) {
-    return new Promise((resolve, reject) => {
-        exec(cmd, opts, (err, stdout, stderr) => {
-            if (err) reject(new Error(stderr || err.message));
-            else resolve(stdout.trim());
-        });
-    });
-}
+async function ensureGitHubRepo(token, repoName) {
+    const [owner, repo] = repoName.split('/');
+    
+    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
+        headers: { 'Authorization': `Bearer ${token}` }
+    });
+    
+    if (response.ok) {
+        return await response.json();
+    }
+    
+    if (response.status === 404) {
+        const createRes = await fetch(`https://api.github.com/user/repos`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                name: repo,
+                private: true,
+                description: 'OpenCode Studio backup',
+                auto_init: true
+            })
+        });
+        
+        if (createRes.ok) {
+            await new Promise(r => setTimeout(r, 2000));
+            return await createRes.json();
+        }
+        
+        const err = await createRes.text();
+        throw new Error(`Failed to create repo: ${err}`);
+    }
+    
+    const err = await response.text();
+    throw new Error(`Failed to check repo: ${err}`);
+}
+
+function copyDirContents(src, dest) {
+    if (!fs.existsSync(src)) return;
+    fs.mkdirSync(dest, { recursive: true });
+    const SKIP_DIRS = ['node_modules', '.git', '.next', 'cache'];
+    const SKIP_EXT = ['.log', '.tmp', '.db', '.sqlite', '.cache', '.pack', '.idx'];
+    
+    for (const name of fs.readdirSync(src)) {
+        const srcPath = path.join(src, name);
+        const destPath = path.join(dest, name);
+        const stat = fs.statSync(srcPath);
+        
+        if (stat.isDirectory()) {
+            if (SKIP_DIRS.includes(name)) continue;
+            copyDirContents(srcPath, destPath);
+        } else {
+            if (SKIP_EXT.some(ext => name.endsWith(ext))) continue;
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+function execPromise(cmd, opts = {}) {
+    return new Promise((resolve, reject) => {
+        exec(cmd, opts, (err, stdout, stderr) => {
+            if (err) reject(new Error(stderr || err.message));
+            else resolve(stdout.trim());
+        });
+    });
+}
 
 app.get('/api/github/backup/status', async (req, res) => {
     try {
@@ -1176,7 +1193,7 @@ app.get('/api/github/backup/status', async (req, res) => {
         if (!user) return res.json({ connected: false, config: backupConfig, error: 'Failed to get GitHub user' });
         
         if (!backupConfig.repo) {
-            return res.json({ connected: true, user: user.login, config: backupConfig });
+            return res.json({ connected: true, user: user.login, config: backupConfig, autoSync: studio.githubAutoSync || false });
         }
         
         const owner = backupConfig.owner || user.login;
@@ -1185,87 +1202,149 @@ app.get('/api/github/backup/status', async (req, res) => {
         });
         
         if (!response.ok) {
-            return res.json({ connected: true, user: user.login, config: backupConfig, repoExists: false });
+            return res.json({ connected: true, user: user.login, config: backupConfig, repoExists: false, autoSync: studio.githubAutoSync || false });
         }
         
         const data = await response.json();
-        res.json({ connected: true, user: user.login, config: backupConfig, repoExists: true, lastUpdated: data.pushed_at });
+        res.json({ connected: true, user: user.login, config: backupConfig, repoExists: true, lastUpdated: data.pushed_at, autoSync: studio.githubAutoSync || false });
     } catch (err) {
         res.json({ connected: false, error: err.message });
     }
 });
 
-app.post('/api/github/backup', async (req, res) => {
-    let tempDir = null;
-    try {
-        const token = await getGitHubToken();
-        if (!token) return res.status(400).json({ error: 'Not logged in to gh CLI. Run: gh auth login' });
-        
-        const user = await getGitHubUser(token);
-        if (!user) return res.status(400).json({ error: 'Failed to get GitHub user' });
-        
-        const { owner, repo, branch } = req.body;
-        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) return res.status(400).json({ error: 'No repo name provided' });
-        
-        const repoName = `${finalOwner}/${finalRepo}`;
-        
-        await ensureGitHubRepo(token, repoName);
-        
-        const opencodeConfig = getConfigPath();
-        if (!opencodeConfig) return res.status(400).json({ 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 });
-        
-        await execPromise(`git clone --depth 1 https://x-access-token:${token}@github.com/${repoName}.git .`, { 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}`;
-        
-        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')) {
-                fs.rmSync(tempDir, { recursive: true });
-                return res.json({ success: true, timestamp, message: 'No changes to backup', url: `https://github.com/${repoName}` });
-            }
-            throw e;
-        }
-        
-        fs.rmSync(tempDir, { recursive: true });
-        
-        studio.githubBackup = { owner: finalOwner, repo: finalRepo, branch: finalBranch };
-        studio.lastGithubBackup = timestamp;
-        saveStudioConfig(studio);
-        
-        res.json({ success: true, timestamp, url: `https://github.com/${repoName}` });
-    } catch (err) {
-        if (tempDir && fs.existsSync(tempDir)) fs.rmSync(tempDir, { recursive: true });
-        console.error('GitHub backup error:', err);
-        res.status(500).json({ error: err.message });
-    }
-});
+app.post('/api/github/backup', async (req, res) => {
+    let tempDir = null;
+    try {
+        const token = await getGitHubToken();
+        if (!token) return res.status(400).json({ error: 'Not logged in to gh CLI. Run: gh auth login' });
+        
+        const user = await getGitHubUser(token);
+        if (!user) return res.status(400).json({ error: 'Failed to get GitHub user' });
+        
+        const { owner, repo, branch } = req.body;
+        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) return res.status(400).json({ error: 'No repo name provided' });
+        
+        const repoName = `${finalOwner}/${finalRepo}`;
+        
+        await ensureGitHubRepo(token, repoName);
+        
+        const opencodeConfig = getConfigPath();
+        if (!opencodeConfig) return res.status(400).json({ 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 });
+        
+        await execPromise(`git clone --depth 1 https://x-access-token:${token}@github.com/${repoName}.git .`, { 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}`;
+        
+        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')) {
+                fs.rmSync(tempDir, { recursive: true });
+                return res.json({ success: true, timestamp, message: 'No changes to backup', url: `https://github.com/${repoName}` });
+            }
+            throw e;
+        }
+        
+        fs.rmSync(tempDir, { recursive: true });
+        
+        studio.githubBackup = { owner: finalOwner, repo: finalRepo, branch: finalBranch };
+        studio.lastGithubBackup = timestamp;
+        saveStudioConfig(studio);
+        
+        res.json({ success: true, timestamp, url: `https://github.com/${repoName}` });
+    } catch (err) {
+        if (tempDir && fs.existsSync(tempDir)) fs.rmSync(tempDir, { recursive: true });
+        console.error('GitHub backup error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+app.post('/api/github/restore', async (req, res) => {
+    let tempDir = null;
+    try {
+        const token = await getGitHubToken();
+        if (!token) return res.status(400).json({ error: 'Not logged in to gh CLI. Run: gh auth login' });
+        
+        const user = await getGitHubUser(token);
+        if (!user) return res.status(400).json({ error: 'Failed to get GitHub user' });
+        
+        const { owner, repo, branch } = req.body;
+        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) return res.status(400).json({ error: 'No repo configured' });
+        
+        const repoName = `${finalOwner}/${finalRepo}`;
+        
+        const opencodeConfig = getConfigPath();
+        if (!opencodeConfig) return res.status(400).json({ 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-restore-${Date.now()}`);
+        fs.mkdirSync(tempDir, { recursive: true });
+        
+        await execPromise(`git clone --depth 1 -b ${finalBranch} https://x-access-token:${token}@github.com/${repoName}.git .`, { cwd: tempDir });
+        
+        const backupOpencodeDir = path.join(tempDir, 'opencode');
+        const backupStudioDir = path.join(tempDir, 'opencode-studio');
+        
+        if (!fs.existsSync(backupOpencodeDir)) {
+            fs.rmSync(tempDir, { recursive: true });
+            return res.status(400).json({ error: 'No opencode backup found in repository' });
+        }
+        
+        copyDirContents(backupOpencodeDir, opencodeDir);
+        if (fs.existsSync(backupStudioDir)) {
+            copyDirContents(backupStudioDir, studioDir);
+        }
+        
+        fs.rmSync(tempDir, { recursive: true });
+        
+        res.json({ success: true, message: 'Config restored from GitHub' });
+    } catch (err) {
+        if (tempDir && fs.existsSync(tempDir)) fs.rmSync(tempDir, { recursive: true });
+        console.error('GitHub restore error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+app.post('/api/github/autosync', async (req, res) => {
+    const studio = loadStudioConfig();
+    const enabled = req.body.enabled;
+    studio.githubAutoSync = enabled;
+    saveStudioConfig(studio);
+    res.json({ success: true, enabled });
+});
 
 const getSkillDir = () => {
     const cp = getConfigPath();

package/package.json

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