codemax-cli 0.0.0-stage → 0.1.1

package/src/core/pty.ts

@@ -0,0 +1,99 @@
+import { termSize } from "./terminal.ts";
+import { IS_WINDOWS } from "./spawn.ts";
+
+const NESTED_SESSION_ENV = /^(CLAUDECODE|CLAUDE_CODE_|CLAUDE_PID|CLAUDE_EFFORT|CODEX_SANDBOX|CODEX_THREAD_ID|CURSOR_AGENT_SESSION)/;
+
+export interface AgentProcessOptions {
+  cmd: string[];
+  cwd: string;
+  env?: Record<string, string>;
+  /** Env vars removed from the child's environment. */
+  dropEnv?: string[];
+  /** Initial PTY size. Defaults to the host terminal size. */
+  cols?: number;
+  rows?: number;
+  onData: (chunk: Uint8Array) => void;
+  onExit: (code: number | null) => void;
+}
+
+/** One agent TUI running inside a Bun PTY. */
+export class AgentProcess {
+  private term: Bun.Terminal;
+  private proc: Bun.Subprocess;
+  private closed = false;
+  readonly startedAt = Date.now();
+
+  constructor(private opts: AgentProcessOptions) {
+    if (IS_WINDOWS) throw new Error("The --tui and --raw modes need a Unix terminal. On Windows, run codemax without them.");
+    const { cols, rows } = opts.cols && opts.rows ? { cols: opts.cols, rows: opts.rows } : termSize();
+    this.term = new Bun.Terminal({
+      cols,
+      rows,
+      data: (_t, chunk) => {
+        if (!this.closed) opts.onData(chunk);
+      },
+    });
+    const env: Record<string, string | undefined> = { ...process.env, TERM: process.env.TERM ?? "xterm-256color", CODEMAX: "1", ...(opts.env ?? {}) };
+    for (const k of opts.dropEnv ?? []) delete env[k];
+    // Never let an agent think it is a child of another agent session
+    // (e.g. codemax started from inside Claude Code).
+    for (const k of Object.keys(env)) if (NESTED_SESSION_ENV.test(k)) delete env[k];
+    this.proc = Bun.spawn(opts.cmd, { cwd: opts.cwd, terminal: this.term, env });
+    this.proc.exited.then((code) => {
+      this.closed = true;
+      try {
+        this.term.close();
+      } catch {
+        /* already closed */
+      }
+      opts.onExit(code);
+    });
+  }
+
+  get pid() {
+    return this.proc.pid;
+  }
+
+  get exited() {
+    return this.closed;
+  }
+
+  write(data: string | Uint8Array) {
+    if (this.closed) return;
+    this.term.write(data);
+  }
+
+  resize(cols: number, rows: number) {
+    if (this.closed) return;
+    try {
+      this.term.resize(cols, rows);
+    } catch {
+      /* ignore */
+    }
+  }
+
+  /** Force a full repaint: most TUIs redraw on SIGWINCH. */
+  jiggle() {
+    const { cols, rows } = termSize();
+    this.resize(Math.max(20, cols - 1), rows);
+    setTimeout(() => this.resize(cols, rows), 30);
+  }
+
+  async kill(graceMs = 1500): Promise<void> {
+    if (this.closed) return;
+    try {
+      this.proc.kill("SIGTERM");
+    } catch {
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        if (!this.closed) this.proc.kill("SIGKILL");
+      } catch {
+        /* ignore */
+      }
+    }, graceMs);
+    await this.proc.exited;
+    clearTimeout(timer);
+  }
+}

package/src/core/quota.ts

