opencode-studio-server 1.7.0 → 1.9.0

package/index.js

@@ -204,17 +204,59 @@ function processLogLine(line) {
                                
             if (isQuotaError) {
                 console.log(`[LogWatcher] Detected quota exhaustion for ${namespace}`);
-                // Mark exhausted for today
-                metadata._quota[namespace].exhausted = true;
-                metadata._quota[namespace].exhaustedDate = today;
                 
-                // Adaptive limit learning: if we hit a limit, maybe that's the ceiling?
-                // Only update if we have meaningful usage (>5) to avoid false positives on glitches
-                const currentUsage = metadata._quota[namespace][today] || 0;
+                // Reload metadata to ensure freshness
+                const currentMeta = loadPoolMetadata();
+                if (!currentMeta._quota) currentMeta._quota = {};
+                if (!currentMeta._quota[namespace]) currentMeta._quota[namespace] = {};
+
+                // Debounce check
+                const lastRotation = currentMeta._quota[namespace].lastRotation || 0;
+                if (Date.now() - lastRotation < 10000) { 
+                    console.log(`[LogWatcher] Ignoring 429 (rotation debounce active)`);
+                    return;
+                }
+
+                const studio = loadStudioConfig();
+                const activeAccount = studio.activeProfiles?.[provider];
+                
+                let rotated = false;
+
+                if (activeAccount) {
+                    console.log(`[LogWatcher] Auto-rotating due to rate limit on ${activeAccount}`);
+                    
+                    if (!currentMeta[namespace]) currentMeta[namespace] = {};
+                    if (!currentMeta[namespace][activeAccount]) currentMeta[namespace][activeAccount] = {};
+                    
+                    // Mark cooldown (1 hour)
+                    currentMeta[namespace][activeAccount].cooldownUntil = Date.now() + 3600000;
+                    currentMeta[namespace][activeAccount].lastCooldownReason = 'auto_429';
+                    
+                    savePoolMetadata(currentMeta); 
+                    
+                    // Attempt rotation
+                    const result = rotateAccount(provider, 'auto_rotation_429');
+                    if (result.success) {
+                        console.log(`[LogWatcher] Successfully rotated to ${result.newAccount}`);
+                        rotated = true;
+                    } else {
+                        console.log(`[LogWatcher] Auto-rotation failed: ${result.error}`);
+                    }
+                }
+
+                if (rotated) return;
+
+                // Fallback: Mark namespace exhausted
+                currentMeta._quota[namespace].exhausted = true;
+                currentMeta._quota[namespace].exhaustedDate = today;
+                
+                const currentUsage = currentMeta._quota[namespace][today] || 0;
                 if (currentUsage > 5) {
-                    // Update daily limit to current usage (maybe round up)
-                    metadata._quota[namespace].dailyLimit = currentUsage;
+                    currentMeta._quota[namespace].dailyLimit = currentUsage;
                 }
+                
+                savePoolMetadata(currentMeta);
+                return;
             }
         }
 
@@ -590,91 +632,373 @@ app.post('/api/restore', (req, res) => {
     }
 });
 
