agent-tank 0.9.2 → 0.9.4

package/bin/agent-tank.js

@@ -3,6 +3,8 @@
 
 const { parseArgs } = require('node:util');
 const { AgentTank } = require('../src/index.js');
+const { installShutdownHandlers } = require('../src/shutdown-handler.js');
+const pkg = require('../package.json');
 
 const options = {
   claude: { type: 'boolean', default: false },
@@ -11,12 +13,14 @@ const options = {
   'claude-api': { type: 'boolean', default: false },
   port: { type: 'string', default: '3456' },
   host: { type: 'string' },
+  docker: { type: 'boolean', default: true },
   'auth-user': { type: 'string' },
   'auth-pass': { type: 'string' },
   'auth-token': { type: 'string' },
   'fresh-process': { type: 'boolean', default: false },
   config: { type: 'string', short: 'c' },
   help: { type: 'boolean', short: 'h', default: false },
+  version: { type: 'boolean', short: 'v', default: false },
   'auto-discover': { type: 'boolean', default: true },
   'auto-refresh': { type: 'boolean', default: true },
   'auto-refresh-interval': { type: 'string', default: '60' },
@@ -50,12 +54,14 @@ Options:
   --codex               Enable Codex monitoring
   --claude-api          Use direct Anthropic API for Claude usage (faster, 60s refresh)
   --port <port>         HTTP server port (default: 3456)
-  --host <host>         Bind address (default: 127.0.0.1)
+  --host <host>         Bind address (default: 127.0.0.1 + Docker bridge when available)
+  --docker              Enable Docker bridge bind when --host is omitted (default: true)
   --auth-user <user>    HTTP Basic Auth username
   --auth-pass <pass>    HTTP Basic Auth password
   --auth-token <token>  API key for Bearer token auth
   --fresh-process       Spawn a new process per refresh (default: false)
   --config, -c          Path to config file (JSON)
+  --version, -v         Show version
   --auto-discover       Auto-discover available agents (default: true)
   --auto-refresh        Enable/disable background auto-refresh (default: true)
   --auto-refresh-mode <mode>         Refresh mode: none, interval, activity (default: activity)
@@ -79,6 +85,7 @@ Environment variables:
   AGENT_TANK_PASS       Basic auth password (overrides --auth-pass)
   AGENT_TANK_TOKEN      API key (overrides --auth-token)
   AGENT_TANK_HOST       Bind address (overrides --host)
+  AGENT_TANK_DOCKER     Enable/disable Docker bridge bind ("1"/"true" or "0"/"false")
   AGENT_TANK_FRESH_PROCESS  Use fresh process per refresh ("1" or "true")
   AGENT_TANK_CLAUDE_API Use direct Anthropic API for Claude usage ("1" or "true")
   AGENT_TANK_AUTO_REFRESH   Enable/disable background auto-refresh ("1" or "true" / "0" or "false")
@@ -94,6 +101,7 @@ Examples:
   agent-tank --claude --gemini        # 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
   agent-tank --auth-user admin --auth-pass secret  # Enable basic auth
   agent-tank --auth-token mykey       # Enable API key auth
   agent-tank -c ./config.json         # Use config file
@@ -127,6 +135,12 @@ async function main() {
     return;
   }
 
+  if (values.version) {
+    process.stdout.write(`${pkg.version}\n`);
+    process.exitCode = 0;
+    return;
+  }
+
   // Load config file if specified
   let config = {};
   if (values.config) {
@@ -151,6 +165,13 @@ async function main() {
   };
 
   const host = process.env.AGENT_TANK_HOST || values.host || config.host;
+  const dockerEnv = process.env.AGENT_TANK_DOCKER;
+  let dockerAccess = values.docker;
+  if (dockerEnv !== undefined) {
+    dockerAccess = dockerEnv === '1' || dockerEnv === 'true';
+  } else if (config.dockerAccess !== undefined) {
+    dockerAccess = config.dockerAccess;
+  }
 
   const freshProcessEnv = process.env.AGENT_TANK_FRESH_PROCESS;
   const freshProcess = values['fresh-process'] ||
@@ -241,6 +262,7 @@ async function main() {
     autoDiscover: values['auto-discover'] && agents.length === 0,
     port: parseInt(values.port || config.port || '3456', 10),
     host,
+    dockerAccess,
     auth,
     freshProcess,
     claudeApi,
@@ -255,15 +277,19 @@ async function main() {
   });
 
   // Graceful shutdown
-  const shutdown = () => {
+  let shuttingDown = false;
+  let cleanupShutdownHandlers = () => {};
+  const shutdown = (signal) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    cleanupShutdownHandlers();
     if (!jsonMode) {
-      originalLog('\nShutting down...');
+      originalLog(`\nShutting down${signal ? ` (${signal})` : ''}...`);
     }
     watcher.stop();
-    process.exitCode = 0;
+    process.exit(0);
   };
-  process.on('SIGINT', shutdown);
-  process.on('SIGTERM', shutdown);
+  cleanupShutdownHandlers = installShutdownHandlers({ shutdown });
 
   try {
     if (onceMode) {
@@ -281,6 +307,7 @@ async function main() {
           originalLog(JSON.stringify(agentStatus, null, 2));
         }
       }
+      cleanupShutdownHandlers();
       watcher.stop();
       process.exitCode = 0;
       return;
@@ -288,6 +315,7 @@ async function main() {
 
     await watcher.start();
   } catch (err) {
+    cleanupShutdownHandlers();
     if (jsonMode) {
       console.log = originalLog;
       console.log(JSON.stringify({ error: err.message }, null, 2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-tank",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "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

@@ -1,4 +1,5 @@
 const pty = require('node-pty');
+const process = require('node:process');
 const logger = require('../logger.js');
 
 class BaseAgent {
@@ -24,6 +25,22 @@ class BaseAgent {
     this._onDataCallback = null;
     this._commandInFlight = false;
     this._disposables = [];
+    this._stopRequested = false;
+  }
+
+  _createStopError() {
+    return new Error('Agent stopping');
+  }
+
+  isStopping() {
+    return this._stopRequested;
+  }
+
+  requestStop() {
+    this._stopRequested = true;
+    this.isRefreshing = false;
+    this._commandInFlight = false;
+    this._onDataCallback = null;
   }
 
   getStatus() {
@@ -39,6 +56,11 @@ class BaseAgent {
   }
 
   async refresh() {
+    if (this.isStopping()) {
+      logger.agent(this.name, 'Skipping refresh while stopping');
+      return;
+    }
+
     if (this.isRefreshing) {
       logger.agent(this.name, 'Already refreshing, skipping...');
       return;
@@ -68,6 +90,10 @@ class BaseAgent {
         }
       }
 
+      if (this.isStopping()) {
+        throw this._createStopError();
+      }
+
       const output = await this.runCommand();
       logger.agent(this.name, 'Got output, length:', logger.dim(`${output.length} chars`));
 
@@ -108,6 +134,10 @@ class BaseAgent {
       if (hasData) { this.usage = parsed; this.lastUpdated = new Date().toISOString(); } else if (this.usage) { logger.agent(this.name, 'Parse returned no data, preserving last known usage'); this.error = 'Failed to parse — using cached data'; } else { this.usage = parsed; this.lastUpdated = new Date().toISOString(); }
       logger.agent(this.name, 'Parsed usage:', logger.json(this.usage));
     } catch (err) {
+      if (this.isStopping() && err.message === 'Agent stopping') {
+        logger.agent(this.name, 'Refresh cancelled during shutdown');
+        return;
+      }
       logger.error(`[${this.name}] Error during refresh:`, err.message);
       this.error = err.message;
     } finally {
@@ -117,6 +147,10 @@ class BaseAgent {
   }
 
   async runCommand() {
+    if (this.isStopping()) {
+      throw this._createStopError();
+    }
+
     if (this.freshProcess) {
       return this._runCommandFresh();
     }
@@ -130,6 +164,10 @@ class BaseAgent {
   }
 
   async spawnProcess() {
+    if (this.isStopping()) {
+      throw this._createStopError();
+    }
+
     return new Promise((resolve, reject) => {
       let trustHandled = false;
       let spawnOutput = '';
@@ -145,6 +183,9 @@ class BaseAgent {
           cwd: '/tmp',
           env,
         });
+        if (typeof this.shell.pid === 'number') {
+          logger.agent(this.name, 'Persistent process pid:', logger.dim(String(this.shell.pid)));
+        }
       } catch (spawnErr) {
         logger.error(`[${this.name}] Failed to spawn:`, spawnErr.message);
         reject(new Error(`Failed to spawn ${this.command}: ${spawnErr.message}`));
@@ -152,6 +193,10 @@ class BaseAgent {
       }
 
       const timer = setTimeout(() => {
+        if (this.isStopping()) {
+          reject(this._createStopError());
+          return;
+        }
         logger.error(`[${this.name}] Spawn timeout after ${this.getTimeout()}ms`);
         this.killProcess();
         reject(new Error('Timeout waiting for process to become ready'));
@@ -159,6 +204,15 @@ class BaseAgent {
 
       let trustCooldownUntil = 0;
       const spawnDataHandler = this.shell.onData((data) => {
+        if (this.isStopping()) {
+          clearTimeout(timer);
+          spawnDataHandler.dispose();
+          spawnExitHandler.dispose();
+          this.killProcess();
+          reject(this._createStopError());
+          return;
+        }
+
         spawnOutput += data;
 
         // Handle trust/update prompts during spawn (only once each)
@@ -202,12 +256,20 @@ class BaseAgent {
         spawnExitHandler.dispose();
         this.shell = null;
         this.processReady = false;
+        if (this.isStopping()) {
+          reject(this._createStopError());
+          return;
+        }
         reject(new Error(`Process exited during spawn with code ${exitCode}`));
       });
     });
   }
 
   async sendCommandAndWait() {
+    if (this.isStopping()) {
+      throw this._createStopError();
+    }
+
     return new Promise((resolve, reject) => {
       const existingOutput = this.output;
       const existingAuthState = this.detectAuthenticationState ? this.detectAuthenticationState(existingOutput) : null;
@@ -228,6 +290,12 @@ class BaseAgent {
       };
 
       const timer = setTimeout(() => {
+        if (this.isStopping()) {
+          this._commandInFlight = false;
+          this._onDataCallback = null;
+          reject(this._createStopError());
+          return;
+        }
         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)));
@@ -245,6 +313,13 @@ class BaseAgent {
       }, this.getTimeout());
 
       this._onDataCallback = () => {
+        if (this.isStopping()) {
+          this._commandInFlight = false;
+          this._onDataCallback = null;
+          clearTimeout(timer);
+          reject(this._createStopError());
+          return;
+        }
         if (this.hasCompleteOutput(this.output)) {
           logger.agent(this.name, 'Complete output detected');
           // Small delay to capture any remaining output
@@ -298,15 +373,27 @@ class BaseAgent {
   _handleAdditionalPrompts(_s, _d, _o) { } // Hook for subclasses; killProcess: see below
   killProcess() { // Terminates the persistent PTY process
     if (this.shell) {
-      logger.agent(this.name, 'Killing persistent process');
+      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 { this.shell.kill(); } catch (_e) { /* Process may already be dead */ }
+      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;
     }
   }
 
   async _runCommandFresh() {
+    if (this.isStopping()) {
+      throw this._createStopError();
+    }
+
     return new Promise((resolve, reject) => {
       const timeout = this.getTimeout();
       let output = '';
@@ -334,6 +421,12 @@ class BaseAgent {
 
       const timer = setTimeout(() => {
         if (!completed) {
+          if (this.isStopping()) {
+            completed = true;
+            shell.kill();
+            reject(this._createStopError());
+            return;
+          }
           completed = true;
           logger.agent(this.name, 'Timeout after', logger.dim(`${timeout}ms`), ', output length:', logger.dim(`${output.length}`));
           if (output.length > 0) {
@@ -352,6 +445,16 @@ class BaseAgent {
 
       let trustCooldownUntil = 0;
       shell.onData((data) => {
+        if (this.isStopping()) {
+          if (!completed) {
+            completed = true;
+            clearTimeout(timer);
+            shell.kill();
+            reject(this._createStopError());
+          }
+          return;
+        }
+
         output += data;
 
         if (output.length <= data.length) {
@@ -395,6 +498,10 @@ class BaseAgent {
         if (!completed) {
           completed = true;
           clearTimeout(timer);
+          if (this.isStopping()) {
+            reject(this._createStopError());
+            return;
+          }
           logger.agent(this.name, 'Process exited with code', logger.dim(exitCode), ', output length:', logger.dim(`${output.length}`));
           if (output) {
             resolve(output);
@@ -414,6 +521,7 @@ class BaseAgent {
 
   /** Lightweight keepalive method to prevent session expiration. Subclasses can override. @returns {Promise<boolean>} True if keepalive succeeded */
   async keepalive() {
+    if (this.isStopping()) { return false; }
     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...`); this.shell.write('\x1b'); return true; }

package/src/agents/claude.js

@@ -204,43 +204,25 @@ class ClaudeAgent extends BaseAgent {
     const clean = this.stripAnsi(output);
     // Detect error responses (rate limiting, session errors) — treat as complete
     if (/rate.?limited|rate_limit_error|Failed to load usage|session.?expired|session.?error|invalid.?session|authentication.?error|auth.?failed|Unable to (?:load|fetch)|Error loading|could not (?:load|fetch)|not authenticated|login required|sign.?in required/i.test(clean)) return true;
-    // Basic requirements - must have actual usage data, not just the loading screen
-    const hasSession = clean.includes('Current session');
-    const hasWeekly = clean.includes('Current week');
-    const hasPercentUsed = clean.includes('% used');
-    if (!hasSession || !hasWeekly || !hasPercentUsed) return false;
-
-    // If "all models" section exists, wait for "Sonnet only" section to render
-    const hasAllModels = /Current\s+week\s*\(?\s*all\s+models/i.test(clean);
-    if (hasAllModels) {
-      const hasSonnetOnly = /Current\s+week\s*\(?\s*Sonnet\s+only/i.test(clean);
-      if (!hasSonnetOnly) {
-        return false;
-      }
-      // Both sections exist, check we have at least one timezone per section
-      const allModelsIdx = clean.search(/Current\s+week\s*\(?\s*all\s+models/i);
-      const sonnetOnlyIdx = clean.search(/Current\s+week\s*\(?\s*Sonnet\s+only/i);
-      const allModelsSection = clean.substring(allModelsIdx, sonnetOnlyIdx);
-      const sonnetSection = clean.substring(sonnetOnlyIdx);
-
-      const allModelsHasTimezone = /\([A-Za-z]+\/[A-Za-z_]+\)/.test(allModelsSection);
-      const sonnetHasTimezone = /\([A-Za-z]+\/[A-Za-z_]+\)/.test(sonnetSection);
+    const parsed = parsePtyOutput(clean);
 
-      return allModelsHasTimezone && sonnetHasTimezone;
-    }
+    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';
 
-    // Fallback for legacy format (single "Current week" without model qualifiers)
-    // Check for timezone pattern which indicates reset times are fully loaded
-    const hasTimezone = /\([A-Za-z]+\/[A-Za-z_]+\)/.test(clean);
-    return hasTimezone;
+    // 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);
   }
 
   sendCommands(shell, _output) {
     logger.agent(this.name, 'Sending /usage command...');
-    // Escape dismisses any previous output/UI, then type command + Enter
+    // 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);
   }
 
   // After getting /usage output, dismiss dialog so next refresh starts with clean prompt

package/src/agents/codex.js

@@ -156,6 +156,9 @@ class CodexAgent extends BaseAgent {
           cwd: '/tmp',
           env: { ...process.env, TERM: 'xterm-256color' },
         });
+        if (typeof this.shell.pid === 'number') {
+          logger.agent(this.name, 'Persistent process pid:', logger.dim(String(this.shell.pid)));
+        }
       } catch (spawnErr) {
         logger.error(`[${this.name}] Failed to spawn:`, spawnErr.message);
         reject(new Error(`Failed to spawn ${this.command}: ${spawnErr.message}`));

package/src/client-auto-refresh.js

@@ -87,8 +87,8 @@ ${metricExtractors}
       if (modelContainer) {
         const resetWrapper = modelContainer.querySelector('.reset-info-wrapper');
         if (resetWrapper) {
-          if (isZero || !resetsIn) {
-            // Hide "Resets in" when at 0%
+          if (!resetsIn) {
+            // Hide reset info only when the backend provides no reset time
             resetWrapper.style.display = 'none';
           } else {
             resetWrapper.style.display = '';