any-buddy 1.0.0 → 1.0.2

package/README.md

@@ -1,7 +1,12 @@
 # claude-code-any-buddy
-
 Pick any Claude Code companion pet you want.
 
+```bash
+npx any-buddy
+```
+
+That's it. Follow the prompts to choose your species, rarity, eyes, hat, and name.
+
 Claude Code assigns you a deterministic pet based on your account ID — you can't change it through normal means. This tool lets you choose your own species, rarity, eyes, and hat, then patches the Claude Code binary to make it happen.
 
 <p align="center">
@@ -23,10 +28,19 @@ The patch is safe — it uses `rename()` to atomically swap the binary, which is
 
 ## Requirements
 
-- **Linux only** — the tool patches a compiled ELF binary at `~/.local/share/claude/versions/`. macOS and Windows use different binary formats and installation paths
 - **Node.js >= 18** — for the CLI and TUI
 - **Bun** — required for hash computation (Claude Code uses `Bun.hash`/wyhash internally; FNV-1a produces different results). Bun is typically already installed if you have Claude Code
-- **Claude Code** — must be installed via the standard method (binary at `~/.local/bin/claude`)
+- **Claude Code** — installed via any standard method
+
+### Platform support
+
+| Platform | Status | Binary location (auto-detected) |
+|---|---|---|
+| Linux | Tested | `~/.local/share/claude/versions/<ver>` |
+| macOS | Should work | `~/.local/bin/claude`, `/opt/homebrew/bin/claude`, `~/.claude/local/claude` |
+| Windows | Should work | `%LOCALAPPDATA%\Programs\claude\claude.exe`, npm global shim |
+
+The binary is found automatically via `which`/`where` and platform-specific known paths. If auto-detection fails, set `CLAUDE_BINARY=/path/to/binary` manually.
 
 ## Install
 
@@ -36,7 +50,7 @@ The interactive flow also lets you **rename** your companion — it edits `~/.cl
 
 ```bash
 # Clone and install
-git clone https://github.com/youruser/claude-code-any-buddy.git
+git clone https://github.com/cpaczek/any-buddy.git
 cd claude-code-any-buddy
 pnpm install
 
@@ -85,6 +99,7 @@ claude-code-any-buddy --species dragon --rarity legendary --eye '✦' --hat wiza
 | `--hat <name>` | `-t` | Pre-select hat |
 | `--name <name>` | `-n` | Rename your companion |
 | `--yes` | `-y` | Skip all confirmation prompts |
+| `--shiny` | | Require shiny variant (~100x longer search) |
 | `--no-hook` | | Don't offer to install the auto-patch hook |
 | `--silent` | | Suppress output (for `apply` in hooks) |
 
@@ -170,7 +185,7 @@ Each pet has 5 stats: **DEBUGGING**, **PATIENCE**, **CHAOS**, **WISDOM**, **SNAR
 
 ### Shiny
 
-1% chance per seed. The brute-force search ignores shiny by default, but you could modify the finder to require it (at the cost of ~100x longer search time).
+1% chance per seed. The interactive flow asks if you want shiny, or pass `--shiny` on the command line. Requiring shiny takes ~100x longer to find a matching salt (seconds instead of milliseconds) since only 1 in 100 seeds produce a shiny pet.
 
 ## How the auto-patch hook works
 
@@ -234,7 +249,7 @@ This patches the salt back to the original, removes the SessionStart hook, and c
 
 ## Limitations
 
