pennyrouter 0.3.17 → 0.3.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pennyrouter",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "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,
@@ -832,7 +841,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 +1284,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) {

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/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