pennyrouter 0.3.17 → 0.3.19

package/README.md

@@ -29,7 +29,7 @@ Installing against a self-hosted gateway is its own flow, with no browser login:
 keeps its own accounts, so the key is minted there.
 
 ```bash
-npx pennyrouter install --private-gateway https://gateway.example.internal
+npx pennyrouter install --private-gateway https://penny-router.apps-dev.gtri.org
 ```
 
 It asks for the gateway URL (unless given) and your email, and mints a key against that
@@ -44,11 +44,11 @@ ones:
 ```json
 {
   "harnesses": ["claude-code", "codex"],
-  "gatewayBaseUrl": "https://gateway.example.internal",
+  "gatewayBaseUrl": "https://penny-router.apps-dev.gtri.org",
   "claudeFunding": ["anthropic-proxy"],
-  "proxyBaseUrl": "https://litellm.example.internal",
+  "anthropicProxyBaseUrl": "https://litellm.core.gtri.org/v1",
   "codexFunding": ["openai-proxy"],
-  "openaiProxyBaseUrl": "https://litellm.example.internal"
+  "openaiProxyBaseUrl": "https://litellm.core.gtri.org/v1"
 }
 ```
 
@@ -57,6 +57,13 @@ npx pennyrouter install --config team-install.json
 ```
 
 Each person is prompted for their email and their proxy key; everything else is prefilled.
+
+For clarity, `proxyBaseUrl`/`proxyApiKey` are the legacy names for the Claude/Anthropic
+wire lane. New files should use `anthropicProxyBaseUrl`/`anthropicProxyApiKey`; Codex uses
+`openaiProxyBaseUrl`/`openaiProxyApiKey`. The `--private-server` spelling is a compatibility
+alias for `--private-gateway`.
+
+
 Any field left out of the file is prompted for, and an unattended run that cannot prompt
 refuses by name rather than installing a half-configured harness. Add `email`, `proxyApiKey`
 and `openaiProxyApiKey` to the file to skip the prompts entirely.

package/package.json

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

package/src/cli.js

@@ -19,13 +19,14 @@ import {
 } from "./harnesses/claude-code.js";
 import { clineHarness } from "./harnesses/cline.js";
 import { codeGptHarness } from "./harnesses/codegpt.js";
-import { codexHarness, detectCodexChatgptAuth } from "./harnesses/codex.js";
+import { codexHarness, detectCodexChatgptAuth, isHostedPennyRouterGateway } from "./harnesses/codex.js";
 import { fetchOpenCodeModels, opencodeHarness } from "./harnesses/opencode.js";
 import { windsurfHarness } from "./harnesses/windsurf.js";
 import { zedHarness } from "./harnesses/zed.js";
 import {
   APP_URL,
   createCliSession,
+  fetchGatewayCapabilities,
   forgetAnthropicToken,
   forgetUpstreamCredential,
   maskKey,
@@ -36,6 +37,14 @@ import {
   storeAnthropicToken,
   storeUpstreamCredential,
 } from "./session.js";
+
+async function codexNativeAuthAvailable({ gatewayBaseUrl, apiKey, localAuth }) {
+  if (!isHostedPennyRouterGateway(gatewayBaseUrl)) return false;
+  const capabilities = await fetchGatewayCapabilities({ gatewayBaseUrl, apiKey });
+  const hasOpenAiCredential = Array.isArray(capabilities?.upstream_credentials)
+    && capabilities.upstream_credentials.includes("openai_api");
+  return Boolean(localAuth || hasOpenAiCredential);
+}
 import {
   backupFile,
   compactHome,
@@ -225,6 +234,10 @@ function parseArgs(argv) {
     else if (arg.startsWith("--openai-proxy-base-url=")) flags.openaiProxyBaseUrl = arg.slice("--openai-proxy-base-url=".length);
     else if (arg === "--openai-proxy-api-key") flags.openaiProxyApiKey = rest[++i] || "";
     else if (arg.startsWith("--openai-proxy-api-key=")) flags.openaiProxyApiKey = arg.slice("--openai-proxy-api-key=".length);
+    else if (arg === "--anthropic-proxy-base-url") flags.proxyBaseUrl = rest[++i] || "";
+    else if (arg.startsWith("--anthropic-proxy-base-url=")) flags.proxyBaseUrl = arg.slice("--anthropic-proxy-base-url=".length);
+    else if (arg === "--anthropic-proxy-api-key") flags.proxyApiKey = rest[++i] || "";
+    else if (arg.startsWith("--anthropic-proxy-api-key=")) flags.proxyApiKey = arg.slice("--anthropic-proxy-api-key=".length);
     else if (arg === "--proxy-base-url") flags.proxyBaseUrl = rest[++i] || "";
     else if (arg.startsWith("--proxy-base-url=")) flags.proxyBaseUrl = arg.slice("--proxy-base-url=".length);
     else if (arg === "--proxy-api-key") flags.proxyApiKey = rest[++i] || "";
@@ -241,17 +254,17 @@ function parseArgs(argv) {
     // --gateway-base-url, which expects the URL and an admin-issued key up front, this asks
     // for what it needs (gateway URL, then email) and mints the key from the gateway itself,
     // so a user on a VPN can install without an administrator handing them a key first.
-    else if (arg === "--private-gateway") {
+    else if (arg === "--private-gateway" || arg === "--private-server") {
       flags.privateGatewayFlow = true;
       flags.privateGateway = true;
       // Optional inline URL: `--private-gateway https://...` rather than a prompt. Only
       // consume the next argument when it is not itself a flag.
       if (rest[i + 1] && !rest[i + 1].startsWith("-")) flags.gatewayBaseUrl = rest[++i];
     }