-- **Linux only** — different binary format on macOS/Windows
+- **Tested on Linux** — macOS and Windows should work but are not yet tested. Please [open an issue](https://github.com/cpaczek/any-buddy/issues) if you hit problems
 - **Requires Bun** — needed for matching Claude Code's wyhash implementation
 - **Salt string dependent** — if Anthropic changes the salt from `friend-2026-401` in a future version, the patch logic would need updating (but the tool will detect this and warn you)
 - **Stats not selectable** — you pick species/rarity/eyes/hat; stats are whatever the matching salt produces

package/bin/cli.mjs

@@ -14,6 +14,7 @@ function parseArgs(argv) {
     else if (arg === '--eye' || arg === '-e') { flags.eye = args[++i]; }
     else if (arg === '--hat' || arg === '-t') { flags.hat = args[++i]; }
     else if (arg === '--name' || arg === '-n') { flags.name = args[++i]; }
+    else if (arg === '--shiny') { flags.shiny = true; }
     else if (arg === '--silent') { flags.silent = true; }
     else if (arg === '--no-hook') { flags.noHook = true; }
     else if (arg === '--yes' || arg === '-y') { flags.yes = true; }
@@ -51,7 +52,13 @@ try {
   if (err.name === 'ExitPromptError') {
     process.exit(0);
   }
-  console.error(err.message);
+  console.error(`\n  Error: ${err.message}`);
+  // If the error message doesn't already include the issue URL, add it
+  if (!err.message.includes('github.com/cpaczek/any-buddy')) {
+    console.error(`\n  If this seems like a bug, please report it at:`);
+    console.error(`  https://github.com/cpaczek/any-buddy/issues`);
+    console.error(`\n  Include your OS (${process.platform}), Node ${process.version}, and the error above.`);
+  }
   process.exit(1);
 }
 
@@ -78,6 +85,7 @@ Options:
   -t, --hat <name>       Hat (none, crown, tophat, propeller, halo, wizard,
                          beanie, tinyduck)
   -n, --name <name>      Rename your companion
+  --shiny                Require shiny (~100x longer search)
   -y, --yes              Skip confirmation prompts
   --no-hook              Don't offer to install the SessionStart hook
   --silent               Suppress output (for apply command in hooks)

package/lib/finder-worker.mjs

@@ -47,7 +47,8 @@ function quickRoll(userId, salt) {
   const species = pick(rng, SPECIES);
   const eye = pick(rng, EYES);
   const hat = rarity === 'common' ? 'none' : pick(rng, HATS);
-  return { rarity, species, eye, hat };
+  const shiny = rng() < 0.01;
+  return { rarity, species, eye, hat, shiny };
 }
 
 const SALT_LEN = 15;
@@ -61,13 +62,15 @@ function randomSalt() {
   return s;
 }
 
-const [userId, wantSpecies, wantRarity, wantEye, wantHat] = process.argv.slice(2);
+const [userId, wantSpecies, wantRarity, wantEye, wantHat, wantShiny] = process.argv.slice(2);
 
 if (!userId || !wantSpecies || !wantRarity || !wantEye || !wantHat) {
-  console.error('Usage: finder-worker.mjs <userId> <species> <rarity> <eye> <hat>');
+  console.error('Usage: finder-worker.mjs <userId> <species> <rarity> <eye> <hat> [shiny]');
   process.exit(1);
 }
 
+const requireShiny = wantShiny === 'true';
+
 const start = Date.now();
 let attempts = 0;
 
@@ -80,7 +83,8 @@ while (true) {
     bones.species === wantSpecies &&
     bones.rarity === wantRarity &&
     bones.eye === wantEye &&
-    bones.hat === wantHat
+    bones.hat === wantHat &&
+    (!requireShiny || bones.shiny)
   ) {
     console.log(JSON.stringify({
       salt,

package/lib/finder.mjs

@@ -15,6 +15,7 @@ export function findSalt(userId, desired) {
     desired.rarity,
     desired.eye,
     desired.hat,
+    String(desired.shiny ?? false),
   ], {
     encoding: 'utf-8',
     timeout: 120000, // 2 minute timeout

package/lib/patcher.mjs

@@ -1,54 +1,134 @@
 import { readFileSync, writeFileSync, copyFileSync, statSync, chmodSync, realpathSync, unlinkSync, renameSync } from 'fs';
 import { existsSync } from 'fs';
 import { execSync } from 'child_process';
-import { join, basename } from 'path';
-import { homedir } from 'os';
+import { join, basename, dirname } from 'path';
+import { homedir, platform } from 'os';
 import { ORIGINAL_SALT } from './constants.mjs';
 
-// Resolve the actual Claude Code binary path dynamically
+const IS_WIN = platform() === 'win32';
+const IS_MAC = platform() === 'darwin';
+const IS_LINUX = platform() === 'linux';
+
+// Cross-platform `which` — returns the resolved path or null
+function which(cmd) {
+  try {
+    const shellCmd = IS_WIN ? `where ${cmd}` : `which ${cmd}`;
+    const result = execSync(shellCmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    // `where` on Windows may return multiple lines; take the first
+    const first = result.split(/\r?\n/)[0].trim();
+    if (first && existsSync(first)) return first;
+  } catch { /* ignore */ }
+  return null;
+}
+
+// Resolve symlinks safely
+function realpath(p) {
+  try { return realpathSync(p); } catch { return p; }
+}
+
+// Resolve the actual Claude Code binary/bundle path.
+// Works on Linux (ELF binary), macOS (Mach-O or app bundle), and Windows (.exe or .cmd shim).
 export function findClaudeBinary() {
-  // 1. Check if user specified a path via env var
+  // 1. User-specified override
   if (process.env.CLAUDE_BINARY) {
     const p = process.env.CLAUDE_BINARY;
-    if (existsSync(p)) return realpathSync(p);
+    if (existsSync(p)) return realpath(p);
     throw new Error(`CLAUDE_BINARY="${p}" does not exist.`);
   }
 
-  // 2. Try `which claude` to find it on PATH (works for any install method)
-  try {
-    const which = execSync('which claude 2>/dev/null', { encoding: 'utf-8' }).trim();
-    if (which && existsSync(which)) {
-      return realpathSync(which);
+  // 2. Try finding `claude` on PATH
+  const onPath = which('claude');
+  if (onPath) {
+    const resolved = realpath(onPath);
+
+    // On Windows, `where claude` might return a .cmd shim from npm.
+    // We need the actual binary it points to.
+    if (IS_WIN && resolved.endsWith('.cmd')) {
+      const target = resolveWindowsShim(resolved);
+      if (target) return target;
     }
-  } catch { /* ignore */ }
 
-  // 3. Common known locations as fallback
-  const candidates = [
-    join(homedir(), '.local', 'bin', 'claude'),
-    '/usr/local/bin/claude',
-    '/usr/bin/claude',
-    join(homedir(), '.npm-global', 'bin', 'claude'),
-    join(homedir(), '.volta', 'bin', 'claude'),
-  ];
+    // On macOS/Linux, the symlink may point to a versions directory
+    return resolved;
+  }
+
+  // 3. Platform-specific known locations
+  const candidates = getPlatformCandidates();
 
   for (const candidate of candidates) {
     if (existsSync(candidate)) {
-      try {
-        return realpathSync(candidate);
-      } catch {
-        return candidate;
-      }
+      return realpath(candidate);
     }
   }
 
+  const platformHint = IS_WIN
+    ? 'On Windows, Claude Code is typically installed via npm or the desktop app.'
+    : IS_MAC
+      ? 'On macOS, Claude Code is typically at ~/.claude/local/ or installed via npm/brew.'
+      : 'On Linux, Claude Code is typically at ~/.local/share/claude/versions/.';
+
   throw new Error(
     'Could not find Claude Code binary.\n' +
-    '  Tried `which claude` and these paths:\n' +
+    `  Platform: ${platform()}\n` +
+    '  Tried `' + (IS_WIN ? 'where' : 'which') + ' claude` and these paths:\n' +
     candidates.map(c => `    - ${c}`).join('\n') +
-    '\n\n  Set CLAUDE_BINARY=/path/to/claude to specify manually.'
+    '\n\n  ' + platformHint +
+    '\n  Set CLAUDE_BINARY=/path/to/binary to specify manually.' +
+    '\n\n  If this is a bug, please report it at:' +
+    '\n  https://github.com/cpaczek/any-buddy/issues'
   );
 }
 
+function getPlatformCandidates() {
+  const home = homedir();
+
+  if (IS_WIN) {
+    const appData = process.env.APPDATA || join(home, 'AppData', 'Roaming');
+    const localAppData = process.env.LOCALAPPDATA || join(home, 'AppData', 'Local');
+    return [
+      join(localAppData, 'Programs', 'claude', 'claude.exe'),
+      join(appData, 'npm', 'claude.cmd'),
+      join(appData, 'npm', 'node_modules', '@anthropic-ai', 'claude-code', 'cli.mjs'),
+      join(home, '.volta', 'bin', 'claude.exe'),
+    ];
+  }
+
+  if (IS_MAC) {
+    return [
+      join(home, '.local', 'bin', 'claude'),
+      join(home, '.claude', 'local', 'claude'),
+      '/usr/local/bin/claude',
+      '/opt/homebrew/bin/claude',
+      join(home, '.npm-global', 'bin', 'claude'),
+      join(home, '.volta', 'bin', 'claude'),
+    ];
+  }
+
+  // Linux
+  return [
+    join(home, '.local', 'bin', 'claude'),
+    '/usr/local/bin/claude',
+    '/usr/bin/claude',
+    join(home, '.npm-global', 'bin', 'claude'),
+    join(home, '.volta', 'bin', 'claude'),
+  ];
+}
+
+// On Windows, npm installs a .cmd shim. Parse it to find the actual JS entry or binary.
+function resolveWindowsShim(cmdPath) {
+  try {
+    const content = readFileSync(cmdPath, 'utf-8');
+    // npm shims contain a line like: "%~dp0\node_modules\@anthropic-ai\claude-code\cli.mjs"
+    const match = content.match(/node_modules[\\/]@anthropic-ai[\\/]claude-code[\\/][^\s"]+/);
+    if (match) {
+      const shimDir = dirname(cmdPath);
+      const target = join(shimDir, match[0]);
+      if (existsSync(target)) return target;
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
 // Find all byte offsets of a string in a buffer
 function findAllOccurrences(buffer, searchStr) {
   const searchBuf = Buffer.from(searchStr, 'utf-8');
@@ -67,7 +147,7 @@ function findAllOccurrences(buffer, searchStr) {
 export function getCurrentSalt(binaryPath) {
   const buf = readFileSync(binaryPath);
   const origOffsets = findAllOccurrences(buf, ORIGINAL_SALT);
-  if (origOffsets.length === 3) {
+  if (origOffsets.length >= 3) {
     return { salt: ORIGINAL_SALT, patched: false, offsets: origOffsets };
   }
   return { salt: null, patched: true, offsets: origOffsets };
@@ -80,9 +160,13 @@ export function verifySalt(binaryPath, salt) {
   return { found: offsets.length, offsets };
 }
 
-// Check if the Claude binary is currently running
+// Check if Claude is currently running (best-effort, non-fatal)
 export function isClaudeRunning(binaryPath) {
   try {
+    if (IS_WIN) {
+      const out = execSync('tasklist /FI "IMAGENAME eq claude.exe" /NH 2>nul', { encoding: 'utf-8' });
+      return out.includes('claude.exe');
+    }
     const name = basename(binaryPath);
     const out = execSync(`pgrep -f "${name}" 2>/dev/null || true`, { encoding: 'utf-8' });
     return out.trim().length > 0;
@@ -92,7 +176,6 @@ export function isClaudeRunning(binaryPath) {
 }
 
 // Patch the binary: replace oldSalt with newSalt at all occurrences.
-// Uses copy-patch-rename to handle ETXTBSY (binary currently running).
 export function patchBinary(binaryPath, oldSalt, newSalt) {
   if (oldSalt.length !== newSalt.length) {
     throw new Error(
@@ -105,11 +188,14 @@ export function patchBinary(binaryPath, oldSalt, newSalt) {
 
   if (offsets.length === 0) {
     throw new Error(
-      `Could not find salt "${oldSalt}" in binary. The binary may already be patched with a different salt, or Claude Code was updated.`
+      `Could not find salt "${oldSalt}" in binary at ${binaryPath}.\n` +
+      '  The binary may already be patched with a different salt, or Claude Code has changed.\n\n' +
+      '  If you think this is a bug, please report it at:\n' +
+      '  https://github.com/cpaczek/any-buddy/issues'
     );
   }
 
-  // Create backup (read from original since it's still readable)
+  // Create backup
   const backupPath = binaryPath + '.anybuddy-bak';
   if (!existsSync(backupPath)) {
     copyFileSync(binaryPath, backupPath);
@@ -121,24 +207,36 @@ export function patchBinary(binaryPath, oldSalt, newSalt) {
     newBuf.copy(buf, offset);
   }
 
-  // Write to a temp file then rename (avoids ETXTBSY on running binary).
-  // On Linux, renaming over a running binary is allowed — the old inode
-  // stays open for the running process, and the new file takes the path.
+  // Write strategy depends on platform.
+  // Linux/macOS: write to temp then atomic rename (handles ETXTBSY).
+  // Windows: can't rename over a running exe, so try direct write first.
   const stats = statSync(binaryPath);
   const tmpPath = binaryPath + '.anybuddy-tmp';
-  writeFileSync(tmpPath, buf);
-  chmodSync(tmpPath, stats.mode);
 
-  // Rename: unlink old (may fail if busy, so rename new on top)
   try {
-    renameSync(tmpPath, binaryPath);
-  } catch {
-    // If rename fails, try unlink + rename
-    try { unlinkSync(binaryPath); } catch { /* ignore */ }
-    renameSync(tmpPath, binaryPath);
+    writeFileSync(tmpPath, buf);
+    if (!IS_WIN) chmodSync(tmpPath, stats.mode);
+
+    try {
+      renameSync(tmpPath, binaryPath);
+    } catch {
+      try { unlinkSync(binaryPath); } catch { /* ignore */ }
+      renameSync(tmpPath, binaryPath);
+    }
+  } catch (err) {
+    // Clean up temp file on failure
+    try { unlinkSync(tmpPath); } catch { /* ignore */ }
+
+    if (IS_WIN && err.code === 'EPERM') {
+      throw new Error(
+        'Cannot patch: the binary is locked (Claude Code may be running).\n' +
+        '  Close all Claude Code windows and try again.'
+      );
+    }
+    throw err;
   }
 
-  // Verify from the newly written file
+  // Verify
   const verifyBuf = readFileSync(binaryPath);
   const verify = findAllOccurrences(verifyBuf, newSalt);
   return {
@@ -152,17 +250,35 @@ export function patchBinary(binaryPath, oldSalt, newSalt) {
 export function restoreBinary(binaryPath) {
   const backupPath = binaryPath + '.anybuddy-bak';
   if (!existsSync(backupPath)) {
-    throw new Error('No backup found. Cannot restore.');
+    throw new Error(
+      'No backup found. Cannot restore.\n' +
+      `  Expected: ${backupPath}`
+    );
   }
+
   const stats = statSync(backupPath);
   const tmpPath = binaryPath + '.anybuddy-tmp';
-  copyFileSync(backupPath, tmpPath);
-  chmodSync(tmpPath, stats.mode);
+
   try {
-    renameSync(tmpPath, binaryPath);
-  } catch {
-    try { unlinkSync(binaryPath); } catch { /* ignore */ }
-    renameSync(tmpPath, binaryPath);
+    copyFileSync(backupPath, tmpPath);
+    if (!IS_WIN) chmodSync(tmpPath, stats.mode);
+
+    try {
+      renameSync(tmpPath, binaryPath);
+    } catch {
+      try { unlinkSync(binaryPath); } catch { /* ignore */ }
+      renameSync(tmpPath, binaryPath);
+    }
+  } catch (err) {
+    try { unlinkSync(tmpPath); } catch { /* ignore */ }
+    if (IS_WIN && err.code === 'EPERM') {
+      throw new Error(
+        'Cannot restore: the binary is locked (Claude Code may be running).\n' +
+        '  Close all Claude Code windows and try again.'
+      );
+    }
+    throw err;
   }
+
   return true;
 }

package/lib/tui.mjs

@@ -74,7 +74,8 @@ export async function runPreview(flags = {}) {
   const hat = rarity === 'common' ? 'none'
     : validateFlag('hat', flags.hat, HATS) ?? await selectHat(species, eye, rarity);
 
-  const bones = { species, eye, hat, rarity, shiny: false, stats: {} };
+  const shiny = flags.shiny ?? false;
+  const bones = { species, eye, hat, rarity, shiny, stats: {} };
   showPet(bones, 'Preview');
   console.log(chalk.dim('  (Preview only - no changes made)\n'));
 }
@@ -203,10 +204,14 @@ export async function runInteractive(flags = {}) {
   const rarity = validateFlag('rarity', flags.rarity, RARITIES) ?? await selectRarity();
   const hat = rarity === 'common' ? 'none'
     : validateFlag('hat', flags.hat, HATS) ?? await selectHat(species, eye, rarity);
+  const shiny = flags.shiny ?? await confirm({
+    message: 'Shiny? (1% normally — search takes ~100x longer)',
+    default: false,
+  });
 
   // Final preview
-  const desired = { species, eye, hat, rarity };
-  const previewBones = { ...desired, shiny: false, stats: {} };
+  const desired = { species, eye, hat, rarity, shiny };
+  const previewBones = { ...desired, stats: {} };
   showPet(previewBones, 'Your selection');
 
   const proceed = flags.yes || await confirm({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "any-buddy",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Pick any Claude Code companion pet you want",
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/youruser/claude-code-any-buddy"
+    "url": "https://github.com/cpaczek/any-buddy"
   },
   "keywords": [
     "claude",