pennyrouter 0.1.3 → 0.1.5

package/README.md

@@ -10,17 +10,36 @@ status checks, and uninstall metadata.
 
 ```bash
 npx pennyrouter install
-npx pennyrouter install --harness claude-code,cline,opencode,codex
+npx pennyrouter install --existing-account
+npx pennyrouter install --harness claude-code,cline,opencode,codex,windsurf,zed,codegpt,aider
+npx pennyrouter disable
+npx pennyrouter enable
 npx pennyrouter uninstall
 npx pennyrouter status
 ```
 
+With no `--harness` flag, the interactive installer shows a checkbox list. Tools with
+detected configs start checked; press Enter to accept or type tool IDs to toggle them.
+
 ## Supported Tools
 
 - Claude Code
 - Cline (manual setup instructions; no VS Code settings mutation)
 - Codex
 - opencode
+- Windsurf
+- Zed
+- JetBrains CodeGPT (manual setup instructions; no XML mutation)
+- Aider
+
+## Penny Models
+
+Tools that expose a model picker get four curated choices:
+
+- Penny Core: `pennyrouter/penny-core:premium`
+- Penny Speed: `pennyrouter/penny-speed:standard`
+- Penny Power: `pennyrouter/penny-power:premium`
+- Penny Custom: `pennyrouter/auto`, using the bundle/profile saved in the user's PennyRouter account
 
 ## Agent Flow
 
@@ -38,6 +57,9 @@ directly.
 The CLI writes only selected local tool configuration files, saves backups under the local
 PennyRouter state directory, and records an uninstall manifest.
 
+`disable` temporarily removes PennyRouter from selected tools while retaining a local
+PennyRouter-managed snapshot for `enable`.
+
 It does not delete PennyRouter accounts, credits, or remote API keys.
 
 ## License

package/package.json

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

package/src/cli.js

@@ -1,10 +1,15 @@
 import { spawnSync } from "node:child_process";
+import { emitKeypressEvents } from "node:readline";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
+import { aiderHarness } from "./harnesses/aider.js";
 import { claudeCodeHarness } from "./harnesses/claude-code.js";
 import { clineHarness } from "./harnesses/cline.js";
+import { codeGptHarness } from "./harnesses/codegpt.js";
 import { codexHarness } from "./harnesses/codex.js";
 import { opencodeHarness } from "./harnesses/opencode.js";
