pennyrouter 0.1.11 → 0.1.12

package/package.json

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

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,169 @@
+// 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 |] penny segment (managed model / BYPASS / off).
+// 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();
+}
+
+function shortModel(m) {
+  if (typeof m !== "string" || !m) return "";
+  return m.split("/").pop().replace(/^claude-/, "");
+}
+
+let penny;
+if (!pennyInstalled) {
+  penny = "🪙 penny off";
+} else if (cache && cache.known && cache.bypass) {
+  penny = "🪙 penny BYPASS";
+} else if (cache && cache.known && cache.model) {
+  penny = "🪙 penny · " + shortModel(cache.model);
+} else {
+  penny = "🪙 penny on";
+}
+
+let prefix = "";
+if (config.wrap_command) {
+  const run = spawnSync(config.wrap_command, {
+    shell: true, input: raw, encoding: "utf8", timeout: 1500,
+  });
+  prefix = (run.stdout || "").split("\\n")[0].trim();
+} else {
+  const model = input.model?.display_name || "";
+  const dir = input.workspace?.current_dir ? basename(input.workspace.current_dir) : "";
+  prefix = [model, dir].filter(Boolean).join(" · ");
+}
+
+console.log(prefix ? prefix + " | " + penny : penny);
+`;