opencode-studio-server 1.16.7 → 1.17.0

package/index.js

@@ -8,7 +8,6 @@ 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;
 
@@ -2558,211 +2557,6 @@ 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/accounts', (req, res) => {
-    res.json(proxyManager.listAccounts());
-});
-
-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 });
-});
-
-const PROXY_CONFIG_PATH = path.join(HOME_DIR, '.config', 'opencode-studio', 'cliproxy.yaml');
-
-app.get('/api/management/config.yaml', (req, res) => {
-    console.log('GET config.yaml hit');
-    if (!fs.existsSync(PROXY_CONFIG_PATH)) {
-        console.log('Config file not found:', PROXY_CONFIG_PATH);
-        return res.send("");
-    }
-    console.log('Sending config file:', PROXY_CONFIG_PATH);
-    const content = fs.readFileSync(PROXY_CONFIG_PATH, 'utf8');
-    res.send(content);
-});
-
-app.put('/api/management/config.yaml', (req, res) => {
-    fs.writeFileSync(PROXY_CONFIG_PATH, req.body);
-    res.json({ ok: true, changed: [] });
-});
-
-app.get('/api/management/api-keys', (req, res) => {
-    if (!fs.existsSync(PROXY_CONFIG_PATH)) return res.json({ "api-keys": [] });
-    const content = fs.readFileSync(PROXY_CONFIG_PATH, 'utf8');
-    const yaml = require('js-yaml');
-    try {
-        const doc = yaml.load(content) || {};
-        const keys = [];
-        if (doc['management-key']) keys.push(doc['management-key']);
-        if (Array.isArray(doc['api-keys'])) keys.push(...doc['api-keys']);
-        res.json({ "api-keys": [...new Set(keys)].filter(k => k) });
-    } catch (e) {
-        res.json({ "api-keys": [] });
-    }
-});
-
-app.put('/api/management/api-keys', (req, res) => {
-    const keys = req.body;
-    if (!fs.existsSync(PROXY_CONFIG_PATH)) return res.status(404).json({ error: "Config not found" });
-    const content = fs.readFileSync(PROXY_CONFIG_PATH, 'utf8');
-    const yaml = require('js-yaml');
-    try {
-        const doc = yaml.load(content) || {};
-        doc['api-keys'] = keys;
-        if (keys.length > 0) doc['management-key'] = keys[0];
-        
-        fs.writeFileSync(PROXY_CONFIG_PATH, yaml.dump(doc));
-        res.json({ status: "ok" });
-    } catch (e) {
-        res.status(500).json({ error: e.message });
-    }
-});
-
-app.get('/api/management/logs', (req, res) => {
-    if (!fs.existsSync(LOG_DIR)) return res.json({ lines: [], "line-count": 0, "latest-timestamp": Date.now() });
-    const logFiles = fs.readdirSync(LOG_DIR).filter(f => f.endsWith('.log'));
-    if (logFiles.length === 0) return res.json({ lines: [], "line-count": 0, "latest-timestamp": Date.now() });
-    
-    const latest = logFiles.map(f => ({ name: f, time: fs.statSync(path.join(LOG_DIR, f)).mtime.getTime() }))
-        .sort((a, b) => b.time - a.time)[0];
-    
-    const content = fs.readFileSync(path.join(LOG_DIR, latest.name), 'utf8');
-    const lines = content.split('\n').slice(-1000);
-    res.json({ lines, "line-count": lines.length, "latest-timestamp": latest.time });
-});
-
-app.get('/api/management/usage', (req, res) => {
-    res.json({
-        usage: {
-            total_requests: 0,
-            success_count: 0,
-            failure_count: 0,
-            total_tokens: 0,
-            requests_by_day: {},
-            requests_by_hour: {},
-            tokens_by_day: {},
-            tokens_by_hour: {},
-            apis: {},
-            failed_requests: 0
-        }
-    });
-});
-
-app.get('/api/management/logging-to-file', (req, res) => {
-    if (!fs.existsSync(PROXY_CONFIG_PATH)) return res.json({ "logging-to-file": false });
-    try {
-        const content = fs.readFileSync(PROXY_CONFIG_PATH, 'utf8');
-        const yaml = require('js-yaml');
-        const doc = yaml.load(content) || {};
-        res.json({ "logging-to-file": !!doc['logging-to-file'] });
-    } catch (e) {
-        res.json({ "logging-to-file": false });
-    }
-});
-
-app.patch('/api/management/logging-to-file', (req, res) => {
-    if (!fs.existsSync(PROXY_CONFIG_PATH)) return res.status(404).json({ error: "Config not found" });
-    const enabled = req.body.value;
-    const content = fs.readFileSync(PROXY_CONFIG_PATH, 'utf8');
-    const yaml = require('js-yaml');
-    try {
-        const doc = yaml.load(content) || {};
-        doc['logging-to-file'] = enabled;
-        fs.writeFileSync(PROXY_CONFIG_PATH, yaml.dump(doc));
-        res.json({ status: "ok" });
-    } catch (e) {
-        res.status(500).json({ error: e.message });
-    }
-});
-
-app.delete('/api/management/logs', (req, res) => {
-    if (!fs.existsSync(LOG_DIR)) return res.json({ success: true, removed: 0 });
-    const logFiles = fs.readdirSync(LOG_DIR).filter(f => f.endsWith('.log'));
-    let removed = 0;
-    try {
-        logFiles.forEach(f => {
-            const filePath = path.join(LOG_DIR, f);
-            fs.unlinkSync(filePath);
-            removed++;
-        });
-        res.json({ success: true, removed });
-    } catch (e) {
-        res.status(500).json({ error: e.message });
-    }
-});
-
 app.get('/api/profiles', (req, res) => {
     res.json(profileManager.listProfiles());
 });

