pennyrouter 0.2.1 → 0.2.2

package/README.md

@@ -22,8 +22,9 @@ npx pennyrouter status
 Installation opens a browser and requires login to the PennyRouter account that should own
 the new machine key. CLI installs no longer create anonymous ghost accounts.
 
-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.
+With no `--harness` flag, the interactive installer shows Claude Code and Codex. Detected
+tools start checked. The additional legacy integrations remain available through an explicit
+`--harness <id>` selection or `--all`.
 
 When Claude Code is selected, the installer also offers an optional Claude Pro/Max
 subscription-auth step. Users can skip it during install and enable it later with

package/package.json

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

package/src/cli.js

@@ -59,6 +59,7 @@ const HARNESS_BY_ID = {
 };
 
 const SUPPORTED_HARNESS_IDS = Object.keys(HARNESS_BY_ID).join(",");
+const DEFAULT_INSTALL_HARNESS_IDS = ["claude-code", "codex"];
 
 export async function main(argv = process.argv.slice(2)) {
   const { command, flags } = parseArgs(argv);
@@ -945,15 +946,16 @@ async function status() {
 
 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 safeDetect(harness)) detected.push(harness);
-  }
-
   if (requested.length > 0) {
     return requested.map((id) => HARNESS_BY_ID[id]).filter(Boolean);
   }
 
+  const detected = [];
+  for (const id of DEFAULT_INSTALL_HARNESS_IDS) {
+    const harness = HARNESS_BY_ID[id];
+    if (await safeDetect(harness)) detected.push(harness);
+  }
+
   if (flags.yes) return detected;
 
   return promptHarnessCheckboxes(detected);
@@ -1079,7 +1081,7 @@ async function promptHarnessCheckboxesByText(harnesses, selectedIds) {
 }
 
 function orderedHarnessesForPrompt(detectedIds) {
-  return Object.values(HARNESS_BY_ID).sort((left, right) => {
+  return DEFAULT_INSTALL_HARNESS_IDS.map((id) => HARNESS_BY_ID[id]).sort((left, right) => {
     const leftDetected = detectedIds.has(left.id);
     const rightDetected = detectedIds.has(right.id);
     if (leftDetected !== rightDetected) return leftDetected ? -1 : 1;

package/src/launch.js

@@ -54,7 +54,11 @@ export function codexLaunchProfilePath() {
   return join(codexHome, "pennyrouter.config.toml");
 }
 
-export function claudeUserCommandPath() {
+export function claudeUserSkillPath() {
+  return join(homeDir(), ".claude", "skills", "penny", "SKILL.md");
+}
+
+function legacyClaudeUserCommandPath() {
   return join(homeDir(), ".claude", "commands", "penny.md");
 }
 
@@ -180,8 +184,8 @@ async function writeClaudeLaunchSettings() {
   await privateWrite(claudeLaunchSettingsPath(), `${JSON.stringify(overlay, null, 2)}\n`);
 }
 
-async function writeClaudeUserCommand() {
-  const path = claudeUserCommandPath();
+async function writeClaudeUserSkill() {
+  const path = claudeUserSkillPath();
   const existing = await readText(path, "");
   if (existing.trim() && !existing.includes(CLAUDE_COMMAND_MARKER)) {
     throw new Error(
@@ -191,14 +195,23 @@ async function writeClaudeUserCommand() {
   await mkdir(dirname(path), { recursive: true });
   await atomicWrite(path, [
     "---",
+    "name: penny",
     "description: PennyRouter commands and help.",
     "argument-hint: <command and arguments>",
+    "disable-model-invocation: true",
     "---",
     CLAUDE_COMMAND_MARKER,
     "",
     "@penny $ARGUMENTS",
     "",
   ].join("\n"));
+  const legacyPath = legacyClaudeUserCommandPath();
+  const legacy = await readText(legacyPath, "");
+  if (legacy.includes(CLAUDE_COMMAND_MARKER)) {
+    await unlink(legacyPath).catch((error) => {
+      if (error.code !== "ENOENT") throw error;
+    });
+  }
 }
 
 async function writeCodexLaunchProfile({ gatewayBaseUrl, subscriptionAuth }) {
@@ -223,7 +236,7 @@ export async function configurePennyHarness(harness, {
   config.api_key = apiKey;
   config.harnesses ||= {};
   if (harness === "claude-code") {
-    await writeClaudeUserCommand();
+    await writeClaudeUserSkill();
     await writeClaudeLaunchSettings();
     config.harnesses.claude = {
       enabled: true,
@@ -258,9 +271,10 @@ export async function removePennyHarness(harness) {
     await unlink(claudeLaunchSettingsPath()).catch((error) => {
       if (error.code !== "ENOENT") throw error;
     });
-    const command = await readText(claudeUserCommandPath(), "");
-    if (command.includes(CLAUDE_COMMAND_MARKER)) {
-      await unlink(claudeUserCommandPath()).catch((error) => {
+    for (const path of [claudeUserSkillPath(), legacyClaudeUserCommandPath()]) {
+      const command = await readText(path, "");
+      if (!command.includes(CLAUDE_COMMAND_MARKER)) continue;
+      await unlink(path).catch((error) => {
         if (error.code !== "ENOENT") throw error;
       });
     }

package/src/launch.test.js

@@ -6,7 +6,7 @@ import path from "node:path";
 import {
   buildPennyInvocation,
   claudeLaunchSettingsPath,
-  claudeUserCommandPath,
+  claudeUserSkillPath,
   codexLaunchProfilePath,
   configurePennyHarness,
   fileMode,
@@ -108,19 +108,20 @@ async function main() {
     assert.throws(() => buildPennyInvocation("claude", ["--settings=x"], config), /manages --settings/);
     assert.throws(() => buildPennyInvocation("codex", ["-p", "other"], config), /manages --profile/);
 
-    const command = fs.readFileSync(claudeUserCommandPath(), "utf8");
+    const command = fs.readFileSync(claudeUserSkillPath(), "utf8");
     assert.ok(command.includes("@penny $ARGUMENTS"));
+    assert.ok(command.includes("name: penny"));
 
     await removePennyHarness("claude-code");
-    assert.ok(!fs.existsSync(claudeUserCommandPath()));
-    fs.mkdirSync(path.dirname(claudeUserCommandPath()), { recursive: true });
-    fs.writeFileSync(claudeUserCommandPath(), "user-owned command\n");
+    assert.ok(!fs.existsSync(claudeUserSkillPath()));
+    fs.mkdirSync(path.dirname(claudeUserSkillPath()), { recursive: true });
+    fs.writeFileSync(claudeUserSkillPath(), "user-owned command\n");
     await assert.rejects(configurePennyHarness("claude-code", {
       apiKey: "pr-super-secret",
       gatewayBaseUrl: "https://gateway.example/",
       models: {},
     }), /not managed by PennyRouter/);
-    assert.equal(fs.readFileSync(claudeUserCommandPath(), "utf8"), "user-owned command\n");
+    assert.equal(fs.readFileSync(claudeUserSkillPath(), "utf8"), "user-owned command\n");
     assert.ok(fs.existsSync(codexLaunchProfilePath()));
     assert.ok(fs.existsSync(pennyShimPath()));
     await removePennyHarness("codex");