agent-tank 0.9.2 → 0.9.3

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 },
@@ -17,6 +19,7 @@ const options = {
   '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' },
@@ -56,6 +59,7 @@ Options:
   --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)
@@ -127,6 +131,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) {
@@ -255,15 +265,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 +295,7 @@ async function main() {
           originalLog(JSON.stringify(agentStatus, null, 2));
         }
       }
+      cleanupShutdownHandlers();
       watcher.stop();
       process.exitCode = 0;
       return;
@@ -288,6 +303,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.3",
   "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/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/index.js

@@ -23,6 +23,24 @@ const pkg = require(path.join(__dirname, '..', 'package.json'));
  */
 const AUTO_REFRESH_MODES = ['none', 'interval', 'activity'];
 
+function describeAgentShutdown(agent) {
+  const parts = [];
+
+  if (agent.shell && typeof agent.shell.pid === 'number') {
+    parts.push(`pty pid ${agent.shell.pid}`);
+  }
+
+  if (agent._rpcClient) {
+    parts.push('json-rpc client');
+  }
+
+  if (parts.length === 0) {
+    parts.push('no active child process');
+  }
+
+  return parts.join(', ');
+}
+
 class AgentTank {
   constructor(options = {}) {
     this.port = options.port || 3456;
@@ -37,6 +55,7 @@ class AgentTank {
     this.publicStatus = {}; // Public API status from upstream providers
     this.skipServer = options.skipServer || false; // Skip HTTP server in one-shot mode
     this.lastRefreshedAt = null;
+    this.stopping = false;
 
     // Auto-refresh configuration (backend periodic refresh)
     // Determine the mode: 'none', 'interval', or 'activity' (default: 'activity')
@@ -121,6 +140,10 @@ class AgentTank {
   }
 
   async start() {
+    if (this.stopping) {
+      return;
+    }
+
     // Display startup banner with website URL, version, and copyright
     this.displayStartupBanner();
 
@@ -169,18 +192,24 @@ class AgentTank {
       await Promise.all(
         Array.from(this.agents.values()).map(agent =>
           agent.spawnProcess().catch(err =>
-            logger.error(`Error spawning ${agent.name}:`, err.message)
+            this.stopping || err.message === 'Agent stopping'
+              ? null
+              : logger.error(`Error spawning ${agent.name}:`, err.message)
           )
         )
       );
     }
 
+    if (this.stopping) {
+      return;
+    }
+
     // Initial fetch
     logger.info('📊 Fetching initial usage data...');
     await this.refreshAll();
 
     // Start backend auto-refresh if enabled (skip in one-shot mode)
-    if (!this.skipServer) {
+    if (!this.skipServer && !this.stopping) {
       this.startAutoRefresh();
       this.startKeepalive();
     }
@@ -231,6 +260,10 @@ class AgentTank {
   }
 
   async refreshAll() {
+    if (this.stopping) {
+      return;
+    }
+
     logger.info('🔄 Refreshing all agents...');
     const agentNames = Array.from(this.agents.keys());
 
@@ -240,7 +273,9 @@ class AgentTank {
       Promise.all(
         Array.from(this.agents.values()).map(agent =>
           agent.refresh().catch(err => {
-            logger.error(`Error refreshing ${agent.name}:`, err.message);
+            if (!this.stopping && err.message !== 'Agent stopping') {
+              logger.error(`Error refreshing ${agent.name}:`, err.message);
+            }
           })
         )
       ),
@@ -276,6 +311,10 @@ class AgentTank {
   }
 
   async refreshAgent(name) {
+    if (this.stopping) {
+      return;
+    }
+
     const agent = this.agents.get(name);
     if (!agent) {
       throw new Error(`Agent not found: ${name}`);
@@ -345,12 +384,19 @@ class AgentTank {
   }
 
   stop() {
+    this.stopping = true;
+    console.log('[Shutdown] Stopping Agent Tank...');
     this.stopAutoRefresh();
     this.stopKeepalive();
-    for (const agent of this.agents.values()) {
+    for (const [name, agent] of this.agents) {
+      console.log(`[Shutdown] ${name}: ${describeAgentShutdown(agent)}`);
+      if (typeof agent.requestStop === 'function') {
+        agent.requestStop();
+      }
       agent.killProcess();
     }
     if (this.server) {
+      console.log('[Shutdown] Closing HTTP server');
       this.server.close();
     }
   }

package/src/json-rpc-client.js

@@ -44,6 +44,9 @@ class JsonRpcClient extends EventEmitter {
           env: this.options.env,
           stdio: ['pipe', 'pipe', 'pipe'],
         });
+        if (typeof this.process.pid === 'number') {
+          console.log(`[JsonRpcClient] Started ${this.command} (pid ${this.process.pid})`);
+        }
 
         this.process.on('error', (err) => {
           this.isConnected = false;

package/src/shutdown-handler.js

@@ -0,0 +1,32 @@
+function installShutdownHandlers({ shutdown, processObj = process, stdin = process.stdin }) {
+  const onSigterm = () => shutdown('SIGTERM');
+  const onStdinData = (chunk) => {
+    const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk || ''));
+    if (data.includes(0x03)) {
+      shutdown('CTRL+C');
+    }
+  };
+
+  processObj.on('SIGTERM', onSigterm);
+
+  const shouldWatchStdin = stdin && stdin.isTTY && typeof stdin.on === 'function';
+  if (shouldWatchStdin) {
+    stdin.on('data', onStdinData);
+    if (typeof stdin.resume === 'function') {
+      stdin.resume();
+    }
+  }
+
+  return () => {
+    processObj.off('SIGTERM', onSigterm);
+
+    if (shouldWatchStdin) {
+      stdin.off('data', onStdinData);
+      if (typeof stdin.pause === 'function') {
+        stdin.pause();
+      }
+    }
+  };
+}
+
+module.exports = { installShutdownHandlers };