pennyrouter 0.3.30 → 0.3.32

package/package.json

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

package/src/cli.js

@@ -685,10 +685,13 @@ export async function install(flags = {}) {
   const selected = await selectHarnesses(flags);
   if (selected.length === 0) {
     console.log("No supported harnesses selected.");
+    await printAdditionalHarnessesHint([]);
     return;
   }
 
   console.log("PennyRouter install");
+  console.log("PennyRouter can be installed into multiple coding harnesses on this machine.");
+  await printAdditionalHarnessesHint(selected);
   console.log("");
 
   const manifest = await loadManifest();
@@ -1554,12 +1557,24 @@ async function selectClaudeFundingProviders(flags, selected) {
 
   console.log("PennyRouter can use your Claude subscription, an Anthropic API key, an OpenRouter API key, or your own Anthropic-compatible proxy to run Claude Code.");
   console.log("Choose one or more providers. PennyRouter will try them in order when available.");
+  const subscriptionAvailable = Boolean(
+    flags.token || flags.tokenCommand || process.env.ANTHROPIC_AUTH_TOKEN || commandExists("claude"),
+  );
+  const options = CLAUDE_PROVIDER_OPTIONS.filter(
+    ({ id }) => id !== "subscription" || subscriptionAvailable,
+  );
   return promptFundingProviderCheckboxes(
-    CLAUDE_PROVIDER_OPTIONS,
-    "Which providers should PennyRouter use for Claude Code?",
+    options,
+    "Which funding source should PennyRouter use for Claude Code?",
     // An enterprise gateway usually fronts the model provider itself, so the proxy is the
     // expected answer there and leads; elsewhere the subscription does.
-    new Set([flags.privateGatewayFlow ? "anthropic-proxy" : "subscription"]),
+    new Set([
+      flags.privateGatewayFlow && options.some(({ id }) => id === "anthropic-proxy")
+        ? "anthropic-proxy"
+        : options.some(({ id }) => id === "subscription")
+          ? "subscription"
+          : options[0]?.id,
+    ].filter(Boolean)),
   );
 }
 
@@ -1580,10 +1595,17 @@ async function selectCodexFundingProviders(flags, selected) {
 
   console.log("PennyRouter can use your ChatGPT subscription, an OpenAI API key, an OpenAI-compatible proxy, or an OpenRouter API key to run Codex.");
   console.log("Choose one or more providers. PennyRouter will try them in order when available.");
+  const options = CODEX_PROVIDER_OPTIONS.filter(
+    ({ id }) => id !== "subscription" || hasChatgptLogin,
+  );
   return promptFundingProviderCheckboxes(
-    CODEX_PROVIDER_OPTIONS,
-    "Which providers should PennyRouter use for Codex?",
-    new Set([flags.privateGatewayFlow ? "openai-proxy" : "subscription"]),
+    options,
+    "Which funding source should PennyRouter use for Codex?",
+    new Set([
+      flags.privateGatewayFlow && options.some(({ id }) => id === "openai-proxy")
+        ? "openai-proxy"
+        : options[0]?.id,
+    ].filter(Boolean)),
   );
 }
 
@@ -1632,7 +1654,9 @@ async function maybeConfigureClaudeAnthropicAuth(flags, selected, enabled = true
   } else if (flags.fromConfig) {
     throw new Error("Claude Code was not found on PATH, so subscription sign-in could not run.");
   } else {
-    console.log("Claude Code was not found on PATH. Paste an Anthropic bearer token, or leave blank to skip.");
+    // The provider picker only offers subscription auth when Claude Code can perform
+    // setup-token (or the user supplied a token). Never send users into a dead manual flow.
+    return null;
   }
   const token = normalizeAnthropicToken(await promptSecretish("Anthropic token (blank to skip): "));
   if (!token) {
@@ -2115,6 +2139,20 @@ async function selectHarnesses(flags) {
   return promptHarnessCheckboxes(detected);
 }
 
+async function printAdditionalHarnessesHint(selected) {
+  const selectedIds = new Set(selected.map(({ id }) => id));
+  const available = [];
+  for (const harness of Object.values(HARNESS_BY_ID)) {
+    if (selectedIds.has(harness.id)) continue;
+    if (!(await safeDetect(harness))) available.push(harness.name);
+  }
+  if (available.length === 0) return;
+  const names = available.length === 1
+    ? available[0]
+    : `${available.slice(0, -1).join(", ")}, or ${available.at(-1)}`;
+  console.log(`To use PennyRouter with ${names}, install ${available.length === 1 ? "it" : "them"} and re-run \`npx pennyrouter install\`.`);
+}
+
 async function promptHarnessCheckboxes(detected) {
   const detectedIds = new Set(detected.map((harness) => harness.id));
   const selectedIds = new Set(detectedIds);

package/src/harnesses/claude-code.js

@@ -99,6 +99,8 @@ export async function fetchClaudeCodeModels(gatewayBaseUrl, apiKey) {
       model: id,
       ...(displayName && displayName !== id ? { label: displayName } : {}),
       ...(description ? { description } : {}),
+      ...(Number.isFinite(entry.max_input_tokens)
+        ? { max_input_tokens: entry.max_input_tokens } : {}),
     });
   }
   if (models.length === 0) {
@@ -107,6 +109,7 @@ export async function fetchClaudeCodeModels(gatewayBaseUrl, apiKey) {
   return {
     models,
     privateGateway: response.headers?.get?.("x-pennyrouter-private-gateway") === "1",
+    ...(payload?.anthropic_catalog_live === true ? { nativeCatalogLive: true } : {}),
   };
 }
 
@@ -156,13 +159,13 @@ export const claudeCodeHarness = {
         delete current.env[`ANTHROPIC_DEFAULT_${slot}_MODEL_DESCRIPTION`];
       }
     } else {
-      // 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.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.fable;
-      writeClaudeCodeModelPresentation(current.env);
+      // Hosted discovery follows Anthropic's live catalog. Fixed slot overrides in
+      // shared settings would keep plain `claude` installs pinned to old releases.
+      for (const slot of ["OPUS", "SONNET", "HAIKU", "FABLE"]) {
+        delete current.env[`ANTHROPIC_DEFAULT_${slot}_MODEL`];
+        delete current.env[`ANTHROPIC_DEFAULT_${slot}_MODEL_NAME`];
+        delete current.env[`ANTHROPIC_DEFAULT_${slot}_MODEL_DESCRIPTION`];
+      }
     }
     delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION;
     delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME;
@@ -220,11 +223,11 @@ export const claudeCodeHarness = {
         delete current.env[`ANTHROPIC_DEFAULT_${slot}_MODEL_DESCRIPTION`];
       }
     } else {
-      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.fable;
-      writeClaudeCodeModelPresentation(current.env);
+      for (const slot of ["OPUS", "SONNET", "HAIKU", "FABLE"]) {
+        delete current.env[`ANTHROPIC_DEFAULT_${slot}_MODEL`];
+        delete current.env[`ANTHROPIC_DEFAULT_${slot}_MODEL_NAME`];
+        delete current.env[`ANTHROPIC_DEFAULT_${slot}_MODEL_DESCRIPTION`];
+      }
     }
     delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION;
     delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME;
