pennyrouter 0.1.8 → 0.1.10

package/package.json

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

package/src/cli.js

@@ -3,7 +3,11 @@ 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, readClaudeCodePennyRouterKey } from "./harnesses/claude-code.js";
+import {
+  claudeCodeHarness,
+  readClaudeCodeGatewayAuth,
+  readClaudeCodePennyRouterKey,
+} from "./harnesses/claude-code.js";
 import { clineHarness } from "./harnesses/cline.js";
 import { codeGptHarness } from "./harnesses/codegpt.js";
 import { codexHarness } from "./harnesses/codex.js";
@@ -13,9 +17,11 @@ import { zedHarness } from "./harnesses/zed.js";
 import {
   APP_URL,
   createCliSession,
+  forgetAnthropicToken,
   maskKey,
   pollForKey,
   sleep,
+  storeAnthropicToken,
 } from "./session.js";
 import {
   backupFile,
@@ -149,28 +155,28 @@ async function authProvider(flags) {
   }
 
   const gatewayBaseUrl = flags.gatewayBaseUrl || process.env.PENNYROUTER_GATEWAY_BASE_URL || "https://api.pennyrouter.com";
-  const record = await claudeCodeHarness.installAnthropicOAuth({
-    pennyKey,
-    anthropicAuthToken: token,
-    gatewayBaseUrl,
-  });
+  // Store the token encrypted server-side, then write a pr-key-only config.
+  await storeAnthropicToken({ gatewayBaseUrl, apiKey: pennyKey, token });
+  const plan = await claudeCodeHarness.planInstall();
+  const record = await claudeCodeHarness.installStoredToken({ apiKey: pennyKey, gatewayBaseUrl, plan });
 
   const manifest = await loadManifest();
   upsertManifestRecord(manifest, {
     ...record,
     anthropic_oauth: true,
+    anthropic_token_stored: true,
     token_source: tokenResult.source,
   });
   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("Configured Claude Code for PennyRouter + your Claude subscription.");
+  console.log("Your Claude token is stored encrypted; Claude Code holds only your PennyRouter key.");
   console.log("If Claude auth expires, refresh the token source and run `pennyrouter auth anthropic` again.");
   console.log(`Config: ${record.config_path}`);
 }
 
 function readAnthropicOAuthToken(flags = {}) {
-  if (flags.token) return { token: flags.token.trim(), source: "flag" };
+  if (flags.token) return { token: normalizeAnthropicToken(flags.token), source: "flag" };
   if (flags.tokenCommand) {
     const result = spawnSync(flags.tokenCommand, {
       encoding: "utf8",
@@ -178,19 +184,31 @@ function readAnthropicOAuthToken(flags = {}) {
       stdio: ["ignore", "pipe", "pipe"],
     });
     if (result.status === 0) {
-      return { token: String(result.stdout || "").trim(), source: "token-command" };
+      return { token: normalizeAnthropicToken(result.stdout), source: "token-command" };
     }
     return { token: "", source: "token-command" };
   }
   if (process.env.ANTHROPIC_AUTH_TOKEN) {
-    return { token: process.env.ANTHROPIC_AUTH_TOKEN.trim(), source: "env" };
+    return { token: normalizeAnthropicToken(process.env.ANTHROPIC_AUTH_TOKEN), source: "env" };
   }
   const result = spawnSync("ant", ["auth", "print-credentials", "--access-token"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
   });
   if (result.status !== 0) return { token: "", source: "none" };
-  return { token: String(result.stdout || "").trim(), source: "ant" };
+  return { token: normalizeAnthropicToken(result.stdout), source: "ant" };
+}
+
+function normalizeAnthropicToken(value) {
+  let text = String(value || "").trim();
+  if (!text) return "";
+  text = text.replace(/^export\s+/, "");
+  const match = text.match(/^ANTHROPIC_AUTH_TOKEN=(.*)$/);
+  if (match) text = match[1].trim();
+  if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
+    text = text.slice(1, -1);
+  }
+  return text.replace(/\s+/g, "").trim();
 }
 
 async function install(flags) {
@@ -244,22 +262,28 @@ async function install(flags) {
     await runHarnessJob(failures, harness.id, "install", async () => {
       const plan = await harness.planInstall();
       const gatewayBaseUrl = flags.gatewayBaseUrl || claim.gateway_base_url;
-      const record = harness.id === "claude-code" && claudeAnthropicAuth
-        ? await harness.installAnthropicOAuth({
-          pennyKey: claim.api_key,
-          anthropicAuthToken: claudeAnthropicAuth.token,
+      let record;
+      if (harness.id === "claude-code" && claudeAnthropicAuth) {
+        // Store the Claude setup-token encrypted server-side, then write a config
+        // that carries ONLY the pr- key. Nothing Anthropic-flavored on disk, and no
+        // dual-credential warnings from Claude Code.
+        await storeAnthropicToken({
           gatewayBaseUrl,
-        })
-        : await harness.install({
+          apiKey: claim.api_key,
+          token: claudeAnthropicAuth.token,
+        });
+        record = await harness.installStoredToken({ apiKey: claim.api_key, gatewayBaseUrl, plan });
+        record.anthropic_oauth = true;
+        record.anthropic_token_stored = true;
+        record.token_source = claudeAnthropicAuth.source;
+      } else {
+        record = await harness.install({
           apiKey: claim.api_key,
           // 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,
           plan,
         });
-      if (harness.id === "claude-code" && claudeAnthropicAuth) {
-        record.anthropic_oauth = true;
-        record.token_source = claudeAnthropicAuth.source;
       }
       records.push(record);
       upsertManifestRecord(manifest, record);
@@ -318,7 +342,7 @@ async function maybeConfigureClaudeAnthropicAuth(flags, selected) {
   } else {
     console.log("Claude Code was not found on PATH. Paste an Anthropic bearer token, or leave blank to skip.");
   }
-  const token = await promptSecretish("Anthropic token (blank to skip): ");
+  const token = normalizeAnthropicToken(await promptSecretish("Anthropic token (blank to skip): "));
   if (!token) {
     console.log("Skipped Claude subscription auth. Enable later with `@penny auth` or `pennyrouter auth anthropic`.");
     console.log("");
@@ -483,6 +507,7 @@ async function uninstall(flags) {
     }
 
     const ok = await runHarnessJob(failures, record.harness, "uninstall", async () => {
+      await forgetStoredAnthropicToken(record);
       await harness.uninstall(record);
       console.log(`Removed ${record.harness}.`);
     });
@@ -497,6 +522,7 @@ async function uninstall(flags) {
       continue;
     }
     await runHarnessJob(failures, record.harness, "uninstall", async () => {
+      await forgetStoredAnthropicToken(record);
       await harness.uninstall(record);
       console.log(`Removed ${record.harness}.`);
     });
@@ -808,6 +834,21 @@ function formatError(error) {
   return error?.message || String(error);
 }
 
+// Best-effort: tell the gateway to forget a stored Claude token when uninstalling a
+// claude-code integration that stored one. Reads the gateway URL + pr- key from the
+// live config BEFORE harness.uninstall strips them. Never throws — a local uninstall
+// must not be blocked by a network hiccup; the record is going away regardless.
+async function forgetStoredAnthropicToken(record) {
+  if (record.harness !== "claude-code" || !record.anthropic_token_stored) return;
+  try {
+    const { gatewayBaseUrl, apiKey } = await readClaudeCodeGatewayAuth();
+    if (!gatewayBaseUrl || !apiKey) return;
+    await forgetAnthropicToken({ gatewayBaseUrl, apiKey });
+  } catch {
+    // swallow — see note above
+  }
+}
+
 async function confirm(question) {
   const rl = createInterface({ input, output });
   const answer = await rl.question(`${question} [y/N] `);

package/src/harnesses/claude-code.js

@@ -77,6 +77,45 @@ export const claudeCodeHarness = {
     };
   },
 
+  // Stored-token mode: the Anthropic setup-token was already POSTed to the gateway
+  // and encrypted against the account (see cli.js storeAnthropicToken). Claude Code's
+  // config therefore carries ONLY the pr- key + base URL — no ANTHROPIC_AUTH_TOKEN.
+  // The gateway pulls the stored token per request. This avoids the plaintext token
+  // on disk AND the dual-credential (api key + auth token) warnings Claude Code emits.
+  async installStoredToken({ apiKey, gatewayBaseUrl, plan }) {
+    const backupPath = await backupFile(CONFIG_PATH, "claude-code");
+    const current = (await readJsonFile(CONFIG_PATH, null)) || {};
+    current.env ||= {};
+    current.env.ANTHROPIC_BASE_URL = gatewayBaseUrl;
+    current.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+    // Single credential only: no stale api key, no separate Anthropic bearer.
+    delete current.env.ANTHROPIC_API_KEY;
+    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(plan.configPath),
+      backup_path: backupPath ? compactHome(backupPath) : null,
+      installed_at: new Date().toISOString(),
+      restart: "restart Claude Code",
+      changes: {
+        env_keys: [
+          "ANTHROPIC_BASE_URL",
+          "ANTHROPIC_AUTH_TOKEN",
+          "ANTHROPIC_DEFAULT_OPUS_MODEL",
+          "ANTHROPIC_DEFAULT_SONNET_MODEL",
+          "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+          "ANTHROPIC_DEFAULT_FABLE_MODEL",
+        ],
+      },
+    };
+  },
+
   async installAnthropicOAuth({ pennyKey, anthropicAuthToken, gatewayBaseUrl }) {
     const backupPath = await backupFile(CONFIG_PATH, "claude-code-anthropic-auth");
     const current = (await readJsonFile(CONFIG_PATH, null)) || {};
@@ -115,13 +154,22 @@ export const claudeCodeHarness = {
   async uninstall(record) {
     const current = (await readJsonFile(record.config_path, null)) || {};
     if (hasPennyRouterEnv(current.env)) {
+      // If the base URL points at PennyRouter, every auth value in env was written
+      // by us for our gateway (a Penny pr- key and/or an Anthropic OAuth bearer we
+      // forward upstream) — clear them all. We can't rely on the token's prefix:
+      // in OAuth mode ANTHROPIC_AUTH_TOKEN holds an Anthropic sk-ant-oat... token,
+      // not a pr- value, and the manifest's anthropic_oauth flag may be absent on a
+      // record synthesized from a detected config. Keying off our base URL is what
+      // makes cleanup reliable regardless of which auth mode was installed.
+      const ourGateway = isPennyRouterBaseUrl(current.env.ANTHROPIC_BASE_URL);
       delete current.env.ANTHROPIC_BASE_URL;
       const tok = current.env.ANTHROPIC_AUTH_TOKEN;
-      if (typeof tok === "string" && (tok.startsWith("pr-") || record.anthropic_oauth)) {
+      if (typeof tok === "string" && (ourGateway || tok.startsWith("pr-") || record.anthropic_oauth)) {
         delete current.env.ANTHROPIC_AUTH_TOKEN;
       }
-      // Legacy installs stored the key under ANTHROPIC_API_KEY.
-      if (typeof current.env.ANTHROPIC_API_KEY === "string" && current.env.ANTHROPIC_API_KEY.startsWith("pr-")) {
+      // ANTHROPIC_API_KEY carries the Penny key in OAuth dual-auth mode, or a pr-
+      // key in legacy installs. Clear it when it's ours by base URL or by prefix.
+      if (typeof current.env.ANTHROPIC_API_KEY === "string" && (ourGateway || current.env.ANTHROPIC_API_KEY.startsWith("pr-"))) {
         delete current.env.ANTHROPIC_API_KEY;
       }
       for (const k of [
@@ -188,3 +236,14 @@ export async function readClaudeCodePennyRouterKey() {
   }
   return null;
 }
+
+// The PennyRouter gateway URL + pr- key currently in Claude Code's config, used to
+// call the gateway's "forget my Claude token" endpoint on uninstall. Read before
+// uninstall strips these keys. Either field may be null if not present.
+export async function readClaudeCodeGatewayAuth() {
+  const current = (await readJsonFile(CONFIG_PATH, null)) || {};
+  const env = current.env || {};
+  const gatewayBaseUrl = isPennyRouterBaseUrl(env.ANTHROPIC_BASE_URL) ? env.ANTHROPIC_BASE_URL : null;
+  const apiKey = await readClaudeCodePennyRouterKey();
+  return { gatewayBaseUrl, apiKey };
+}

package/src/session.js

@@ -46,6 +46,47 @@ export function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// Encrypt-and-store an Anthropic setup-token against the account server-side, so the
+// pr- key alone unlocks Claude and no token is written to the harness config. The
+// gateway (not the web app) owns this: it holds the pr- key auth and the encryption.
+export async function storeAnthropicToken({ gatewayBaseUrl, apiKey, token }) {
+  const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/upstream-credentials`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({ provider: "anthropic", token }),
+  });
+  if (!response.ok) {
+    let detail = "";
+    try {
+      detail = (await response.json())?.detail || "";
+    } catch {
+      // non-JSON body; fall through to status-only message
+    }
+    throw new Error(`Storing Claude token failed: HTTP ${response.status}${detail ? ` — ${detail}` : ""}`);
+  }
+  return response.json();
+}
+
+// Best-effort "forget my Claude token" on uninstall. Never throws — a cleanup that
+// can't reach the network shouldn't block removing the local integration.
+export async function forgetAnthropicToken({ gatewayBaseUrl, apiKey }) {
+  if (!gatewayBaseUrl || !apiKey) return false;
+  try {
+    const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/upstream-credentials/anthropic`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: { authorization: `Bearer ${apiKey}` },
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
 function platformName() {
   if (process.platform === "darwin") return "Mac";
   if (process.platform === "win32") return "Windows";