moshcode 0.58.0 → 0.60.0

package/src/cost-cli.mjs

@@ -0,0 +1,232 @@
+// `moshcode cost` — what the herd is spending, right now.
+//
+// The roster answers "which agent is blocked". This answers the other question
+// you have at 2am with six agents running: "what is this costing me". Same
+// shape as `moshcode ps` on purpose — one row per session, one line of totals —
+// because it is the same list of sessions seen through a different column.
+//
+// Everything it prints comes from the engines' own session logs (src/cost.mjs).
+// Nothing is sampled, nothing is proxied, and a number the engine itself
+// computed is never overwritten by our arithmetic.
+import {
+  DEFAULT_WINDOW_MS, UNCOSTED_ENGINES, attributeRuns, engineRuns,
+  formatTokens, formatUsd, totals,
+} from "./cost.mjs";
+import { pricingFile } from "./cost-pricing.mjs";
+import { EXIT, humanAge, roster } from "./herd-cli.mjs";
+import { acid, ash, bone, dim, err, info, table, warn } from "./ui.mjs";
+
+const tilde = (p) => {
+  const home = process.env.HOME || "";
+  return home && p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+};
+
+/** "30m", "6h", "3d", "90s" — the same vocabulary `moshcode wait --timeout` takes. */
+export function parseWindow(raw, fallback = DEFAULT_WINDOW_MS) {
+  const m = /^(\d+(?:\.\d+)?)\s*([smhd])?$/.exec(String(raw ?? "").trim());
+  if (!m) return fallback;
+  const n = Number(m[1]);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return n * { s: 1e3, m: 60e3, h: 3600e3, d: 86400e3 }[m[2] || "h"];
+}
+
+function flagValue(argv, name) {
+  const i = argv.indexOf(name);
+  if (i === -1) return null;
+  const next = argv[i + 1];
+  return next && !next.startsWith("-") ? next : null;
+}
+
+/**
+ * How confident the dollar figure is, in one character.
+ *
+ * `~` means we multiplied tokens by a published rate card; no marker means the
+ * engine handed us the price. On a subscription the estimate is what the same
+ * work would cost on the API — worth watching, not worth invoicing.
+ */
+function costCell(cost, source) {
+  if (cost == null) return ash("—");
+  const text = formatUsd(cost);
+  if (source === "engine") return bone(text);
+  return `${bone(text)}${dim("~")}`;
+}
+
+/**
+ * Cache tokens get their own column rather than folding into `in`.
+ *
+ * On a long agent session they are most of the traffic and a tenth of the price
+ * — a single "in" number that mixes them makes a $3 session look like a $60
+ * one, and hides the thing you would actually act on.
+ */
+const cacheTokens = (u) => u.cacheRead + u.cacheWrite5m + u.cacheWrite1h;
+
+/** The per-session table, shared by the one-shot report and `--watch`. */
+export function renderCost(rows, { indent = "  " } = {}) {
+  if (!rows.length) return "";
+  return table(
+    rows.map((r) => [
+      bone(r.name),
+      ash(String(r.engine)),
+      ash(r.models?.length ? r.models.join(",") : "—"),
+      dim(formatTokens(r.usage.input)),
+      dim(formatTokens(r.usage.output)),
+      dim(formatTokens(cacheTokens(r.usage))),
+      costCell(r.cost, r.costSource),
+      dim(humanAge(r.age)),
+    ]),
+    { columns: ["session", "engine", "model", "in", "out", "cache", "cost", "age"], header: true, indent: indent.length },
+  );
+}
+
+/** The `--all` table: engine sessions as the engines recorded them. */
+function renderRuns(runs, { indent = "  " } = {}) {
+  if (!runs.length) return "";
+  return table(
+    runs.map((r) => [
+      bone(String(r.id).slice(0, 8)),
+      ash(r.engine),
+      ash(r.models?.length ? r.models.join(",") : "—"),
+      ash(tilde(r.cwd || "")),
+      dim(formatTokens(r.usage.input)),
+      dim(formatTokens(r.usage.output)),
+      dim(formatTokens(cacheTokens(r.usage))),
+      costCell(r.cost, r.costSource),
+    ]),
+    { columns: ["run", "engine", "model", "cwd", "in", "out", "cache", "cost"], header: true, indent: indent.length },
+  );
+}
+
+/**
+ * Gather everything once: the roster, the engine runs in the window, and the
+ * attribution between them. Returned whole so `--json`, the table, and the
+ * herd bar all read the same numbers.
+ */
+export async function costReport({ since, cwd = null, engines = null } = {}) {
+  const sessions = roster();
+  const runs = await engineRuns({ since, cwd, engines });
+  const { rows, unattributed } = attributeRuns(sessions, runs);
+  return { sessions, runs, rows, unattributed, since };
+}
+
+/**
+ * The total is the total of the table above it, and anything the table left out
+ * is its own line. A single grand total over rows that are not all shown reads
+ * as "your herd cost $850" when the herd cost nothing and another terminal did.
+ */
+function footer(report, write, { attribution = true } = {}) {
+  const shown = totals(report.rows);
+  const loose = totals(report.unattributed);
+  const all = totals([...report.rows, ...report.unattributed]);
+
+  write("");
+  write(`  ${bone("total")}  ${costCell(shown.cost, "rates")}  ${dim(`${formatTokens(shown.usage.input)} in · ${formatTokens(shown.usage.output)} out · ${formatTokens(cacheTokens(shown.usage))} cached`)}`);
+  if (attribution && report.unattributed.length) {
+    write(info(`plus ${formatUsd(loose.cost)} in ${report.unattributed.length} engine session(s) outside the herd — ${acid("moshcode cost --all")} shows them.`));
+  }
+  if (shown.cost != null || loose.cost != null) {
+    write(dim(`  ~ estimated from published rates; unmarked figures are the engine's own.`));
+  }
+  if (all.unpriced.length) {
+    write(warn(`no rate for ${all.unpriced.join(", ")} — tokens counted, cost omitted.`));
+    write(info(`price them in ${tilde(pricingFile())}: { "${all.unpriced[0]}": { "input": 1.25, "output": 10 } }`));
+  }
+}
+
+/**
+ * `moshcode cost [name] [--all] [--since 6h] [--engine <name>] [--json] [--watch [secs]]`
+ */
+export async function costCommand(argv = [], { write = console.log } = {}) {
+  const asJson = argv.includes("--json");
+  const all = argv.includes("--all");
+  const since = Date.now() - parseWindow(flagValue(argv, "--since"));
+  const engineFlag = flagValue(argv, "--engine");
+  const engines = engineFlag ? engineFlag.split(",").map((s) => s.trim()).filter(Boolean) : null;
+  const watch = argv.includes("--watch");
+  const flagWords = new Set([flagValue(argv, "--since"), flagValue(argv, "--engine"), flagValue(argv, "--watch")]);
+  const name = argv.find((a) => !a.startsWith("-") && !flagWords.has(a)) || null;
+
+  if (watch && asJson) {
+    write(err("--watch and --json do not go together — pipe repeated `moshcode cost --json` instead."));
+    return EXIT.usage;
+  }
+
+  const once = async () => {
+    const report = await costReport({ since, engines });
+    let rows = report.rows;
+    if (name) {
+      rows = rows.filter((r) => r.name === name);
+      if (!rows.length) {
+        write(err(`no session named ${JSON.stringify(name)} — ${acid("moshcode ps")}`));
+        return EXIT.gone;
+      }
+    }
+
+    if (asJson) {
+      write(JSON.stringify({
+        since,
+        sessions: rows.map(({ name: n, engine, cwd, state, models, usage, cost, costSource, unpriced, runs }) => ({
+          name: n, engine, cwd, state, models, usage, cost, costSource, unpriced,
+          runs: runs.map((r) => ({ id: r.id, model: r.model, usage: r.usage, cost: r.cost, costSource: r.costSource, start: r.start, end: r.end })),
+        })),
+        unattributed: report.unattributed.map((r) => ({
+          id: r.id, engine: r.engine, cwd: r.cwd, model: r.model, usage: r.usage, cost: r.cost, costSource: r.costSource, start: r.start, end: r.end,
+        })),
+        totals: totals([...rows, ...report.unattributed]),
+      }, null, 2));
+      return EXIT.matched;
+    }
+
+    if (all) {
+      const runs = name ? rows.flatMap((r) => r.runs) : report.runs;
+      if (!runs.length) {
+        write(info("no engine sessions on disk in this window — widen it with `--since 7d`."));
+        return EXIT.matched;
+      }
+      write(renderRuns(runs));
+      // The runs ARE the rows here, so they are what the total totals. And the
+      // "not tied to a herd session" note would be describing the whole table
+      // back at itself, so it stays off.
+      footer({ ...report, rows: runs, unattributed: [] }, write, { attribution: false });
+      return EXIT.matched;
+    }
+
+    if (!rows.length) {
+      write(info("the herd is empty — `moshcode herd start claude` puts something in it."));
+      write(info(`already ran an agent outside the herd? ${acid("moshcode cost --all")}`));
+      return EXIT.matched;
+    }
+
+    write(renderCost(rows));
+    footer({ ...report, rows }, write);
+    if (UNCOSTED_ENGINES.some((e) => rows.some((r) => r.engine === e))) {
+      write(info(`${UNCOSTED_ENGINES.join(", ")} keep no usage log moshcode can read — those rows show no cost, not zero cost.`));
+    }
+    return EXIT.matched;
+  };
+
+  if (!watch) return once();
+
+  // --watch is the "ongoing" part: the same report, re-read on an interval,
+  // because the interesting thing about a running agent's cost is the slope.
+  const every = Math.max(2, Number(flagValue(argv, "--watch") || 10)) * 1000;
+  let stop = false;
+  const onSigint = () => { stop = true; };
+  process.on("SIGINT", onSigint);
+  try {
+    while (!stop) {
+      if (process.stdout.isTTY) process.stdout.write("\x1b[2J\x1b[H");
+      await once();
+      write(dim(`  refreshing every ${Math.round(every / 1000)}s · ctrl-c to stop`));
+      await new Promise((resolve) => {
+        const timer = setTimeout(resolve, every);
+        // A timer must not hold the process open past a ctrl-c.
+        timer.unref?.();
+        const poll = setInterval(() => { if (stop) { clearTimeout(timer); clearInterval(poll); resolve(); } }, 100);
+        poll.unref?.();
+      });
+    }
+  } finally {
+    process.off("SIGINT", onSigint);
+  }
+  return EXIT.matched;
+}

