agent-tank 0.9.6 → 0.9.8

package/src/agents/agy.js

@@ -0,0 +1,301 @@
+const { BaseAgent } = require('./base.js');
+const { calculatePace } = require('../pace-evaluator.js');
+const { CYCLE_DURATIONS } = require('../usage-formatters.js');
+const logger = require('../logger.js');
+
+class AgyAgent extends BaseAgent {
+  constructor() {
+    super('agy', 'agy', ['--dangerously-skip-permissions']);
+    this._aboutSent = false;
+  }
+
+  getTimeout() {
+    return 35000; // Antigravity can take 10+ seconds to start and sign in
+  }
+
+  getEnv() {
+    // Use xterm-256color for proper terminal support
+    // Antigravity CLI needs good terminal emulation for its TUI
+    return {
+      ...process.env,
+      TERM: 'xterm-256color',
+      COLORTERM: 'truecolor',
+    };
+  }
+
+  _hasReadyPrompt(output) {
+    const clean = this.stripAnsi(output);
+    return /Antigravity CLI[\s\S]*\n>\s*(?:\n|$)/i.test(clean)
+      || /Google AI Pro[\s\S]*\n>\s*(?:\n|$)/i.test(clean)
+      || /Ready\s*\(/.test(clean);
+  }
+
+  isReadyForCommands(output) {
+    // Don't consider ready if authentication is in progress
+    if (this._isAuthenticating(output)) {
+      return false;
+    }
+    return this._hasReadyPrompt(output);
+  }
+
+  _isAuthenticating(output) {
+    // Detect OAuth/authentication screens where Escape would cancel the flow
+    const clean = this.stripAnsi(output);
+    const hasAuthFlow = /waiting for authentication/i.test(clean)
+      || /signing in/i.test(clean)
+      || /press esc.*to cancel/i.test(clean)
+      || /authenticating\.\.\./i.test(clean);
+
+    if (!hasAuthFlow) {
+      return false;
+    }
+
+    // Footer hints can render before the actual input prompt is available.
+    // Treat auth as complete only when the real prompt has returned.
+    return !this._hasReadyPrompt(clean);
+  }
+
+  detectAuthenticationState(output) {
+    const clean = this.stripAnsi(output);
+    if (!clean) return null;
+
+    const hasAuthFailure = /failed to sign in\.\s*message:\s*([^\n]+)/i.test(clean)
+      || /authentication consent could not be obtained/i.test(clean);
+    if (hasAuthFailure) {
+      const failureMatch = clean.match(/failed to sign in\.\s*message:\s*([^\n]+)/i);
+      const detail = failureMatch
+        ? `Failed to sign in: ${failureMatch[1].trim()}`
+        : 'Antigravity CLI authentication failed.';
+
+      return {
+        authenticated: false,
+        status: 'unauthenticated',
+        message: 'Authentication required',
+        detail,
+        action: 'Run agy in an interactive terminal to authenticate.',
+      };
+    }
+
+    if (this._hasReadyPrompt(clean) || /signing in/i.test(clean)) {
+      return null;
+    }
+
+    const hasAuthMenu = /how would you like to authenticate for this project\?/i.test(clean)
+      || /currently not signed in/i.test(clean);
+
+    if (!hasAuthMenu) {
+      return null;
+    }
+
+    return {
+      authenticated: false,
+      status: 'unauthenticated',
+      message: 'Authentication required',
+      detail: 'Antigravity CLI is waiting for authentication.',
+      action: 'Run agy in an interactive terminal to authenticate.',
+    };
+  }
+
+  handleTrustPrompt(shell, output) {
+    // Check for trust prompt with various wordings
+    const trustPatterns = [
+      'Do you trust',
+      'trust the files',
+      'trust this folder',
+      'Trust this workspace',
+      'allow access',
+      'grant access',
+      'grant full access',
+    ];
+
+    if (trustPatterns.some(pattern => output.toLowerCase().includes(pattern.toLowerCase()))) {
+      logger.agent(this.name, 'Detected trust prompt, auto-accepting...');
+      // Numbered menu with "1. Trust folder" pre-selected; Enter accepts it.
+      shell.write('1\r');
+
+      // Antigravity can redraw after trust; clear transitional UI before readiness.
+      setTimeout(() => {
+        if (!shell) return;
+        logger.agent(this.name, 'Post-trust: sending Escape to clear restart UI...');
+        shell.write('\x1b');
+      }, 3000);
+
+      return true;
+    }
+    return false;
+  }
+
+  hasCompleteOutput(output) {
+    const clean = this.stripAnsi(output);
+    if (this.detectAuthenticationState(clean)) return true;
+    if (/Model\s+Quota/i.test(clean)) {
+      return /(?:Gemini|Claude|GPT)[\s\S]*\d+(?:\.\d+)?%/i.test(clean);
+    }
+    const hasModel = /(?:Gemini|Claude|GPT)[^\n]+/i.test(clean);
+    const hasPercent = /\d+(?:\.\d+)?%/i.test(clean);
+    return hasModel && hasPercent;
+  }
+
+  // Convert duration string like "3h 26m" or "5d 2h" to seconds
+  parseDurationToSeconds(durationStr) {
+    if (!durationStr) return null;
+
+    let totalSeconds = 0;
+
+    // Match days
+    const daysMatch = durationStr.match(/(\d+)\s*d/i);
+    if (daysMatch) {
+      totalSeconds += parseInt(daysMatch[1]) * 24 * 60 * 60;
+    }
+
+    // Match hours
+    const hoursMatch = durationStr.match(/(\d+)\s*h/i);
+    if (hoursMatch) {
+      totalSeconds += parseInt(hoursMatch[1]) * 60 * 60;
+    }
+
+    // Match minutes
+    const minsMatch = durationStr.match(/(\d+)\s*m/i);
+    if (minsMatch) {
+      totalSeconds += parseInt(minsMatch[1]) * 60;
+    }
+
+    return totalSeconds > 0 ? totalSeconds : null;
+  }
+
+  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 /usage command');
+      // Don't retry - let the timeout handle it. Sending Escape would cancel auth.
+      return;
+    }
+    logger.agent(this.name, 'Sending /usage command...');
+    setTimeout(() => shell.write('/usage'), 200);
+    setTimeout(() => shell.write('\r'), 600);
+  }
+
+  // Calculate pace data for a model entry when reset timing is available.
+  _addPaceData(entry, resetsInSeconds) {
+    const cycleDuration = CYCLE_DURATIONS.sessionAgy;
+    if (!cycleDuration || resetsInSeconds == null) return;
+    const paceData = calculatePace({ usagePercent: entry.percentUsed, resetsInSeconds, cycleDurationSeconds: cycleDuration });
+    if (paceData) entry.pace = paceData;
+  }
+
+  parseOutput(output) {
+    const clean = this.stripAnsi(output);
+    const usage = {
+      models: [],
+    };
+
+    this._parseAgyUsage(clean, usage);
+
+    // Detect version update notification in output
+    const updateMatch = clean.match(/[Uu]pdate\s+available[^\d]*([\d.]+)\s*(?:→|->|to)\s*([\d.]+)/);
+    if (updateMatch) {
+      usage.version = { current: updateMatch[1], latest: updateMatch[2] };
+    }
+
+    return usage;
+  }
+
+  _parseAgyUsage(clean, usage) {
+    if (!/Model\s+Quota/i.test(clean)) return;
+
+    const lines = clean.split('\n').map(line => line.trim()).filter(Boolean);
+    const knownMarkers = new Set([
+      'Model Quota',
+      'Quota available',
+      '? for shortcuts',
+    ]);
+
+    for (let i = 0; i < lines.length; i++) {
+      const modelLine = lines[i];
+      if (knownMarkers.has(modelLine) || /^(?:[>└]|[-─↑/↓]|esc\s+to\s+cancel)/i.test(modelLine)) {
+        continue;
+      }
+      if (!/[A-Za-z]/.test(modelLine) || /\d+\s*%/.test(modelLine)) {
+        continue;
+      }
+
+      const percentLine = lines[i + 1] || '';
+      const percentMatch = percentLine.match(/(\d+(?:\.\d+)?)\s*%/);
+      if (!percentMatch) {
+        continue;
+      }
+
+      const usageLeft = parseFloat(percentMatch[1]);
+      const percentUsed = Number((100 - usageLeft).toFixed(1));
+      const resetLine = lines[i + 2] || '';
+      const resetMatch = resetLine.match(/(?:resets?|available)\s*(?:in|at)?\s*([0-9dhm\s]+)?/i);
+      const resetsIn = resetMatch?.[1]?.trim() || null;
+      const resetsInSeconds = resetsIn ? this.parseDurationToSeconds(resetsIn) : null;
+
+      if (!usage.models.find(m => m.model === modelLine)) {
+        const modelEntry = { model: modelLine, usageLeft, percentUsed, resetsIn, resetsInSeconds };
+        this._addPaceData(modelEntry, resetsInSeconds);
+        usage.models.push(modelEntry);
+      }
+    }
+  }
+
+  async fetchMetadata() {
+    if (this._aboutSent) {
+      return this.metadata;
+    }
+
+    this._aboutSent = true;
+    return this._parseAgyMetadata(this.output);
+  }
+
+  _parseAgyMetadata(output) {
+    const clean = this.stripAnsi(output);
+    const metadata = {};
+
+    const versionMatch = clean.match(/Antigravity\s+CLI\s+v?([\d.]+)/i);
+    if (versionMatch) metadata.version = versionMatch[1];
+
+    const emailMatch = clean.match(/(\S+@\S+)/);
+    if (emailMatch) metadata.email = this.stripBoxChars(emailMatch[1]);
+
+    const cwdMatch = clean.match(/\n\s*(\/[^\n]+)\n/);
+    if (cwdMatch) metadata.cwd = this.stripBoxChars(cwdMatch[1]);
+
+    const modelMatch = clean.match(/((?:Gemini|Claude|GPT)[^\n]+?)\s+\((?:Google AI|[^)]*Pro|[^)]*Free|[^)]*)\)/i)
+      || clean.match(/\?\s+for\s+shortcuts\s+(.+?)(?:\n|$)/i);
+    if (modelMatch) metadata.model = this.stripBoxChars(modelMatch[1]);
+
+    metadata.cli = 'agy';
+    return Object.keys(metadata).length > 1 ? metadata : { cli: 'agy' };
+  }
+
+  /**
+   * Lightweight keepalive to prevent session expiration.
+   * Sends escape key to maintain the PTY session without triggering API calls.
+   *
+   * @returns {Promise<boolean>} True if keepalive succeeded
+   */
+  async keepalive() {
+    if (this.freshProcess) {
+      console.log(`[${this.name}] Keepalive skipped (fresh process mode)`);
+      return true;
+    }
+
+    if (!this.shell || !this.processReady) {
+      console.log(`[${this.name}] Keepalive: spawning process...`);
+      await this.spawnProcess();
+    }
+
+    if (this.shell) {
+      console.log(`[${this.name}] Keepalive: sending ping...`);
+      // Send escape key to dismiss any UI and trigger activity
+      this.shell.write('\x1b');
+      return true;
+    }
+
+    return false;
+  }
+}
+
+module.exports = { AgyAgent };

