buddy-reroll 0.3.2 → 0.3.4

package/index.js

@@ -40,8 +40,12 @@ if (!IS_BUN && !IS_APPLY_HOOK) {
 }
 
 function getUserId(configPath) {
-  const config = JSON.parse(readFileSync(configPath, "utf-8"));
-  return config.oauthAccount?.accountUuid ?? config.userID ?? "anon";
+  try {
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    return config.oauthAccount?.accountUuid ?? config.userID ?? "anon";
+  } catch {
+    return "anon";
+  }
 }
 
 // ── Binary patch ─────────────────────────────────────────────────────────
@@ -93,29 +97,24 @@ function patchBinary(binaryPath, oldSalt, newSalt) {
   if (count === 0) throw new Error(`Salt "${oldSalt}" not found in binary`);
 
   const isWin = platform() === "win32";
+  const tmpPath = binaryPath + ".tmp";
   const maxRetries = isWin ? 3 : 1;
+
   for (let attempt = 0; attempt < maxRetries; attempt++) {
     try {
-      const tmpPath = binaryPath + ".tmp";
       writeFileSync(tmpPath, data, { mode: originalMode });
-      try {
-        renameSync(tmpPath, binaryPath);
-      } catch {
-        if (existsSync(binaryPath + ".backup")) {
-          try { unlinkSync(binaryPath); } catch {}
-        }
-        renameSync(tmpPath, binaryPath);
-      }
-
-      chmodSync(binaryPath, originalMode);
 
-      const verify = readFileSync(binaryPath);
-      const found = verify.indexOf(Buffer.from(newSalt));
-      if (found === -1) throw new Error("Patch verification failed — new salt not found after write");
+      const verify = readFileSync(tmpPath);
+      if (verify.indexOf(Buffer.from(newSalt)) === -1) {
+        try { unlinkSync(tmpPath); } catch {}
+        throw new Error("Patch verification failed — new salt not found in temp file");
+      }
 
+      renameSync(tmpPath, binaryPath);
+      try { chmodSync(binaryPath, originalMode); } catch {}
       return count;
     } catch (err) {
-      try { unlinkSync(binaryPath + ".tmp"); } catch {}
+      try { unlinkSync(tmpPath); } catch {}
       if (isWin && (err.code === "EACCES" || err.code === "EPERM" || err.code === "EBUSY") && attempt < maxRetries - 1) {
         sleepMs(2000);
         continue;
@@ -123,7 +122,7 @@ function patchBinary(binaryPath, oldSalt, newSalt) {
       if (isWin && (err.code === "EPERM" || err.code === "EBUSY")) {
         throw new Error("Can't write — Claude Code might still be running. Close it and try again.");
       }
-      throw new Error(`Failed to write: ${err.message}`);
+      throw err;
     }
   }
 }
@@ -143,12 +142,18 @@ function resignBinary(binaryPath) {
 }
 
 function clearCompanion(configPath) {
-  const raw = readFileSync(configPath, "utf-8");
-  const config = JSON.parse(raw);
-  delete config.companion;
-  delete config.companionMuted;
-  const indent = raw.match(/^(\s+)"/m)?.[1] ?? "  ";
-  writeFileSync(configPath, JSON.stringify(config, null, indent) + "\n");
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    if (!config.companion && !config.companionMuted) return;
+    delete config.companion;
+    delete config.companionMuted;
+    const indent = raw.match(/^(\s+)"/m)?.[1] ?? "  ";
+    const mode = statSync(configPath).mode;
+    const tmpPath = configPath + ".tmp";
+    writeFileSync(tmpPath, JSON.stringify(config, null, indent) + "\n", { mode });
+    renameSync(tmpPath, configPath);
+  } catch {}
 }
 
 function fail(message) {
@@ -460,13 +465,13 @@ async function main() {
   }
 
   if (args["apply-hook"]) {
+    let mutated = false;
     try {
       const stored = readStoredSalt();
       if (!stored) process.exit(0);
       const bp = findBinaryPath();
       const cp = findConfigPath();
       if (!bp || !cp) process.exit(0);
-      const uid = getUserId(cp);
       const binaryData = readFileSync(bp);
       const currentSalt = findCurrentSalt(binaryData);
       if (!currentSalt) process.exit(0);
@@ -476,21 +481,41 @@ async function main() {
       const backupPath = patchability.backupPath;
       if (!existsSync(backupPath)) copyFileSync(bp, backupPath);
       patchBinary(bp, currentSalt, stored.salt);
+      mutated = true;
       if (platform() === "darwin") {
         try {
           execFileSync("codesign", ["-s", "-", "--force", bp], { stdio: "ignore", timeout: 30000 });
         } catch {
           copyFileSync(backupPath, bp);
+          try { chmodSync(bp, statSync(backupPath).mode); } catch {}
           process.exit(1);
         }
       }
       clearCompanion(cp);
-    } catch {}
+    } catch (err) {
+      process.stderr.write(`buddy-reroll --apply-hook failed: ${err.message}\n`);
+      process.exit(mutated ? 1 : 0);
+    }
     process.exit(0);
   }
 
   if (args.doctor) {
-    console.log(`\n${formatDoctorReport(getDoctorReport(), "buddy-reroll doctor")}\n`);
+    const report = getDoctorReport();
+    if (report.status === "not-executable" && report.binaryPath) {
+      try {
+        const { chmodSync, statSync } = await import("fs");
+        const mode = statSync(report.binaryPath).mode | 0o111;
+        chmodSync(report.binaryPath, mode);
+        console.log(`\n  ✓ Fixed: restored execute permission on ${report.binaryPath}`);
+        const fixed = getDoctorReport();
+        console.log(`\n${formatDoctorReport(fixed, "buddy-reroll doctor")}\n`);
+      } catch (err) {
+        console.log(`\n${formatDoctorReport(report, "buddy-reroll doctor")}\n`);
+        console.log(`  ⚠ Auto-fix failed: ${err.message}\n    Run manually: chmod +x "${report.binaryPath}"\n`);
+      }
+    } else {
+      console.log(`\n${formatDoctorReport(report, "buddy-reroll doctor")}\n`);
+    }
     return;
   }
 

package/lib/doctor.js

@@ -1,3 +1,4 @@
+import { accessSync, constants, chmodSync, statSync } from "fs";
 import { getClaudeBinaryOverride, getClaudeConfigDir, findBinaryPath, findConfigPath, getPatchability } from "./runtime.js";
 
 function buildStatus(binaryPath, configPath, patchability) {
@@ -5,6 +6,11 @@ function buildStatus(binaryPath, configPath, patchability) {
   if (!binaryPath) return "missing-binary";
   if (!configPath) return "missing-config";
   if (!patchability.ok) return "read-only";
+  try {
+    accessSync(binaryPath, constants.X_OK);
+  } catch {
+    return "not-executable";
+  }
   return "ready";
 }
 
@@ -18,6 +24,8 @@ function buildNextStep(status) {
       return "Open Claude Code once so it writes config, or point `CLAUDE_CONFIG_DIR` to the correct config directory.";
     case "read-only":
       return "Use a user-writable Claude install, or point `CLAUDE_BINARY_PATH` to a writable Claude binary copy; `--current` can still work with a read-only install.";
+    case "not-executable":
+      return "Claude binary lost its execute permission (likely from a patch). Run: chmod +x <binary-path>";
     default:
       return "`--current` and reroll commands are ready to run on this machine.";
   }

package/lib/finder.js

@@ -7,7 +7,7 @@ import { rollFrom } from "./companion.js";
 
 const WORKER_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), "..", "scripts", "worker.js");
 
-export async function parallelBruteForce(userId, target, onProgress) {
+export async function parallelBruteForce(userId, target, onProgress, signal) {
   const numWorkers = Math.max(1, Math.min(cpus().length, 8));
   const expected = estimateAttempts(target);
 
@@ -18,13 +18,25 @@ export async function parallelBruteForce(userId, target, onProgress) {
     const workerAttempts = [];
     let resolved = false;
     let exited = 0;
+    let timer;
+
+    function finish(fn, val) {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timer);
+      killAll();
+      fn(val);
+    }
 
     function killAll() {
       for (const child of children) {
-        try { child.kill(); } catch {}
+        try { child.kill("SIGKILL"); } catch {}
       }
     }
 
+    if (signal?.aborted) { reject(new Error("Cancelled")); return; }
+    signal?.addEventListener("abort", () => finish(reject, new Error("Cancelled")), { once: true });
+
     for (let i = 0; i < numWorkers; i++) {
       workerStdout[i] = "";
       workerStderr[i] = "";
@@ -50,9 +62,7 @@ export async function parallelBruteForce(userId, target, onProgress) {
               workerAttempts[i] = progress.attempts;
               const totalAttempts = workerAttempts.reduce((a, b) => a + b, 0);
               const elapsed = progress.elapsed || 0;
-              if (onProgress) {
-                onProgress(totalAttempts, elapsed, expected, numWorkers);
-              }
+              if (onProgress) onProgress(totalAttempts, elapsed, expected, numWorkers);
             }
           } catch {}
         }
@@ -63,14 +73,11 @@ export async function parallelBruteForce(userId, target, onProgress) {
         if (resolved) return;
 
         if (code === 0 && workerStdout[i].trim()) {
-          resolved = true;
-          killAll();
-
           try {
             const result = JSON.parse(workerStdout[i].trim());
             const totalAttempts = workerAttempts.reduce((a, b) => a + b, 0);
             const roll = rollFrom(result.salt, userId);
-            resolve({
+            finish(resolve, {
               salt: result.salt,
               result: roll,
               checked: Math.max(totalAttempts, result.attempts),
@@ -78,35 +85,31 @@ export async function parallelBruteForce(userId, target, onProgress) {
               workers: numWorkers,
             });
           } catch (err) {
-            reject(err);
+            finish(reject, err);
           }
           return;
         }
 
-        if (exited === numWorkers && !resolved) {
+        if (exited === numWorkers) {
           const totalAttempts = workerAttempts.reduce((a, b) => a + b, 0);
           const stderr = workerStderr.filter(Boolean).join("\n").trim();
           const detail = stderr ? `\n  Worker output: ${stderr.slice(0, 200)}` : "";
-          reject(new Error(`All ${numWorkers} workers exited without finding a match (${totalAttempts.toLocaleString()} tries).${detail}`));
+          finish(reject, new Error(`All ${numWorkers} workers exited without finding a match (${totalAttempts.toLocaleString()} tries).${detail}`));
         }
       });
 
       child.on("error", (err) => {
         exited++;
         if (exited === numWorkers && !resolved) {
-          reject(new Error(`Worker failed to start: ${err.message}`));
+          finish(reject, new Error(`Worker failed to start: ${err.message}`));
         }
       });
     }
 
     const timeoutMs = Math.max(600_000, Math.ceil(expected / 50_000_000) * 60_000 + 600_000);
-    setTimeout(() => {
-      if (!resolved) {
-        resolved = true;
-        killAll();
-        const totalAttempts = workerAttempts.reduce((a, b) => a + b, 0);
-        reject(new Error(`Timed out after ${Math.round(timeoutMs / 1000)}s (${totalAttempts.toLocaleString()} tries). This combination might be extremely rare — try fewer constraints.`));
-      }
+    timer = setTimeout(() => {
+      const totalAttempts = workerAttempts.reduce((a, b) => a + b, 0);
+      finish(reject, new Error(`Timed out after ${Math.round(timeoutMs / 1000)}s (${totalAttempts.toLocaleString()} tries). This combination might be extremely rare — try fewer constraints.`));
     }, timeoutMs);
   });
 }

package/lib/hooks.js

@@ -1,75 +1,92 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync, statSync } from "fs";
 import { join, dirname } from "path";
 import { homedir } from "os";
 
 const HOOK_COMMAND = "npx buddy-reroll --apply-hook";
 
+const HOOK_ENTRY = {
+  hooks: [{ type: "command", command: HOOK_COMMAND }],
+};
+
+function isOurHook(entry) {
+  if (typeof entry === "string") return entry === HOOK_COMMAND;
+  if (entry?.hooks) return entry.hooks.some((h) => h.command === HOOK_COMMAND);
+  return false;
+}
+
 export function getSettingsPath() {
   return join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"), "settings.json");
 }
 
 export function readSettings(settingsPath) {
-  if (!existsSync(settingsPath)) {
-    return {};
-  }
+  if (!existsSync(settingsPath)) return {};
   try {
     return JSON.parse(readFileSync(settingsPath, "utf-8"));
   } catch {
-    return {};
+    return null;
   }
 }
 
-export function writeSettings(settingsPath, obj) {
+function writeSettingsAtomic(settingsPath, obj) {
   const dir = dirname(settingsPath);
   mkdirSync(dir, { recursive: true });
-  writeFileSync(settingsPath, JSON.stringify(obj, null, 2) + "\n");
+  const tmpPath = settingsPath + ".tmp";
+  const content = JSON.stringify(obj, null, 2) + "\n";
+  let mode;
+  try { mode = statSync(settingsPath).mode; } catch {}
+  writeFileSync(tmpPath, content, mode ? { mode } : undefined);
+  renameSync(tmpPath, settingsPath);
+}
+
+export function writeSettings(settingsPath, obj) {
+  writeSettingsAtomic(settingsPath, obj);
 }
 
 export function installHook(settingsPath = getSettingsPath()) {
   const settings = readSettings(settingsPath);
-  
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
-  if (!settings.hooks.SessionStart) {
-    settings.hooks.SessionStart = [];
-  }
-  
-  if (settings.hooks.SessionStart.includes(HOOK_COMMAND)) {
+  if (!settings) return { installed: false, reason: "settings file is corrupted, not modifying" };
+
+  if (!settings.hooks) settings.hooks = {};
+  if (!Array.isArray(settings.hooks.SessionStart)) settings.hooks.SessionStart = [];
+
+  const existing = settings.hooks.SessionStart.find(isOurHook);
+  if (existing && typeof existing === "object") {
     return { installed: false, reason: "already installed" };
   }
-  
-  settings.hooks.SessionStart.push(HOOK_COMMAND);
-  writeSettings(settingsPath, settings);
-  
+
+  settings.hooks.SessionStart = settings.hooks.SessionStart.filter((e) => !isOurHook(e));
+  settings.hooks.SessionStart.push(HOOK_ENTRY);
+  writeSettingsAtomic(settingsPath, settings);
+
   return { installed: true, path: settingsPath };
 }
 
 export function removeHook(settingsPath = getSettingsPath()) {
   const settings = readSettings(settingsPath);
-  
-  if (!settings.hooks || !settings.hooks.SessionStart) {
+  if (!settings) return { removed: false, reason: "settings file is corrupted, not modifying" };
+
+  if (!settings.hooks || !Array.isArray(settings.hooks.SessionStart)) {
     return { removed: false, reason: "not installed" };
   }
-  
-  settings.hooks.SessionStart = settings.hooks.SessionStart.filter(cmd => cmd !== HOOK_COMMAND);
-  
-  if (settings.hooks.SessionStart.length === 0) {
-    delete settings.hooks.SessionStart;
-  }
-  
-  if (Object.keys(settings.hooks).length === 0) {
-    delete settings.hooks;
+
+  const before = settings.hooks.SessionStart.length;
+  settings.hooks.SessionStart = settings.hooks.SessionStart.filter((e) => !isOurHook(e));
+
+  if (settings.hooks.SessionStart.length === before) {
+    return { removed: false, reason: "not installed" };
   }
-  
-  writeSettings(settingsPath, settings);
-  
+
+  if (settings.hooks.SessionStart.length === 0) delete settings.hooks.SessionStart;
+  if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+
+  writeSettingsAtomic(settingsPath, settings);
   return { removed: true, path: settingsPath };
 }
 
 export function isHookInstalled(settingsPath = getSettingsPath()) {
   const settings = readSettings(settingsPath);
-  return settings.hooks?.SessionStart?.includes(HOOK_COMMAND) ?? false;
+  if (!settings) return false;
+  return Array.isArray(settings.hooks?.SessionStart) && settings.hooks.SessionStart.some(isOurHook);
 }
 
 export function getSaltStorePath() {
@@ -80,14 +97,14 @@ export function storeSalt(salt) {
   const path = getSaltStorePath();
   const dir = dirname(path);
   mkdirSync(dir, { recursive: true });
-  writeFileSync(path, JSON.stringify({ salt, timestamp: Date.now() }, null, 2) + "\n");
+  const tmpPath = path + ".tmp";
+  writeFileSync(tmpPath, JSON.stringify({ salt, timestamp: Date.now() }, null, 2) + "\n");
+  renameSync(tmpPath, path);
 }
 
 export function readStoredSalt() {
   const path = getSaltStorePath();
-  if (!existsSync(path)) {
-    return null;
-  }
+  if (!existsSync(path)) return null;
   try {
     return JSON.parse(readFileSync(path, "utf-8"));
   } catch {

package/lib/hooks.test.js

@@ -1,7 +1,8 @@
 import { describe, it, expect, beforeEach, afterEach } from "bun:test";
 import { mkdtempSync, rmSync, writeFileSync, readFileSync } from "fs";
 import { join } from "path";
-import { tmpdir } from "os";
+import { tmpdir, homedir } from "os";
+import { realpathSync } from "fs";
 import {
   readSettings,
   writeSettings,
@@ -12,10 +13,19 @@ import {
   readStoredSalt,
 } from "./hooks.js";
 
+const HOOK_COMMAND = "npx buddy-reroll --apply-hook";
+
+function findOurHook(settings) {
+  const entries = settings.hooks?.SessionStart ?? [];
+  return entries.find(
+    (e) => typeof e === "object" && e.hooks?.some((h) => h.command === HOOK_COMMAND)
+  );
+}
+
 let tempDir;
 
 beforeEach(() => {
-  tempDir = mkdtempSync(join(tmpdir(), "buddy-reroll-test-"));
+  tempDir = mkdtempSync(join(realpathSync(tmpdir()), "buddy-reroll-test-"));
   process.env.CLAUDE_CONFIG_DIR = tempDir;
 });
 
@@ -26,215 +36,203 @@ afterEach(() => {
 
 describe("readSettings", () => {
   it("returns empty object when file doesn't exist", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    expect(readSettings(settingsPath)).toEqual({});
+    expect(readSettings(join(tempDir, "settings.json"))).toEqual({});
   });
 
   it("parses valid JSON file", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    writeSettings(settingsPath, { permissions: { allow: [] } });
-    expect(readSettings(settingsPath)).toEqual({ permissions: { allow: [] } });
+    const p = join(tempDir, "settings.json");
+    writeSettings(p, { permissions: { allow: [] } });
+    expect(readSettings(p)).toEqual({ permissions: { allow: [] } });
   });
 
-  it("returns empty object for corrupted JSON", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    writeFileSync(settingsPath, "{ invalid json");
-    expect(readSettings(settingsPath)).toEqual({});
+  it("returns null for corrupted JSON", () => {
+    const p = join(tempDir, "settings.json");
+    writeFileSync(p, "{ invalid json");
+    expect(readSettings(p)).toBeNull();
   });
 });
 
 describe("writeSettings", () => {
   it("creates parent directories if needed", () => {
-    const settingsPath = join(tempDir, "nested", "dir", "settings.json");
-    writeSettings(settingsPath, { test: true });
-    expect(readSettings(settingsPath)).toEqual({ test: true });
+    const p = join(tempDir, "nested", "dir", "settings.json");
+    writeSettings(p, { test: true });
+    expect(readSettings(p)).toEqual({ test: true });
   });
 
-  it("writes JSON with 2-space indent and newline", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    writeSettings(settingsPath, { a: 1, b: 2 });
-    const content = readFileSync(settingsPath, "utf-8");
+  it("writes JSON with 2-space indent and trailing newline", () => {
+    const p = join(tempDir, "settings.json");
+    writeSettings(p, { a: 1 });
+    const content = readFileSync(p, "utf-8");
     expect(content).toContain("  ");
     expect(content.endsWith("\n")).toBe(true);
   });
 });
 
 describe("installHook", () => {
-  it("creates settings.json if missing", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    const result = installHook(settingsPath);
+  it("creates settings.json with correct hook format", () => {
+    const p = join(tempDir, "settings.json");
+    const result = installHook(p);
     expect(result.installed).toBe(true);
-    const settings = readSettings(settingsPath);
-    expect(settings.hooks.SessionStart).toContain("npx buddy-reroll --apply-hook");
-  });
-
-  it("adds hook to existing settings", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    writeSettings(settingsPath, { permissions: { allow: [] } });
-    installHook(settingsPath);
-    const settings = readSettings(settingsPath);
-    expect(settings.permissions).toEqual({ allow: [] });
-    expect(settings.hooks.SessionStart).toContain("npx buddy-reroll --apply-hook");
-  });
-
-  it("is idempotent - doesn't duplicate hook", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    installHook(settingsPath);
-    const result = installHook(settingsPath);
+    const settings = readSettings(p);
+    const hook = findOurHook(settings);
+    expect(hook).toBeDefined();
+    expect(hook.matcher).toBeUndefined();
+    expect(hook.hooks[0].type).toBe("command");
+    expect(hook.hooks[0].command).toBe(HOOK_COMMAND);
+  });
+
+  it("adds hook to existing settings without clobbering", () => {
+    const p = join(tempDir, "settings.json");
+    writeSettings(p, { permissions: { allow: ["test"] } });
+    installHook(p);
+    const settings = readSettings(p);
+    expect(settings.permissions).toEqual({ allow: ["test"] });
+    expect(findOurHook(settings)).toBeDefined();
+  });
+
+  it("is idempotent", () => {
+    const p = join(tempDir, "settings.json");
+    installHook(p);
+    const result = installHook(p);
     expect(result.installed).toBe(false);
     expect(result.reason).toBe("already installed");
-    const settings = readSettings(settingsPath);
-    const count = settings.hooks.SessionStart.filter(cmd => cmd === "npx buddy-reroll --apply-hook").length;
-    expect(count).toBe(1);
-  });
-
-  it("preserves existing hooks in SessionStart array", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    writeSettings(settingsPath, {
-      hooks: { SessionStart: ["existing-hook"] },
-    });
-    installHook(settingsPath);
-    const settings = readSettings(settingsPath);
-    expect(settings.hooks.SessionStart).toContain("existing-hook");
-    expect(settings.hooks.SessionStart).toContain("npx buddy-reroll --apply-hook");
+    const settings = readSettings(p);
+    const hooks = settings.hooks.SessionStart.filter(
+      (e) => typeof e === "object" && e.hooks?.some((h) => h.command === HOOK_COMMAND)
+    );
+    expect(hooks.length).toBe(1);
+  });
+
+  it("migrates old string-format hook to new format", () => {
+    const p = join(tempDir, "settings.json");
+    writeSettings(p, { hooks: { SessionStart: [HOOK_COMMAND] } });
+    installHook(p);
+    const settings = readSettings(p);
+    const strings = settings.hooks.SessionStart.filter((e) => typeof e === "string");
+    expect(strings.length).toBe(0);
+    expect(findOurHook(settings)).toBeDefined();
+  });
+
+  it("preserves other hooks in SessionStart array", () => {
+    const p = join(tempDir, "settings.json");
+    const otherHook = { matcher: "Bash", hooks: [{ type: "command", command: "echo hi" }] };
+    writeSettings(p, { hooks: { SessionStart: [otherHook] } });
+    installHook(p);
+    const settings = readSettings(p);
+    expect(settings.hooks.SessionStart.length).toBe(2);
+    expect(settings.hooks.SessionStart[0]).toEqual(otherHook);
   });
 });
 
 describe("removeHook", () => {
-  it("removes hook from SessionStart", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    installHook(settingsPath);
-    const result = removeHook(settingsPath);
+  it("removes hook", () => {
+    const p = join(tempDir, "settings.json");
+    installHook(p);
+    const result = removeHook(p);
     expect(result.removed).toBe(true);
-    const settings = readSettings(settingsPath);
-    expect(settings.hooks?.SessionStart?.includes("npx buddy-reroll --apply-hook") ?? false).toBe(false);
+    expect(findOurHook(readSettings(p))).toBeUndefined();
   });
 
-  it("deletes empty SessionStart array", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    installHook(settingsPath);
-    removeHook(settingsPath);
-    const settings = readSettings(settingsPath);
-    expect(settings.hooks?.SessionStart).toBeUndefined();
+  it("removes old string-format hook too", () => {
+    const p = join(tempDir, "settings.json");
+    writeSettings(p, { hooks: { SessionStart: [HOOK_COMMAND] } });
+    const result = removeHook(p);
+    expect(result.removed).toBe(true);
   });
 
-  it("deletes empty hooks object", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    installHook(settingsPath);
-    removeHook(settingsPath);
-    const settings = readSettings(settingsPath);
+  it("deletes empty SessionStart and hooks", () => {
+    const p = join(tempDir, "settings.json");
+    installHook(p);
+    removeHook(p);
+    const settings = readSettings(p);
     expect(settings.hooks).toBeUndefined();
   });
 
-  it("returns false when hook not installed", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    const result = removeHook(settingsPath);
-    expect(result.removed).toBe(false);
-    expect(result.reason).toBe("not installed");
+  it("returns false when not installed", () => {
+    const p = join(tempDir, "settings.json");
+    expect(removeHook(p).removed).toBe(false);
   });
 
-  it("preserves other hooks in SessionStart", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    writeSettings(settingsPath, {
-      hooks: { SessionStart: ["other-hook", "npx buddy-reroll --apply-hook"] },
-    });
-    removeHook(settingsPath);
-    const settings = readSettings(settingsPath);
-    expect(settings.hooks.SessionStart).toContain("other-hook");
-    expect(settings.hooks.SessionStart).not.toContain("npx buddy-reroll --apply-hook");
+  it("preserves other hooks", () => {
+    const p = join(tempDir, "settings.json");
+    const otherHook = { matcher: "Bash", hooks: [{ type: "command", command: "echo hi" }] };
+    writeSettings(p, { hooks: { SessionStart: [otherHook, HOOK_COMMAND] } });
+    removeHook(p);
+    const settings = readSettings(p);
+    expect(settings.hooks.SessionStart).toEqual([otherHook]);
   });
 
   it("preserves other hook types", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    writeSettings(settingsPath, {
-      hooks: {
-        SessionStart: ["npx buddy-reroll --apply-hook"],
-        OnExit: ["some-command"],
-      },
-    });
-    removeHook(settingsPath);
-    const settings = readSettings(settingsPath);
-    expect(settings.hooks.OnExit).toContain("some-command");
+    const p = join(tempDir, "settings.json");
+    installHook(p);
+    const settings = readSettings(p);
+    settings.hooks.PostToolUse = [{ matcher: "Edit", hooks: [{ type: "command", command: "lint" }] }];
+    writeSettings(p, settings);
+    removeHook(p);
+    const after = readSettings(p);
+    expect(after.hooks.PostToolUse).toBeDefined();
   });
 });
 
 describe("isHookInstalled", () => {
-  it("returns true after install", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    installHook(settingsPath);
-    expect(isHookInstalled(settingsPath)).toBe(true);
+  it("true after install", () => {
+    const p = join(tempDir, "settings.json");
+    installHook(p);
+    expect(isHookInstalled(p)).toBe(true);
   });
 
-  it("returns false after remove", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    installHook(settingsPath);
-    removeHook(settingsPath);
-    expect(isHookInstalled(settingsPath)).toBe(false);
+  it("false after remove", () => {
+    const p = join(tempDir, "settings.json");
+    installHook(p);
+    removeHook(p);
+    expect(isHookInstalled(p)).toBe(false);
   });
 
-  it("returns false when settings don't exist", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    expect(isHookInstalled(settingsPath)).toBe(false);
+  it("false when no file", () => {
+    expect(isHookInstalled(join(tempDir, "settings.json"))).toBe(false);
   });
 
-  it("returns false when hooks don't exist", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    writeSettings(settingsPath, { permissions: { allow: [] } });
-    expect(isHookInstalled(settingsPath)).toBe(false);
+  it("detects old string-format as installed", () => {
+    const p = join(tempDir, "settings.json");
+    writeSettings(p, { hooks: { SessionStart: [HOOK_COMMAND] } });
+    expect(isHookInstalled(p)).toBe(true);
   });
 });
 
 describe("storeSalt and readStoredSalt", () => {
-  it("roundtrips salt with timestamp", () => {
-    const salt = "test-salt-value";
-    storeSalt(salt);
+  it("roundtrips salt", () => {
+    storeSalt("test-salt");
     const stored = readStoredSalt();
-    expect(stored.salt).toBe(salt);
-    expect(typeof stored.timestamp).toBe("number");
+    expect(stored.salt).toBe("test-salt");
     expect(stored.timestamp).toBeGreaterThan(0);
   });
 
-  it("returns null when file doesn't exist", () => {
+  it("returns null when missing", () => {
     expect(readStoredSalt()).toBeNull();
   });
 
-  it("returns null for corrupted salt file", () => {
-    const saltPath = join(tempDir, ".buddy-reroll.json");
-    writeFileSync(saltPath, "{ invalid json");
+  it("returns null for corrupted file", () => {
+    writeFileSync(join(tempDir, ".buddy-reroll.json"), "broken");
     expect(readStoredSalt()).toBeNull();
   });
-
-  it("creates parent directories for salt file", () => {
-    const salt = "another-test-salt";
-    storeSalt(salt);
-    const stored = readStoredSalt();
-    expect(stored.salt).toBe(salt);
-  });
 });
 
 describe("integration", () => {
-  it("preserves existing settings when installing hook", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    writeSettings(settingsPath, {
+  it("preserves complex settings through install and remove", () => {
+    const p = join(tempDir, "settings.json");
+    writeSettings(p, {
       permissions: { allow: ["some-permission"] },
       other: { nested: { value: 42 } },
     });
-    installHook(settingsPath);
-    const settings = readSettings(settingsPath);
-    expect(settings.permissions).toEqual({ allow: ["some-permission"] });
-    expect(settings.other).toEqual({ nested: { value: 42 } });
-    expect(settings.hooks.SessionStart).toContain("npx buddy-reroll --apply-hook");
-  });
-
-  it("preserves existing settings when removing hook", () => {
-    const settingsPath = join(tempDir, "settings.json");
-    writeSettings(settingsPath, {
-      permissions: { allow: ["some-permission"] },
-      hooks: { SessionStart: ["npx buddy-reroll --apply-hook"] },
-    });
-    removeHook(settingsPath);
-    const settings = readSettings(settingsPath);
-    expect(settings.permissions).toEqual({ allow: ["some-permission"] });
-    expect(settings.hooks).toBeUndefined();
+    installHook(p);
+    const after = readSettings(p);
+    expect(after.permissions).toEqual({ allow: ["some-permission"] });
+    expect(after.other).toEqual({ nested: { value: 42 } });
+    expect(findOurHook(after)).toBeDefined();
+
+    removeHook(p);
+    const final = readSettings(p);
+    expect(final.permissions).toEqual({ allow: ["some-permission"] });
+    expect(final.hooks).toBeUndefined();
   });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-reroll",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Reroll your Claude Code buddy companion to any species/rarity/eye/hat/shiny combo",
   "type": "module",
   "bin": {

package/ui.jsx

@@ -1,4 +1,4 @@
-import React, { useState, useEffect, useRef } from "react";
+import React, { useState, useEffect, useRef, useCallback } from "react";
 import { render, Box, Text, useApp, useInput } from "ink";
 import { renderSprite, RARITY_STARS, RARITY_COLORS } from "./sprites.js";
 import { existsSync, copyFileSync } from "fs";
@@ -125,19 +125,41 @@ function PreviewCard({ species, rarity, eye, hat, shiny, stats }) {
   );
 }
 
-function ShowCurrentStep({ isActive }) {
+function ExitOnKey({ isActive, children }) {
   const { exit } = useApp();
+  const exiting = useRef(false);
 
-  useInput(() => {
+  const doExit = useCallback(() => {
+    if (exiting.current) return;
+    exiting.current = true;
     exit();
-    setTimeout(() => process.exit(0), 100);
-  }, { isActive });
+    setTimeout(() => process.exit(0), 200);
+  }, [exit]);
+
+  useInput(() => doExit(), { isActive });
+
+  useEffect(() => {
+    if (!isActive) return;
+    const fallback = () => doExit();
+    process.stdin.once("data", fallback);
+    const timer = setTimeout(() => doExit(), 30000);
+    return () => {
+      process.stdin.removeListener("data", fallback);
+      clearTimeout(timer);
+    };
+  }, [isActive, doExit]);
+
+  return children;
+}
 
+function ShowCurrentStep({ isActive }) {
   return (
-    <Box flexDirection="column">
-      <Text color="green">✓ Current companion shown above.</Text>
-      <KeyHint>Press any key to exit</KeyHint>
-    </Box>
+    <ExitOnKey isActive={isActive}>
+      <Box flexDirection="column">
+        <Text color="green">✓ Current companion shown above.</Text>
+        <KeyHint>Press any key to exit</KeyHint>
+      </Box>
+    </ExitOnKey>
   );
 }
 
@@ -169,40 +191,44 @@ function SpeciesStep({ speciesList, current, onChange, onSubmit, onBack, isActiv
 
 function SearchStep({ userId, target, bruteForce, onFound, onFail, isActive }) {
   const [progress, setProgress] = useState("");
-  const cancelRef = useRef(false);
+  const abortRef = useRef(null);
   const hasStarted = useRef(false);
   const { exit } = useApp();
 
   useInput((input, key) => {
     if (key.escape) {
-      cancelRef.current = true;
+      if (abortRef.current) abortRef.current.abort();
       exit();
+      setTimeout(() => process.exit(0), 200);
     }
   }, { isActive });
 
   useEffect(() => {
     if (hasStarted.current) return;
     hasStarted.current = true;
+    const ac = new AbortController();
+    abortRef.current = ac;
     (async () => {
       let found;
       try {
         found = await bruteForce(userId, target, (attempts, elapsed, expected, workers) => {
-          if (!cancelRef.current) {
+          if (!ac.signal.aborted) {
             const pct = Math.min(100, Math.round((attempts / expected) * 100));
             const rate = attempts / (elapsed / 1000);
             const rateStr = rate >= 1e6 ? `${(rate / 1e6).toFixed(1)}M` : `${(rate / 1e3).toFixed(1)}k`;
             const eta = Math.max(0, (expected - attempts) / rate);
             setProgress(`${pct}% | ${rateStr} tries/s | ~${Math.round(eta)}s left | ${workers} cores`);
           }
-        });
+        }, ac.signal);
       } catch {
-        if (!cancelRef.current) onFail();
+        if (!ac.signal.aborted) onFail();
         return;
       }
-      if (cancelRef.current) return;
+      if (ac.signal.aborted) return;
       if (found) onFound(found);
       else onFail();
     })();
+    return () => ac.abort();
   }, [bruteForce, userId, target, onFound, onFail]);
 
   return (
@@ -214,30 +240,26 @@ function SearchStep({ userId, target, bruteForce, onFound, onFail, isActive }) {
 }
 
 function DoneStep({ messages, isActive }) {
-  const { exit } = useApp();
   const hasErrors = messages.some((msg) => msg.type === "error");
 
-  useInput(() => {
-    exit();
-    setTimeout(() => process.exit(0), 100);
-  }, { isActive });
-
   return (
-    <Box flexDirection="column">
-      {messages.map((msg) => (
-        <Text key={`${msg.type}-${msg.text}`} color={msg.type === "error" ? "red" : "green"}>
-          {msg.type === "error" ? "✗ " : "✓ "}{msg.text}
-        </Text>
-      ))}
-      <Box marginTop={1}>
-        <Text bold>
-          {hasErrors
-            ? "Something went wrong — check the issue above and try again."
-            : "All set! Your buddy will stick around even after updates. Restart Claude Code and say /buddy!"}
-        </Text>
+    <ExitOnKey isActive={isActive}>
+      <Box flexDirection="column">
+        {messages.map((msg) => (
+          <Text key={`${msg.type}-${msg.text}`} color={msg.type === "error" ? "red" : "green"}>
+            {msg.type === "error" ? "✗ " : "✓ "}{msg.text}
+          </Text>
+        ))}
+        <Box marginTop={1}>
+          <Text bold>
+            {hasErrors
+              ? "Something went wrong — check the issue above and try again."
+              : "All set! Your buddy will stick around even after updates. Restart Claude Code and say /buddy!"}
+          </Text>
+        </Box>
+        <KeyHint>Press any key to exit</KeyHint>
       </Box>
-      <KeyHint>Press any key to exit</KeyHint>
-    </Box>
+    </ExitOnKey>
   );
 }