pennyrouter 0.3.14 → 0.3.16

package/package.json

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

package/src/harnesses/opencode.js

@@ -146,6 +146,36 @@ export const opencodeHarness = {
   },
 };
 
+/**
+ * Drop the persistent PennyRouter provider block from OpenCode's config.
+ *
+ * `penny opencode` supplies the provider per launch instead. OpenCode deep-merges the
+ * launch config over this file rather than replacing it, so a block left here would
+ * union its retired models into the picker and pin every session to whichever gateway
+ * was installed last. It also holds an API key in plaintext that the launch path keeps
+ * in the process environment instead.
+ */
+export async function stripPersistentOpenCodeProvider() {
+  const configPath = (await exists(JSONC_PATH)) ? JSONC_PATH : JSON_PATH;
+  if (!(await exists(configPath))) return false;
+  const current = await readConfig(configPath);
+  const hadProvider = Boolean(current.provider?.pennyrouter);
+  const hadEnabled = Array.isArray(current.enabled_providers)
+    && current.enabled_providers.includes("pennyrouter");
+  if (!hadProvider && !hadEnabled) return false;
+
+  if (hadProvider) delete current.provider.pennyrouter;
+  if (current.provider && Object.keys(current.provider).length === 0) delete current.provider;
+  if (hadEnabled) {
+    // Installing wrote this to surface the Penny models. Left behind it would hide every
+    // other provider the user configured from a plain `opencode`.
+    current.enabled_providers = current.enabled_providers.filter((p) => p !== "pennyrouter");
+    if (current.enabled_providers.length === 0) delete current.enabled_providers;
+  }
+  await atomicWrite(configPath, `${JSON.stringify(current, null, 2)}\n`);
+  return true;
+}
+
 async function removeGeneratedModelCache() {
   try {
     await unlink(expandHome(MODEL_CACHE_PATH));
@@ -210,9 +240,11 @@ export function opencodeModelId(modelId) {
 
 export async function fetchOpenCodeModels(gatewayBaseUrl, apiKey, { requireFresh = false } = {}) {
   try {
+    // The harness header selects the gateway's OpenAI-wire catalog: it relays the
+    // upstream proxy's real allowlist rather than PennyRouter's discovery-only entries.
     const headers = apiKey
-      ? { Authorization: `Bearer ${apiKey}`, "x-api-key": apiKey }
-      : undefined;
+      ? { Authorization: `Bearer ${apiKey}`, "x-api-key": apiKey, "x-pennyrouter-harness": "opencode" }
+      : { "x-pennyrouter-harness": "opencode" };
     const response = await fetch(`${String(gatewayBaseUrl).replace(/\/+$/, "")}/v1/models`, { headers });
     if (!response.ok) throw new Error(`model catalog returned ${response.status}`);
     const payload = await response.json();

package/src/harnesses/opencode.test.js

@@ -66,6 +66,7 @@ async function main() {
     assert.deepEqual(request.options.headers, {
       Authorization: "Bearer pr-test",
       "x-api-key": "pr-test",
+      "x-pennyrouter-harness": "opencode",
     });
 
     const plan = await opencodeHarness.planInstall();

package/src/launch.js

@@ -24,7 +24,8 @@ import {
   writeClaudeCodeModelPresentation,
 } from "./harnesses/claude-code.js";
 import { renderCodexConfig } from "./harnesses/codex.js";
-import { atomicWrite, homeDir, readJsonFile, readText } from "./state.js";
+import { fetchOpenCodeModels, stripPersistentOpenCodeProvider } from "./harnesses/opencode.js";
+import { atomicWrite, homeDir, readJsonFile, readText, writeJsonFile } from "./state.js";
 
 const CONFIG_VERSION = 1;
 const PATH_START = "# >>> pennyrouter PATH >>>";
@@ -171,21 +172,40 @@ export function resolvePennyProfile(config, name = null, { requireExisting = fal
     profile: requested,
     api_key: entry.api_key,
     gateway_base_url: entry.gateway_base_url,
+    subscription_auth: entry.subscription_auth,
   };
 }
 
-/** Write credentials into a named profile and make it active. */
-export function setPennyProfile(config, name, { apiKey, gatewayBaseUrl }) {
+/**
+ * Write credentials into a named profile and make it active. Existing keys on the profile
+ * are preserved: `subscription_auth` is profile-scoped and outlives a credential refresh.
+ */
+export function setPennyProfile(config, name, { apiKey, gatewayBaseUrl, subscriptionAuth }) {
+  const existing = (config.profiles || {})[name] || {};
+  const next = { ...existing, api_key: apiKey, gateway_base_url: gatewayBaseUrl };
+  if (subscriptionAuth !== undefined) next.subscription_auth = Boolean(subscriptionAuth);
   return {
     ...config,
-    profiles: {
-      ...(config.profiles || {}),
-      [name]: { api_key: apiKey, gateway_base_url: gatewayBaseUrl },
-    },
+    profiles: { ...(config.profiles || {}), [name]: next },
     active_profile: name,
   };
 }
 
+/**
+ * Resolve whether a harness may use subscription-backed upstream auth.
+ *
+ * Subscription auth is a property of the gateway, not the harness: a private/proxy gateway
+ * (Bedrock, corporate egress) has no subscription lane to route to, and asking a harness to
+ * attach a ChatGPT/Anthropic token there produces upstream calls it cannot complete. The
+ * profile value therefore wins; the harness-level value is the pre-profile fallback for
+ * installs written before the flag moved. Absent both, it is off.
+ */
+export function resolveSubscriptionAuth(config, harness) {
+  const profileValue = config?.subscription_auth;
+  if (profileValue !== undefined) return Boolean(profileValue);
+  return Boolean(config?.harnesses?.[harness]?.subscription_auth);
+}
+
 export async function loadPennyConfig({ profile = null, requireExisting = false } = {}) {
   const config = (await readJsonFile(pennyConfigPath(), null)) || {
     version: CONFIG_VERSION,
@@ -369,7 +389,8 @@ export function renderCodexLaunchProfile({ gatewayBaseUrl, subscriptionAuth }) {
   const authLines = subscriptionAuth
     ? [
         "requires_openai_auth = true",
-        'env_http_headers = { "x-pennyrouter-key" = "PENNYROUTER_API_KEY", "x-pennyrouter-title-session" = "PENNYROUTER_TITLE_SESSION_ID", "x-pennyrouter-harness" = "codex", "x-pennyrouter-surface" = "codex-terminal" }',
+        'env_http_headers = { "x-pennyrouter-key" = "PENNYROUTER_API_KEY", "x-pennyrouter-title-session" = "PENNYROUTER_TITLE_SESSION_ID" }',
+        'http_headers = { "x-pennyrouter-harness" = "codex", "x-pennyrouter-surface" = "codex-terminal" }',
       ]
     : [
         'env_key = "PENNYROUTER_API_KEY"',
@@ -618,7 +639,7 @@ export async function createCodexDesktopHome({ config, realHome }) {
     const desktopConfig = setCodexDesktopDefault(renderCodexConfig(removeCodexPennyProvider(nativeConfig), {
       apiKey: config.api_key,
       gatewayBaseUrl: config.gateway_base_url,
-      subscriptionAuth: Boolean(config.harnesses?.codex?.subscription_auth),
+      subscriptionAuth: resolveSubscriptionAuth(config, "codex"),
       surface: "codex-desktop",
     }));
     await privateWrite(join(overlay, "config.toml"), desktopConfig);
@@ -972,7 +993,82 @@ function rewriteClaudeAuthStartup(args) {
   return args;
 }
 
-export function buildPennyInvocation(harness, args, config) {
+function openCodeModelCachePath(profile) {
+  return join(pennyDataDir(), `opencode-models-${profile || DEFAULT_PROFILE}.json`);
+}
+
+/**
+ * Model catalog for one OpenCode launch, newest first.
+ *
+ * The gateway is the authority, but it is not always reachable: a private gateway sits
+ * behind a VPN the user is not always on. Falling back to the last catalog seen for this
+ * profile keeps OpenCode launchable offline, and is why the catalog is cached per profile
+ * rather than globally -- a cloud catalog must never stand in for a private one.
+ */
+export async function resolveOpenCodeLaunchModels(config) {
+  // One-time migration off the install-time provider block. Harmless once it is gone.
+  if (await stripPersistentOpenCodeProvider()) {
+    console.error(
+      "PennyRouter: removed the stored OpenCode provider block; "
+      + "`penny opencode` now configures the provider per launch.",
+    );
+  }
+  const cachePath = openCodeModelCachePath(config.profile);
+  try {
+    const models = await fetchOpenCodeModels(config.gateway_base_url, config.api_key, {
+      requireFresh: true,
+    });
+    await writeJsonFile(cachePath, { models, fetched_at: new Date().toISOString() });
+    return models;
+  } catch (error) {
+    const cached = await readJsonFile(cachePath, null);
+    if (cached?.models?.length) {
+      console.error(
+        `PennyRouter: could not reach ${config.gateway_base_url} (${error.message}). `
+        + `Using the model list cached ${cached.fetched_at}.`,
+      );
+      return cached.models;
+    }
+    throw new Error(
+      `PennyRouter could not fetch the model catalog from ${config.gateway_base_url} `
+      + `(${error.message}), and no cached catalog exists for the "${config.profile}" profile.`,
+    );
+  }
+}
+
+/**
+ * OpenCode config declaring the PennyRouter provider for one launch.
+ *
+ * OpenCode deep-merges this over the on-disk config rather than replacing it, so the
+ * models map here unions with any `provider.pennyrouter.models` left in opencode.json:
+ * `penny opencode` removes that block so a retired model cannot survive in the picker.
+ */
+export function buildOpenCodeSessionConfig(config, models) {
+  return {
+    provider: {
+      pennyrouter: {
+        npm: "@ai-sdk/openai-compatible",
+        name: "PennyRouter",
+        options: {
+          baseURL: `${String(config.gateway_base_url).replace(/\/+$/, "")}/v1`,
+          apiKey: config.api_key,
+          headers: {
+            "x-pennyrouter-title-session": "{env:PENNYROUTER_TITLE_SESSION_ID}",
+            "x-pennyrouter-harness": "opencode",
+          },
+        },
+        models: Object.fromEntries(
+          models.map((model) => [
+            model.id,
+            { name: model.name, ...(model.description ? { description: model.description } : {}) },
+          ]),
+        ),
+      },
+    },
+  };
+}
+
+export function buildPennyInvocation(harness, args, config, models = null) {
   const item = config.harnesses?.[harness];
   if (!item || !item.enabled) {
     throw new Error(`PennyRouter is not enabled for ${harness}. Run npx pennyrouter install.`);
@@ -1018,6 +1114,11 @@ export function buildPennyInvocation(harness, args, config) {
   }
   if (harness === "opencode") {
     env.PENNYROUTER_TITLE_SESSION_ID = randomUUID();
+    // Bind this launch to the resolved profile through OpenCode's session-scoped config
+    // channel. A persistent provider block cannot express "this profile for this window":
+    // it is one file shared by every OpenCode process, so two profiles cannot run at once
+    // and a plain `opencode` would inherit whichever gateway was installed last.
+    if (models) env.OPENCODE_CONFIG_CONTENT = JSON.stringify(buildOpenCodeSessionConfig(config, models));
     return { command: "opencode", args, env };
   }
   throw new Error(`Unknown Penny harness "${harness}". Try penny claude, penny codex, or penny opencode.`);
@@ -1096,7 +1197,8 @@ export async function runPenny(argv = process.argv.slice(2)) {
     }
     return runCodexDesktop(config, { logs, mode });
   }
-  const invocation = buildPennyInvocation(harness, argv.slice(1), config);
+  const models = harness === "opencode" ? await resolveOpenCodeLaunchModels(config) : null;
+  const invocation = buildPennyInvocation(harness, argv.slice(1), config, models);
   const child = spawn(invocation.command, invocation.args, {
     cwd: process.cwd(),
     env: invocation.env,

package/src/launch.test.js

@@ -191,6 +191,10 @@ async function main() {
     fs.rmSync(desktopHome, { recursive: true, force: true });
     const codexProfile = fs.readFileSync(codexLaunchProfilePath(), "utf8");
     assert.ok(codexProfile.includes('"x-pennyrouter-key" = "PENNYROUTER_API_KEY"'));
+    assert.match(codexProfile,
+      /env_http_headers = \{ "x-pennyrouter-key" = "PENNYROUTER_API_KEY", "x-pennyrouter-title-session" = "PENNYROUTER_TITLE_SESSION_ID" \}/);
+    assert.match(codexProfile,
+      /http_headers = \{ "x-pennyrouter-harness" = "codex", "x-pennyrouter-surface" = "codex-terminal" \}/);
     assert.ok(codexProfile.includes("[tui]\nterminal_title = []"));
     assert.ok(codexProfile.includes('"x-pennyrouter-title-session" = "PENNYROUTER_TITLE_SESSION_ID"'));
     assert.ok(codexProfile.includes('"x-pennyrouter-harness" = "codex"'));