pennyrouter 0.3.8 → 0.3.11

package/package.json

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

package/src/cli.js

@@ -20,7 +20,7 @@ import {
 import { clineHarness } from "./harnesses/cline.js";
 import { codeGptHarness } from "./harnesses/codegpt.js";
 import { codexHarness, detectCodexChatgptAuth } from "./harnesses/codex.js";
-import { opencodeHarness } from "./harnesses/opencode.js";
+import { fetchOpenCodeModels, opencodeHarness } from "./harnesses/opencode.js";
 import { windsurfHarness } from "./harnesses/windsurf.js";
 import { zedHarness } from "./harnesses/zed.js";
 import {
@@ -642,7 +642,16 @@ export async function install(flags = {}) {
     // key against a store this install never talks to. Ask for the gateway, mint there, and
     // skip the claim entirely.
     gatewayBaseUrl = await resolvePrivateGatewayUrl(flags);
-    claim = { api_key: await obtainPrivateGatewayKey(flags, gatewayBaseUrl), gateway_base_url: gatewayBaseUrl };
+    const launchConfig = await loadPennyConfig();
+    const globalAuth = await readClaudeCodeGatewayAuth();
+    const storedGateway = launchConfig.gateway_base_url || globalAuth.gatewayBaseUrl;
+    const storedKey = storedGateway && sameGatewayBaseUrl(gatewayBaseUrl, storedGateway)
+      ? (launchConfig.api_key || globalAuth.apiKey)
+      : null;
+    claim = {
+      api_key: await obtainPrivateGatewayKey(flags, gatewayBaseUrl, storedKey),
+      gateway_base_url: gatewayBaseUrl,
+    };
 
     const claudeProviders = await selectClaudeFundingProviders(flags, needsAuth);
     const codexProviders = await selectCodexFundingProviders(flags, needsAuth);
@@ -661,48 +670,86 @@ export async function install(flags = {}) {
       }));
     }
   } else {
-    const session = await createCliSession({
-      appUrl: flags.appUrl || APP_URL,
-      harnesses: selected.map((harness) => harness.id),
-      accountMode: "existing",
-    });
+    // Re-running the ordinary installer should refresh local harness configuration, not mint
+    // another machine key. Reuse a key already saved for this same gateway; an explicit gateway
+    // URL still wins, and a URL change deliberately falls through to fresh authorization.
+    const launchConfig = await loadPennyConfig();
+    const globalAuth = await readClaudeCodeGatewayAuth();
+    const existingApiKey = flags.pennyKey || launchConfig.api_key || globalAuth.apiKey;
+    const existingGateway = launchConfig.gateway_base_url || globalAuth.gatewayBaseUrl
+      || DEFAULT_GATEWAY_BASE_URL;
+    const requestedGateway = flags.gatewayBaseUrl || existingGateway;
+    const reusableKey = existingApiKey
+      && sameGatewayBaseUrl(requestedGateway, existingGateway)
+      ? existingApiKey
+      : null;
+
+    if (reusableKey) {
+      gatewayBaseUrl = existingGateway;
+      claim = { api_key: reusableKey, gateway_base_url: gatewayBaseUrl };
+      console.log(`Using existing PennyRouter key for ${gatewayBaseUrl}.`);
+      console.log("");
 
-    console.log("Opening your browser to log in and authorize this machine with your PennyRouter account...");
-    console.log(`If your browser did not open, visit:\n${session.authorize_url}`);
-    if (!flags.noBrowser) openBrowser(session.authorize_url);
-    console.log("");
-    console.log("Waiting for approval...");
+      const claudeProviders = await selectClaudeFundingProviders(flags, needsAuth);
+      const codexProviders = await selectCodexFundingProviders(flags, needsAuth);
+      claudeAnthropicAuth = await maybeConfigureClaudeAnthropicAuth(
+        flags, needsAuth, claudeProviders.has("subscription"));
+      funding = await configureUserFunding(
+        flags, needsAuth, claudeAnthropicAuth, claudeProviders, codexProviders);
 
-    claim = await pollForKey(session);
-    console.log(`Authorized. Received key ${maskKey(claim.api_key)}.`);
-    console.log("");
+      for (const credential of funding.credentials) {
+        await withGatewayContext(gatewayBaseUrl, () => storeUpstreamCredential({
+          gatewayBaseUrl,
+          apiKey: claim.api_key,
+          provider: credential.provider,
+          token: credential.token,
+          metadata: credential.metadata,
+        }));
+      }
+    } else {
+      const session = await createCliSession({
+        appUrl: flags.appUrl || APP_URL,
+        harnesses: selected.map((harness) => harness.id),
+        accountMode: "existing",
+      });
 
-    const claudeProviders = await selectClaudeFundingProviders(flags, needsAuth);
-    const codexProviders = await selectCodexFundingProviders(flags, needsAuth);
-    claudeAnthropicAuth = await maybeConfigureClaudeAnthropicAuth(
-      flags, needsAuth, claudeProviders.has("subscription"));
-    funding = await configureUserFunding(
-      flags, needsAuth, claudeAnthropicAuth, claudeProviders, codexProviders);
-    gatewayBaseUrl = flags.gatewayBaseUrl || claim.gateway_base_url;
-    if (flags.gatewayBaseUrl) {
-      const normalized = normalizeGatewayBaseUrl(flags.gatewayBaseUrl);
-      if (!normalized) {
-        throw new Error(
-          `--gateway-base-url "${flags.gatewayBaseUrl}" is not a usable URL. Use a host like `
-          + "localhost:8400 or https://gateway.example.com.",
-        );
+      console.log("Opening your browser to log in and authorize this machine with your PennyRouter account...");
+      console.log(`If your browser did not open, visit:\n${session.authorize_url}`);
+      if (!flags.noBrowser) openBrowser(session.authorize_url);
+      console.log("");
+      console.log("Waiting for approval...");
+
+      claim = await pollForKey(session);
+      console.log(`Authorized. Received key ${maskKey(claim.api_key)}.`);
+      console.log("");
+
+      const claudeProviders = await selectClaudeFundingProviders(flags, needsAuth);
+      const codexProviders = await selectCodexFundingProviders(flags, needsAuth);
+      claudeAnthropicAuth = await maybeConfigureClaudeAnthropicAuth(
+        flags, needsAuth, claudeProviders.has("subscription"));
+      funding = await configureUserFunding(
+        flags, needsAuth, claudeAnthropicAuth, claudeProviders, codexProviders);
+      gatewayBaseUrl = flags.gatewayBaseUrl || claim.gateway_base_url;
+      if (flags.gatewayBaseUrl) {
+        const normalized = normalizeGatewayBaseUrl(flags.gatewayBaseUrl);
+        if (!normalized) {
+          throw new Error(
+            `--gateway-base-url "${flags.gatewayBaseUrl}" is not a usable URL. Use a host like `
+            + "localhost:8000 or https://gateway.example.com.",
+          );
+        }
+        gatewayBaseUrl = normalized;
       }
-      gatewayBaseUrl = normalized;
-    }
 
-    for (const credential of funding.credentials) {
-      await withGatewayContext(gatewayBaseUrl, () => storeUpstreamCredential({
-        gatewayBaseUrl,
-        apiKey: claim.api_key,
-        provider: credential.provider,
-        token: credential.token,
-        metadata: credential.metadata,
-      }));
+      for (const credential of funding.credentials) {
+        await withGatewayContext(gatewayBaseUrl, () => storeUpstreamCredential({
+          gatewayBaseUrl,
+          apiKey: claim.api_key,
+          provider: credential.provider,
+          token: credential.token,
+          metadata: credential.metadata,
+        }));
+      }
     }
   }
 
@@ -756,12 +803,15 @@ export async function install(flags = {}) {
 
       let record;
       if (!supportsPennyCommand || makeDefault) {
+        const opencodeModels = harness.id === "opencode" && flags.privateGatewayFlow
+          ? await fetchOpenCodeModels(gatewayBaseUrl, claim.api_key, { requireFresh: true })
+          : null;
         record = harness.id === "claude-code" && claudeSubscriptionAuth
           ? await harness.installStoredToken({
               apiKey: claim.api_key, gatewayBaseUrl, plan, existingRecord,
             })
           : await harness.install({
-              apiKey: claim.api_key, gatewayBaseUrl, plan, existingRecord,
+              apiKey: claim.api_key, gatewayBaseUrl, plan, existingRecord, models: opencodeModels,
             });
       } else {
         if (hadGlobalRouting) {
@@ -923,7 +973,7 @@ async function resolvePrivateGatewayUrl(flags) {
 /* The key for a private gateway: an admin-issued one if the user has it, otherwise minted
    from the gateway itself against their email. --private-key wins so an administrator can
    still hand out keys on a gateway that also allows self-service. */
-async function obtainPrivateGatewayKey(flags, gatewayBaseUrl) {
+async function obtainPrivateGatewayKey(flags, gatewayBaseUrl, existingApiKey = null) {
   const issued = (flags.privateKey || "").trim();
   if (issued) {
     if (!issued.startsWith("pr-")) {
@@ -934,6 +984,12 @@ async function obtainPrivateGatewayKey(flags, gatewayBaseUrl) {
     return issued;
   }
 
+  if (existingApiKey) {
+    console.log(`Using existing PennyRouter key for ${gatewayBaseUrl}.`);
+    console.log("");
+    return existingApiKey;
+  }
+
   let email = (flags.email || "").trim();
   if (!email) {
     // A shared --config file names the gateway but not who is installing, so the email is
@@ -982,6 +1038,12 @@ function normalizeGatewayBaseUrl(raw) {
   return withScheme.replace(/\/+$/, "");
 }
 
+function sameGatewayBaseUrl(left, right) {
+  const normalizedLeft = normalizeGatewayBaseUrl(left);
+  const normalizedRight = normalizeGatewayBaseUrl(right);
+  return Boolean(normalizedLeft && normalizedRight && normalizedLeft === normalizedRight);
+}
+
 /* A gateway that is unreachable (wrong host, wrong port, not running) surfaces from fetch() as
    an opaque "fetch failed" with no status. Name the gateway we could not reach so the user knows
    which URL to fix. Real HTTP errors carry their own message and pass through untouched. */

package/src/harnesses/opencode.js

@@ -8,14 +8,17 @@ import {
   readText,
   writeJsonFile,
 } from "../state.js";
+import { unlink } from "node:fs/promises";
 const JSONC_PATH = "~/.config/opencode/opencode.jsonc";
 const JSON_PATH = "~/.config/opencode/opencode.json";
 const MODEL_STATE_PATH = "~/.local/state/opencode/model.json";
+const MODEL_CACHE_PATH = "~/.cache/opencode/models.json";
 export const OPENCODE_MODEL_CHOICES = [
-  { id: "pennyrouter/penny-core:premium", name: "Penny Core" },
-  { id: "pennyrouter/penny-speed:standard", name: "Penny Speed" },
-  { id: "pennyrouter/penny-power:premium", name: "Penny Power" },
   { id: "pennyrouter/auto", name: "PennyRouter Auto" },
+  { id: "claude-haiku-4-5-20251001", name: "Haiku 4.5" },
+  { id: "claude-sonnet-5", name: "Sonnet 5" },
+  { id: "claude-opus-5", name: "Opus 5" },
+  { id: "claude-fable-5", name: "Fable 5" },
   { id: "claude-penny-deepseek-v4-flash", name: "DeepSeek V4 Flash" },
   { id: "claude-penny-glm-5-3", name: "GLM 5.3" },
   { id: "claude-penny-gpt-5-6-luna", name: "GPT-5.6 Luna" },
@@ -25,6 +28,16 @@ export const OPENCODE_MODEL_CHOICES = [
   { id: "claude-penny-minimax-m3", name: "MiniMax M3" },
   { id: "claude-penny-nemotron-ultra-free", name: "Nemotron 3 Ultra (free)" },
   { id: "claude-penny-solar-pro4", name: "Solar Pro 4" },
+  { id: "gpt-5.6-sol", name: "GPT 5.6 Sol (PennyRouter)" },
+  { id: "gpt-5.6-terra", name: "GPT 5.6 Terra (PennyRouter)" },
+  { id: "gpt-5.6-luna", name: "GPT 5.6 Luna (PennyRouter)" },
+  { id: "gpt-5.5", name: "GPT 5.5 (PennyRouter)" },
+  { id: "gpt-5.4", name: "GPT 5.4 (PennyRouter)" },
+  { id: "gpt-5.4-mini", name: "GPT 5.4 Mini (PennyRouter)" },
+  { id: "gpt-penny-auto", name: "PennyRouter Auto (GPT)" },
+  { id: "gpt-penny-deepseek", name: "DeepSeek V4 Flash (PennyRouter)" },
+  { id: "gpt-penny-glm", name: "GLM 5.3 (PennyRouter)" },
+  { id: "gpt-penny-grok", name: "Grok 4.6 (PennyRouter)" },
 ];
 
 export const opencodeHarness = {
@@ -42,8 +55,8 @@ export const opencodeHarness = {
       summary: [
         `write ${configPath}`,
         "merge PennyRouter provider without replacing existing providers",
-        "publish the curated Penny bundles and individual model pins",
-        `reset ${MODEL_STATE_PATH} so opencode rediscovers configured models`,
+        "publish PennyRouter Auto and the available Claude/GPT model pins",
+        `reset ${MODEL_STATE_PATH} and ${MODEL_CACHE_PATH} so opencode rediscovers configured models`,
       ],
     };
   },
@@ -90,6 +103,10 @@ export const opencodeHarness = {
       }
     }
     await writeJsonFile(MODEL_STATE_PATH, model);
+    // OpenCode keeps a separate generated registry cache. Clearing it is necessary when a
+    // provider's model map changes; otherwise the picker can continue showing retired models
+    // even though opencode.json has been rewritten correctly.
+    await removeGeneratedModelCache();
 
     return {
       harness: "opencode",
@@ -129,6 +146,14 @@ export const opencodeHarness = {
   },
 };
 
+async function removeGeneratedModelCache() {
+  try {
+    await unlink(expandHome(MODEL_CACHE_PATH));
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+
 async function readConfig(path) {
   const text = await readText(path, "");
   if (!text.trim()) return {};
@@ -183,27 +208,30 @@ export function opencodeModelId(modelId) {
   return modelId;
 }
 
-export async function fetchOpenCodeModels(gatewayBaseUrl) {
+export async function fetchOpenCodeModels(gatewayBaseUrl, apiKey, { requireFresh = false } = {}) {
   try {
-    const response = await fetch(`${String(gatewayBaseUrl).replace(/\/+$/, "")}/v1/models`);
+    const headers = apiKey
+      ? { Authorization: `Bearer ${apiKey}`, "x-api-key": apiKey }
+      : undefined;
+    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();
-    const catalog = new Map(
-      Array.isArray(payload?.data)
-        ? payload.data
-          .filter((model) => typeof model?.id === "string")
-          .map((model) => [model.id, model])
-        : [],
-    );
-    const models = OPENCODE_MODEL_CHOICES.map((choice) => {
-      const model = catalog.get(choice.id);
-      return {
-        ...choice,
-        ...(model?.description ? { description: model.description } : {}),
-      };
-    });
+    const models = Array.isArray(payload?.data)
+      ? payload.data
+        .filter((model) => typeof model?.id === "string")
+        // Bundles are a legacy OpenCode surface. Auto is the one intentional exception.
+        .filter((model) => !model.id.startsWith("pennyrouter/") || model.id === "pennyrouter/auto")
+        .map((model) => ({
+          id: model.id,
+          name: model.display_name || model.name || openCodeModelName(model.id),
+          ...(model.description ? { description: model.description } : {}),
+        }))
+      : [];
     if (models.length > 0) return models;
-  } catch {}
+  } catch (error) {
+    if (requireFresh) throw new Error(`Could not fetch the private gateway model catalog: ${error.message}`);
+  }
+  if (requireFresh) throw new Error("The private gateway returned no usable OpenCode models.");
   return OPENCODE_MODEL_CHOICES;
 }
 

package/src/harnesses/opencode.test.js

@@ -3,13 +3,19 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
-import { opencodeHarness, opencodeModelId, OPENCODE_MODEL_CHOICES } from "./opencode.js";
+import {
+  fetchOpenCodeModels,
+  opencodeHarness,
+  opencodeModelId,
+  OPENCODE_MODEL_CHOICES,
+} from "./opencode.js";
 
 const ENV_KEYS = ["HOME", "XDG_STATE_HOME"];
 
 async function main() {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "pr-opencode-test-"));
   const previous = Object.fromEntries(ENV_KEYS.map((key) => [key, process.env[key]]));
+  const previousFetch = globalThis.fetch;
   const home = path.join(root, "home");
   const configPath = path.join(home, ".config", "opencode", "opencode.jsonc");
   const modelStatePath = path.join(home, ".local", "state", "opencode", "model.json");
@@ -35,6 +41,33 @@ async function main() {
   try {
     assert.equal(opencodeModelId("pennyrouter/auto"), "pennyrouter/auto");
     assert.equal(opencodeModelId("custom/model-a"), "custom/model-a");
+
+    let request;
+    globalThis.fetch = async (url, options) => {
+      request = { url, options };
+      return {
+        ok: true,
+        async json() {
+          return { data: [
+            { id: "pennyrouter/auto", display_name: "Auto from private gateway" },
+            { id: "pennyrouter/penny-core:premium", display_name: "Legacy bundle" },
+            { id: "claude-sonnet-5", display_name: "Private Sonnet", description: "Fresh" },
+          ] };
+        },
+      };
+    };
+    assert.deepEqual(await fetchOpenCodeModels(
+      "https://private.example/", "pr-test", { requireFresh: true },
+    ), [
+      { id: "pennyrouter/auto", name: "Auto from private gateway" },
+      { id: "claude-sonnet-5", name: "Private Sonnet", description: "Fresh" },
+    ]);
+    assert.equal(request.url, "https://private.example/v1/models");
+    assert.deepEqual(request.options.headers, {
+      Authorization: "Bearer pr-test",
+      "x-api-key": "pr-test",
+    });
+
     const plan = await opencodeHarness.planInstall();
     const record = await opencodeHarness.install({
       apiKey: "pr-test",
@@ -63,6 +96,7 @@ async function main() {
       if (previous[key] === undefined) delete process.env[key];
       else process.env[key] = previous[key];
     }
+    globalThis.fetch = previousFetch;
     fs.rmSync(root, { recursive: true, force: true });
   }