pennyrouter 0.3.37 → 0.3.39

package/standalone/web-demo/README.md

@@ -21,10 +21,10 @@ To run the current Penny Compare measurement code in the panes:
 npm start -- --compare
 ```
 
-This starts native Claude on the left and `penny claude` on the right. On macOS/Linux, it uses the existing Python session reader, cost model, HUD, and delta calculation. On Windows, it reads Claude transcripts and prices calls in Node, with no Python or tmux requirement. Exit saves a JSON report under `apps/compare/reports` and prints the summary in the left pane. Both platforms need Claude Code and the `penny` command on `PATH`.
+This opens a setup screen with the same Claude/Codex pane choices, directories, labels, and shared model selection as the classic launcher. The default is native Claude on the left and Penny Claude on the right, using `<current directory>/native` and `<current directory>/penny`. On macOS/Linux, it uses the existing Python session reader, cost model, HUD, and delta calculation. On Windows, it reads Claude or Codex transcripts and prices calls in Node, with no Python or tmux requirement. Exit saves a JSON report under `apps/compare/reports` and shows the final summary. The selected harness commands must be on `PATH`.
 
-The Windows path currently supports Claude Code comparisons. Codex and OpenCode transcript readers are still in the Python path.
+Use `--harness=codex` to preselect Codex in the setup screen. The pane selectors can also mix Claude and Codex; the shared model control is available when both panes use the same harness family.
 
-To exercise the Windows measurement path on macOS/Linux, use `npm start -- --compare-node`.
+To exercise the Node measurement paths on macOS/Linux, use `npm start -- --compare-node --harness=claude` for Claude or `npm start -- --compare-node --harness=codex` for Codex. Claude is the default if you omit `--harness`.
 
 The demo requires Claude Code on `PATH` for that option. Closing or reloading the page ends both sessions. The local server listens only on `127.0.0.1`; it does not start a PennyRouter gateway.

package/standalone/web-demo/claude-meter.mjs

@@ -1,18 +1,44 @@
+import { readFileSync } from 'node:fs';
 import { mkdir, open, readdir, stat, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-// Mirrors the standard Claude rates in ../pricing.py (USD per token).
-const rates = {
-  'claude-opus-5': [5e-6, .5e-6, 6.25e-6, 10e-6, 25e-6],
-  'claude-sonnet-5': [3e-6, .3e-6, 3.75e-6, 6e-6, 15e-6],
-  'claude-haiku-4-5': [1e-6, .1e-6, 1.25e-6, 2e-6, 5e-6],
-};
+// Standard per-token rates from ../rates.json (scripts/generate_compare_rates.py), the same
+// file pricing.py reads. Each rate list is [input, cache read, cache write 5m, cache write 1h,
+// output]; a model may carry an `above` list that applies once one request's input context
+// exceeds its threshold.
+const { models } = JSON.parse(readFileSync(new URL('../rates.json', import.meta.url), 'utf8'));
 
-function rateFor(model) {
-  const normalized = String(model || '').replace(/^.*\//, '').replace('[1m]', '');
-  const key = Object.keys(rates).find((name) => normalized.startsWith(name));
-  return rates[key] || rates['claude-sonnet-5'];
+function longestPrefix(name, table) {
+  const keys = Object.keys(table).filter((key) => name.startsWith(key));
+  return keys.sort((a, b) => b.length - a.length)[0];
+}
+
+function rateFor(model, contextTokens = 0) {
+  const normalized = String(model || '').replace(/^.*\//, '').replace('[1m]', '').trim();
+  const entry = models[longestPrefix(normalized, models)] || models['claude-sonnet-5'];
+  return entry.above && contextTokens > entry.above.threshold ? entry.above.rates : entry.rates;
+}
+
+// Codex's session_meta line embeds the full base instructions (~20 KB), so a fixed small
+// read truncates it mid-JSON. Read until the first newline, bounded.
+async function readFirstLine(path, limit = 1024 * 1024) {
+  const handle = await open(path, 'r');
+  try {
+    const chunks = [];
+    const buffer = Buffer.alloc(16 * 1024);
+    let position = 0;
+    while (position < limit) {
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+      if (!bytesRead) break;
+      const chunk = buffer.subarray(0, bytesRead);
+      const newline = chunk.indexOf(10);
+      if (newline >= 0) { chunks.push(Buffer.from(chunk.subarray(0, newline))); break; }
+      chunks.push(Buffer.from(chunk));
+      position += bytesRead;
+    }
+    return Buffer.concat(chunks).toString('utf8');
+  } finally { await handle.close(); }
 }
 
 function emptyTotals() {
@@ -21,11 +47,13 @@ function emptyTotals() {
 }
 
 export class ClaudeMeter {
-  constructor({ sessionId, cwd, side, role }) {
+  constructor({ sessionId, cwd, side, role, label, variant }) {
     this.sessionId = sessionId;
     this.cwd = cwd;
     this.side = side;
     this.role = role;
+    this.label = label || role;
+    this.variant = variant;
     this.root = join(homedir(), '.claude', 'projects');
     this.files = new Map();
     this.ids = new Set();
@@ -54,17 +82,12 @@ export class ClaudeMeter {
       for (const entry of entries) {
         if (!entry.endsWith('.jsonl')) continue;
         const path = join(this.root, project.name, entry);
-        let handle;
         try {
-          handle = await open(path, 'r');
-          const buffer = Buffer.alloc(4096);
-          const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-          const first = buffer.subarray(0, bytesRead).toString('utf8').split('\n', 1)[0];
-          if (JSON.parse(first).sessionId === this.sessionId) {
+          if (JSON.parse(await readFirstLine(path)).sessionId === this.sessionId) {
             this.transcriptPath = path;
             return path;
           }
-        } catch { /* next */ } finally { await handle?.close(); }
+        } catch { /* next */ }
       }
     }
     return null;
@@ -118,7 +141,7 @@ export class ClaudeMeter {
         const input = Number(usage.input_tokens) || 0;
         const output = Number(usage.output_tokens) || 0;
         const model = message.model || this.model;
-        const prices = rateFor(model);
+        const prices = rateFor(model, read + write + input);
         const cost = input * prices[0] + read * prices[1] + write5 * prices[2] +
           write1 * prices[3] + output * prices[4];
         const call = { timestamp: obj.timestamp || null, recorded_at: Date.now() / 1000,
@@ -146,16 +169,112 @@ export class ClaudeMeter {
   }
 
   snapshot() {
-    return { side: this.side, role: this.role, label: this.role, variant: this.side === 'left' ? 'claude' : 'penny-claude',
+    return { side: this.side, role: this.role, label: this.label, variant: this.variant,
       harness: 'claude-code', cwd: this.cwd, pricing_profile: 'standard', session_id: this.sessionId,
       transcript_path: this.transcriptPath, model: this.model, call_count: this.calls.length,
       totals: { ...this.totals } };
   }
 }
 
+// Codex writes cumulative token_count snapshots to dated rollout JSONL files.
+// Keep a cursor per transcript and charge each snapshot's delta once.
+export class CodexMeter extends ClaudeMeter {
+  constructor(options) {
+    super(options);
+    this.root = join(homedir(), '.codex', 'sessions');
+    this.transcriptPath = null;
+    this.previous = null;
+    this.started = Date.now() / 1000;
+  }
+
+  async findTranscript() {
+    if (this.transcriptPath) return this.transcriptPath;
+    const visit = async (directory) => {
+      let entries;
+      try { entries = await readdir(directory, { withFileTypes: true }); } catch { return []; }
+      const found = [];
+      for (const entry of entries) {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory()) found.push(...await visit(path));
+        else if (entry.name.endsWith('.jsonl')) {
+          try {
+            const meta = JSON.parse(await readFirstLine(path)).payload;
+            const info = await stat(path);
+            const expectedProvider = this.role === 'NATIVE' ? 'openai' : 'pennyrouter';
+            if (meta?.cwd && meta.cwd.toLowerCase() === this.cwd.toLowerCase() &&
+                meta.model_provider === expectedProvider &&
+                info.mtimeMs / 1000 >= this.started - 3) found.push([path, info.mtimeMs]);
+          } catch { /* incomplete or unrelated rollout */ }
+        }
+      }
+      return found;
+    };
+    const candidates = await visit(this.root);
+    candidates.sort((a, b) => b[1] - a[1]);
+    this.transcriptPath = candidates[0]?.[0] || null;
+    return this.transcriptPath;
+  }
+
+  async poll() {
+    const path = await this.findTranscript();
+    if (!path) return this.snapshot();
+    let size;
+    try { ({ size } = await stat(path)); } catch { return this.snapshot(); }
+    let offset = this.files.get(path) || 0;
+    if (size < offset) { offset = 0; this.previous = null; }
+    if (size === offset) return this.snapshot();
+    const handle = await open(path, 'r');
+    try {
+      const buffer = Buffer.alloc(size - offset);
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, offset);
+      const text = buffer.subarray(0, bytesRead).toString('utf8');
+      const end = text.lastIndexOf('\n');
+      if (end < 0) return this.snapshot();
+      this.files.set(path, offset + Buffer.byteLength(text.slice(0, end + 1)));
+      for (const line of text.slice(0, end).split('\n')) {
+        let obj;
+        try { obj = JSON.parse(line); } catch { continue; }
+        const payload = obj.payload;
+        if (obj.type === 'turn_context' && payload?.model) this.model = payload.model;
+        if (payload?.type !== 'token_count' || !payload.info?.total_token_usage) continue;
+        const total = payload.info.total_token_usage;
+        const fingerprint = ['input_tokens', 'cached_input_tokens', 'cache_write_input_tokens',
+          'output_tokens', 'reasoning_output_tokens'].map((key) => Number(total[key]) || 0);
+        if (this.previous && fingerprint.every((value, index) => value === this.previous[index])) continue;
+        const delta = fingerprint.map((value, index) => Math.max(0, value - (this.previous?.[index] || 0)));
+        this.previous = fingerprint;
+        const [input, cached, write, output, reasoning] = delta;
+        const fresh = Math.max(0, input - cached - write);
+        const context = Number(payload.info.last_token_usage?.input_tokens) || input;
+        const prices = rateFor(this.model, context);
+        const cost = fresh * prices[0] + cached * prices[1] + write * prices[2] + output * prices[4];
+        const call = { timestamp: obj.timestamp || null, recorded_at: Date.now() / 1000,
+          model: this.model, cache_read: cached, cache_write: write, write_5m: write,
+          write_1h: 0, fresh_input: fresh, output, reasoning_output: reasoning,
+          total: input + output, cost, context_tokens: context, pricing_profile: 'standard',
+          rates_per_million: Object.fromEntries(
+            ['input', 'cache_read', 'cache_write_5m', 'cache_write_1h', 'output']
+              .map((name, index) => [name, prices[index] * 1_000_000])) };
+        this.calls.push(call);
+        this.totals.cache_read += cached; this.totals.cache_write += write;
+        this.totals.write_5m += write; this.totals.fresh_input += fresh;
+        this.totals.output += output; this.totals.reasoning_output += reasoning;
+        this.totals.total += call.total; this.totals.cost += cost;
+      }
+    } finally { await handle.close(); }
+    return this.snapshot();
+  }
+
+  snapshot() {
+    return { ...super.snapshot(), variant: this.side === 'left' ? 'codex' : 'penny-codex',
+      harness: 'codex', transcript_path: this.transcriptPath };
+  }
+}
+
 export async function saveReport(left, right, reportsDir) {
-  const native = left.snapshot();
-  const penny = right.snapshot();
+  const sides = [left.snapshot(), right.snapshot()];
+  const native = sides.find((side) => side.role === 'NATIVE') || sides[0];
+  const penny = sides.find((side) => side.role === 'PENNY') || sides[1];
   const savings = {
     cost: native.totals.cost - penny.totals.cost,
     tokens: native.totals.total - penny.totals.total,

package/standalone/web-demo/server.mjs

@@ -1,29 +1,32 @@
 import { createServer } from 'node:http';
 import { randomUUID } from 'node:crypto';
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { spawn, execFile } from 'node:child_process';
-import { join, dirname } from 'node:path';
-import { tmpdir } from 'node:os';
+import { join, dirname, resolve } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
 import { WebSocketServer } from 'ws';
 import pty from 'node-pty';
-import { ClaudeMeter, saveReport } from './claude-meter.mjs';
+import { ClaudeMeter, CodexMeter, saveReport } from './claude-meter.mjs';
 
 const here = dirname(fileURLToPath(import.meta.url));
 const compareDir = dirname(here);
 const execFileAsync = promisify(execFile);
 const args = process.argv.slice(2);
 const claude = args.includes('--claude');
+const harnessArg = args.find((arg) => /^--harness=(claude|codex)$/.test(arg));
+const startupHarness = harnessArg?.slice('--harness='.length) || 'claude';
 const nodeMeter = args.includes('--compare-node') ||
   (args.includes('--compare') && process.platform === 'win32');
 const compare = args.includes('--compare') || nodeMeter;
 const pythonCompare = compare && !nodeMeter && process.platform !== 'win32';
 const portArg = args.find((arg) => /^--port=\d+$/.test(arg));
 const port = Number(portArg?.slice(7) ?? 8789);
-if (args.some((arg) => !['--claude', '--compare', '--compare-node', portArg].includes(arg)) ||
-    (claude && compare) || port < 1 || port > 65535) {
-  console.error('Usage: npm start -- [--claude | --compare | --compare-node] [--port=8789]');
+if (args.some((arg) => !['--claude', '--compare', '--compare-node', '--harness=claude', '--harness=codex', portArg].includes(arg)) ||
+    (claude && compare) || (harnessArg && !compare) ||
+    (args.includes('--harness=claude') && args.includes('--harness=codex')) || port < 1 || port > 65535) {
+  console.error('Usage: npm start -- [--claude | --compare [--harness=claude|codex] | --compare-node [--harness=claude|codex]] [--port=8789]');
   process.exit(1);
 }
 
@@ -38,7 +41,13 @@ const server = createServer(async (request, response) => {
   const file = files.get(request.url);
   if (!file) { response.writeHead(404).end(); return; }
   try {
-    const body = await readFile(join(here, file[0]));
+  let body = await readFile(join(here, file[0]));
+  if (request.url === '/') {
+    body = body.toString('utf8')
+      .replace('__PENNY_CWD__', JSON.stringify(process.cwd()).replaceAll('<', '\\u003c'))
+      .replace('__PENNY_COMPARE__', JSON.stringify(compare))
+      .replace('__PENNY_DEFAULT_HARNESS__', JSON.stringify(startupHarness));
+  }
     response.writeHead(200, { 'Content-Type': file[1], 'Cache-Control': 'no-store' }).end(body);
   } catch (error) {
     console.error(error);
@@ -57,22 +66,46 @@ server.on('upgrade', (request, socket, head) => {
   wss.handleUpgrade(request, socket, head, (ws) => wss.emit('connection', ws));
 });
 
-function launchCommand(side, state, sessionId) {
+const variants = new Set(['claude', 'penny-claude', 'codex', 'penny-codex']);
+const safeModel = /^[A-Za-z0-9._/-]{1,160}$/;
+
+async function validateConfig(config) {
+  const codexModels = ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna', 'gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini'];
+  const claudeModels = ['opus', 'sonnet', 'haiku', 'fable'];
+  if (!config || !variants.has(config.variant) || typeof config.cwd !== 'string' ||
+      config.cwd.length > 4096 || typeof config.label !== 'string' || config.label.length > 80 ||
+      typeof config.model !== 'string' || (config.model && !safeModel.test(config.model)) ||
+      (config.model && config.variant.includes('codex') && !codexModels.includes(config.model)) ||
+      (config.model && !config.variant.includes('codex') &&
+        !claudeModels.includes(config.model) && !config.model.startsWith('claude-'))) {
+    throw new Error('Invalid compare settings. Choose Claude or Codex, a directory, and a valid model name.');
+  }
+  const expanded = config.cwd.startsWith('~/') ? join(homedir(), config.cwd.slice(2)) : config.cwd;
+  const cwd = resolve(expanded);
+  if (!(await stat(cwd)).isDirectory()) throw new Error(`Directory does not exist: ${cwd}`);
+  return { ...config, cwd };
+}
+
+function launchCommand(side, state, sessionId, config) {
   if (pythonCompare) {
-    const variant = side === 'left' ? 'claude' : 'penny-claude';
-    const args = [join(compareDir, 'pane.py'), variant, '--side', side,
-      '--cwd', process.cwd(), '--pricing-profile', 'standard'];
+    const args = [join(compareDir, 'pane.py'), config.variant, '--side', side,
+      '--cwd', config.cwd, '--pricing-profile', 'standard'];
+    if (config.model) args.push('--model', config.model);
+    if (config.label) args.push('--label', config.label);
     if (side === 'right') args.push('--delta-file', join(state, 'delta.txt'));
     return ['python3', args];
   }
   if (nodeMeter) {
+    const codex = config.variant.includes('codex');
+    const command = config.variant.startsWith('penny-')
+      ? `penny ${codex ? 'codex' : 'claude'}` : (codex ? 'codex' : 'claude');
+    const modelArg = config.model ? ` --model ${config.model}` : '';
     if (process.platform === 'win32') {
       const shell = process.env.ComSpec || 'cmd.exe';
-      return [shell, ['/d', '/s', '/c', side === 'left'
-        ? `claude --session-id ${sessionId}` : `penny claude --session-id ${sessionId}`]];
+      return [shell, ['/d', '/s', '/c', `${command}${codex ? '' : ` --session-id ${sessionId}`}${modelArg}`]];
     }
     const shell = process.env.SHELL || '/bin/sh';
-    return [shell, ['-lc', `exec ${side === 'left' ? 'claude' : 'penny claude'} --session-id ${sessionId}`]];
+    return [shell, ['-lc', `exec ${command}${codex ? '' : ` --session-id ${sessionId}`}${modelArg}`]];
   }
   if (process.platform === 'win32') {
     const shell = process.env.ComSpec || 'cmd.exe';
@@ -84,6 +117,7 @@ function launchCommand(side, state, sessionId) {
 
 wss.on('connection', (ws) => {
   const sessions = new Map();
+  const compareConfig = new Map();
   const meters = new Map();
   const snapshots = new Map();
   let state;
@@ -135,6 +169,23 @@ wss.on('connection', (ws) => {
   const handle = async (raw) => {
     let message;
     try { message = JSON.parse(raw); } catch { return; }
+    if (message.type === 'configure') {
+      try {
+        if (!compare) throw new Error('Compare setup is unavailable in shell demo mode.');
+        const left = await validateConfig(message.config?.left);
+        const right = await validateConfig(message.config?.right);
+        if (left.model && left.variant.includes('codex') !== right.variant.includes('codex')) {
+          throw new Error('Choose the same model family for both panes, or leave Model set to default.');
+        }
+        compareConfig.set('left', left);
+        compareConfig.set('right', right);
+        send({ type: 'configured' });
+      } catch (error) {
+        compareConfig.clear();
+        send({ type: 'configuration-error', error: error.message });
+      }
+      return;
+    }
     if (message.type === 'exit') {
       if (exiting) return;
       exiting = true;
@@ -166,6 +217,10 @@ wss.on('connection', (ws) => {
     if (message.type === 'start' && !sessions.has(message.side) &&
         size(message.cols, 500) && size(message.rows, 200)) {
       try {
+        const config = compare
+          ? compareConfig.get(message.side)
+          : { variant: 'claude', cwd: process.cwd(), label: '', model: '' };
+        if (!config) throw new Error('Choose and validate both compare panes before starting.');
         await ready;
         if (closed) return;
         if (pythonCompare && !delta) {
@@ -173,8 +228,8 @@ wss.on('connection', (ws) => {
             { stdio: 'ignore' });
           delta.on('error', (error) => send({ type: 'error', side: 'right', error: error.message }));
         }
-        const sessionId = nodeMeter ? randomUUID() : undefined;
-        const [command, commandArgs] = launchCommand(message.side, state, sessionId);
+        const sessionId = nodeMeter && !config.variant.includes('codex') ? randomUUID() : undefined;
+        const [command, commandArgs] = launchCommand(message.side, state, sessionId, config);
         const env = { ...process.env, TERM: 'xterm-256color',
           ...(pythonCompare ? { PENNY_COMPARE_STATE: state } : {}) };
         if (compare && message.side === 'left') {
@@ -184,12 +239,14 @@ wss.on('connection', (ws) => {
         }
         const session = pty.spawn(command, commandArgs, {
           name: 'xterm-256color', cols: message.cols, rows: message.rows,
-          cwd: process.cwd(), env,
+          cwd: config.cwd, env,
         });
         sessions.set(message.side, session);
         if (nodeMeter) {
-          meters.set(message.side, new ClaudeMeter({ sessionId, cwd: process.cwd(),
-            side: message.side, role: message.side === 'left' ? 'NATIVE' : 'PENNY' }));
+          const Meter = config.variant.includes('codex') ? CodexMeter : ClaudeMeter;
+          const role = config.variant.startsWith('penny-') ? 'PENNY' : 'NATIVE';
+          meters.set(message.side, new Meter({ sessionId, cwd: config.cwd,
+            side: message.side, role, label: config.label, variant: config.variant }));
           send({ type: 'meter-mode' });
           if (!meterTimer) meterTimer = setInterval(() => { void pollMeters(); }, 1000);
         }
@@ -216,12 +273,17 @@ wss.on('connection', (ws) => {
 server.listen(port, '127.0.0.1', () => {
   const url = `http://127.0.0.1:${port}`;
   console.log(`Penny Compare live terminal demo: ${url}`);
-  console.log(compare ? 'Native Claude and Penny Claude panes with transcript HUDs.' :
-    claude ? 'Each pane starts Claude Code.' : 'Each pane starts a shell. Type claude to run Claude Code.');
+  console.log(compare
+    ? `Compare setup ready (${pythonCompare ? 'Python session metering' : 'Node transcript metering'}). Choose both panes in the browser.`
+    : claude ? 'Each pane starts Claude Code.' : 'Each pane starts a shell. Type claude to run Claude Code.');
   if (process.platform === 'win32') {
     execFile(process.env.ComSpec || 'cmd.exe', ['/d', '/s', '/c', `start "" "${url}"`],
       { windowsHide: true }, (error) => {
         if (error) console.error(`Could not open the browser automatically: ${error.message}`);
       });
+  } else {
+    execFile(process.platform === 'darwin' ? 'open' : 'xdg-open', [url], (error) => {
+      if (error) console.error(`Could not open the browser automatically: ${error.message}`);
+    });
   }
 });