agent-tank 0.9.5 → 0.9.7

package/README.md

@@ -7,7 +7,7 @@ Agent Tank is a local dashboard and HTTP API for monitoring usage limits in AI c
 It supports:
 
 - Claude Code
-- Gemini CLI
+- Antigravity CLI
 - OpenAI Codex
 
 ## How It Gets the Data
@@ -17,7 +17,7 @@ This is the part that matters.
 Agent Tank reads usage directly from the local CLI tools you already use. It launches the installed CLIs locally, runs their built-in usage commands, and parses the output into a unified web UI and JSON API.
 
 - Claude: runs `/usage`
-- Gemini: runs `/stats`
+- Antigravity: runs `/usage`
 - Codex: prefers JSON-RPC `account/rateLimits/read`, falls back to `/status`
 
 What it does not do:
@@ -37,7 +37,7 @@ Agent Tank is meant for subscription-based coding agent products where the CLI i
 Examples:
 
 - Claude Code Pro / Max
-- Gemini CLI with supported subscription plans
+- Antigravity CLI with supported subscription plans
 - ChatGPT Codex with supported plans
 
 It is not for:
@@ -87,7 +87,7 @@ agent-tank --no-docker
 
 ```bash
 # Monitor only specific agents
-agent-tank --claude --gemini
+agent-tank --claude --agy
 
 # Use a custom port
 agent-tank --port 8080
@@ -127,7 +127,7 @@ agent-tank --refresh-cooldown 60
 | Agent | Method | Metrics |
 |---|---|---|
 | Claude | PTY `/usage` or Anthropic OAuth API | Current session, weekly all-models, weekly Sonnet-only |
-| Gemini | PTY `/stats` | Per-model usage and reset windows |
+| Antigravity | PTY `/usage` | Per-model quota availability and reset windows when reported |
 | Codex | JSON-RPC preferred, PTY fallback | 5-hour limits, weekly limits, model/account info |
 
 ## Basic Usage
@@ -183,7 +183,7 @@ Set it to `0` to disable the cooldown entirely.
 ```text
 Options:
   --claude              Enable Claude monitoring
-  --gemini              Enable Gemini monitoring
+  --agy                 Enable Antigravity monitoring
   --codex               Enable Codex monitoring
   --port <port>         HTTP server port (default: 3456)
   --host <host>         Bind address (default: 127.0.0.1 + Docker bridge when available)
@@ -238,7 +238,7 @@ Environment variables override CLI flags and config file values.
 ```json
 {
   "claude": true,
-  "gemini": true,
+  "agy": true,
   "codex": false,
   "port": 8080,
   "dockerAccess": true,
@@ -266,6 +266,19 @@ Run with:
 agent-tank -c config.json
 ```
 
+## Antigravity
+
+Antigravity support uses the `agy` CLI and reads the interactive `/usage` output.
+
+In `--once` mode, Agent Tank prints the result and exits immediately after the output is flushed.
+
+Examples:
+
+```bash
+agent-tank --agy
+agent-tank --agy --once --json
+```
+
 ## HTTP API
 
 ### Endpoints
@@ -393,7 +406,7 @@ In activity mode, Agent Tank watches common local directories:
 
 - Claude: `~/.config/claude/projects/`, `~/.claude/`
 - Codex: `~/.codex/sessions/`, `~/.codex/`
-- Gemini: `~/.config/gemini/`, `~/.gemini/`
+- Antigravity: `~/.gemini/antigravity-cli/`
 
 If no suitable directories are found, it falls back to interval mode.
 