-    else if (arg.startsWith("--private-gateway=")) {
+    else if (arg.startsWith("--private-gateway=") || arg.startsWith("--private-server=")) {
       flags.privateGatewayFlow = true;
       flags.privateGateway = true;
-      flags.gatewayBaseUrl = arg.slice("--private-gateway=".length);
+      flags.gatewayBaseUrl = arg.slice(arg.indexOf("=") + 1);
     }
     // Email the private gateway mints the key against; prompted for when absent.
     else if (arg === "--email") flags.email = rest[++i] || "";
@@ -319,6 +332,15 @@ export function applyConfigFile(flags) {
   if (config.harnesses && flags.harness === undefined) {
     flags.harness = config.harnesses.join(",");
   }
+  // Migrate the ambiguous Claude proxy keys in-memory. Existing shared install files remain
+  // valid while new files can say explicitly which wire lane they configure.
+  if (config.anthropicProxyBaseUrl === undefined && config.proxyBaseUrl !== undefined) {
+    config.anthropicProxyBaseUrl = config.proxyBaseUrl;
+  }
+  if (config.anthropicProxyApiKey === undefined && config.proxyApiKey !== undefined) {
+    config.anthropicProxyApiKey = config.proxyApiKey;
+  }
+
   const claudeFunding = new Set(config.claudeFunding || []);
   const codexFunding = new Set(config.codexFunding || []);
   if (claudeFunding.has("subscription") && flags.anthropicAuth === undefined) {
@@ -349,6 +371,15 @@ export function applyConfigFile(flags) {
     const value = String(config[field.config_key] || "").trim();
     if (value && flags[field.config_key] === undefined) flags[field.config_key] = value;
   }
+  // ``proxy*`` was the original Claude/Anthropic naming. Keep it as an input alias, but
+  // normalize the explicit JSON names back to the internal flags used by the installer.
+  if (flags.proxyBaseUrl === undefined && flags.anthropicProxyBaseUrl !== undefined) {
+    flags.proxyBaseUrl = flags.anthropicProxyBaseUrl;
+  }
+  if (flags.proxyApiKey === undefined && flags.anthropicProxyApiKey !== undefined) {
+    flags.proxyApiKey = flags.anthropicProxyApiKey;
+  }
+
   if (flags.gatewayBaseUrl) {
     flags.privateGateway = true;
     // Take the self-hosted install path rather than the hosted browser claim, whose key is
@@ -832,7 +863,13 @@ export async function install(flags = {}) {
 
       const harnessNeededAuth = needsAuth.includes(harness);
       const codexSubscriptionAuth = harness.id === "codex"
-        ? (harnessNeededAuth ? funding.codexSubscriptionAuth : Boolean(existingRecord?.openai_subscription_auth))
+        ? await codexNativeAuthAvailable({
+            gatewayBaseUrl: gatewayBaseUrl,
+            apiKey: claim.api_key,
+            localAuth: harnessNeededAuth
+              ? funding.codexSubscriptionAuth
+              : Boolean(existingRecord?.openai_subscription_auth),
+          })
         : false;
       const claudeSubscriptionAuth = harness.id === "claude-code"
         && Boolean(claudeAnthropicAuth || existingRecord?.anthropic_token_stored);
@@ -1269,7 +1306,11 @@ async function update(flags) {
       const claudeSubscriptionAuth = record.harness === "claude-code"
         && Boolean(record.anthropic_token_stored);
       const codexSubscriptionAuth = record.harness === "codex"
-        ? await detectCodexChatgptAuth()
+        ? await codexNativeAuthAvailable({
+            gatewayBaseUrl,
+            apiKey,
+            localAuth: await detectCodexChatgptAuth(),
+          })
         : false;
 
       if (supportsPennyCommand) {
@@ -1404,8 +1445,10 @@ async function selectClaudeFundingProviders(flags, selected) {
       || process.env.ANTHROPIC_AUTH_TOKEN)) supplied.add("subscription");
   if (flags.anthropicApiKey || process.env.ANTHROPIC_API_KEY) supplied.add("anthropic-api");
   if (flags.openrouterApiKey || process.env.OPENROUTER_API_KEY) supplied.add("openrouter");
-  if ((flags.proxyBaseUrl || process.env.PENNYROUTER_PROXY_BASE_URL)
-      && (flags.proxyApiKey || process.env.PENNYROUTER_PROXY_API_KEY)) {
+  if ((flags.proxyBaseUrl || process.env.PENNYROUTER_ANTHROPIC_PROXY_BASE_URL
+      || process.env.PENNYROUTER_PROXY_BASE_URL)
+      && (flags.proxyApiKey || process.env.PENNYROUTER_ANTHROPIC_PROXY_API_KEY
+      || process.env.PENNYROUTER_PROXY_API_KEY)) {
     supplied.add("anthropic-proxy");
   }
   // A --config file states its providers outright, and that choice stands whether or not the
@@ -1540,10 +1583,14 @@ async function configureUserFunding(flags, selected, claudeAnthropicAuth,
     flags.openaiProxyApiKey || process.env.PENNYROUTER_OPENAI_PROXY_API_KEY || "",
   ).trim();
   let proxyBaseUrl = String(
-    flags.proxyBaseUrl || process.env.PENNYROUTER_PROXY_BASE_URL || "",
+    flags.proxyBaseUrl || flags.anthropicProxyBaseUrl
+      || process.env.PENNYROUTER_ANTHROPIC_PROXY_BASE_URL
+      || process.env.PENNYROUTER_PROXY_BASE_URL || "",
   ).trim();
   let proxyApiKey = String(
-    flags.proxyApiKey || process.env.PENNYROUTER_PROXY_API_KEY || "",
+    flags.proxyApiKey || flags.anthropicProxyApiKey
+      || process.env.PENNYROUTER_ANTHROPIC_PROXY_API_KEY
+      || process.env.PENNYROUTER_PROXY_API_KEY || "",
   ).trim();
   const codexSubscriptionAuth = wantsCodex && codexProviders.has("subscription")
     ? await detectCodexChatgptAuth()
@@ -2382,7 +2429,7 @@ function printHelp() {
   console.log(`PennyRouter CLI
 
 Usage:
-  pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--make-default|--penny-only] [--no-path-update] [--no-mcp] [--anthropic-auth|--no-anthropic-auth] [--anthropic-api-key KEY] [--openai-api-key KEY] [--openai-proxy-base-url URL --openai-proxy-api-key KEY] [--openrouter-api-key KEY] [--proxy-base-url URL --proxy-api-key KEY] [--private-gateway[=URL] [--email you@example.com]] [--gateway-base-url URL] [--private-key pr-...] [--local[=URL]|--prod] [--config PATH]
+  pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--make-default|--penny-only] [--no-path-update] [--no-mcp] [--anthropic-auth|--no-anthropic-auth] [--anthropic-api-key KEY] [--openai-api-key KEY] [--openai-proxy-base-url URL --openai-proxy-api-key KEY] [--openrouter-api-key KEY] [--anthropic-proxy-base-url URL --anthropic-proxy-api-key KEY] [--proxy-base-url URL --proxy-api-key KEY] [--private-gateway|--private-server[=URL] [--email you@example.com]] [--gateway-base-url URL] [--private-key pr-...] [--local[=URL]|--prod] [--config PATH]
   pennyrouter update [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--dry-run] [--penny-key pr-...] [--gateway-base-url URL|--local[=URL]|--prod] [--no-mcp]
   pennyrouter auth anthropic [--penny-key pr-...] [--token oauth-token] [--token-command CMD] [--gateway-base-url URL] [--forget]
   pennyrouter disable [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]

package/src/harnesses/codex.js

@@ -103,6 +103,12 @@ export function renderCodexConfig(
   text,
   { apiKey, gatewayBaseUrl, subscriptionAuth, surface = "codex-terminal" },
 ) {
+  // Native Codex subscription/WebSocket auth is valid only through PennyRouter's hosted
+  // cloud gateway. Local, private, proxy, and other custom gateways must always use the
+  // ordinary PennyRouter bearer provider, even when Codex itself is logged into ChatGPT.
+  // Keep this guard at the final renderer so every install/update/desktop path gets the
+  // same safety rule regardless of which profile selected it.
+  subscriptionAuth = Boolean(subscriptionAuth && isHostedPennyRouterGateway(gatewayBaseUrl));
   const clean = removeManagedCodexConfig(text, { removeRootProvider: true }).trimEnd();
   if (new RegExp(`^\\s*\\[model_providers\\.${escapeRegex(PROVIDER_ID)}\\]\\s*$`, "m").test(clean)) {
     throw new Error(
@@ -142,6 +148,14 @@ export function renderCodexConfig(
   return `${lines.join("\n").replace(/\n{3,}/g, "\n\n").trim()}\n`;
 }
 
+export function isHostedPennyRouterGateway(gatewayBaseUrl) {
+  try {
+    return new URL(String(gatewayBaseUrl)).hostname.toLowerCase() === "api.pennyrouter.com";
+  } catch {
+    return false;
+  }
+}
+
 export function removeManagedCodexConfig(text, { removeRootProvider = false } = {}) {
   let out = String(text || "").replace(
     new RegExp(`${escapeRegex(MANAGED_START)}[\\s\\S]*?${escapeRegex(MANAGED_END)}\\n?`, "g"),

package/src/harnesses/codex.test.js

@@ -8,6 +8,7 @@ import {
   codexUsesChatgptAuth,
   removeManagedCodexConfig,
   renderCodexConfig,
+  isHostedPennyRouterGateway,
 } from "./codex.js";
 
 function testAuthDetection() {
@@ -21,13 +22,13 @@ function testSubscriptionProviderIsRootSafe() {
   const original = `model = "gpt-test"\n\n[features]\nplugins = false\n`;
   const next = renderCodexConfig(original, {
     apiKey: "pr-test-secret",
-    gatewayBaseUrl: "http://localhost:8400/",
+    gatewayBaseUrl: "https://api.pennyrouter.com/",
     subscriptionAuth: true,
   });
 
   assert.ok(next.indexOf('model_provider = "pennyrouter"') < next.indexOf("[features]"));
   assert.ok(next.includes('[model_providers.pennyrouter]'));
-  assert.ok(next.includes('base_url = "http://localhost:8400/v1"'));
+  assert.ok(next.includes('base_url = "https://api.pennyrouter.com/v1"'));
   assert.ok(next.includes("requires_openai_auth = true"));
   assert.ok(next.includes('"x-pennyrouter-key" = "pr-test-secret"'));
   assert.ok(next.includes('"x-pennyrouter-harness" = "codex"'));
@@ -36,6 +37,26 @@ function testSubscriptionProviderIsRootSafe() {
   assert.equal((next.match(/# --- PennyRouter managed Codex provider ---/g) || []).length, 1);
 }
 
+function testPrivateAndProxyGatewaysNeverEnableNativeSubscription() {
+  assert.equal(isHostedPennyRouterGateway("https://api.pennyrouter.com"), true);
+  for (const gateway of [
+    "http://localhost:8400",
+    "https://private.example.test",
+    "https://openrouter.example.test",
+  ]) {
+    assert.equal(isHostedPennyRouterGateway(gateway), false);
+    const next = renderCodexConfig("", {
+      apiKey: "pr-private",
+      gatewayBaseUrl: gateway,
+      subscriptionAuth: true,
+    });
+    assert.ok(next.includes('model_provider = "pennyrouter"'));
+    assert.ok(next.includes('experimental_bearer_token = "pr-private"'));
+    assert.ok(!next.includes("requires_openai_auth"));
+    assert.ok(next.includes('supports_websockets = false'));
+  }
+}
+
 function testLegacyMigrationAndIdempotence() {
   const legacy = `[features]\nplugins = false\nopenai_base_url = "http://old/v1"\nopenai_api_key = "pr-old"\n`;
   const once = renderCodexConfig(legacy, {
@@ -115,6 +136,7 @@ async function testReinstallPreservesRecordedProvider() {
 
 testAuthDetection();
 testSubscriptionProviderIsRootSafe();
+testPrivateAndProxyGatewaysNeverEnableNativeSubscription();
 testLegacyMigrationAndIdempotence();
 testProviderCollisionFailsClosed();
 testUninstallLeavesUserConfig();

package/src/install-manifest.json

@@ -56,12 +56,12 @@
           "name": "Proxy (e.g., Bedrock, Azure, private server)",
           "fields": [
             {
-              "config_key": "proxyBaseUrl",
-              "label": "Proxy base URL",
+              "config_key": "anthropicProxyBaseUrl",
+              "label": "Anthropic proxy base URL",
               "secret": false,
               "placeholder": "https://proxy.example.com"
             },
-            { "config_key": "proxyApiKey", "label": "Proxy API key", "secret": true }
+            { "config_key": "anthropicProxyApiKey", "label": "Anthropic proxy API key", "secret": true }
           ]
         }
       ]

package/src/launch.js

@@ -390,6 +390,16 @@ export async function installPennyRuntime({ updatePath = true } = {}) {
 }
 
 export function renderCodexLaunchProfile({ gatewayBaseUrl, subscriptionAuth }) {
+  // Private/proxy/custom gateways never use Codex's native subscription/WebSocket lane.
+  // Apply the same hosted-only rule as the Codex config renderer at this launch-profile
+  // boundary, since this path is what bare `penny codex` selects at runtime.
+  try {
+    subscriptionAuth = Boolean(
+      subscriptionAuth && new URL(String(gatewayBaseUrl)).hostname.toLowerCase() === "api.pennyrouter.com",
+    );
+  } catch {
+    subscriptionAuth = false;
+  }
   if (subscriptionAuth) {
     return [
       CODEX_PROFILE_MARKER,

package/src/launch.test.js

@@ -187,14 +187,14 @@ async function main() {
     const desktopConfig = fs.readFileSync(path.join(desktopHome, "config.toml"), "utf8");
     assert.match(desktopConfig, /^model_provider = "pennyrouter"/);
     assert.match(desktopConfig, /\[model_providers\.pennyrouter\]/);
-    assert.match(desktopConfig, /"x-pennyrouter-key" = "pr-super-secret"/);
+    assert.match(desktopConfig, /experimental_bearer_token = "pr-super-secret"/);
     assert.match(desktopConfig, /"x-pennyrouter-surface" = "codex-desktop"/);
     assert.equal(fs.readFileSync(path.join(home, ".codex", "config.toml"), "utf8"), nativeCodex);
     fs.rmSync(desktopHome, { recursive: true, force: true });
     const codexProfile = fs.readFileSync(codexLaunchProfilePath(), "utf8");
-    assert.match(codexProfile, /model_provider = "openai"/);
-    assert.match(codexProfile, /openai_base_url = "https:\/\/gateway\.example"/);
-    assert.ok(!codexProfile.includes("[model_providers.pennyrouter]"));
+    assert.match(codexProfile, /model_provider = "pennyrouter"/);
+    assert.match(codexProfile, /base_url = "https:\/\/gateway\.example\/v1"/);
+    assert.ok(codexProfile.includes("[model_providers.pennyrouter]"));
     assert.ok(codexProfile.includes("[tui]\nterminal_title = []"));
     assert.ok(!codexProfile.includes("pr-super-secret"));
     assert.ok(!rc.includes("pr-super-secret"));

package/src/session.js

@@ -71,6 +71,17 @@ export async function storeUpstreamCredential({ gatewayBaseUrl, apiKey, provider
   return response.json();
 }
 
+export async function fetchGatewayCapabilities({ gatewayBaseUrl, apiKey }) {
+  const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/auth/capabilities`;
+  try {
+    const response = await fetch(url, { headers: { authorization: `Bearer ${apiKey}` } });
+    if (!response.ok) return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+
 // Mint a key on a private gateway that has self-service provisioning enabled. The hosted
 // browser claim mints against pennyrouter.com's key store, which a private gateway does not
 // share, so this is the equivalent step for a self-hosted install. A gateway that has not