opencode-studio-server 1.19.0 → 1.21.0

package/index.js

@@ -1027,37 +1027,30 @@ app.post('/api/ohmyopencode', (req, res) => {
             return res.status(400).json({ error: 'Missing preferences.agents' });
         }
         
-        // Save preferences to studio.json
         const studio = loadStudioConfig();
         studio.ohmy = preferences;
         saveStudioConfig(studio);
         
-        // Load current oh-my-opencode.json or start fresh
         const currentConfig = loadOhMyOpenCodeConfig() || {};
         const warnings = [];
         
-        // For each agent, pick first available model and apply thinking/reasoning
         for (const [agentName, agentPrefs] of Object.entries(preferences.agents)) {
             const choices = agentPrefs.choices || [];
             const available = choices.find(c => c.available);
             if (available) {
-                // Set the model in oh-my-opencode.json
                 if (!currentConfig.agents) currentConfig.agents = {};
                 const agentConfig = { model: available.model };
                 
-                // Add thinking config if enabled (for Gemini models)
-                if (agentPrefs.thinking && agentPrefs.thinking.type === 'enabled') {
+                if (available.thinking && available.thinking.type === 'enabled') {
                     agentConfig.thinking = { type: 'enabled' };
                 }
                 
-                // Add reasoning config if set (for OpenAI o-series models)
-                if (agentPrefs.reasoning && agentPrefs.reasoning.effort) {
-                    agentConfig.reasoning = { effort: agentPrefs.reasoning.effort };
+                if (available.reasoning && available.reasoning.effort) {
+                    agentConfig.reasoning = { effort: available.reasoning.effort };
                 }
                 
                 currentConfig.agents[agentName] = agentConfig;
             } else if (choices.length > 0) {
-                // No available model, keep existing or warn
                 warnings.push(`No available model for agent "${agentName}"`);
             }
         }
@@ -1144,40 +1137,34 @@ async function ensureGitHubRepo(token, repoName) {
     throw new Error(`Failed to check repo: ${err}`);
 }
 
-function buildCommitTree(opencodeDir, studioDir, files = {}, basePath = '') {
-    const tree = [];
-    
-    for (const name of fs.readdirSync(basePath || opencodeDir)) {
-        const fullPath = path.join(basePath || opencodeDir, name);
-        const stat = fs.statSync(fullPath);
-        
-        if (stat.isDirectory()) {
-            if (name === 'node_modules' || name === '.git' || name === '.next') continue;
-            const subtree = buildCommitTree(opencodeDir, studioDir, files, fullPath);
-            tree.push({
-                path: path.relative(opencodeDir, fullPath),
-                mode: '040000',
-                type: 'tree',
-                sha: subtree.sha,
-                size: subtree.size
-            });
-            if (subtree.size) tree[tree.length - 1].size = subtree.size;
-        } else {
-            if (name.endsWith('.log') || name.endsWith('.tmp')) continue;
-            const content = fs.readFileSync(fullPath, 'utf8');
-            const size = Buffer.byteLength(content);
-            const blob = { path: path.relative(opencodeDir, fullPath), mode: '100644', type: 'blob', size, content };
-            const blobKey = `${basePath || opencodeDir}/${name}`;
-            files[blobKey] = blob;
-            tree.push(blob);
-        }
-    }
-    
-    return { sha: null, tree };
-}
+function collectBlobs(rootDir, basePath = '', blobs = []) {
+    const dir = basePath || rootDir;
+    if (!fs.existsSync(dir)) return blobs;
+    
+    for (const name of fs.readdirSync(dir)) {
+        const fullPath = path.join(dir, name);
+        const stat = fs.statSync(fullPath);
+        
+        if (stat.isDirectory()) {
+            if (name === 'node_modules' || name === '.git' || name === '.next') continue;
+            collectBlobs(rootDir, fullPath, blobs);
+        } else {
+            if (name.endsWith('.log') || name.endsWith('.tmp')) continue;
+            const content = fs.readFileSync(fullPath, 'utf8');
+            blobs.push({
+                path: path.relative(rootDir, fullPath).replace(/\\/g, '/'),
+                mode: '100644',
+                type: 'blob',
+                content
+            });
+        }
+    }
+    return blobs;
+}
 
-async function createGitHubBlob(token, blob) {
-    const response = await fetch('https://api.github.com/git/blobs', {
+async function createGitHubBlob(token, repoName, blob) {
+    const [owner, repo] = repoName.split('/');
+    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/git/blobs`, {
         method: 'POST',
         headers: {
             'Authorization': `Bearer ${token}`,
@@ -1198,32 +1185,35 @@ async function createGitHubBlob(token, blob) {
     return data.sha;
 }
 
-async function createGitHubTree(token, repoName, treeItems) {
-    const [owner, repo] = repoName.split('/');
-    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/git/trees`, {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${token}`,
-            'Content-Type': 'application/json'
-        },
-        body: JSON.stringify({
-            tree: treeItems.map(item => ({
-                path: item.path,
-                mode: item.mode,
-                type: item.type,
-                sha: item.sha
-            }))
-        })
-    });
-    
-    if (!response.ok) {
-        const err = await response.text();
-        throw new Error(`Failed to create tree: ${err}`);
-    }
-    
-    const data = await response.json();
-    return data.sha;
-}
+async function createGitHubTree(token, repoName, treeItems, baseSha = null) {
+    const [owner, repo] = repoName.split('/');
+    const body = {
+        tree: treeItems.map(item => ({
+            path: item.path,
+            mode: item.mode,
+            type: item.type,
+            sha: item.sha
+        }))
+    };
+    if (baseSha) body.base_tree = baseSha;
+    
+    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/git/trees`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(body)
+    });
+    
+    if (!response.ok) {
+        const err = await response.text();
+        throw new Error(`Failed to create tree: ${err}`);
+    }
+    
+    const data = await response.json();
+    return data.sha;
+}
 
 async function createGitHubCommit(token, repoName, treeSha, message) {
     const [owner, repo] = repoName.split('/');
@@ -1260,25 +1250,49 @@ async function createGitHubCommit(token, repoName, treeSha, message) {
     return data.sha;
 }
 
-async function updateGitHubRef(token, repoName, commitSha, branch = 'main') {
-    const [owner, repo] = repoName.split('/');
-    
-    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/git/refs/heads/${branch}`, {
-        method: 'PATCH',
-        headers: {
-            'Authorization': `Bearer ${token}`,
-            'Content-Type': 'application/json'
-        },
-        body: JSON.stringify({
-            sha: commitSha
-        })
-    });
-    
-    if (!response.status === 200 && response.status !== 201) {
-        const err = await response.text();
-        throw new Error(`Failed to update ref: ${err}`);
-    }
-}
+async function updateGitHubRef(token, repoName, commitSha, branch = 'main') {
+    const [owner, repo] = repoName.split('/');
+    
+    const checkRes = await fetch(`https://api.github.com/repos/${owner}/${repo}/git/refs/heads/${branch}`, {
+        headers: { 'Authorization': `Bearer ${token}` }
+    });
+    
+    if (checkRes.status === 404) {
+        const createRes = await fetch(`https://api.github.com/repos/${owner}/${repo}/git/refs`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                ref: `refs/heads/${branch}`,
+                sha: commitSha
+            })
+        });
+        
+        if (!createRes.ok) {
+            const err = await createRes.text();
+            throw new Error(`Failed to create ref: ${err}`);
+        }
+        return;
+    }
+    
+    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/git/refs/heads/${branch}`, {
+        method: 'PATCH',
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            sha: commitSha
+        })
+    });
+    
+    if (!response.ok) {
+        const err = await response.text();
+        throw new Error(`Failed to update ref: ${err}`);
+    }
+}
 
 app.get('/api/github/backup/status', async (req, res) => {
     try {
@@ -1335,22 +1349,26 @@ app.post('/api/github/backup', async (req, res) => {
         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');
-        
-        const blobs = {};
-        const opencodeTree = buildCommitTree(opencodeDir, studioDir, blobs);
-        const studioTree = buildCommitTree(studioDir, studioDir, {}, studioDir);
-        
-        const opencodeTreeSha = await createGitHubTree(token, repoName, opencodeTree.tree);
-        const studioTreeSha = await createGitHubTree(token, repoName, studioTree.tree);
-        
-        const rootTreeItems = [
-            { path: 'opencode', mode: '040000', type: 'tree', sha: opencodeTreeSha },
-            { path: 'opencode-studio', mode: '040000', type: 'tree', sha: studioTreeSha }
-        ];
-        
-        const rootTreeSha = await createGitHubTree(token, repoName, rootTreeItems);
+        const opencodeDir = path.dirname(opencodeConfig);
+        const studioDir = path.join(HOME_DIR, '.config', 'opencode-studio');
+        
+        const opencodeBlobs = collectBlobs(opencodeDir);
+        const studioBlobs = collectBlobs(studioDir);
+        
+        for (const blob of opencodeBlobs) {
+            blob.sha = await createGitHubBlob(token, repoName, blob);
+            blob.path = `opencode/${blob.path}`;
+            delete blob.content;
+        }
+        
+        for (const blob of studioBlobs) {
+            blob.sha = await createGitHubBlob(token, repoName, blob);
+            blob.path = `opencode-studio/${blob.path}`;
+            delete blob.content;
+        }
+        
+        const allBlobs = [...opencodeBlobs, ...studioBlobs];
+        const rootTreeSha = await createGitHubTree(token, repoName, allBlobs);
         
         const timestamp = new Date().toISOString();
         const commitMessage = `OpenCode Studio backup ${timestamp}`;

package/package.json

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