+import { windsurfHarness } from "./harnesses/windsurf.js";
+import { zedHarness } from "./harnesses/zed.js";
 import {
   APP_URL,
   createCliSession,
@@ -13,9 +18,10 @@ import {
   sleep,
 } from "./session.js";
 import {
-  expandHome,
+  backupFile,
+  compactHome,
   loadManifest,
-  readJsonFile,
+  restoreFile,
   saveManifest,
   statePath,
 } from "./state.js";
@@ -25,8 +31,14 @@ const HARNESS_BY_ID = {
   cline: clineHarness,
   opencode: opencodeHarness,
   codex: codexHarness,
+  windsurf: windsurfHarness,
+  zed: zedHarness,
+  codegpt: codeGptHarness,
+  aider: aiderHarness,
 };
 
+const SUPPORTED_HARNESS_IDS = Object.keys(HARNESS_BY_ID).join(",");
+
 export async function main(argv = process.argv.slice(2)) {
   const { command, flags } = parseArgs(argv);
 
@@ -45,6 +57,16 @@ export async function main(argv = process.argv.slice(2)) {
     return;
   }
 
+  if (command === "disable") {
+    await disable(flags);
+    return;
+  }
+
+  if (command === "enable") {
+    await enable(flags);
+    return;
+  }
+
   if (command === "status") {
     await status();
     return;
@@ -65,6 +87,7 @@ function parseArgs(argv) {
     else if (arg === "--all") flags.all = true;
     else if (arg === "--dry-run") flags.dryRun = true;
     else if (arg === "--no-browser") flags.noBrowser = true;
+    else if (arg === "--existing-account") flags.existingAccount = true;
     else if (arg === "--harness") flags.harness = rest[++i] || "";
     else if (arg.startsWith("--harness=")) flags.harness = arg.slice("--harness=".length);
     else if (arg === "--app-url") flags.appUrl = rest[++i] || "";
@@ -84,14 +107,10 @@ async function install(flags) {
 
   console.log("PennyRouter install");
   console.log("");
-  console.log("Selected tools:");
-  for (const harness of selected) console.log(`  - ${harness.name}`);
-  console.log("");
 
   if (flags.dryRun) {
     for (const harness of selected) {
-      const plan = await harness.planInstall();
-      printPlan(harness, plan);
+      console.log(`Will install on ${harness.name}${installNoteForHarness(harness.id)}.`);
     }
     console.log("Dry run only. No files changed.");
     return;
@@ -100,9 +119,14 @@ async function install(flags) {
   const session = await createCliSession({
     appUrl: flags.appUrl || APP_URL,
     harnesses: selected.map((harness) => harness.id),
+    accountMode: flags.existingAccount ? "existing" : "seed",
   });
 
-  console.log("Opening your browser to authorize this machine...");
+  console.log(
+    flags.existingAccount
+      ? "Opening your browser to authorize this machine with your existing PennyRouter account..."
+      : "Opening your browser to authorize this machine...",
+  );
   console.log(`If your browser did not open, visit:\n${session.authorize_url}`);
   if (!flags.noBrowser) openBrowser(session.authorize_url);
   console.log("");
@@ -114,29 +138,92 @@ async function install(flags) {
 
   const manifest = await loadManifest();
   const records = [];
+  const failures = [];
   for (const harness of selected) {
-    const plan = await harness.planInstall();
-    printPlan(harness, plan);
-    const record = await harness.install({
-      apiKey: claim.api_key,
-      gatewayBaseUrl: claim.gateway_base_url,
-      plan,
+    await runHarnessJob(failures, harness.id, "install", async () => {
+      const plan = await harness.planInstall();
+      const record = await harness.install({
+        apiKey: claim.api_key,
+        gatewayBaseUrl: claim.gateway_base_url,
+        plan,
+      });
+      records.push(record);
+      upsertManifestRecord(manifest, record);
+      await saveManifest(manifest);
     });
-    records.push(record);
-    upsertManifestRecord(manifest, record);
   }
 
   await saveManifest(manifest);
   console.log("");
   console.log("Installed PennyRouter.");
-  console.log(`Manifest: ${statePath("installations.json")}`);
   for (const record of records) {
-    if (record.restart) console.log(`${record.harness}: ${record.restart}`);
+    const harness = HARNESS_BY_ID[record.harness];
+    console.log(`Installed on ${harness?.name || record.harness}${installNoteForRecord(record)}.`);
   }
+  console.log(`Manifest: ${statePath("installations.json")}`);
+  reportFailures(failures);
 }
 
-async function uninstall(flags) {
+async function disable(flags) {
+  const manifest = await loadManifest();
+  if (pruneUnsupportedManifestRecords(manifest).length > 0) await saveManifest(manifest);
+  const records = manifest.installations || [];
+  const { selectedIds, selectedRecords } = await resolveLifecycleTargets(flags, records);
+
+  if (selectedRecords.length === 0) {
+    console.log("No matching PennyRouter installations found.");
+    return;
+  }
+
+  console.log("PennyRouter disable");
+  console.log("");
+  for (const record of selectedRecords) {
+    console.log(`  - ${record.harness}: ${record.config_path || "manual setup"}`);
+  }
+  console.log("");
+
+  if (!flags.yes) {
+    const ok = await confirm("Temporarily turn off these PennyRouter local integrations?");
+    if (!ok) return;
+  }
+
+  const failures = [];
+  for (const record of selectedRecords) {
+    if (record.disabled) {
+      console.log(`${record.harness} is already disabled.`);
+      continue;
+    }
+
+    const harness = HARNESS_BY_ID[record.harness];
+    if (!harness) {
+      console.log(`Skipping ${record.harness}: this CLI no longer knows how to disable it.`);
+      continue;
+    }
+
+    await runHarnessJob(failures, record.harness, "disable", async () => {
+      if (record.config_path) {
+        const snapshotPath = await backupFile(record.config_path, `${record.harness}-disabled`);
+        record.disabled_snapshot_path = snapshotPath;
+      }
+
+      if (typeof harness.disable === "function") await harness.disable(record);
+      else await harness.uninstall(record);
+
+      record.disabled = true;
+      record.disabled_at = new Date().toISOString();
+      upsertManifestRecord(manifest, record);
+      await saveManifest(manifest);
+      console.log(`Disabled ${record.harness}.`);
+    });
+  }
+
+  await saveManifest(manifest);
+  reportFailures(failures);
+}
+
+async function enable(flags) {
   const manifest = await loadManifest();
+  if (pruneUnsupportedManifestRecords(manifest).length > 0) await saveManifest(manifest);
   const records = manifest.installations || [];
   const selectedIds = resolveRequestedHarnessIds(flags, records.map((record) => record.harness));
   const selectedRecords = records.filter((record) => selectedIds.includes(record.harness));
@@ -146,6 +233,64 @@ async function uninstall(flags) {
     return;
   }
 
+  console.log("PennyRouter enable");
+  console.log("");
+  for (const record of selectedRecords) {
+    console.log(`  - ${record.harness}: ${record.config_path || "manual setup"}`);
+  }
+  console.log("");
+
+  if (!flags.yes) {
+    const ok = await confirm("Turn these PennyRouter local integrations back on?");
+    if (!ok) return;
+  }
+
+  const failures = [];
+  for (const record of selectedRecords) {
+    if (!record.disabled) {
+      console.log(`${record.harness} is already enabled.`);
+      continue;
+    }
+
+    const harness = HARNESS_BY_ID[record.harness];
+    if (!harness) {
+      console.log(`Skipping ${record.harness}: this CLI no longer knows how to enable it.`);
+      continue;
+    }
+
+    await runHarnessJob(failures, record.harness, "enable", async () => {
+      if (typeof harness.enable === "function") await harness.enable(record);
+      else if (record.config_path && record.disabled_snapshot_path) {
+        await restoreFile(record.disabled_snapshot_path, record.config_path);
+      } else if (record.manual_required) {
+        console.log(`${record.harness}: re-enable manually in the tool UI using the status details.`);
+      } else {
+        throw new Error("no disabled snapshot found; run install again");
+      }
+
+      delete record.disabled;
+      delete record.disabled_at;
+      upsertManifestRecord(manifest, record);
+      await saveManifest(manifest);
+      console.log(`Enabled ${record.harness}.`);
+    });
+  }
+
+  await saveManifest(manifest);
+  reportFailures(failures);
+}
+
+async function uninstall(flags) {
+  const manifest = await loadManifest();
+  if (pruneUnsupportedManifestRecords(manifest).length > 0) await saveManifest(manifest);
+  const records = manifest.installations || [];
+  const { selectedIds, selectedRecords } = await resolveLifecycleTargets(flags, records);
+
+  if (selectedRecords.length === 0) {
+    console.log("No matching PennyRouter installations found.");
+    return;
+  }
+
   console.log("PennyRouter uninstall");
   console.log("");
   for (const record of selectedRecords) {
@@ -159,6 +304,7 @@ async function uninstall(flags) {
   }
 
   const kept = [];
+  const failures = [];
   for (const record of records) {
     if (!selectedIds.includes(record.harness)) {
       kept.push(record);
@@ -172,16 +318,81 @@ async function uninstall(flags) {
       continue;
     }
 
-    await harness.uninstall(record);
-    console.log(`Removed ${record.harness}.`);
+    const ok = await runHarnessJob(failures, record.harness, "uninstall", async () => {
+      await harness.uninstall(record);
+      console.log(`Removed ${record.harness}.`);
+    });
+    if (!ok) kept.push(record);
+  }
+
+  for (const record of selectedRecords) {
+    if (records.some((existing) => existing.harness === record.harness)) continue;
+    const harness = HARNESS_BY_ID[record.harness];
+    if (!harness) {
+      console.log(`Skipping ${record.harness}: this CLI does not know how to uninstall it.`);
+      continue;
+    }
+    await runHarnessJob(failures, record.harness, "uninstall", async () => {
+      await harness.uninstall(record);
+      console.log(`Removed ${record.harness}.`);
+    });
   }
 
   manifest.installations = kept;
   await saveManifest(manifest);
+  reportFailures(failures);
+}
+
+async function resolveLifecycleTargets(flags, records) {
+  const requested = parseHarnessList(flags.harness);
+  const ids = flags.all
+    ? Object.keys(HARNESS_BY_ID)
+    : requested.length > 0
+      ? requested
+      : records.length > 0
+        ? records.map((record) => record.harness)
+        : await detectHarnessIds();
+
+  const selectedIds = [...new Set(ids)];
+  const selectedRecords = records.filter((record) => selectedIds.includes(record.harness));
+  const manifestIds = new Set(selectedRecords.map((record) => record.harness));
+
+  for (const id of selectedIds) {
+    if (manifestIds.has(id)) continue;
+    const harness = HARNESS_BY_ID[id];
+    if (!harness) continue;
+    if (!(await safeDetect(harness))) continue;
+    let plan;
+    try {
+      plan = await harness.planInstall();
+    } catch (error) {
+      console.log(`Skipping ${id}: ${formatError(error)}`);
+      continue;
+    }
+    selectedRecords.push({
+      harness: id,
+      config_path: plan.configPath ? compactHome(plan.configPath) : null,
+      backup_path: null,
+      installed_at: null,
+      recovered_from_detected_config: true,
+    });
+  }
+
+  return { selectedIds, selectedRecords };
+}
+
+async function detectHarnessIds() {
+  const ids = [];
+  for (const harness of Object.values(HARNESS_BY_ID)) {
+    if (await safeDetect(harness)) ids.push(harness.id);
+  }
+  return ids;
 }
 
 async function status() {
   const manifest = await loadManifest();
+  const pruned = pruneUnsupportedManifestRecords(manifest);
+  if (pruned.length > 0) await saveManifest(manifest);
   const records = manifest.installations || [];
   console.log("PennyRouter local setup");
   console.log("");
@@ -192,10 +403,13 @@ async function status() {
   }
 
   for (const record of records) {
-    console.log(`${record.harness}: ${record.manual_required ? "manual setup shown" : "installed"}`);
+    const state = record.disabled ? "disabled" : record.manual_required ? "manual setup shown" : "installed";
+    console.log(`${record.harness}: ${state}`);
     if (record.config_path) console.log(`  config: ${record.config_path}`);
     if (record.backup_path) console.log(`  backup: ${record.backup_path}`);
+    if (record.disabled_snapshot_path) console.log(`  disabled snapshot: ${record.disabled_snapshot_path}`);
     if (record.installed_at) console.log(`  installed: ${record.installed_at}`);
+    if (record.disabled_at) console.log(`  disabled: ${record.disabled_at}`);
     if (record.manual_required) console.log("  note: finish or remove this integration in the tool UI");
   }
 }
@@ -204,36 +418,168 @@ async function selectHarnesses(flags) {
   const requested = flags.all ? Object.keys(HARNESS_BY_ID) : parseHarnessList(flags.harness);
   const detected = [];
   for (const harness of Object.values(HARNESS_BY_ID)) {
-    if (await harness.detect()) detected.push(harness);
+    if (await safeDetect(harness)) detected.push(harness);
   }
 
   if (requested.length > 0) {
     return requested.map((id) => HARNESS_BY_ID[id]).filter(Boolean);
   }
 
-  if (detected.length === 0) {
-    console.log("No supported harness configs were detected.");
-    console.log("Use --harness claude-code,cline,opencode,codex to create config for specific tools.");
-    return [];
-  }
+  if (flags.yes) return detected;
 
-  if (flags.yes || detected.length === 1) return detected;
+  return promptHarnessCheckboxes(detected);
+}
 
-  console.log("Detected supported tools:");
-  detected.forEach((harness, index) => console.log(`  ${index + 1}. ${harness.name}`));
-  console.log("  a. All detected");
-  console.log("");
+async function promptHarnessCheckboxes(detected) {
+  const detectedIds = new Set(detected.map((harness) => harness.id));
+  const selectedIds = new Set(detectedIds);
+  const harnesses = orderedHarnessesForPrompt(detectedIds);
+  if (!input.isTTY || !output.isTTY) return promptHarnessCheckboxesByText(harnesses, selectedIds);
+
+  return promptHarnessCheckboxesByKeys(harnesses, selectedIds);
+}
 
+async function promptHarnessCheckboxesByKeys(harnesses, selectedIds) {
+  let cursor = 0;
+  const previousRawMode = input.isRaw;
+
+  emitKeypressEvents(input);
+  input.setRawMode(true);
+  input.resume();
+  output.write("\x1b[?25l");
+
+  const render = () => {
+    output.write("\x1b[2J\x1b[H");
+    output.write("\n\n");
+    output.write(`${color("Where should PennyRouter be installed?", "bold")}\n\n\n`);
+    harnesses.forEach((harness, index) => {
+      const pointer = index === cursor ? color(">", "cyan") : " ";
+      const checked = selectedIds.has(harness.id) ? color("x", "green") : " ";
+      const name = index === cursor ? color(harness.name, "cyan") : harness.name;
+      output.write(` ${pointer} [${checked}] ${name}\n`);
+    });
+    output.write("\nEnter to continue.\n");
+  };
+
+  render();
+
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      input.off("keypress", onKeypress);
+      input.setRawMode(Boolean(previousRawMode));
+      input.pause();
+      output.write("\x1b[?25h");
+      output.write("\n");
+    };
+
+    const onKeypress = (_str, key = {}) => {
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        reject(new Error("Cancelled."));
+        return;
+      }
+
+      if (key.name === "up" || key.name === "k") {
+        cursor = (cursor - 1 + harnesses.length) % harnesses.length;
+        render();
+        return;
+      }
+
+      if (key.name === "down" || key.name === "j") {
+        cursor = (cursor + 1) % harnesses.length;
+        render();
+        return;
+      }
+
+      if (key.name === "space") {
+        const id = harnesses[cursor].id;
+        if (selectedIds.has(id)) selectedIds.delete(id);
+        else selectedIds.add(id);
+        render();
+        return;
+      }
+
+      if (key.name === "return" || key.name === "enter") {
+        cleanup();
+        resolve(harnesses.filter((harness) => selectedIds.has(harness.id)));
+      }
+    };
+
+    input.on("keypress", onKeypress);
+  });
+}
+
+async function promptHarnessCheckboxesByText(harnesses, selectedIds) {
   const rl = createInterface({ input, output });
-  const answer = await rl.question("Install for which tools? Enter numbers, comma-separated, or 'a': ");
-  rl.close();
 
-  if (answer.trim().toLowerCase() === "a") return detected;
-  const indexes = answer
-    .split(",")
-    .map((part) => Number(part.trim()) - 1)
-    .filter((index) => Number.isInteger(index) && detected[index]);
-  return [...new Set(indexes)].map((index) => detected[index]);
+  try {
+    while (true) {
+      console.log("");
+      console.log("");
+      console.log(color("Where should PennyRouter be installed?", "bold"));
+      for (const harness of harnesses) {
+        const checked = selectedIds.has(harness.id) ? color("x", "green") : " ";
+        console.log(`  [${checked}] ${harness.name}`);
+      }
+      console.log("");
+      const answer = await rl.question(
+        "Press Enter to continue, or type names to toggle (comma-separated, 'all', or 'none'): ",
+      );
+      const value = answer.trim().toLowerCase();
+      if (!value) return harnesses.filter((harness) => selectedIds.has(harness.id));
+      if (value === "all") {
+        for (const harness of harnesses) selectedIds.add(harness.id);
+      } else if (value === "none") {
+        selectedIds.clear();
+      } else {
+        for (const token of parseHarnessList(value)) {
+          const id = resolveHarnessToken(token);
+          if (!HARNESS_BY_ID[id]) {
+            console.log(`Unknown tool "${token}".`);
+            continue;
+          }
+          if (selectedIds.has(id)) selectedIds.delete(id);
+          else selectedIds.add(id);
+        }
+      }
+      console.log("");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+function orderedHarnessesForPrompt(detectedIds) {
+  return Object.values(HARNESS_BY_ID).sort((left, right) => {
+    const leftDetected = detectedIds.has(left.id);
+    const rightDetected = detectedIds.has(right.id);
+    if (leftDetected !== rightDetected) return leftDetected ? -1 : 1;
+    return left.name.localeCompare(right.name);
+  });
+}
+
+function resolveHarnessToken(token) {
+  const normalized = normalizeHarnessToken(token);
+  for (const harness of Object.values(HARNESS_BY_ID)) {
+    if (normalizeHarnessToken(harness.id) === normalized) return harness.id;
+    if (normalizeHarnessToken(harness.name) === normalized) return harness.id;
+  }
+  return token;
+}
+
+function normalizeHarnessToken(value) {
+  return String(value).toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+function color(text, style) {
+  if (!output.isTTY || process.env.NO_COLOR) return text;
+  const codes = {
+    bold: ["\x1b[1m", "\x1b[22m"],
+    cyan: ["\x1b[36m", "\x1b[39m"],
+    green: ["\x1b[32m", "\x1b[39m"],
+  };
+  const pair = codes[style];
+  return pair ? `${pair[0]}${text}${pair[1]}` : text;
 }
 
 function parseHarnessList(value = "") {
@@ -255,6 +601,48 @@ function upsertManifestRecord(manifest, record) {
   manifest.installations.push(record);
 }
 
+function pruneUnsupportedManifestRecords(manifest) {
+  manifest.installations ||= [];
+  const kept = manifest.installations.filter((record) => HARNESS_BY_ID[record.harness]);
+  const pruned = manifest.installations.filter((record) => !HARNESS_BY_ID[record.harness]);
+  manifest.installations = kept;
+  return pruned;
+}
+
+async function safeDetect(harness) {
+  try {
+    return await harness.detect();
+  } catch (error) {
+    console.log(`Skipping ${harness.id}: detect failed: ${formatError(error)}`);
+    return false;
+  }
+}
+
+async function runHarnessJob(failures, harnessId, action, job) {
+  try {
+    await job();
+    return true;
+  } catch (error) {
+    failures.push({ harness: harnessId, action, error });
+    console.error(`${harnessId} ${action} failed: ${formatError(error)}`);
+    return false;
+  }
+}
+
+function reportFailures(failures) {
+  if (failures.length === 0) return;
+  console.error("");
+  console.error("Some PennyRouter integrations failed:");
+  for (const failure of failures) {
+    console.error(`  - ${failure.harness} ${failure.action}: ${formatError(failure.error)}`);
+  }
+  process.exitCode = 1;
+}
+
+function formatError(error) {
+  return error?.message || String(error);
+}
+
 async function confirm(question) {
   const rl = createInterface({ input, output });
   const answer = await rl.question(`${question} [y/N] `);
@@ -262,9 +650,15 @@ async function confirm(question) {
   return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
 }
 
-function printPlan(harness, plan) {
-  console.log(`${harness.name}:`);
-  for (const line of plan.summary) console.log(`  - ${line}`);
+function installNoteForRecord(record) {
+  if (record.manual_required) return " (manual setup shown)";
+  return installNoteForHarness(record.harness);
+}
+
+function installNoteForHarness(harnessId) {
+  if (harnessId === "cline" || harnessId === "codegpt") return " (manual setup)";
+  if (harnessId === "opencode") return " (select a Penny model from /model)";
+  return " (auto-selected)";
 }
 
 function openBrowser(url) {
@@ -279,14 +673,19 @@ function printHelp() {
   console.log(`PennyRouter CLI
 
 Usage:
-  pennyrouter install [--harness claude-code,cline,opencode,codex] [--all] [--yes] [--dry-run]
-  pennyrouter uninstall [--harness claude-code,cline,opencode,codex] [--all] [--yes]
+  pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--existing-account]
+  pennyrouter disable [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
+  pennyrouter enable [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
+  pennyrouter uninstall [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
   pennyrouter status
 
 Examples:
   npx pennyrouter install
+  npx pennyrouter install --existing-account
   npx pennyrouter install --all
-  npx pennyrouter install --harness claude-code,cline,opencode,codex --yes
+  npx pennyrouter install --harness windsurf,zed,codegpt,aider --yes
+  npx pennyrouter disable
+  npx pennyrouter enable
   npx pennyrouter uninstall
 `);
 }

package/src/harnesses/aider.js

@@ -0,0 +1,48 @@
+import { atomicWrite, backupFile, compactHome, exists, expandHome, readText } from "../state.js";
+import { removeYamlKeys, setYamlScalar } from "./shared.js";
+
+const CONFIG_PATH = "~/.aider.conf.yml";
+
+export const aiderHarness = {
+  id: "aider",
+  name: "Aider",
+
+  async detect() {
+    return exists(CONFIG_PATH);
+  },
+
+  async planInstall() {
+    return {
+      configPath: expandHome(CONFIG_PATH),
+      summary: [
+        `write ${CONFIG_PATH}`,
+        "set OpenAI-compatible base URL and API key",
+        "set default model to Penny Custom through LiteLLM naming",
+      ],
+    };
+  },
+
+  async install({ apiKey, gatewayBaseUrl, plan }) {
+    const backupPath = await backupFile(CONFIG_PATH, "aider");
+    let next = await readText(CONFIG_PATH, "");
+    next = setYamlScalar(next, "openai-api-base", `${gatewayBaseUrl}/v1`);
+    next = setYamlScalar(next, "openai-api-key", apiKey);
+    next = setYamlScalar(next, "model", "litellm/pennyrouter/auto");
+    await atomicWrite(CONFIG_PATH, next.endsWith("\n") ? next : `${next}\n`);
+
+    return {
+      harness: "aider",
+      config_path: compactHome(plan.configPath),
+      backup_path: backupPath ? compactHome(backupPath) : null,
+      installed_at: new Date().toISOString(),
+      restart: "restart Aider",
+      changes: { keys: ["openai-api-base", "openai-api-key", "model"] },
+    };
+  },
+
+  async uninstall(record) {
+    const text = await readText(record.config_path, "");
+    const next = removeYamlKeys(text, ["openai-api-base", "openai-api-key", "model"]);
+    await atomicWrite(record.config_path, next.endsWith("\n") ? next : `${next}\n`);
+  },
+};

package/src/harnesses/claude-code.js

@@ -1,6 +1,21 @@
 import { atomicWrite, backupFile, compactHome, exists, expandHome, readJsonFile } from "../state.js";
 
 const CONFIG_PATH = "~/.claude/settings.json";
+const LEGACY_MODEL_LABEL = "PennyRouter Bundle";
+const CLAUDE_CODE_MODELS = {
+  speed: "Penny Speed",
+  core: "Penny Core",
+  coreMax: "Penny Core Max",
+  power: "Penny Power",
+  custom: "Penny Custom",
+};
+const MODEL_OVERRIDE_KEYS = {
+  "claude-sonnet-4-6": CLAUDE_CODE_MODELS.core,
+  "claude-sonnet-4-6-1m": CLAUDE_CODE_MODELS.coreMax,
+  "claude-opus-4-8": CLAUDE_CODE_MODELS.power,
+  "claude-haiku-4-5": CLAUDE_CODE_MODELS.speed,
+  "claude-fable-5": CLAUDE_CODE_MODELS.custom,
+};
 
 export const claudeCodeHarness = {
   id: "claude-code",
@@ -17,7 +32,7 @@ export const claudeCodeHarness = {
         `write ${CONFIG_PATH}`,
         "set Anthropic-compatible base URL to PennyRouter",
         "store the PennyRouter API key without printing it",
-        'label every tier "PennyRouter Bundle" (routing is automatic)',
+        "map Claude Code models to Penny model choices",
       ],
     };
   },
@@ -31,12 +46,14 @@ export const claudeCodeHarness = {
     // Anthropic API key. Clear any stale key so it doesn't take precedence.
     current.env.ANTHROPIC_AUTH_TOKEN = apiKey;
     delete current.env.ANTHROPIC_API_KEY;
-    // The gateway ignores the requested model and routes by bundle + triage, so the
-    // per-tier names are cosmetic. Brand all three so the Claude Code footer shows
-    // "PennyRouter Bundle" instead of Opus/Sonnet/Haiku.
-    current.env.ANTHROPIC_DEFAULT_OPUS_MODEL = "PennyRouter Bundle";
-    current.env.ANTHROPIC_DEFAULT_SONNET_MODEL = "PennyRouter Bundle";
-    current.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = "PennyRouter Bundle";
+    // Claude Code displays these env values directly in its model picker; the
+    // gateway decodes the friendly labels into bundle/profile overrides.
+    current.env.ANTHROPIC_DEFAULT_OPUS_MODEL = CLAUDE_CODE_MODELS.power;
+    current.env.ANTHROPIC_DEFAULT_SONNET_MODEL = CLAUDE_CODE_MODELS.speed;
+    current.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = CLAUDE_CODE_MODELS.core;
+    current.env.ANTHROPIC_DEFAULT_FABLE_MODEL = CLAUDE_CODE_MODELS.custom;
+    current.modelOverrides ||= {};
+    Object.assign(current.modelOverrides, MODEL_OVERRIDE_KEYS);
 
     await atomicWrite(CONFIG_PATH, `${JSON.stringify(current, null, 2)}\n`);
 
@@ -53,14 +70,16 @@ export const claudeCodeHarness = {
           "ANTHROPIC_DEFAULT_OPUS_MODEL",
           "ANTHROPIC_DEFAULT_SONNET_MODEL",
           "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+          "ANTHROPIC_DEFAULT_FABLE_MODEL",
         ],
+        model_overrides: Object.keys(MODEL_OVERRIDE_KEYS),
       },
     };
   },
 
   async uninstall(record) {
     const current = (await readJsonFile(record.config_path, null)) || {};
-    if (current.env?.ANTHROPIC_BASE_URL?.includes("pennyrouter.com")) {
+    if (hasPennyRouterEnv(current.env)) {
       delete current.env.ANTHROPIC_BASE_URL;
       const tok = current.env.ANTHROPIC_AUTH_TOKEN;
       if (typeof tok === "string" && tok.startsWith("pr-")) {
@@ -74,11 +93,60 @@ export const claudeCodeHarness = {
         "ANTHROPIC_DEFAULT_OPUS_MODEL",
         "ANTHROPIC_DEFAULT_SONNET_MODEL",
         "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+        "ANTHROPIC_DEFAULT_FABLE_MODEL",
       ]) {
-        if (current.env[k] === "PennyRouter Bundle") delete current.env[k];
+        if (current.env[k] === LEGACY_MODEL_LABEL || isPennyRouterModelValue(current.env[k])) delete current.env[k];
       }
     }
+    if (current.modelOverrides && typeof current.modelOverrides === "object") {
+      for (const [key, value] of Object.entries(MODEL_OVERRIDE_KEYS)) {
+        if (current.modelOverrides[key] === value) delete current.modelOverrides[key];
+      }
+      if (Object.keys(current.modelOverrides).length === 0) delete current.modelOverrides;
+    }
+    if (current["anthropic.baseURL"] && isPennyRouterValue(current["anthropic.baseURL"])) {
+      delete current["anthropic.baseURL"];
+    }
+    if (typeof current["anthropic.apiKey"] === "string" && current["anthropic.apiKey"].startsWith("pr-")) {
+      delete current["anthropic.apiKey"];
+    }
     if (current.env && Object.keys(current.env).length === 0) delete current.env;
     await atomicWrite(record.config_path, `${JSON.stringify(current, null, 2)}\n`);
   },
 };
+
+function hasPennyRouterEnv(env) {
+  if (!env || typeof env !== "object") return false;
+  return (
+    isPennyRouterBaseUrl(env.ANTHROPIC_BASE_URL) ||
+    isPennyRouterValue(env.ANTHROPIC_AUTH_TOKEN) ||
+    isPennyRouterValue(env.ANTHROPIC_API_KEY) ||
+    env.ANTHROPIC_DEFAULT_OPUS_MODEL === LEGACY_MODEL_LABEL ||
+    env.ANTHROPIC_DEFAULT_SONNET_MODEL === LEGACY_MODEL_LABEL ||
+    env.ANTHROPIC_DEFAULT_HAIKU_MODEL === LEGACY_MODEL_LABEL ||
+    env.ANTHROPIC_DEFAULT_FABLE_MODEL === LEGACY_MODEL_LABEL ||
+    isPennyRouterModelValue(env.ANTHROPIC_DEFAULT_OPUS_MODEL) ||
+    isPennyRouterModelValue(env.ANTHROPIC_DEFAULT_SONNET_MODEL) ||
+    isPennyRouterModelValue(env.ANTHROPIC_DEFAULT_HAIKU_MODEL) ||
+    isPennyRouterModelValue(env.ANTHROPIC_DEFAULT_FABLE_MODEL)
+  );
+}
+
+function isPennyRouterValue(value) {
+  return typeof value === "string" && (value.startsWith("pr-") || value.includes("pennyrouter"));
+}
+
+function isPennyRouterBaseUrl(value) {
+  return typeof value === "string" && value.includes("pennyrouter");
+}
+
+function isPennyRouterModelValue(value) {
+  return (
+    isPennyRouterValue(value) ||
+    value === CLAUDE_CODE_MODELS.speed ||
+    value === CLAUDE_CODE_MODELS.core ||
+    value === CLAUDE_CODE_MODELS.coreMax ||
+    value === CLAUDE_CODE_MODELS.power ||
+    value === CLAUDE_CODE_MODELS.custom
+  );
+}

package/src/harnesses/cline.js

@@ -28,7 +28,7 @@ export const clineHarness = {
     console.log("  - API Provider: OpenAI Compatible");
     console.log(`  - Base URL: ${gatewayBaseUrl}/v1`);
     console.log(`  - API Key: ${copied ? "copied to clipboard" : "copy from your PennyRouter dashboard"}`);
-    console.log("  - Model ID: pennyrouter/auto");
+    console.log("  - Model ID: pennyrouter/auto (Penny Custom)");
     console.log("");
     console.log("The CLI did not write VS Code settings because Cline stores provider config differently across versions.");
     if (!copied) {
@@ -46,6 +46,7 @@ export const clineHarness = {
         provider: "OpenAI Compatible",
         base_url: `${gatewayBaseUrl}/v1`,
         model: "pennyrouter/auto",
+        model_name: "Penny Custom",
       },
     };
   },

package/src/harnesses/codegpt.js

@@ -0,0 +1,76 @@
+import { spawnSync } from "node:child_process";
+
+export const codeGptHarness = {
+  id: "codegpt",
+  name: "JetBrains CodeGPT",
+
+  async detect() {
+    return false;
+  },
+
+  async planInstall() {
+    return {
+      configPath: null,
+      summary: [
+        "show manual CodeGPT OpenAI-compatible setup instructions",
+        "do not mutate JetBrains XML settings until the exact IDE/version schema is confirmed",
+        "record that manual CodeGPT setup instructions were shown",
+      ],
+    };
+  },
+
+  async install({ apiKey, gatewayBaseUrl }) {
+    const copied = copyToClipboard(apiKey);
+
+    console.log("");
+    console.log("JetBrains CodeGPT manual setup");
+    console.log("  Open CodeGPT settings in your JetBrains IDE and set:");
+    console.log(`  - Base URL: ${gatewayBaseUrl}/v1`);
+    console.log(`  - API Key: ${copied ? "copied to clipboard" : "copy from your PennyRouter dashboard"}`);
+    console.log("  - Model: pennyrouter/auto (Penny Custom)");
+    console.log("");
+    console.log("The CLI did not write JetBrains XML settings because CodeGPT stores options under IDE/version-specific paths.");
+    if (!copied) {
+      console.log("Clipboard copy failed, so the key was not printed. Open PennyRouter and create or reveal a key manually for CodeGPT.");
+    }
+
+    return {
+      harness: "codegpt",
+      config_path: null,
+      backup_path: null,
+      installed_at: new Date().toISOString(),
+      manual_required: true,
+      restart: "restart the JetBrains IDE after saving CodeGPT settings",
+      changes: {
+        provider: "OpenAI Compatible",
+        base_url: `${gatewayBaseUrl}/v1`,
+        model: "pennyrouter/auto",
+        model_name: "Penny Custom",
+      },
+    };
+  },
+
+  async uninstall() {
+    console.log("");
+    console.log("JetBrains CodeGPT manual uninstall");
+    console.log("  Open CodeGPT settings and remove or replace the PennyRouter provider:");
+    console.log("  - Base URL: https://api.pennyrouter.com/v1");
+    console.log("  - API Key: pr-...");
+    console.log("  - Model: pennyrouter/auto");
+  },
+};
+
+function copyToClipboard(text) {
+  const commands =
+    process.platform === "darwin"
+      ? [["pbcopy"]]
+      : process.platform === "win32"
+        ? [["clip"]]
+        : [["xclip", "-selection", "clipboard"], ["xsel", "--clipboard", "--input"]];
+
+  for (const [command, ...args] of commands) {
+    const result = spawnSync(command, args, { input: text, stdio: ["pipe", "ignore", "ignore"] });
+    if (result.status === 0) return true;
+  }
+  return false;
+}

package/src/harnesses/opencode.js

@@ -8,6 +8,7 @@ import {
   readText,
   writeJsonFile,
 } from "../state.js";
+import { PENNYROUTER_MODEL_CHOICES } from "./shared.js";
 
 const JSONC_PATH = "~/.config/opencode/opencode.jsonc";
 const JSON_PATH = "~/.config/opencode/opencode.json";
@@ -15,7 +16,7 @@ const MODEL_STATE_PATH = "~/.local/state/opencode/model.json";
 
 export const opencodeHarness = {
   id: "opencode",
-  name: "opencode",
+  name: "OpenCode",
 
   async detect() {
     return (await exists(JSONC_PATH)) || (await exists(JSON_PATH));
@@ -28,6 +29,7 @@ export const opencodeHarness = {
       summary: [
         `write ${configPath}`,
         "merge PennyRouter provider without replacing existing providers",
+        "publish the four Penny model choices",
         `reset ${MODEL_STATE_PATH} so opencode rediscovers configured models`,
       ],
     };
@@ -45,17 +47,9 @@ export const opencodeHarness = {
         baseURL: `${gatewayBaseUrl}/v1`,
         apiKey,
       },
-      models: {
-        "pennyrouter/auto": { name: "PennyRouter Auto" },
-        "pennyrouter/anthropic": { name: "PennyRouter Anthropic" },
-        "pennyrouter/openai": { name: "PennyRouter OpenAI" },
-        "pennyrouter/gemini": { name: "PennyRouter Gemini" },
-        "pennyrouter/grok": { name: "PennyRouter Grok" },
-        "pennyrouter/deepseek": { name: "PennyRouter DeepSeek" },
-        "pennyrouter/zai": { name: "PennyRouter Z.ai" },
-        "pennyrouter/qwen": { name: "PennyRouter Qwen" },
-        "pennyrouter/penny": { name: "PennyRouter Penny" },
-      },
+      models: Object.fromEntries(
+        PENNYROUTER_MODEL_CHOICES.map((model) => [model.id, { name: model.name }]),
+      ),
     };
 
     await atomicWrite(configPath, `${JSON.stringify(current, null, 2)}\n`);
@@ -68,7 +62,7 @@ export const opencodeHarness = {
       config_path: compactHome(plan.configPath),
       backup_path: backupPath ? compactHome(backupPath) : null,
       installed_at: new Date().toISOString(),
-      restart: "type /exit, run opencode again, then pick PennyRouter Auto",
+      restart: "type /exit, run opencode again, then pick a Penny model",
       changes: {
         provider_id: "pennyrouter",
         model_state_path: MODEL_STATE_PATH,

package/src/harnesses/shared.js

@@ -0,0 +1,51 @@
+export const PENNYROUTER_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: "Penny Custom",
+  },
+];
+
+export const PENNYROUTER_MODELS = PENNYROUTER_MODEL_CHOICES.map((model) => model.id);
+
+export const PENNYROUTER_MODEL_NAMES = Object.fromEntries(
+  PENNYROUTER_MODEL_CHOICES.map((model) => [model.id, model.name]),
+);
+
+export function removeJsonKeys(object, keys) {
+  if (!object || typeof object !== "object") return;
+  for (const key of keys) delete object[key];
+}
+
+export function setYamlScalar(text, key, value) {
+  const escaped = String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const line = `${key}: "${escaped}"`;
+  const pattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*:.*$`, "m");
+  if (pattern.test(text)) return text.replace(pattern, line);
+  const normalized = text.trimEnd();
+  return `${normalized}${normalized ? "\n" : ""}${line}\n`;
+}
+
+export function removeYamlKeys(text, keys) {
+  const patterns = keys.map((key) => new RegExp(`^\\s*${escapeRegExp(key)}\\s*:.*$`));
+  return text
+    .split("\n")
+    .filter((line) => !patterns.some((pattern) => pattern.test(line)))
+    .join("\n")
+    .replace(/\n{3,}/g, "\n\n");
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/src/harnesses/windsurf.js

@@ -0,0 +1,57 @@
+import { atomicWrite, backupFile, compactHome, exists, expandHome, readJsonFile } from "../state.js";
+import { PENNYROUTER_MODELS } from "./shared.js";
+
+const CONFIG_PATH = process.platform === "win32"
+  ? "~/\\.codeium\\windsurf\\config.json"
+  : "~/.codeium/windsurf/config.json";
+
+export const windsurfHarness = {
+  id: "windsurf",
+  name: "Windsurf",
+
+  async detect() {
+    return exists(CONFIG_PATH);
+  },
+
+  async planInstall() {
+    return {
+      configPath: expandHome(CONFIG_PATH),
+      summary: [
+        `write ${CONFIG_PATH}`,
+        "set OpenAI-compatible base URL and API key",
+        "enable PennyRouter model aliases",
+      ],
+    };
+  },
+
+  async install({ apiKey, gatewayBaseUrl, plan }) {
+    const backupPath = await backupFile(CONFIG_PATH, "windsurf");
+    const current = (await readJsonFile(CONFIG_PATH, null)) || {};
+    current.api_base_url = `${gatewayBaseUrl}/v1`;
+    current.api_key = apiKey;
+    current.enabled_models = PENNYROUTER_MODELS;
+    await atomicWrite(CONFIG_PATH, `${JSON.stringify(current, null, 2)}\n`);
+
+    return {
+      harness: "windsurf",
+      config_path: compactHome(plan.configPath),
+      backup_path: backupPath ? compactHome(backupPath) : null,
+      installed_at: new Date().toISOString(),
+      restart: "restart Windsurf",
+      changes: { keys: ["api_base_url", "api_key", "enabled_models"] },
+    };
+  },
+
+  async uninstall(record) {
+    const current = (await readJsonFile(record.config_path, null)) || {};
+    if (typeof current.api_base_url === "string" && current.api_base_url.includes("pennyrouter")) {
+      delete current.api_base_url;
+      if (typeof current.api_key === "string" && current.api_key.startsWith("pr-")) delete current.api_key;
+    }
+    if (Array.isArray(current.enabled_models)) {
+      current.enabled_models = current.enabled_models.filter((model) => !String(model).includes("pennyrouter"));
+      if (current.enabled_models.length === 0) delete current.enabled_models;
+    }
+    await atomicWrite(record.config_path, `${JSON.stringify(current, null, 2)}\n`);
+  },
+};

package/src/harnesses/zed.js

@@ -0,0 +1,61 @@
+import { atomicWrite, backupFile, compactHome, exists, expandHome, readJsonFile } from "../state.js";
+import { PENNYROUTER_MODELS } from "./shared.js";
+
+const CONFIG_PATH = process.platform === "win32"
+  ? "~/AppData/Roaming/Zed/settings.json"
+  : "~/.config/zed/settings.json";
+
+export const zedHarness = {
+  id: "zed",
+  name: "Zed",
+
+  async detect() {
+    return exists(CONFIG_PATH);
+  },
+
+  async planInstall() {
+    return {
+      configPath: expandHome(CONFIG_PATH),
+      summary: [
+        `write ${CONFIG_PATH}`,
+        "configure Zed custom language model provider for PennyRouter",
+        "publish PennyRouter model aliases",
+      ],
+    };
+  },
+
+  async install({ apiKey, gatewayBaseUrl, plan }) {
+    const backupPath = await backupFile(CONFIG_PATH, "zed");
+    const current = (await readJsonFile(CONFIG_PATH, null)) || {};
+    current.language_models ||= {};
+    current.language_models.providers ||= {};
+    current.language_models.providers.custom = {
+      api_url: `${gatewayBaseUrl}/v1`,
+      api_key: apiKey,
+      available_models: PENNYROUTER_MODELS,
+    };
+    await atomicWrite(CONFIG_PATH, `${JSON.stringify(current, null, 2)}\n`);
+
+    return {
+      harness: "zed",
+      config_path: compactHome(plan.configPath),
+      backup_path: backupPath ? compactHome(backupPath) : null,
+      installed_at: new Date().toISOString(),
+      restart: "restart Zed",
+      changes: { provider: "language_models.providers.custom" },
+    };
+  },
+
+  async uninstall(record) {
+    const current = (await readJsonFile(record.config_path, null)) || {};
+    const provider = current.language_models?.providers?.custom;
+    if (provider && JSON.stringify(provider).includes("pennyrouter")) {
+      delete current.language_models.providers.custom;
+    }
+    if (current.language_models?.providers && Object.keys(current.language_models.providers).length === 0) {
+      delete current.language_models.providers;
+    }
+    if (current.language_models && Object.keys(current.language_models).length === 0) delete current.language_models;
+    await atomicWrite(record.config_path, `${JSON.stringify(current, null, 2)}\n`);
+  },
+};

package/src/session.js

@@ -5,7 +5,7 @@ export function maskKey(key) {
   return `${key.slice(0, 3)}...${key.slice(-4)}`;
 }
 
-export async function createCliSession({ appUrl = APP_URL, harnesses }) {
+export async function createCliSession({ appUrl = APP_URL, harnesses, accountMode = "seed" }) {
   const label = `${platformName()} / ${harnesses.join(",") || "PennyRouter"}`;
   const response = await fetch(`${appUrl}/api/cli/session`, {
     method: "POST",
@@ -13,6 +13,7 @@ export async function createCliSession({ appUrl = APP_URL, harnesses }) {
     body: JSON.stringify({
       harness: harnesses.join(","),
       label,
+      account_mode: accountMode,
     }),
   });
 

package/src/state.js

@@ -82,6 +82,13 @@ export async function backupFile(path, harness) {
   return backupPath;
 }
 
+export async function restoreFile(sourcePath, destinationPath) {
+  const source = expandHome(sourcePath);
+  const destination = expandHome(destinationPath);
+  await mkdir(dirname(destination), { recursive: true });
+  await copyFile(source, destination);
+}
+
 export async function atomicWrite(path, text) {
   const expanded = expandHome(path);
   await mkdir(dirname(expanded), { recursive: true });