pennyrouter 0.1.10 → 0.1.12

package/package.json

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

package/src/cli.js

@@ -120,6 +120,8 @@ function parseArgs(argv) {
     // `--local=<url>` overrides the port/host.
     else if (arg === "--local") flags.gatewayBaseUrl = "http://localhost:8400";
     else if (arg.startsWith("--local=")) flags.gatewayBaseUrl = arg.slice("--local=".length);
+    else if (arg === "--forget") flags.forget = true;
+    else if (arg === "--forget-token") flags.forgetToken = true;
     else if (!arg.startsWith("-")) flags.args.push(arg);
     else throw new Error(`Unknown option "${arg}". Run "pennyrouter help".`);
   }
@@ -133,6 +135,39 @@ async function authProvider(flags) {
     throw new Error(`Unknown auth provider "${provider}". Try "pennyrouter auth anthropic".`);
   }
 
+  if (flags.forget) {
+    const pennyKey = flags.pennyKey || await readClaudeCodePennyRouterKey();
+    if (!pennyKey) {
+      throw new Error(
+        "No PennyRouter key found in Claude Code settings. Pass `--penny-key pr-...`.",
+      );
+    }
+    const gatewayBaseUrl = flags.gatewayBaseUrl || process.env.PENNYROUTER_GATEWAY_BASE_URL || "https://api.pennyrouter.com";
+    if (flags.dryRun) {
+      console.log(`Will delete stored Anthropic token from gateway: ${gatewayBaseUrl}`);
+      return;
+    }
+    const ok = await forgetAnthropicToken({ gatewayBaseUrl, apiKey: pennyKey });
+    if (ok) {
+      console.log("Successfully forgot stored Anthropic token on server.");
+    } else {
+      console.log("Failed to forget stored Anthropic token on server.");
+    }
+    const manifest = await loadManifest();
+    let updated = false;
+    for (const record of (manifest.installations || [])) {
+      if (record.harness === "claude-code" && record.anthropic_token_stored) {
+        record.anthropic_token_stored = false;
+        record.anthropic_oauth = false;
+        updated = true;
+      }
+    }
+    if (updated) {
+      await saveManifest(manifest);
+    }
+    return;
+  }
+
   if (flags.dryRun) {
     console.log("Will configure Claude Code for PennyRouter + Anthropic OAuth dual auth.");
     console.log("Dry run only. No files changed.");
@@ -493,6 +528,7 @@ async function uninstall(flags) {
 
   const kept = [];
   const failures = [];
+  let anthropicTokenNotice = false;
   for (const record of records) {
     if (!selectedIds.includes(record.harness)) {
       kept.push(record);
@@ -507,7 +543,11 @@ async function uninstall(flags) {
     }
 
     const ok = await runHarnessJob(failures, record.harness, "uninstall", async () => {
-      await forgetStoredAnthropicToken(record);
+      if (flags.forgetToken) {
+        await forgetStoredAnthropicToken(record);
+      } else if (record.anthropic_token_stored) {
+        anthropicTokenNotice = true;
+      }
       await harness.uninstall(record);
       console.log(`Removed ${record.harness}.`);
     });
@@ -522,12 +562,22 @@ async function uninstall(flags) {
       continue;
     }
     await runHarnessJob(failures, record.harness, "uninstall", async () => {
-      await forgetStoredAnthropicToken(record);
+      if (flags.forgetToken) {
+        await forgetStoredAnthropicToken(record);
+      } else if (record.anthropic_token_stored) {
+        anthropicTokenNotice = true;
+      }
       await harness.uninstall(record);
       console.log(`Removed ${record.harness}.`);
     });
   }
 
+  if (anthropicTokenNotice) {
+    console.log("");
+    console.log("Note: Your stored Anthropic token remains on the server for other machines.");
+    console.log("To delete it from the server, run: pennyrouter auth anthropic --forget");
+  }
+
   manifest.installations = kept;
   await saveManifest(manifest);
   reportFailures(failures);
@@ -929,10 +979,10 @@ function printHelp() {
 
 Usage:
   pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--existing-account] [--anthropic-auth|--no-anthropic-auth] [--local[=URL]]
-  pennyrouter auth anthropic [--penny-key pr-...] [--token oauth-token] [--token-command CMD] [--gateway-base-url URL]
+  pennyrouter auth anthropic [--penny-key pr-...] [--token oauth-token] [--token-command CMD] [--gateway-base-url URL] [--forget]
   pennyrouter disable [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
   pennyrouter enable [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
-  pennyrouter uninstall [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
+  pennyrouter uninstall [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--forget-token]
   pennyrouter status
 
 Examples:

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);
+`;