sprag-cli 3.67.0 → 3.68.0

package/src/glyphs.js

@@ -53,6 +53,7 @@ const ICON = {
   month: '💵',
   ctx: '📦',
   saved: '💰',
+  used: '📊',
   reset: '🔄',
   // Gauge cells. Separate ticks rather than one continuous block: the bar is a
   // count of how much of a budget is gone, and ticks are countable where a solid
@@ -82,6 +83,7 @@ const NARROW = {
   month: '∑',     // a running total
   ctx: '◧',       // a box filling up
   saved: '✓',
+  used: '◩',      // a split square: what the spend is made of
   reset: '↩',     // the window turning over
   // Same segmented shape as the icon set, in the two glyphs this font has.
   // ▰▱ (U+25B0/25B1) are absent from JetBrains Mono; ■□ (U+25A0/25A1) are there.

package/src/installer.js

@@ -16,7 +16,8 @@
 import { writeFileSync, mkdirSync, existsSync, unlinkSync, readFileSync, rmSync, copyFileSync, renameSync, realpathSync, statSync } from 'node:fs';
 import { loadConfig, saveConfig } from './config.js';
 import { CLI_NAME, LEGACY_CLI_NAME } from './cli-name.js';
-import { join, dirname } from 'node:path';
+import { join, dirname, resolve } from 'node:path';
+import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { claudeUserDir, userDataDir } from './paths.js';
 
@@ -354,6 +355,65 @@ export function removeLegacyCommand() {
   return { path: file, action: 'removed' };
 }
 
+/**
+ * Whether a foreign statusLine command is a script that calls this tool, as
+ * opposed to someone else's statusline.
+ *
+ * Both look the same to isOurCommand(): the command is `bash ~/.claude/x.sh`,
+ * not `sprag ...`. The difference matters to the person reading the install
+ * output. "Existing statusLine command (bash ~/.claude/x.sh)" reads as another
+ * tool's slot, when the script is their own wrapper around `sprag --statusline`
+ * and replacing it with the direct command loses nothing. The usual reason such a
+ * wrapper exists is an `npx` fallback written before the package was renamed, and
+ * `npx claude-token-saver@latest` now resolves to the deprecated package, which
+ * stopped at 3.55.0: the line it draws is frozen there, quietly, while the
+ * statusline appears to work.
+ *
+ * Recognised commands are `bash <path>`, `sh <path>` and a bare path ending in
+ * `.sh`. The script must exist and its text must name this tool next to
+ * `--statusline`; a script that only mentions the tool (a comment, an unrelated
+ * `sprag` directory) is not a wrapper. Best-effort throughout: an unreadable or
+ * oversized file is simply "not a wrapper", and the caller falls back to the
+ * generic conflict message.
+ *
+ * @returns {{ script: string, name: string, deprecatedFallback: boolean } | null}
+ *   `script` is the path as written in the command, for display.
+ */
+function detectStatuslineWrapper(command) {
+  if (typeof command !== 'string') return null;
+  const m = command.trim().match(/^(?:(?:bash|sh)\s+)?("[^"]+"|'[^']+'|\S+)(?:\s.*)?$/);
+  if (!m) return null;
+  const hasShell = /^(?:bash|sh)\s/.test(command.trim());
+  const script = m[1].replace(/^["']|["']$/g, '');
+  if (!hasShell && !script.endsWith('.sh')) return null;
+  // Settings commands spell the home directory three ways; the shell Claude Code
+  // runs them in would expand all of them.
+  const home = homedir();
+  const onDisk = resolve(script
+    .replace(/^~(?=$|[/\\])/, home)
+    .replace(/^\$\{?HOME\}?(?=$|[/\\])/, home));
+  let body;
+  try {
+    const st = statSync(onDisk);
+    // A statusline wrapper is a few lines; anything this large is not one.
+    if (!st.isFile() || st.size > 256 * 1024) return null;
+    body = readFileSync(onDisk, 'utf8');
+  } catch {
+    return null;
+  }
+  if (!body.includes('--statusline')) return null;
+  const nameAt = (text) => {
+    const k = text.match(new RegExp(`${LEGACY_CLI}|${CLI}`));
+    return k ? k[0] : null;
+  };
+  // The name on the `--statusline` line is the one being called; failing that,
+  // whichever comes first (the command may sit in a variable set elsewhere).
+  const callLine = body.split('\n').find((l) => l.includes('--statusline') && nameAt(l));
+  const name = nameAt(callLine ?? body);
+  if (!name) return null;
+  return { script, name, deprecatedFallback: body.includes(`${LEGACY_CLI}@latest`) };
+}
+
 // Registers/repairs the Claude Code statusLine entry in ~/.claude/settings.json.
 // - No statusLine yet: insert ours with refreshInterval:STATUSLINE_REFRESH_INTERVAL.
 // - statusLine already points at sprag: ensure that refreshInterval
@@ -402,6 +462,22 @@ export function installStatusline({ force = false, merge = false } = {}) {
     // `conflict` lets the interactive install distinguish "someone else's
     // statusline is here" (worth asking about) from other skip reasons
     // (unreadable JSON), which a prompt cannot fix.
+    const wrapper = detectStatuslineWrapper(cur.command);
+    if (wrapper) {
+      // Still a conflict, for the same reason: the entry is not ours to rewrite
+      // unasked. Only the wording changes, to say what the entry is.
+      const fallback = wrapper.deprecatedFallback
+        ? ` (its npx fallback resolves to the deprecated ${LEGACY_CLI} package, last published as 3.55.0)`
+        : '';
+      return {
+        path: file,
+        action: 'skipped',
+        conflict: true,
+        wrapper: true,
+        existingCommand: cur.command,
+        reason: `existing statusLine wrapper script (${wrapper.script}) calls ${wrapper.name}; re-run with --force to replace it with \`${STATUSLINE_COMMAND}\`${fallback}`,
+      };
+    }
     return { path: file, action: 'skipped', conflict: true, existingCommand: cur.command, reason: `existing statusLine command (${cur.command}) — re-run with --force to overwrite` };
   }
   const base = cur;

package/src/model-alias.js

@@ -36,9 +36,9 @@
  * package is published to npm, so neither may live in the source.
  */
 
-import { readFileSync, mkdirSync, existsSync, createReadStream, statSync } from 'node:fs';
+import { readFileSync, mkdirSync, existsSync, statSync } from 'node:fs';
 import { readFile, readdir } from 'node:fs/promises';
-import { createInterface } from 'node:readline';
+import { transcriptLines } from './transcript-lines.js';
 import { join, dirname, basename } from 'node:path';
 import { userDataDir, claudeUserDir } from './paths.js';
 import { gatewayBase } from './gateway-auth.js';
@@ -416,49 +416,41 @@ export function voteRole(requested, declared, parentDeclared) {
 async function scanMainTranscript(path, votes, requestedByToolUse, agentTypeCache) {
   let sawGateway = false;
   let declared = null;
-  const rl = createInterface({
-    input: createReadStream(path, { encoding: 'utf8' }),
-    crlfDelay: Infinity,
-  });
-  try {
-    for await (const line of rl) {
-      if (!line.includes('arn:aws:bedrock:') && !line.includes('"Task"') && !line.includes('"Agent"')
-        && !line.includes('"identity"')) {
-        continue;
-      }
-      let entry;
-      try {
-        entry = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (!declared && entry.isSidechain !== true) declared = declaredModelOf(entry);
-      const msg = entry.message;
-      if (!msg) continue;
-
-      // The session's own model: the parent side of the transcript.
-      if (msg.model && entry.isSidechain !== true) {
-        const pid = profileIdFrom(msg.model);
-        if (pid) {
-          sawGateway = true;
-          // Circumstantial: a subagent's records also land in the parent file
-          // without the flag often enough to outvote real evidence.
-          addVote(votes, pid, 'main', 'inferred');
-        }
+  for await (const line of transcriptLines(path)) {
+    if (!line.includes('arn:aws:bedrock:') && !line.includes('"Task"') && !line.includes('"Agent"')
+      && !line.includes('"identity"')) {
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!declared && entry.isSidechain !== true) declared = declaredModelOf(entry);
+    const msg = entry.message;
+    if (!msg) continue;
+
+    // The session's own model: the parent side of the transcript.
+    if (msg.model && entry.isSidechain !== true) {
+      const pid = profileIdFrom(msg.model);
+      if (pid) {
+        sawGateway = true;
+        // Circumstantial: a subagent's records also land in the parent file
+        // without the flag often enough to outvote real evidence.
+        addVote(votes, pid, 'main', 'inferred');
       }
+    }
 
-      if (!Array.isArray(msg.content)) continue;
-      for (const block of msg.content) {
-        if (!block || block.type !== 'tool_use') continue;
-        if (block.name !== 'Task' && block.name !== 'Agent') continue;
-        const input = block.input || {};
-        const role = roleFromModelParam(input.model)
-          || roleFromAgentType(input.subagent_type, agentTypeCache);
-        if (block.id && role) requestedByToolUse.set(block.id, role);
-      }
+    if (!Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (!block || block.type !== 'tool_use') continue;
+      if (block.name !== 'Task' && block.name !== 'Agent') continue;
+      const input = block.input || {};
+      const role = roleFromModelParam(input.model)
+        || roleFromAgentType(input.subagent_type, agentTypeCache);
+      if (block.id && role) requestedByToolUse.set(block.id, role);
     }
-  } finally {
-    rl.close();
   }
   return { sawGateway, declared };
 }
@@ -469,25 +461,18 @@ async function scanMainTranscript(path, votes, requestedByToolUse, agentTypeCach
  */
 async function subagentModelInfo(path) {
   let declared = null;
-  const rl = createInterface({
-    input: createReadStream(path, { encoding: 'utf8' }),
-    crlfDelay: Infinity,
-  });
-  try {
-    for await (const line of rl) {
-      if (!line.includes('arn:aws:bedrock:') && !line.includes('"identity"')) continue;
-      let entry;
-      try {
-        entry = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      declared ??= declaredModelOf(entry);
-      const pid = profileIdFrom(entry.message?.model);
-      if (pid) return { pid, declared };
+  // transcriptLines() closes the file on the early return below; see its header.
+  for await (const line of transcriptLines(path)) {
+    if (!line.includes('arn:aws:bedrock:') && !line.includes('"identity"')) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
     }
-  } finally {
-    rl.close();
+    declared ??= declaredModelOf(entry);
+    const pid = profileIdFrom(entry.message?.model);
+    if (pid) return { pid, declared };
   }
   return { pid: null, declared };
 }

package/src/model-share.js

@@ -0,0 +1,136 @@
+/**
+ * Model share: how the spend since the routing counter's mark splits across
+ * model families, by cost. Feeds the statusline's bar and `sprag saved`'s table.
+ *
+ * "Same period" as `sprag saved`: the routing reset mark, or the start of the
+ * calendar month when nothing was ever reset, capped at 90 days of parsing.
+ */
+import { pricedParts, sessionCost } from './claude-price.js';
+import { modelFamily } from './savings-ledger.js';
+import { readResetMarks } from './saved-reset.cjs';
+import { RESET, RED, GREEN, YELLOW, CYAN, MAGENTA, GRAY } from './formatters/statusline.js';
+
+const DAY = 86400000;
+export const MAX_DAYS = 90;
+
+/**
+ * Split `slots` whole units across `values` in proportion, largest remainder
+ * first, so the parts always add up to exactly `slots`. Ties keep input order.
+ */
+export function roundShares(values, slots) {
+  const vs = (values || []).map((v) => (Number.isFinite(v) && v > 0 ? v : 0));
+  const total = vs.reduce((a, b) => a + b, 0);
+  if (total <= 0 || !(slots > 0)) return vs.map(() => 0);
+  const exact = vs.map((v) => (v / total) * slots);
+  const out = exact.map((x) => Math.floor(x + 1e-9));
+  let left = slots - out.reduce((a, b) => a + b, 0);
+  const order = exact
+    .map((x, i) => ({ i, frac: x - Math.floor(x + 1e-9) }))
+    .sort((a, b) => b.frac - a.frac || a.i - b.i);
+  for (let k = 0; left > 0 && order.length; k = (k + 1) % order.length, left--) out[order[k].i] += 1;
+  return out;
+}
+
+function rank(families) {
+  return families
+    .map((f, i) => ({ ...f, i }))
+    .sort((a, b) => b.usd - a.usd || a.i - b.i);
+}
+
+function toneOf(family) {
+  switch (family) {
+    case 'opus': return MAGENTA;
+    case 'sonnet': return CYAN;
+    case 'haiku': return GREEN;
+    case 'fable': return YELLOW;
+    case 'mythos': return RED;
+    default: return GRAY;
+  }
+}
+
+const FAMILY_NAMES = { opus: 'Opus', sonnet: 'Sonnet', haiku: 'Haiku', fable: 'Fable', mythos: 'Mythos' };
+
+/**
+ * Statusline legend, `● Opus 90%  ● Sonnet 10%`: a dot in the family's colour,
+ * the name, and a gray whole percent. Reads without a key, which the bar and
+ * letters did not. Without colour the dot carries nothing, so it is dropped.
+ * A family that spent money but rounds to 0% shows as `<1%`: dropping it made
+ * a model that had just been delegated to look unused.
+ */
+export function shareLegend(families, { color = true } = {}) {
+  const ranked = rank(families || []);
+  const pcts = roundShares(ranked.map((f) => f.usd), 100);
+  return ranked
+    .map((f, idx) => {
+      if (!(f.usd > 0)) return null;
+      const name = FAMILY_NAMES[f.family] || f.family;
+      const pct = pcts[idx] > 0 ? `${pcts[idx]}%` : '<1%';
+      return color
+        ? `${toneOf(f.family)}●${RESET} ${name} ${GRAY}${pct}${RESET}`
+        : `${name} ${pct}`;
+    })
+    .filter(Boolean)
+    .join('  ');
+}
+
+/** Cost per family over the given sessions, subagent runs split out. Pure. */
+export function computeModelShare(sessions, { env = process.env } = {}) {
+  const all = new Map();
+  const sub = new Map();
+  let unpriced = 0;
+  let totalUsd = 0;
+  let subUsd = 0;
+  for (const s of sessions || []) {
+    for (const part of pricedParts(s)) {
+      if (!part || !part.totals) continue;
+      let cost = null;
+      try { cost = sessionCost(part.totals, part.model, { env }); } catch { cost = null; }
+      if (!cost || !Number.isFinite(cost.actual)) { unpriced++; continue; }
+      const family = modelFamily(part.model);
+      all.set(family, (all.get(family) || 0) + cost.actual);
+      totalUsd += cost.actual;
+      if (!part.own) {
+        sub.set(family, (sub.get(family) || 0) + cost.actual);
+        subUsd += cost.actual;
+      }
+    }
+  }
+  const list = (m) => [...m.entries()]
+    .map(([family, usd]) => ({ family, usd, pct: totalUsd > 0 ? (usd / totalUsd) * 100 : 0 }))
+    .sort((a, b) => b.usd - a.usd);
+  if (!(totalUsd > 0)) {
+    return { totalUsd: 0, unpriced, families: [], subagent: { usd: 0, pct: 0, families: [] } };
+  }
+  return {
+    totalUsd,
+    unpriced,
+    families: list(all),
+    subagent: { usd: subUsd, pct: (subUsd / totalUsd) * 100, families: list(sub) },
+  };
+}
+
+/**
+ * Collect the sessions for the routing counter's period and compute the share.
+ * `monthSessions` (already parsed by the statusline) is reused when the period
+ * starts inside the month; otherwise, or when absent, the transcripts are parsed.
+ */
+export async function loadModelShare({ dir, env = process.env, projectFilter, now = Date.now(), monthSessions } = {}) {
+  const { parseAllSessions, sessionsSince } = await import('./parser.js');
+  const { monthStartMs } = await import('./month-spend.js');
+  const reset = readResetMarks(dir).routing;
+  const monthStart = monthStartMs(new Date(now));
+  let since = Number.isFinite(reset) && reset > 0 ? reset : monthStart;
+  let sinceKind = since === monthStart && !(Number.isFinite(reset) && reset > 0) ? 'month' : 'reset';
+  if (now - since > MAX_DAYS * DAY) {
+    since = now - MAX_DAYS * DAY;
+    sinceKind = 'capped';
+  }
+  let sessions;
+  if (monthSessions && since >= monthStart) {
+    sessions = await sessionsSince(monthSessions, since);
+  } else {
+    const days = Math.max(1, Math.ceil((now - since) / DAY));
+    sessions = await sessionsSince(await parseAllSessions({ days, projectFilter, sinceMs: since }), since);
+  }
+  return { ...computeModelShare(sessions, { env }), since, sinceKind };
+}

package/src/parser.js

@@ -1,6 +1,6 @@
-import { createReadStream, openSync, readSync, closeSync, fstatSync } from 'node:fs';
+import { openSync, readSync, closeSync, fstatSync } from 'node:fs';
 import { readdir, stat } from 'node:fs/promises';
-import { createInterface } from 'node:readline';
+import { transcriptLines } from './transcript-lines.js';
 import { join, isAbsolute, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { loadCache, getCached, putCached, saveCache, getCachedSince, putCachedSince } from './session-cache.js';
@@ -33,12 +33,7 @@ export async function parseSessionFile(filePath) {
   let lastTimestamp = null;
   let gatewayObserved = false;
 
-  const rl = createInterface({
-    input: createReadStream(filePath, { encoding: 'utf8' }),
-    crlfDelay: Infinity,
-  });
-
-  for await (const line of rl) {
+  for await (const line of transcriptLines(filePath)) {
     let entry;
     try {
       entry = JSON.parse(line);
@@ -277,11 +272,7 @@ export async function getLastUserMessageTime(filePath) {
   const tail = lastUserTsFromTail(filePath);
   if (tail.found) return tail.ts ? new Date(tail.ts) : null;
   try {
-    const rl = createInterface({
-      input: createReadStream(filePath, { encoding: 'utf8' }),
-      crlfDelay: Infinity,
-    });
-    for await (const line of rl) {
+    for await (const line of transcriptLines(filePath)) {
       if (!line) continue;
       try {
         const entry = JSON.parse(line);

package/src/session-records.js

@@ -7,8 +7,7 @@
  * requestId (last-write-wins, matching parser.js).
  */
 
-import { createReadStream } from 'node:fs';
-import { createInterface } from 'node:readline';
+import { transcriptLines } from './transcript-lines.js';
 import { resolveModelAlias } from './model-alias.js';
 
 /**
@@ -94,12 +93,7 @@ export async function collectSessionRecords(filePath, { includeContent = true }
   let lastCwd = '';
   let lastRecord = null;
 
-  const rl = createInterface({
-    input: createReadStream(filePath, { encoding: 'utf8' }),
-    crlfDelay: Infinity,
-  });
-
-  for await (const line of rl) {
+  for await (const line of transcriptLines(filePath)) {
     let entry;
     try {
       entry = JSON.parse(line);

package/src/statusline-base.js

@@ -9,7 +9,6 @@
 
 import { spawnSync } from 'node:child_process';
 import { loadConfig } from './config.js';
-import { readStdinRaw } from './stdin-payload.js';
 
 // A light name check instead of importing installer.js (heavy for a hot path).
 // If the saved base were ourselves, running it would recurse without end.
@@ -19,12 +18,19 @@ const OURS = /(^|[\s/\\])(sprag|claude-token-saver)(-cli)?(\.cmd|\.exe|\.ps1)?(\
 // that inner run must not start the base again, so the child carries a marker.
 const NESTED = 'SPRAG_STATUSLINE_BASE';
 
-export function withBaseStatusline(output) {
+/**
+ * `input` is the payload Claude Code wrote on stdin, forwarded to the base
+ * verbatim; the caller passes the text it already read. This function must not
+ * read fd 0 itself: the statusline has drained it by now, and a process whose
+ * stdin is still open (the test runner on Windows keeps the pipe to each test
+ * file open) blocks in readFileSync(0) with no timeout at all.
+ */
+export function withBaseStatusline(output, { input = '' } = {}) {
   if (process.env[NESTED] === '1') return output;
   try {
     const cmd = loadConfig().statuslineBase?.command;
     if (typeof cmd !== 'string' || !cmd.trim() || OURS.test(cmd)) return output;
-    const opts = { input: readStdinRaw(), encoding: 'utf8', timeout: 1500, env: { ...process.env, [NESTED]: '1' } };
+    const opts = { input, encoding: 'utf8', timeout: 1500, env: { ...process.env, [NESTED]: '1' } };
     const r = process.platform === 'win32'
       ? spawnSync(cmd, { ...opts, shell: true })
       : spawnSync('/bin/sh', ['-c', cmd], opts);

package/src/stdin-payload.js

@@ -109,7 +109,7 @@ export function bedrockDisplayFromId(id) {
   // The minor version is one or two digits. An id with no minor goes straight
   // to its date stamp (`claude-opus-4-20250514`), and reading that stamp as the
   // minor printed "Opus 4.20250514".
-  const m = id.match(/claude[-_](opus|sonnet|haiku)[-_](\d+)(?:[-_](\d{1,2})(?!\d))?/i);
+  const m = id.match(/claude[-_](opus|sonnet|haiku|fable|mythos)[-_](\d+)(?:[-_](\d{1,2})(?!\d))?/i);
   if (!m) return null;
   const family = m[1].charAt(0).toUpperCase() + m[1].slice(1).toLowerCase();
   return m[3] === undefined ? `${family} ${m[2]}` : `${family} ${m[2]}.${m[3]}`;

package/src/transcript-lines.js

@@ -0,0 +1,40 @@
+/**
+ * Lines of a transcript file, with the file closed before the loop is over.
+ *
+ * Every transcript reader used to build its own readline over createReadStream.
+ * That works until a loop leaves early: `return` inside `for await` closes the
+ * readline interface, but on Node 20 the ReadStream underneath keeps its
+ * descriptor until garbage collection. And even a loop that runs to the end is
+ * not done when it ends: 'end' fires before the asynchronous fs.close() has
+ * run, so a caller that deletes the directory right away still finds the file
+ * open. POSIX does not mind; Windows answers ENOTEMPTY, which is how the
+ * Windows CI job failed on Node 20 alone.
+ *
+ * A generator's finally block runs on `break`, `return` and throw alike, so
+ * the stream is destroyed on every exit, and the 'close' event is awaited so
+ * the descriptor is gone when the loop is.
+ */
+
+import { createReadStream } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { once } from 'node:events';
+
+/**
+ * @param {string} filePath
+ * @returns {AsyncGenerator<string>}
+ */
+export async function* transcriptLines(filePath) {
+  const input = createReadStream(filePath, { encoding: 'utf8' });
+  const rl = createInterface({ input, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) yield line;
+  } finally {
+    rl.close();
+    input.destroy();
+    // A stream that failed to open has already closed itself; one that was
+    // still open closes asynchronously, and the wait is what makes the file
+    // deletable the moment the caller gets control back. 'error' after
+    // destroy() is not something to surface here: the loop already threw.
+    if (!input.closed) await once(input, 'close').catch(() => {});
+  }
+}