opencode-studio-server 1.0.0 → 1.0.1

package/index.js

@@ -1,14 +1,34 @@
-const express = require('express');
-const cors = require('cors');
-const bodyParser = require('body-parser');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { exec, spawn } = require('child_process');
-
-const app = express();
-const PORT = 3001;
-
+const express = require('express');
+const cors = require('cors');
+const bodyParser = require('body-parser');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { exec, spawn } = require('child_process');
+
+const app = express();
+const PORT = 3001;
+const IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+
+let lastActivityTime = Date.now();
+let idleTimer = null;
+
+function resetIdleTimer() {
+    lastActivityTime = Date.now();
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+        console.log('Server idle for 30 minutes, shutting down...');
+        process.exit(0);
+    }, IDLE_TIMEOUT_MS);
+}
+
+resetIdleTimer();
+
+app.use((req, res, next) => {
+    resetIdleTimer();
+    next();
+});
+
 const ALLOWED_ORIGINS = [
     'http://localhost:3000',
     'http://127.0.0.1:3000',
@@ -169,6 +189,11 @@ app.get('/api/health', (req, res) => {
     res.json({ status: 'ok', timestamp: Date.now() });
 });
 
+app.post('/api/shutdown', (req, res) => {
+    res.json({ success: true, message: 'Server shutting down' });
+    setTimeout(() => process.exit(0), 100);
+});
+
 app.get('/api/pending-action', (req, res) => {
     const action = loadPendingAction();
     res.json({ action });
@@ -764,15 +789,16 @@ function saveAuthConfig(config) {
     }
 }
 
-const PROVIDER_DISPLAY_NAMES = {
-    'github-copilot': 'GitHub Copilot',
-    'google': 'Google',
-    'anthropic': 'Anthropic',
-    'openai': 'OpenAI',
-    'zai': 'Z.AI',
-    'xai': 'xAI',
-    'groq': 'Groq',
-    'together': 'Together AI',
+const PROVIDER_DISPLAY_NAMES = {
+    'github-copilot': 'GitHub Copilot',
+    'google': 'Google',
+    'google-gemini-oauth': 'Google Gemini (OAuth)',
+    'anthropic': 'Anthropic',
+    'openai': 'OpenAI',
+    'zai': 'Z.AI',
+    'xai': 'xAI',
+    'groq': 'Groq',
+    'together': 'Together AI',
     'mistral': 'Mistral',
     'deepseek': 'DeepSeek',
     'openrouter': 'OpenRouter',
@@ -780,31 +806,45 @@ const PROVIDER_DISPLAY_NAMES = {
     'azure': 'Azure OpenAI',
 };
 
-app.get('/api/auth', (req, res) => {
-    const authConfig = loadAuthConfig();
-    const authFile = getAuthFile();
-    
-    if (!authConfig) {
-        return res.json({ 
-            credentials: [], 
-            authFile: null,
-            message: 'No auth file found' 
-        });
-    }
-    
-    const credentials = Object.entries(authConfig).map(([id, config]) => {
-        const isExpired = config.expires ? Date.now() > config.expires : false;
-        return {
-            id,
-            name: PROVIDER_DISPLAY_NAMES[id] || id,
-            type: config.type,
-            isExpired,
-            expiresAt: config.expires || null,
-        };
-    });
-    
-    res.json({ credentials, authFile });
-});
+app.get('/api/auth', (req, res) => {
+    const authConfig = loadAuthConfig();
+    const authFile = getAuthFile();
+    const paths = getPaths();
+    
+    let hasGeminiAuthPlugin = false;
+    if (paths && fs.existsSync(paths.opencodeJson)) {
+        try {
+            const config = JSON.parse(fs.readFileSync(paths.opencodeJson, 'utf8'));
+            if (Array.isArray(config.plugin)) {
+                hasGeminiAuthPlugin = config.plugin.some(p => 
+                    typeof p === 'string' && p.includes('opencode-gemini-auth')
+                );
+            }
+        } catch {}
+    }
+    
+    if (!authConfig) {
+        return res.json({ 
+            credentials: [], 
+            authFile: null,
+            message: 'No auth file found',
+            hasGeminiAuthPlugin,
+        });
+    }
+    
+    const credentials = Object.entries(authConfig).map(([id, config]) => {
+        const isExpired = config.expires ? Date.now() > config.expires : false;
+        return {
+            id,
+            name: PROVIDER_DISPLAY_NAMES[id] || id,
+            type: config.type,
+            isExpired,
+            expiresAt: config.expires || null,
+        };
+    });
+    
+    res.json({ credentials, authFile, hasGeminiAuthPlugin });
+});
 
 app.post('/api/auth/login', (req, res) => {
     const { provider } = req.body;
@@ -874,6 +914,203 @@ app.get('/api/auth/providers', (req, res) => {
     res.json(providers);
 });
 
-app.listen(PORT, () => {
-    console.log(`Server running on http://localhost:${PORT}`);
-});
+const AUTH_PROFILES_DIR = path.join(HOME_DIR, '.config', 'opencode-studio', 'auth-profiles');
+
+function ensureAuthProfilesDir() {
+    if (!fs.existsSync(AUTH_PROFILES_DIR)) {
+        fs.mkdirSync(AUTH_PROFILES_DIR, { recursive: true });
+    }
+}
+
+function getProviderProfilesDir(provider) {
+    return path.join(AUTH_PROFILES_DIR, provider);
+}
+
+function listAuthProfiles(provider) {
+    const dir = getProviderProfilesDir(provider);
+    if (!fs.existsSync(dir)) return [];
+    
+    try {
+        return fs.readdirSync(dir)
+            .filter(f => f.endsWith('.json'))
+            .map(f => f.replace('.json', ''));
+    } catch {
+        return [];
+    }
+}
+
+function getNextProfileName(provider) {
+    const existing = listAuthProfiles(provider);
+    let num = 1;
+    while (existing.includes(`account-${num}`)) {
+        num++;
+    }
+    return `account-${num}`;
+}
+
+function saveAuthProfile(provider, profileName, data) {
+    ensureAuthProfilesDir();
+    const dir = getProviderProfilesDir(provider);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const filePath = path.join(dir, `${profileName}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+    return true;
+}
+
+function loadAuthProfile(provider, profileName) {
+    const filePath = path.join(getProviderProfilesDir(provider), `${profileName}.json`);
+    if (!fs.existsSync(filePath)) return null;
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch {
+        return null;
+    }
+}
+
+function deleteAuthProfile(provider, profileName) {
+    const filePath = path.join(getProviderProfilesDir(provider), `${profileName}.json`);
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+        return true;
+    }
+    return false;
+}
+
+function getActiveProfiles() {
+    const studioConfig = loadStudioConfig();
+    return studioConfig.activeProfiles || {};
+}
+
+function setActiveProfile(provider, profileName) {
+    const studioConfig = loadStudioConfig();
+    studioConfig.activeProfiles = studioConfig.activeProfiles || {};
+    studioConfig.activeProfiles[provider] = profileName;
+    saveStudioConfig(studioConfig);
+}
+
+app.get('/api/auth/profiles', (req, res) => {
+    ensureAuthProfilesDir();
+    const activeProfiles = getActiveProfiles();
+    const authConfig = loadAuthConfig() || {};
+    
+    const profiles = {};
+    
+    Object.keys(PROVIDER_DISPLAY_NAMES).forEach(provider => {
+        const providerProfiles = listAuthProfiles(provider);
+        profiles[provider] = {
+            profiles: providerProfiles,
+            active: activeProfiles[provider] || null,
+            hasCurrentAuth: !!authConfig[provider],
+        };
+    });
+    
+    res.json(profiles);
+});
+
+app.get('/api/auth/profiles/:provider', (req, res) => {
+    const { provider } = req.params;
+    const providerProfiles = listAuthProfiles(provider);
+    const activeProfiles = getActiveProfiles();
+    const authConfig = loadAuthConfig() || {};
+    
+    res.json({
+        profiles: providerProfiles,
+        active: activeProfiles[provider] || null,
+        hasCurrentAuth: !!authConfig[provider],
+    });
+});
+
+app.post('/api/auth/profiles/:provider', (req, res) => {
+    const { provider } = req.params;
+    const { name } = req.body;
+    
+    const authConfig = loadAuthConfig();
+    if (!authConfig || !authConfig[provider]) {
+        return res.status(400).json({ error: `No active auth for ${provider} to save` });
+    }
+    
+    const profileName = name || getNextProfileName(provider);
+    const data = authConfig[provider];
+    
+    try {
+        saveAuthProfile(provider, profileName, data);
+        setActiveProfile(provider, profileName);
+        res.json({ success: true, name: profileName });
+    } catch (err) {
+        res.status(500).json({ error: 'Failed to save profile', details: err.message });
+    }
+});
+
+app.post('/api/auth/profiles/:provider/:name/activate', (req, res) => {
+    const { provider, name } = req.params;
+    
+    const profileData = loadAuthProfile(provider, name);
+    if (!profileData) {
+        return res.status(404).json({ error: 'Profile not found' });
+    }
+    
+    const authConfig = loadAuthConfig() || {};
+    authConfig[provider] = profileData;
+    
+    if (saveAuthConfig(authConfig)) {
+        setActiveProfile(provider, name);
+        res.json({ success: true });
+    } else {
+        res.status(500).json({ error: 'Failed to activate profile' });
+    }
+});
+
+app.delete('/api/auth/profiles/:provider/:name', (req, res) => {
+    const { provider, name } = req.params;
+    
+    if (deleteAuthProfile(provider, name)) {
+        const activeProfiles = getActiveProfiles();
+        if (activeProfiles[provider] === name) {
+            const studioConfig = loadStudioConfig();
+            delete studioConfig.activeProfiles[provider];
+            saveStudioConfig(studioConfig);
+        }
+        res.json({ success: true });
+    } else {
+        res.status(404).json({ error: 'Profile not found' });
+    }
+});
+
+app.put('/api/auth/profiles/:provider/:name', (req, res) => {
+    const { provider, name } = req.params;
+    const { newName } = req.body;
+    
+    if (!newName || newName === name) {
+        return res.status(400).json({ error: 'New name is required and must be different' });
+    }
+    
+    const profileData = loadAuthProfile(provider, name);
+    if (!profileData) {
+        return res.status(404).json({ error: 'Profile not found' });
+    }
+    
+    const existingProfiles = listAuthProfiles(provider);
+    if (existingProfiles.includes(newName)) {
+        return res.status(400).json({ error: 'Profile name already exists' });
+    }
+    
+    try {
+        saveAuthProfile(provider, newName, profileData);
+        deleteAuthProfile(provider, name);
+        
+        const activeProfiles = getActiveProfiles();
+        if (activeProfiles[provider] === name) {
+            setActiveProfile(provider, newName);
+        }
+        
+        res.json({ success: true, name: newName });
+    } catch (err) {
+        res.status(500).json({ error: 'Failed to rename profile', details: err.message });
+    }
+});
+
+app.listen(PORT, () => {
+    console.log(`Server running on http://localhost:${PORT}`);
+});

package/launcher.vbs

@@ -0,0 +1,6 @@
+Set WshShell = CreateObject("WScript.Shell")
+args = ""
+If WScript.Arguments.Count > 0 Then
+    args = " """ & WScript.Arguments(0) & """"
+End If
+WshShell.Run """C:\\node\\node.exe""" & " ""C:\\Users\\Microck\\opencode-studio\\server\\cli.js"" " & args, 0, False

package/package.json

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

package/register-protocol.js

@@ -1,13 +1,32 @@
 const { exec } = require('child_process');
 const path = require('path');
 const os = require('os');
+const fs = require('fs');
 
 const PROTOCOL = 'opencodestudio';
 
 function registerWindows() {
-    const nodePath = process.execPath.replace(/\\/g, '\\\\');
-    const scriptPath = path.join(__dirname, 'cli.js').replace(/\\/g, '\\\\');
-    const command = `"${nodePath}" "${scriptPath}" "%1"`;
+    const nodePath = process.execPath;
+    const scriptPath = path.join(__dirname, 'cli.js');
+    
+    // Create a VBScript launcher that runs node hidden
+    const vbsPath = path.join(__dirname, 'launcher.vbs');
+    const vbsContent = `Set WshShell = CreateObject("WScript.Shell")
+args = ""
+If WScript.Arguments.Count > 0 Then
+    args = " """ & WScript.Arguments(0) & """"
+End If
+WshShell.Run """${nodePath.replace(/\\/g, '\\\\')}""" & " ""${scriptPath.replace(/\\/g, '\\\\')}"" " & args, 0, False
+`;
+    
+    try {
+        fs.writeFileSync(vbsPath, vbsContent);
+    } catch (err) {
+        console.error('Failed to create launcher.vbs:', err.message);
+    }
+    
+    // Register protocol to use wscript with the VBS launcher
+    const command = `wscript.exe "${vbsPath.replace(/\\/g, '\\\\')}" "%1"`;
     
     const regCommands = [
         `reg add "HKCU\\Software\\Classes\\${PROTOCOL}" /ve /d "URL:OpenCode Studio Protocol" /f`,