agent-tank 0.9.3 → 0.9.5

package/bin/agent-tank.js

@@ -13,6 +13,7 @@ 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' },
@@ -24,6 +25,7 @@ const options = {
   'auto-refresh': { type: 'boolean', default: true },
   'auto-refresh-interval': { type: 'string', default: '60' },
   'auto-refresh-mode': { type: 'string', default: 'activity' },
+  'refresh-cooldown': { type: 'string', default: '30' },
   'activity-debounce': { type: 'string', default: '5000' },
   'history-retention-days': { type: 'string', default: '14' },
   'keepalive': { type: 'boolean', default: true },
@@ -53,7 +55,8 @@ 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
@@ -64,6 +67,7 @@ Options:
   --auto-refresh        Enable/disable background auto-refresh (default: true)
   --auto-refresh-mode <mode>         Refresh mode: none, interval, activity (default: activity)
   --auto-refresh-interval <seconds>  Auto-refresh interval in seconds (default: 60, 0 = disabled)
+  --refresh-cooldown <seconds>       Minimum time between refreshes per agent (default: 30, 0 = disabled)
   --activity-debounce <ms>           Activity debounce interval in milliseconds (default: 5000)
   --keepalive           Enable/disable session keepalive (default: true)
   --keepalive-interval <seconds>     Session keepalive interval in seconds (default: 300, 0 = disabled)
@@ -83,11 +87,13 @@ 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")
   AGENT_TANK_AUTO_REFRESH_MODE      Refresh mode: none, interval, activity
   AGENT_TANK_AUTO_REFRESH_INTERVAL  Auto-refresh interval in seconds
+  AGENT_TANK_REFRESH_COOLDOWN       Minimum time between refreshes per agent in seconds
   AGENT_TANK_ACTIVITY_DEBOUNCE      Activity debounce interval in milliseconds
   AGENT_TANK_KEEPALIVE      Enable/disable session keepalive ("1" or "true" / "0" or "false")
   AGENT_TANK_KEEPALIVE_INTERVAL  Session keepalive interval in seconds
@@ -98,6 +104,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
@@ -105,6 +112,7 @@ Examples:
   agent-tank --auto-refresh-mode activity  # Use activity-based polling (default)
   agent-tank --activity-debounce 10000     # Wait 10 seconds after activity before refresh
   agent-tank --auto-refresh-interval 30  # Refresh every 30 seconds
+  agent-tank --refresh-cooldown 45     # Limit each agent to one refresh every 45 seconds
   agent-tank --no-auto-refresh        # Disable background auto-refresh
   agent-tank --keepalive-interval 600 # Send keepalive every 10 minutes
   agent-tank --no-keepalive           # Disable session keepalive
@@ -161,6 +169,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'] ||
@@ -199,6 +214,16 @@ async function main() {
     autoRefreshMode = config.autoRefresh.mode;
   }
 
+  const refreshCooldownEnv = process.env.AGENT_TANK_REFRESH_COOLDOWN;
+  let refreshCooldown = parseInt(values['refresh-cooldown'], 10);
+  if (refreshCooldownEnv !== undefined) {
+    refreshCooldown = parseInt(refreshCooldownEnv, 10);
+  } else if (config.refreshCooldown !== undefined) {
+    refreshCooldown = config.refreshCooldown;
+  } else if (config.autoRefresh?.refreshCooldown !== undefined) {
+    refreshCooldown = config.autoRefresh.refreshCooldown;
+  }
+
   // Activity debounce configuration (env > CLI > config file)
   const activityDebounceEnv = process.env.AGENT_TANK_ACTIVITY_DEBOUNCE;
   let activityDebounce = parseInt(values['activity-debounce'], 10);
@@ -251,12 +276,14 @@ async function main() {
     autoDiscover: values['auto-discover'] && agents.length === 0,
     port: parseInt(values.port || config.port || '3456', 10),
     host,
+    dockerAccess,
     auth,
     freshProcess,
     claudeApi,
     autoRefreshEnabled: onceMode ? false : autoRefreshEnabled, // Disable auto-refresh in one-shot mode
     autoRefreshInterval,
     autoRefreshMode: onceMode ? 'none' : autoRefreshMode, // Disable auto-refresh in one-shot mode
+    refreshCooldown,
     activityDebounce,
     keepaliveEnabled: onceMode ? false : keepaliveEnabled, // Disable keepalive in one-shot mode
     keepaliveInterval,

package/package.json

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

@@ -329,7 +329,7 @@ class BaseAgent {
 
       // Process is already at prompt, send commands immediately
       logger.agent(this.name, 'Sending commands to persistent process...');
-      this.sendCommands(this.shell, this.output);
+      this.sendCommands(this.shell, existingOutput);
     });
   }
 

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

