pennyrouter 0.2.23 → 0.2.25

package/package.json

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

package/src/cli.js

@@ -1,4 +1,5 @@
 import { spawn, spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { emitKeypressEvents } from "node:readline";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
@@ -181,15 +182,94 @@ function parseArgs(argv) {
     // `--local=<url>` overrides the port/host.
     else if (arg === "--local") flags.gatewayBaseUrl = "http://localhost:8400";
     else if (arg.startsWith("--local=")) flags.gatewayBaseUrl = arg.slice("--local=".length);
+    // --prod: point the installed harness back at the default production gateway
+    // (https://api.pennyrouter.com). Undoes --local.
+    else if (arg === "--prod") flags.gatewayBaseUrl = DEFAULT_GATEWAY_BASE_URL;
     else if (arg === "--forget") flags.forget = true;
     else if (arg === "--forget-token") flags.forgetToken = true;
+    else if (arg === "--config") flags.configPath = rest[++i] || "";
+    else if (arg.startsWith("--config=")) flags.configPath = arg.slice("--config=".length);
     else if (!arg.startsWith("-")) flags.args.push(arg);
     else throw new Error(`Unknown option "${arg}". Run "pennyrouter help".`);
   }
 
+  if (flags.configPath) applyConfigFile(flags);
+
   return { command, flags };
 }
 
