pennyrouter 0.3.10 → 0.3.11

package/package.json

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

package/src/cli.js

@@ -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,
+        }));
+      }
     }
   }
 
@@ -926,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-")) {
@@ -937,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
@@ -985,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. */