agent-tank 0.9.0

package/src/agents/api-response-parser.js

@@ -0,0 +1,255 @@
+/**
+ * API Response Parser for Claude Agent
+ * Handles parsing of direct Anthropic API responses into the unified usage schema
+ */
+
+const { calculatePace } = require('../pace-evaluator.js');
+const { CYCLE_DURATIONS } = require('../usage-formatters.js');
+
+/**
+ * Format duration from seconds to readable text
+ * @param {number} diffSeconds - Duration in seconds
+ * @returns {string} Formatted duration string
+ */
+function formatDuration(diffSeconds) {
+  const mins = Math.floor(diffSeconds / 60);
+  const hours = Math.floor(mins / 60);
+  const m = mins % 60;
+  if (hours > 24) {
+    return `${Math.floor(hours / 24)}d ${hours % 24}h`;
+  }
+  return hours > 0 ? `${hours}h ${m}m` : `${m}m`;
+}
+
+/**
+ * Calculate reset time info from an ISO timestamp
+ * @param {string|null} isoTimestamp - ISO format timestamp
+ * @param {Date} now - Current date/time
+ * @returns {Object} Reset time information
+ */
+function parseResetTimestamp(isoTimestamp, now) {
+  if (!isoTimestamp) {
+    return { resetsAt: null, resetsIn: null, resetsInSeconds: null };
+  }
+  const resetDate = new Date(isoTimestamp);
+  const diffMs = resetDate - now;
+  if (diffMs <= 0) {
+    return { resetsAt: isoTimestamp, resetsIn: 'soon', resetsInSeconds: 0 };
+  }
+  const diffSeconds = Math.floor(diffMs / 1000);
+  return {
+    resetsAt: isoTimestamp,
+    resetsIn: formatDuration(diffSeconds),
+    resetsInSeconds: diffSeconds,
+  };
+}
+
+/**
+ * Add pace data to a usage section
+ * @param {Object|null} sectionData - Usage section data
+ * @param {string} cycleType - Type of cycle ('session' or 'weekly')
+ * @returns {Object|null} Section data with pace info added
+ */
+function addPaceData(sectionData, cycleType) {
+  if (!sectionData || sectionData.resetsInSeconds == null) return sectionData;
+  const cycleDuration = CYCLE_DURATIONS[cycleType];
+  if (!cycleDuration) return sectionData;
+  const paceData = calculatePace({
+    usagePercent: sectionData.percent ?? 0,
+    resetsInSeconds: sectionData.resetsInSeconds,
+    cycleDurationSeconds: cycleDuration,
+  });
+  if (paceData) sectionData.pace = paceData;
+  return sectionData;
+}
+
+/**
+ * Parse session limit from API response
+ * @param {Object} apiResponse - Raw API response
+ * @param {Date} now - Current date/time
+ * @returns {Object|null} Parsed session data
+ */
+function parseSessionLimit(apiResponse, now) {
+  if (!apiResponse.sessionLimit) return null;
+
+  const sl = apiResponse.sessionLimit;
+  const percent = sl.percentUsed ?? (sl.used && sl.limit ? Math.round((sl.used / sl.limit) * 100) : null);
+
+  if (percent === null) return null;
+
+  const resetInfo = parseResetTimestamp(sl.resetsAt, now);
+  const session = { label: 'Current session', percent, ...resetInfo };
+  return addPaceData(session, 'session');
+}
+
+/**
+ * Parse weekly all models limit from API response
+ * @param {Object} apiResponse - Raw API response
+ * @param {Date} now - Current date/time
+ * @returns {Object|null} Parsed weekly all models data
+ */
+function parseWeeklyAllModels(apiResponse, now) {
+  const wl = apiResponse.weeklyAllModels || apiResponse.weeklyLimit;
+  if (!wl) return null;
+
+  const percent = wl.percentUsed ?? (wl.used && wl.limit ? Math.round((wl.used / wl.limit) * 100) : null);
+
+  if (percent === null) return null;
+
+  const resetInfo = parseResetTimestamp(wl.resetsAt, now);
+  const weeklyAll = { label: 'Current week (all models)', percent, ...resetInfo };
+  return addPaceData(weeklyAll, 'weekly');
+}
+
+/**
+ * Parse weekly Sonnet only limit from API response
+ * @param {Object} apiResponse - Raw API response
+ * @param {Date} now - Current date/time
+ * @returns {Object|null} Parsed weekly Sonnet data
+ */
+function parseWeeklySonnet(apiResponse, now) {
+  const ws = apiResponse.weeklySonnet || apiResponse.weeklySonnetOnly;
+  if (!ws) return null;
+
+  const percent = ws.percentUsed ?? (ws.used && ws.limit ? Math.round((ws.used / ws.limit) * 100) : null);
+
+  if (percent === null) return null;
+
+  const resetInfo = parseResetTimestamp(ws.resetsAt, now);
+  const weeklySonnet = { label: 'Current week (Sonnet only)', percent, ...resetInfo };
+  return addPaceData(weeklySonnet, 'weekly');
+}
+
+/**
+ * Parse extra usage from API response
+ * @param {Object} apiResponse - Raw API response
+ * @param {Date} now - Current date/time
+ * @returns {Object|null} Parsed extra usage data
+ */
+function parseExtraUsage(apiResponse, now) {
+  if (!apiResponse.extraUsage) return null;
+
+  const eu = apiResponse.extraUsage;
+  const percent = eu.percentUsed ?? (eu.spent && eu.budget ? Math.round((eu.spent / eu.budget) * 100) : null);
+  const resetInfo = parseResetTimestamp(eu.resetsAt, now);
+
+  const extraUsage = {
+    label: 'Extra usage',
+    percent,
+    spent: eu.spent ?? null,
+    budget: eu.budget ?? null,
+    ...resetInfo,
+  };
+  return addPaceData(extraUsage, 'weekly');
+}
+
+/**
+ * Parse flat percentage fields from API response
+ * @param {Object} apiResponse - Raw API response
+ * @param {Object} usage - Current usage object to augment
+ * @param {Date} now - Current date/time
+ * @returns {Object} Updated usage object
+ */
+function parseFlatPercentageFields(apiResponse, usage, now) {
+  if (!usage.session && apiResponse.sessionPercent !== undefined) {
+    const session = {
+      label: 'Current session',
+      percent: apiResponse.sessionPercent,
+      ...parseResetTimestamp(apiResponse.sessionResetsAt, now),
+    };
+    usage.session = addPaceData(session, 'session');
+  }
+
+  if (!usage.weeklyAll && apiResponse.weeklyPercent !== undefined) {
+    const weeklyAll = {
+      label: 'Current week (all models)',
+      percent: apiResponse.weeklyPercent,
+      ...parseResetTimestamp(apiResponse.weeklyResetsAt, now),
+    };
+    usage.weeklyAll = addPaceData(weeklyAll, 'weekly');
+  }
+
+  return usage;
+}
+
+/**
+ * Normalize the OAuth usage API response to the parser's expected schema.
+ * The API returns: five_hour, seven_day, seven_day_sonnet, extra_usage
+ * The parser expects: sessionLimit, weeklyAllModels, weeklySonnet, extraUsage
+ * @param {Object} raw - Raw API response
+ * @returns {Object} Normalized response
+ */
+function normalizeOAuthResponse(raw) {
+  if (!raw.five_hour && !raw.seven_day) return raw; // already normalized or unknown
+  const norm = {};
+  if (raw.five_hour) {
+    norm.sessionLimit = {
+      percentUsed: Math.round(raw.five_hour.utilization),
+      resetsAt: raw.five_hour.resets_at,
+    };
+  }
+  if (raw.seven_day) {
+    norm.weeklyAllModels = {
+      percentUsed: Math.round(raw.seven_day.utilization),
+      resetsAt: raw.seven_day.resets_at,
+    };
+  }
+  if (raw.seven_day_sonnet) {
+    norm.weeklySonnet = {
+      percentUsed: Math.round(raw.seven_day_sonnet.utilization),
+      resetsAt: raw.seven_day_sonnet.resets_at,
+    };
+  }
+  if (raw.extra_usage?.is_enabled) {
+    norm.extraUsage = {
+      percentUsed: Math.round(raw.extra_usage.utilization),
+      spent: raw.extra_usage.used_credits != null
+        ? Math.round(raw.extra_usage.used_credits) / 100 : null,
+      budget: raw.extra_usage.monthly_limit != null
+        ? Math.round(raw.extra_usage.monthly_limit) / 100 : null,
+      resetsAt: raw.seven_day?.resets_at || null,
+    };
+  }
+  return norm;
+}
+
+/**
+ * Parse the direct API response into the unified usage schema
+ * @param {Object} apiResponse - The raw API response from Anthropic
+ * @returns {Object} The parsed usage object matching the PTY format
+ */
+function parseApiResponse(apiResponse) {
+  const usage = { session: null, weeklyAll: null, weeklySonnet: null };
+
+  if (!apiResponse) return usage;
+
+  // Handle nested usage object format
+  if (apiResponse.usage) {
+    return parseApiResponse(apiResponse.usage);
+  }
+
+  // Normalize OAuth API response format to parser schema
+  const normalized = normalizeOAuthResponse(apiResponse);
+
+  const now = new Date();
+
+  // Parse each section
+  usage.session = parseSessionLimit(normalized, now);
+  usage.weeklyAll = parseWeeklyAllModels(normalized, now);
+  usage.weeklySonnet = parseWeeklySonnet(normalized, now);
+
+  const extraUsage = parseExtraUsage(normalized, now);
+  if (extraUsage) {
+    usage.extraUsage = extraUsage;
+  }
+
+  // Handle flat percentage fields as fallback
+  return parseFlatPercentageFields(normalized, usage, now);
+}
+
+module.exports = {
+  parseApiResponse,
+  formatDuration,
+  parseResetTimestamp,
+  addPaceData,
+};

