agentgui 1.0.203 → 1.0.207

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.203",
+  "version": "1.0.207",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -3,7 +3,6 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import zlib from 'zlib';
-import net from 'net';
 import crypto from 'crypto';
 import { fileURLToPath } from 'url';
 import { WebSocketServer } from 'ws';
@@ -155,6 +154,21 @@ expressApp.use(BASE_URL + '/files/:conversationId', (req, res, next) => {
   router(req, res, next);
 });
 
+function findCommand(cmd) {
+  const isWindows = os.platform() === 'win32';
+  try {
+    if (isWindows) {
+      const result = execSync(`where ${cmd}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+      return result.split('\n')[0].trim();
+    } else {
+      const result = execSync(`which ${cmd}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+      return result;
+    }
+  } catch (_) {
+    return null;
+  }
+}
+
 function discoverAgents() {
   const agents = [];
   const binaries = [
@@ -173,10 +187,8 @@ function discoverAgents() {
     { cmd: 'fast-agent', id: 'fast-agent', name: 'fast-agent', icon: 'F' },
   ];
   for (const bin of binaries) {
-    try {
-      const result = execSync(`which ${bin.cmd} 2>/dev/null`, { encoding: 'utf-8' }).trim();
-      if (result) agents.push({ id: bin.id, name: bin.name, icon: bin.icon, path: result });
-    } catch (_) {}
+    const result = findCommand(bin.cmd);
+    if (result) agents.push({ id: bin.id, name: bin.name, icon: bin.icon, path: result });
   }
   return agents;
 }
@@ -202,13 +214,15 @@ function extractOAuthFromFile(oauth2Path) {
 function getGeminiOAuthCreds() {
   const oauthRelPath = path.join('node_modules', '@google', 'gemini-cli-core', 'dist', 'src', 'code_assist', 'oauth2.js');
   try {
-    const geminiPath = execSync('which gemini', { encoding: 'utf8' }).trim();
-    const realPath = fs.realpathSync(geminiPath);
-    const pkgRoot = path.resolve(path.dirname(realPath), '..');
-    const result = extractOAuthFromFile(path.join(pkgRoot, oauthRelPath));
-    if (result) return result;
+    const geminiPath = findCommand('gemini');
+    if (geminiPath) {
+      const realPath = fs.realpathSync(geminiPath);
+      const pkgRoot = path.resolve(path.dirname(realPath), '..');
+      const result = extractOAuthFromFile(path.join(pkgRoot, oauthRelPath));
+      if (result) return result;
+    }
   } catch (e) {
-    console.error('[gemini-oauth] which gemini lookup failed:', e.message);
+    console.error('[gemini-oauth] gemini lookup failed:', e.message);
   }
   try {
     const npmCacheDirs = new Set();
@@ -228,15 +242,6 @@ function getGeminiOAuthCreds() {
   } catch (e) {
     console.error('[gemini-oauth] npm cache scan failed:', e.message);
   }
-  try {
-    const found = execSync('find / -path "*/gemini-cli-core/dist/src/code_assist/oauth2.js" -maxdepth 10 2>/dev/null | head -1', { encoding: 'utf8', timeout: 10000 }).trim();
-    if (found) {
-      const result = extractOAuthFromFile(found);
-      if (result) return result;
-    }
-  } catch (e) {
-    console.error('[gemini-oauth] filesystem search failed:', e.message);
-  }
   console.error('[gemini-oauth] Could not find Gemini CLI OAuth credentials in any known location');
   return null;
 }
@@ -245,17 +250,19 @@ const GEMINI_OAUTH_FILE = path.join(GEMINI_DIR, 'oauth_creds.json');
 const GEMINI_ACCOUNTS_FILE = path.join(GEMINI_DIR, 'google_accounts.json');
 
 let geminiOAuthState = { status: 'idle', error: null, email: null };
-let geminiOAuthCallbackServer = null;
-
-function getAvailablePort() {
-  return new Promise((resolve, reject) => {
-    const srv = net.createServer();
-    srv.listen(0, () => {
-      const port = srv.address().port;
-      srv.close(() => resolve(port));
-    });
-    srv.on('error', reject);
-  });
+let geminiOAuthPending = null;
+
+function buildBaseUrl(req) {
+  const override = process.env.AGENTGUI_BASE_URL;
+  if (override) return override.replace(/\/+$/, '');
+  const fwdProto = req.headers['x-forwarded-proto'];
+  const fwdHost = req.headers['x-forwarded-host'] || req.headers['host'];
+  if (fwdHost) {
+    const proto = fwdProto || (req.socket.encrypted ? 'https' : 'http');
+    const cleanHost = fwdHost.replace(/:443$/, '').replace(/:80$/, '');
+    return `${proto}://${cleanHost}`;
+  }
+  return `http://127.0.0.1:${PORT}`;
 }
 
 function saveGeminiCredentials(tokens, email) {
@@ -292,17 +299,11 @@ function geminiOAuthResultPage(title, message, success) {
 </div></body></html>`;
 }
 
-async function startGeminiOAuth() {
-  if (geminiOAuthCallbackServer) {
-    try { geminiOAuthCallbackServer.close(); } catch (_) {}
-    geminiOAuthCallbackServer = null;
-  }
-
+async function startGeminiOAuth(baseUrl) {
   const creds = getGeminiOAuthCreds();
   if (!creds) throw new Error('Could not find Gemini CLI OAuth credentials. Install gemini CLI first.');
 
-  const port = await getAvailablePort();
-  const redirectUri = `http://127.0.0.1:${port}/oauth2callback`;
+  const redirectUri = `${baseUrl}${BASE_URL}/oauth2callback`;
   const state = crypto.randomBytes(32).toString('hex');
 
   const client = new OAuth2Client({
@@ -317,93 +318,87 @@ async function startGeminiOAuth() {
     state,
   });
 
+  geminiOAuthPending = { client, redirectUri, state };
   geminiOAuthState = { status: 'pending', error: null, email: null };
 
-  return new Promise((resolve, reject) => {
-    const cbServer = http.createServer(async (req, res) => {
-      try {
-        const reqUrl = new URL(req.url, `http://127.0.0.1:${port}`);
-        if (reqUrl.pathname !== '/oauth2callback') {
-          res.writeHead(404);
-          res.end('Not found');
-          return;
-        }
-
-        const error = reqUrl.searchParams.get('error');
-        if (error) {
-          const desc = reqUrl.searchParams.get('error_description') || error;
-          geminiOAuthState = { status: 'error', error: desc, email: null };
-          res.writeHead(200, { 'Content-Type': 'text/html' });
-          res.end(geminiOAuthResultPage('Authentication Failed', desc, false));
-          cbServer.close();
-          return;
-        }
+  setTimeout(() => {
+    if (geminiOAuthState.status === 'pending') {
+      geminiOAuthState = { status: 'error', error: 'Authentication timed out', email: null };
+      geminiOAuthPending = null;
+    }
+  }, 5 * 60 * 1000);
 
-        if (reqUrl.searchParams.get('state') !== state) {
-          geminiOAuthState = { status: 'error', error: 'State mismatch', email: null };
-          res.writeHead(200, { 'Content-Type': 'text/html' });
-          res.end(geminiOAuthResultPage('Authentication Failed', 'State mismatch.', false));
-          cbServer.close();
-          return;
-        }
+  return authUrl;
+}
 
-        const code = reqUrl.searchParams.get('code');
-        if (!code) {
-          geminiOAuthState = { status: 'error', error: 'No authorization code', email: null };
-          res.writeHead(200, { 'Content-Type': 'text/html' });
-          res.end(geminiOAuthResultPage('Authentication Failed', 'No authorization code received.', false));
-          cbServer.close();
-          return;
-        }
+async function handleGeminiOAuthCallback(req, res) {
+  const reqUrl = new URL(req.url, buildBaseUrl(req));
 
-        const { tokens } = await client.getToken({ code, redirect_uri: redirectUri });
-        client.setCredentials(tokens);
+  if (!geminiOAuthPending) {
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(geminiOAuthResultPage('Authentication Failed', 'No pending OAuth flow.', false));
+    return;
+  }
 
-        let email = '';
-        try {
-          const { token } = await client.getAccessToken();
-          if (token) {
-            const resp = await fetch('https://www.googleapis.com/oauth2/v2/userinfo', {
-              headers: { Authorization: `Bearer ${token}` }
-            });
-            if (resp.ok) {
-              const info = await resp.json();
-              email = info.email || '';
-            }
-          }
-        } catch (_) {}
+  const error = reqUrl.searchParams.get('error');
+  if (error) {
+    const desc = reqUrl.searchParams.get('error_description') || error;
+    geminiOAuthState = { status: 'error', error: desc, email: null };
+    geminiOAuthPending = null;
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(geminiOAuthResultPage('Authentication Failed', desc, false));
+    return;
+  }
 
-        saveGeminiCredentials(tokens, email);
-        geminiOAuthState = { status: 'success', error: null, email };
+  const { client, redirectUri, state: expectedState } = geminiOAuthPending;
 
-        res.writeHead(200, { 'Content-Type': 'text/html' });
-        res.end(geminiOAuthResultPage('Authentication Successful', email ? `Signed in as ${email}` : 'Gemini CLI credentials saved.', true));
-        cbServer.close();
-      } catch (e) {
-        geminiOAuthState = { status: 'error', error: e.message, email: null };
-        res.writeHead(200, { 'Content-Type': 'text/html' });
-        res.end(geminiOAuthResultPage('Authentication Failed', e.message, false));
-        cbServer.close();
-      }
-    });
+  if (reqUrl.searchParams.get('state') !== expectedState) {
+    geminiOAuthState = { status: 'error', error: 'State mismatch', email: null };
+    geminiOAuthPending = null;
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(geminiOAuthResultPage('Authentication Failed', 'State mismatch.', false));
+    return;
+  }
 
-    cbServer.on('error', (err) => {
-      geminiOAuthState = { status: 'error', error: err.message, email: null };
-      reject(err);
-    });
+  const code = reqUrl.searchParams.get('code');
+  if (!code) {
+    geminiOAuthState = { status: 'error', error: 'No authorization code', email: null };
+    geminiOAuthPending = null;
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(geminiOAuthResultPage('Authentication Failed', 'No authorization code received.', false));
+    return;
+  }
 
-    cbServer.listen(port, '127.0.0.1', () => {
-      geminiOAuthCallbackServer = cbServer;
-      resolve(authUrl);
-    });
+  try {
+    const { tokens } = await client.getToken({ code, redirect_uri: redirectUri });
+    client.setCredentials(tokens);
 
-    setTimeout(() => {
-      if (geminiOAuthState.status === 'pending') {
-        geminiOAuthState = { status: 'error', error: 'Authentication timed out', email: null };
-        try { cbServer.close(); } catch (_) {}
+    let email = '';
+    try {
+      const { token } = await client.getAccessToken();
+      if (token) {
+        const resp = await fetch('https://www.googleapis.com/oauth2/v2/userinfo', {
+          headers: { Authorization: `Bearer ${token}` }
+        });
+        if (resp.ok) {
+          const info = await resp.json();
+          email = info.email || '';
+        }
       }
-    }, 5 * 60 * 1000);
-  });
+    } catch (_) {}
+
+    saveGeminiCredentials(tokens, email);
+    geminiOAuthState = { status: 'success', error: null, email };
+    geminiOAuthPending = null;
+
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(geminiOAuthResultPage('Authentication Successful', email ? `Signed in as ${email}` : 'Gemini CLI credentials saved.', true));
+  } catch (e) {
+    geminiOAuthState = { status: 'error', error: e.message, email: null };
+    geminiOAuthPending = null;
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(geminiOAuthResultPage('Authentication Failed', e.message, false));
+  }
 }
 
 function getGeminiOAuthStatus() {
@@ -620,6 +615,11 @@ const server = http.createServer(async (req, res) => {
     // Remove query parameters from routePath for matching
     const pathOnly = routePath.split('?')[0];
 
+    if (pathOnly === '/oauth2callback' && req.method === 'GET') {
+      await handleGeminiOAuthCallback(req, res);
+      return;
+    }
+
     if (pathOnly === '/api/conversations' && req.method === 'GET') {
             sendJSON(req, res, 200, { conversations: queries.getConversationsList() });
       return;
@@ -1093,7 +1093,7 @@ const server = http.createServer(async (req, res) => {
 
     if (pathOnly === '/api/gemini-oauth/start' && req.method === 'POST') {
       try {
-        const authUrl = await startGeminiOAuth();
+        const authUrl = await startGeminiOAuth(buildBaseUrl(req));
         sendJSON(req, res, 200, { authUrl });
       } catch (e) {
         console.error('[gemini-oauth] /api/gemini-oauth/start failed:', e);
@@ -1115,7 +1115,7 @@ const server = http.createServer(async (req, res) => {
 
       if (agentId === 'gemini') {
         try {
-          const authUrl = await startGeminiOAuth();
+          const authUrl = await startGeminiOAuth(buildBaseUrl(req));
           const conversationId = '__agent_auth__';
           broadcastSync({ type: 'script_started', conversationId, script: 'auth-gemini', agentId: 'gemini', timestamp: Date.now() });
           broadcastSync({ type: 'script_output', conversationId, data: `\x1b[36mOpening Google OAuth in your browser...\x1b[0m\r\n\r\nIf it doesn't open automatically, visit:\r\n${authUrl}\r\n`, stream: 'stdout', timestamp: Date.now() });