@@ -0,0 +1,55 @@
+import type { AgentId, QuotaStatus } from "../adapters/types.ts";
+import { stripAnsi } from "./terminal.ts";
+
+/**
+ * Vendor-neutral phrases. Deliberately narrow: "rate limit" or "429" alone
+ * show up constantly in normal coding work and must not trip the detector.
+ */
+export const GENERIC_QUOTA_PATTERNS = [/usage limit (reached|exceeded)/i, /you['’]ve (hit|reached) your (usage |weekly |session |daily )?limit/i, /insufficient[_ ]quota/i];
+
+/** How long an output-text detection counts before it is forgotten. */
+export const OUTPUT_DETECTION_TTL_MS = 30 * 60_000;
+
+export function isExhausted(q?: QuotaStatus, now = Date.now()): boolean {
+  if (!q?.exhausted) return false;
+  return !q.expiresAt || q.expiresAt > now;
+}
+
+/**
+ * Scans the ANSI-stripped PTY output of one agent for quota exhaustion text.
+ * Keeps a small rolling buffer so matches spanning chunks are still found.
+ */
+export class OutputScanner {
+  private buf = "";
+  private lastHit = 0;
+  constructor(
+    private agent: AgentId,
+    private patterns: RegExp[],
+    private onHit: (q: QuotaStatus) => void,
+    private debounceMs = 60_000,
+  ) {}
+
+  feed(chunk: string) {
+    this.buf = (this.buf + stripAnsi(chunk)).slice(-4096);
+    if (Date.now() - this.lastHit < this.debounceMs) return;
+    for (const re of [...this.patterns, ...GENERIC_QUOTA_PATTERNS]) {
+      const m = this.buf.match(re);
+      if (m) {
+        this.lastHit = Date.now();
+        this.onHit({ agent: this.agent, exhausted: true, source: "output", detail: `text match: "${m[0].slice(0, 80)}"`, at: Date.now(), expiresAt: Date.now() + OUTPUT_DETECTION_TTL_MS });
+        this.buf = "";
+        return;
+      }
+    }
+  }
+}
+
+export function quotaLabel(q?: QuotaStatus): string {
+  if (!q) return "";
+  if (isExhausted(q)) {
+    const reset = q.resetsAt ? ` until ${new Date(q.resetsAt).toLocaleTimeString()}` : "";
+    return q.source === "output" ? `exhausted? (text match)${reset}` : `EXHAUSTED${reset}`;
+  }
+  if (typeof q.usedPercent === "number") return `${Math.round(q.usedPercent)}% used`;
+  return "";
+}

package/src/core/spawn.ts

@@ -0,0 +1,20 @@
+/*
+ * Cross-platform process arguments. On macOS and Linux these return argv
+ * unchanged. On Windows, CLIs installed through npm are `.cmd` shims that
+ * cannot be started directly, so they are resolved through PATH/PATHEXT and
+ * run via cmd.exe; shell commands go to cmd.exe instead of sh.
+ */
+export const IS_WINDOWS = process.platform === "win32";
+
+/** argv ready for Bun.spawn on this platform. */
+export function platformArgv(argv: string[]): string[] {
+  if (!IS_WINDOWS || argv.length === 0) return argv;
+  const [bin, ...rest] = argv as [string, ...string[]];
+  const path = Bun.which(bin) ?? bin;
+  return /\.(cmd|bat)$/i.test(path) ? ["cmd.exe", "/d", "/s", "/c", path, ...rest] : [path, ...rest];
+}
+
+/** argv that runs one shell command line (`!cmd` in the chat). */
+export function shellArgv(cmd: string): string[] {
+  return IS_WINDOWS ? ["cmd.exe", "/d", "/s", "/c", cmd] : ["sh", "-c", cmd];
+}

package/src/core/terminal.ts

@@ -0,0 +1,51 @@
+export const ESC = "\x1b";
+export const CSI = `${ESC}[`;
+
+/**
+ * Put the host terminal back into a sane state after an agent TUI dies.
+ * Agents killed mid-run do not restore anything, so undo every mode a modern
+ * TUI may have switched on: alt screen, mouse, bracketed paste, focus events,
+ * synchronized output, the kitty keyboard protocol and xterm modifyOtherKeys.
+ */
+export const RESET_SEQ = [
+  `${CSI}?2004l`, // bracketed paste off
+  `${CSI}?1000l${CSI}?1002l${CSI}?1003l${CSI}?1005l${CSI}?1006l${CSI}?1015l`, // mouse tracking off
+  `${CSI}?1004l`, // focus events off
+  `${CSI}?2026l`, // synchronized output off
+  `${CSI}<u${CSI}<u${CSI}<u${CSI}<u`, // pop kitty keyboard flags (no-op where unsupported)
+  `${CSI}=0;1u`, // kitty keyboard flags = 0
+  `${CSI}>4;0m`, // xterm modifyOtherKeys off
+  `${CSI}?1l`, // normal cursor keys
+  `${ESC}>`, // numeric keypad
+  `${CSI}?1049l`, // leave alt screen
+  `${CSI}!p`, // DECSTR soft reset (scroll region, origin mode, SGR, cursor visible)
+  `${CSI}r`, // scroll region = full screen
+  `${CSI}?25h`, // show cursor
+  `${CSI}?7h`, // autowrap on
+  `${CSI}0m`, // reset attrs
+].join("");
+
+/** Clear the screen and home the cursor; used before a new agent draws. */
+export const CLEAR_SEQ = `${CSI}2J${CSI}H`;
+
+export const ALT_ON = `${CSI}?1049h${CSI}?25l${CSI}H${CSI}2J`;
+export const ALT_OFF = `${CSI}?25h${CSI}?1049l`;
+
+export const PASTE_START = `${CSI}200~`;
+export const PASTE_END = `${CSI}201~`;
+
+export function stripAnsi(s: string): string {
+  // CSI, OSC, and single-char escapes.
+  return s
+    .replace(/\x1b\][^\x07\x1b]*(\x07|\x1b\\)/g, "")
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+    .replace(/\x1b[@-Z\\-_]/g, "");
+}
+
+export function termSize(): { cols: number; rows: number } {
+  return { cols: process.stdout.columns || 80, rows: process.stdout.rows || 24 };
+}
+
+export const out = (s: string) => {
+  process.stdout.write(s);
+};

package/src/core/usage.ts

@@ -0,0 +1,116 @@
+import type { AgentId } from "../adapters/types.ts";
+import { estimateCost, fmtTokens, fmtUsd, priceFor, priceProvenance } from "./pricing.ts";
+
+/** One usage sample: a model call, a turn, or a delta reported by the agent. */
+export interface UsageRecord {
+  ts: number;
+  agent: AgentId;
+  sessionId: string;
+  model?: string;
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  /** Cost the agent itself reported (OpenCode, Grok do). */
+  agentCostUsd?: number;
+  /** USD frozen at record time so later price changes do not rewrite history. */
+  costUsd?: number;
+  /** Where that figure came from: "agent", "user", "openrouter@2026-10-18", "builtin@…", or "none". */
+  priceSource?: string;
+}
+
+/** Price a fresh record now and freeze the result on it. */
+export function priceRecord(r: UsageRecord): UsageRecord {
+  if (typeof r.agentCostUsd === "number") return { ...r, costUsd: r.agentCostUsd, priceSource: "agent" };
+  const hit = priceFor(r.model);
+  const est = estimateCost(r.model, r);
+  if (hit && est !== null) {
+    const prov = priceProvenance();
+    return { ...r, costUsd: est, priceSource: hit.source === "user" ? "user" : hit.source === "builtin" ? `builtin@${prov.source === "builtin" ? prov.asOf : "2026-10-18"}` : `${hit.source}@${prov.asOf}` };
+  }
+  return { ...r, costUsd: undefined, priceSource: "none" };
+}
+
+export interface UsageTotals {
+  agent: AgentId;
+  models: Set<string>;
+  calls: number;
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  /** API-equivalent USD: agent-reported where available, else estimated from list prices. */
+  costUsd: number;
+  /** True when some records had no price and were counted at $0. */
+  partial: boolean;
+}
+
+export function recordCost(r: UsageRecord): { usd: number; known: boolean } {
+  if (typeof r.agentCostUsd === "number") return { usd: r.agentCostUsd, known: true };
+  if (typeof r.costUsd === "number") return { usd: r.costUsd, known: true };
+  if (r.priceSource === "none") return { usd: 0, known: false };
+  const est = estimateCost(r.model, r); // legacy records without a frozen cost
+  return est === null ? { usd: 0, known: !(r.input || r.output || r.cacheRead || r.cacheWrite) } : { usd: est, known: true };
+}
+
+export function totalsByAgent(records: UsageRecord[]): UsageTotals[] {
+  const map = new Map<AgentId, UsageTotals>();
+  for (const r of records) {
+    let t = map.get(r.agent);
+    if (!t) {
+      t = { agent: r.agent, models: new Set(), calls: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, costUsd: 0, partial: false };
+      map.set(r.agent, t);
+    }
+    if (r.model) t.models.add(r.model);
+    t.calls++;
+    t.input += r.input;
+    t.output += r.output;
+    t.cacheRead += r.cacheRead;
+    t.cacheWrite += r.cacheWrite;
+    const c = recordCost(r);
+    t.costUsd += c.usd;
+    if (!c.known) t.partial = true;
+  }
+  return [...map.values()].sort((a, b) => b.costUsd - a.costUsd);
+}
+
+export function sumCost(records: UsageRecord[]): number {
+  return records.reduce((s, r) => s + recordCost(r).usd, 0);
+}
+
+/** Plain-text table for /usage and `codemax usage`. */
+export function renderUsageTable(records: UsageRecord[], opts: { title: string; sessionId?: string }): string[] {
+  const rows = totalsByAgent(records);
+  const lines: string[] = [];
+  lines.push(`${opts.title} · API-equivalent value at list prices (your subscriptions covered this)`);
+  if (!rows.length) {
+    lines.push("  no usage recorded yet");
+    return lines;
+  }
+  const head = ["agent", "calls", "input", "output", "cache read", "cache write", "est. cost"];
+  const data = rows.map((t) => [
+    t.agent + (t.models.size ? ` (${[...t.models].map(shortModel).join(", ")})` : ""),
+    String(t.calls),
+    fmtTokens(t.input),
+    fmtTokens(t.output),
+    fmtTokens(t.cacheRead),
+    fmtTokens(t.cacheWrite),
+    fmtUsd(t.costUsd) + (t.partial ? "*" : ""),
+  ]);
+  const total = ["total", String(rows.reduce((s, t) => s + t.calls, 0)), fmtTokens(rows.reduce((s, t) => s + t.input, 0)), fmtTokens(rows.reduce((s, t) => s + t.output, 0)), fmtTokens(rows.reduce((s, t) => s + t.cacheRead, 0)), fmtTokens(rows.reduce((s, t) => s + t.cacheWrite, 0)), fmtUsd(rows.reduce((s, t) => s + t.costUsd, 0))];
+  const all = [head, ...data, total];
+  const w = head.map((_, i) => Math.max(...all.map((r) => r[i]!.length)));
+  const fmt = (r: string[]) => "  " + r.map((c, i) => (i === 0 ? c.padEnd(w[i]!) : c.padStart(w[i]!))).join("  ");
+  lines.push(fmt(head));
+  for (const r of data) lines.push(fmt(r));
+  lines.push(fmt(total));
+  if (rows.some((t) => t.partial)) lines.push("  * includes calls on a model with no known price; set it in ~/.codemax/prices.json");
+  const prov = priceProvenance();
+  const agentPriced = records.filter((r) => typeof r.agentCostUsd === "number").length;
+  lines.push(`  prices: ${prov.source} list as of ${prov.asOf}${agentPriced ? ` · ${agentPriced} calls priced by the agent itself` : ""} · each call keeps the rate it was recorded at`);
+  return lines;
+}
+
+export function shortModel(m: string): string {
+  return m.replace(/^claude-/, "").replace(/^(anthropic|openai|xai|google|opencode)\//, "");
+}