agent-tank 0.9.1 → 0.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-tank",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Monitor and query usage limits for LLM CLI tools (Claude, Gemini, Codex) via HTTP API",
   "main": "src/index.js",
   "bin": {

package/src/agents/base.js

@@ -11,6 +11,7 @@ class BaseAgent {
     this._metadataFetched = false;
     this.lastUpdated = null;
     this.error = null;
+    this.auth = null;
     this.isRefreshing = false;
     this.refreshInterval = null;    // Per-agent override (seconds), null = use global
     this.minRefreshInterval = null; // Per-agent minimum (seconds), null = no minimum
@@ -32,6 +33,7 @@ class BaseAgent {
       metadata: this.metadata,
       lastUpdated: this.lastUpdated,
       error: this.error,
+      auth: this.auth,
       isRefreshing: this.isRefreshing,
     };
   }
@@ -45,6 +47,7 @@ class BaseAgent {
     logger.agent(this.name, 'Starting refresh...');
     this.isRefreshing = true;
     this.error = null;
+    this.auth = null;
 
     try {
       // Fetch metadata once on first refresh (if agent supports it)
@@ -71,6 +74,15 @@ class BaseAgent {
       // Check for rate limit and session errors before parsing
       // Match actual error messages, not incidental mentions like "rate limits and credits"
       const cleanOutput = this.stripAnsi(output);
+      const authState = this.detectAuthenticationState ? this.detectAuthenticationState(cleanOutput) : null;
+      if (authState) {
+        logger.agent(this.name, 'Authentication issue detected:', logger.json(authState));
+        this.auth = authState;
+        this.error = this.usage ? `${authState.message} — using cached data` : authState.message;
+        this.lastUpdated = new Date().toISOString();
+        return;
+      }
+
       if (/rate.?limited|rate_limit_error/i.test(cleanOutput)) {
         logger.agent(this.name, 'Rate limited, preserving last known usage data');
         this.error = 'Rate limited — using cached data';
@@ -159,6 +171,20 @@ class BaseAgent {
         this._handleAdditionalPrompts(this.shell, data, spawnOutput);
         this._respondToTerminalQueries(data);
 
+        const authState = this.detectAuthenticationState ? this.detectAuthenticationState(spawnOutput) : null;
+        if (authState) {
+          logger.agent(this.name, 'Authentication issue detected during spawn');
+          clearTimeout(timer);
+          spawnDataHandler.dispose();
+          spawnExitHandler.dispose();
+          this.processReady = true;
+          this.output = spawnOutput;
+          this._setupPersistentDataHandler();
+          this._setupPersistentExitHandler();
+          resolve();
+          return;
+        }
+
         if (Date.now() >= trustCooldownUntil && this.isReadyForCommands(spawnOutput)) {
           logger.agent(this.name, 'Process ready for commands');
           clearTimeout(timer);
@@ -183,6 +209,14 @@ class BaseAgent {
 
   async sendCommandAndWait() {
     return new Promise((resolve, reject) => {
+      const existingOutput = this.output;
+      const existingAuthState = this.detectAuthenticationState ? this.detectAuthenticationState(existingOutput) : null;
+      if (existingAuthState) {
+        logger.agent(this.name, 'Using existing authentication output without sending commands');
+        resolve(existingOutput);
+        return;
+      }
+
       this.output = '';
       this._commandInFlight = true;
 

package/src/agents/gemini.js

@@ -10,10 +10,24 @@ class GeminiAgent extends BaseAgent {
   }
 
   getTimeout() {
-    return 25000; // 25 seconds
+    return 35000; // 35 seconds - Gemini can take 10+ seconds to start
+  }
+
+  getEnv() {
+    // Use xterm-256color for proper terminal support
+    // Gemini CLI needs good terminal emulation for its TUI
+    return {
+      ...process.env,
+      TERM: 'xterm-256color',
+      COLORTERM: 'truecolor',
+    };
   }
 
   isReadyForCommands(output) {
+    // Don't consider ready if authentication is in progress
+    if (this._isAuthenticating(output)) {
+      return false;
+    }
     // v0.24: "Type your message" prompt
     // v0.35+: "Ready" in terminal title + visible prompt area (no "Type your message")
     // Also check for terminal title sequence containing "Ready"
@@ -22,6 +36,52 @@ class GeminiAgent extends BaseAgent {
       || /Ready\s*\(/.test(output);
   }
 
+  _isAuthenticating(output) {
+    // Detect OAuth/authentication screens where Escape would cancel the flow
+    const clean = this.stripAnsi(output);
+
+    // If we see the ready prompt, auth is complete (even if auth text still in buffer)
+    if (clean.includes('Type your message') || clean.includes('? for shortcuts')) {
+      return false;
+    }
+
+    // Only consider authenticating if we see auth-specific text
+    return /waiting for authentication/i.test(clean)
+      || /press esc.*to cancel/i.test(clean)
+      || /authenticating\.\.\./i.test(clean);
+  }
+
+  detectAuthenticationState(output) {
+    const clean = this.stripAnsi(output);
+    if (!clean) return null;
+
+    const hasAuthMenu = /how would you like to authenticate for this project\?/i.test(clean)
+      || /get started/i.test(clean);
+    const hasAuthFailure = /failed to sign in\.\s*message:\s*([^\n]+)/i.test(clean)
+      || /please run gemini cli in an interactive terminal to authenticate/i.test(clean)
+      || /authentication consent could not be obtained/i.test(clean);
+
+    if (!hasAuthMenu && !hasAuthFailure) {
+      return null;
+    }
+
+    const failureMatch = clean.match(/failed to sign in\.\s*message:\s*([^\n]+)/i);
+    const detail = failureMatch
+      ? `Failed to sign in: ${failureMatch[1].trim()}`
+      : 'Gemini CLI is waiting for authentication.';
+    const action = /NO_BROWSER=true/i.test(clean)
+      ? 'Run Gemini CLI in an interactive terminal to authenticate, or use NO_BROWSER=true for manual authentication.'
+      : 'Run Gemini CLI in an interactive terminal to authenticate.';
+
+    return {
+      authenticated: false,
+      status: 'unauthenticated',
+      message: 'Authentication required',
+      detail,
+      action,
+    };
+  }
+
   handleTrustPrompt(shell, output) {
     // Check for trust prompt with various wordings
     const trustPatterns = [
@@ -42,6 +102,7 @@ class GeminiAgent extends BaseAgent {
       // v0.35+ does an internal restart after trust — send Escape after a delay
       // to dismiss any transitional UI before the process becomes ready again
       setTimeout(() => {
+        if (!shell) return;
         logger.agent(this.name, 'Post-trust: sending Escape to clear restart UI...');
         shell.write('\x1b');
       }, 3000);
@@ -55,6 +116,7 @@ class GeminiAgent extends BaseAgent {
     // Gemini shows "Usage limits" after the model usage table (v0.24.x)
     if (output.includes('Usage limits span all sessions')) return true;
     const clean = this.stripAnsi(output);
+    if (this.detectAuthenticationState(clean)) return true;
     const hasModel = /gemini-[\w.-]+/i.test(clean);
     const hasPercent = /\d+(?:\.\d+)?%/i.test(clean);
     // v0.24: "Resets in 3h 26m", v0.35+: "(23h 21m)" after time
@@ -89,10 +151,16 @@ class GeminiAgent extends BaseAgent {
     return totalSeconds > 0 ? totalSeconds : null;
   }
 
-  sendCommands(shell, _output) {
+  sendCommands(shell, output) {
+    // Check if authentication is still in progress - don't send commands that could interfere
+    if (this._isAuthenticating(output) || this.detectAuthenticationState(output)) {
+      logger.agent(this.name, 'Authentication required or in progress, cannot send /stats command');
+      // Don't retry - let the timeout handle it. Sending Escape would cancel auth.
+      return;
+    }
     logger.agent(this.name, 'Sending /stats command...');
     // v0.35+: typing /stats triggers autocomplete dropdown.
-    // Escape dismisses autocomplete, then Enter submits the command.
+    // Escape clears any pending state, then send command, Escape again to dismiss autocomplete
     setTimeout(() => shell.write('\x1b'), 50);
     setTimeout(() => shell.write('/stats'), 500);
     setTimeout(() => shell.write('\x1b'), 1000);
@@ -161,6 +229,10 @@ class GeminiAgent extends BaseAgent {
       await this.spawnProcess();
     }
 
+    if (this.detectAuthenticationState(this.output)) {
+      return null;
+    }
+
     return new Promise((resolve, _reject) => {
       let aboutOutput = '';
       let completed = false;
@@ -181,8 +253,16 @@ class GeminiAgent extends BaseAgent {
       }, 10000); // 10 second timeout for /about
 
       this._commandInFlight = true;
+      let trustHandled = false;
       this._onDataCallback = () => {
         aboutOutput = this.output;
+        // Handle trust prompts that appear during command execution
+        if (!trustHandled && this.handleTrustPrompt(this.shell, aboutOutput)) {
+          trustHandled = true;
+          aboutOutput = '';
+          this.output = '';
+          return;
+        }
         // Check if we have complete /about output
         if (this._hasCompleteAboutOutput(aboutOutput)) {
           logger.agent(this.name, 'Complete /about output detected');
@@ -192,11 +272,39 @@ class GeminiAgent extends BaseAgent {
 
       logger.agent(this.name, 'Sending /about command for metadata...');
       this.output = '';
-      // Escape clears pending state, delay for CLI to be fully interactive,
-      // second Enter in case /about has an autocomplete menu in newer versions
-      setTimeout(() => this.shell.write('\x1b'), 100);
-      setTimeout(() => this.shell.write('/about\r'), 2000);
-      setTimeout(() => this.shell.write('\r'), 2500);
+
+      // Wait for authentication to complete before sending commands
+      // Auth can start after spawn if token refresh is needed
+      // Gemini can take 10+ seconds to fully start up
+      let authWaitCount = 0;
+      const maxAuthWait = 15; // Max 15 seconds waiting for auth
+
+      const waitForAuth = () => {
+        if (this.detectAuthenticationState(this.output)) {
+          logger.agent(this.name, 'Authentication required, skipping /about metadata fetch');
+          finish(null);
+          return;
+        }
+        if (this._isAuthenticating(this.output)) {
+          authWaitCount++;
+          if (authWaitCount >= maxAuthWait) {
+            logger.agent(this.name, 'Authentication timeout - Gemini may be stuck in auth flow');
+            // Don't send commands that would interfere with stuck auth
+            // Let the overall timeout handle this
+            return;
+          }
+          logger.agent(this.name, 'Authentication in progress, waiting...');
+          setTimeout(waitForAuth, 1000);
+          return;
+        }
+        // Auth complete (or not happening), send commands
+        // Guard against shell being nullified if process exits during setTimeout delays
+        // Don't send Escape first - it can cancel auth flows that started between checks
+        setTimeout(() => this.shell?.write('/about\r'), 500);
+        setTimeout(() => this.shell?.write('\r'), 1000);
+      };
+
+      setTimeout(waitForAuth, 100);
     });
   }
 

package/src/status-page.css

@@ -516,6 +516,21 @@ body.light-mode .progress-bar {
   font-size: 13px;
 }
 
+.auth-notice {
+  font-size: 13px;
+  color: #f6ad55;
+  padding: 8px 10px;
+  margin-bottom: 10px;
+  background: rgba(246, 173, 85, 0.08);
+  border: 1px solid rgba(246, 173, 85, 0.2);
+  border-radius: 4px;
+}
+
+.auth-detail {
+  margin-top: 4px;
+  color: var(--text-secondary);
+}
+
 /* Version update notice below agent cards */
 .version-update-notice {
   font-family: var(--font-mono);
@@ -533,6 +548,12 @@ body.light-mode .version-update-notice {
   border-color: rgba(183, 121, 31, 0.2);
 }
 
+body.light-mode .auth-notice {
+  color: #b7791f;
+  background: rgba(246, 173, 85, 0.12);
+  border-color: rgba(183, 121, 31, 0.2);
+}
+
 button {
   width: 100%;
   padding: 10px;

package/src/status-page.js

@@ -9,6 +9,15 @@ const { getStatusBadgeClass, getStatusText } = require('./public-status');
 
 const styles = fs.readFileSync(path.join(__dirname, 'status-page.css'), 'utf8');
 
+function escapeHtml(value) {
+  return String(value)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
 function statusPage(status) {
   const agents = Object.entries(status);
 
@@ -36,7 +45,7 @@ function statusPage(status) {
     const publicStatus = data.publicStatus;
     const badgeClass = publicStatus ? getStatusBadgeClass(publicStatus.status) : 'status-badge-grey';
     const badgeText = publicStatus ? getStatusText(publicStatus.status) : 'Unknown';
-    const badgeTitle = publicStatus?.description || 'Unable to fetch status';
+    const badgeTitle = escapeHtml(publicStatus?.description || 'Unable to fetch status');
     const statusBadgeHtml = `<span class="status-badge ${badgeClass}" title="${badgeTitle}">${badgeText}</span>`;
 
     // Version update notice - check usage.version (Codex) or metadata.updateAvailable (Gemini)
@@ -45,10 +54,15 @@ function statusPage(status) {
       ? `<div class="version-update-notice">Update available: v${version.current} → v${version.latest}</div>`
       : '';
 
+    const authHtml = data.auth
+      ? `<div class="auth-notice">${escapeHtml(data.auth.action || 'Please log in via the CLI.')}</div>`
+      : '';
+    const errorHtml = data.error && !data.auth ? `<span class="error-msg">${escapeHtml(data.error)}</span>` : '';
+
     // Only show card-footer if there's an error or update notice
-    const hasFooterContent = data.error || updateHtml;
+    const hasFooterContent = errorHtml || authHtml || updateHtml;
     const footerHtml = hasFooterContent
-      ? `<div class="card-footer">${data.error ? `<span class="error-msg">${data.error}</span>` : ''}${updateHtml}</div>`
+      ? `<div class="card-footer">${errorHtml}${authHtml}${updateHtml}</div>`
       : '';
 
     return `