@cosmovex/agentpager 0.1.0

package/dist/guard/spend.js

@@ -0,0 +1,158 @@
+// What this session has actually cost, read from the agent's own transcript.
+//
+// Every vendor ships a spend *display* and none ships a spend *stop*. Claude Code's
+// `--max-budget-usd` is print-mode only; the identical request to make it enforce was closed "not
+// planned" (#65409), reopened as #95964, and is still open. Codex CLI's `rollout_budget` prints
+// reminders at 50k/25k/10k tokens and never denies a call. Meanwhile #93255 records a user who set
+// a $20 cap and watched $40 go out of the door.
+//
+// So the number has to be computed here, from the transcript the agent is already writing, before
+// the next tool call runs. No API, no vendor cooperation, no polling — the PreToolUse hook is handed
+// `transcript_path` on stdin, and that file already contains every usage record for the session.
+import { createReadStream, existsSync, readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { agentpagerHome } from './rules.js';
+import { createInterface } from 'node:readline';
+/**
+ * The date the built-in table below was last checked against the vendor's price list. It is shown to
+ * the user (`agentpager guard status`) so a stale table is visible, not silent.
+ *
+ * ⚠️ NEEDS RE-VERIFYING against Anthropic's pricing page. USD per million tokens, coarse per-family
+ * figures matched by substring.
+ *  - Haiku 4.5 ($1 / $5, cache read $0.10) was MEASURED on 2026-09-26: three real `claude -p` runs
+ *    reproduced the CLI's own `total_cost_usd` to the sixth decimal (docs/GUARD_HEADLESS.md). The
+ *    old "haiku" row was Haiku 3.5's price and under-counted Haiku 4.5 by ~44%.
+ *  - Sonnet and Opus rows are carried over from the first version and were NOT re-checked. Opus at
+ *    $15/$75 is the older generation's price; newer Opus is cheaper, which errs toward stopping a
+ *    session early — the safe direction for a cap.
+ *  - Claude Code writes its prompt cache with a 1-hour TTL, billed at 2x input (measured on Haiku
+ *    4.5; assumed the same multiplier for the other families).
+ */
+export const PRICES_AS_OF = '2026-09-26 (Haiku 4.5 measured; Sonnet/Opus not re-verified)';
+// Deliberately coarse and matched by substring, so a model we have never heard of still gets a
+// sane estimate rather than zero. A cap that silently reads $0.00 for an unknown model is worse
+// than no cap at all — it is a cap that is off while claiming to be on.
+export const PRICES = [
+    [/haiku[-\s]?4[-.]?5/i, { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.1 }],
+    [/opus/i, { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5 }],
+    [/sonnet/i, { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 }],
+    [/haiku/i, { input: 0.8, output: 4, cacheWrite: 1, cacheRead: 0.08 }],
+];
+/** An unknown model is priced as the most expensive tier: a cap must fail toward blocking, not toward $0. */
+const MOST_EXPENSIVE = PRICES.map(([, p]) => p).reduce((a, b) => (b.input + b.output > a.input + a.output ? b : a));
+const isPrice = (p) => p && [p.input, p.output, p.cacheWrite, p.cacheRead].every((n) => typeof n === 'number' && Number.isFinite(n) && n >= 0) && (p.cacheWrite1h === undefined || (typeof p.cacheWrite1h === 'number' && p.cacheWrite1h >= 0));
+/**
+ * `~/.agentpager/prices.json` lets a person (or a newer AgentPager) correct the table without a new
+ * release: `{ "opus-4": { "input": 5, "output": 25, "cacheWrite": 6.25, "cacheRead": 0.5 } }`.
+ * Keys are case-insensitive substrings of the model name; the longest key wins. A missing or broken
+ * file is simply ignored.
+ */
+export function loadPriceOverrides() {
+    try {
+        const raw = JSON.parse(readFileSync(join(agentpagerHome(), 'prices.json'), 'utf8'));
+        return Object.entries(raw ?? {})
+            .filter(([, p]) => isPrice(p))
+            .map(([k, p]) => [k.toLowerCase(), p])
+            .sort((a, b) => b[0].length - a[0].length);
+    }
+    catch {
+        return [];
+    }
+}
+export function priceFor(model, overrides = loadPriceOverrides()) {
+    const m = model.toLowerCase();
+    const over = overrides.find(([k]) => m.includes(k));
+    if (over)
+        return over[1];
+    return PRICES.find(([re]) => re.test(model))?.[1] ?? MOST_EXPENSIVE;
+}
+export function costOf(model, u, overrides) {
+    const p = priceFor(model, overrides);
+    const m = (n, rate) => ((n ?? 0) / 1_000_000) * rate;
+    const oneHour = p.cacheWrite1h ?? p.input * 2;
+    const split = u.cache_creation;
+    // With a TTL split, price each part; without one, assume the dearer 1-hour rate (fail toward blocking).
+    const write = split && (split.ephemeral_5m_input_tokens !== undefined || split.ephemeral_1h_input_tokens !== undefined)
+        ? m(split.ephemeral_5m_input_tokens, p.cacheWrite) + m(split.ephemeral_1h_input_tokens, oneHour)
+        : m(u.cache_creation_input_tokens, oneHour);
+    return m(u.input_tokens, p.input) + m(u.output_tokens, p.output) + write + m(u.cache_read_input_tokens, p.cacheRead);
+}
+export const ZERO = { usd: 0, tokens: 0, turns: 0 };
+/**
+ * Sums every usage record in a transcript. Unreadable or half-written lines are skipped rather than
+ * thrown on: a JSONL file being appended to by another process WILL sometimes hand us a torn last
+ * line, and a guard that crashes on that is a guard that stops guarding.
+ */
+export async function spendOf(transcriptPath) {
+    // Claude Code writes ONE transcript line per content block of a reply (thinking, text, each
+    // tool_use), and every one of them carries the whole message's usage. Summing lines counted a
+    // 3-block reply three times (measured 2.8x on a real transcript), so usage is counted once per
+    // message id — the last line wins, since a streamed reply's final line has the final output count.
+    const byMessage = new Map();
+    let anon = 0;
+    let stream;
+    try {
+        stream = createReadStream(transcriptPath, { encoding: 'utf8' });
+    }
+    catch {
+        return ZERO; // no transcript yet: a brand-new session has spent nothing
+    }
+    const total = () => {
+        const overrides = loadPriceOverrides();
+        let usd = 0;
+        let tokens = 0;
+        for (const { model, u } of byMessage.values()) {
+            usd += costOf(model, u, overrides);
+            tokens += (u.input_tokens ?? 0) + (u.output_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0);
+        }
+        return { usd, tokens, turns: byMessage.size };
+    };
+    try {
+        for await (const line of createInterface({ input: stream, crlfDelay: Infinity })) {
+            if (!line.trim())
+                continue;
+            let row;
+            try {
+                row = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const msg = row?.message ?? row;
+            const u = msg?.usage;
+            if (!u || typeof u !== 'object')
+                continue;
+            const id = typeof msg?.id === 'string' && msg.id ? msg.id : `anon-${anon++}`;
+            byMessage.set(id, { model: String(msg?.model ?? row?.model ?? ''), u });
+        }
+    }
+    catch {
+        // A read error mid-file still leaves a partial total, which is the safe direction: we may
+        // under-report and let a call through, never over-report and block work that was within budget.
+        return total();
+    }
+    return total();
+}
+export const money = (usd) => (usd < 0.01 ? `$${usd.toFixed(4)}` : `$${usd.toFixed(2)}`);
+/**
+ * Where Claude Code keeps a session's transcript: `<config>/projects/<encoded cwd>/<id>.jsonl`. The
+ * folder name encodes the project path in a way that has changed between releases, so look for the
+ * file by id instead of rebuilding the name.
+ */
+export function findTranscript(sessionId) {
+    if (!/^[\w-]{8,80}$/.test(sessionId))
+        return null; // never build a path from arbitrary text
+    const root = join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'), 'projects');
+    try {
+        for (const dir of readdirSync(root)) {
+            const p = join(root, dir, `${sessionId}.jsonl`);
+            if (existsSync(p))
+                return p;
+        }
+    }
+    catch {
+        /* no projects folder: no sessions */
+    }
+    return null;
+}