buddy-reroll 0.3.3 → 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,16 +481,21 @@ 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);
   }
 

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,11 +1,10 @@
-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 = {
-  matcher: "",
   hooks: [{ type: "command", command: HOOK_COMMAND }],
 };
 
@@ -24,18 +23,28 @@ export function readSettings(settingsPath) {
   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) return { installed: false, reason: "settings file is corrupted, not modifying" };
 
   if (!settings.hooks) settings.hooks = {};
   if (!Array.isArray(settings.hooks.SessionStart)) settings.hooks.SessionStart = [];
@@ -47,13 +56,14 @@ export function installHook(settingsPath = getSettingsPath()) {
 
   settings.hooks.SessionStart = settings.hooks.SessionStart.filter((e) => !isOurHook(e));
   settings.hooks.SessionStart.push(HOOK_ENTRY);
-  writeSettings(settingsPath, settings);
+  writeSettingsAtomic(settingsPath, settings);
 
   return { installed: true, path: settingsPath };
 }
 
 export function removeHook(settingsPath = getSettingsPath()) {
   const settings = readSettings(settingsPath);
+  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" };
@@ -69,12 +79,13 @@ export function removeHook(settingsPath = getSettingsPath()) {
   if (settings.hooks.SessionStart.length === 0) delete settings.hooks.SessionStart;
   if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
 
-  writeSettings(settingsPath, settings);
+  writeSettingsAtomic(settingsPath, settings);
   return { removed: true, path: settingsPath };
 }
 
 export function isHookInstalled(settingsPath = getSettingsPath()) {
   const settings = readSettings(settingsPath);
+  if (!settings) return false;
   return Array.isArray(settings.hooks?.SessionStart) && settings.hooks.SessionStart.some(isOurHook);
 }
 
@@ -86,7 +97,9 @@ 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() {

package/lib/hooks.test.js

@@ -45,10 +45,10 @@ describe("readSettings", () => {
     expect(readSettings(p)).toEqual({ permissions: { allow: [] } });
   });
 
-  it("returns empty object for corrupted JSON", () => {
+  it("returns null for corrupted JSON", () => {
     const p = join(tempDir, "settings.json");
     writeFileSync(p, "{ invalid json");
-    expect(readSettings(p)).toEqual({});
+    expect(readSettings(p)).toBeNull();
   });
 });
 
@@ -76,7 +76,7 @@ describe("installHook", () => {
     const settings = readSettings(p);
     const hook = findOurHook(settings);
     expect(hook).toBeDefined();
-    expect(hook.matcher).toBe("");
+    expect(hook.matcher).toBeUndefined();
     expect(hook.hooks[0].type).toBe("command");
     expect(hook.hooks[0].command).toBe(HOOK_COMMAND);
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-reroll",
-  "version": "0.3.3",
+  "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>
   );
 }