pennyrouter 0.3.1 → 0.3.2

package/package.json

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

package/src/cli.js

@@ -607,6 +607,16 @@ export async function install(flags = {}) {
     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.",
+        );
+      }
+      gatewayBaseUrl = normalized;
+    }
 
     // A user-supplied proxy may live on a private network that the hosted gateway cannot
     // reach. Let interactive installs choose the gateway after they choose the proxy: blank
@@ -615,10 +625,20 @@ export async function install(flags = {}) {
     // explicit localhost:8400 developer shortcut and skips this prompt.
     if ((claudeProviders.has("anthropic-proxy") || codexProviders.has("openai-proxy")) && !flags.gatewayBaseUrl
         && !flags.yes && input.isTTY && output.isTTY) {
-      const privateGateway = (await promptText(
+      const answer = (await promptText(
         "PennyRouter gateway URL for this proxy (blank for hosted gateway): ",
       )).trim();
-      if (privateGateway) {
+      if (answer) {
+        const privateGateway = normalizeGatewayBaseUrl(answer);
+        if (!privateGateway) {
+          throw new Error(
+            `"${answer}" is not a usable gateway URL. Use a host like `
+            + "localhost:8400 or https://gateway.example.com.",
+          );
+        }
+        // Show the normalized form: the user typed "localhost:8000" and everything from here on
+        // uses "http://localhost:8000", so any later error names a URL they recognize.
+        if (privateGateway !== answer) console.log(`Using gateway ${privateGateway}.`);
         gatewayBaseUrl = privateGateway;
         flags.privateGateway = true;
       }
@@ -633,7 +653,8 @@ export async function install(flags = {}) {
         console.log("");
         console.log(`Private gateway: ${gatewayBaseUrl}`);
         console.log("Your PennyRouter administrator issues keys for this gateway.");
-        privateKey = (await promptText("Paste your private gateway key (pr-...): ")).trim();
+        // No echo: this is an issued credential, and a visible paste lingers in scrollback.
+        privateKey = (await promptSecretish("Paste your private gateway key (pr-...): ")).trim();
       }
       if (!privateKey) {
         throw new Error(
@@ -650,19 +671,20 @@ export async function install(flags = {}) {
     }
 
     for (const credential of funding.credentials) {
-      await storeUpstreamCredential({
+      await withGatewayContext(gatewayBaseUrl, () => storeUpstreamCredential({
         gatewayBaseUrl,
         apiKey: claim.api_key,
         provider: credential.provider,
         token: credential.token,
         metadata: credential.metadata,
-      });
+      }));
     }
   }
 
   if (needsAuth.some((harness) => harness.id === "claude-code")) {
     console.log("Verifying modern Claude Code compatibility before changing local settings...");
-    await probeClaudeCodeGateway({ gatewayBaseUrl, apiKey: claim.api_key });
+    await withGatewayContext(
+      gatewayBaseUrl, () => probeClaudeCodeGateway({ gatewayBaseUrl, apiKey: claim.api_key }));
     console.log("");
   }
 
@@ -844,6 +866,46 @@ function mcpTargets(flags) {
 /** The gateway URL worth pinning into the MCP entry, or "" for the default.
     The MCP server already falls back to production on its own, so writing that value would only
     freeze today's default into every user's config. */
+/* Users type gateways the way they say them out loud — "localhost:8000",
+   "gateway.example.com". Those are not absolute URLs, so fetch() rejects them with a bare
+   "fetch failed" long after the prompt, where the cause is invisible. Supply the obvious scheme
+   (plain http for loopback, https elsewhere) and prove the result parses, so a typo fails here
+   instead. Returns null when the value cannot be salvaged. */
+function normalizeGatewayBaseUrl(raw) {
+  const value = String(raw || "").trim().replace(/\/+$/, "");
+  if (!value) return null;
+  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(value)
+    ? value
+    : `${/^(localhost|127\.0\.0\.1|\[::1\])(:|$)/i.test(value) ? "http" : "https"}://${value}`;
+  let parsed;
+  try {
+    parsed = new URL(withScheme);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+  if (!parsed.hostname) return null;
+  return withScheme.replace(/\/+$/, "");
+}
+
+/* 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. */
+async function withGatewayContext(gatewayBaseUrl, action) {
+  try {
+    return await action();
+  } catch (error) {
+    const message = String(error?.message || error);
+    if (/fetch failed|ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ECONNRESET|network/i.test(message)) {
+      throw new Error(
+        `Could not reach the PennyRouter gateway at ${gatewayBaseUrl} (${message}). `
+        + "Check that the URL is correct and that the gateway is running.",
+      );
+    }
+    throw error;
+  }
+}
+
 function customGatewayBaseUrl(url) {
   const value = String(url || "").trim().replace(/\/+$/, "");
   return !value || value === DEFAULT_GATEWAY_BASE_URL ? "" : value;