agentgui 1.0.210 → 1.0.212

package/database.js

@@ -1120,6 +1120,24 @@ export const queries = {
     });
   },
 
+  getChunksSinceSeq(sessionId, sinceSeq) {
+    const stmt = prep(
+      `SELECT id, sessionId, conversationId, sequence, type, data, created_at
+       FROM chunks WHERE sessionId = ? AND sequence > ? ORDER BY sequence ASC`
+    );
+    const rows = stmt.all(sessionId, sinceSeq);
+    return rows.map(row => {
+      try {
+        return {
+          ...row,
+          data: typeof row.data === 'string' ? JSON.parse(row.data) : row.data
+        };
+      } catch (e) {
+        return row;
+      }
+    });
+  },
+
   deleteSessionChunks(sessionId) {
     const stmt = prep('DELETE FROM chunks WHERE sessionId = ?');
     const result = stmt.run(sessionId);

package/package.json

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

package/server.js

@@ -246,6 +246,9 @@ function extractOAuthFromFile(oauth2Path) {
 }
 
 function getGeminiOAuthCreds() {
+  if (process.env.GOOGLE_OAUTH_CLIENT_ID && process.env.GOOGLE_OAUTH_CLIENT_SECRET) {
+    return { clientId: process.env.GOOGLE_OAUTH_CLIENT_ID, clientSecret: process.env.GOOGLE_OAUTH_CLIENT_SECRET, custom: true };
+  }
   const oauthRelPath = path.join('node_modules', '@google', 'gemini-cli-core', 'dist', 'src', 'code_assist', 'oauth2.js');
   try {
     const geminiPath = findCommand('gemini');
@@ -333,13 +336,24 @@ function geminiOAuthResultPage(title, message, success) {
 </div></body></html>`;
 }
 
-async function startGeminiOAuth() {
+function isRemoteRequest(req) {
+  return !!(req && (req.headers['x-forwarded-for'] || req.headers['x-forwarded-host'] || req.headers['x-forwarded-proto']));
+}
+
+async function startGeminiOAuth(req) {
   const creds = getGeminiOAuthCreds();
   if (!creds) throw new Error('Could not find Gemini CLI OAuth credentials. Install gemini CLI first.');
 
-  const redirectUri = `http://localhost:${PORT}${BASE_URL}/oauth2callback`;
-  const state = crypto.randomBytes(32).toString('hex');
+  const useCustomClient = !!creds.custom;
+  const remote = isRemoteRequest(req);
+  let redirectUri;
+  if (useCustomClient && req) {
+    redirectUri = `${buildBaseUrl(req)}${BASE_URL}/oauth2callback`;
+  } else {
+    redirectUri = `http://localhost:${PORT}${BASE_URL}/oauth2callback`;
+  }
 
+  const state = crypto.randomBytes(32).toString('hex');
   const client = new OAuth2Client({
     clientId: creds.clientId,
     clientSecret: creds.clientSecret,
@@ -352,6 +366,7 @@ async function startGeminiOAuth() {
     state,
   });
 
+  const mode = useCustomClient ? 'custom' : (remote ? 'cli-remote' : 'cli-local');
   geminiOAuthPending = { client, redirectUri, state };
   geminiOAuthState = { status: 'pending', error: null, email: null };
 
@@ -362,7 +377,7 @@ async function startGeminiOAuth() {
     }
   }, 5 * 60 * 1000);
 
-  return authUrl;
+  return { authUrl, mode };
 }
 
 async function exchangeGeminiOAuthCode(code, state) {
@@ -926,9 +941,15 @@ const server = http.createServer(async (req, res) => {
       if (!sess) { sendJSON(req, res, 404, { error: 'Session not found' }); return; }
 
       const url = new URL(req.url, 'http://localhost');
+      const sinceSeq = parseInt(url.searchParams.get('sinceSeq') || '-1');
       const since = parseInt(url.searchParams.get('since') || '0');
 
-      const chunks = queries.getChunksSince(sessionId, since);
+      let chunks;
+      if (sinceSeq >= 0) {
+        chunks = queries.getChunksSinceSeq(sessionId, sinceSeq);
+      } else {
+        chunks = queries.getChunksSince(sessionId, since);
+      }
             sendJSON(req, res, 200, { ok: true, chunks });
       return;
     }
@@ -1130,8 +1151,8 @@ const server = http.createServer(async (req, res) => {
 
     if (pathOnly === '/api/gemini-oauth/start' && req.method === 'POST') {
       try {
-        const authUrl = await startGeminiOAuth();
-        sendJSON(req, res, 200, { authUrl });
+        const result = await startGeminiOAuth(req);
+        sendJSON(req, res, 200, { authUrl: result.authUrl, mode: result.mode });
       } catch (e) {
         console.error('[gemini-oauth] /api/gemini-oauth/start failed:', e);
         sendJSON(req, res, 500, { error: e.message });
@@ -1188,10 +1209,10 @@ const server = http.createServer(async (req, res) => {
 
       if (agentId === 'gemini') {
         try {
-          const authUrl = await startGeminiOAuth();
+          const result = await startGeminiOAuth(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() });
+          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${result.authUrl}\r\n`, stream: 'stdout', timestamp: Date.now() });
 
           const pollId = setInterval(() => {
             if (geminiOAuthState.status === 'success') {
@@ -1208,7 +1229,7 @@ const server = http.createServer(async (req, res) => {
 
           setTimeout(() => clearInterval(pollId), 5 * 60 * 1000);
 
-          sendJSON(req, res, 200, { ok: true, agentId, authUrl });
+          sendJSON(req, res, 200, { ok: true, agentId, authUrl: result.authUrl, mode: result.mode });
           return;
         } catch (e) {
           console.error('[gemini-oauth] /api/agents/gemini/auth failed:', e);
@@ -1696,6 +1717,7 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
           conversationId,
           block: systemBlock,
           blockIndex: allBlocks.length,
+          seq: currentSequence,
           timestamp: Date.now()
         });
       } else if (parsed.type === 'assistant' && parsed.message?.content) {
@@ -1711,6 +1733,7 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
             conversationId,
             block,
             blockIndex: allBlocks.length - 1,
+            seq: currentSequence,
             timestamp: Date.now()
           });
 
@@ -1737,6 +1760,7 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
               conversationId,
               block: toolResultBlock,
               blockIndex: allBlocks.length,
+              seq: currentSequence,
               timestamp: Date.now()
             });
           }
@@ -1762,6 +1786,7 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
           block: resultBlock,
           blockIndex: allBlocks.length,
           isResult: true,
+          seq: currentSequence,
           timestamp: Date.now()
         });
 
@@ -1812,6 +1837,7 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
       sessionId,
       conversationId,
       eventCount,
+      seq: currentSequence,
       timestamp: Date.now()
     });
 
@@ -2051,9 +2077,13 @@ wss.on('connection', (ws, req) => {
           }));
         } else if (data.type === 'set_voice') {
           ws.ttsVoiceId = data.voiceId || 'default';
+        } else if (data.type === 'latency_report') {
+          ws.latencyTier = data.quality || 'good';
+          ws.latencyAvg = data.avg || 0;
         } else if (data.type === 'ping') {
           ws.send(JSON.stringify({
             type: 'pong',
+            requestId: data.requestId,
             timestamp: Date.now()
           }));
         }
@@ -2082,13 +2112,16 @@ wss.on('connection', (ws, req) => {
 const BROADCAST_TYPES = new Set([
   'message_created', 'conversation_created', 'conversation_updated',
   'conversations_updated', 'conversation_deleted', 'queue_status', 'queue_updated',
-  'streaming_start', 'streaming_complete', 'streaming_error',
   'rate_limit_hit', 'rate_limit_clear',
   'script_started', 'script_stopped', 'script_output'
 ]);
 
 const wsBatchQueues = new Map();
-const WS_BATCH_INTERVAL = 16;
+const BATCH_BY_TIER = { excellent: 16, good: 32, fair: 50, poor: 100, bad: 200 };
+
+function getBatchInterval(ws) {
+  return BATCH_BY_TIER[ws.latencyTier] || 32;
+}
 
 function flushWsBatch(ws) {
   const queue = wsBatchQueues.get(ws);
@@ -2109,7 +2142,7 @@ function sendToClient(ws, data) {
   if (!queue) { queue = { msgs: [], timer: null }; wsBatchQueues.set(ws, queue); }
   queue.msgs.push(data);
   if (!queue.timer) {
-    queue.timer = setTimeout(() => flushWsBatch(ws), WS_BATCH_INTERVAL);
+    queue.timer = setTimeout(() => flushWsBatch(ws), getBatchInterval(ws));
   }
 }
 

package/static/index.html

@@ -2213,6 +2213,85 @@
     }
 
     html.dark .event-streaming-complete { background: linear-gradient(135deg, #0a1f0f, #0f2b1a); }
+
+    @keyframes skeleton-pulse {
+      0%, 100% { opacity: 0.4; }
+      50% { opacity: 0.15; }
+    }
+    .skeleton-pulse { animation: skeleton-pulse 1.5s ease-in-out infinite; }
+    .skeleton-loading { padding: 1rem; }
+
+    .message-sending { opacity: 0.6; transition: opacity 0.3s ease; }
+    .message-send-failed { border-left: 3px solid var(--color-error); }
+
+    .connection-indicator {
+      display: inline-flex;
+      align-items: center;
+      gap: 0.375rem;
+      padding: 0.25rem 0.5rem;
+      border-radius: 1rem;
+      font-size: 0.75rem;
+      cursor: pointer;
+      transition: all 0.3s ease;
+    }
+    .connection-dot {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      transition: background-color 0.5s ease;
+    }
+    .connection-dot.excellent { background: #10b981; }
+    .connection-dot.good { background: #10b981; }
+    .connection-dot.fair { background: #f59e0b; }
+    .connection-dot.poor { background: #f97316; }
+    .connection-dot.bad { background: #ef4444; }
+    .connection-dot.unknown { background: #6b7280; }
+    .connection-dot.disconnected { background: #ef4444; animation: pulse 1.5s ease-in-out infinite; }
+    .connection-dot.reconnecting { background: #f59e0b; animation: pulse 1s ease-in-out infinite; }
+
+    .connection-tooltip {
+      position: absolute;
+      top: 100%;
+      right: 0;
+      margin-top: 0.5rem;
+      padding: 0.75rem;
+      background: var(--color-bg-secondary);
+      border: 1px solid var(--color-border);
+      border-radius: 0.5rem;
+      font-size: 0.75rem;
+      white-space: nowrap;
+      z-index: 100;
+      box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+    }
+
+    .new-content-pill {
+      position: sticky;
+      bottom: 0.5rem;
+      left: 50%;
+      transform: translateX(-50%);
+      padding: 0.375rem 1rem;
+      background: var(--color-primary);
+      color: white;
+      border: none;
+      border-radius: 1rem;
+      font-size: 0.8rem;
+      cursor: pointer;
+      z-index: 50;
+      box-shadow: 0 2px 8px rgba(0,0,0,0.2);
+      transition: opacity 0.2s ease;
+    }
+    .new-content-pill:hover { opacity: 0.9; }
+
+    @keyframes block-appear {
+      from { opacity: 0; transform: translateY(6px); }
+      to { opacity: 1; transform: translateY(0); }
+    }
+    .streaming-blocks > * {
+      animation: block-appear 0.2s ease-out both;
+    }
+    .streaming-blocks > details.block-tool-use {
+      transition: max-height 0.3s ease;
+    }
   </style>
 </head>
 <body>

package/static/js/agent-auth.js

@@ -217,7 +217,8 @@
         if (data.authUrl) {
           window.open(data.authUrl, '_blank');
           if (agentId === 'gemini') {
-            showOAuthPasteModal();
+            var needsPaste = data.mode === 'cli-remote';
+            if (needsPaste) showOAuthPasteModal();
             cleanupOAuthPolling();
             oauthPollInterval = setInterval(function() {
               fetch(BASE + '/api/gemini-oauth/status').then(function(r) { return r.json(); }).then(function(status) {