pennyrouter 0.2.19 → 0.2.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pennyrouter",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "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/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);
   }

package/src/statusline.js

@@ -46,6 +46,7 @@ export async function configureClaudeCodeStatusline(current) {
   current.statusLine = {
     type: "command",
     command: `node "${statuslineScriptPath()}"`,
+    refreshInterval: 1,
     ...(existing?.padding !== undefined ? { padding: existing.padding } : {}),
   };
   return { script_path: statuslineScriptPath(), wrapped: Boolean(config.wrap_command) };
@@ -164,13 +165,28 @@ function askBadges(c) {
   return out;
 }
 
+// Cache warmth countdown: when a prompt cache prefix is live, show time remaining.
+// The gateway sends cache_expires_at (absolute Unix timestamp); we interpolate locally
+// so it ticks down smoothly every statusline render (every ~1s), only "jumping" when
+// the gateway refreshes (~15s) with a fresh timestamp.
+function cacheWarmth(c) {
+  if (!c || typeof c.cache_expires_at !== "number" || c.cache_expires_at <= 0) {
+    return "";
+  }
+  const remaining = c.cache_expires_at - Date.now() / 1000;
+  if (remaining <= 0) return "";
+  const minutes = Math.floor(remaining / 60);
+  const seconds = Math.floor(remaining % 60);
+  return " · 🔥 warm " + minutes + ":" + String(seconds).padStart(2, "0");
+}
+
 let penny;
 if (!pennyInstalled) {
   penny = "🪙 penny off";
 } else if (cache && cache.known && cache.bypass) {
   penny = "🪙 penny off";
 } else {
-  penny = "🪙 penny" + authSuffix(cache && cache.auth_mode) + askBadges(cache);
+  penny = "🪙 penny" + authSuffix(cache && cache.auth_mode) + askBadges(cache) + cacheWarmth(cache);
 }
 
 let lines;