agent-fuel 0.4.0 → 0.4.2

package/README.md

@@ -86,12 +86,12 @@ type UsageSnapshot = {
 ```
 ⚡️ Agent Fuel - CLI Quota Monitor
 
-Claude Code   [███████████████████░░░░░░░░░░░]  64% remaining (resets 01:00 PM)
-Codex         [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░]   0% remaining (resets in 4h 33m)
-AGY Gemini    [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░]   0% remaining (resets in 3h 16m) [Gemini 3.5 Flash (Medium)]
-AGY Other     [██████████████████░░░░░░░░░░░░]  60% remaining (resets in 4h 47m) [Claude Sonnet 4.6 (Thinking)]
+Claude Code   [██████████████████████░░░░░░░░]  72% remaining (resets 23:10 (Europe/Copenhagen))
+Codex         [█████████████████████░░░░░░░░░]  69% remaining (resets 23:37)
+AGY Gemini    [██████████████████████████████] 100% remaining ✓ quota available [Gemini 3.5 Flash (Medium)]
+AGY Other     [████████████░░░░░░░░░░░░░░░░░░]  40% remaining (resets in 122h 53m) [Claude Sonnet 4.6 (Thinking)]
 
-agent-fuel v0.3.0
+agent-fuel v0.x.y
 ```
 
 Rows appear as each adapter resolves — Claude Code (instant) prints first, Codex and AGY follow as their TUI scrapes complete.
@@ -111,18 +111,3 @@ Rows appear as each adapter resolves — Claude Code (instant) prints first, Cod
 
 > **Note on `AGENT_FUEL_CODEX_BUDGET`:** Codex quota is read directly from the Codex TUI via `expect` scraping. This variable is only used as a rough fallback estimate (shown as `[~est]`) when the TUI reports no quota warning and a percentage cannot be determined. It is a guess based on local session cost data — not an official Codex quota signal. The TUI scrape is always preferred.
 
----
-
-## 📦 Changelog
-
-### v0.3.0
-- **Codex TUI scrape**: replaced inaccurate `ccusage` cost estimate with an `expect` wrapper that reads the real Codex quota warning (`"Individual quota reached. Resets in Xh Ym"`) — same pattern as AGY. `ccusage` kept as a labelled `[~est]` fallback when quota has not yet been exhausted.
-- **Streaming render with fixed order**: placeholder rows print immediately; each bar overwrites in-place as its adapter resolves. Row order is always `Claude Code → Codex → AGY Gemini → AGY Other`.
-- **AGY split view**: Gemini and non-Gemini (Claude, etc.) quota buckets shown as separate rows
-- **5-minute disk cache** for AGY quota — repeated runs complete in ~1s instead of ~20s
-- Output size cap, typed `any` removal, env validation hardening
-
-### v0.2.x
-- AGY quota now scraped live from `agy /usage` panel via `expect` wrapper (zero token cost)
-- Claude Code budget corrected to $20 rolling limit
-- Replaced token-consuming `claude -p` calls with offline `ccusage` scraping

package/dist/adapters/agy.js

@@ -1,13 +1,11 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
-import { TuiScraper } from '../tmux.js';
+import { TuiScraper, sleep } from '../tmux.js';
+import { debug } from '../debug.js';
 const CACHE_PATH = path.join(os.homedir(), '.gemini/antigravity-cli/.agent-fuel-quota-cache.json');
 const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
 // ── Scraping ───────────────────────────────────────────────────────────────
-async function sleep(ms) {
-    return new Promise(res => setTimeout(res, ms));
-}
 /**
  * Launches `agy` in a tmux session, opens the `/usage` panel, waits for
  * the Model Quota list to render, then returns clean rendered screen text.
@@ -16,8 +14,16 @@ async function runAgyUsage() {
     const tui = new TuiScraper('agy');
     try {
         tui.start();
-        // Wait for AGY main menu ready
-        await tui.waitFor(/for shortcuts/, 20_000);
+        // Wait for AGY main menu ready.
+        // On first run in a new directory, AGY shows a "Do you trust this project?"
+        // prompt. The "Yes, I trust this folder" option is pre-selected; press Enter.
+        const firstScreen = await tui.waitFor(/for shortcuts|Do you trust/i, 20_000);
+        if (!/for shortcuts/i.test(firstScreen)) {
+            debug('agy:scrape', 'trust prompt detected — confirming with Enter');
+            await sleep(300); // ensure app is fully interactive before sending input
+            tui.sendKey('Enter');
+            await tui.waitFor(/for shortcuts/, 15_000);
+        }
         // Navigate to /usage panel
         tui.send('/usage');
         await tui.waitFor(/Model Quota/, 10_000);

package/dist/adapters/claude.js

@@ -1,9 +1,6 @@
-import { TuiScraper } from '../tmux.js';
+import { TuiScraper, sleep } from '../tmux.js';
 import { debug } from '../debug.js';
 // ── TUI scraper ────────────────────────────────────────────────────────────
-async function sleep(ms) {
-    return new Promise(res => setTimeout(res, ms));
-}
 /**
  * Launches `claude` in a tmux session, opens /status, navigates to the
  * Status tab (which shows real quota usage bars), and returns the captured
@@ -33,6 +30,23 @@ async function runClaudeScrape() {
         tui.kill();
     }
 }
+// ── Parser ─────────────────────────────────────────────────────────────────
+/** Convert any 12h am/pm time within a string to 24h (HH:MM). */
+function to24h(s) {
+    return s.replace(/\b(\d{1,2})(?::(\d{2}))?\s*(am|pm)\b/gi, (_, h, m, meridiem) => {
+        let hour = parseInt(h, 10);
+        const min = m ?? '00';
+        if (meridiem.toLowerCase() === 'am') {
+            if (hour === 12)
+                hour = 0; // 12am → 00:xx
+        }
+        else {
+            if (hour !== 12)
+                hour += 12; // 1–11pm → 13–23
+        }
+        return `${String(hour).padStart(2, '0')}:${min}`;
+    });
+}
 function parseScrapeOutput(screen) {
     debug('claude:parse', `screen length: ${screen.length}`);
     debug('claude:parse', 'screen', screen);
@@ -42,9 +56,10 @@ function parseScrapeOutput(screen) {
     debug('claude:parse', `found ${usedMatches.length} "% used" matches`);
     const sessionUsedPct = usedMatches[0] ? parseInt(usedMatches[0][1], 10) : null;
     const weeklyUsedPct = usedMatches[1] ? parseInt(usedMatches[1][1], 10) : null;
-    // Reset time: "Resets H:MMam" or "Resets May 30 at 6am" — grab the first occurrence
+    // Reset time: "Resets H:MMam" or "Resets May 30 at 6am" — grab the first occurrence,
+    // then normalise any 12h am/pm component to 24h (e.g. "11:10pm" → "23:10").
     const resetMatch = screen.match(/Resets\s+([^\n\r]+)/i);
-    const sessionResetAt = resetMatch ? resetMatch[1].trim() : null;
+    const sessionResetAt = resetMatch ? to24h(resetMatch[1].trim()) : null;
     debug('claude:parse', 'result', { sessionUsedPct, sessionResetAt, weeklyUsedPct });
     return { sessionUsedPct, sessionResetAt, weeklyUsedPct };
 }

package/dist/adapters/codex.js

@@ -1,7 +1,10 @@
 import { exec, execFileSync } from 'node:child_process';
 import { promisify } from 'node:util';
-import { readFileSync, unlinkSync } from 'node:fs';
-import { TuiScraper } from '../tmux.js';
+import { readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import path from 'node:path';
+import { TuiScraper, sleep, registerTempFile, unregisterTempFile } from '../tmux.js';
 import { debug } from '../debug.js';
 const execAsync = promisify(exec);
 // Used ONLY as a rough fallback estimate when the TUI scrape cannot determine
@@ -10,9 +13,17 @@ const execAsync = promisify(exec);
 const DEFAULT_BUDGET_USD = 20.0;
 const ROLLING_WINDOW_MS = 5 * 60 * 60 * 1000;
 // ── TUI scraper (tmux) ─────────────────────────────────────────────────────
-async function sleep(ms) {
-    return new Promise(res => setTimeout(res, ms));
-}
+// Codex may show one or more blocking dialogs before its main screen ("Tip:").
+// Known dialogs and their dismissal key ("2" = skip/use existing):
+//   • Update nag:      "Update available! x.x → y.y"
+//   • New-model intro: "Introducing GPT-5.5"
+const CODEX_READY = /Tip:/i;
+const CODEX_DIALOG = /Update available|Introducing GPT|Try new model|Use existing model/i;
+const CODEX_EITHER = new RegExp(`(?:${CODEX_READY.source})|(?:${CODEX_DIALOG.source})`, 'i');
+const CODEX_STARTUP_MS = 25_000;
+const CODEX_DIALOG_SETTLE_MS = 1_000; // wait for UI to re-render after dismissing a dialog
+const CODEX_STATUS_REFRESH_MS = 2_000; // first /status just triggers a quota refresh
+const CODEX_STATUS_READY_MS = 4_000; // second /status carries the live quota data
 /**
  * Launches `codex` in a tmux session, pipes all terminal bytes to a temp
  * file, sends /status twice, then reads the file and returns the raw bytes.
@@ -25,30 +36,56 @@ async function sleep(ms) {
  */
 async function runCodexScrape() {
     const tui = new TuiScraper('codex');
-    const pipePath = `/tmp/af-codex-${Date.now()}.log`;
+    const tmpDir = os.tmpdir();
+    const randomSuffix = crypto.randomBytes(6).toString('hex');
+    const pipePath = path.join(tmpDir, `af-codex-${Date.now()}-${randomSuffix}.log`);
+    registerTempFile(pipePath);
+    // Create the file with restricted permissions before tmux starts writing to it
+    writeFileSync(pipePath, '', { mode: 0o600 });
     try {
         tui.start();
-        // Stream all pane output to a file from the start
-        execFileSync('tmux', ['pipe-pane', '-t', tui.sessionId, `cat >> '${pipePath}'`]);
+        // Stream all pane output to a file from the start.
+        // Single-quote escaping: safe against all shell metacharacters ($, `, \, space, etc.)
+        // Note: pipe-pane executes this command via tmux's `default-shell` (defaults to /bin/sh).
+        // If the user has set default-shell to a non-POSIX shell (e.g. fish), the `'\\''` idiom
+        // will fail — but pipePath is constructed from os.tmpdir() + hex, so single quotes
+        // cannot appear in practice, making the replace a no-op and the quoting sh-compatible.
+        const shellSafePath = "'" + pipePath.replace(/'/g, "'\\''") + "'";
+        execFileSync('tmux', ['pipe-pane', '-t', tui.sessionId, `cat >> ${shellSafePath}`]);
         debug('codex:scrape', `pipe-pane logging to ${pipePath}`);
-        // Wait for TUI ready: current screen (historyLines=0) shows Tip, meaning MCP boot done
-        await tui.waitFor(/Tip:/i, 20_000, 0);
+        // Wait for TUI ready, dismissing any blocking dialogs along the way.
+        const dialogDeadline = Date.now() + CODEX_STARTUP_MS;
+        let screen = await tui.waitFor(CODEX_EITHER, CODEX_STARTUP_MS, 0);
+        while (!CODEX_READY.test(screen)) {
+            debug('codex:scrape', 'blocking dialog detected — sending "2" to dismiss');
+            tui.send('2');
+            await sleep(CODEX_DIALOG_SETTLE_MS);
+            const remaining = dialogDeadline - Date.now(); // compute AFTER sleep
+            if (remaining < 500) {
+                throw new Error('Codex TUI never reached ready state after dismissing dialogs');
+            }
+            screen = await tui.waitFor(CODEX_EITHER, remaining, 0);
+        }
         // First /status: panel says "Limits: refresh requested; run /status again shortly"
         tui.send('/status');
-        await sleep(2_000);
+        await sleep(CODEX_STATUS_REFRESH_MS);
         // Second /status: has actual 5h/weekly quota data
         tui.send('/status');
-        await sleep(4_000);
+        await sleep(CODEX_STATUS_READY_MS);
         const raw = readFileSync(pipePath, 'utf-8');
         debug('codex:scrape', `pipe log size: ${raw.length} bytes`);
         return raw;
     }
     finally {
-        tui.kill();
+        try {
+            tui.kill();
+        }
+        catch { /* already dead */ }
+        unregisterTempFile(pipePath); // always remove from registry, regardless of unlink success
         try {
             unlinkSync(pipePath);
         }
-        catch { /* ok */ }
+        catch { /* ok if already gone */ }
     }
 }
 function stripAnsi(str) {
@@ -119,7 +156,8 @@ async function fetchCcusageEstimate(budgetLimit) {
         try {
             ({ stdout } = await execAsync('npx --no-install ccusage codex session --json'));
         }
-        catch {
+        catch (err) {
+            debug('codex:ccusage', 'ccusage exec failed', String(err));
             return unknown();
         }
         debug('codex:ccusage', 'raw stdout', stdout);
@@ -156,7 +194,7 @@ async function fetchCcusageEstimate(budgetLimit) {
         if (latestActivity > 0) {
             try {
                 resetAt = new Date(latestActivity + ROLLING_WINDOW_MS).toLocaleTimeString([], {
-                    hour: '2-digit', minute: '2-digit',
+                    hour: '2-digit', minute: '2-digit', hour12: false,
                 });
             }
             catch { /* leave null */ }
@@ -178,7 +216,8 @@ async function fetchCcusageEstimate(budgetLimit) {
             raw: { totalCost, todaySessionsCount: todaySessions.length, isEstimate: true },
         };
     }
-    catch {
+    catch (err) {
+        debug('codex:ccusage', 'unexpected error in ccusage fallback', String(err));
         return unknown();
     }
 }

package/dist/debug.js

@@ -1,10 +1,41 @@
-import { appendFileSync, mkdirSync } from 'node:fs';
+import { appendFileSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
 const enabled = process.argv.includes('--debug');
+const MAX_DEBUG_LOGS = 10;
+function pruneOldLogs(dir) {
+    try {
+        // Count first — stat only if pruning is actually needed.
+        // Use MAX_DEBUG_LOGS - 1 to reserve a slot for the new log file that is
+        // created after this call, so the total on disk never exceeds MAX_DEBUG_LOGS.
+        const names = readdirSync(dir)
+            .filter(f => f.startsWith('debug-') && f.endsWith('.log'));
+        if (names.length < MAX_DEBUG_LOGS)
+            return;
+        const files = names.map(f => {
+            const p = join(dir, f);
+            return { path: p, time: statSync(p).mtimeMs };
+        });
+        // Sort by modification time, oldest first
+        files.sort((a, b) => a.time - b.time);
+        const toDeleteCount = files.length - (MAX_DEBUG_LOGS - 1);
+        for (let i = 0; i < toDeleteCount; i++) {
+            try {
+                unlinkSync(files[i].path);
+            }
+            catch {
+                // ignore individual deletion failures
+            }
+        }
+    }
+    catch {
+        // ignore directory read/stat errors
+    }
+}
 const logFile = enabled
     ? (() => {
         const dir = join(process.cwd(), '.logs');
         mkdirSync(dir, { recursive: true });
+        pruneOldLogs(dir);
         const ts = new Date().toISOString().replace(/[:.]/g, '-');
         return join(dir, `debug-${ts}.log`);
     })()

package/dist/tmux.d.ts

@@ -1,3 +1,5 @@
+export declare function registerTempFile(filePath: string): void;
+export declare function unregisterTempFile(filePath: string): void;
 export declare class TuiScraper {
     private readonly command;
     private readonly width;
@@ -11,3 +13,4 @@ export declare class TuiScraper {
     waitFor(pattern: RegExp, timeoutMs: number, historyLines?: number): Promise<string>;
     kill(): void;
 }
+export declare function sleep(ms: number): Promise<void>;

package/dist/tmux.js

@@ -1,5 +1,62 @@
 import { execFileSync } from 'node:child_process';
+import { unlinkSync } from 'node:fs';
+import crypto from 'node:crypto';
 import { debug } from './debug.js';
+// Global registries for active resources
+const activeScrapers = new Set();
+const activeTempFiles = new Set();
+export function registerTempFile(filePath) {
+    activeTempFiles.add(filePath);
+}
+export function unregisterTempFile(filePath) {
+    activeTempFiles.delete(filePath);
+}
+function cleanupAll() {
+    if (activeScrapers.size === 0 && activeTempFiles.size === 0)
+        return;
+    process.stderr.write(`\n\x1b[33m[agent-fuel] Clean up triggered. Cleaning up resources...\x1b[0m\n`);
+    for (const scraper of activeScrapers) {
+        try {
+            scraper.kill();
+        }
+        catch {
+            // ignore
+        }
+    }
+    activeScrapers.clear();
+    for (const file of activeTempFiles) {
+        try {
+            unlinkSync(file);
+        }
+        catch {
+            // ignore
+        }
+    }
+    activeTempFiles.clear();
+}
+// Register signal handlers eagerly at module load time so that any temp files
+// registered before TuiScraper.start() (e.g. between registerTempFile and start())
+// are still cleaned up on SIGINT/SIGTERM/SIGHUP.
+let signalsRegistered = false;
+function registerSignalHandlers() {
+    if (signalsRegistered)
+        return;
+    signalsRegistered = true;
+    const signals = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+    for (const sig of signals) {
+        process.on(sig, () => {
+            cleanupAll();
+            const code = sig === 'SIGINT' ? 130 : sig === 'SIGTERM' ? 143 : 129;
+            process.exit(code);
+        });
+    }
+    process.on('uncaughtException', (err) => {
+        process.stderr.write(`\x1b[31mUncaught Exception:\x1b[0m ${err.stack || err}\n`);
+        cleanupAll();
+        process.exit(1);
+    });
+}
+registerSignalHandlers(); // called at import time — guarded by signalsRegistered flag
 export class TuiScraper {
     command;
     width;
@@ -9,11 +66,11 @@ export class TuiScraper {
         this.command = command;
         this.width = width;
         this.height = height;
-        this.sessionId = `af-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        this.sessionId = `af-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
     }
     start() {
         try {
-            execFileSync('which', ['tmux'], { stdio: 'ignore' });
+            execFileSync('which', ['tmux'], { stdio: 'ignore', timeout: 5000 });
         }
         catch {
             throw new Error('tmux not found — install with: brew install tmux');
@@ -23,7 +80,8 @@ export class TuiScraper {
             'new-session', '-d', '-s', this.sessionId,
             '-x', String(this.width), '-y', String(this.height),
             this.command,
-        ]);
+        ], { stdio: 'ignore', timeout: 5000 });
+        activeScrapers.add(this);
     }
     // historyLines > 0 → include that many lines of scrollback above the visible screen.
     // This catches transient overlays that rendered and then re-rendered away.
@@ -31,18 +89,18 @@ export class TuiScraper {
         const args = historyLines > 0
             ? ['capture-pane', '-t', this.sessionId, '-S', `-${historyLines}`, '-p']
             : ['capture-pane', '-t', this.sessionId, '-p'];
-        const text = execFileSync('tmux', args).toString();
+        const text = execFileSync('tmux', args, { timeout: 5000 }).toString();
         debug('tmux:capture', `[${this.sessionId}] captured ${text.length} chars (history=${historyLines})`);
         return text;
     }
     send(text) {
         debug('tmux:send', `[${this.sessionId}] sending: ${JSON.stringify(text)}`);
-        execFileSync('tmux', ['send-keys', '-t', this.sessionId, text, 'Enter']);
+        execFileSync('tmux', ['send-keys', '-t', this.sessionId, text, 'Enter'], { stdio: 'ignore', timeout: 5000 });
     }
     // Send a named key (Tab, Escape, Up, Down, etc.) without appending Enter.
     sendKey(key) {
         debug('tmux:send', `[${this.sessionId}] sendKey: ${key}`);
-        execFileSync('tmux', ['send-keys', '-t', this.sessionId, key]);
+        execFileSync('tmux', ['send-keys', '-t', this.sessionId, key], { stdio: 'ignore', timeout: 5000 });
     }
     async waitFor(pattern, timeoutMs, historyLines = 500) {
         const deadline = Date.now() + timeoutMs;
@@ -62,11 +120,12 @@ export class TuiScraper {
     kill() {
         debug('tmux', `killing session ${this.sessionId}`);
         try {
-            execFileSync('tmux', ['kill-session', '-t', this.sessionId], { stdio: 'ignore' });
+            execFileSync('tmux', ['kill-session', '-t', this.sessionId], { stdio: 'ignore', timeout: 3000 });
         }
         catch { /* already dead */ }
+        activeScrapers.delete(this); // delete after kill attempt so a concurrent signal doesn't see a half-killed scraper
     }
 }
-function sleep(ms) {
+export function sleep(ms) {
     return new Promise(res => setTimeout(res, ms));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-fuel",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Sleek term-based dashboard for AI coding CLI quotas",
   "type": "module",
   "main": "dist/index.js",
@@ -28,7 +28,7 @@
   "author": "Pedro Rodrigues",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "^20.11.24",
-    "typescript": "^5.3.3"
+    "@types/node": "^25.9.1",
+    "typescript": "^6.0.3"
   }
 }