package/src/agents/base.js

@@ -1,3 +1,5 @@
+/* eslint-disable max-lines -- Tracked in issue #90; keep this PR scoped to background startup behavior. */
+
 const pty = require('node-pty');
 const process = require('node:process');
 const logger = require('../logger.js');
@@ -32,6 +34,25 @@ class BaseAgent {
     return new Error('Agent stopping');
   }
 
+  /**
+   * Best-effort dump of raw output to a temp file for debugging.
+   * Never throws: the target may be unwritable (e.g. a stale file in
+   * /tmp owned by another user), and these dumps run inside timer
+   * callbacks where an exception would crash the whole process.
+   * @param {string} output Raw output to dump
+   * @returns {string|null} Path written to, or null on failure
+   */
+  writeDebugOutput(output) {
+    const debugPath = require('node:path').join(require('node:os').tmpdir(), `${this.name}-output.txt`);
+    try {
+      require('fs').writeFileSync(debugPath, output);
+      return debugPath;
+    } catch (err) {
+      logger.agent(this.name, 'Could not write debug output:', logger.dim(err.message));
+      return null;
+    }
+  }
+
   isStopping() {
     return this._stopRequested;
   }
@@ -308,7 +329,7 @@ class BaseAgent {
         logger.agent(this.name, 'Command timeout after', logger.dim(`${this.getTimeout()}ms`), ', output length:', logger.dim(`${this.output.length}`));
         if (this.output.length > 0) {
           logger.agent(this.name, 'Partial output:', logger.dim(this.stripAnsi(this.output).substring(0, 500)));
-          require('fs').writeFileSync(`/tmp/${this.name}-output.txt`, this.output);
+          this.writeDebugOutput(this.output);
         }
         // Kill the stuck process so it respawns fresh on the next refresh
         logger.agent(this.name, 'Killing stuck process to force respawn');
@@ -351,7 +372,7 @@ class BaseAgent {
       this.output += data;
 
       // Always respond to terminal queries — suppressing them causes deadlocks
-      // when CLIs (e.g. Gemini) wait for cursor position responses before
+      // when CLIs wait for cursor position responses before
       // rendering output. Delay slightly during command-in-flight to avoid
       // interleaving with command text being sent via setTimeout.
       if (this._commandInFlight) {
@@ -448,8 +469,10 @@ class BaseAgent {
           logger.agent(this.name, 'Timeout after', logger.dim(`${timeout}ms`), ', output length:', logger.dim(`${output.length}`));
           if (output.length > 0) {
             logger.agent(this.name, 'Partial output:', logger.dim(this.stripAnsi(output).substring(0, 500)));
-            require('fs').writeFileSync(`/tmp/${this.name}-output.txt`, output);
-            logger.agent(this.name, 'Full output written to', logger.dim(`/tmp/${this.name}-output.txt`));
+            const debugPath = this.writeDebugOutput(output);
+            if (debugPath) {
+              logger.agent(this.name, 'Full output written to', logger.dim(debugPath));
+            }
           }
           shell.kill();
           if (output.length > 100) {

package/src/agents/claude.js

@@ -209,20 +209,28 @@ class ClaudeAgent extends BaseAgent {
     const hasSessionData = parsed.session && typeof parsed.session.percent === 'number';
     const hasLegacyWeekly = parsed.weekly && typeof parsed.weekly.percent === 'number';
     const hasAllModelsWeekly = parsed.weeklyAll && typeof parsed.weeklyAll.percent === 'number';
+    const hasSonnetWeekly = parsed.weeklySonnet && typeof parsed.weeklySonnet.percent === 'number';
 
     // Newer Claude builds often emit usable session/weekly data before the UI fully settles.
-    // If we can already parse session data plus either weekly format, treat the response as complete.
-    return hasSessionData && (hasLegacyWeekly || hasAllModelsWeekly);
+    // For the all-model weekly format, wait for the separate Sonnet section too.
+    return Boolean(hasSessionData && (hasLegacyWeekly || (hasAllModelsWeekly && hasSonnetWeekly)));
   }
 
   sendCommands(shell, _output) {
     logger.agent(this.name, 'Sending /usage command...');
     // Claude keeps slash-command suggestions open for /usage on newer builds.
     // Confirm the command selection, then submit the actual command execution.
-    setTimeout(() => shell.write('\x1b'), 50);
-    setTimeout(() => shell.write('/usage'), 600);
-    setTimeout(() => shell.write('\r'), 1000);
-    setTimeout(() => shell.write('\r'), 1400);
+    const writeIfActive = (value) => {
+      if (!shell) return;
+      try {
+        shell.write(value);
+      } catch (_err) {
+        // The persistent exit handler records the underlying process state.
+      }
+    };
+    setTimeout(() => writeIfActive('/usage'), 100);
+    setTimeout(() => writeIfActive('\r'), 500);
+    setTimeout(() => writeIfActive('\r'), 900);
   }
 
   // After getting /usage output, dismiss dialog so next refresh starts with clean prompt
@@ -286,6 +294,18 @@ class ClaudeAgent extends BaseAgent {
         this._onDataCallback = null;
         this._commandInFlight = false;
         clearTimeout(timer);
+        if (this.shell && statusOutput) {
+          try {
+            this.shell.write('\x1b');
+          } catch (_err) {
+            // The persistent exit handler records the underlying process state.
+          }
+          setTimeout(() => {
+            this.output = '';
+            resolve(result);
+          }, 300);
+          return;
+        }
         resolve(result);
       };
 
@@ -306,10 +326,19 @@ class ClaudeAgent extends BaseAgent {
 
       logger.agent(this.name, 'Sending /status command for metadata...');
       this.output = '';
-      // Send escape first to dismiss any UI, then /status
-      setTimeout(() => this.shell.write('\x1b'), 50);
-      setTimeout(() => this.shell.write('/status'), 600);
-      setTimeout(() => this.shell.write('\r'), 1000);
+      const writeIfActive = (value) => {
+        if (!this.shell) {
+          finish(this._parseStatusOutput(statusOutput));
+          return;
+        }
+        try {
+          this.shell.write(value);
+        } catch (_err) {
+          finish(this._parseStatusOutput(statusOutput));
+        }
+      };
+      setTimeout(() => writeIfActive('/status'), 100);
+      setTimeout(() => writeIfActive('\r'), 500);
     });
   }
 

package/src/agents/codex.js

@@ -229,7 +229,7 @@ class CodexAgent extends BaseAgent {
         logger.agent(this.name, 'Command timeout after', logger.dim(`${this.getTimeout()}ms`), ', output length:', logger.dim(`${this.output.length}`));
         if (this.output.length > 0) {
           logger.agent(this.name, 'Partial output:', logger.dim(this.stripAnsi(this.output).substring(0, 500)));
-          require('fs').writeFileSync(`/tmp/${this.name}-output.txt`, this.output);
+          this.writeDebugOutput(this.output);
         }
         if (this.output.length > 100) {
           finish(this.output);

package/src/agents/pty-output-parser.js

@@ -125,6 +125,12 @@ function extractResetTime(section) {
   // Look for date+time pattern FIRST (more specific)
   const dateTimeMatch = section.match(/((?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2},?\s*\d{1,2}(?::\d{2})?\s*(am|pm))\s*\(([^)]+)\)/i);
   if (dateTimeMatch) return `${dateTimeMatch[1]} (${dateTimeMatch[3]})`;
+  // Compact PTY output can lose the column spaces: "Jun10,6pm(Europe/Berlin)".
+  const compactDateTimeMatch = section.match(/((?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec))(\d{1,2}),?(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*\(([^)]+)\)/i);
+  if (compactDateTimeMatch) {
+    const [, month, day, hour, minutes, ampm, tz] = compactDateTimeMatch;
+    return `${month} ${day}, ${hour}${minutes ? `:${minutes}` : ''}${ampm} (${tz})`;
+  }
   // Try clean time-only pattern
   const timeOnlyMatch = section.match(/(\d{1,2}(?::\d{2})?\s*(?:am|pm))\s*\(([^)]+)\)/i);
   if (timeOnlyMatch) return `${timeOnlyMatch[1]} (${timeOnlyMatch[2]})`;
@@ -149,7 +155,7 @@ function extractResetTime(section) {
  */
 function parseUsageSection(section) {
   if (!section) return null;
-  const percentMatch = section.match(/(\d+)\s*%\s*used/i);
+  const percentMatch = section.match(/(\d+)\s*%\s*use?d/i);
   if (!percentMatch) return null;
   const resetsAt = extractResetTime(section);
   const resetData = resetsAt ? parseResetTime(resetsAt) : null;
@@ -245,21 +251,21 @@ function parsePtyOutput(clean) {
   const usage = { session: null, weeklyAll: null, weeklySonnet: null };
 
   // Parse session
-  const sessionData = parseUsageSection(extractSection(clean, 'Current\\s+session', 'Current\\s+week'));
+  const sessionData = parseUsageSection(extractSection(clean, 'Current\\s*session', 'Current\\s*week'));
   if (sessionData) {
     usage.session = { label: 'Current session', ...sessionData };
     addPaceData(usage.session, 'session');
   }
 
   // Parse weekly (all models)
-  const weeklyAllData = parseUsageSection(extractSection(clean, 'Current\\s+week\\s*\\(?\\s*all\\s+models\\s*\\)?', 'Current\\s+week\\s*\\(?\\s*Sonnet'));
+  const weeklyAllData = parseUsageSection(extractSection(clean, 'Current\\s*week\\s*\\(?\\s*all\\s*models\\s*\\)?', 'Current\\s*week\\s*\\(?\\s*Son'));
   if (weeklyAllData) {
     usage.weeklyAll = { label: 'Current week (all models)', ...weeklyAllData };
     addPaceData(usage.weeklyAll, 'weekly');
   }
 
   // Parse weekly (Sonnet only)
-  const weeklySonnetData = parseUsageSection(extractSection(clean, 'Current\\s+week\\s*\\(?\\s*Sonnet\\s+only\\s*\\)?', 'Extra\\s+usage|esc\\s+to\\s+cancel|Current\\s+week\\s*\\('));
+  const weeklySonnetData = parseUsageSection(extractSection(clean, 'Current\\s*week\\s*\\(?\\s*Son\\w*\\s*\\w*ly\\s*\\)?', 'Extra\\s*usage|esc\\s*to\\s*cancel|Current\\s*week\\s*\\('));
   if (weeklySonnetData) {
     usage.weeklySonnet = { label: 'Current week (Sonnet only)', ...weeklySonnetData };
     addPaceData(usage.weeklySonnet, 'weekly');