opencode-studio-server 1.27.0 → 1.28.1

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

@@ -341,8 +341,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 } } }
-                    }
+                        "high": { "options": { "thinkingConfig": { "thinkingLevel": "high", "includeThoughts": true } } },
+                        "xhigh": { "options": { "thinkingConfig": { "thinkingLevel": "xhigh", "includeThoughts": true } } }
+                    }
                 },
                 "gemini-3-flash": {
                     "id": "gemini-3-flash",
@@ -359,8 +360,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 } } }
-                    }
+                        "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",
@@ -381,8 +383,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 } } }
-                    }
+                        "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",
@@ -408,8 +411,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 } } }
-                    }
+                        "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",
@@ -424,8 +428,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 } } }
-                    }
+                        "high": { "options": { "thinkingConfig": { "thinkingBudget": 32000, "includeThoughts": true } } },
+                        "xhigh": { "options": { "thinkingConfig": { "thinkingBudget": 64000, "includeThoughts": true } } }
+                    }
                 }
             }
         }
@@ -461,6 +466,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 +488,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;
 
@@ -594,14 +616,15 @@ app.get('/api/config', (req, res) => {
     res.json(config);
 });
 
-app.post('/api/config', (req, res) => {
-    try {
-        saveConfig(req.body);
-        res.json({ success: true });
-    } catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
+app.post('/api/config', (req, res) => {
+    try {
+        saveConfig(req.body);
+        triggerGitHubAutoSync();
+        res.json({ success: true });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
 
 app.get('/api/backup', (req, res) => {
     try {
@@ -1020,56 +1043,57 @@ 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);
-        
+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();
+        triggerGitHubAutoSync();
         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 });
-    }
-});
+            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,130 +1119,102 @@ 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());
-        });
-    });
-}
-
-app.get('/api/github/backup/status', async (req, res) => {
-    try {
-        const token = await getGitHubToken();
-        const studio = loadStudioConfig();
-        const backupConfig = studio.githubBackup || {};
-        
-        if (!token) return res.json({ connected: false, config: backupConfig, error: 'Not logged in to gh CLI. Run: gh auth login' });
-        
-        const user = await getGitHubUser(token);
-        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, autoSync: studio.githubAutoSync || false });
-        }
-        
-        const owner = backupConfig.owner || user.login;
-        const response = await fetch(`https://api.github.com/repos/${owner}/${backupConfig.repo}`, {
-            headers: { 'Authorization': `Bearer ${token}` }
+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 (!response.ok) {
-            return res.json({ connected: true, user: user.login, config: backupConfig, repoExists: false, autoSync: studio.githubAutoSync || false });
-        }
+        if (createRes.ok) {
+            await new Promise(r => setTimeout(r, 2000));
+            return await createRes.json();
+        }
         
-        const data = await response.json();
-        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 });
+        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}`);
+}
 
-app.post('/api/github/backup', async (req, res) => {
+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());
+        });
+    });
+}
+
+
+let autoSyncTimer = null;
+
+async function performGitHubBackup(options = {}) {
+    const { owner, repo, branch } = options;
     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' });
+        if (!token) throw new 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' });
+        if (!user) throw new 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' });
+        if (!finalRepo) throw new 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' });
+        if (!opencodeConfig) throw new Error('No opencode config path found');
         
         const opencodeDir = path.dirname(opencodeConfig);
         const studioDir = path.join(HOME_DIR, '.config', 'opencode-studio');
@@ -1226,7 +1222,15 @@ app.post('/api/github/backup', async (req, res) => {
         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 });
+        // 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');
@@ -1242,94 +1246,154 @@ app.post('/api/github/backup', async (req, res) => {
         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')) {
-                fs.rmSync(tempDir, { recursive: true });
-                return res.json({ success: true, timestamp, message: 'No changes to backup', url: `https://github.com/${repoName}` });
+                result.message = 'No changes to backup';
+            } else {
+                throw e;
             }
-            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 });
+        return result;
+    } finally {
+        if (tempDir && fs.existsSync(tempDir)) {
+            try { fs.rmSync(tempDir, { recursive: true }); } catch (e) {}
+        }
     }
-});
+}
 
-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);
+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);
         }
-        
-        fs.rmSync(tempDir, { recursive: true });
-        
-        res.json({ success: true, message: 'Config restored from GitHub' });
+    }, 15000); // 15s debounce
+}
+
+app.get('/api/github/backup/status', async (req, res) => {
+    try {
+        const token = await getGitHubToken();
+        const studio = loadStudioConfig();
+        const backupConfig = studio.githubBackup || {};
+        
+        if (!token) return res.json({ connected: false, config: backupConfig, error: 'Not logged in to gh CLI. Run: gh auth login' });
+        
+        const user = await getGitHubUser(token);
+        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, autoSync: studio.githubAutoSync || false });
+        }
+        
+        const owner = backupConfig.owner || user.login;
+        const response = await fetch(`https://api.github.com/repos/${owner}/${backupConfig.repo}`, {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        
+        if (!response.ok) {
+            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, autoSync: studio.githubAutoSync || false });
+    } catch (err) {
+        res.json({ connected: false, error: err.message });
+    }
+});
+
+app.post('/api/github/backup', async (req, res) => {
+    try {
+        const result = await performGitHubBackup(req.body);
+        res.json(result);
     } catch (err) {
-        if (tempDir && fs.existsSync(tempDir)) fs.rmSync(tempDir, { recursive: true });
-        console.error('GitHub restore error:', err);
+        console.error('GitHub backup 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;
+
+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);
+    if (enabled) triggerGitHubAutoSync();
     res.json({ success: true, enabled });
-});
-
-const getSkillDir = () => {
+});
+
+const getSkillDir = () => {
     const cp = getConfigPath();
     return cp ? path.join(path.dirname(cp), 'skill') : null;
 };
@@ -1363,8 +1427,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');
-    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) => {
@@ -1373,8 +1438,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 });
-    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) => {
@@ -1388,8 +1454,9 @@ app.post('/api/skills/:name/toggle', (req, res) => {
         studio.disabledSkills.push(name);
     }
     
-    saveStudioConfig(studio);
-    res.json({ success: true, enabled: !studio.disabledSkills.includes(name) });
+    saveStudioConfig(studio);
+    triggerGitHubAutoSync();
+    res.json({ success: true, enabled: !studio.disabledSkills.includes(name) });
 });
 
 const getPluginDir = () => {
@@ -1466,9 +1533,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);
-    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) => {
@@ -1493,8 +1561,10 @@ app.delete('/api/plugins/:name', (req, res) => {
         }
     }
     
-    if (deleted) 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) => {
@@ -1508,8 +1578,9 @@ app.post('/api/plugins/:name/toggle', (req, res) => {
         studio.disabledPlugins.push(name);
     }
     
-    saveStudioConfig(studio);
-    res.json({ success: true, enabled: !studio.disabledPlugins.includes(name) });
+    saveStudioConfig(studio);
+    triggerGitHubAutoSync();
+    res.json({ success: true, enabled: !studio.disabledPlugins.includes(name) });
 });
 
 const getActiveGooglePlugin = () => {
@@ -3406,7 +3477,17 @@ app.post('/api/presets/:id/apply', (req, res) => {
 // Start watcher on server start
 function startServer() {
     ['google', 'anthropic', 'openai', 'xai', 'openrouter', 'together', 'mistral', 'deepseek', 'amazon-bedrock', 'azure', 'github-copilot'].forEach(p => importCurrentAuthToPool(p));
-    app.listen(PORT, () => console.log(`Server running at http://localhost:${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) {

package/package.json

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