+// Lets a GUI installer (e.g. the macOS DMG) answer the install questions up front instead of
+// over a TTY: pick harnesses, pick funding per harness, optionally supply keys. Populates the
+// same `flags` fields the equivalent CLI flags set, so it flows through the existing
+// non-interactive paths unchanged. CLI flags win over the config file where both are given.
+// Funding choices imply --yes (skip remaining prompts) but, unlike bare --yes, do NOT suppress
+// the Claude subscription browser sign-in — see maybeConfigureClaudeAnthropicAuth.
+function applyConfigFile(flags) {
+  let config;
+  try {
+    config = JSON.parse(readFileSync(flags.configPath, "utf8"));
+  } catch (error) {
+    throw new Error(`Could not read --config file "${flags.configPath}": ${error.message}`);
+  }
+
+  if (config.harnesses && flags.harness === undefined) {
+    flags.harness = config.harnesses.join(",");
+  }
+  const claudeFunding = new Set(config.claudeFunding || []);
+  const codexFunding = new Set(config.codexFunding || []);
+  if (claudeFunding.has("subscription") && flags.anthropicAuth === undefined) {
+    flags.anthropicAuth = true;
+  }
+  if (claudeFunding.has("anthropic-api") && flags.anthropicApiKey === undefined) {
+    flags.anthropicApiKey = config.anthropicApiKey || "";
+  }
+  if ((claudeFunding.has("openrouter") || codexFunding.has("openrouter"))
+      && flags.openrouterApiKey === undefined) {
+    flags.openrouterApiKey = config.openrouterApiKey || "";
+  }
+  if (codexFunding.has("openai-api") && flags.openaiApiKey === undefined) {
+    flags.openaiApiKey = config.openaiApiKey || "";
+  }
+
+  flags.yes = true;
+  flags.fromConfig = true;
+  flags.configClaudeFunding = claudeFunding;
+  flags.configCodexFunding = codexFunding;
+}
+
+// A harness needs the account-claim/funding flow only if it's new, or if the funding the
+// config asked for differs from what's already stored on it — an unchanged re-run of
+// --config should behave like `update`, not force a fresh Claude/PennyRouter sign-in.
+// Plain (non--config) installs call every selected harness "changed" by always passing an
+// empty requested set here, so this only takes effect on the --config path (see `needsAuth`
+// in install()).
+export function harnessFundingChanged(flags, harness, manifest) {
+  const existingRecord = (manifest.installations || []).find(
+    (candidate) => candidate.harness === harness.id,
+  );
+  if (!existingRecord) return true;
+
+  if (harness.id === "claude-code") {
+    const requested = flags.configClaudeFunding || new Set();
+    if (requested.size === 0) return false;
+    const current = existingRecord.user_funded_provider === "claude-subscription"
+      ? "subscription"
+      : existingRecord.user_funded_provider;
+    return requested.size !== 1 || !requested.has(current);
+  }
+
+  if (harness.id === "codex") {
+    const requested = flags.configCodexFunding || new Set();
+    if (requested.size === 0) return false;
+    const current = existingRecord.openai_subscription_auth
+      ? "subscription"
+      : existingRecord.user_funded_provider;
+    return requested.size !== 1 || !requested.has(current);
+  }
+
+  return false;
+}
+
 async function authProvider(flags) {
   const provider = (flags.args[0] || "anthropic").toLowerCase();
   if (provider !== "anthropic" && provider !== "claude") {
@@ -436,40 +516,74 @@ export async function install(flags = {}) {
     return;
   }
 
-  const session = await createCliSession({
-    appUrl: flags.appUrl || APP_URL,
-    harnesses: selected.map((harness) => harness.id),
-    accountMode: "existing",
-  });
-
-  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...");
+  // A --config re-run against an existing install only needs a fresh account claim and
+  // funding popups for harnesses that are actually new or whose requested funding differs
+  // from what's already stored — an unchanged harness should behave like `update`, not
+  // trigger the Claude/PennyRouter sign-in windows again. Plain (non-config) installs always
+  // treat everything selected as needing auth, matching the original behavior.
+  const needsAuth = flags.fromConfig
+    ? selected.filter((harness) => harnessFundingChanged(flags, harness, manifest))
+    : selected;
 
-  const claim = await pollForKey(session);
-  console.log(`Authorized. Received key ${maskKey(claim.api_key)}.`);
-  console.log("");
+  let claim;
+  let claudeAnthropicAuth = null;
+  let funding = { credentials: [], codexSubscriptionAuth: false, claudeCredentialProvider: null, codexCredentialProvider: null };
+  let gatewayBaseUrl;
 
-  const claudeProviders = await selectClaudeFundingProviders(flags, selected);
-  const codexProviders = await selectCodexFundingProviders(flags, selected);
-  const claudeAnthropicAuth = await maybeConfigureClaudeAnthropicAuth(
-    flags, selected, claudeProviders.has("subscription"));
-  const funding = await configureUserFunding(
-    flags, selected, claudeAnthropicAuth, claudeProviders, codexProviders);
-  const gatewayBaseUrl = flags.gatewayBaseUrl || claim.gateway_base_url;
-
-  for (const credential of funding.credentials) {
-    await storeUpstreamCredential({
-      gatewayBaseUrl,
-      apiKey: claim.api_key,
-      provider: credential.provider,
-      token: credential.token,
+  if (needsAuth.length === 0) {
+    const launchConfig = await loadPennyConfig();
+    const globalAuth = await readClaudeCodeGatewayAuth();
+    const apiKey = flags.pennyKey || launchConfig.api_key || globalAuth.apiKey;
+    if (!apiKey) {
+      throw new Error(
+        "Could not find your PennyRouter key in the local config. Pass `--penny-key pr-...`, "
+        + "or remove --config to re-authorize.",
+      );
+    }
+    console.log("No new tools or funding requested — refreshing your existing setup.");
+    console.log("");
+    claim = { api_key: apiKey, gateway_base_url: null };
+    gatewayBaseUrl = flags.gatewayBaseUrl
+      || launchConfig.gateway_base_url
+      || globalAuth.gatewayBaseUrl
+      || process.env.PENNYROUTER_GATEWAY_BASE_URL
+      || DEFAULT_GATEWAY_BASE_URL;
+  } else {
+    const session = await createCliSession({
+      appUrl: flags.appUrl || APP_URL,
+      harnesses: selected.map((harness) => harness.id),
+      accountMode: "existing",
     });
+
+    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;
+
+    for (const credential of funding.credentials) {
+      await storeUpstreamCredential({
+        gatewayBaseUrl,
+        apiKey: claim.api_key,
+        provider: credential.provider,
+        token: credential.token,
+      });
+    }
   }
 
-  if (selected.some((harness) => harness.id === "claude-code")) {
+  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 });
     console.log("");
@@ -501,8 +615,9 @@ export async function install(flags = {}) {
         assertNoRunningHarness(harness.id, flags);
       }
 
+      const harnessNeededAuth = needsAuth.includes(harness);
       const codexSubscriptionAuth = harness.id === "codex"
-        ? funding.codexSubscriptionAuth
+        ? (harnessNeededAuth ? funding.codexSubscriptionAuth : Boolean(existingRecord?.openai_subscription_auth))
         : false;
       const claudeSubscriptionAuth = harness.id === "claude-code"
         && Boolean(claudeAnthropicAuth || existingRecord?.anthropic_token_stored);
@@ -550,11 +665,15 @@ export async function install(flags = {}) {
         record.anthropic_token_stored = true;
         record.token_source = claudeAnthropicAuth?.source || existingRecord?.token_source || "stored";
       }
-      if (harness.id === "claude-code" && funding.claudeCredentialProvider) {
-        record.user_funded_provider = funding.claudeCredentialProvider;
+      if (harness.id === "claude-code") {
+        record.user_funded_provider = harnessNeededAuth
+          ? (funding.claudeCredentialProvider || existingRecord?.user_funded_provider)
+          : existingRecord?.user_funded_provider;
       }
-      if (harness.id === "codex" && funding.codexCredentialProvider) {
-        record.user_funded_provider = funding.codexCredentialProvider;
+      if (harness.id === "codex") {
+        record.user_funded_provider = harnessNeededAuth
+          ? (funding.codexCredentialProvider || existingRecord?.user_funded_provider)
+          : existingRecord?.user_funded_provider;
       }
       if (harness.id === "codex") record.openai_subscription_auth = codexSubscriptionAuth;
       records.push(record);
@@ -982,7 +1101,10 @@ async function maybeConfigureClaudeAnthropicAuth(flags, selected, enabled = true
     if (tokenResult.token) return tokenResult;
   }
 
-  if (flags.yes || !input.isTTY || !output.isTTY) {
+  // --config drives --yes to skip prompts, but it still expects the subscription browser
+  // sign-in to run — the caller (e.g. the macOS installer) attaches a pty for exactly this,
+  // so treat it like the interactive path rather than the plain --yes/non-TTY automation path.
+  if ((flags.yes && !flags.fromConfig) || !input.isTTY || !output.isTTY) {
     if (flags.anthropicAuth) {
       throw new Error(
         "Claude subscription auth was requested, but no Anthropic bearer token was found. Pass --token, --token-command, or ANTHROPIC_AUTH_TOKEN.",
@@ -998,7 +1120,8 @@ async function maybeConfigureClaudeAnthropicAuth(flags, selected, enabled = true
   if (commandExists("claude")) {
     // The user already opted into subscription auth above, so run `claude setup-token`
     // directly and capture the token — no copy-paste, no second confirm. The command
-    // opens the browser for approval inline. On failure we fall through to manual paste.
+    // opens the browser for approval inline. On failure we fall through to manual paste,
+    // unless we came from --config, where there's no terminal to paste into.
     console.log("Launching Claude sign-in — approve in your browser…");
     const captured = await runClaudeSetupToken();
     if (captured) {
@@ -1006,8 +1129,13 @@ async function maybeConfigureClaudeAnthropicAuth(flags, selected, enabled = true
       console.log("");
       return { token: captured, source: "setup-token" };
     }
+    if (flags.fromConfig) {
+      throw new Error("Claude sign-in did not complete. Run the installer again.");
+    }
     console.log("");
     console.log("Couldn't capture a token automatically. Paste it below, or leave blank to skip.");
+  } else if (flags.fromConfig) {
+    throw new Error("Claude Code was not found on PATH, so subscription sign-in could not run.");
   } else {
     console.log("Claude Code was not found on PATH. Paste an Anthropic bearer token, or leave blank to skip.");
   }
@@ -1858,8 +1986,8 @@ function printHelp() {
   console.log(`PennyRouter CLI
 
 Usage:
-  pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--make-default|--penny-only] [--no-path-update] [--no-mcp] [--anthropic-auth|--no-anthropic-auth] [--anthropic-api-key KEY] [--openai-api-key KEY] [--openrouter-api-key KEY] [--local[=URL]] [--allow-running-harnesses]
-  pennyrouter update [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--dry-run] [--penny-key pr-...] [--gateway-base-url URL|--local[=URL]] [--no-mcp] [--allow-running-harnesses]
+  pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--make-default|--penny-only] [--no-path-update] [--no-mcp] [--anthropic-auth|--no-anthropic-auth] [--anthropic-api-key KEY] [--openai-api-key KEY] [--openrouter-api-key KEY] [--local[=URL]|--prod] [--config PATH] [--allow-running-harnesses]
+  pennyrouter update [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--dry-run] [--penny-key pr-...] [--gateway-base-url URL|--local[=URL]|--prod] [--no-mcp] [--allow-running-harnesses]
   pennyrouter auth anthropic [--penny-key pr-...] [--token oauth-token] [--token-command CMD] [--gateway-base-url URL] [--forget]
   pennyrouter disable [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
   pennyrouter enable [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
@@ -1888,6 +2016,7 @@ Examples:
   npx pennyrouter update --harness claude-code
   npx pennyrouter update --harness codex --local
   npx pennyrouter update --all --local
+  npx pennyrouter update --all --prod
   npx pennyrouter install
   npx pennyrouter install --make-default
   npx pennyrouter install --penny-only
@@ -1898,6 +2027,7 @@ Examples:
   npx pennyrouter auth anthropic
   npx pennyrouter install --all
   npx pennyrouter install --harness windsurf,zed,codegpt,aider --yes
+  npx pennyrouter install --config ./penny_install.json
   npx pennyrouter disable
   npx pennyrouter enable
   npx pennyrouter uninstall

package/src/cli.test.js

@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { harnessFundingChanged, main } from "./cli.js";
+
+// --config lets a GUI installer (the macOS DMG) answer install questions up front instead of
+// over a TTY. These tests drive it through `main()` in --dry-run, which prints its plan and
+// returns before any network call or filesystem write, so no mocking is needed.
+
+function withConfigFile(config, run) {
+  const dir = mkdtempSync(join(tmpdir(), "pennyrouter-config-"));
+  const path = join(dir, "penny_install.json");
+  writeFileSync(path, JSON.stringify(config));
+  try {
+    return run(path);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+function captureLogs(run) {
+  const original = console.log;
+  const lines = [];
+  console.log = (...args) => lines.push(args.join(" "));
+  return run().finally(() => { console.log = original; }).then(() => lines);
+}
+
+test("--config selects harnesses without prompting", async () => {
+  await withConfigFile({ harnesses: ["claude-code"] }, async (path) => {
+    const lines = await captureLogs(() => main(["install", "--config", path, "--dry-run"]));
+    assert.ok(lines.some((line) => line.includes("Claude Code")));
+    assert.ok(!lines.some((line) => line.includes("Codex")));
+  });
+});
+
+test("--config with claudeFunding subscription sets --anthropic-auth", async () => {
+  await withConfigFile(
+    { harnesses: ["claude-code"], claudeFunding: ["subscription"] },
+    async (path) => {
+      const lines = await captureLogs(() => main(["install", "--config", path, "--dry-run"]));
+      assert.ok(lines.some((line) => line.includes("Claude Code provider picker")));
+    },
+  );
+});
+
+test("--config rejects an unreadable file", async () => {
+  await assert.rejects(
+    () => main(["install", "--config", "/nonexistent/penny_install.json", "--dry-run"]),
+    /Could not read --config file/,
+  );
+});
+
+test("explicit --harness overrides --config harnesses", async () => {
+  await withConfigFile({ harnesses: ["codex"] }, async (path) => {
+    const lines = await captureLogs(
+      () => main(["install", "--harness", "claude-code", "--config", path, "--dry-run"]),
+    );
+    assert.ok(lines.some((line) => line.includes("Claude Code")));
+    assert.ok(!lines.some((line) => line.includes("Codex")));
+  });
+});
+
+// harnessFundingChanged decides whether a --config re-run needs to re-open the account-claim
+// and subscription-auth popups for a harness, or can treat it like `update` (skip both). This
+// only kicks in on --config re-runs against an existing manifest; a live end-to-end run against
+// a real account confirmed the same three cases these unit tests cover.
+
+const claudeHarness = { id: "claude-code" };
+const codexHarness = { id: "codex" };
+
+test("harnessFundingChanged: brand new harness always needs auth", () => {
+  const manifest = { installations: [] };
+  assert.equal(harnessFundingChanged({}, claudeHarness, manifest), true);
+});
+
+test("harnessFundingChanged: claude subscription unchanged", () => {
+  const manifest = {
+    installations: [{ harness: "claude-code", user_funded_provider: "claude-subscription" }],
+  };
+  const flags = { configClaudeFunding: new Set(["subscription"]) };
+  assert.equal(harnessFundingChanged(flags, claudeHarness, manifest), false);
+});
+
+test("harnessFundingChanged: claude subscription to anthropic-api is a change", () => {
+  const manifest = {
+    installations: [{ harness: "claude-code", user_funded_provider: "claude-subscription" }],
+  };
+  const flags = { configClaudeFunding: new Set(["anthropic-api"]) };
+  assert.equal(harnessFundingChanged(flags, claudeHarness, manifest), true);
+});
+
+test("harnessFundingChanged: codex subscription unchanged (openai_subscription_auth flag)", () => {
+  const manifest = {
+    installations: [{
+      harness: "codex",
+      user_funded_provider: "chatgpt-subscription",
+      openai_subscription_auth: true,
+    }],
+  };
+  const flags = { configCodexFunding: new Set(["subscription"]) };
+  assert.equal(harnessFundingChanged(flags, codexHarness, manifest), false);
+});
+
+test("harnessFundingChanged: codex openrouter unchanged", () => {
+  const manifest = {
+    installations: [{
+      harness: "codex",
+      user_funded_provider: "openrouter",
+      openai_subscription_auth: false,
+    }],
+  };
+  const flags = { configCodexFunding: new Set(["openrouter"]) };
+  assert.equal(harnessFundingChanged(flags, codexHarness, manifest), false);
+});
+
+test("harnessFundingChanged: no requested funding for an existing harness is not a change", () => {
+  const manifest = {
+    installations: [{ harness: "claude-code", user_funded_provider: "claude-subscription" }],
+  };
+  assert.equal(harnessFundingChanged({}, claudeHarness, manifest), false);
+});

package/src/statusline.js

@@ -46,7 +46,7 @@ export async function configureClaudeCodeStatusline(current) {
   current.statusLine = {
     type: "command",
     command: `node "${statuslineScriptPath()}"`,
-    refreshInterval: 10,
+    refreshInterval: 1,
     ...(existing?.padding !== undefined ? { padding: existing.padding } : {}),
   };
   return { script_path: statuslineScriptPath(), wrapped: Boolean(config.wrap_command) };
@@ -121,6 +121,9 @@ if (process.argv[2] === "--refresh") {
     });
     if (resp.ok) {
       const data = await resp.json();
+      if (data.cache_expires_at && typeof data.cache_expires_at === "number") {
+        data.cache_expires_at = Math.round(data.cache_expires_at / 10) * 10;
+      }
       mkdirSync(cacheDir, { recursive: true });
       writeFileSync(join(cacheDir, sessionId + ".json"), JSON.stringify(data));
     }
@@ -168,17 +171,15 @@ function askBadges(c) {
 // Cache warmth countdown: when a prompt cache prefix is live, show time remaining.
 // The gateway sends cache_expires_at (absolute Unix timestamp); we interpolate locally
 // so it ticks down smoothly every statusline render (every ~1s), only "jumping" when
-// the gateway refreshes (~10s) with a fresh timestamp. Round to nearest 10 seconds
-// to avoid annoying flicker; show ❄️ cold when expired.
+// the gateway refreshes (~15s) with a fresh timestamp. Show ❄️ cold when expired.
 function cacheWarmth(c) {
   if (!c || typeof c.cache_expires_at !== "number" || c.cache_expires_at <= 0) {
     return "";
   }
   const remaining = c.cache_expires_at - Date.now() / 1000;
   if (remaining <= 0) return " · ❄️ cold";
-  const roundedRemaining = Math.round(remaining / 10) * 10;
-  const minutes = Math.floor(roundedRemaining / 60);
-  const seconds = Math.floor(roundedRemaining % 60);
+  const minutes = Math.floor(remaining / 60);
+  const seconds = Math.floor(remaining % 60);
   return " · 🔥 warm " + minutes + ":" + String(seconds).padStart(2, "0");
 }