agent-tank 0.9.4 → 0.9.5

package/README.md

@@ -75,7 +75,7 @@ By default it starts on:
 http://127.0.0.1:3456
 ```
 
-If Docker is running with a detectable local bridge interface, Agent Tank also binds that bridge address by default so containers on the same host can reach it without exposing it on the public interface.
+If Docker is available, Agent Tank asks Docker for the active bridge gateway addresses and binds them by default so containers on the same host can reach it without exposing it on the public interface. If Docker is unavailable, it falls back to local bridge interface detection.
 
 Use this if you want localhost only:
 
@@ -97,6 +97,9 @@ agent-tank --once --json
 
 # Show the installed Agent Tank version
 agent-tank --version
+
+# Require at least 60 seconds between refreshes for the same agent
+agent-tank --refresh-cooldown 60
 ```
 
 ## What You Get
@@ -165,6 +168,16 @@ agent-tank --no-docker
 agent-tank --auto-refresh-mode none
 ```
 
+### Slow Down Agent Refreshes
+
+By default, Agent Tank will not refresh the same agent more than once every 30 seconds, even if the refresh is triggered manually or by detected CLI activity. This reduces unnecessary polling and helps avoid CLI-side rate limiting.
+
+```bash
+agent-tank --refresh-cooldown 60
+```
+
+Set it to `0` to disable the cooldown entirely.
+
 ## Command Line Options
 
 ```text
@@ -186,6 +199,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)
+  --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)
@@ -213,6 +227,7 @@ Environment variables override CLI flags and config file values.
 | `AGENT_TANK_AUTO_REFRESH` | Enable/disable auto-refresh |
 | `AGENT_TANK_AUTO_REFRESH_MODE` | `none`, `interval`, or `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 keepalive |
 | `AGENT_TANK_KEEPALIVE_INTERVAL` | Keepalive interval in seconds |
@@ -228,10 +243,12 @@ Environment variables override CLI flags and config file values.
   "port": 8080,
   "dockerAccess": true,
   "claudeApi": false,
+  "refreshCooldown": 30,
   "autoRefresh": {
     "mode": "activity",
     "interval": 60,
-    "activityDebounce": 5000
+    "activityDebounce": 5000,
+    "refreshCooldown": 30
   },
   "keepalive": {
     "enabled": true,

package/bin/agent-tank.js

@@ -25,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 },
@@ -66,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)
@@ -91,6 +93,7 @@ Environment variables:
   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
@@ -109,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
@@ -210,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);
@@ -269,6 +283,7 @@ async function main() {
     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.4",
+  "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/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/index.js

@@ -1,5 +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');
@@ -49,7 +50,9 @@ function isPrivateIpv4(address) {
     /^172\.(1[6-9]|2\d|3[0-1])\./.test(address);
 }
 
-function detectDockerHost(networkInterfaces = os.networkInterfaces()) {
+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;
@@ -57,12 +60,55 @@ function detectDockerHost(networkInterfaces = os.networkInterfaces()) {
 
     for (const info of addresses || []) {
       if (info && info.family === 'IPv4' && !info.internal && isPrivateIpv4(info.address)) {
-        return 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 null;
+  return detectDockerHostsFromInterfaces(networkInterfaces);
 }
 
 class AgentTank {
@@ -83,6 +129,9 @@ 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.refreshCooldown = Math.max(0, options.refreshCooldown ?? 30);
+    this._agentRefreshStartedAt = new Map();
+    this._agentRefreshPromises = new Map();
     this.stopping = false;
 
     // Auto-refresh configuration (backend periodic refresh)
@@ -299,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);
             }
           })
         )
@@ -347,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) {
@@ -356,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(); }
 
@@ -447,16 +537,22 @@ class AgentTank {
     });
   }
 
-  _resolveListenHosts(detectHost = detectDockerHost) {
+  _resolveListenHosts(detectHost = detectDockerHosts) {
     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);
+      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);
+          }
+        }
       }
     }
 
@@ -500,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, detectDockerHost };
+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,
         };