pennyrouter 0.1.5 → 0.1.7

package/README.md

@@ -11,6 +11,7 @@ status checks, and uninstall metadata.
 ```bash
 npx pennyrouter install
 npx pennyrouter install --existing-account
+npx pennyrouter auth anthropic
 npx pennyrouter install --harness claude-code,cline,opencode,codex,windsurf,zed,codegpt,aider
 npx pennyrouter disable
 npx pennyrouter enable
@@ -34,12 +35,33 @@ detected configs start checked; press Enter to accept or type tool IDs to toggle
 
 ## Penny Models
 
-Tools that expose a model picker get four curated choices:
+Tools that expose a model picker (e.g. Claude Code `/model`) get four curated choices. The three
+named-model choices PIN the trunk to that exact model — you pick the model, PennyRouter still cuts
+the bill via its side machinery (cache/compaction/swallowed background calls) without switching the
+model you chose. "Penny Custom" is the dynamic option: PennyRouter cost-routes each turn.
 
-- Penny Core: `pennyrouter/penny-core:premium`
-- Penny Speed: `pennyrouter/penny-speed:standard`
-- Penny Power: `pennyrouter/penny-power:premium`
-- Penny Custom: `pennyrouter/auto`, using the bundle/profile saved in the user's PennyRouter account
+- Penny Opus: pins `anthropic/claude-opus-4-8`
+- Penny Sonnet: pins `anthropic/claude-sonnet-4-6`
+- Penny Haiku: pins `anthropic/claude-haiku-4-5-20251001`
+- Penny Custom: `pennyrouter/auto` — dynamic routing on the bundle/profile saved in the user's account
+
+## Claude Pro/Max Subscription Auth
+
+After installing PennyRouter for Claude Code, users with an Anthropic OAuth login can route
+Anthropic-native Claude turns through their own Claude subscription token:
+
+```bash
+ant auth login
+npx pennyrouter auth anthropic
+```
+
+The command updates Claude Code so `x-api-key` carries the PennyRouter key and
+`Authorization: Bearer ...` carries the Anthropic OAuth token. The gateway forwards that
+bearer token to Anthropic with the required OAuth beta header and does not deduct
+PennyRouter credit for those Anthropic-native upstream calls.
+
+`ant auth print-credentials` refreshes the access token before the CLI stores it. If the
+stored token expires during a long-running session, rerun `npx pennyrouter auth anthropic`.
 
 ## Agent Flow
 

package/package.json

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

package/src/cli.js

@@ -3,7 +3,7 @@ import { emitKeypressEvents } from "node:readline";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { aiderHarness } from "./harnesses/aider.js";
-import { claudeCodeHarness } from "./harnesses/claude-code.js";
+import { claudeCodeHarness, readClaudeCodePennyRouterKey } from "./harnesses/claude-code.js";
 import { clineHarness } from "./harnesses/cline.js";
 import { codeGptHarness } from "./harnesses/codegpt.js";
 import { codexHarness } from "./harnesses/codex.js";
@@ -52,6 +52,11 @@ export async function main(argv = process.argv.slice(2)) {
     return;
   }
 
+  if (command === "auth") {
+    await authProvider(flags);
+    return;
+  }
+
   if (command === "uninstall") {
     await uninstall(flags);
     return;
@@ -79,6 +84,7 @@ function parseArgs(argv) {
   const command = argv[0] && !argv[0].startsWith("-") ? argv[0] : "install";
   const rest = command === argv[0] ? argv.slice(1) : argv;
   const flags = {};
+  flags.args = [];
 
   for (let i = 0; i < rest.length; i += 1) {
     const arg = rest[i];
@@ -88,16 +94,86 @@ function parseArgs(argv) {
     else if (arg === "--dry-run") flags.dryRun = true;
     else if (arg === "--no-browser") flags.noBrowser = true;
     else if (arg === "--existing-account") flags.existingAccount = true;
+    else if (arg === "--penny-key") flags.pennyKey = rest[++i] || "";
+    else if (arg.startsWith("--penny-key=")) flags.pennyKey = arg.slice("--penny-key=".length);
+    else if (arg === "--token") flags.token = rest[++i] || "";
+    else if (arg.startsWith("--token=")) flags.token = arg.slice("--token=".length);
     else if (arg === "--harness") flags.harness = rest[++i] || "";
     else if (arg.startsWith("--harness=")) flags.harness = arg.slice("--harness=".length);
     else if (arg === "--app-url") flags.appUrl = rest[++i] || "";
     else if (arg.startsWith("--app-url=")) flags.appUrl = arg.slice("--app-url=".length);
+    else if (arg === "--gateway-base-url") flags.gatewayBaseUrl = rest[++i] || "";
+    else if (arg.startsWith("--gateway-base-url=")) flags.gatewayBaseUrl = arg.slice("--gateway-base-url=".length);
+    // --local: point the installed harness at a locally-running gateway (default
+    // http://localhost:8400), for developing/testing against your own gateway. Auth still goes
+    // to prod (pennyrouter.com) so you get a real key; only the harness's serving URL is local.
+    // `--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.startsWith("-")) flags.args.push(arg);
     else throw new Error(`Unknown option "${arg}". Run "pennyrouter help".`);
   }
 
   return { command, flags };
 }
 
