pennyrouter 0.1.4 → 0.1.6

package/README.md

@@ -11,7 +11,7 @@ status checks, and uninstall metadata.
 ```bash
 npx pennyrouter install
 npx pennyrouter install --existing-account
-npx pennyrouter install --harness claude-code,cline,opencode,codex,cursor,windsurf,zed,codegpt,aider
+npx pennyrouter install --harness claude-code,cline,opencode,codex,windsurf,zed,codegpt,aider
 npx pennyrouter disable
 npx pennyrouter enable
 npx pennyrouter uninstall
@@ -27,12 +27,20 @@ detected configs start checked; press Enter to accept or type tool IDs to toggle
 - Cline (manual setup instructions; no VS Code settings mutation)
 - Codex
 - opencode
-- Cursor
 - 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
 
 Users can ask a coding agent to follow:

package/package.json

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

package/src/cli.js

@@ -7,7 +7,6 @@ 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";
@@ -20,6 +19,7 @@ import {
 } from "./session.js";
 import {
   backupFile,
+  compactHome,
   loadManifest,
   restoreFile,
   saveManifest,
@@ -31,7 +31,6 @@ const HARNESS_BY_ID = {
   cline: clineHarness,
   opencode: opencodeHarness,
   codex: codexHarness,
-  cursor: cursorHarness,
   windsurf: windsurfHarness,
   zed: zedHarness,
   codegpt: codeGptHarness,
@@ -139,15 +138,19 @@ async function install(flags) {
 
   const manifest = await loadManifest();
   const records = [];
+  const failures = [];
   for (const harness of selected) {
-    const plan = await harness.planInstall();
-    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);
@@ -158,13 +161,14 @@ async function install(flags) {
     console.log(`Installed on ${harness?.name || record.harness}${installNoteForRecord(record)}.`);
   }
   console.log(`Manifest: ${statePath("installations.json")}`);
+  reportFailures(failures);
 }
 
 async function disable(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));
+  const { selectedIds, selectedRecords } = await resolveLifecycleTargets(flags, records);
 
   if (selectedRecords.length === 0) {
     console.log("No matching PennyRouter installations found.");
@@ -183,6 +187,7 @@ async function disable(flags) {
     if (!ok) return;
   }
 
+  const failures = [];
   for (const record of selectedRecords) {
     if (record.disabled) {
       console.log(`${record.harness} is already disabled.`);
@@ -195,24 +200,30 @@ async function disable(flags) {
       continue;
     }
 
-    if (record.config_path) {
-      const snapshotPath = await backupFile(record.config_path, `${record.harness}-disabled`);
-      record.disabled_snapshot_path = snapshotPath;
-    }
+    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);
+      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}.`);
+      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));
@@ -234,6 +245,7 @@ async function enable(flags) {
     if (!ok) return;
   }
 
+  const failures = [];
   for (const record of selectedRecords) {
     if (!record.disabled) {
       console.log(`${record.harness} is already enabled.`);
@@ -246,29 +258,33 @@ async function enable(flags) {
       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;
-    }
+    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;
-    console.log(`Enabled ${record.harness}.`);
+      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 = resolveRequestedHarnessIds(flags, records.map((record) => record.harness));
-  const selectedRecords = records.filter((record) => selectedIds.includes(record.harness));
+  const { selectedIds, selectedRecords } = await resolveLifecycleTargets(flags, records);
 
   if (selectedRecords.length === 0) {
     console.log("No matching PennyRouter installations found.");
@@ -288,6 +304,7 @@ async function uninstall(flags) {
   }
 
   const kept = [];
+  const failures = [];
   for (const record of records) {
     if (!selectedIds.includes(record.harness)) {
       kept.push(record);
@@ -301,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("");
@@ -336,7 +418,7 @@ 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) {
@@ -519,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] `);
@@ -533,7 +657,7 @@ function installNoteForRecord(record) {
 
 function installNoteForHarness(harnessId) {
   if (harnessId === "cline" || harnessId === "codegpt") return " (manual setup)";
-  if (harnessId === "opencode") return " (select PennyRouter Auto from /model)";
+  if (harnessId === "opencode") return " (select a Penny model from /model)";
   return " (auto-selected)";
 }
 
@@ -559,7 +683,7 @@ Examples:
   npx pennyrouter install
   npx pennyrouter install --existing-account
   npx pennyrouter install --all
-  npx pennyrouter install --harness cursor,windsurf,zed,codegpt,aider --yes
+  npx pennyrouter install --harness windsurf,zed,codegpt,aider --yes
   npx pennyrouter disable
   npx pennyrouter enable
   npx pennyrouter uninstall

package/src/harnesses/aider.js

@@ -17,7 +17,7 @@ export const aiderHarness = {
       summary: [
         `write ${CONFIG_PATH}`,
         "set OpenAI-compatible base URL and API key",
-        "set default model to PennyRouter Auto through LiteLLM naming",
+        "set default model to Penny Custom through LiteLLM naming",
       ],
     };
   },

package/src/harnesses/claude-code.js

@@ -1,6 +1,13 @@
 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",
+  power: "Penny Power",
+  custom: "Penny Custom",
+};
 
 export const claudeCodeHarness = {
   id: "claude-code",
@@ -17,7 +24,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 +38,12 @@ 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.core;
+    current.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = CLAUDE_CODE_MODELS.speed;
+    current.env.ANTHROPIC_DEFAULT_FABLE_MODEL = CLAUDE_CODE_MODELS.custom;
 
     await atomicWrite(CONFIG_PATH, `${JSON.stringify(current, null, 2)}\n`);
 
@@ -53,6 +60,7 @@ export const claudeCodeHarness = {
           "ANTHROPIC_DEFAULT_OPUS_MODEL",
           "ANTHROPIC_DEFAULT_SONNET_MODEL",
           "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+          "ANTHROPIC_DEFAULT_FABLE_MODEL",
         ],
       },
     };
@@ -60,7 +68,7 @@ export const claudeCodeHarness = {
 
   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 +82,53 @@ 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["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.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

@@ -27,7 +27,7 @@ export const codeGptHarness = {
     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("  - 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) {
@@ -45,6 +45,7 @@ export const codeGptHarness = {
         provider: "OpenAI Compatible",
         base_url: `${gatewayBaseUrl}/v1`,
         model: "pennyrouter/auto",
+        model_name: "Penny Custom",
       },
     };
   },

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";
@@ -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

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

package/src/harnesses/cursor.js

@@ -1,83 +0,0 @@
-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, "''")}'`;
-}