@@ -271,11 +274,11 @@ export const claudeCodeHarness = {
     current.env.ANTHROPIC_API_KEY = pennyKey;
     current.env.ANTHROPIC_AUTH_TOKEN = anthropicAuthToken;
     current.env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
-    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.fable;
-    writeClaudeCodeModelPresentation(current.env);
+    for (const slot of ["OPUS", "SONNET", "HAIKU", "FABLE"]) {
+      delete current.env[`ANTHROPIC_DEFAULT_${slot}_MODEL`];
+      delete current.env[`ANTHROPIC_DEFAULT_${slot}_MODEL_NAME`];
+      delete current.env[`ANTHROPIC_DEFAULT_${slot}_MODEL_DESCRIPTION`];
+    }
     delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION;
     delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME;
     delete current.env.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION;

package/src/harnesses/codex.js

@@ -86,6 +86,8 @@ export async function detectCodexChatgptAuth() {
   const status = spawnSync("codex", ["login", "status"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
+    // Windows npm installs Codex as a .cmd shim, which requires shell resolution.
+    shell: process.platform === "win32",
   });
   return status.status === 0 && /logged in using chatgpt/i.test(`${status.stdout}\n${status.stderr}`);
 }

package/src/launch.js

@@ -23,7 +23,6 @@ import { configureClaudeCodeStatusline } from "./statusline.js";
 import {
   fetchClaudeCodeModels,
   upgradeClaudeCodeModelValue,
-  writeClaudeCodeModelPresentation,
 } from "./harnesses/claude-code.js";
 import {
   fetchCodexModels,
@@ -856,6 +855,7 @@ export async function writeClaudeLaunchSettings({
   apiKey,
   models = [],
   privateGateway = false,
+  slotModels = {},
 } = {}) {
   const native = (await readJsonFile(join(homeDir(), ".claude", "settings.json"), null)) || {};
   // Claude Code gives values from --settings precedence over the parent process
@@ -883,6 +883,22 @@ export async function writeClaudeLaunchSettings({
             // An empty value is treated as unset by Claude Code, and prevents a
             // stale API key in the shared settings from creating dual auth.
             ANTHROPIC_API_KEY: "",
+            ANTHROPIC_DEFAULT_HAIKU_MODEL: "",
+            ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME: "",
+            ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION: "",
+            ANTHROPIC_DEFAULT_SONNET_MODEL: "",
+            ANTHROPIC_DEFAULT_SONNET_MODEL_NAME: "",
+            ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION: "",
+            ANTHROPIC_DEFAULT_OPUS_MODEL: "",
+            ANTHROPIC_DEFAULT_OPUS_MODEL_NAME: "",
+            ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION: "",
+            ANTHROPIC_DEFAULT_FABLE_MODEL: "",
+            ANTHROPIC_DEFAULT_FABLE_MODEL_NAME: "",
+            ANTHROPIC_DEFAULT_FABLE_MODEL_DESCRIPTION: "",
+            ...Object.fromEntries(
+              Object.entries(slotModels).filter(([slot]) => ["haiku", "sonnet", "opus", "fable"].includes(slot))
+                .map(([slot, value]) => [`ANTHROPIC_DEFAULT_${slot.toUpperCase()}_MODEL`, value]),
+            ),
           },
         }
       : {}),
@@ -892,6 +908,17 @@ export async function writeClaudeLaunchSettings({
   await privateWrite(claudeLaunchSettingsPath(), `${JSON.stringify(overlay, null, 2)}\n`);
 }
 
+function hostedClaudeSlots(models) {
+  const slots = {};
+  for (const entry of models) {
+    const match = /^claude-(haiku|sonnet|opus|fable)-/.exec(entry.model || "");
+    if (!match || slots[match[1]]) continue;
+    const oneMillion = entry.max_input_tokens >= 1000000;
+    slots[match[1]] = `${entry.model}${oneMillion ? "[1m]" : ""}`;
+  }
+  return slots;
+}
+
 function claudeCodeModelCachePath(profile) {
   return join(pennyDataDir(), `claude-models-${profile || DEFAULT_PROFILE}.json`);
 }
@@ -915,6 +942,7 @@ export async function resolveClaudeCodeLaunchModels(config) {
         // Old cache files predate the explicit server marker. Treating them as hosted
         // is the safe rollout behavior: never hide built-ins based on a guess.
         privateGateway: cached.privateGateway === true,
+        nativeCatalogLive: cached.nativeCatalogLive === true,
       };
     }
     console.error(
@@ -1326,21 +1354,23 @@ export function buildPennyInvocation(harness, args, config, models = null) {
   const env = { ...process.env, PENNYROUTER_API_KEY: config.api_key };
   if (harness === "claude") {
     env.PENNYROUTER_TITLE_SESSION_FILE = join(pennyDataDir(), `title-session-${randomUUID()}`);
-    const models = item.models || {};
+    const claudeModels = models ?? item.models ?? {};
     env.ANTHROPIC_BASE_URL = config.gateway_base_url;
     env.ANTHROPIC_AUTH_TOKEN = config.api_key;
     // Ask Claude Code to discover the gateway's model catalog at startup. The gateway
     // advertises Penny-facing ids in /v1/models; this is separate from inference routing.
     env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
     delete env.ANTHROPIC_API_KEY;
-    if (models.haiku) env.ANTHROPIC_DEFAULT_HAIKU_MODEL = upgradeClaudeCodeModelValue(models.haiku);
-    if (models.sonnet) env.ANTHROPIC_DEFAULT_SONNET_MODEL = upgradeClaudeCodeModelValue(models.sonnet);
-    if (models.opus) env.ANTHROPIC_DEFAULT_OPUS_MODEL = upgradeClaudeCodeModelValue(models.opus);
-    if (models.fable) env.ANTHROPIC_DEFAULT_FABLE_MODEL = upgradeClaudeCodeModelValue(models.fable);
+    for (const slot of ["haiku", "sonnet", "opus", "fable"]) {
+      const name = `ANTHROPIC_DEFAULT_${slot.toUpperCase()}_MODEL`;
+      if (claudeModels[slot]) env[name] = upgradeClaudeCodeModelValue(claudeModels[slot]);
+      else delete env[name];
+      delete env[`${name}_NAME`];
+      delete env[`${name}_DESCRIPTION`];
+    }
     delete env.ANTHROPIC_CUSTOM_MODEL_OPTION;
     delete env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME;
     delete env.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION;
-    writeClaudeCodeModelPresentation(env);
     // Per-model limits must come from Claude Code's recognized native model ids. This
     // global override would incorrectly give Haiku the 1M window.
     delete env.CLAUDE_CODE_MAX_CONTEXT_TOKENS;
@@ -1472,11 +1502,14 @@ export async function runPenny(argv = process.argv.slice(2)) {
     // Refresh on every launch so profile selection is honored immediately,
     // including --private, --cloud, and named profiles.
     const catalog = await resolveClaudeCodeLaunchModels(config);
+    models = catalog.privateGateway || !catalog.nativeCatalogLive
+      ? {} : hostedClaudeSlots(catalog.models);
     await writeClaudeLaunchSettings({
       gatewayBaseUrl: config.gateway_base_url,
       apiKey: config.api_key,
       models: catalog.models,
       privateGateway: catalog.privateGateway,
+      slotModels: models,
     });
   }
   if (harness === "opencode") models = await resolveOpenCodeLaunchModels(config);

package/src/launch.test.js

@@ -136,11 +136,11 @@ async function main() {
     const claudeLaunchSettings = JSON.parse(
       fs.readFileSync(claudeLaunchSettingsPath(), "utf8"),
     );
-    assert.deepEqual(claudeLaunchSettings.env, {
-      ANTHROPIC_BASE_URL: "https://gateway.example/",
-      ANTHROPIC_AUTH_TOKEN: "pr-super-secret",
-      ANTHROPIC_API_KEY: "",
-    });
+    assert.equal(claudeLaunchSettings.env.ANTHROPIC_BASE_URL, "https://gateway.example/");
+    assert.equal(claudeLaunchSettings.env.ANTHROPIC_AUTH_TOKEN, "pr-super-secret");
+    assert.equal(claudeLaunchSettings.env.ANTHROPIC_API_KEY, "");
+    assert.equal(claudeLaunchSettings.env.ANTHROPIC_DEFAULT_OPUS_MODEL, "");
+    assert.equal(claudeLaunchSettings.env.ANTHROPIC_DEFAULT_OPUS_MODEL_NAME, "");
     await writeClaudeLaunchSettings({
       gatewayBaseUrl: "https://gateway.example/",
       apiKey: "pr-super-secret",
@@ -153,6 +153,15 @@ async function main() {
       fs.readFileSync(claudeLaunchSettingsPath(), "utf8"),
     );
     assert.equal(hostedClaudeSettings.modelPicker, undefined);
+    await writeClaudeLaunchSettings({
+      gatewayBaseUrl: "https://gateway.example/",
+      apiKey: "pr-super-secret",
+      slotModels: { opus: "claude-opus-5-5[1m]" },
+    });
+    const refreshedClaudeSettings = JSON.parse(
+      fs.readFileSync(claudeLaunchSettingsPath(), "utf8"),
+    );
+    assert.equal(refreshedClaudeSettings.env.ANTHROPIC_DEFAULT_OPUS_MODEL, "claude-opus-5-5[1m]");
     await writeClaudeLaunchSettings({
       gatewayBaseUrl: "https://gateway.example/",
       apiKey: "pr-super-secret",
@@ -260,9 +269,13 @@ async function main() {
     // would wrongly hand Haiku a 1M window too.
     assert.equal(claude.env.ANTHROPIC_DEFAULT_OPUS_MODEL, "claude-opus-5[1m]");
     assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL, "claude-haiku-4-5-20251001");
-    assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME, "Haiku 4.5");
-    assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION, "Fast, economical Claude model · 200K context");
+    assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME, undefined);
+    assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION, undefined);
     assert.equal(claude.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS, undefined);
+    const refreshedClaude = buildPennyInvocation("claude", [], config, {
+      haiku: "claude-haiku-4-5-20251001", opus: "claude-opus-5-5[1m]",
+    });
+    assert.equal(refreshedClaude.env.ANTHROPIC_DEFAULT_OPUS_MODEL, "claude-opus-5-5[1m]");
 
     const proxyStartup = buildPennyInvocation("claude", ["proxy"], config);
     assert.deepEqual(proxyStartup.args.slice(-1), ["@penny auth proxy"]);
@@ -289,16 +302,20 @@ async function main() {
     assert.ok(command.includes("@penny $ARGUMENTS"));
     assert.ok(command.includes("name: penny"));
 
-    // Persistent direct-Claude installs use the same native ids and must not
-    // leave the former global 1M override behind.
+    // A hosted reinstall clears old fixed slots so Claude Code can use its live
+    // gateway catalog and its own current built-in models.
+    fs.writeFileSync(path.join(home, ".claude", "settings.json"), JSON.stringify({
+      env: { ANTHROPIC_DEFAULT_OPUS_MODEL: "claude-opus-5[1m]",
+        ANTHROPIC_DEFAULT_OPUS_MODEL_NAME: "Opus 5" },
+    }));
     await claudeCodeHarness.install({
       apiKey: "pr-super-secret",
       gatewayBaseUrl: "https://gateway.example/",
       plan: { configPath: path.join(home, ".claude", "settings.json") },
     });
     const persistedClaude = JSON.parse(fs.readFileSync(path.join(home, ".claude", "settings.json"), "utf8"));
-    assert.equal(persistedClaude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL, "claude-haiku-4-5-20251001");
-    assert.equal(persistedClaude.env.ANTHROPIC_DEFAULT_SONNET_MODEL, "claude-sonnet-5[1m]");
+    assert.equal("ANTHROPIC_DEFAULT_OPUS_MODEL" in persistedClaude.env, false);
+    assert.equal("ANTHROPIC_DEFAULT_OPUS_MODEL_NAME" in persistedClaude.env, false);
     assert.equal("CLAUDE_CODE_MAX_CONTEXT_TOKENS" in persistedClaude.env, false);
 
     // Private gateways own the model catalog. Their picker must not merge the