+async function authProvider(flags) {
+  const provider = (flags.args[0] || "anthropic").toLowerCase();
+  if (provider !== "anthropic" && provider !== "claude") {
+    throw new Error(`Unknown auth provider "${provider}". Try "pennyrouter auth anthropic".`);
+  }
+
+  if (flags.dryRun) {
+    console.log("Will configure Claude Code for PennyRouter + Anthropic OAuth dual auth.");
+    console.log("Dry run only. No files changed.");
+    return;
+  }
+
+  const pennyKey = flags.pennyKey || await readClaudeCodePennyRouterKey();
+  if (!pennyKey) {
+    throw new Error(
+      "No PennyRouter key found in Claude Code settings. Run `pennyrouter install --harness claude-code` first, or pass `--penny-key pr-...`.",
+    );
+  }
+
+  const token = flags.token || readAnthropicOAuthToken();
+  if (!token) {
+    throw new Error(
+      "No Anthropic OAuth token found. Run `ant auth login`, then retry `pennyrouter auth anthropic`.",
+    );
+  }
+
+  const gatewayBaseUrl = flags.gatewayBaseUrl || process.env.PENNYROUTER_GATEWAY_BASE_URL || "https://api.pennyrouter.com";
+  const record = await claudeCodeHarness.installAnthropicOAuth({
+    pennyKey,
+    anthropicAuthToken: token,
+    gatewayBaseUrl,
+  });
+
+  const manifest = await loadManifest();
+  upsertManifestRecord(manifest, {
+    ...record,
+    anthropic_oauth: true,
+    token_source: flags.token ? "flag" : "ant",
+  });
+  await saveManifest(manifest);
+
+  console.log("Configured Claude Code for PennyRouter + Anthropic OAuth.");
+  console.log("Anthropic-native Claude turns will use your Claude subscription token upstream.");
+  console.log("If Claude auth expires, run `pennyrouter auth anthropic` again.");
+  console.log(`Config: ${record.config_path}`);
+}
+
+function readAnthropicOAuthToken() {
+  if (process.env.ANTHROPIC_AUTH_TOKEN) return process.env.ANTHROPIC_AUTH_TOKEN.trim();
+  const result = spawnSync("ant", ["auth", "print-credentials", "--access-token"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  if (result.status !== 0) return "";
+  return String(result.stdout || "").trim();
+}
+
 async function install(flags) {
   const selected = await selectHarnesses(flags);
   if (selected.length === 0) {
@@ -112,6 +188,7 @@ async function install(flags) {
     for (const harness of selected) {
       console.log(`Will install on ${harness.name}${installNoteForHarness(harness.id)}.`);
     }
+    if (flags.gatewayBaseUrl) console.log(`Serving gateway: ${flags.gatewayBaseUrl}`);
     console.log("Dry run only. No files changed.");
     return;
   }
@@ -144,7 +221,9 @@ async function install(flags) {
       const plan = await harness.planInstall();
       const record = await harness.install({
         apiKey: claim.api_key,
-        gatewayBaseUrl: claim.gateway_base_url,
+        // An explicit --local / --gateway-base-url overrides the URL the server hands back
+        // (which points at prod) — so a --local install serves through the local gateway.
+        gatewayBaseUrl: flags.gatewayBaseUrl || claim.gateway_base_url,
         plan,
       });
       records.push(record);
@@ -673,7 +752,8 @@ function printHelp() {
   console.log(`PennyRouter CLI
 
 Usage:
-  pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--existing-account]
+  pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--existing-account] [--local[=URL]]
+  pennyrouter auth anthropic [--penny-key pr-...] [--token oauth-token] [--gateway-base-url URL]
   pennyrouter disable [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
   pennyrouter enable [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
   pennyrouter uninstall [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
@@ -682,6 +762,7 @@ Usage:
 Examples:
   npx pennyrouter install
   npx pennyrouter install --existing-account
+  npx pennyrouter auth anthropic
   npx pennyrouter install --all
   npx pennyrouter install --harness windsurf,zed,codegpt,aider --yes
   npx pennyrouter disable

package/src/harnesses/claude-code.js

@@ -2,20 +2,23 @@ import { atomicWrite, backupFile, compactHome, exists, expandHome, readJsonFile
 
 const CONFIG_PATH = "~/.claude/settings.json";
 const LEGACY_MODEL_LABEL = "PennyRouter Bundle";
+// Values written into Claude Code's four model slots. CC displays a slot's VALUE verbatim in
+// its /model menu AND sends it as the request `model`, so each value is both the menu label
+// and the gateway's routing key. The three concrete Claude slots carry friendly PINNED labels
+// ("Penny Opus/Sonnet/Haiku") that the gateway maps to that exact model — the user's pick
+// runs on the model they chose, no dynamic tier switching on the trunk (background/utility
+// calls still route cheap, which is where the savings come from). The Fable slot is the
+// DYNAMIC "Penny Custom" option: let PennyRouter cost-route. Legacy "Penny Speed/Core/Power"
+// installs (dynamic bundles) are still recognized for uninstall (see isPennyRouterModelValue).
 const CLAUDE_CODE_MODELS = {
-  speed: "Penny Speed",
-  core: "Penny Core",
-  coreMax: "Penny Core Max",
-  power: "Penny Power",
-  custom: "Penny Custom",
-};
-const MODEL_OVERRIDE_KEYS = {
-  "claude-sonnet-4-6": CLAUDE_CODE_MODELS.core,
-  "claude-sonnet-4-6-1m": CLAUDE_CODE_MODELS.coreMax,
-  "claude-opus-4-8": CLAUDE_CODE_MODELS.power,
-  "claude-haiku-4-5": CLAUDE_CODE_MODELS.speed,
-  "claude-fable-5": CLAUDE_CODE_MODELS.custom,
+  haiku: "Penny Haiku",     // -> pinned anthropic/claude-haiku-4-5-20251001
+  sonnet: "Penny Sonnet",   // -> pinned anthropic/claude-sonnet-4-6
+  opus: "Penny Opus",       // -> pinned anthropic/claude-opus-4-8
+  custom: "Penny Custom",   // -> dynamic (PennyRouter cost-routing)
 };
+// Retired dynamic-bundle labels (pre-pinned-trunk). Not written by a fresh install; matched
+// only so uninstall/detect still recognize and clean up an older install.
+const LEGACY_PENNY_LABELS = ["Penny Speed", "Penny Core", "Penny Power"];
 
 export const claudeCodeHarness = {
   id: "claude-code",
@@ -48,12 +51,10 @@ export const claudeCodeHarness = {
     delete current.env.ANTHROPIC_API_KEY;
     // Claude Code displays these env values directly in its model picker; the
     // gateway decodes the friendly labels into bundle/profile overrides.
-    current.env.ANTHROPIC_DEFAULT_OPUS_MODEL = CLAUDE_CODE_MODELS.power;
-    current.env.ANTHROPIC_DEFAULT_SONNET_MODEL = CLAUDE_CODE_MODELS.speed;
-    current.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = CLAUDE_CODE_MODELS.core;
+    current.env.ANTHROPIC_DEFAULT_OPUS_MODEL = CLAUDE_CODE_MODELS.opus;
+    current.env.ANTHROPIC_DEFAULT_SONNET_MODEL = CLAUDE_CODE_MODELS.sonnet;
+    current.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = CLAUDE_CODE_MODELS.haiku;
     current.env.ANTHROPIC_DEFAULT_FABLE_MODEL = CLAUDE_CODE_MODELS.custom;
-    current.modelOverrides ||= {};
-    Object.assign(current.modelOverrides, MODEL_OVERRIDE_KEYS);
 
     await atomicWrite(CONFIG_PATH, `${JSON.stringify(current, null, 2)}\n`);
 
@@ -72,7 +73,41 @@ export const claudeCodeHarness = {
           "ANTHROPIC_DEFAULT_HAIKU_MODEL",
           "ANTHROPIC_DEFAULT_FABLE_MODEL",
         ],
-        model_overrides: Object.keys(MODEL_OVERRIDE_KEYS),
+      },
+    };
+  },
+
+  async installAnthropicOAuth({ pennyKey, anthropicAuthToken, gatewayBaseUrl }) {
+    const backupPath = await backupFile(CONFIG_PATH, "claude-code-anthropic-auth");
+    const current = (await readJsonFile(CONFIG_PATH, null)) || {};
+    current.env ||= {};
+    current.env.ANTHROPIC_BASE_URL = gatewayBaseUrl;
+    // Dual-auth mode: x-api-key authenticates the local user to PennyRouter; the
+    // Authorization bearer token is forwarded by the gateway to Anthropic.
+    current.env.ANTHROPIC_API_KEY = pennyKey;
+    current.env.ANTHROPIC_AUTH_TOKEN = anthropicAuthToken;
+    current.env.ANTHROPIC_DEFAULT_OPUS_MODEL = CLAUDE_CODE_MODELS.opus;
+    current.env.ANTHROPIC_DEFAULT_SONNET_MODEL = CLAUDE_CODE_MODELS.sonnet;
+    current.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = CLAUDE_CODE_MODELS.haiku;
+    current.env.ANTHROPIC_DEFAULT_FABLE_MODEL = CLAUDE_CODE_MODELS.custom;
+
+    await atomicWrite(CONFIG_PATH, `${JSON.stringify(current, null, 2)}\n`);
+    return {
+      harness: "claude-code",
+      config_path: compactHome(expandHome(CONFIG_PATH)),
+      backup_path: backupPath ? compactHome(backupPath) : null,
+      installed_at: new Date().toISOString(),
+      restart: "restart Claude Code",
+      changes: {
+        env_keys: [
+          "ANTHROPIC_BASE_URL",
+          "ANTHROPIC_API_KEY",
+          "ANTHROPIC_AUTH_TOKEN",
+          "ANTHROPIC_DEFAULT_OPUS_MODEL",
+          "ANTHROPIC_DEFAULT_SONNET_MODEL",
+          "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+          "ANTHROPIC_DEFAULT_FABLE_MODEL",
+        ],
       },
     };
   },
@@ -82,7 +117,7 @@ export const claudeCodeHarness = {
     if (hasPennyRouterEnv(current.env)) {
       delete current.env.ANTHROPIC_BASE_URL;
       const tok = current.env.ANTHROPIC_AUTH_TOKEN;
-      if (typeof tok === "string" && tok.startsWith("pr-")) {
+      if (typeof tok === "string" && (tok.startsWith("pr-") || record.anthropic_oauth)) {
         delete current.env.ANTHROPIC_AUTH_TOKEN;
       }
       // Legacy installs stored the key under ANTHROPIC_API_KEY.
@@ -98,12 +133,6 @@ export const claudeCodeHarness = {
         if (current.env[k] === LEGACY_MODEL_LABEL || isPennyRouterModelValue(current.env[k])) delete current.env[k];
       }
     }
-    if (current.modelOverrides && typeof current.modelOverrides === "object") {
-      for (const [key, value] of Object.entries(MODEL_OVERRIDE_KEYS)) {
-        if (current.modelOverrides[key] === value) delete current.modelOverrides[key];
-      }
-      if (Object.keys(current.modelOverrides).length === 0) delete current.modelOverrides;
-    }
     if (current["anthropic.baseURL"] && isPennyRouterValue(current["anthropic.baseURL"])) {
       delete current["anthropic.baseURL"];
     }
@@ -143,10 +172,19 @@ function isPennyRouterBaseUrl(value) {
 function isPennyRouterModelValue(value) {
   return (
     isPennyRouterValue(value) ||
-    value === CLAUDE_CODE_MODELS.speed ||
-    value === CLAUDE_CODE_MODELS.core ||
-    value === CLAUDE_CODE_MODELS.coreMax ||
-    value === CLAUDE_CODE_MODELS.power ||
-    value === CLAUDE_CODE_MODELS.custom
+    value === CLAUDE_CODE_MODELS.haiku ||
+    value === CLAUDE_CODE_MODELS.sonnet ||
+    value === CLAUDE_CODE_MODELS.opus ||
+    value === CLAUDE_CODE_MODELS.custom ||
+    LEGACY_PENNY_LABELS.includes(value)
   );
 }
+
+export async function readClaudeCodePennyRouterKey() {
+  const current = (await readJsonFile(CONFIG_PATH, null)) || {};
+  const env = current.env || {};
+  for (const value of [env.ANTHROPIC_API_KEY, env.ANTHROPIC_AUTH_TOKEN, current["anthropic.apiKey"]]) {
+    if (typeof value === "string" && value.startsWith("pr-")) return value;
+  }
+  return null;
+}