agent-tank 0.9.8 → 0.9.9

package/package.json

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

package/src/agents/agy.js

@@ -4,6 +4,10 @@ const { CYCLE_DURATIONS } = require('../usage-formatters.js');
 const logger = require('../logger.js');
 
 class AgyAgent extends BaseAgent {
+  // Matches both the older "Model Quota" screen and the newer grouped
+  // "Models & Quota" screen reported by recent Antigravity CLI builds.
+  static QUOTA_HEADER = /Models?\s*&?\s*Quota/i;
+
   constructor() {
     super('agy', 'agy', ['--dangerously-skip-permissions']);
     this._aboutSent = false;
@@ -128,8 +132,8 @@ class AgyAgent extends BaseAgent {
   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);
+    if (AgyAgent.QUOTA_HEADER.test(clean)) {
+      return /(?:Gemini|Claude|GPT|Weekly\s+Limit|Five[\s-]?Hour\s+Limit)[\s\S]*\d+(?:\.\d+)?\s*%/i.test(clean);
     }
     const hasModel = /(?:Gemini|Claude|GPT)[^\n]+/i.test(clean);
     const hasPercent = /\d+(?:\.\d+)?%/i.test(clean);
@@ -171,8 +175,32 @@ class AgyAgent extends BaseAgent {
       return;
     }
     logger.agent(this.name, 'Sending /usage command...');
-    setTimeout(() => shell.write('/usage'), 200);
-    setTimeout(() => shell.write('\r'), 600);
+    // A prior /usage leaves Antigravity's usage modal open. On a reused
+    // persistent process that modal swallows the next /usage (0 bytes back ->
+    // 35s timeout -> kill/respawn, which is why refreshes alternated
+    // success/timeout). Press Escape first to return to the prompt; it is a
+    // no-op at a clean prompt and safe because auth flows are guarded above.
+    setTimeout(() => shell.write('\x1b'), 200);
+    setTimeout(() => shell.write('/usage'), 600);
+    setTimeout(() => shell.write('\r'), 1000);
+  }
+
+  // Convert an ALL-CAPS Antigravity group header (e.g. "CLAUDE AND GPT") into a
+  // readable label ("Claude and GPT"), preserving known acronyms and lowercasing
+  // connective words.
+  _formatGroupName(raw) {
+    const acronyms = new Set(['GPT', 'GPU', 'AI', 'CLI', 'API', 'OSS']);
+    const connectives = new Set(['and', 'or', 'of', 'the', 'for', 'with']);
+    return raw
+      .split(/\s+/)
+      .map((word, idx) => {
+        const upper = word.toUpperCase();
+        if (acronyms.has(upper)) return upper;
+        const lower = word.toLowerCase();
+        if (idx > 0 && connectives.has(lower)) return lower;
+        return lower.charAt(0).toUpperCase() + lower.slice(1);
+      })
+      .join(' ');
   }
 
   // Calculate pace data for a model entry when reset timing is available.
@@ -201,21 +229,40 @@ class AgyAgent extends BaseAgent {
   }
 
   _parseAgyUsage(clean, usage) {
-    if (!/Model\s+Quota/i.test(clean)) return;
+    if (!AgyAgent.QUOTA_HEADER.test(clean)) return;
 
     const lines = clean.split('\n').map(line => line.trim()).filter(Boolean);
     const knownMarkers = new Set([
       'Model Quota',
+      'Models & Quota',
       'Quota available',
       '? for shortcuts',
     ]);
 
+    // Newer Antigravity builds group quotas under section headers such as
+    // "GEMINI MODELS" / "CLAUDE AND GPT MODELS", with each group reporting its
+    // own "Weekly Limit" and "Five Hour Limit". Track the active group so those
+    // generic labels can be qualified and not collapsed into a single entry.
+    let currentGroup = null;
+
     for (let i = 0; i < lines.length; i++) {
-      const modelLine = lines[i];
-      if (knownMarkers.has(modelLine) || /^(?:[>└]|[-─↑/↓]|esc\s+to\s+cancel)/i.test(modelLine)) {
+      const line = lines[i];
+
+      const groupMatch = line.match(/^([A-Z][A-Z0-9 &/-]*?)\s+MODELS$/);
+      if (groupMatch) {
+        currentGroup = this._formatGroupName(groupMatch[1].trim());
         continue;
       }
-      if (!/[A-Za-z]/.test(modelLine) || /\d+\s*%/.test(modelLine)) {
+
+      if (knownMarkers.has(line) || /^(?:[>└│]|[-─↑/↓]|esc\s+to\s+cancel)/i.test(line)) {
+        continue;
+      }
+      // Descriptive lines that are not models (e.g. "Account: ...",
+      // "Models within this group: ...").
+      if (/^(?:Account|Models within this group)\s*:/i.test(line)) {
+        continue;
+      }
+      if (!/[A-Za-z]/.test(line) || /\d+\s*%/.test(line)) {
         continue;
       }
 
@@ -232,8 +279,16 @@ class AgyAgent extends BaseAgent {
       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 };
+      // Qualify shared limit labels with their group so entries from different
+      // groups stay distinct; per-model labels are already unique on their own.
+      const isSharedLimit = /^(?:weekly|five[\s-]?hour|5[\s-]?hour|daily|hourly)\b/i.test(line);
+      const modelName = (currentGroup && isSharedLimit)
+        ? `${currentGroup} · ${line}`
+        : line;
+
+      if (!usage.models.find(m => m.model === modelName)) {
+        const modelEntry = { model: modelName, usageLeft, percentUsed, resetsIn, resetsInSeconds };
+        if (currentGroup) modelEntry.group = currentGroup;
         this._addPaceData(modelEntry, resetsInSeconds);
         usage.models.push(modelEntry);
       }

package/src/agents/base.js

@@ -5,6 +5,10 @@ const process = require('node:process');
 const logger = require('../logger.js');
 
 class BaseAgent {
+  // Grace period before escalating a runtime SIGTERM to SIGKILL for CLIs that
+  // ignore graceful termination. Overridable in tests.
+  static FORCE_KILL_GRACE_MS = 2000;
+
   constructor(name, command, args = []) {
     this.name = name;
     this.command = command;
@@ -409,22 +413,57 @@ class BaseAgent {
   }
 
   _handleAdditionalPrompts(_s, _d, _o) { } // Hook for subclasses; killProcess: see below
-  killProcess() { // Terminates the persistent PTY process
-    if (this.shell) {
-      const pidText = typeof this.shell.pid === 'number' ? ` (pid ${this.shell.pid})` : '';
-      logger.agent(this.name, `Killing persistent process${pidText}`);
-      const shell = this.shell;
-      for (const d of this._disposables) { d.dispose(); }
-      this._disposables = []; this._onDataCallback = null; this.processReady = false;
-      try {
-        // PTY-backed CLIs may spawn descendants; kill the whole process group when available.
-        if (typeof shell.pid === 'number' && shell.pid > 0) {
-          try { process.kill(-shell.pid, 'SIGTERM'); } catch (_e) { /* Group may not exist */ }
-        }
-        shell.kill();
-      } catch (_e) { /* Process may already be dead */ }
-      this.shell = null;
+  // Terminates the persistent PTY process.
+  //
+  // Some CLIs (notably `agy` and `codex`) ignore SIGTERM/SIGHUP and would
+  // otherwise survive as orphaned processes (reparented to init) every time we
+  // respawn them or the server exits. We always attempt a graceful SIGTERM
+  // first, then escalate to SIGKILL:
+  //   - runtime (default): asynchronously, after a short grace period, if the
+  //     process is still alive (the event loop is running, so the timer fires);
+  //   - immediate (shutdown): synchronously, because the process is about to
+  //     call process.exit() and pending timers would never run.
+  killProcess({ immediate = false } = {}) {
+    if (!this.shell) return;
+    const shell = this.shell;
+    const pid = (typeof shell.pid === 'number' && shell.pid > 0) ? shell.pid : null;
+    const pidText = pid != null ? ` (pid ${pid})` : '';
+    logger.agent(this.name, `Killing persistent process${pidText}`);
+    for (const d of this._disposables) { d.dispose(); }
+    this._disposables = []; this._onDataCallback = null; this.processReady = false;
+
+    this._signalProcess(pid, shell, 'SIGTERM');
+
+    if (immediate) {
+      this._signalProcess(pid, shell, 'SIGKILL');
+    } else if (pid != null) {
+      const timer = setTimeout(() => {
+        if (!this._isProcessAlive(pid)) return;
+        logger.agent(this.name, `Process ${pid} ignored SIGTERM; sending SIGKILL`);
+        this._signalProcess(pid, shell, 'SIGKILL');
+      }, BaseAgent.FORCE_KILL_GRACE_MS);
+      // Never let the escalation timer keep the process alive on its own.
+      if (typeof timer.unref === 'function') timer.unref();
     }
+
+    this.shell = null;
+  }
+
+  // Best-effort signal to a PTY process and its process group. PTY-backed CLIs
+  // may spawn descendants, so we signal the whole group when we have a pid.
+  // Never throws: the process or group may already be gone.
+  _signalProcess(pid, shell, signal) {
+    try {
+      if (pid != null) {
+        try { process.kill(-pid, signal); } catch (_e) { /* Group may not exist */ }
+      }
+      shell.kill(signal);
+    } catch (_e) { /* Process may already be dead */ }
+  }
+
+  // Returns true if the process is still alive (signal 0 probes without killing).
+  _isProcessAlive(pid) {
+    try { process.kill(pid, 0); return true; } catch (_e) { return false; }
   }
 
   async _runCommandFresh() {

package/src/agents/codex.js

@@ -347,12 +347,12 @@ class CodexAgent extends BaseAgent {
     this._rpcSupported = useRpc;
   }
 
-  killProcess() {
+  killProcess(options = {}) {
     if (this._rpcClient) {
       this._rpcClient.stop();
       this._rpcClient = null;
     }
-    super.killProcess();
+    super.killProcess(options);
   }
 
   /** Lightweight keepalive to prevent session expiration. @returns {Promise<boolean>} True if keepalive succeeded */

package/src/index.js

@@ -571,7 +571,9 @@ class AgentTank {
       if (typeof agent.requestStop === 'function') {
         agent.requestStop();
       }
-      agent.killProcess();
+      // Shutdown is followed by process.exit(), so escalate to SIGKILL
+      // synchronously — a deferred timer would never run.
+      agent.killProcess({ immediate: true });
     }
     if (this.servers.length > 0) {
       console.log('[Shutdown] Closing HTTP server');

package/src/shutdown-handler.js

@@ -1,5 +1,16 @@
+// Signals that should trigger a graceful shutdown so agent PTY processes are
+// cleaned up instead of leaking as orphans. SIGINT and SIGHUP matter for
+// detached/background runs that have no TTY (where the stdin Ctrl+C watcher
+// below does not apply). SIGKILL is intentionally absent — it cannot be caught.
+const SHUTDOWN_SIGNALS = ['SIGTERM', 'SIGINT', 'SIGHUP'];
+
 function installShutdownHandlers({ shutdown, processObj = process, stdin = process.stdin }) {
-  const onSigterm = () => shutdown('SIGTERM');
+  const signalHandlers = SHUTDOWN_SIGNALS.map(signal => {
+    const handler = () => shutdown(signal);
+    processObj.on(signal, handler);
+    return [signal, handler];
+  });
+
   const onStdinData = (chunk) => {
     const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk || ''));
     if (data.includes(0x03)) {
@@ -7,8 +18,6 @@ function installShutdownHandlers({ shutdown, processObj = process, stdin = proce
     }
   };
 
-  processObj.on('SIGTERM', onSigterm);
-
   const shouldWatchStdin = stdin && stdin.isTTY && typeof stdin.on === 'function';
   if (shouldWatchStdin) {
     stdin.on('data', onStdinData);
@@ -18,7 +27,9 @@ function installShutdownHandlers({ shutdown, processObj = process, stdin = proce
   }
 
   return () => {
-    processObj.off('SIGTERM', onSigterm);
+    for (const [signal, handler] of signalHandlers) {
+      processObj.off(signal, handler);
+    }
 
     if (shouldWatchStdin) {
       stdin.off('data', onStdinData);