agent-fuel 0.4.1 → 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/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, sleep } 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
@@ -18,6 +21,9 @@ 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.
@@ -30,11 +36,22 @@ const CODEX_STARTUP_MS = 25_000;
  */
 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, dismissing any blocking dialogs along the way.
         const dialogDeadline = Date.now() + CODEX_STARTUP_MS;
@@ -42,7 +59,7 @@ async function runCodexScrape() {
         while (!CODEX_READY.test(screen)) {
             debug('codex:scrape', 'blocking dialog detected — sending "2" to dismiss');
             tui.send('2');
-            await sleep(1_000); // wait for dialog to actually clear before re-checking
+            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');
@@ -51,20 +68,24 @@ async function runCodexScrape() {
         }
         // 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) {
@@ -135,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);
@@ -194,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;

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,9 +120,10 @@ 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
     }
 }
 export function sleep(ms) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-fuel",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Sleek term-based dashboard for AI coding CLI quotas",
   "type": "module",
   "main": "dist/index.js",