pennyrouter 0.1.3 → 0.1.4

package/README.md

@@ -10,17 +10,28 @@ 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,cursor,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
+- Cursor
+- Windsurf
+- Zed
+- JetBrains CodeGPT (manual setup instructions; no XML mutation)
+- Aider
 
 ## Agent Flow
 
@@ -38,6 +49,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.4",
   "description": "Install and manage PennyRouter local coding-agent integrations.",
   "homepage": "https://pennyrouter.com",
   "bugs": {

package/src/cli.js

@@ -1,10 +1,16 @@
 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 { cursorHarness } from "./harnesses/cursor.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 +19,9 @@ import {
   sleep,
 } from "./session.js";
 import {
-  expandHome,
+  backupFile,
   loadManifest,
-  readJsonFile,
+  restoreFile,
   saveManifest,
   statePath,
 } from "./state.js";
@@ -25,8 +31,15 @@ const HARNESS_BY_ID = {
   cline: clineHarness,
   opencode: opencodeHarness,
   codex: codexHarness,
+  cursor: cursorHarness,
+  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 +58,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 +88,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 +108,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 +120,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("");
@@ -116,7 +141,6 @@ async function install(flags) {
   const records = [];
   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,
@@ -129,10 +153,115 @@ async function install(flags) {
   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")}`);
+}
+
+async function disable(flags) {
+  const manifest = await loadManifest();
+  const records = manifest.installations || [];
+  const selectedIds = resolveRequestedHarnessIds(flags, records.map((record) => record.harness));
+  const selectedRecords = records.filter((record) => selectedIds.includes(record.harness));
+
+  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;
+  }
+
+  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;
+    }
+
+    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();
+    console.log(`Disabled ${record.harness}.`);
+  }
+
+  await saveManifest(manifest);
+}
+
+async function enable(flags) {
+  const manifest = await loadManifest();
+  const records = manifest.installations || [];
+  const selectedIds = resolveRequestedHarnessIds(flags, records.map((record) => record.harness));
+  const selectedRecords = records.filter((record) => selectedIds.includes(record.harness));
+
+  if (selectedRecords.length === 0) {
+    console.log("No matching PennyRouter installations found.");
+    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;
+  }
+
+  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;
+    }
+
+    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 {
+      console.log(`${record.harness}: no disabled snapshot found; run install again.`);
+      continue;
+    }
+
+    delete record.disabled;
+    delete record.disabled_at;
+    console.log(`Enabled ${record.harness}.`);
+  }
+
+  await saveManifest(manifest);
 }
 
 async function uninstall(flags) {
@@ -192,10 +321,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");
   }
 }
@@ -211,29 +343,161 @@ async function selectHarnesses(flags) {
     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 = "") {
@@ -262,9 +526,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 PennyRouter Auto from /model)";
+  return " (auto-selected)";
 }
 
 function openBrowser(url) {
@@ -279,14 +549,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 cursor,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 PennyRouter Auto 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/codegpt.js

@@ -0,0 +1,75 @@
+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");
+    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",
+      },
+    };
+  },
+
+  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/cursor.js

@@ -0,0 +1,83 @@
+import { spawnSync } from "node:child_process";
+import { backupFile, compactHome, exists, expandHome } from "../state.js";
+import { PENNYROUTER_MODELS } from "./shared.js";
+
+const CONFIG_PATH = process.platform === "darwin"
+  ? "~/Library/Application Support/Cursor/User/globalStorage/state.vscdb"
+  : process.platform === "win32"
+    ? "~/AppData/Roaming/Cursor/User/globalStorage/state.vscdb"
+    : "~/.config/Cursor/User/globalStorage/state.vscdb";
+
+export const cursorHarness = {
+  id: "cursor",
+  name: "Cursor",
+
+  async detect() {
+    return exists(CONFIG_PATH);
+  },
+
+  async planInstall() {
+    return {
+      configPath: expandHome(CONFIG_PATH),
+      summary: [
+        `write ${CONFIG_PATH}`,
+        "set Cursor backend OpenAI base URL and API key",
+        "set Cursor custom model list to PennyRouter aliases",
+      ],
+    };
+  },
+
+  async install({ apiKey, gatewayBaseUrl, plan }) {
+    const backupPath = await backupFile(CONFIG_PATH, "cursor");
+    runSqlite(plan.configPath, [
+      ["backend.openaiBaseUrl", JSON.stringify(`${gatewayBaseUrl}/v1`)],
+      ["backend.openaiApiKey", JSON.stringify(apiKey)],
+      ["backend.customModels", JSON.stringify(PENNYROUTER_MODELS)],
+    ]);
+
+    return {
+      harness: "cursor",
+      config_path: compactHome(plan.configPath),
+      backup_path: backupPath ? compactHome(backupPath) : null,
+      installed_at: new Date().toISOString(),
+      restart: "quit and restart Cursor",
+      changes: {
+        table: "kvptr",
+        keys: ["backend.openaiBaseUrl", "backend.openaiApiKey", "backend.customModels"],
+      },
+    };
+  },
+
+  async uninstall(record) {
+    runSqlite(expandHome(record.config_path), null, [
+      "backend.openaiBaseUrl",
+      "backend.openaiApiKey",
+      "backend.customModels",
+    ]);
+  },
+};
+
+function runSqlite(dbPath, upserts = [], deletes = []) {
+  const statements = [];
+  for (const [key, value] of upserts || []) {
+    statements.push(`INSERT OR REPLACE INTO kvptr (key, value) VALUES (${sqlString(key)}, ${sqlString(value)});`);
+  }
+  for (const key of deletes || []) {
+    statements.push(`DELETE FROM kvptr WHERE key = ${sqlString(key)};`);
+  }
+
+  const result = spawnSync("sqlite3", [dbPath], {
+    input: `${statements.join("\n")}\n`,
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  if (result.status !== 0) {
+    const detail = result.stderr?.trim() || "sqlite3 command failed";
+    throw new Error(`Cursor config update failed: ${detail}. Quit Cursor and ensure sqlite3 is installed.`);
+  }
+}
+
+function sqlString(value) {
+  return `'${String(value).replace(/'/g, "''")}'`;
+}

package/src/harnesses/opencode.js

@@ -15,7 +15,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));

package/src/harnesses/shared.js

@@ -0,0 +1,38 @@
+export const PENNYROUTER_MODELS = [
+  "pennyrouter/auto",
+  "pennyrouter/anthropic",
+  "pennyrouter/openai",
+  "pennyrouter/gemini",
+  "pennyrouter/grok",
+  "pennyrouter/deepseek",
+  "pennyrouter/zai",
+  "pennyrouter/qwen",
+  "pennyrouter/penny",
+];
+
+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 });