any-buddy 1.0.0

package/bin/cli.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+import { runInteractive, runPreview, runCurrent, runApply, runRestore } from '../lib/tui.mjs';
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const flags = {};
+  const positional = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--species' || arg === '-s') { flags.species = args[++i]; }
+    else if (arg === '--rarity' || arg === '-r') { flags.rarity = args[++i]; }
+    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 === '--silent') { flags.silent = true; }
+    else if (arg === '--no-hook') { flags.noHook = true; }
+    else if (arg === '--yes' || arg === '-y') { flags.yes = true; }
+    else if (!arg.startsWith('-')) { positional.push(arg); }
+  }
+
+  return { command: positional[0], flags };
+}
+
+const { command, flags } = parseArgs(process.argv);
+
+try {
+  switch (command) {
+    case 'apply':
+      await runApply({ silent: flags.silent });
+      break;
+    case 'preview':
+      await runPreview(flags);
+      break;
+    case 'current':
+      await runCurrent();
+      break;
+    case 'restore':
+      await runRestore();
+      break;
+    case 'help':
+      printHelp();
+      break;
+    default:
+      if (command === '--help' || command === '-h') { printHelp(); break; }
+      await runInteractive(flags);
+      break;
+  }
+} catch (err) {
+  if (err.name === 'ExitPromptError') {
+    process.exit(0);
+  }
+  console.error(err.message);
+  process.exit(1);
+}
+
+function printHelp() {
+  console.log(`
+claude-code-any-buddy — Pick any Claude Code companion pet
+
+Usage:
+  claude-code-any-buddy                          Interactive pet picker
+  claude-code-any-buddy --species dragon         Skip species prompt
+  claude-code-any-buddy -s cat -r legendary -e ✦ -t wizard -y
+                                                 Fully non-interactive
+  claude-code-any-buddy preview                  Browse pets without applying
+  claude-code-any-buddy current                  Show your current pet
+  claude-code-any-buddy apply [--silent]         Re-apply saved pet after update
+  claude-code-any-buddy restore                  Restore original pet
+
+Options:
+  -s, --species <name>   Species (duck, goose, blob, cat, dragon, octopus, owl,
+                         penguin, turtle, snail, ghost, axolotl, capybara,
+                         cactus, robot, rabbit, mushroom, chonk)
+  -r, --rarity <level>   Rarity (common, uncommon, rare, epic, legendary)
+  -e, --eye <char>       Eye style (· ✦ × ◉ @ °)
+  -t, --hat <name>       Hat (none, crown, tophat, propeller, halo, wizard,
+                         beanie, tinyduck)
+  -n, --name <name>      Rename your companion
+  -y, --yes              Skip confirmation prompts
+  --no-hook              Don't offer to install the SessionStart hook
+  --silent               Suppress output (for apply command in hooks)
+
+Environment:
+  CLAUDE_BINARY          Path to Claude Code binary (auto-detected by default)
+`);
+}

package/lib/config.mjs