package/package.json

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

package/proxy-manager.js

@@ -1,228 +0,0 @@
-const { spawn, exec, execSync } = 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;
-
-const checkBinary = (cmd) => {
-    return new Promise((resolve) => {
-        if (path.isAbsolute(cmd)) {
-            return resolve(fs.existsSync(cmd));
-        }
-        const checkCmd = process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`;
-        exec(checkCmd, (err) => {
-            resolve(!err);
-        });
-    });
-};
-
-const getProxyCommand = async () => {
-    if (process.platform === 'win32') {
-        const localAppData = process.env.LOCALAPPDATA;
-        if (localAppData) {
-            const aliases = ['CLIProxyAPI.exe', 'cli-proxy-api.exe', 'cliproxyapi.exe'];
-            for (const alias of aliases) {
-                const wingetPath = path.join(localAppData, 'Microsoft', 'WinGet', 'Links', alias);
-                if (fs.existsSync(wingetPath)) return wingetPath;
-            }
-            
-            const progPath = path.join(localAppData, 'Programs', 'CLIProxyAPI', 'CLIProxyAPI.exe');
-            if (fs.existsSync(progPath)) return progPath;
-        }
-    }
-
-    if (await checkBinary('cli-proxy-api')) return 'cli-proxy-api';
-    if (await checkBinary('cliproxyapi')) return 'cliproxyapi';
-    if (await checkBinary('CLIProxyAPI')) return 'CLIProxyAPI';
-    if (await checkBinary('cliproxyapi.exe')) return 'cliproxyapi.exe';
-    if (await checkBinary('cliproxy')) return 'cliproxy';
-    return null;
-};
-
-const loadProxyConfig = () => {
-    if (!fs.existsSync(PROXY_CONFIG_FILE)) {
-        const defaultConfig = {
-            port: 8317,
-            cors: true,
-            "allow-origin": "*",
-            "auth-dir": PROXY_AUTH_DIR,
-            "management-key": "",
-            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');
-        const config = yaml.load(content);
-        if (config && config['management-key'] === undefined) {
-            config['management-key'] = "";
-            saveProxyConfig(config);
-        }
-        if (config && config.cors === undefined) {
-            config.cors = true;
-            config['allow-origin'] = "*";
-            saveProxyConfig(config);
-        }
-        return config;
-    } 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);
-    }
-};
-
-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." };
-
-    if (!fs.existsSync(PROXY_CONFIG_FILE)) loadProxyConfig();
-
-    console.log(`Starting proxy with command: ${cmd} -config "${PROXY_CONFIG_FILE}"`);
-    
-    try {
-        proxyProcess = spawn(cmd, ['-config', PROXY_CONFIG_FILE], {
-            detached: true,
-            stdio: 'pipe',
-            windowsHide: true
-        });
-        
-        proxyProcess.unref();
-
-        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();
-    
-    let portBusy = false;
-    try {
-        if (process.platform === 'win32') {
-            const out = execSync('netstat -ano | findstr :8317 | findstr LISTENING', { encoding: 'utf8' });
-            portBusy = out.includes('LISTENING');
-        } else {
-            const out = execSync('lsof -i :8317 | grep LISTEN', { encoding: 'utf8' });
-            portBusy = out.length > 0;
-        }
-    } catch (e) {
-        portBusy = false;
-    }
-
-    if (portBusy) {
-        isProxyRunning = true;
-    } else {
-        isProxyRunning = false;
-        proxyProcess = null;
-    }
-
-    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" };
-    }
-
-    const fullCmd = `${cmd} ${loginFlag} -config "${PROXY_CONFIG_FILE}"`;
-    
-    return { 
-        success: true, 
-        command: fullCmd,
-        message: "Terminal launching..."
-    };
-};
-
-const listAccounts = () => {
-    if (!fs.existsSync(PROXY_AUTH_DIR)) return [];
-    try {
-        return fs.readdirSync(PROXY_AUTH_DIR)
-            .filter(f => f.endsWith('.json'))
-            .map(f => {
-                const parts = f.replace('.json', '').split('-');
-                const provider = parts[0];
-                const email = parts.slice(1).join('-').replace(/_/g, '.').replace('.gmail.com', '@gmail.com');
-                return { id: f, provider, email: email || f };
-            });
-    } catch {
-        return [];
-    }
-};
-
-module.exports = {
-    startProxy,
-    stopProxy,
-    getStatus,
-    loadProxyConfig,
-    saveProxyConfig,
-    runLogin,
-    listAccounts
-};