agent-tank 0.9.2 → 0.9.4

package/src/index.js

@@ -1,4 +1,5 @@
 const path = require('node:path');
+const os = require('node:os');
 const { ClaudeAgent } = require('./agents/claude.js');
 const { GeminiAgent } = require('./agents/gemini.js');
 const { CodexAgent } = require('./agents/codex.js');
@@ -22,11 +23,54 @@ const pkg = require(path.join(__dirname, '..', 'package.json'));
  * - 'activity': Activity-based polling (refreshes when log activity is detected)
  */
 const AUTO_REFRESH_MODES = ['none', 'interval', 'activity'];
+const DOCKER_INTERFACE_PATTERNS = [/^docker\d*$/i, /^br-/i, /^podman\d*$/i];
+
+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(', ');
+}
+
+function isPrivateIpv4(address) {
+  return /^10\./.test(address) ||
+    /^192\.168\./.test(address) ||
+    /^172\.(1[6-9]|2\d|3[0-1])\./.test(address);
+}
+
+function detectDockerHost(networkInterfaces = os.networkInterfaces()) {
+  for (const [name, addresses] of Object.entries(networkInterfaces)) {
+    if (!DOCKER_INTERFACE_PATTERNS.some(pattern => pattern.test(name))) {
+      continue;
+    }
+
+    for (const info of addresses || []) {
+      if (info && info.family === 'IPv4' && !info.internal && isPrivateIpv4(info.address)) {
+        return info.address;
+      }
+    }
+  }
+
+  return null;
+}
 
 class AgentTank {
   constructor(options = {}) {
     this.port = options.port || 3456;
     this.host = options.host || '127.0.0.1';
+    this.explicitHost = !!options.host;
+    this.dockerAccess = options.dockerAccess !== false;
     this.autoDiscover = options.autoDiscover !== false;
     this.requestedAgents = options.agents || null;
     this.freshProcess = options.freshProcess || false;
@@ -34,9 +78,12 @@ class AgentTank {
     this.auth = options.auth || {};
     this.agents = new Map();
     this.server = null;
+    this.servers = [];
+    this.listenHosts = [];
     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 +168,10 @@ class AgentTank {
   }
 
   async start() {
+    if (this.stopping) {
+      return;
+    }
+
     // Display startup banner with website URL, version, and copyright
     this.displayStartupBanner();
 
@@ -160,7 +211,7 @@ class AgentTank {
 
     // Start HTTP server immediately so it's available during agent loading (unless skipped)
     if (!this.skipServer) {
-      this.startServer();
+      await this.startServer();
     }
 
     // Pre-spawn persistent processes in parallel before sending commands
@@ -169,18 +220,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 +288,10 @@ class AgentTank {
   }
 
   async refreshAll() {
+    if (this.stopping) {
+      return;
+    }
+
     logger.info('🔄 Refreshing all agents...');
     const agentNames = Array.from(this.agents.keys());
 
@@ -240,7 +301,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 +339,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}`);
@@ -338,21 +405,85 @@ class AgentTank {
   }
 
   startServer() {
-    this.server = createServer(this);
-    this.server.listen(this.port, this.host, () => {
+    const hosts = this._resolveListenHosts();
+
+    return Promise.all(hosts.map(async (host, index) => {
+      const server = createServer(this);
+      try {
+        await new Promise((resolve, reject) => {
+          const onError = (err) => {
+            server.off('listening', onListening);
+            reject(err);
+          };
+          const onListening = () => {
+            server.off('error', onError);
+            resolve();
+          };
+          server.once('error', onError);
+          server.once('listening', onListening);
+          server.listen(this.port, host);
+        });
+        this.servers.push(server);
+        this.listenHosts.push(host);
+      } catch (err) {
+        try {
+          server.close();
+        } catch (_closeErr) {
+          // Ignore cleanup errors for failed listeners
+        }
+
+        if (index === 0) {
+          throw err;
+        }
+
+        logger.warn(`Could not bind optional host ${host}:${this.port} (${err.message})`);
+      }
+    })).then(() => {
+      this.server = this.servers[0] || null;
+      if (this.listenHosts.length > 0) {
+        this.host = this.listenHosts[0];
+      }
       displayServerBanner(this);
     });
   }
 
+  _resolveListenHosts(detectHost = detectDockerHost) {
+    if (this.explicitHost) {
+      return [this.host];
+    }
+
+    const hosts = ['127.0.0.1'];
+    if (this.dockerAccess) {
+      const dockerHost = detectHost();
+      if (dockerHost && dockerHost !== '127.0.0.1') {
+        hosts.push(dockerHost);
+      }
+    }
+
+    return hosts;
+  }
+
   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) {
-      this.server.close();
+    if (this.servers.length > 0) {
+      console.log('[Shutdown] Closing HTTP server');
+      for (const server of this.servers) {
+        server.close();
+      }
     }
+    this.server = null;
+    this.servers = [];
+    this.listenHosts = [];
   }
 
   /** Get keepalive status. @returns {Object|null} Keepalive manager status or null if not initialized */
@@ -373,4 +504,4 @@ class AgentTank {
   }
 }
 
-module.exports = { AgentTank, AUTO_REFRESH_MODES };
+module.exports = { AgentTank, AUTO_REFRESH_MODES, detectDockerHost };

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/server.js

@@ -135,9 +135,12 @@ function displayServerBanner(tank) {
   if (tank.auth.token) {
     logger.info('🔑 Authentication: API key');
   }
-  logger.server(`Listening on: ${tank.host}:${tank.port}`);
-  logger.server(`📄 Status page: http://${tank.host}:${tank.port}/`);
-  logger.server(`📡 JSON API:    http://${tank.host}:${tank.port}/status`);
+  const listenHosts = tank.listenHosts && tank.listenHosts.length > 0 ? tank.listenHosts : [tank.host];
+  logger.server(`Listening on: ${listenHosts.map(host => `${host}:${tank.port}`).join(', ')}`);
+  for (const host of listenHosts) {
+    logger.server(`📄 Status page: http://${host}:${tank.port}`);
+    logger.server(`📡 JSON API:    http://${host}:${tank.port}/status`);
+  }
   console.log('');
 }
 

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 };

package/src/usage-formatters.js

@@ -49,10 +49,10 @@ function getStatusDotClass(value) {
 }
 
 function resetInfoItem(resetsIn, originalValue, cycleType, options = {}) {
-  const { isZero = false, paceData = null } = options;
+  const { paceData = null } = options;
   // Always render the wrapper so XHR updates can show/hide it dynamically.
-  // Hidden when at 0% (no useful info when at full capacity).
-  const hidden = isZero ? ' style="display:none"' : '';
+  // Hidden only when there is no reset information to show.
+  const hidden = resetsIn ? '' : ' style="display:none"';
   const tooltip = originalValue ? ` title="${originalValue}"` : '';
 
   // Calculate elapsed time progress bar