@@ -0,0 +1,132 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const OUR_CONFIG = join(homedir(), '.claude-code-any-buddy.json');
+
+// Read the user's Claude userId from ~/.claude.json
+export function getClaudeUserId() {
+  const paths = [
+    join(homedir(), '.claude.json'),
+    join(homedir(), '.claude', '.config.json'),
+  ];
+
+  for (const p of paths) {
+    if (existsSync(p)) {
+      try {
+        const config = JSON.parse(readFileSync(p, 'utf-8'));
+        return config.oauthAccount?.accountUuid ?? config.userID ?? 'anon';
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return 'anon';
+}
+
+// Save our pet config
+export function savePetConfig(data) {
+  writeFileSync(OUR_CONFIG, JSON.stringify(data, null, 2) + '\n');
+}
+
+// Load our pet config
+export function loadPetConfig() {
+  if (!existsSync(OUR_CONFIG)) return null;
+  try {
+    return JSON.parse(readFileSync(OUR_CONFIG, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+// Get the path to ~/.claude.json
+function getClaudeConfigPath() {
+  const paths = [
+    join(homedir(), '.claude.json'),
+    join(homedir(), '.claude', '.config.json'),
+  ];
+  for (const p of paths) {
+    if (existsSync(p)) return p;
+  }
+  return paths[0]; // default
+}
+
+// Read the companion's current name from ~/.claude.json
+export function getCompanionName() {
+  const configPath = getClaudeConfigPath();
+  if (!existsSync(configPath)) return null;
+  try {
+    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+    return config.companion?.name ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// Rename the companion in ~/.claude.json
+export function renameCompanion(newName) {
+  const configPath = getClaudeConfigPath();
+  if (!existsSync(configPath)) {
+    throw new Error(`Claude config not found at ${configPath}`);
+  }
+  const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+  if (!config.companion) {
+    throw new Error('No companion found in config. Run /buddy in Claude Code first to hatch one.');
+  }
+  config.companion.name = newName;
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+}
+
+// Read or write Claude Code's settings.json for hooks
+const SETTINGS_PATH = join(homedir(), '.claude', 'settings.json');
+
+export function getClaudeSettings() {
+  if (!existsSync(SETTINGS_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(SETTINGS_PATH, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+export function saveClaudeSettings(settings) {
+  const dir = join(homedir(), '.claude');
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + '\n');
+}
+
+const HOOK_COMMAND = 'claude-code-any-buddy apply --silent';
+
+export function isHookInstalled() {
+  const settings = getClaudeSettings();
+  const hooks = settings.hooks?.SessionStart;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some(h => h.command === HOOK_COMMAND);
+}
+
+export function installHook() {
+  const settings = getClaudeSettings();
+  if (!settings.hooks) settings.hooks = {};
+  if (!Array.isArray(settings.hooks.SessionStart)) settings.hooks.SessionStart = [];
+
+  if (!settings.hooks.SessionStart.some(h => h.command === HOOK_COMMAND)) {
+    settings.hooks.SessionStart.push({
+      type: 'command',
+      command: HOOK_COMMAND,
+    });
+  }
+
+  saveClaudeSettings(settings);
+}
+
+export function removeHook() {
+  const settings = getClaudeSettings();
+  if (!settings.hooks?.SessionStart) return;
+  settings.hooks.SessionStart = settings.hooks.SessionStart.filter(
+    h => h.command !== HOOK_COMMAND
+  );
+  if (settings.hooks.SessionStart.length === 0) delete settings.hooks.SessionStart;
+  if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+  saveClaudeSettings(settings);
+}

package/lib/constants.mjs

@@ -0,0 +1,41 @@
+export const ORIGINAL_SALT = 'friend-2026-401';
+
+export const RARITIES = ['common', 'uncommon', 'rare', 'epic', 'legendary'];
+
+export const RARITY_WEIGHTS = {
+  common: 60,
+  uncommon: 25,
+  rare: 10,
+  epic: 4,
+  legendary: 1,
+};
+
+export const RARITY_STARS = {
+  common: '★',
+  uncommon: '★★',
+  rare: '★★★',
+  epic: '★★★★',
+  legendary: '★★★★★',
+};
+
+export const SPECIES = [
+  'duck', 'goose', 'blob', 'cat', 'dragon', 'octopus', 'owl', 'penguin',
+  'turtle', 'snail', 'ghost', 'axolotl', 'capybara', 'cactus', 'robot',
+  'rabbit', 'mushroom', 'chonk',
+];
+
+export const EYES = ['·', '✦', '×', '◉', '@', '°'];
+
+export const HATS = [
+  'none', 'crown', 'tophat', 'propeller', 'halo', 'wizard', 'beanie', 'tinyduck',
+];
+
+export const STAT_NAMES = ['DEBUGGING', 'PATIENCE', 'CHAOS', 'WISDOM', 'SNARK'];
+
+export const RARITY_FLOOR = {
+  common: 5,
+  uncommon: 15,
+  rare: 25,
+  epic: 35,
+  legendary: 50,
+};

package/lib/finder-worker.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env bun
+// This script runs under Bun for fast native Bun.hash access.
+// Called by finder.mjs as a subprocess.
+// Args: <userId> <species> <rarity> <eye> <hat>
+// Outputs JSON: { salt, attempts, elapsed }
+
+const RARITIES = ['common', 'uncommon', 'rare', 'epic', 'legendary'];
+const RARITY_WEIGHTS = { common: 60, uncommon: 25, rare: 10, epic: 4, legendary: 1 };
+const SPECIES = [
+  'duck', 'goose', 'blob', 'cat', 'dragon', 'octopus', 'owl', 'penguin',
+  'turtle', 'snail', 'ghost', 'axolotl', 'capybara', 'cactus', 'robot',
+  'rabbit', 'mushroom', 'chonk',
+];
+const EYES = ['·', '✦', '×', '◉', '@', '°'];
+const HATS = ['none', 'crown', 'tophat', 'propeller', 'halo', 'wizard', 'beanie', 'tinyduck'];
+
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return function () {
+    a |= 0;
+    a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+function pick(rng, arr) {
+  return arr[Math.floor(rng() * arr.length)];
+}
+
+function rollRarity(rng) {
+  const total = 100;
+  let roll = rng() * total;
+  for (const rarity of RARITIES) {
+    roll -= RARITY_WEIGHTS[rarity];
+    if (roll < 0) return rarity;
+  }
+  return 'common';
+}
+
+function quickRoll(userId, salt) {
+  const key = userId + salt;
+  const seed = Number(BigInt(Bun.hash(key)) & 0xffffffffn);
+  const rng = mulberry32(seed);
+  const rarity = rollRarity(rng);
+  const species = pick(rng, SPECIES);
+  const eye = pick(rng, EYES);
+  const hat = rarity === 'common' ? 'none' : pick(rng, HATS);
+  return { rarity, species, eye, hat };
+}
+
+const SALT_LEN = 15;
+const CHARSET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_';
+
+function randomSalt() {
+  let s = '';
+  for (let i = 0; i < SALT_LEN; i++) {
+    s += CHARSET[(Math.random() * CHARSET.length) | 0];
+  }
+  return s;
+}
+
+const [userId, wantSpecies, wantRarity, wantEye, wantHat] = process.argv.slice(2);
+
+if (!userId || !wantSpecies || !wantRarity || !wantEye || !wantHat) {
+  console.error('Usage: finder-worker.mjs <userId> <species> <rarity> <eye> <hat>');
+  process.exit(1);
+}
+
+const start = Date.now();
+let attempts = 0;
+
+while (true) {
+  attempts++;
+  const salt = randomSalt();
+  const bones = quickRoll(userId, salt);
+
+  if (
+    bones.species === wantSpecies &&
+    bones.rarity === wantRarity &&
+    bones.eye === wantEye &&
+    bones.hat === wantHat
+  ) {
+    console.log(JSON.stringify({
+      salt,
+      attempts,
+      elapsed: Date.now() - start,
+    }));
+    process.exit(0);
+  }
+
+  if (attempts % 500000 === 0) {
+    process.stderr.write(`${(attempts / 1000).toFixed(0)}k seeds tried...\n`);
+  }
+}

package/lib/finder.mjs

@@ -0,0 +1,25 @@
+import { execFileSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const WORKER_PATH = join(__dirname, 'finder-worker.mjs');
+
+// Spawns a Bun subprocess that brute-forces salts using native Bun.hash.
+// Returns { salt, attempts, elapsed }.
+export function findSalt(userId, desired) {
+  const result = execFileSync('bun', [
+    WORKER_PATH,
+    userId,
+    desired.species,
+    desired.rarity,
+    desired.eye,
+    desired.hat,
+  ], {
+    encoding: 'utf-8',
+    timeout: 120000, // 2 minute timeout
+    stdio: ['pipe', 'pipe', 'inherit'], // stderr passes through for progress
+  });
+
+  return JSON.parse(result.trim());
+}

package/lib/generation.mjs

@@ -0,0 +1,96 @@
+import { execFileSync } from 'child_process';
+import {
+  RARITIES, RARITY_WEIGHTS, RARITY_FLOOR, SPECIES, EYES, HATS, STAT_NAMES,
+} from './constants.mjs';
+
+// Bun.hash (wyhash) — spawns bun to get the exact same hash Claude Code uses.
+// String passed via stdin since bun -e doesn't forward argv.
+// Cached to avoid repeated subprocess calls for the same input.
+const hashCache = new Map();
+
+export function hashString(s) {
+  if (hashCache.has(s)) return hashCache.get(s);
+  try {
+    const result = execFileSync('bun', ['-e',
+      'const s=await Bun.stdin.text();process.stdout.write(String(Number(BigInt(Bun.hash(s))&0xffffffffn)))',
+    ], { encoding: 'utf-8', input: s, timeout: 5000 });
+    const h = parseInt(result.trim(), 10);
+    hashCache.set(s, h);
+    return h;
+  } catch {
+    // Fallback to FNV-1a if bun isn't available (won't match Claude Code but works for testing)
+    let h = 2166136261;
+    for (let i = 0; i < s.length; i++) {
+      h ^= s.charCodeAt(i);
+      h = Math.imul(h, 16777619);
+    }
+    const result = h >>> 0;
+    hashCache.set(s, result);
+    return result;
+  }
+}
+
+// Mulberry32 seeded PRNG — matches buddy/companion.ts exactly
+export function mulberry32(seed) {
+  let a = seed >>> 0;
+  return function () {
+    a |= 0;
+    a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+function pick(rng, arr) {
+  return arr[Math.floor(rng() * arr.length)];
+}
+
+function rollRarity(rng) {
+  const total = Object.values(RARITY_WEIGHTS).reduce((a, b) => a + b, 0);
+  let roll = rng() * total;
+  for (const rarity of RARITIES) {
+    roll -= RARITY_WEIGHTS[rarity];
+    if (roll < 0) return rarity;
+  }
+  return 'common';
+}
+
+function rollStats(rng, rarity) {
+  const floor = RARITY_FLOOR[rarity];
+  const peak = pick(rng, STAT_NAMES);
+  let dump = pick(rng, STAT_NAMES);
+  while (dump === peak) dump = pick(rng, STAT_NAMES);
+
+  const stats = {};
+  for (const name of STAT_NAMES) {
+    if (name === peak) {
+      stats[name] = Math.min(100, floor + 50 + Math.floor(rng() * 30));
+    } else if (name === dump) {
+      stats[name] = Math.max(1, floor - 10 + Math.floor(rng() * 15));
+    } else {
+      stats[name] = floor + Math.floor(rng() * 40);
+    }
+  }
+  return stats;
+}
+
+export function rollFrom(rng) {
+  const rarity = rollRarity(rng);
+  const bones = {
+    rarity,
+    species: pick(rng, SPECIES),
+    eye: pick(rng, EYES),
+    hat: rarity === 'common' ? 'none' : pick(rng, HATS),
+    shiny: rng() < 0.01,
+    stats: rollStats(rng, rarity),
+  };
+  const inspirationSeed = Math.floor(rng() * 1e9);
+  return { bones, inspirationSeed };
+}
+
+// Roll with explicit salt param (unlike source which hardcodes it)
+export function roll(userId, salt) {
+  const key = userId + salt;
+  return rollFrom(mulberry32(hashString(key)));
+}

package/lib/patcher.mjs

@@ -0,0 +1,168 @@
+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 { ORIGINAL_SALT } from './constants.mjs';
+
+// Resolve the actual Claude Code binary path dynamically
+export function findClaudeBinary() {
+  // 1. Check if user specified a path via env var
+  if (process.env.CLAUDE_BINARY) {
+    const p = process.env.CLAUDE_BINARY;
+    if (existsSync(p)) return realpathSync(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);
+    }
+  } 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'),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      try {
+        return realpathSync(candidate);
+      } catch {
+        return candidate;
+      }
+    }
+  }
+
+  throw new Error(
+    'Could not find Claude Code binary.\n' +
+    '  Tried `which claude` and these paths:\n' +
+    candidates.map(c => `    - ${c}`).join('\n') +
+    '\n\n  Set CLAUDE_BINARY=/path/to/claude to specify manually.'
+  );
+}
+
+// Find all byte offsets of a string in a buffer
+function findAllOccurrences(buffer, searchStr) {
+  const searchBuf = Buffer.from(searchStr, 'utf-8');
+  const offsets = [];
+  let pos = 0;
+  while (pos < buffer.length) {
+    const idx = buffer.indexOf(searchBuf, pos);
+    if (idx === -1) break;
+    offsets.push(idx);
+    pos = idx + 1;
+  }
+  return offsets;
+}
+
+// Read the current salt from the binary (checks if patched or original)
+export function getCurrentSalt(binaryPath) {
+  const buf = readFileSync(binaryPath);
+  const origOffsets = findAllOccurrences(buf, ORIGINAL_SALT);
+  if (origOffsets.length === 3) {
+    return { salt: ORIGINAL_SALT, patched: false, offsets: origOffsets };
+  }
+  return { salt: null, patched: true, offsets: origOffsets };
+}
+
+// Check if a specific salt is present in the binary
+export function verifySalt(binaryPath, salt) {
+  const buf = readFileSync(binaryPath);
+  const offsets = findAllOccurrences(buf, salt);
+  return { found: offsets.length, offsets };
+}
+
+// Check if the Claude binary is currently running
+export function isClaudeRunning(binaryPath) {
+  try {
+    const name = basename(binaryPath);
+    const out = execSync(`pgrep -f "${name}" 2>/dev/null || true`, { encoding: 'utf-8' });
+    return out.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+// 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(
+      `Salt length mismatch: old=${oldSalt.length}, new=${newSalt.length}. Must be ${ORIGINAL_SALT.length} chars.`
+    );
+  }
+
+  const buf = readFileSync(binaryPath);
+  const offsets = findAllOccurrences(buf, oldSalt);
+
+  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.`
+    );
+  }
+
+  // Create backup (read from original since it's still readable)
+  const backupPath = binaryPath + '.anybuddy-bak';
+  if (!existsSync(backupPath)) {
+    copyFileSync(binaryPath, backupPath);
+  }
+
+  // Replace all occurrences in the buffer
+  const newBuf = Buffer.from(newSalt, 'utf-8');
+  for (const offset of offsets) {
+    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.
+  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);
+  }
+
+  // Verify from the newly written file
+  const verifyBuf = readFileSync(binaryPath);
+  const verify = findAllOccurrences(verifyBuf, newSalt);
+  return {
+    replacements: offsets.length,
+    verified: verify.length === offsets.length,
+    backupPath,
+  };
+}
+
+// Restore the binary from backup
+export function restoreBinary(binaryPath) {
+  const backupPath = binaryPath + '.anybuddy-bak';
+  if (!existsSync(backupPath)) {
+    throw new Error('No backup found. Cannot restore.');
+  }
+  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);
+  }
+  return true;
+}