opencode-studio-server 1.12.13 → 1.13.0

package/AGENTS.md

@@ -7,6 +7,7 @@ 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,6 +31,7 @@ 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

@@ -8,6 +8,7 @@ const crypto = require('crypto');
 const { spawn, exec } = require('child_process');
 
 const pkg = require('./package.json');
+const proxyManager = require('./proxy-manager');
 const SERVER_VERSION = pkg.version;
 
 // Atomic file write: write to temp file then rename to prevent corruption
@@ -1406,22 +1407,6 @@ app.get('/api/auth/providers', (req, res) => {
 });
 
 app.get('/api/auth', (req, res) => {
-    importCurrentGoogleAuthToPool();
-    syncAntigravityPool();
-    const authCfg = loadAuthConfig() || {};
-    const studio = loadStudioConfig();
-    const ac = studio.activeProfiles || {};
-    const credentials = [];
-    const activePlugin = studio.activeGooglePlugin;
-    
-    // DEBUG LOGGING
-    console.log('--- Auth Debug ---');
-    console.log('Active Google Plugin:', activePlugin);
-    console.log('Found keys in authCfg:', Object.keys(authCfg));
-    if (authCfg.google) console.log('Google Auth found!');
-    if (authCfg['google.antigravity']) console.log('google.antigravity found!');
-    if (authCfg['google.gemini']) console.log('google.gemini found!');
-    
     const providers = [
         { id: 'google', name: 'Google', type: 'oauth' },
         { id: 'anthropic', name: 'Anthropic', type: 'api' },
@@ -1436,6 +1421,15 @@ app.get('/api/auth', (req, res) => {
         { id: 'azure', name: 'Azure OpenAI', type: 'api' }
     ];
 
+    providers.forEach(p => importCurrentAuthToPool(p.id));
+    syncAntigravityPool();
+
+    const authCfg = loadAuthConfig() || {};
+    const studio = loadStudioConfig();
+    const ac = studio.activeProfiles || {};
+    const credentials = [];
+    const activePlugin = studio.activeGooglePlugin;
+
     const opencodeCfg = loadConfig();
     const currentPlugins = opencodeCfg?.plugin || [];
     
@@ -1483,13 +1477,15 @@ app.get('/api/auth', (req, res) => {
 });
 
 app.get('/api/auth/profiles', (req, res) => {
+    const providers = ['google', 'anthropic', 'openai', 'xai', 'openrouter', 'together', 'mistral', 'deepseek', 'amazon-bedrock', 'azure', 'github-copilot'];
+    providers.forEach(p => importCurrentAuthToPool(p));
     syncAntigravityPool();
+    
     const authCfg = loadAuthConfig() || {};
     const studio = loadStudioConfig();
     const ac = studio.activeProfiles || {};
     const activePlugin = studio.activeGooglePlugin;
     const profiles = {};
-    const providers = ['google', 'anthropic', 'openai', 'xai', 'openrouter', 'together', 'mistral', 'deepseek', 'amazon-bedrock', 'azure', 'github-copilot'];
     
     providers.forEach(p => {
         const saved = listAuthProfiles(p, activePlugin);
@@ -1882,6 +1878,78 @@ function listAntigravityAccounts() {
     }));
 }
 
+function decodeJWT(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3) return null;
+        const payload = Buffer.from(parts[1], 'base64').toString('utf8');
+        return JSON.parse(payload);
+    } catch {
+        return null;
+    }
+}
+
+function importCurrentAuthToPool(provider) {
+    if (provider === 'google') {
+        return importCurrentGoogleAuthToPool();
+    }
+
+    const authCfg = loadAuthConfig();
+    if (!authCfg || !authCfg[provider]) return;
+
+    const creds = authCfg[provider];
+    let email = creds.email;
+
+    if (!email && provider === 'openai' && creds.access) {
+        const decoded = decodeJWT(creds.access);
+        if (decoded && decoded['https://api.openai.com/profile']?.email) {
+            email = decoded['https://api.openai.com/profile'].email;
+        }
+    }
+
+    const name = email || creds.accountId || creds.id || `profile-${Date.now()}`;
+    const profileDir = path.join(AUTH_PROFILES_DIR, provider);
+    if (!fs.existsSync(profileDir)) fs.mkdirSync(profileDir, { recursive: true });
+
+    const profilePath = path.join(profileDir, `${name}.json`);
+
+    let shouldSync = true;
+    if (fs.existsSync(profilePath)) {
+        try {
+            const current = JSON.parse(fs.readFileSync(profilePath, 'utf8'));
+            if (JSON.stringify(current) === JSON.stringify(creds)) {
+                shouldSync = false;
+            }
+        } catch {
+        }
+    }
+
+    if (shouldSync) {
+        console.log(`[Auth] Syncing ${provider} login for ${name} to pool.`);
+        atomicWriteFileSync(profilePath, JSON.stringify(creds, null, 2));
+
+        const metadata = loadPoolMetadata();
+        if (!metadata[provider]) metadata[provider] = {};
+        
+        metadata[provider][name] = {
+            ...(metadata[provider][name] || {}),
+            email: email || null,
+            createdAt: metadata[provider][name]?.createdAt || Date.now(),
+            lastUsed: Date.now(),
+            usageCount: metadata[provider][name]?.usageCount || 0,
+            imported: true
+        };
+        savePoolMetadata(metadata);
+
+        const studio = loadStudioConfig();
+        if (!studio.activeProfiles) studio.activeProfiles = {};
+        if (studio.activeProfiles[provider] !== name) {
+            studio.activeProfiles[provider] = name;
+            saveStudioConfig(studio);
+        }
+    }
+}
+
 function importCurrentGoogleAuthToPool() {
     const studio = loadStudioConfig();
     // Only applies if Antigravity is active
@@ -1982,70 +2050,6 @@ function syncAntigravityPool() {
     savePoolMetadata(metadata);
 }
 
-function importExistingAuth() {
-    const authCfg = loadAuthConfig();
-    if (!authCfg) return;
-
-    const studio = loadStudioConfig();
-    const activeProfiles = studio.activeProfiles || {};
-    let changed = false;
-
-    // Standard providers to check
-    const providers = ['google', 'openai', 'anthropic', 'xai', 'openrouter', 'github-copilot', 'mistral', 'deepseek', 'amazon-bedrock', 'azure'];
-
-    providers.forEach(provider => {
-        if (!authCfg[provider]) return; // No creds for this provider
-
-        // Determine namespace
-        // For auto-import, we target the standard 'google' namespace unless antigravity plugin is active?
-        // Actually, auth.json 'google' key usually means Gemini/Vertex standard auth.
-        const namespace = provider === 'google' && studio.activeGooglePlugin === 'antigravity' 
-            ? 'google.antigravity' 
-            : (provider === 'google' ? 'google.gemini' : provider);
-
-        const profileDir = path.join(AUTH_PROFILES_DIR, namespace);
-        
-        // If we already have an active profile for this provider, skip import
-        if (activeProfiles[provider]) return;
-
-        // If directory exists and has files, check if empty
-        if (fs.existsSync(profileDir) && fs.readdirSync(profileDir).filter(f => f.endsWith('.json')).length > 0) {
-            return;
-        }
-
-        // Import!
-        if (!fs.existsSync(profileDir)) fs.mkdirSync(profileDir, { recursive: true });
-        
-        const email = authCfg[provider].email || null;
-        const name = email || `imported-${Date.now()}`;
-        const profilePath = path.join(profileDir, `${name}.json`);
-        
-        console.log(`[AutoImport] Importing existing ${provider} credentials as ${name}`);
-        atomicWriteFileSync(profilePath, JSON.stringify(authCfg[provider], null, 2));
-        
-        // Set as active
-        if (!studio.activeProfiles) studio.activeProfiles = {};
-        studio.activeProfiles[provider] = name;
-        changed = true;
-
-        // Update metadata
-        const metadata = loadPoolMetadata();
-        if (!metadata[namespace]) metadata[namespace] = {};
-        metadata[namespace][name] = {
-            email: email,
-            createdAt: Date.now(),
-            lastUsed: Date.now(),
-            usageCount: 0,
-            imported: true
-        };
-        savePoolMetadata(metadata);
-    });
-
-    if (changed) {
-        saveStudioConfig(studio);
-    }
-}
-
 function getAccountStatus(meta, now) {
     if (!meta) return 'ready';
     if (meta.cooldownUntil && meta.cooldownUntil > now) return 'cooldown';
@@ -2436,6 +2440,84 @@ app.post('/api/auth/pool/quota/limit', (req, res) => {
     res.json({ success: true, dailyLimit: limit });
 });
 
+app.get('/api/proxy/status', async (req, res) => {
+    const status = await proxyManager.getStatus();
+    res.json(status);
+});
+
+app.post('/api/proxy/start', async (req, res) => {
+    const result = await proxyManager.startProxy();
+    res.json(result);
+});
+
+app.post('/api/proxy/stop', async (req, res) => {
+    const result = proxyManager.stopProxy();
+    res.json(result);
+});
+
+app.post('/api/proxy/login', async (req, res) => {
+    const { provider } = req.body;
+    const result = await proxyManager.runLogin(provider);
+    if (!result.success) return res.status(400).json(result);
+    
+    const cmd = result.command;
+    const cp = getConfigPath();
+    const configDir = cp ? path.dirname(cp) : process.cwd();
+    const safeDir = configDir.replace(/"/g, '\\"');
+    const platform = process.platform;
+    
+    if (platform === 'win32') {
+        const terminalCmd = `start "" /d "${safeDir}" cmd /c "call ${cmd} || pause"`;
+        exec(terminalCmd, (err) => {
+            if (err) return res.status(500).json({ error: 'Failed to open terminal', details: err.message });
+            res.json({ success: true, message: 'Terminal opened' });
+        });
+    } else if (platform === 'darwin') {
+        const terminalCmd = `osascript -e 'tell application "Terminal" to do script "cd ${safeDir} && ${cmd}"'`;
+        exec(terminalCmd, (err) => {
+            if (err) return res.status(500).json({ error: 'Failed to open terminal', details: err.message });
+            res.json({ success: true, message: 'Terminal opened' });
+        });
+    } else {
+        const linuxTerminals = [
+            { name: 'x-terminal-emulator', cmd: `x-terminal-emulator -e "bash -c 'cd ${safeDir} && ${cmd}'"` },
+            { name: 'gnome-terminal', cmd: `gnome-terminal -- bash -c "cd ${safeDir} && ${cmd}; read -p 'Press Enter to close...'"` },
+            { name: 'konsole', cmd: `konsole -e bash -c "cd ${safeDir} && ${cmd}; read -p 'Press Enter to close...'"` },
+            { name: 'xfce4-terminal', cmd: `xfce4-terminal -e "bash -c \"cd ${safeDir} && ${cmd}; read -p 'Press Enter to close...'\"" ` },
+            { name: 'xterm', cmd: `xterm -e "bash -c 'cd ${safeDir} && ${cmd}; read -p Press_Enter_to_close...'"` }
+        ];
+        
+        const tryTerminal = (index) => {
+            if (index >= linuxTerminals.length) {
+                return res.json({ 
+                    success: false, 
+                    message: 'No terminal emulator found', 
+                    note: 'Run this command manually:',
+                    command: cmd
+                });
+            }
+            const terminal = linuxTerminals[index];
+            exec(terminal.cmd, (err) => {
+                if (err) {
+                    tryTerminal(index + 1);
+                } else {
+                    res.json({ success: true, message: 'Terminal opened' });
+                }
+            });
+        };
+        tryTerminal(0);
+    }
+});
+
+app.get('/api/proxy/config', (req, res) => {
+    res.json(proxyManager.loadProxyConfig());
+});
+
+app.post('/api/proxy/config', (req, res) => {
+    proxyManager.saveProxyConfig(req.body);
+    res.json({ success: true });
+});
+
 // ============================================
 // END ACCOUNT POOL MANAGEMENT
 // ============================================
@@ -3035,8 +3117,7 @@ app.post('/api/presets/:id/apply', (req, res) => {
 
 // Start watcher on server start
 function startServer() {
-    // setupLogWatcher(); // Disabled as per user request (manual switching only)
-    importExistingAuth();
+    ['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}`));
 }
 
@@ -3053,4 +3134,27 @@ module.exports = {
     loadStudioConfig,
     saveStudioConfig,
     buildAccountPool
-};
+};
+app.get('/api/prompts/global', (req, res) => {
+    const cp = getConfigPath();
+    const globalPath = path.join(path.dirname(cp), 'OPENCODE.md');
+    
+    if (fs.existsSync(globalPath)) {
+        res.json({ content: fs.readFileSync(globalPath, 'utf8') });
+    } else {
+        res.json({ content: '' }); 
+    }
+});
+
+app.post('/api/prompts/global', (req, res) => {
+    const { content } = req.body;
+    const cp = getConfigPath();
+    const globalPath = path.join(path.dirname(cp), 'OPENCODE.md');
+    
+    try {
+        atomicWriteFileSync(globalPath, content);
+        res.json({ success: true });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-studio-server",
-  "version": "1.12.13",
+  "version": "1.13.0",
   "description": "Backend server for OpenCode Studio - manages opencode configurations",
   "main": "index.js",
   "bin": {
@@ -27,6 +27,7 @@
   "dependencies": {
     "body-parser": "^2.2.1",
     "cors": "^2.8.5",
-    "express": "^5.2.1"
+    "express": "^5.2.1",
+    "js-yaml": "^4.1.1"
   }
 }

package/proxy-manager.js

@@ -0,0 +1,162 @@
+const { spawn, exec } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const yaml = require('js-yaml');
+
+const HOME_DIR = os.homedir();
+const CONFIG_DIR = path.join(HOME_DIR, '.config', 'opencode-studio');
+const PROXY_CONFIG_FILE = path.join(CONFIG_DIR, 'cliproxy.yaml');
+const PROXY_AUTH_DIR = path.join(HOME_DIR, '.cli-proxy-api');
+
+let proxyProcess = null;
+let isProxyRunning = false;
+
+// Helper to check if binary exists
+const checkBinary = (cmd) => {
+    return new Promise((resolve) => {
+        const checkCmd = process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`;
+        exec(checkCmd, (err) => {
+            resolve(!err);
+        });
+    });
+};
+
+const getProxyCommand = async () => {
+    if (await checkBinary('cliproxyapi')) return 'cliproxyapi';
+    if (await checkBinary('cliproxy')) return 'cliproxy';
+    return null;
+};
+
+// Config Management
+const loadProxyConfig = () => {
+    if (!fs.existsSync(PROXY_CONFIG_FILE)) {
+        // Default config
+        const defaultConfig = {
+            port: 8317,
+            "auth-dir": PROXY_AUTH_DIR,
+            routing: { strategy: "round-robin" },
+            "quota-exceeded": {
+                "switch-project": true,
+                "switch-preview-model": true
+            },
+            "gemini-api-key": []
+        };
+        saveProxyConfig(defaultConfig);
+        return defaultConfig;
+    }
+    
+    try {
+        const content = fs.readFileSync(PROXY_CONFIG_FILE, 'utf8');
+        return yaml.load(content);
+    } catch (e) {
+        console.error("Failed to load proxy config:", e);
+        return {};
+    }
+};
+
+const saveProxyConfig = (config) => {
+    try {
+        if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        const content = yaml.dump(config);
+        fs.writeFileSync(PROXY_CONFIG_FILE, content);
+    } catch (e) {
+        console.error("Failed to save proxy config:", e);
+    }
+};
+
+// Process Management
+const startProxy = async () => {
+    if (isProxyRunning) return { success: true, message: "Already running" };
+
+    const cmd = await getProxyCommand();
+    if (!cmd) return { success: false, error: "CLIProxyAPI binary not found. Please install it." };
+
+    // Ensure config exists
+    if (!fs.existsSync(PROXY_CONFIG_FILE)) loadProxyConfig();
+
+    console.log(`Starting proxy with command: ${cmd} -config ${PROXY_CONFIG_FILE}`);
+    
+    try {
+        // -no-browser flag to prevent it from trying to open browser on startup if that's a thing
+        proxyProcess = spawn(cmd, ['-config', PROXY_CONFIG_FILE], {
+            detached: false,
+            stdio: 'pipe' 
+        });
+
+        proxyProcess.stdout.on('data', (data) => {
+            console.log(`[Proxy] ${data}`);
+        });
+
+        proxyProcess.stderr.on('data', (data) => {
+            console.error(`[Proxy Err] ${data}`);
+        });
+
+        proxyProcess.on('close', (code) => {
+            console.log(`[Proxy] Exited with code ${code}`);
+            isProxyRunning = false;
+            proxyProcess = null;
+        });
+
+        isProxyRunning = true;
+        return { success: true, pid: proxyProcess.pid };
+    } catch (e) {
+        return { success: false, error: e.message };
+    }
+};
+
+const stopProxy = () => {
+    if (proxyProcess) {
+        proxyProcess.kill();
+        proxyProcess = null;
+        isProxyRunning = false;
+        return { success: true };
+    }
+    return { success: false, error: "Not running" };
+};
+
+const getStatus = async () => {
+    const cmd = await getProxyCommand();
+    return { 
+        running: isProxyRunning, 
+        pid: proxyProcess?.pid,
+        configFile: PROXY_CONFIG_FILE,
+        port: 8317,
+        installed: !!cmd,
+        binary: cmd
+    };
+};
+
+const runLogin = async (provider) => {
+    const cmd = await getProxyCommand();
+    if (!cmd) return { success: false, error: "Binary not found" };
+
+    let loginFlag = '';
+    switch(provider) {
+        case 'google': 
+        case 'antigravity': loginFlag = '-antigravity-login'; break;
+        case 'openai': 
+        case 'codex': loginFlag = '-codex-login'; break;
+        case 'anthropic': loginFlag = '-claude-login'; break;
+        default: return { success: false, error: "Unknown provider" };
+    }
+
+    // Return the command so the UI can spawn a terminal for it
+    // We pass the config file so it saves the token to the right place/knows the auth-dir
+    const fullCmd = `${cmd} ${loginFlag} -config "${PROXY_CONFIG_FILE}"`;
+    
+    return { 
+        success: true, 
+        command: fullCmd,
+        message: "Terminal launching..."
+    };
+};
+
+module.exports = {
+    startProxy,
+    stopProxy,
+    getStatus,
+    loadProxyConfig,
+    saveProxyConfig,
+    runLogin
+};