@@ -481,15 +494,15 @@ You need at least one supported CLI installed and authenticated.
 
 - [Claude Code](https://claude.ai/download) as `claude`
   - Version 2.0+ required for `/usage`
-- Gemini CLI as `gemini`
-  - Version 0.24.5+ required for `/stats`
+- Antigravity CLI as `agy`
+  - `/usage` command support required
 - OpenAI Codex as `codex`
 
 Useful checks:
 
 ```bash
 claude --version
-gemini --version
+agy --version
 codex --version
 ```
 
@@ -499,7 +512,7 @@ codex --version
 const { AgentTank } = require('agent-tank');
 
 const watcher = new AgentTank({
-  agents: ['claude', 'gemini'],
+  agents: ['claude', 'agy'],
   port: 3456,
   autoDiscover: true
 });

package/bin/agent-tank.js

@@ -8,7 +8,7 @@ const pkg = require('../package.json');
 
 const options = {
   claude: { type: 'boolean', default: false },
-  gemini: { type: 'boolean', default: false },
+  agy: { type: 'boolean', default: false },
   codex: { type: 'boolean', default: false },
   'claude-api': { type: 'boolean', default: false },
   port: { type: 'string', default: '3456' },
@@ -43,6 +43,17 @@ function exitWithCode(code, message, stream = process.stderr) {
   process.exitCode = code;
 }
 
+function writeAndExit(stream, text, exitCode, { cleanup, watcher, jsonMode, originalLog }) {
+  stream.write(text, () => {
+    cleanup();
+    watcher.stop();
+    if (jsonMode) {
+      console.log = originalLog;
+    }
+    process.exit(exitCode);
+  });
+}
+
 function printHelp() {
   process.stdout.write(`
 agent-tank - Monitor LLM CLI usage limits
@@ -51,7 +62,7 @@ Usage: agent-tank [options]
 
 Options:
   --claude              Enable Claude monitoring
-  --gemini              Enable Gemini monitoring
+  --agy                 Enable Antigravity monitoring
   --codex               Enable Codex monitoring
   --claude-api          Use direct Anthropic API for Claude usage (faster, 60s refresh)
   --port <port>         HTTP server port (default: 3456)
@@ -101,7 +112,7 @@ Environment variables:
 
 Examples:
   agent-tank                          # Auto-discover and monitor all available
-  agent-tank --claude --gemini        # Monitor specific agents
+  agent-tank --claude --agy           # Monitor specific agents
   agent-tank --port 8080              # Use custom port
   agent-tank --host 0.0.0.0           # Expose on all interfaces
   agent-tank --no-docker              # Bind localhost only when host is omitted
@@ -159,7 +170,7 @@ async function main() {
   // Merge CLI options with config (env vars > CLI flags > config file)
   const agents = [];
   if (values.claude || config.claude) agents.push('claude');
-  if (values.gemini || config.gemini) agents.push('gemini');
+  if (values.agy || config.agy) agents.push('agy');
   if (values.codex || config.codex) agents.push('codex');
 
   const auth = {
@@ -311,21 +322,28 @@ async function main() {
       await watcher.start();
       const status = watcher.getStatus();
       if (jsonMode) {
-        // Restore console.log for JSON output
-        console.log = originalLog;
-        console.log(JSON.stringify(status, null, 2));
-        // Suppress console.log again before stopping to avoid extra shutdown output
-        console.log = () => {};
+        const output = `${JSON.stringify(status, null, 2)}\n`;
+        writeAndExit(process.stdout, output, 0, {
+          cleanup: cleanupShutdownHandlers,
+          watcher,
+          jsonMode,
+          originalLog,
+        });
+        return;
       } else {
+        let output = '';
         for (const [name, agentStatus] of Object.entries(status)) {
-          originalLog(`\n=== ${name.toUpperCase()} ===`);
-          originalLog(JSON.stringify(agentStatus, null, 2));
+          output += `\n=== ${name.toUpperCase()} ===\n`;
+          output += `${JSON.stringify(agentStatus, null, 2)}\n`;
         }
+        writeAndExit(process.stdout, output, 0, {
+          cleanup: cleanupShutdownHandlers,
+          watcher,
+          jsonMode,
+          originalLog,
+        });
+        return;
       }
-      cleanupShutdownHandlers();
-      watcher.stop();
-      process.exitCode = 0;
-      return;
     }
 
     await watcher.start();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-tank",
-  "version": "0.9.5",
-  "description": "Monitor and query usage limits for LLM CLI tools (Claude, Gemini, Codex) via HTTP API",
+  "version": "0.9.7",
+  "description": "Monitor and query usage limits for LLM CLI tools (Claude, Antigravity, Codex) via HTTP API",
   "main": "src/index.js",
   "bin": {
     "agent-tank": "bin/agent-tank.js"
@@ -19,7 +19,8 @@
   "keywords": [
     "llm",
     "claude",
-    "gemini",
+    "antigravity",
+    "agy",
     "codex",
     "openai",
     "anthropic",
@@ -42,6 +43,7 @@
   },
   "homepage": "https://agenttank.io",
   "dependencies": {
+    "chokidar": "^3.6.0",
     "node-pty": "^1.0.0",
     "source-map-support": "^0.5.21"
   },

package/src/activity-monitor.js

@@ -1,7 +1,7 @@
 /**
  * ActivityMonitor - Monitors local log directories for LLM CLI activity
  *
- * Watches known log directories for Claude, Codex, and Gemini using fs.watch.
+ * Watches known log directories for Claude, Codex, and Antigravity using chokidar with polling.
  * When activity is detected (new log entries), it triggers usage refresh callbacks
  * with configurable debouncing to prevent excessive polling.
  */
@@ -9,6 +9,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const os = require('node:os');
+const chokidar = require('chokidar');
 
 /**
  * Default log directories for each agent.
@@ -23,9 +24,8 @@ const DEFAULT_LOG_DIRECTORIES = {
     path.join(os.homedir(), '.codex', 'sessions'),
     path.join(os.homedir(), '.codex'),
   ],
-  gemini: [
-    path.join(os.homedir(), '.config', 'gemini'),
-    path.join(os.homedir(), '.gemini'),
+  agy: [
+    path.join(os.homedir(), '.gemini', 'antigravity-cli'),
   ],
 };
 
@@ -72,7 +72,7 @@ class ActivityMonitor {
 
   /**
    * Start monitoring log directories for activity.
-   * Sets up fs.watch on each agent's log directories.
+   * Sets up chokidar polling watchers on each agent's log directories.
    *
    * @returns {Object} Status object with monitoring details
    */
@@ -92,7 +92,18 @@ class ActivityMonitor {
       for (const dir of dirs) {
         if (fs.existsSync(dir)) {
           try {
-            const watcher = fs.watch(dir, { recursive: true }, (eventType, filename) => {
+            // Use chokidar with polling to avoid EMFILE errors from too many native watchers
+            const watcher = chokidar.watch(dir, {
+              persistent: true,
+              ignoreInitial: true,
+              usePolling: true,
+              interval: 1000,
+              depth: 99,
+              ignored: ['**/.git/**', '**/*.lock'],
+            });
+
+            watcher.on('all', (eventType, filepath) => {
+              const filename = path.relative(dir, filepath);
               this._handleFileChange(agent, eventType, filename);
             });
 
@@ -158,7 +169,7 @@ class ActivityMonitor {
   }
 
   /**
-   * Handle a file change event from fs.watch.
+   * Handle a file change event from chokidar.
    * Debounces activity detection per agent.
    *
    * @param {string} agent - Agent name

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

@@ -231,6 +231,10 @@ class BaseAgent {
           clearTimeout(timer);
           spawnDataHandler.dispose();
           spawnExitHandler.dispose();
+          if (!this.shell) {
+            reject(new Error('Process exited during spawn before handlers were attached'));
+            return;
+          }
           this.processReady = true;
           this.output = spawnOutput;
           this._setupPersistentDataHandler();
@@ -243,6 +247,11 @@ class BaseAgent {
           logger.agent(this.name, 'Process ready for commands');
           clearTimeout(timer);
           spawnDataHandler.dispose();
+          spawnExitHandler.dispose();
+          if (!this.shell) {
+            reject(new Error('Process exited during spawn before handlers were attached'));
+            return;
+          }
           this.processReady = true;
           this._setupPersistentDataHandler();
           this._setupPersistentExitHandler();
@@ -334,11 +343,15 @@ class BaseAgent {
   }
 
   _setupPersistentDataHandler() {
+    if (!this.shell) {
+      logger.agent(this.name, 'Skipping persistent data handler setup: shell already exited');
+      return;
+    }
     const handler = this.shell.onData((data) => {
       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) {
@@ -356,6 +369,10 @@ class BaseAgent {
   }
 
   _setupPersistentExitHandler() {
+    if (!this.shell) {
+      logger.agent(this.name, 'Skipping persistent exit handler setup: shell already exited');
+      return;
+    }
     const handler = this.shell.onExit(({ exitCode }) => {
       logger.agent(this.name, 'Persistent process exited with code', logger.dim(exitCode));
       this.shell = null; this.processReady = false; this._onDataCallback = null; this._disposables = [];