-app.post('/api/sync/push', (req, res) => {
+const DROPBOX_CLIENT_ID = 'your-dropbox-app-key';
+const GDRIVE_CLIENT_ID = 'your-google-client-id';
+
+function buildBackupData() {
+    const studio = loadStudioConfig();
+    const opencodeConfig = loadConfig();
+    const skills = [];
+    const plugins = [];
+    
+    const sd = getSkillDir();
+    if (sd && fs.existsSync(sd)) {
+        fs.readdirSync(sd, { withFileTypes: true })
+            .filter(e => e.isDirectory() && fs.existsSync(path.join(sd, e.name, 'SKILL.md')))
+            .forEach(e => {
+                skills.push({ name: e.name, content: fs.readFileSync(path.join(sd, e.name, 'SKILL.md'), 'utf8') });
+            });
+    }
+    
+    const pd = getPluginDir();
+    if (pd && fs.existsSync(pd)) {
+        fs.readdirSync(pd, { withFileTypes: true }).forEach(e => {
+            if (e.isFile() && /\.(js|ts)$/.test(e.name)) {
+                plugins.push({ name: e.name.replace(/\.(js|ts)$/, ''), content: fs.readFileSync(path.join(pd, e.name), 'utf8') });
+            }
+        });
+    }
+    
+    const cloudSettings = studio.cloudProvider ? { provider: studio.cloudProvider } : {};
+    
+    return {
+        version: 1,
+        timestamp: new Date().toISOString(),
+        studioConfig: { ...studio, cloudToken: undefined, cloudProvider: undefined },
+        opencodeConfig,
+        skills,
+        plugins
+    };
+}
+
+function restoreFromBackup(backup, studio) {
+    if (backup.studioConfig) {
+        const merged = { 
+            ...backup.studioConfig, 
+            cloudProvider: studio.cloudProvider,
+            cloudToken: studio.cloudToken,
+            autoSync: studio.autoSync,
+            lastSyncAt: studio.lastSyncAt 
+        };
+        saveStudioConfig(merged);
+    }
+    if (backup.opencodeConfig) saveConfig(backup.opencodeConfig);
+    
+    const sd = getSkillDir();
+    if (sd && backup.skills && Array.isArray(backup.skills)) {
+        if (!fs.existsSync(sd)) fs.mkdirSync(sd, { recursive: true });
+        backup.skills.forEach(s => {
+            const skillDir = path.join(sd, s.name);
+            if (!fs.existsSync(skillDir)) fs.mkdirSync(skillDir, { recursive: true });
+            atomicWriteFileSync(path.join(skillDir, 'SKILL.md'), s.content);
+        });
+    }
+    
+    const pd = getPluginDir();
+    if (pd && backup.plugins && Array.isArray(backup.plugins)) {
+        if (!fs.existsSync(pd)) fs.mkdirSync(pd, { recursive: true });
+        backup.plugins.forEach(p => {
+            atomicWriteFileSync(path.join(pd, `${p.name}.js`), p.content);
+        });
+    }
+}
+
+app.get('/api/sync/status', (req, res) => {
+    const studio = loadStudioConfig();
+    res.json({
+        provider: studio.cloudProvider || null,
+        connected: !!(studio.cloudProvider && studio.cloudToken),
+        lastSync: studio.lastSyncAt || null,
+        autoSync: !!studio.autoSync
+    });
+});
+
+app.post('/api/sync/config', (req, res) => {
+    const { autoSync } = req.body;
+    const studio = loadStudioConfig();
+    if (autoSync !== undefined) studio.autoSync = !!autoSync;
+    saveStudioConfig(studio);
+    res.json({ success: true, autoSync: !!studio.autoSync });
+});
+
+app.post('/api/sync/disconnect', (req, res) => {
+    const studio = loadStudioConfig();
+    delete studio.cloudProvider;
+    delete studio.cloudToken;
+    delete studio.cloudRefreshToken;
+    saveStudioConfig(studio);
+    res.json({ success: true });
+});
+
+app.get('/api/sync/dropbox/auth-url', (req, res) => {
+    const state = crypto.randomBytes(16).toString('hex');
+    const studio = loadStudioConfig();
+    studio.oauthState = state;
+    saveStudioConfig(studio);
+    
+    const redirectUri = req.query.redirect_uri || 'http://localhost:3000/settings';
+    studio.oauthRedirectUri = redirectUri;
+    saveStudioConfig(studio);
+    
+    const params = new URLSearchParams({
+        client_id: DROPBOX_CLIENT_ID,
+        response_type: 'code',
+        token_access_type: 'offline',
+        redirect_uri: redirectUri,
+        state: state
+    });
+    res.json({ url: `https://www.dropbox.com/oauth2/authorize?${params}` });
+});
+
+app.post('/api/sync/dropbox/callback', async (req, res) => {
     try {
+        const { code, state } = req.body;
         const studio = loadStudioConfig();
-        const syncFolder = studio.syncFolder;
-        if (!syncFolder) return res.status(400).json({ error: 'Sync folder not configured' });
-        if (!fs.existsSync(syncFolder)) return res.status(400).json({ error: 'Sync folder does not exist' });
         
-        const opencodeConfig = loadConfig();
-        const skills = [];
-        const plugins = [];
+        if (state !== studio.oauthState) {
+            return res.status(400).json({ error: 'Invalid state' });
+        }
+        const redirectUri = studio.oauthRedirectUri || 'http://localhost:3000/settings';
+        delete studio.oauthState;
+        delete studio.oauthRedirectUri;
         
-        const sd = getSkillDir();
-        if (sd && fs.existsSync(sd)) {
-            fs.readdirSync(sd, { withFileTypes: true })
-                .filter(e => e.isDirectory() && fs.existsSync(path.join(sd, e.name, 'SKILL.md')))
-                .forEach(e => {
-                    skills.push({ name: e.name, content: fs.readFileSync(path.join(sd, e.name, 'SKILL.md'), 'utf8') });
-                });
+        const response = await fetch('https://api.dropboxapi.com/oauth2/token', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({
+                code,
+                grant_type: 'authorization_code',
+                client_id: DROPBOX_CLIENT_ID,
+                redirect_uri: redirectUri
+            })
+        });
+        
+        if (!response.ok) {
+            const err = await response.text();
+            return res.status(400).json({ error: `Dropbox auth failed: ${err}` });
         }
         
-        const pd = getPluginDir();
-        if (pd && fs.existsSync(pd)) {
-            fs.readdirSync(pd, { withFileTypes: true }).forEach(e => {
-                if (e.isFile() && /\.(js|ts)$/.test(e.name)) {
-                    plugins.push({ name: e.name.replace(/\.(js|ts)$/, ''), content: fs.readFileSync(path.join(pd, e.name), 'utf8') });
-                }
-            });
+        const tokens = await response.json();
+        studio.cloudProvider = 'dropbox';
+        studio.cloudToken = tokens.access_token;
+        if (tokens.refresh_token) studio.cloudRefreshToken = tokens.refresh_token;
+        saveStudioConfig(studio);
+        
+        res.json({ success: true, provider: 'dropbox' });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+app.get('/api/sync/gdrive/auth-url', (req, res) => {
+    const state = crypto.randomBytes(16).toString('hex');
+    const studio = loadStudioConfig();
+    studio.oauthState = state;
+    
+    const redirectUri = req.query.redirect_uri || 'http://localhost:3000/settings';
+    studio.oauthRedirectUri = redirectUri;
+    saveStudioConfig(studio);
+    
+    const params = new URLSearchParams({
+        client_id: GDRIVE_CLIENT_ID,
+        response_type: 'code',
+        scope: 'https://www.googleapis.com/auth/drive.file',
+        access_type: 'offline',
+        prompt: 'consent',
+        redirect_uri: redirectUri,
+        state: state
+    });
+    res.json({ url: `https://accounts.google.com/o/oauth2/v2/auth?${params}` });
+});
+
+app.post('/api/sync/gdrive/callback', async (req, res) => {
+    try {
+        const { code, state } = req.body;
+        const studio = loadStudioConfig();
+        
+        if (state !== studio.oauthState) {
+            return res.status(400).json({ error: 'Invalid state' });
         }
+        const redirectUri = studio.oauthRedirectUri || 'http://localhost:3000/settings';
+        delete studio.oauthState;
+        delete studio.oauthRedirectUri;
         
-        const backup = {
-            version: 1,
-            timestamp: new Date().toISOString(),
-            studioConfig: { ...studio, syncFolder: undefined },
-            opencodeConfig,
-            skills,
-            plugins
-        };
+        const response = await fetch('https://oauth2.googleapis.com/token', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({
+                code,
+                client_id: GDRIVE_CLIENT_ID,
+                // client_secret: 'GDRIVE_CLIENT_SECRET', // NOTE: OAuth flow for installed apps usually requires client secret.
+                // For simplicity in this demo, we assume PKCE or a public client flow if supported, 
+                // OR the user will need to provide the secret in environment variables.
+                // Since this is a local server, we might need the secret.
+                // Let's assume for now we'll put a placeholder or rely on env vars.
+                // Google "Installed App" flow doesn't always need secret if type is "Desktop".
+                // However, for web flow it does. 
+                // Let's assume we need a client secret env var for now.
+                client_secret: process.env.GDRIVE_CLIENT_SECRET || 'your-google-client-secret',
+                redirect_uri: redirectUri,
+                grant_type: 'authorization_code'
+            })
+        });
         
-        const backupPath = path.join(syncFolder, 'opencode-studio-sync.json');
-        atomicWriteFileSync(backupPath, JSON.stringify(backup, null, 2));
+        if (!response.ok) {
+            const err = await response.text();
+            return res.status(400).json({ error: `Google auth failed: ${err}` });
+        }
         
-        studio.lastSyncAt = backup.timestamp;
+        const tokens = await response.json();
+        studio.cloudProvider = 'gdrive';
+        studio.cloudToken = tokens.access_token;
+        if (tokens.refresh_token) studio.cloudRefreshToken = tokens.refresh_token;
         saveStudioConfig(studio);
         
-        res.json({ success: true, path: backupPath, timestamp: backup.timestamp });
+        res.json({ success: true, provider: 'gdrive' });
     } catch (err) {
         res.status(500).json({ error: err.message });
     }
 });
 
-app.post('/api/sync/pull', (req, res) => {
+app.post('/api/sync/push', async (req, res) => {
     try {
         const studio = loadStudioConfig();
-        const syncFolder = studio.syncFolder;
-        if (!syncFolder) return res.status(400).json({ error: 'Sync folder not configured' });
-        
-        const backupPath = path.join(syncFolder, 'opencode-studio-sync.json');
-        if (!fs.existsSync(backupPath)) return res.status(404).json({ error: 'No sync file found in folder' });
+        if (!studio.cloudProvider || !studio.cloudToken) {
+            return res.status(400).json({ error: 'No cloud provider connected' });
+        }
         
-        const backup = JSON.parse(fs.readFileSync(backupPath, 'utf8'));
+        const backup = buildBackupData();
+        const content = JSON.stringify(backup, null, 2);
         
-        if (backup.studioConfig) {
-            const merged = { ...backup.studioConfig, syncFolder: studio.syncFolder };
-            saveStudioConfig(merged);
+        if (studio.cloudProvider === 'dropbox') {
+            const response = await fetch('https://content.dropboxapi.com/2/files/upload', {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${studio.cloudToken}`,
+                    'Content-Type': 'application/octet-stream',
+                    'Dropbox-API-Arg': JSON.stringify({
+                        path: '/opencode-studio-sync.json',
+                        mode: 'overwrite',
+                        autorename: false
+                    })
+                },
+                body: content
+            });
+            
+            if (!response.ok) {
+                const err = await response.text();
+                return res.status(400).json({ error: `Dropbox upload failed: ${err}` });
+            }
+        } else if (studio.cloudProvider === 'gdrive') {
+            // Find existing file
+            const listRes = await fetch('https://www.googleapis.com/drive/v3/files?q=name=\'opencode-studio-sync.json\' and trashed=false', {
+                headers: { 'Authorization': `Bearer ${studio.cloudToken}` }
+            });
+            const listData = await listRes.json();
+            const existingFile = listData.files?.[0];
+
+            if (existingFile) {
+                // Update content
+                const updateRes = await fetch(`https://www.googleapis.com/upload/drive/v3/files/${existingFile.id}?uploadType=media`, {
+                    method: 'PATCH',
+                    headers: {
+                        'Authorization': `Bearer ${studio.cloudToken}`,
+                        'Content-Type': 'application/json'
+                    },
+                    body: content
+                });
+                if (!updateRes.ok) {
+                    const err = await updateRes.text();
+                    return res.status(400).json({ error: `Google Drive update failed: ${err}` });
+                }
+            } else {
+                // Create new file (multipart)
+                const metadata = { name: 'opencode-studio-sync.json', mimeType: 'application/json' };
+                const boundary = '-------314159265358979323846';
+                const delimiter = "\r\n--" + boundary + "\r\n";
+                const close_delim = "\r\n--" + boundary + "--";
+                
+                const multipartBody = 
+                    delimiter + 
+                    'Content-Type: application/json\r\n\r\n' + 
+                    JSON.stringify(metadata) + 
+                    delimiter + 
+                    'Content-Type: application/json\r\n\r\n' + 
+                    content + 
+                    close_delim;
+
+                const createRes = await fetch('https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart', {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${studio.cloudToken}`,
+                        'Content-Type': `multipart/related; boundary="${boundary}"`
+                    },
+                    body: multipartBody
+                });
+                if (!createRes.ok) {
+                    const err = await createRes.text();
+                    return res.status(400).json({ error: `Google Drive create failed: ${err}` });
+                }
+            }
         }
-        if (backup.opencodeConfig) saveConfig(backup.opencodeConfig);
         
-        const sd = getSkillDir();
-        if (sd && backup.skills && Array.isArray(backup.skills)) {
-            if (!fs.existsSync(sd)) fs.mkdirSync(sd, { recursive: true });
-            backup.skills.forEach(s => {
-                const skillDir = path.join(sd, s.name);
-                if (!fs.existsSync(skillDir)) fs.mkdirSync(skillDir, { recursive: true });
-                atomicWriteFileSync(path.join(skillDir, 'SKILL.md'), s.content);
-            });
+        studio.lastSyncAt = backup.timestamp;
+        saveStudioConfig(studio);
+        res.json({ success: true, timestamp: backup.timestamp });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+app.post('/api/sync/pull', async (req, res) => {
+    try {
+        const studio = loadStudioConfig();
+        if (!studio.cloudProvider || !studio.cloudToken) {
+            return res.status(400).json({ error: 'No cloud provider connected' });
         }
         
-        const pd = getPluginDir();
-        if (pd && backup.plugins && Array.isArray(backup.plugins)) {
-            if (!fs.existsSync(pd)) fs.mkdirSync(pd, { recursive: true });
-            backup.plugins.forEach(p => {
-                atomicWriteFileSync(path.join(pd, `${p.name}.js`), p.content);
+        let content;
+        
+        if (studio.cloudProvider === 'dropbox') {
+            const response = await fetch('https://content.dropboxapi.com/2/files/download', {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${studio.cloudToken}`,
+                    'Dropbox-API-Arg': JSON.stringify({ path: '/opencode-studio-sync.json' })
+                }
             });
+            
+            if (!response.ok) {
+                if (response.status === 409) {
+                    return res.status(404).json({ error: 'No sync file found in cloud' });
+                }
+                const err = await response.text();
+                return res.status(400).json({ error: `Dropbox download failed: ${err}` });
+            }
+            
+            content = await response.text();
+        } else if (studio.cloudProvider === 'gdrive') {
+            const listRes = await fetch('https://www.googleapis.com/drive/v3/files?q=name=\'opencode-studio-sync.json\' and trashed=false', {
+                headers: { 'Authorization': `Bearer ${studio.cloudToken}` }
+            });
+            const listData = await listRes.json();
+            const existingFile = listData.files?.[0];
+            
+            if (!existingFile) return res.status(404).json({ error: 'No sync file found in cloud' });
+            
+            const downloadRes = await fetch(`https://www.googleapis.com/drive/v3/files/${existingFile.id}?alt=media`, {
+                headers: { 'Authorization': `Bearer ${studio.cloudToken}` }
+            });
+            if (!downloadRes.ok) {
+                const err = await downloadRes.text();
+                return res.status(400).json({ error: `Google Drive download failed: ${err}` });
+            }
+            content = await downloadRes.text();
         }
         
+        const backup = JSON.parse(content);
+        restoreFromBackup(backup, studio);
+        
         const updated = loadStudioConfig();
         updated.lastSyncAt = new Date().toISOString();
         saveStudioConfig(updated);
@@ -685,98 +1009,41 @@ app.post('/api/sync/pull', (req, res) => {
     }
 });
 
-app.get('/api/sync/status', (req, res) => {
+app.post('/api/sync/auto', async (req, res) => {
     const studio = loadStudioConfig();
-    const syncFolder = studio.syncFolder;
-    let fileExists = false;
-    let fileTimestamp = null;
-    
-    if (syncFolder) {
-        const backupPath = path.join(syncFolder, 'opencode-studio-sync.json');
-        if (fs.existsSync(backupPath)) {
-            fileExists = true;
-            try {
-                const backup = JSON.parse(fs.readFileSync(backupPath, 'utf8'));
-                fileTimestamp = backup.timestamp;
-            } catch {}
-        }
-    }
-    
-    res.json({
-        configured: !!syncFolder,
-        folder: syncFolder || null,
-        lastSync: studio.lastSyncAt || null,
-        autoSync: !!studio.autoSync,
-        fileExists,
-        fileTimestamp
-    });
-});
-
-app.post('/api/sync/config', (req, res) => {
-    const { folder, autoSync } = req.body;
-    const studio = loadStudioConfig();
-    
-    if (folder !== undefined) {
-        if (folder) {
-            if (!fs.existsSync(folder)) {
-                return res.status(400).json({ error: 'Folder does not exist' });
-            }
-            studio.syncFolder = folder;
-        } else {
-            delete studio.syncFolder;
-        }
-    }
-    
-    if (autoSync !== undefined) {
-        studio.autoSync = !!autoSync;
-    }
-    
-    saveStudioConfig(studio);
-    res.json({ success: true, folder: studio.syncFolder || null, autoSync: !!studio.autoSync });
-});
-
-app.post('/api/sync/auto', (req, res) => {
-    const studio = loadStudioConfig();
-    if (!studio.syncFolder || !studio.autoSync) {
+    if (!studio.cloudProvider || !studio.cloudToken || !studio.autoSync) {
         return res.json({ action: 'none', reason: 'auto-sync not configured' });
     }
     
-    const syncFolder = studio.syncFolder;
-    const backupPath = path.join(syncFolder, 'opencode-studio-sync.json');
-    
-    if (!fs.existsSync(backupPath)) {
-        return res.json({ action: 'none', reason: 'no remote file' });
-    }
-    
     try {
-        const remote = JSON.parse(fs.readFileSync(backupPath, 'utf8'));
-        const remoteTime = new Date(remote.timestamp).getTime();
-        const localTime = studio.lastSyncAt ? new Date(studio.lastSyncAt).getTime() : 0;
+        let content;
         
-        if (remoteTime > localTime) {
-            if (remote.studioConfig) {
-                const merged = { ...remote.studioConfig, syncFolder: studio.syncFolder, autoSync: studio.autoSync, lastSyncAt: studio.lastSyncAt };
-                saveStudioConfig(merged);
-            }
-            if (remote.opencodeConfig) saveConfig(remote.opencodeConfig);
+        if (studio.cloudProvider === 'dropbox') {
+            const response = await fetch('https://content.dropboxapi.com/2/files/download', {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${studio.cloudToken}`,
+                    'Dropbox-API-Arg': JSON.stringify({ path: '/opencode-studio-sync.json' })
+                }
+            });
             
-            const sd = getSkillDir();
-            if (sd && remote.skills && Array.isArray(remote.skills)) {
-                if (!fs.existsSync(sd)) fs.mkdirSync(sd, { recursive: true });
-                remote.skills.forEach(s => {
-                    const skillDir = path.join(sd, s.name);
-                    if (!fs.existsSync(skillDir)) fs.mkdirSync(skillDir, { recursive: true });
-                    atomicWriteFileSync(path.join(skillDir, 'SKILL.md'), s.content);
-                });
+            if (!response.ok) {
+                return res.json({ action: 'none', reason: 'no remote file' });
             }
             
-            const pd = getPluginDir();
-            if (pd && remote.plugins && Array.isArray(remote.plugins)) {
-                if (!fs.existsSync(pd)) fs.mkdirSync(pd, { recursive: true });
-                remote.plugins.forEach(p => {
-                    atomicWriteFileSync(path.join(pd, `${p.name}.js`), p.content);
-                });
-            }
+            content = await response.text();
+        }
+        
+        if (!content) {
+            return res.json({ action: 'none', reason: 'no content' });
+        }
+        
+        const remote = JSON.parse(content);
+        const remoteTime = new Date(remote.timestamp).getTime();
+        const localTime = studio.lastSyncAt ? new Date(studio.lastSyncAt).getTime() : 0;
+        
+        if (remoteTime > localTime) {
+            restoreFromBackup(remote, studio);
             
             const updated = loadStudioConfig();
             updated.lastSyncAt = new Date().toISOString();
@@ -1697,67 +1964,56 @@ function getPoolQuota(provider, pool) {
     };
 }
 
-// GET /api/auth/pool - Get account pool for Google (or specified provider)
-app.get('/api/auth/pool', (req, res) => {
-    const provider = req.query.provider || 'google';
-    syncAntigravityPool();
+function rotateAccount(provider, reason = 'manual_rotation') {
     const pool = buildAccountPool(provider);
-    const quota = getPoolQuota(provider, pool);
-    res.json({ pool, quota });
-});
 
-// POST /api/auth/pool/rotate - Rotate to next available account
-app.post('/api/auth/pool/rotate', (req, res) => {
-    const provider = req.body.provider || 'google';
-    const pool = buildAccountPool(provider);
-    
     if (pool.accounts.length === 0) {
-        return res.status(400).json({ error: 'No accounts in pool' });
+        return { success: false, error: 'No accounts in pool' };
     }
-    
+
     const now = Date.now();
     const available = pool.accounts.filter(acc => 
         acc.status === 'ready' || (acc.status === 'cooldown' && acc.cooldownUntil && acc.cooldownUntil < now)
     );
-    
+
     if (available.length === 0) {
-        return res.status(400).json({ error: 'No available accounts (all in cooldown or expired)' });
+        return { success: false, error: 'No available accounts (all in cooldown or expired)' };
     }
-    
+
     // Pick least recently used
     const next = available.sort((a, b) => a.lastUsed - b.lastUsed)[0];
     const previousActive = pool.activeAccount;
-    
+
     // Activate the new account
     const activePlugin = getActiveGooglePlugin();
     const namespace = provider === 'google'
         ? (activePlugin === 'antigravity' ? 'google.antigravity' : 'google.gemini')
         : provider;
-    
+
     const profilePath = path.join(AUTH_PROFILES_DIR, namespace, `${next.name}.json`);
     if (!fs.existsSync(profilePath)) {
-        return res.status(404).json({ error: 'Profile file not found' });
+        return { success: false, error: 'Profile file not found' };
     }
-    
+
     const profileData = JSON.parse(fs.readFileSync(profilePath, 'utf8'));
-    
+
     // Update auth.json
     const authCfg = loadAuthConfig() || {};
     authCfg[provider] = profileData;
     if (provider === 'google') {
         authCfg[namespace] = profileData;
     }
-    
+
     const cp = getConfigPath();
     const ap = path.join(path.dirname(cp), 'auth.json');
     atomicWriteFileSync(ap, JSON.stringify(authCfg, null, 2));
-    
+
     // Update studio config
     const studio = loadStudioConfig();
     if (!studio.activeProfiles) studio.activeProfiles = {};
     studio.activeProfiles[provider] = next.name;
     saveStudioConfig(studio);
-    
+
     // Update metadata
     const metadata = loadPoolMetadata();
     if (!metadata[namespace]) metadata[namespace] = {};
@@ -1767,19 +2023,46 @@ app.post('/api/auth/pool/rotate', (req, res) => {
         usageCount: (metadata[namespace][next.name]?.usageCount || 0) + 1
     };
 
+    // Unmark exhaustion if we successfully rotated
+    if (metadata._quota?.[namespace]?.exhausted) {
+        delete metadata._quota[namespace].exhausted;
+    }
+
     if (!metadata._quota) metadata._quota = {};
     if (!metadata._quota[namespace]) metadata._quota[namespace] = {};
     const today = new Date().toISOString().split('T')[0];
     metadata._quota[namespace][today] = (metadata._quota[namespace][today] || 0) + 1;
+    metadata._quota[namespace].lastRotation = now;
 
     savePoolMetadata(metadata);
-    
-    res.json({
+
+    return {
         success: true,
         previousAccount: previousActive,
         newAccount: next.name,
-        reason: 'manual_rotation'
-    });
+        reason: reason
+    };
+}
+
+// GET /api/auth/pool - Get account pool for Google (or specified provider)
+app.get('/api/auth/pool', (req, res) => {
+    const provider = req.query.provider || 'google';
+    syncAntigravityPool();
+    const pool = buildAccountPool(provider);
+    const quota = getPoolQuota(provider, pool);
+    res.json({ pool, quota });
+});
+
+// POST /api/auth/pool/rotate - Rotate to next available account
+app.post('/api/auth/pool/rotate', (req, res) => {
+    const provider = req.body.provider || 'google';
+    const result = rotateAccount(provider, 'manual_rotation');
+    
+    if (!result.success) {
+        return res.status(400).json(result);
+    }
+    
+    res.json(result);
 });
 
 // POST /api/auth/pool/limit - Set daily quota limit
@@ -2534,7 +2817,18 @@ app.post('/api/presets/:id/apply', (req, res) => {
 });
 
 // Start watcher on server start
-setupLogWatcher();
-importExistingAuth();
+if (require.main === module) {
+    setupLogWatcher();
+    importExistingAuth();
+    app.listen(PORT, () => console.log(`Server running at http://localhost:${PORT}`));
+}
 
-app.listen(PORT, () => console.log(`Server running at http://localhost:${PORT}`));
+module.exports = {
+    rotateAccount,
+    processLogLine,
+    loadPoolMetadata,
+    savePoolMetadata,
+    loadStudioConfig,
+    saveStudioConfig,
+    buildAccountPool
+};

package/package.json

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