opencode-studio-server 1.12.14 → 1.14.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/backend.log

@@ -0,0 +1,3 @@
+[Auth] Syncing github-copilot login for profile-1768679085919 to pool.
+Server running at http://localhost:3001
+[Profiles] Migrating existing config to "default" profile

package/index.js

@@ -8,6 +8,8 @@ const crypto = require('crypto');
 const { spawn, exec } = require('child_process');
 
 const pkg = require('./package.json');
+const proxyManager = require('./proxy-manager');
+const profileManager = require('./profile-manager');
 const SERVER_VERSION = pkg.version;
 
 // Atomic file write: write to temp file then rename to prevent corruption
@@ -2439,6 +2441,112 @@ 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 });
+});
+
+app.get('/api/profiles', (req, res) => {
+    res.json(profileManager.listProfiles());
+});
+
+app.post('/api/profiles', (req, res) => {
+    try {
+        res.json(profileManager.createProfile(req.body.name));
+    } catch (e) {
+        res.status(400).json({ error: e.message });
+    }
+});
+
+app.delete('/api/profiles/:name', (req, res) => {
+    try {
+        res.json(profileManager.deleteProfile(req.params.name));
+    } catch (e) {
+        res.status(400).json({ error: e.message });
+    }
+});
+
+app.post('/api/profiles/:name/activate', (req, res) => {
+    try {
+        res.json(profileManager.activateProfile(req.params.name));
+    } catch (e) {
+        res.status(400).json({ error: e.message });
+    }
+});
+
 // ============================================
 // END ACCOUNT POOL MANAGEMENT
 // ============================================
@@ -3055,4 +3163,35 @@ module.exports = {
     loadStudioConfig,
     saveStudioConfig,
     buildAccountPool
-};
+};
+app.get('/api/prompts/global', (req, res) => {
+    const cp = getConfigPath();
+    const dir = cp ? path.dirname(cp) : path.join(os.homedir(), '.config', 'opencode');
+    const globalPath = path.join(dir, '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 dir = cp ? path.dirname(cp) : path.join(os.homedir(), '.config', 'opencode');
+    const globalPath = path.join(dir, 'OPENCODE.md');
+    
+    console.log(`[Prompts] Saving to: ${globalPath}`);
+
+    try {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        atomicWriteFileSync(globalPath, content);
+        res.json({ success: true });
+    } catch (err) {
+        console.error('[Prompts] Error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-studio-server",
-  "version": "1.12.14",
+  "version": "1.14.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/profile-manager.js

@@ -0,0 +1,89 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME_DIR = os.homedir();
+const OPENCODE_DIR = path.join(HOME_DIR, '.config', 'opencode');
+const PROFILES_DIR = path.join(HOME_DIR, '.config', 'opencode-profiles');
+
+if (!fs.existsSync(PROFILES_DIR)) {
+    fs.mkdirSync(PROFILES_DIR, { recursive: true });
+}
+
+function isSymlink(filepath) {
+    try {
+        return fs.lstatSync(filepath).isSymbolicLink();
+    } catch {
+        return false;
+    }
+}
+
+function init() {
+    const defaultProfilePath = path.join(PROFILES_DIR, 'default');
+    
+    if (fs.existsSync(OPENCODE_DIR) && !isSymlink(OPENCODE_DIR)) {
+        if (!fs.existsSync(defaultProfilePath)) {
+            console.log('[Profiles] Migrating existing config to "default" profile');
+            fs.renameSync(OPENCODE_DIR, defaultProfilePath);
+            fs.symlinkSync(defaultProfilePath, OPENCODE_DIR, 'junction');
+        }
+    } else if (!fs.existsSync(OPENCODE_DIR) && !isSymlink(OPENCODE_DIR)) {
+        fs.mkdirSync(defaultProfilePath, { recursive: true });
+        fs.symlinkSync(defaultProfilePath, OPENCODE_DIR, 'junction');
+    }
+}
+
+function listProfiles() {
+    init();
+    const profiles = fs.readdirSync(PROFILES_DIR).filter(f => {
+        return fs.statSync(path.join(PROFILES_DIR, f)).isDirectory();
+    });
+    
+    let active = null;
+    if (isSymlink(OPENCODE_DIR)) {
+        const target = fs.readlinkSync(OPENCODE_DIR);
+        active = path.basename(target);
+    } else {
+        active = 'default (unmanaged)';
+    }
+    
+    return { profiles, active };
+}
+
+function createProfile(name) {
+    const dir = path.join(PROFILES_DIR, name);
+    if (fs.existsSync(dir)) throw new Error('Profile already exists');
+    fs.mkdirSync(dir, { recursive: true });
+    return { success: true };
+}
+
+function deleteProfile(name) {
+    const { active } = listProfiles();
+    if (name === active) throw new Error('Cannot delete active profile');
+    if (name === 'default') throw new Error('Cannot delete default profile');
+    
+    const dir = path.join(PROFILES_DIR, name);
+    if (fs.existsSync(dir)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    return { success: true };
+}
+
+function activateProfile(name) {
+    const target = path.join(PROFILES_DIR, name);
+    if (!fs.existsSync(target)) throw new Error('Profile not found');
+    
+    if (fs.existsSync(OPENCODE_DIR)) {
+        fs.rmSync(OPENCODE_DIR, { recursive: true, force: true });
+    }
+    
+    fs.symlinkSync(target, OPENCODE_DIR, 'junction');
+    return { success: true };
+}
+
+module.exports = {
+    listProfiles,
+    createProfile,
+    deleteProfile,
+    activateProfile
+};

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
+};