package/src/cost-pricing.mjs

@@ -0,0 +1,159 @@
+// What a million tokens costs, per model, so `moshcode cost` can turn the token
+// counts an engine wrote down into dollars.
+//
+// TOKENS ARE THE MEASUREMENT; DOLLARS ARE THE ESTIMATE. Only some engines
+// record a price of their own (opencode computes one per message, aider prints
+// a running session total). The rest — Claude Code, Codex — record usage and
+// nothing else, because the person running them is usually on a subscription
+// where the marginal request costs nothing extra. What this table produces for
+// those is "what these tokens would have cost at published API rates", which is
+// the number worth watching while a herd of agents burns through a repo, and is
+// not a bill. src/cost.mjs keeps the two apart: `costSource` is "engine" when
+// the engine priced it and "rates" when this table did.
+//
+// A model with no entry is NOT guessed at. Its tokens are still counted and
+// reported, its cost comes back null, and `moshcode cost` names it under the
+// table so you can price it yourself. A wrong number that looks authoritative is worse
+// than an honest blank — especially for engines whose vendors we don't track.
+import fs from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+
+/**
+ * Published rates, USD per million tokens.
+ *
+ * `input`/`output` are the base rates. `cacheRead` and `cacheWrite` are
+ * optional; when absent they are derived from `input` by CACHE_MULTIPLIERS
+ * below, which is Anthropic's published relationship (and the only vendor whose
+ * cache pricing this file claims to know).
+ *
+ * Anthropic rates as published 2026-06; Sonnet 5's introductory $2/$10 runs
+ * through 2026-08-31 and is deliberately not encoded — an intro rate that
+ * expires silently would make this table wrong on a date nobody is watching.
+ */
+export const PRICING = {
+  "claude-fable-5": { input: 10, output: 50 },
+  "claude-mythos-5": { input: 10, output: 50 },
+  "claude-opus-5": { input: 5, output: 25 },
+  "claude-opus-4-8": { input: 5, output: 25 },
+  "claude-opus-4-7": { input: 5, output: 25 },
+  "claude-opus-4-6": { input: 5, output: 25 },
+  "claude-opus-4-5": { input: 5, output: 25 },
+  "claude-sonnet-5": { input: 3, output: 15 },
+  "claude-sonnet-4-6": { input: 3, output: 15 },
+  "claude-sonnet-4-5": { input: 3, output: 15 },
+  "claude-haiku-4-5": { input: 1, output: 5 },
+  // No OpenAI, Google, Moonshot or Alibaba entries on purpose. Their coding
+  // CLIs are sold as subscriptions with model names that do not appear on a
+  // public price list (`gpt-5.6-sol` is what a Codex rollout actually records),
+  // so anything written here would be invented. Price them yourself:
+  //
+  //   ~/.moshcode/pricing.json
+  //   { "gpt-5.6-sol": { "input": 1.25, "output": 10 } }
+};
+
+/**
+ * Cache tokens as a multiple of the input rate: a read is a tenth of a fresh
+ * input token, a five-minute write is a quarter more, a one-hour write is
+ * double. Claude Code's transcript distinguishes the two write TTLs
+ * (`ephemeral_5m_input_tokens` / `ephemeral_1h_input_tokens`), so both are here
+ * rather than one blended guess.
+ */
+export const CACHE_MULTIPLIERS = { read: 0.1, write5m: 1.25, write1h: 2 };
+
+/** Where a user's own rates live. Merged over PRICING, never under it. */
+export const pricingFile = () => path.join(homedir(), ".moshcode", "pricing.json");
+
+/**
+ * User overrides. Never throws — a malformed pricing file must not take down a
+ * cost report, and reporting tokens with no price is already a supported state.
+ */
+export function loadUserPricing(file = pricingFile()) {
+  let raw;
+  try { raw = JSON.parse(fs.readFileSync(file, "utf8")); }
+  catch { return {}; }
+  if (!raw || typeof raw !== "object") return {};
+  const out = {};
+  for (const [model, rate] of Object.entries(raw)) {
+    if (!rate || typeof rate !== "object") continue;
+    const input = Number(rate.input);
+    const output = Number(rate.output);
+    if (!Number.isFinite(input) || !Number.isFinite(output)) continue;
+    const entry = { input, output };
+    if (Number.isFinite(Number(rate.cacheRead))) entry.cacheRead = Number(rate.cacheRead);
+    if (Number.isFinite(Number(rate.cacheWrite))) entry.cacheWrite = Number(rate.cacheWrite);
+    out[String(model).toLowerCase()] = entry;
+  }
+  return out;
+}
+
+/**
+ * The rate card for one model id, or null when nobody has priced it.
+ *
+ * Matching is deliberately forgiving, in three steps, because the string an
+ * engine writes down is not always the string a price list uses:
+ *   1. exact, lowercased — `claude-opus-5`
+ *   2. dated snapshot stripped — `claude-haiku-4-5-20251001` → `claude-haiku-4-5`
+ *   3. longest table key that the model id starts with — so a provider prefix
+ *      (`anthropic/claude-opus-5`, `us.anthropic.claude-opus-5-v1`) still finds
+ *      its rate rather than reading as an unknown model.
+ * A user entry wins at every step: pricing you wrote down beats pricing we
+ * shipped, including for a model we already know.
+ */
+export function rateFor(model, { userPricing = loadUserPricing() } = {}) {
+  if (!model) return null;
+  const id = String(model).trim().toLowerCase();
+  if (!id) return null;
+  const table = { ...PRICING, ...userPricing };
+
+  if (Object.hasOwn(table, id)) return table[id];
+
+  const undated = id.replace(/-\d{8}$/, "");
+  if (undated !== id && Object.hasOwn(table, undated)) return table[undated];
+
+  let best = null;
+  for (const key of Object.keys(table)) {
+    if (!id.includes(key)) continue;
+    if (!best || key.length > best.length) best = key;
+  }
+  return best ? table[best] : null;
+}
+
+/**
+ * Dollars for one usage bundle, or null when the model has no rate.
+ *
+ * `usage` is the shape src/cost.mjs normalises every engine into:
+ * { input, output, cacheRead, cacheWrite5m, cacheWrite1h }. Missing fields are
+ * zero — an engine that never reports cache tokens must not price as NaN.
+ */
+export function priceUsage(model, usage = {}, options = {}) {
+  const rate = rateFor(model, options);
+  if (!rate) return null;
+  const m = 1e6;
+  const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
+  const readRate = rate.cacheRead ?? rate.input * CACHE_MULTIPLIERS.read;
+  const writeRate = rate.cacheWrite ?? rate.input * CACHE_MULTIPLIERS.write5m;
+  const write1hRate = rate.cacheWrite ?? rate.input * CACHE_MULTIPLIERS.write1h;
+  return (
+    (num(usage.input) * rate.input
+      + num(usage.output) * rate.output
+      + num(usage.cacheRead) * readRate
+      + num(usage.cacheWrite5m) * writeRate
+      + num(usage.cacheWrite1h) * write1hRate) / m
+  );
+}
+
+/** Sum usage bundles into one. */
+export function addUsage(a = {}, b = {}) {
+  const keys = ["input", "output", "cacheRead", "cacheWrite5m", "cacheWrite1h"];
+  const out = {};
+  for (const k of keys) out[k] = (Number(a[k]) || 0) + (Number(b[k]) || 0);
+  return out;
+}
+
+export const EMPTY_USAGE = { input: 0, output: 0, cacheRead: 0, cacheWrite5m: 0, cacheWrite1h: 0 };
+
+/** Every token in a bundle, cache included — the "how much did it read" number. */
+export const totalTokens = (u = {}) =>
+  (Number(u.input) || 0) + (Number(u.output) || 0)
+  + (Number(u.cacheRead) || 0) + (Number(u.cacheWrite5m) || 0) + (Number(u.cacheWrite1h) || 0);