@@ -23,32 +23,36 @@ class GeminiAgent extends BaseAgent {
     };
   }
 
+  _hasReadyPrompt(output) {
+    const clean = this.stripAnsi(output);
+    return clean.includes('Type your message')
+      || clean.includes('gemini>')
+      || /Ready\s*\(/.test(clean);
+  }
+
   isReadyForCommands(output) {
     // Don't consider ready if authentication is in progress
     if (this._isAuthenticating(output)) {
       return false;
     }
-    // v0.24: "Type your message" prompt
-    // v0.35+: "Ready" in terminal title + visible prompt area (no "Type your message")
-    // Also check for terminal title sequence containing "Ready"
-    return output.includes('Type your message')
-      || output.includes('gemini>')
-      || /Ready\s*\(/.test(output);
+    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)
+      || /press esc.*to cancel/i.test(clean)
+      || /authenticating\.\.\./i.test(clean);
 
-    // If we see the ready prompt, auth is complete (even if auth text still in buffer)
-    if (clean.includes('Type your message') || clean.includes('? for shortcuts')) {
+    if (!hasAuthFlow) {
       return false;
     }
 
-    // Only consider authenticating if we see auth-specific text
-    return /waiting for authentication/i.test(clean)
-      || /press esc.*to cancel/i.test(clean)
-      || /authenticating\.\.\./i.test(clean);
+    // Newer Gemini builds can render footer hints like "? for shortcuts"
+    // before the actual input prompt is available. Treat auth as complete
+    // only when the real prompt has returned.
+    return !this._hasReadyPrompt(clean);
   }
 
   detectAuthenticationState(output) {
@@ -159,12 +163,10 @@ class GeminiAgent extends BaseAgent {
       return;
     }
     logger.agent(this.name, 'Sending /stats command...');
-    // v0.35+: typing /stats triggers autocomplete dropdown.
-    // Escape clears any pending state, then send command, Escape again to dismiss autocomplete
-    setTimeout(() => shell.write('\x1b'), 50);
-    setTimeout(() => shell.write('/stats'), 500);
-    setTimeout(() => shell.write('\x1b'), 1000);
-    setTimeout(() => shell.write('\r'), 1500);
+    // Newer Gemini builds use Esc for "rewind", which can derail the command flow.
+    // Submit /stats directly once the prompt is ready.
+    setTimeout(() => shell.write('/stats'), 200);
+    setTimeout(() => shell.write('\r'), 600);
   }
 
   // Calculate pace data for a model entry (Gemini uses 24h sessions)

package/src/auto-refresh-manager.js

@@ -230,12 +230,11 @@ class AutoRefreshManager {
       console.log(`Backend auto-refresh [${globalAgents.join(', ')}]: every ${globalInterval}s (interval mode)`);
       this.autoRefreshTimer = setInterval(async () => {
         console.log(`[Auto-refresh] Refreshing ${globalAgents.join(', ')}...`);
-        const promises = globalAgents.map(name => {
-          const agent = this.agents.get(name);
-          return agent ? agent.refresh().catch(err =>
+        const promises = globalAgents.map(name =>
+          this.onRefreshAgent(name).catch(err =>
             console.error(`Error refreshing ${name}:`, err.message)
-          ) : Promise.resolve();
-        });
+          )
+        );
         await Promise.all(promises);
         this.lastRefreshedAt = new Date().toISOString();
       }, globalInterval * 1000);

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 = '';

package/src/index.js

@@ -1,4 +1,6 @@
 const path = require('node:path');
+const os = require('node:os');
+const { execFileSync } = require('node:child_process');
 const { ClaudeAgent } = require('./agents/claude.js');
 const { GeminiAgent } = require('./agents/gemini.js');
 const { CodexAgent } = require('./agents/codex.js');
@@ -22,6 +24,7 @@ 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 = [];
@@ -41,10 +44,79 @@ function describeAgentShutdown(agent) {
   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 detectDockerHostsFromInterfaces(networkInterfaces = os.networkInterfaces()) {
+  const hosts = [];
+
+  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)) {
+        if (!hosts.includes(info.address)) {
+          hosts.push(info.address);
+        }
+      }
+    }
+  }
+
+  return hosts.length > 0 ? hosts : null;
+}
+
+function detectDockerHosts({
+  exec = execFileSync,
+  networkInterfaces = os.networkInterfaces(),
+} = {}) {
+  try {
+    const listOutput = exec('docker', ['network', 'ls', '--format', '{{json .}}'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const networks = listOutput
+      .split('\n')
+      .map(line => line.trim())
+      .filter(Boolean)
+      .map(line => JSON.parse(line))
+      .filter(network => network && network.Driver === 'bridge');
+
+    const hosts = [];
+    for (const network of networks) {
+      const inspectOutput = exec('docker', ['network', 'inspect', network.ID, '--format', '{{json .IPAM.Config}}'], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }).trim();
+
+      const ipamConfigs = inspectOutput ? JSON.parse(inspectOutput) : [];
+      for (const config of ipamConfigs || []) {
+        if (config && config.Gateway && isPrivateIpv4(config.Gateway) && !hosts.includes(config.Gateway)) {
+          hosts.push(config.Gateway);
+        }
+      }
+    }
+
+    if (hosts.length > 0) {
+      return hosts;
+    }
+  } catch (_err) {
+    // Fall back to interface detection when Docker is unavailable.
+  }
+
+  return detectDockerHostsFromInterfaces(networkInterfaces);
+}
+
 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;
@@ -52,9 +124,14 @@ 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.refreshCooldown = Math.max(0, options.refreshCooldown ?? 30);
+    this._agentRefreshStartedAt = new Map();
+    this._agentRefreshPromises = new Map();
     this.stopping = false;
 
     // Auto-refresh configuration (backend periodic refresh)
@@ -183,7 +260,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
@@ -271,10 +348,10 @@ class AgentTank {
     const [, publicStatusResult] = await Promise.all([
       // Agent PTY refreshes
       Promise.all(
-        Array.from(this.agents.values()).map(agent =>
-          agent.refresh().catch(err => {
+        Array.from(this.agents.keys()).map(name =>
+          this._refreshAgentWithCooldown(name).catch(err => {
             if (!this.stopping && err.message !== 'Agent stopping') {
-              logger.error(`Error refreshing ${agent.name}:`, err.message);
+              logger.error(`Error refreshing ${name}:`, err.message);
             }
           })
         )
@@ -319,7 +396,7 @@ class AgentTank {
     if (!agent) {
       throw new Error(`Agent not found: ${name}`);
     }
-    await agent.refresh();
+    await this._refreshAgentWithCooldown(name);
 
     // Record snapshot and attach pace evaluation for single agent refresh
     if (agent.usage) {
@@ -328,6 +405,47 @@ class AgentTank {
     }
   }
 
+  _getRefreshCooldownRemainingMs(name, now = Date.now()) {
+    if (this.refreshCooldown <= 0) {
+      return 0;
+    }
+
+    const lastStartedAt = this._agentRefreshStartedAt.get(name);
+    if (!lastStartedAt) {
+      return 0;
+    }
+
+    return Math.max(0, (this.refreshCooldown * 1000) - (now - lastStartedAt));
+  }
+
+  async _refreshAgentWithCooldown(name) {
+    const agent = this.agents.get(name);
+    if (!agent) {
+      throw new Error(`Agent not found: ${name}`);
+    }
+
+    const activeRefresh = this._agentRefreshPromises.get(name);
+    if (activeRefresh) {
+      logger.agent(name, 'Refresh already in progress, reusing existing refresh');
+      return activeRefresh;
+    }
+
+    const remainingMs = this._getRefreshCooldownRemainingMs(name);
+    if (remainingMs > 0) {
+      logger.agent(name, `Refresh cooldown active, skipping (${Math.ceil(remainingMs / 1000)}s remaining)`);
+      return;
+    }
+
+    this._agentRefreshStartedAt.set(name, Date.now());
+    const refreshPromise = agent.refresh().finally(() => {
+      if (this._agentRefreshPromises.get(name) === refreshPromise) {
+        this._agentRefreshPromises.delete(name);
+      }
+    });
+    this._agentRefreshPromises.set(name, refreshPromise);
+    return refreshPromise;
+  }
+
   /** Get usage history statistics. @returns {Object} */
   getHistoryStats() { return this.historyStore.getStats(); }
 
@@ -377,12 +495,70 @@ 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 = detectDockerHosts) {
+    if (this.explicitHost) {
+      return [this.host];
+    }
+
+    const hosts = ['127.0.0.1'];
+    if (this.dockerAccess) {
+      const dockerHosts = detectHost();
+      if (dockerHosts) {
+        // Handle both single IP (legacy) and array of IPs
+        const hostList = Array.isArray(dockerHosts) ? dockerHosts : [dockerHosts];
+        for (const h of hostList) {
+          if (h && h !== '127.0.0.1' && !hosts.includes(h)) {
+            hosts.push(h);
+          }
+        }
+      }
+    }
+
+    return hosts;
+  }
+
   stop() {
     this.stopping = true;
     console.log('[Shutdown] Stopping Agent Tank...');
@@ -395,10 +571,15 @@ class AgentTank {
       }
       agent.killProcess();
     }
-    if (this.server) {
+    if (this.servers.length > 0) {
       console.log('[Shutdown] Closing HTTP server');
-      this.server.close();
+      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 */
@@ -415,8 +596,15 @@ class AgentTank {
 
   /** Get the auto-refresh configuration. @returns {Object} */
   getAutoRefreshConfig() {
-    return { mode: this.autoRefresh.mode, enabled: this.autoRefresh.enabled, interval: this.autoRefresh.interval, activityDebounce: this.autoRefresh.activityDebounce, lastRefreshedAt: this.autoRefreshManager ? this.autoRefreshManager.getLastRefreshedAt() : null };
+    return {
+      mode: this.autoRefresh.mode,
+      enabled: this.autoRefresh.enabled,
+      interval: this.autoRefresh.interval,
+      activityDebounce: this.autoRefresh.activityDebounce,
+      refreshCooldown: this.refreshCooldown,
+      lastRefreshedAt: this.autoRefreshManager ? this.autoRefreshManager.getLastRefreshedAt() : null
+    };
   }
 }
 
-module.exports = { AgentTank, AUTO_REFRESH_MODES };
+module.exports = { AgentTank, AUTO_REFRESH_MODES, detectDockerHosts, detectDockerHostsFromInterfaces };

package/src/server.js

@@ -52,6 +52,7 @@ function createRequestHandler(tank) {
           autoRefresh: {
             enabled: tank.autoRefresh.enabled && tank.autoRefresh.interval > 0,
             interval: tank.autoRefresh.interval, // in seconds
+            refreshCooldown: tank.refreshCooldown,
           },
           lastRefreshedAt: tank.lastRefreshedAt,
         };
@@ -135,9 +136,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/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