pennyrouter 0.2.18 → 0.2.20

package/package.json

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

package/src/cli.js

@@ -8,6 +8,7 @@ import { mcpStatus, registerMcp } from "./mcp-register.js";
 
 /** The harnesses that can run an MCP server. The other supported harnesses cannot. */
 const MCP_HARNESS_IDS = ["claude-code", "codex"];
+const DEFAULT_GATEWAY_BASE_URL = "https://api.pennyrouter.com";
 import {
   CLAUDE_CODE_MODELS,
   claudeCodeHarness,
@@ -203,7 +204,7 @@ async function authProvider(flags) {
         "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";
+    const gatewayBaseUrl = flags.gatewayBaseUrl || process.env.PENNYROUTER_GATEWAY_BASE_URL || DEFAULT_GATEWAY_BASE_URL;
     if (flags.dryRun) {
       console.log(`Will delete stored Anthropic token from gateway: ${gatewayBaseUrl}`);
       return;
@@ -255,7 +256,7 @@ async function authProvider(flags) {
     );
   }
 
-  const gatewayBaseUrl = flags.gatewayBaseUrl || process.env.PENNYROUTER_GATEWAY_BASE_URL || "https://api.pennyrouter.com";
+  const gatewayBaseUrl = flags.gatewayBaseUrl || process.env.PENNYROUTER_GATEWAY_BASE_URL || DEFAULT_GATEWAY_BASE_URL;
   const manifest = await loadManifest();
   const existingRecord = (manifest.installations || []).find(
     (candidate) => candidate.harness === "claude-code",
@@ -593,7 +594,9 @@ export async function install(flags = {}) {
   // Registered after routing, which is the primary job: a naming conflict here reports itself
   // and leaves a working install rather than failing the whole run.
   if (!flags.noMcp && !flags.dryRun) {
-    const mcp = await registerMcp(records.map((r) => r.harness));
+    const mcp = await registerMcp(records.map((r) => r.harness), {
+      gatewayBaseUrl: customGatewayBaseUrl(gatewayBaseUrl),
+    });
     const registered = mcp.filter((r) => r.changed).map((r) => HARNESS_BY_ID[r.harness]?.name);
     if (registered.length) {
       console.log("");
@@ -636,8 +639,20 @@ function mcpTargets(flags) {
   return requested.length ? requested : MCP_HARNESS_IDS;
 }
 
+/** The gateway URL worth pinning into the MCP entry, or "" for the default.
+    The MCP server already falls back to production on its own, so writing that value would only
+    freeze today's default into every user's config. */
+function customGatewayBaseUrl(url) {
+  const value = String(url || "").trim().replace(/\/+$/, "");
+  return !value || value === DEFAULT_GATEWAY_BASE_URL ? "" : value;
+}
+
 async function installMcp(flags) {
-  const results = await registerMcp(mcpTargets(flags));
+  const results = await registerMcp(mcpTargets(flags), {
+    gatewayBaseUrl: customGatewayBaseUrl(
+      flags.gatewayBaseUrl || process.env.PENNYROUTER_GATEWAY_BASE_URL,
+    ),
+  });
   console.log("PennyRouter Threads MCP");
   console.log("");
   for (const result of results) {
@@ -688,7 +703,7 @@ async function serveMcp(flags) {
     || launchConfig.gateway_base_url
     || globalAuth.gatewayBaseUrl
     || process.env.PENNYROUTER_GATEWAY_BASE_URL
-    || "https://api.pennyrouter.com";
+    || DEFAULT_GATEWAY_BASE_URL;
 
   await runMcpServer({
     gatewayBaseUrl,
@@ -741,7 +756,7 @@ async function update(flags) {
     || launchConfig.gateway_base_url
     || globalAuth.gatewayBaseUrl
     || process.env.PENNYROUTER_GATEWAY_BASE_URL
-    || "https://api.pennyrouter.com";
+    || DEFAULT_GATEWAY_BASE_URL;
 
   if (!apiKey) {
     throw new Error(
@@ -832,7 +847,9 @@ async function update(flags) {
   // and `pennyrouter mcp uninstall` removes it for good.
   if (!flags.dryRun && !flags.noMcp) {
     const wanted = targets.filter((record) => MCP_HARNESS_IDS.includes(record.harness));
-    const results = await registerMcp(wanted.map((record) => record.harness));
+    const results = await registerMcp(wanted.map((record) => record.harness), {
+      gatewayBaseUrl: customGatewayBaseUrl(gatewayBaseUrl),
+    });
     const added = results.filter((r) => r.changed).map((r) => HARNESS_BY_ID[r.harness]?.name);
     if (added.length) console.log(`Registered the Threads MCP server on ${added.join(" and ")}.`);
     for (const result of results.filter((r) => r.error)) {

package/src/harnesses/claude-code.js

@@ -4,15 +4,19 @@ import { configureClaudeCodeStatusline, restoreClaudeCodeStatusline } from "../s
 const CONFIG_PATH = "~/.claude/settings.json";
 const LEGACY_MODEL_LABEL = "PennyRouter Bundle";
 const CONNECTOR_SETTING = "disableClaudeAiConnectors";
-// The slot values remain genuine Anthropic ids so Claude Code recognizes their actual context
-// windows (Haiku 200K; the 1M-capable models 1M) and sends the native id on the wire. Claude
-// Code separately supports *_MODEL_NAME and *_MODEL_DESCRIPTION for the picker, so Penny can
-// present a friendly alias without sacrificing model recognition.
+// The slot values remain genuine Anthropic ids so Claude Code recognizes them and sends the
+// native id on the wire. Claude Code separately supports *_MODEL_NAME and *_MODEL_DESCRIPTION
+// for the picker, so Penny can present a friendly alias without sacrificing model recognition.
+//
+// The 1M-context variant is a `[1m]` suffix on the id — Claude Code does NOT infer a 1M window
+// from a bare id, so a bare `claude-sonnet-5` gets 200K and auto-compacts around 150K. The
+// suffix rides the wire; the gateway strips it for the upstream model and turns it into the
+// `context-1m` beta header. Haiku has no 1M variant, so it stays bare.
 export const CLAUDE_CODE_MODELS = {
   haiku: "claude-haiku-4-5-20251001",
-  sonnet: "claude-sonnet-5",
-  opus: "claude-opus-5",
-  fable: "claude-fable-5",
+  sonnet: "claude-sonnet-5[1m]",
+  opus: "claude-opus-5[1m]",
+  fable: "claude-fable-5[1m]",
   custom: "Penny Custom",             // -> dynamic (PennyRouter cost-routing)
 };
 const CLAUDE_CODE_MODEL_PRESENTATION = {

package/src/launch.test.js

@@ -103,7 +103,10 @@ async function main() {
     assert.ok(!claude.args.includes("--plugin-dir"));
     assert.equal(claude.env.ANTHROPIC_AUTH_TOKEN, "pr-super-secret");
     assert.equal(claude.env.ANTHROPIC_BASE_URL, "https://gateway.example/");
-    assert.equal(claude.env.ANTHROPIC_DEFAULT_OPUS_MODEL, "claude-opus-5");
+    // 1M-capable slots carry the `[1m]` suffix; Haiku has no 1M variant and stays bare.
+    // Per-slot suffixes, not the global CLAUDE_CODE_MAX_CONTEXT_TOKENS override, which
+    // 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 (PennyRouter)");
     assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION, "Fast, economical Claude model · 200K context");
@@ -128,7 +131,7 @@ async function main() {
     });
     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");
+    assert.equal(persistedClaude.env.ANTHROPIC_DEFAULT_SONNET_MODEL, "claude-sonnet-5[1m]");
     assert.equal("CLAUDE_CODE_MAX_CONTEXT_TOKENS" in persistedClaude.env, false);
 
     await removePennyHarness("claude-code");

package/src/mcp-register.js

@@ -29,12 +29,21 @@ const CODEX_CONFIG = "~/.codex/config.toml";
 const MANAGED_START = "# --- PennyRouter managed MCP server ---";
 const MANAGED_END = "# --- end PennyRouter managed MCP server ---";
 
-/** What we register. Shared by both harnesses so the two configs cannot drift apart. */
-export function serverEntry(harness = "claude-code") {
+/** What we register. Shared by both harnesses so the two configs cannot drift apart.
+
+    `gatewayBaseUrl` is pinned into the entry only when the install targeted a non-default
+    gateway. The MCP server is spawned later by the harness, in a process that shares nothing
+    with the install run, so a base URL chosen at install time reaches it only by being written
+    here. Omitted when unset, which keeps default installs byte-identical to earlier versions. */
+export function serverEntry(harness = "claude-code", gatewayBaseUrl = "") {
+  const url = String(gatewayBaseUrl || "").trim();
   return {
     command: "npx",
     args: ["-y", "pennyrouter", "mcp"],
-    env: { PENNYROUTER_MCP_HARNESS: harness },
+    env: {
+      PENNYROUTER_MCP_HARNESS: harness,
+      ...(url ? { PENNYROUTER_GATEWAY_BASE_URL: url } : {}),
+    },
   };
 }
 
@@ -48,7 +57,7 @@ export function isManagedEntry(entry) {
 
 // -- Claude Code ----------------------------------------------------------
 
-export function applyClaudeRegistry(config, { remove = false } = {}) {
+export function applyClaudeRegistry(config, { remove = false, gatewayBaseUrl = "" } = {}) {
   const next = { ...(config || {}) };
   const servers = { ...(next.mcpServers || {}) };
 
@@ -63,7 +72,7 @@ export function applyClaudeRegistry(config, { remove = false } = {}) {
           "write. Rename it before installing so your configuration is not overwritten.",
       );
     }
-    servers[SERVER_NAME] = serverEntry("claude-code");
+    servers[SERVER_NAME] = serverEntry("claude-code", gatewayBaseUrl);
   }
 
   if (Object.keys(servers).length) next.mcpServers = servers;
@@ -71,14 +80,14 @@ export function applyClaudeRegistry(config, { remove = false } = {}) {
   return next;
 }
 
-async function writeClaude({ remove }) {
+async function writeClaude({ remove, gatewayBaseUrl }) {
   if (!(await exists(CLAUDE_REGISTRY))) {
     // Claude Code writes this on first run. Creating it ourselves risks clobbering a shape we
     // do not own, so skip rather than guess.
     return { changed: false, reason: "Claude Code config not found" };
   }
   const current = (await readJsonFile(CLAUDE_REGISTRY, null)) || {};
-  const next = applyClaudeRegistry(current, { remove });
+  const next = applyClaudeRegistry(current, { remove, gatewayBaseUrl });
   if (JSON.stringify(next) === JSON.stringify(current)) return { changed: false };
 
   await backupFile(CLAUDE_REGISTRY, "mcp");
@@ -88,7 +97,7 @@ async function writeClaude({ remove }) {
 
 // -- Codex ----------------------------------------------------------------
 
-export function renderCodexMcp(text, { remove = false } = {}) {
+export function renderCodexMcp(text, { remove = false, gatewayBaseUrl = "" } = {}) {
   const clean = removeManagedCodexMcp(text).trimEnd();
   if (remove) return clean ? `${clean}\n` : "";
 
@@ -100,13 +109,18 @@ export function renderCodexMcp(text, { remove = false } = {}) {
     );
   }
 
-  const entry = serverEntry("codex");
+  const entry = serverEntry("codex", gatewayBaseUrl);
+  // Rendered from entry.env rather than a fixed line, so a key added to serverEntry reaches both
+  // harnesses instead of silently appearing only in Claude Code's JSON.
+  const env = Object.entries(entry.env)
+    .map(([key, value]) => `${key} = "${value}"`)
+    .join(", ");
   const block = [
     MANAGED_START,
     `[mcp_servers.${SERVER_NAME}]`,
     `command = "${entry.command}"`,
     `args = [${entry.args.map((a) => `"${a}"`).join(", ")}]`,
-    `env = { PENNYROUTER_MCP_HARNESS = "${entry.env.PENNYROUTER_MCP_HARNESS}" }`,
+    `env = { ${env} }`,
     MANAGED_END,
   ].join("\n");
 
@@ -130,10 +144,10 @@ function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-async function writeCodex({ remove }) {
+async function writeCodex({ remove, gatewayBaseUrl }) {
   if (!(await exists(CODEX_CONFIG))) return { changed: false, reason: "Codex config not found" };
   const current = await readFile(expandHome(CODEX_CONFIG), "utf8").catch(() => "");
-  const next = renderCodexMcp(current, { remove });
+  const next = renderCodexMcp(current, { remove, gatewayBaseUrl });
   if (next === current) return { changed: false };
 
   await backupFile(CODEX_CONFIG, "mcp");
@@ -181,13 +195,13 @@ export async function mcpStatus(harnessIds = Object.keys(WRITERS)) {
  * Register (or with `remove`, unregister) the MCP server for `harnessIds`.
  * Returns one result per harness; a harness whose config is absent is skipped, not an error.
  */
-export async function registerMcp(harnessIds, { remove = false } = {}) {
+export async function registerMcp(harnessIds, { remove = false, gatewayBaseUrl = "" } = {}) {
   const results = [];
   for (const id of harnessIds) {
     const writer = WRITERS[id];
     if (!writer) continue;
     try {
-      results.push({ harness: id, ...(await writer({ remove })) });
+      results.push({ harness: id, ...(await writer({ remove, gatewayBaseUrl })) });
     } catch (error) {
       // A conflict must not fail the whole install: routing is the primary job and is already
       // done by this point. Report it and let the user resolve the name.

package/src/mcp-register.test.js

@@ -20,6 +20,33 @@ import {
   assert.equal(entry.env.PENNYROUTER_MCP_HARNESS, "claude-code");
   assert.ok(!JSON.stringify(entry).includes("/"), "no absolute paths");
   assert.ok(!/pennyrouter@/.test(JSON.stringify(entry)), "not version-pinned");
+  assert.ok(!("PENNYROUTER_GATEWAY_BASE_URL" in entry.env), "no URL pinned by default");
+}
+
+// A non-default gateway must be pinned into the entry. The MCP server is spawned later by the
+// harness, in a process that never sees the install run's flags, so `--local` reaches it only
+// through the written config. Regression: `--local` used to set the URL for the install process
+// alone, leaving the registered server pointed at production and every transfer failing there.
+{
+  const local = serverEntry("claude-code", "http://localhost:8400");
+  assert.equal(local.env.PENNYROUTER_GATEWAY_BASE_URL, "http://localhost:8400");
+  assert.equal(local.env.PENNYROUTER_MCP_HARNESS, "claude-code");
+
+  // Both harnesses carry it, or the two configs drift apart.
+  const toml = renderCodexMcp("", { gatewayBaseUrl: "http://localhost:8400" });
+  assert.match(toml, /PENNYROUTER_MCP_HARNESS = "codex"/);
+  assert.match(toml, /PENNYROUTER_GATEWAY_BASE_URL = "http:\/\/localhost:8400"/);
+
+  // Default installs stay byte-identical, so existing entries are not rewritten on update.
+  assert.equal(renderCodexMcp(""), renderCodexMcp("", { gatewayBaseUrl: "" }));
+  assert.ok(!renderCodexMcp("").includes("PENNYROUTER_GATEWAY_BASE_URL"));
+
+  const claude = applyClaudeRegistry({}, { gatewayBaseUrl: "http://localhost:8400" });
+  assert.equal(
+    claude.mcpServers[SERVER_NAME].env.PENNYROUTER_GATEWAY_BASE_URL,
+    "http://localhost:8400",
+  );
+  assert.ok(isManagedEntry(claude.mcpServers[SERVER_NAME]), "still ours after pinning a URL");
 }
 
 // -- Claude Code registry -------------------------------------------------

package/src/mcp.test.js

@@ -123,7 +123,9 @@ const workspace = mkdtempSync(join(tmpdir(), "pr-mcp-ws-"));
   // the model explained the silence as a "size/display limitation" and fell back to fetching
   // the share URL directly — pulling 574KB of JS-shell markup into the context that
   // thread_resume exists to protect. The descriptions have to rule that out explicitly.
+  // Only the share-link tools: thread_transfer takes no URL, so there is no URL to fetch instead.
   for (const tool of byId.get(2).result.tools) {
+    if (!tool.inputSchema?.properties?.url) continue;
     assert.match(tool.description, /not fetch|Never fall back to fetching/i, tool.name);
     assert.match(tool.description, /blocked/i, tool.name);
   }