package/src/agents/base.js

@@ -0,0 +1,396 @@
+const pty = require('node-pty');
+const logger = require('../logger.js');
+
+class BaseAgent {
+  constructor(name, command, args = []) {
+    this.name = name;
+    this.command = command;
+    this.args = args;
+    this.usage = null;
+    this.metadata = null;
+    this._metadataFetched = false;
+    this.lastUpdated = null;
+    this.error = null;
+    this.isRefreshing = false;
+    this.refreshInterval = null;    // Per-agent override (seconds), null = use global
+    this.minRefreshInterval = null; // Per-agent minimum (seconds), null = no minimum
+
+    // Persistent process state
+    this.shell = null;
+    this.processReady = false;
+    this.output = '';
+    this.freshProcess = false;
+    this._onDataCallback = null;
+    this._commandInFlight = false;
+    this._disposables = [];
+  }
+
+  getStatus() {
+    return {
+      name: this.name,
+      usage: this.usage,
+      metadata: this.metadata,
+      lastUpdated: this.lastUpdated,
+      error: this.error,
+      isRefreshing: this.isRefreshing,
+    };
+  }
+
+  async refresh() {
+    if (this.isRefreshing) {
+      logger.agent(this.name, 'Already refreshing, skipping...');
+      return;
+    }
+
+    logger.agent(this.name, 'Starting refresh...');
+    this.isRefreshing = true;
+    this.error = null;
+
+    try {
+      // Fetch metadata once on first refresh (if agent supports it)
+      if (!this._metadataFetched && this.fetchMetadata) {
+        try {
+          logger.agent(this.name, 'Fetching metadata (first refresh)...');
+          this.metadata = await this.fetchMetadata();
+          logger.agent(this.name, 'Parsed metadata:', logger.json(this.metadata));
+        } catch (metaErr) {
+          logger.error(`[${this.name}] Error fetching metadata:`, metaErr.message);
+          // Continue with usage fetch even if metadata fails
+        }
+        this._metadataFetched = true;
+        // In fresh process mode, kill the persistent process spawned for metadata
+        // so that runCommand() starts cleanly with _runCommandFresh()
+        if (this.freshProcess) {
+          this.killProcess();
+        }
+      }
+
+      const output = await this.runCommand();
+      logger.agent(this.name, 'Got output, length:', logger.dim(`${output.length} chars`));
+
+      // Check for rate limit and session errors before parsing
+      // Match actual error messages, not incidental mentions like "rate limits and credits"
+      const cleanOutput = this.stripAnsi(output);
+      if (/rate.?limited|rate_limit_error/i.test(cleanOutput)) {
+        logger.agent(this.name, 'Rate limited, preserving last known usage data');
+        this.error = 'Rate limited — using cached data';
+        this.lastUpdated = new Date().toISOString();
+        // Don't overwrite this.usage — keep the last known good data
+        return;
+      }
+
+      // Check for session/auth errors — preserve cached data if available
+      const sessionErrorMatch = cleanOutput.match(/session.?expired|session.?error|invalid.?session|authentication.?error|auth.?failed|Unable to (?:load|fetch)|Error loading|could not (?:load|fetch)|Failed to load usage|not authenticated|login required|sign.?in required/i);
+      if (sessionErrorMatch) {
+        const errorMsg = sessionErrorMatch[0];
+        logger.agent(this.name, 'Session error detected:', logger.dim(errorMsg));
+        this.error = this.usage ? `Session error — using cached data` : `Session error: ${errorMsg}`;
+        this.lastUpdated = new Date().toISOString();
+        return;
+      }
+
+      const parsed = this.parseOutput(output);
+
+      // Only update usage if we got meaningful data (not all-null)
+      const hasData = parsed && Object.values(parsed).some(v => v !== null && v !== undefined && (typeof v !== 'object' || (Array.isArray(v) ? v.length > 0 : Object.keys(v).length > 0)));
+      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) {
+      logger.error(`[${this.name}] Error during refresh:`, err.message);
+      this.error = err.message;
+    } finally {
+      this.isRefreshing = false;
+      logger.agent(this.name, 'Refresh complete');
+    }
+  }
+
+  async runCommand() {
+    if (this.freshProcess) {
+      return this._runCommandFresh();
+    }
+
+    // Persistent mode: spawn if needed, then send command
+    if (!this.shell || !this.processReady) {
+      await this.spawnProcess();
+    }
+
+    return this.sendCommandAndWait();
+  }
+
+  async spawnProcess() {
+    return new Promise((resolve, reject) => {
+      let trustHandled = false;
+      let spawnOutput = '';
+
+      logger.agent(this.name, 'Spawning persistent process:', logger.dim(`${this.command} ${this.args.join(' ')}`));
+
+      try {
+        const env = this.getEnv ? this.getEnv() : { ...process.env, TERM: 'xterm-256color' };
+        this.shell = pty.spawn(this.command, this.args, {
+          name: 'xterm-color',
+          cols: 120,
+          rows: 40,
+          cwd: '/tmp',
+          env,
+        });
+      } catch (spawnErr) {
+        logger.error(`[${this.name}] Failed to spawn:`, spawnErr.message);
+        reject(new Error(`Failed to spawn ${this.command}: ${spawnErr.message}`));
+        return;
+      }
+
+      const timer = setTimeout(() => {
+        logger.error(`[${this.name}] Spawn timeout after ${this.getTimeout()}ms`);
+        this.killProcess();
+        reject(new Error('Timeout waiting for process to become ready'));
+      }, this.getTimeout());
+
+      let trustCooldownUntil = 0;
+      const spawnDataHandler = this.shell.onData((data) => {
+        spawnOutput += data;
+
+        // Handle trust/update prompts during spawn (only once each)
+        if (!trustHandled && this.handleTrustPrompt && this.handleTrustPrompt(this.shell, spawnOutput)) {
+          trustHandled = true;
+          spawnOutput = '';
+          trustCooldownUntil = Date.now() + 4000;
+          return;
+        }
+        this._handleAdditionalPrompts(this.shell, data, spawnOutput);
+        this._respondToTerminalQueries(data);
+
+        if (Date.now() >= trustCooldownUntil && this.isReadyForCommands(spawnOutput)) {
+          logger.agent(this.name, 'Process ready for commands');
+          clearTimeout(timer);
+          spawnDataHandler.dispose();
+          this.processReady = true;
+          this._setupPersistentDataHandler();
+          this._setupPersistentExitHandler();
+          resolve();
+        }
+      });
+
+      const spawnExitHandler = this.shell.onExit(({ exitCode }) => {
+        clearTimeout(timer);
+        spawnDataHandler.dispose();
+        spawnExitHandler.dispose();
+        this.shell = null;
+        this.processReady = false;
+        reject(new Error(`Process exited during spawn with code ${exitCode}`));
+      });
+    });
+  }
+
+  async sendCommandAndWait() {
+    return new Promise((resolve, reject) => {
+      this.output = '';
+      this._commandInFlight = true;
+
+      const finish = (result) => {
+        this._commandInFlight = false;
+        this._onDataCallback = null;
+        clearTimeout(timer);
+        resolve(result);
+      };
+
+      const timer = setTimeout(() => {
+        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)));
+          require('fs').writeFileSync(`/tmp/${this.name}-output.txt`, this.output);
+        }
+        // Kill the stuck process so it respawns fresh on the next refresh
+        logger.agent(this.name, 'Killing stuck process to force respawn');
+        const partialOutput = this.output;
+        this.killProcess();
+        if (partialOutput.length > 100) {
+          resolve(partialOutput);
+        } else {
+          reject(new Error('Timeout waiting for usage data'));
+        }
+      }, this.getTimeout());
+
+      this._onDataCallback = () => {
+        if (this.hasCompleteOutput(this.output)) {
+          logger.agent(this.name, 'Complete output detected');
+          // Small delay to capture any remaining output
+          setTimeout(() => finish(this.output), 100);
+        }
+      };
+
+      // Process is already at prompt, send commands immediately
+      logger.agent(this.name, 'Sending commands to persistent process...');
+      this.sendCommands(this.shell, this.output);
+    });
+  }
+
+  _setupPersistentDataHandler() {
+    const handler = this.shell.onData((data) => {
+      this.output += data;
+
+      // Always respond to terminal queries — suppressing them causes deadlocks
+      // when CLIs (e.g. Gemini) wait for cursor position responses before
+      // rendering output. Delay slightly during command-in-flight to avoid
+      // interleaving with command text being sent via setTimeout.
+      if (this._commandInFlight) {
+        setTimeout(() => this._respondToTerminalQueries(data), 50);
+      } else {
+        this._respondToTerminalQueries(data);
+      }
+
+      // Invoke command waiter callback if set
+      if (this._onDataCallback) {
+        this._onDataCallback(data);
+      }
+    });
+    this._disposables.push(handler);
+  }
+
+  _setupPersistentExitHandler() {
+    const handler = this.shell.onExit(({ exitCode }) => {
+      logger.agent(this.name, 'Persistent process exited with code', logger.dim(exitCode));
+      this.shell = null; this.processReady = false; this._onDataCallback = null; this._disposables = [];
+    });
+    this._disposables.push(handler);
+  }
+
+  _respondToTerminalQueries(data, target) {
+    const sh = target || this.shell; if (!sh) return;
+    if (data.includes('\x1b[6n')) sh.write('\x1b[1;1R'); if (data.includes('\x1b[c')) sh.write('\x1b[?62;22c'); if (data.includes('\x1b[?u')) sh.write('\x1b[?0u');
+    if (data.includes('\x1b]10;?')) sh.write('\x1b]10;rgb:ffff/ffff/ffff\x1b\\'); if (data.includes('\x1b]11;?')) sh.write('\x1b]11;rgb:0000/0000/0000\x1b\\');
+    if (data.includes('\x1b[>q')) sh.write('\x1bP>|xterm(1)\x1b\\'); if (data.includes('\x1b[>4;?m')) sh.write('\x1b[>4m');
+  }
+
+  _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');
+      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 */ }
+      this.shell = null;
+    }
+  }
+
+  async _runCommandFresh() {
+    return new Promise((resolve, reject) => {
+      const timeout = this.getTimeout();
+      let output = '';
+      let completed = false;
+      let commandsSent = false;
+      let trustHandled = false;
+
+      logger.agent(this.name, 'Spawning:', logger.dim(`${this.command} ${this.args.join(' ')}`));
+
+      let shell;
+      try {
+        const env = this.getEnv ? this.getEnv() : { ...process.env, TERM: 'xterm-256color' };
+        shell = pty.spawn(this.command, this.args, {
+          name: 'xterm-color',
+          cols: 120,
+          rows: 40,
+          cwd: '/tmp',
+          env,
+        });
+      } catch (spawnErr) {
+        logger.error(`[${this.name}] Failed to spawn:`, spawnErr.message);
+        reject(new Error(`Failed to spawn ${this.command}: ${spawnErr.message}`));
+        return;
+      }
+
+      const timer = setTimeout(() => {
+        if (!completed) {
+          completed = true;
+          logger.agent(this.name, 'Timeout after', logger.dim(`${timeout}ms`), ', output length:', logger.dim(`${output.length}`));
+          if (output.length > 0) {
+            logger.agent(this.name, 'Partial output:', logger.dim(this.stripAnsi(output).substring(0, 500)));
+            require('fs').writeFileSync(`/tmp/${this.name}-output.txt`, output);
+            logger.agent(this.name, 'Full output written to', logger.dim(`/tmp/${this.name}-output.txt`));
+          }
+          shell.kill();
+          if (output.length > 100) {
+            resolve(output);
+          } else {
+            reject(new Error('Timeout waiting for usage data'));
+          }
+        }
+      }, timeout);
+
+      let trustCooldownUntil = 0;
+      shell.onData((data) => {
+        output += data;
+
+        if (output.length <= data.length) {
+          logger.agent(this.name, 'First data received', logger.dim(`(${data.length} chars)`));
+          if (data.length < 200) {
+            logger.agent(this.name, 'Initial output:', logger.dim(this.stripAnsi(data).substring(0, 100)));
+          }
+        }
+
+        if (!trustHandled && this.handleTrustPrompt && this.handleTrustPrompt(shell, output)) {
+          trustHandled = true;
+          output = '';
+          trustCooldownUntil = Date.now() + 4000;
+          return;
+        }
+
+        this._respondToTerminalQueries(data, shell);
+        this._handleAdditionalPrompts(shell, data, output);
+
+        if (Date.now() >= trustCooldownUntil && !commandsSent && this.isReadyForCommands(output)) {
+          logger.agent(this.name, 'Ready for commands, sending...');
+          commandsSent = true;
+          this.sendCommands(shell, output);
+        }
+
+        // Check if we have enough data to extract usage
+        if (commandsSent && this.hasCompleteOutput(output)) {
+          logger.agent(this.name, 'Complete output detected, finishing...');
+          setTimeout(() => {
+            if (!completed) {
+              completed = true;
+              clearTimeout(timer);
+              shell.kill();
+              resolve(output);
+            }
+          }, 300);
+        }
+      });
+
+      shell.onExit(({ exitCode }) => {
+        if (!completed) {
+          completed = true;
+          clearTimeout(timer);
+          logger.agent(this.name, 'Process exited with code', logger.dim(exitCode), ', output length:', logger.dim(`${output.length}`));
+          if (output) {
+            resolve(output);
+          } else {
+            reject(new Error(`Process exited with code ${exitCode}`));
+          }
+        }
+      });
+    });
+  }
+
+  getTimeout() { return 30000; }
+  isReadyForCommands(_o) { return false; }
+  hasCompleteOutput(_o) { return false; }
+  sendCommands(_s, _o) { }
+  parseOutput(_o) { return null; }
+
+  /** Lightweight keepalive method to prevent session expiration. Subclasses can override. @returns {Promise<boolean>} True if keepalive succeeded */
+  async keepalive() {
+    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; }
+    return false;
+  }
+  /* eslint-disable no-control-regex */
+  static ANSI_CURSOR_RIGHT = /\x1B\[(\d+)C/g; static ANSI_ESCAPE_SEQ = /\x1B\[[0-9;?]*[a-zA-Z]/g;
+  static ANSI_OSC_SEQ = /\x1B\][^\x07\x1B]*(?:\x07|\x1B\\)/g; static ANSI_DCS_SEQ = /\x1BP[^\x1B]*\x1B\\/g;
+  static ANSI_CHARSET = /\x1B[()#][A-Za-z0-9]/g; static ANSI_TWOCHAR = /\x1B[=>DMEH78cNOZn\\|}{~]/g;
+  static ANSI_LEFTOVER = /\x1B/g; static MULTI_SPACE = /  +/g; /* eslint-enable no-control-regex */
+  stripAnsi(str) { return str.replace(BaseAgent.ANSI_CURSOR_RIGHT, (_, n) => ' '.repeat(parseInt(n))).replace(BaseAgent.ANSI_ESCAPE_SEQ, '').replace(BaseAgent.ANSI_OSC_SEQ, '').replace(BaseAgent.ANSI_DCS_SEQ, '').replace(BaseAgent.ANSI_CHARSET, '').replace(BaseAgent.ANSI_TWOCHAR, '').replace(BaseAgent.ANSI_LEFTOVER, '').replace(/\r/g, '').replace(BaseAgent.MULTI_SPACE, ' '); }
+  stripBoxChars(str) { return str ? str.replace(/[│╭╮╯╰─┌┐└┘├┤┬┴┼║═╔╗╚╝╠╣╦╩╬]/g, '').trim() : str; }
+}
+module.exports = { BaseAgent };