pennyrouter 0.1.11 → 0.1.13

package/package.json

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

package/src/cli.js

@@ -1,4 +1,4 @@
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { emitKeypressEvents } from "node:readline";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
@@ -234,6 +234,41 @@ function readAnthropicOAuthToken(flags = {}) {
   return { token: normalizeAnthropicToken(result.stdout), source: "ant" };
 }
 
+// ANSI/CSI escape sequences that `claude setup-token`'s TUI emits (colors, cursor
+// moves, bracketed-paste). We strip these before scanning for the token so a match
+// isn't split by control bytes. Kept deliberately broad.
+// eslint-disable-next-line no-control-regex
+const ANSI_ESCAPE_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+// The token line printed by `claude setup-token`. Match any sk-ant-* token so we don't
+// depend on the exact variant/version (e.g. sk-ant-oat01-...).
+const ANTHROPIC_SETUP_TOKEN_RE = /sk-ant-[A-Za-z0-9_-]+/;
+
+// Run `claude setup-token` inline and extract the token it prints. The command is a
+// full-screen TUI (ANSI art + banner) that also prints the real token on a line like
+// "sk-ant-oat01-...". We pipe stdout so we can read it, but tee every chunk straight
+// back to the terminal so the user still sees the whole flow (including "you won't be
+// able to see it again"). stdin/stderr inherit the TTY for the interactive parts. After
+// exit we ANSI-strip the captured stdout and regex out the token. Returns "" on
+// non-zero exit or if no token line was found, so the caller falls back to paste.
+function runClaudeSetupToken() {
+  return new Promise((resolve) => {
+    let captured = "";
+    const child = spawn("claude", ["setup-token"], {
+      stdio: ["inherit", "pipe", "inherit"],
+    });
+    child.stdout.on("data", (chunk) => {
+      captured += chunk.toString("utf8");
+      output.write(chunk); // tee: keep the TUI visible to the user
+    });
+    child.on("error", () => resolve(""));
+    child.on("close", (code) => {
+      if (code !== 0) return resolve("");
+      const match = captured.replace(ANSI_ESCAPE_RE, "").match(ANTHROPIC_SETUP_TOKEN_RE);
+      resolve(match ? match[0] : "");
+    });
+  });
+}
+
 function normalizeAnthropicToken(value) {
   let text = String(value || "").trim();
   if (!text) return "";
@@ -373,7 +408,17 @@ async function maybeConfigureClaudeAnthropicAuth(flags, selected) {
 
   console.log("");
   if (commandExists("claude")) {
-    console.log("Run `claude setup-token` in another terminal, then paste the token here.");
+    // The user already opted into subscription auth above, so run `claude setup-token`
+    // directly and capture the token — no copy-paste, no second confirm. The command
+    // opens the browser for approval inline. On failure we fall through to manual paste.
+    console.log("Launching `claude setup-token` — approve in your browser when prompted.");
+    const captured = await runClaudeSetupToken();
+    if (captured) {
+      console.log("");
+      return { token: captured, source: "setup-token" };
+    }
+    console.log("");
+    console.log("Couldn't capture a token automatically. Paste it below, or leave blank to skip.");
   } else {
     console.log("Claude Code was not found on PATH. Paste an Anthropic bearer token, or leave blank to skip.");
   }

package/src/harnesses/claude-code.js

@@ -1,4 +1,5 @@
 import { atomicWrite, backupFile, compactHome, exists, expandHome, readJsonFile } from "../state.js";
+import { configureClaudeCodeStatusline, restoreClaudeCodeStatusline } from "../statusline.js";
 
 const CONFIG_PATH = "~/.claude/settings.json";
 const LEGACY_MODEL_LABEL = "PennyRouter Bundle";
@@ -56,6 +57,8 @@ export const claudeCodeHarness = {
     current.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = CLAUDE_CODE_MODELS.haiku;
     current.env.ANTHROPIC_DEFAULT_FABLE_MODEL = CLAUDE_CODE_MODELS.custom;
 
+    const statusline = await configureClaudeCodeStatusline(current);
+
     await atomicWrite(CONFIG_PATH, `${JSON.stringify(current, null, 2)}\n`);
 
     return {
@@ -64,6 +67,7 @@ export const claudeCodeHarness = {
       backup_path: backupPath ? compactHome(backupPath) : null,
       installed_at: new Date().toISOString(),
       restart: "restart Claude Code",
+      statusline: statusline.wrapped ? "wrapped-existing" : "installed",
       changes: {
         env_keys: [
           "ANTHROPIC_BASE_URL",
@@ -95,6 +99,8 @@ export const claudeCodeHarness = {
     current.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = CLAUDE_CODE_MODELS.haiku;
     current.env.ANTHROPIC_DEFAULT_FABLE_MODEL = CLAUDE_CODE_MODELS.custom;
 
+    const statusline = await configureClaudeCodeStatusline(current);
+
     await atomicWrite(CONFIG_PATH, `${JSON.stringify(current, null, 2)}\n`);
 
     return {
@@ -103,6 +109,7 @@ export const claudeCodeHarness = {
       backup_path: backupPath ? compactHome(backupPath) : null,
       installed_at: new Date().toISOString(),
       restart: "restart Claude Code",
+      statusline: statusline.wrapped ? "wrapped-existing" : "installed",
       changes: {
         env_keys: [
           "ANTHROPIC_BASE_URL",
@@ -130,6 +137,8 @@ export const claudeCodeHarness = {
     current.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = CLAUDE_CODE_MODELS.haiku;
     current.env.ANTHROPIC_DEFAULT_FABLE_MODEL = CLAUDE_CODE_MODELS.custom;
 
+    const statusline = await configureClaudeCodeStatusline(current);
+
     await atomicWrite(CONFIG_PATH, `${JSON.stringify(current, null, 2)}\n`);
     return {
       harness: "claude-code",
@@ -137,6 +146,7 @@ export const claudeCodeHarness = {
       backup_path: backupPath ? compactHome(backupPath) : null,
       installed_at: new Date().toISOString(),
       restart: "restart Claude Code",
+      statusline: statusline.wrapped ? "wrapped-existing" : "installed",
       changes: {
         env_keys: [
           "ANTHROPIC_BASE_URL",
@@ -188,6 +198,8 @@ export const claudeCodeHarness = {
       delete current["anthropic.apiKey"];
     }
     if (current.env && Object.keys(current.env).length === 0) delete current.env;
+    // Statusline: restore the user's original command if we wrapped one, else remove ours.
+    await restoreClaudeCodeStatusline(current);
     await atomicWrite(record.config_path, `${JSON.stringify(current, null, 2)}\n`);
   },
 };

package/src/statusline.js

@@ -0,0 +1,178 @@
+// Claude Code statusline integration.
+//
+// Install drops a standalone node script (no deps) and points Claude Code's
+// `statusLine` setting at it. If the user already had a statusLine command, it is
+// PRESERVED: the original command is stored in the statusline config file and the
+// script runs it first, appending the PennyRouter segment to its output — uninstall
+// restores the original verbatim.
+//
+// The script never blocks on the network: it prints from a per-session cache file and
+// spawns a detached refresh (GET /v1/penny/statusline/<session_id> on the gateway,
+// authed with the pr- key already in Claude Code's settings). The gateway keys that
+// endpoint on the CC session uuid it sees in every request's metadata.user_id — the
+// same uuid Claude Code hands the statusline script on stdin.
+
+import { statePath, atomicWrite, readJsonFile, writeJsonFile } from "./state.js";
+
+export const STATUSLINE_SCRIPT_BASENAME = "claude-statusline.mjs";
+export const STATUSLINE_CONFIG_BASENAME = "claude-statusline.json";
+
+export function statuslineScriptPath() {
+  return statePath(STATUSLINE_SCRIPT_BASENAME);
+}
+
+function statuslineConfigPath() {
+  return statePath(STATUSLINE_CONFIG_BASENAME);
+}
+
+function isOurCommand(command) {
+  return typeof command === "string" && command.includes(STATUSLINE_SCRIPT_BASENAME);
+}
+
+// Mutates `current` (the parsed ~/.claude/settings.json object) to point statusLine at
+// our script; writes the script + config files. The caller persists `current`.
+export async function configureClaudeCodeStatusline(current) {
+  const existing = current.statusLine;
+  const config = (await readJsonFile(statuslineConfigPath(), null)) || {};
+  if (existing && existing.type === "command" && existing.command && !isOurCommand(existing.command)) {
+    // A user-authored statusline: wrap it, and remember it for uninstall. Never
+    // overwrite a previously captured wrap with our own command (re-install case).
+    config.wrap_command = existing.command;
+    if (existing.padding !== undefined) config.wrap_padding = existing.padding;
+  }
+  config.refresh_seconds = config.refresh_seconds ?? 15;
+  await writeJsonFile(statuslineConfigPath(), config);
+  await atomicWrite(statuslineScriptPath(), STATUSLINE_SCRIPT);
+  current.statusLine = {
+    type: "command",
+    command: `node "${statuslineScriptPath()}"`,
+    ...(existing?.padding !== undefined ? { padding: existing.padding } : {}),
+  };
+  return { script_path: statuslineScriptPath(), wrapped: Boolean(config.wrap_command) };
+}
+
+// Mutates `current` to undo configureClaudeCodeStatusline: restore the user's original
+// statusline command if we wrapped one, otherwise remove the setting entirely. A
+// statusLine we didn't write is left untouched.
+export async function restoreClaudeCodeStatusline(current) {
+  if (!current.statusLine || !isOurCommand(current.statusLine.command)) return;
+  const config = (await readJsonFile(statuslineConfigPath(), null)) || {};
+  if (config.wrap_command) {
+    current.statusLine = {
+      type: "command",
+      command: config.wrap_command,
+      ...(config.wrap_padding !== undefined ? { padding: config.wrap_padding } : {}),
+    };
+  } else {
+    delete current.statusLine;
+  }
+}
+
+// The standalone script written to disk. Node >= 18 (global fetch). Keep it dependency-
+// free and fast: read stdin, print from cache, refresh out-of-band.
+const STATUSLINE_SCRIPT = `#!/usr/bin/env node
+// PennyRouter statusline for Claude Code (installed by \`pennyrouter install\`).
+// Prints: [wrapped original statusline (all lines) |] penny segment (penny / penny (sub)
+// / penny (byok) / penny off). The wrapped statusline's first line gets the penny suffix;
+// any further lines (e.g. a context bar) pass through verbatim.
+// Never blocks on the network: reads a per-session cache and refreshes it detached.
+import { readFileSync, mkdirSync, writeFileSync, statSync } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import { join, basename } from "node:path";
+import os from "node:os";
+
+const stateDir = join(
+  process.env.XDG_STATE_HOME || join(os.homedir(), ".local", "state"),
+  "pennyrouter",
+);
+const cacheDir = join(stateDir, "statusline-cache");
+
+function readJson(path) {
+  try { return JSON.parse(readFileSync(path, "utf8")); } catch { return null; }
+}
+
+function claudeEnv() {
+  const settings = readJson(join(os.homedir(), ".claude", "settings.json")) || {};
+  const env = settings.env || {};
+  const base = env.ANTHROPIC_BASE_URL || "";
+  const keyCandidates = [env.ANTHROPIC_API_KEY, env.ANTHROPIC_AUTH_TOKEN];
+  const key = keyCandidates.find((v) => typeof v === "string" && v.startsWith("pr-")) || "";
+  return { base, key };
+}
+
+// --refresh <sessionId>: fetch gateway status into the cache file, then exit.
+if (process.argv[2] === "--refresh") {
+  const sessionId = process.argv[3];
+  const { base, key } = claudeEnv();
+  if (!sessionId || !base || !key) process.exit(0);
+  try {
+    const resp = await fetch(base.replace(/\\/$/, "") + "/v1/penny/statusline/" + sessionId, {
+      headers: { "x-api-key": key },
+      signal: AbortSignal.timeout(4000),
+    });
+    if (resp.ok) {
+      const data = await resp.json();
+      mkdirSync(cacheDir, { recursive: true });
+      writeFileSync(join(cacheDir, sessionId + ".json"), JSON.stringify(data));
+    }
+  } catch { /* best-effort: stale cache beats a broken statusline */ }
+  process.exit(0);
+}
+
+const raw = readFileSync(0, "utf8");
+let input = {};
+try { input = JSON.parse(raw); } catch { /* keep {} */ }
+const sessionId = input.session_id || "";
+const config = readJson(join(stateDir, "claude-statusline.json")) || {};
+const refreshMs = (config.refresh_seconds ?? 15) * 1000;
+
+const cachePath = join(cacheDir, sessionId + ".json");
+let cache = sessionId ? readJson(cachePath) : null;
+let cacheAge = Infinity;
+try { cacheAge = Date.now() - statSync(cachePath).mtimeMs; } catch { /* no cache yet */ }
+
+const { base, key } = claudeEnv();
+const pennyInstalled = base.includes("pennyrouter") && Boolean(key);
+if (sessionId && pennyInstalled && cacheAge > refreshMs) {
+  spawn(process.execPath, [process.argv[1], "--refresh", sessionId], {
+    detached: true, stdio: "ignore",
+  }).unref();
+}
+
+// Auth tier suffix: only "sub"/"byok" are shown (penny-tier and unknown render bare).
+function authSuffix(mode) {
+  return mode === "sub" || mode === "byok" ? " (" + mode + ")" : "";
+}
+
+let penny;
+if (!pennyInstalled) {
+  penny = "🪙 penny off";
+} else if (cache && cache.known && cache.bypass) {
+  penny = "🪙 penny off";
+} else {
+  penny = "🪙 penny" + authSuffix(cache && cache.auth_mode);
+}
+
+// Wrap the underlying statusline (e.g. ccstatusline) and append the penny segment to
+// its FIRST line only, preserving every subsequent line verbatim (the Context bar and
+// any other rows). Taking only line [0] here is what dropped multi-line statuslines.
+let lines;
+if (config.wrap_command) {
+  const run = spawnSync(config.wrap_command, {
+    shell: true, input: raw, encoding: "utf8", timeout: 1500,
+  });
+  lines = (run.stdout || "").replace(/\\n$/, "").split("\\n");
+  if (lines.length === 1 && lines[0] === "") lines = [];
+} else {
+  const model = input.model?.display_name || "";
+  const dir = input.workspace?.current_dir ? basename(input.workspace.current_dir) : "";
+  lines = [[model, dir].filter(Boolean).join(" · ")].filter(Boolean);
+}
+
+if (lines.length === 0) {
+  console.log(penny);
+} else {
+  lines[0] = lines[0].trimEnd() + " | " + penny;
+  console.log(lines.join("\\n"));
+}
+`;