buddy-reroll 0.3.2 → 0.3.3

package/index.js

@@ -490,7 +490,22 @@ async function main() {
   }
 
   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/hooks.js

@@ -4,14 +4,23 @@ import { homedir } from "os";
 
 const HOOK_COMMAND = "npx buddy-reroll --apply-hook";
 
+const HOOK_ENTRY = {
+  matcher: "",
+  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 {
@@ -27,49 +36,46 @@ export function writeSettings(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.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);
+
+  settings.hooks.SessionStart = settings.hooks.SessionStart.filter((e) => !isOurHook(e));
+  settings.hooks.SessionStart.push(HOOK_ENTRY);
   writeSettings(settingsPath, settings);
-  
+
   return { installed: true, path: settingsPath };
 }
 
 export function removeHook(settingsPath = getSettingsPath()) {
   const settings = readSettings(settingsPath);
-  
-  if (!settings.hooks || !settings.hooks.SessionStart) {
+
+  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" };
   }
-  
+
+  if (settings.hooks.SessionStart.length === 0) delete settings.hooks.SessionStart;
+  if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+
   writeSettings(settingsPath, settings);
-  
   return { removed: true, path: settingsPath };
 }
 
 export function isHookInstalled(settingsPath = getSettingsPath()) {
   const settings = readSettings(settingsPath);
-  return settings.hooks?.SessionStart?.includes(HOOK_COMMAND) ?? false;
+  return Array.isArray(settings.hooks?.SessionStart) && settings.hooks.SessionStart.some(isOurHook);
 }
 
 export function getSaltStorePath() {
@@ -85,9 +91,7 @@ export function storeSalt(salt) {
 
 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({});
+    const p = join(tempDir, "settings.json");
+    writeFileSync(p, "{ invalid json");
+    expect(readSettings(p)).toEqual({});
   });
 });
 
 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).toBe("");
+    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.3",
   "description": "Reroll your Claude Code buddy companion to any species/rarity/eye/hat/shiny combo",
   "type": "module",
   "bin": {