pennyrouter 0.3.32 → 0.3.34

package/README.md

@@ -97,6 +97,7 @@ directory to the user PATH:
 
 ```bash
 penny claude
+penny claude --stats
 penny claude desktop
 penny claude desktop gateway
 penny claude desktop native
@@ -108,6 +109,9 @@ penny codex desktop native
 penny opencode
 ```
 
+`penny claude --stats` launches Claude Code with Penny Compare's live single-session token and
+cost readout. Other arguments still pass through, so `penny claude --stats --resume` works.
+
 Arguments are passed through to the native harness, so commands such as `penny claude --resume`,
 `penny codex resume --last`, and `penny opencode --continue` work normally. By default, bare
 `claude`, `codex`, and `opencode` remain

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pennyrouter",
-  "version": "0.3.32",
+  "version": "0.3.34",
   "description": "Install and manage PennyRouter local coding-agent integrations.",
   "homepage": "https://pennyrouter.com",
   "bugs": {

package/src/cli.js

@@ -1595,9 +1595,7 @@ async function selectCodexFundingProviders(flags, selected) {
 
   console.log("PennyRouter can use your ChatGPT subscription, an OpenAI API key, an OpenAI-compatible proxy, or an OpenRouter API key to run Codex.");
   console.log("Choose one or more providers. PennyRouter will try them in order when available.");
-  const options = CODEX_PROVIDER_OPTIONS.filter(
-    ({ id }) => id !== "subscription" || hasChatgptLogin,
-  );
+  const options = CODEX_PROVIDER_OPTIONS;
   return promptFundingProviderCheckboxes(
     options,
     "Which funding source should PennyRouter use for Codex?",
@@ -1703,7 +1701,7 @@ async function configureUserFunding(flags, selected, claudeAnthropicAuth,
       || process.env.PENNYROUTER_ANTHROPIC_PROXY_API_KEY
       || process.env.PENNYROUTER_PROXY_API_KEY || "",
   ).trim();
-  const codexSubscriptionAuth = wantsCodex && codexProviders.has("subscription")
+  let codexSubscriptionAuth = wantsCodex && codexProviders.has("subscription")
     ? await detectCodexChatgptAuth()
     : false;
 
@@ -1729,9 +1727,15 @@ async function configureUserFunding(flags, selected, claudeAnthropicAuth,
     }
   }
   if (wantsCodex && codexProviders.has("subscription") && !codexSubscriptionAuth) {
-    throw new Error(
-      "ChatGPT subscription was selected, but Codex is not logged in. Run `codex login`, or select an API-key provider.",
-    );
+    console.log("Codex needs to sign in to your ChatGPT account. Starting `codex login`...");
+    const login = spawnSync("codex", ["login"], {
+      stdio: "inherit",
+      shell: process.platform === "win32",
+    });
+    if (login.error || login.status !== 0 || !(await detectCodexChatgptAuth())) {
+      throw new Error("Codex login did not complete. Run `codex login`, then rerun `npx pennyrouter install`.");
+    }
+    codexSubscriptionAuth = true;
   }
   if (wantsCodex && codexProviders.has("openai-api") && !openaiApiKey) {
     if (!interactive) throw new Error("OpenAI API was selected, but no key was provided.");
@@ -2129,14 +2133,17 @@ async function selectHarnesses(flags) {
   }
 
   const detected = [];
+  const available = [];
   for (const id of DEFAULT_INSTALL_HARNESS_IDS) {
     const harness = HARNESS_BY_ID[id];
-    if (await safeDetect(harness)) detected.push(harness);
+    const installed = await safeDetect(harness);
+    if (installed) detected.push(harness);
+    available.push({ ...harness, installed });
   }
 
   if (flags.yes) return detected;
 
-  return promptHarnessCheckboxes(detected);
+  return promptHarnessCheckboxes(available, detected);
 }
 
 async function printAdditionalHarnessesHint(selected) {
@@ -2153,10 +2160,14 @@ async function printAdditionalHarnessesHint(selected) {
   console.log(`To use PennyRouter with ${names}, install ${available.length === 1 ? "it" : "them"} and re-run \`npx pennyrouter install\`.`);
 }
 
-async function promptHarnessCheckboxes(detected) {
+async function promptHarnessCheckboxes(available, detected) {
   const detectedIds = new Set(detected.map((harness) => harness.id));
   const selectedIds = new Set(detectedIds);
-  const harnesses = orderedHarnessesForPrompt(detectedIds);
+  const harnesses = orderedHarnessesForPrompt(new Set(available.map((harness) => harness.id)))
+    .map((harness) => ({
+      ...harness,
+      installed: available.find((item) => item.id === harness.id)?.installed ?? false,
+    }));
   if (!input.isTTY || !output.isTTY) return promptHarnessCheckboxesByText(harnesses, selectedIds);
 
   return promptHarnessCheckboxesByKeys(harnesses, selectedIds);
@@ -2178,7 +2189,8 @@ async function promptHarnessCheckboxesByKeys(harnesses, selectedIds) {
     harnesses.forEach((harness, index) => {
       const pointer = index === cursor ? color(">", "cyan") : " ";
       const checked = selectedIds.has(harness.id) ? color("x", "green") : " ";
-      const name = index === cursor ? color(harness.name, "cyan") : harness.name;
+      const label = harness.installed ? harness.name : `${harness.name} (install ${harness.name} first)`;
+      const name = harness.installed && index === cursor ? color(label, "cyan") : label;
       output.write(` ${pointer} [${checked}] ${name}\n`);
     });
     output.write("\nEnter to continue.\n");
@@ -2215,7 +2227,12 @@ async function promptHarnessCheckboxesByKeys(harnesses, selectedIds) {
       }
 
       if (key.name === "space") {
-        const id = harnesses[cursor].id;
+        const harness = harnesses[cursor];
+        if (!harness.installed) {
+          render();
+          return;
+        }
+        const id = harness.id;
         if (selectedIds.has(id)) selectedIds.delete(id);
         else selectedIds.add(id);
         render();
@@ -2242,7 +2259,8 @@ async function promptHarnessCheckboxesByText(harnesses, selectedIds) {
       console.log(color("Where should PennyRouter be installed?", "bold"));
       for (const harness of harnesses) {
         const checked = selectedIds.has(harness.id) ? color("x", "green") : " ";
-        console.log(`  [${checked}] ${harness.name}`);
+        const label = harness.installed ? harness.name : `${harness.name} (install ${harness.name} first)`;
+        console.log(`  [${checked}] ${label}`);
       }
       console.log("");
       const answer = await rl.question(
@@ -2261,6 +2279,11 @@ async function promptHarnessCheckboxesByText(harnesses, selectedIds) {
             console.log(`Unknown tool "${token}".`);
             continue;
           }
+          if (!harnesses.find((harness) => harness.id === id)?.installed) {
+            const unavailable = HARNESS_BY_ID[id];
+            console.log(`Install ${unavailable.name} first to select it.`);
+            continue;
+          }
           if (selectedIds.has(id)) selectedIds.delete(id);
           else selectedIds.add(id);
         }

package/src/launch.js

@@ -1240,6 +1240,25 @@ export function extractProfileArgs(args) {
   return { profile, args: rest };
 }
 
+/**
+ * Remove the launcher-only stats flag while preserving every native harness argument.
+ * A bare `--` ends Penny's option parsing, so a later `--stats` still reaches the harness.
+ */
+export function extractStatsArgs(args) {
+  const rest = [];
+  let stats = false;
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--") {
+      rest.push(...args.slice(i));
+      break;
+    }
+    if (arg === "--stats") stats = true;
+    else rest.push(arg);
+  }
+  return { stats, args: rest };
+}
+
 function assertNoConflictingArgs(harness, args) {
   if (harness === "claude" && args.some((arg) => arg === "--settings" || arg.startsWith("--settings="))) {
     throw new Error("penny claude manages --settings; remove that flag or run native claude.");
@@ -1416,23 +1435,63 @@ async function waitForChild(child) {
   });
 }
 
+/** Launch Penny Claude inside Penny Compare's single-session token readout. */
+export async function runPennyClaudeStats(args, profile) {
+  if (!(process.platform === "darwin" || process.platform === "linux")) {
+    throw new Error("penny claude --stats is supported on macOS and Linux.");
+  }
+  const panePath = join(pennyCompareDir(), "pane.py");
+  try {
+    await stat(panePath);
+  } catch {
+    throw new Error(
+      "Penny's stats display is not installed. Run `npx pennyrouter compare` and try again.",
+    );
+  }
+  const child = spawn("python3", [
+    panePath,
+    "penny-claude",
+    "--side",
+    "single",
+    "--cwd",
+    process.cwd(),
+    "--harness-args-json",
+    JSON.stringify(["--penny-profile", profile, ...args]),
+  ], {
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: "inherit",
+  });
+  const result = await waitForChild(child);
+  if (result.signal) return 128 + (osConstants.signals[result.signal] || 0);
+  return result.code ?? 1;
+}
+
 export async function runPenny(argv = process.argv.slice(2)) {
   const harness = argv[0];
   if (!harness || harness === "help" || harness === "--help" || harness === "-h") {
     console.log("Usage: penny <claude|codex|opencode> [--penny-profile <name>] [native arguments...]");
     console.log("       --private / --cloud select the like-named profile.");
+    console.log("       penny claude --stats adds the live single-session token readout.");
     return 0;
   }
   if (!["claude", "codex", "opencode"].includes(harness)) {
     throw new Error(`Unknown harness "${harness}". Try penny claude, penny codex, or penny opencode.`);
   }
-  const selection = extractProfileArgs(argv.slice(1));
+  const statsSelection = extractStatsArgs(argv.slice(1));
+  if (statsSelection.stats && harness !== "claude") {
+    throw new Error("--stats is currently supported only by penny claude.");
+  }
+  const selection = extractProfileArgs(statsSelection.args);
   argv = [harness, ...selection.args];
   const config = await loadPennyConfig({
     profile: selection.profile,
     requireExisting: Boolean(selection.profile),
   });
   if (harness === "claude" && argv[1]?.toLowerCase() === "desktop") {
+    if (statsSelection.stats) {
+      throw new Error("--stats applies to Claude Code sessions, not Claude Desktop.");
+    }
     const option = argv[2]?.toLowerCase();
     if (option === "--restore" || option === "restore") {
       if (argv.length > 3) {
@@ -1469,6 +1528,9 @@ export async function runPenny(argv = process.argv.slice(2)) {
     }
     return runClaudeDesktop(config, { logs, mode });
   }
+  if (statsSelection.stats) {
+    return runPennyClaudeStats(argv.slice(1), config.profile);
+  }
   if (harness === "codex" && argv[1]?.toLowerCase() === "desktop") {
     const option = argv[2]?.toLowerCase();
     const mode = option === "native" || option === "--native" ? "native" : "gateway";

package/standalone/pane.py

@@ -51,7 +51,7 @@ NATIVE_PROXY_TOKEN_ENV = "PENNY_COMPARE_NATIVE_AUTH_TOKEN"
 class Readout:
     """Paints the fixed block at the top of the pane."""
 
-    def __init__(self, harness, title, delta_path=None, provider=None, label=None,
+    def __init__(self, harness, title, delta_path=None, label=None,
                  session_id=None, side=None, variant=None, pricing_profile="standard"):
         self.harness = harness
         # The pane's fixed role ("NATIVE"/"PENNY"). It keys the files the two panes use to
@@ -60,8 +60,6 @@ class Readout:
         # What the readout actually shows, which the user may rename.
         self.label = label or title
         self.delta_path = delta_path
-        # For Codex, whether this pane's session should be the PennyRouter-routed one.
-        self.provider = provider
         # Claude accepts a caller-supplied session id, so its transcript can be selected exactly
         # instead of inferred from timing, model names, or Penny's global title handoff files.
         self.session_id = session_id
@@ -142,13 +140,14 @@ class Readout:
     def resolve(self):
         """Pin this pane to the transcript its own harness created.
 
-        Both panes run in the same working directory, so the newest session there is ambiguous
-        between them, and resolving by timing alone can label the two backwards.
+        Claude is launched with an explicit session id, making its transcript path deterministic.
+        Codex and OpenCode are selected from files created after this pane launched, narrowed by
+        cwd, with pane claims preventing two local panes from adopting the same transcript.
 
-        Claude is launched with an explicit session id, making both its native and Penny
-        transcript paths deterministic. Codex has no equivalent launch flag, but records the
-        provider in its session header, so each Codex pane takes the session matching how it was
-        started.
+        Do not filter Codex by provider here. Subscription-backed Penny sessions deliberately
+        record ``model_provider = openai``, and a hosted gateway cannot create a claim file on
+        this machine. That filter rejects the correct local JSONL for both penny-session and the
+        normal compare layout, where cwd/time/claiming already identify it.
         """
         if self.path and os.path.exists(self.path):
             return self.path
@@ -163,8 +162,7 @@ class Readout:
         # session, so require one created afterwards rather than adopting the newest on disk.
         taken = self._peers() | self._preexisting
         candidate = newest_session(self.harness, os.getcwd(),
-                                   since=self.started, exclude=taken,
-                                   provider=self.provider)
+                                   since=self.started, exclude=taken)
         if candidate and not self._claim(candidate):
             return None
         self.path = candidate
@@ -346,6 +344,8 @@ def main():
                         help="start both panes on one model so the comparison is like for like")
     parser.add_argument("--label", default=None,
                         help="name shown on this pane's readout (default: NATIVE or PENNY)")
+    parser.add_argument("--cwd", default=None,
+                        help="working directory selected by the compare launcher")
     parser.add_argument("--side", choices=("left", "right", "single"),
                         help="stable pane position used by the final report")
     parser.add_argument("--pricing-profile", choices=("standard", "govcloud"),
@@ -353,8 +353,26 @@ def main():
     parser.add_argument("--native-proxy", action="store_true",
                         help=f"route the NATIVE pane through {NATIVE_PROXY_URL_ENV} / "
                              f"{NATIVE_PROXY_TOKEN_ENV} instead of going direct")
+    parser.add_argument("--harness-args-json", default="[]",
+                        help=argparse.SUPPRESS)
     args = parser.parse_args()
 
+    try:
+        harness_args = json.loads(args.harness_args_json)
+        if not isinstance(harness_args, list) or not all(
+                isinstance(value, str) for value in harness_args):
+            raise ValueError("expected a JSON array of strings")
+    except (json.JSONDecodeError, ValueError) as error:
+        sys.stderr.write(f"penny-compare: invalid harness arguments: {error}\n")
+        return 2
+
+    if args.cwd:
+        try:
+            os.chdir(os.path.expanduser(args.cwd))
+        except OSError as error:
+            sys.stderr.write(f"penny-compare: cannot enter {args.cwd}: {error}\n")
+            return 1
+
     harness, command, title = VARIANTS[args.variant]
     session_id = None
     if harness == "claude-code":
@@ -364,20 +382,14 @@ def main():
         # Passed to the harness rather than set in the environment, so Penny's own model
         # configuration is not overridden on the penny side.
         command = command + ["--model", args.model]
+    command = command + harness_args
 
     rows = shutil.get_terminal_size().lines
     # Reserve the top rows for the readout and confine scrolling to what is left.
     sys.stdout.write(f"\033[2J\033[{hud.ROWS + 1};{rows}r\033[{hud.ROWS + 1};1H")
     sys.stdout.flush()
 
-    # Codex and OpenCode have no caller-assigned session id, so they identify their transcript by the provider
-    # recorded in the session header instead.
-    is_penny = command[0] == "penny"
     readout = Readout(harness, title, args.delta_file,
-                      # OpenCode owns provider/model selection inside its own TUI. The
-                      # penny-opencode spelling is only a launch convenience, not a reliable
-                      # provider identity like Codex's session header is.
-                      provider=is_penny if harness == "codex" else None,
                       label=args.label,
                       session_id=session_id,
                       side=args.side,

package/standalone/penny-compare

@@ -236,6 +236,8 @@ workdir_left="${dir_left:-$PWD/native}"
 workdir_left="${workdir_left/#\~/$HOME}"
 workdir_right="${dir_right:-$PWD/penny}"
 workdir_right="${workdir_right/#\~/$HOME}"
+workdir_left_arg=" --cwd $(printf '%q' "$workdir_left")"
+workdir_right_arg=" --cwd $(printf '%q' "$workdir_right")"
 
 # --native-proxy only means anything on a NATIVE Claude or Codex pane;
 # a penny-* pane already owns its own proxy routing and ignores the flag either way.
@@ -265,10 +267,10 @@ wire_args="${wire:+ $wire}${wire_both:+ $wire_both}${wire_https:+ $wire_https}"
 
 tmux new-session -d -s "$session" -c "$workdir_left" -x "$(tput cols)" -y "$(tput lines)" \
   -e PENNY_COMPARE_STATE="$state" \
-  "$here/pane.py $left --side left --pricing-profile $pricing_profile${model:+ --model $model}${native_proxy_left:+ $native_proxy_left}${label_left_arg}${wire_args}"
+  "$here/pane.py $left --side left --pricing-profile $pricing_profile${workdir_left_arg}${model:+ --model $model}${native_proxy_left:+ $native_proxy_left}${label_left_arg}${wire_args}"
 tmux split-window -h -t "$session" -c "$workdir_right" \
   -e PENNY_COMPARE_STATE="$state" \
-  "$here/pane.py $right --side right --pricing-profile $pricing_profile --delta-file $delta${model:+ --model $model}${native_proxy_right:+ $native_proxy_right}${label_right_arg}${wire_args}"
+  "$here/pane.py $right --side right --pricing-profile $pricing_profile --delta-file $delta${workdir_right_arg}${model:+ --model $model}${native_proxy_right:+ $native_proxy_right}${label_right_arg}${wire_args}"
 
 # The comparison belongs to neither pane, so a small watcher derives it from both.
 tmux new-window -d -t "$session" -n delta "$here/delta.py '$state' '$delta'"