buddy-reroll 0.2.0 → 0.3.0

package/lib/hooks.js

@@ -0,0 +1,96 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+
+const HOOK_COMMAND = "npx buddy-reroll --apply-hook";
+
+export function getSettingsPath() {
+  return join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"), "settings.json");
+}
+
+export function readSettings(settingsPath) {
+  if (!existsSync(settingsPath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(settingsPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+export function writeSettings(settingsPath, obj) {
+  const dir = dirname(settingsPath);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(settingsPath, JSON.stringify(obj, null, 2) + "\n");
+}
+
+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)) {
+    return { installed: false, reason: "already installed" };
+  }
+  
+  settings.hooks.SessionStart.push(HOOK_COMMAND);
+  writeSettings(settingsPath, settings);
+  
+  return { installed: true, path: settingsPath };
+}
+
+export function removeHook(settingsPath = getSettingsPath()) {
+  const settings = readSettings(settingsPath);
+  
+  if (!settings.hooks || !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;
+  }
+  
+  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;
+}
+
+export function getSaltStorePath() {
+  return join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"), ".buddy-reroll.json");
+}
+
+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");
+}
+
+export function readStoredSalt() {
+  const path = getSaltStorePath();
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}

package/lib/hooks.test.js

@@ -0,0 +1,240 @@
+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 {
+  readSettings,
+  writeSettings,
+  installHook,
+  removeHook,
+  isHookInstalled,
+  storeSalt,
+  readStoredSalt,
+} from "./hooks.js";
+
+let tempDir;
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), "buddy-reroll-test-"));
+  process.env.CLAUDE_CONFIG_DIR = tempDir;
+});
+
+afterEach(() => {
+  delete process.env.CLAUDE_CONFIG_DIR;
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe("readSettings", () => {
+  it("returns empty object when file doesn't exist", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    expect(readSettings(settingsPath)).toEqual({});
+  });
+
+  it("parses valid JSON file", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    writeSettings(settingsPath, { permissions: { allow: [] } });
+    expect(readSettings(settingsPath)).toEqual({ permissions: { allow: [] } });
+  });
+
+  it("returns empty object for corrupted JSON", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    writeFileSync(settingsPath, "{ invalid json");
+    expect(readSettings(settingsPath)).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 });
+  });
+
+  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");
+    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);
+    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);
+    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");
+  });
+});
+
+describe("removeHook", () => {
+  it("removes hook from SessionStart", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    installHook(settingsPath);
+    const result = removeHook(settingsPath);
+    expect(result.removed).toBe(true);
+    const settings = readSettings(settingsPath);
+    expect(settings.hooks?.SessionStart?.includes("npx buddy-reroll --apply-hook") ?? false).toBe(false);
+  });
+
+  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("deletes empty hooks object", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    installHook(settingsPath);
+    removeHook(settingsPath);
+    const settings = readSettings(settingsPath);
+    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("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 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");
+  });
+});
+
+describe("isHookInstalled", () => {
+  it("returns true after install", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    installHook(settingsPath);
+    expect(isHookInstalled(settingsPath)).toBe(true);
+  });
+
+  it("returns false after remove", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    installHook(settingsPath);
+    removeHook(settingsPath);
+    expect(isHookInstalled(settingsPath)).toBe(false);
+  });
+
+  it("returns false when settings don't exist", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    expect(isHookInstalled(settingsPath)).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);
+  });
+});
+
+describe("storeSalt and readStoredSalt", () => {
+  it("roundtrips salt with timestamp", () => {
+    const salt = "test-salt-value";
+    storeSalt(salt);
+    const stored = readStoredSalt();
+    expect(stored.salt).toBe(salt);
+    expect(typeof stored.timestamp).toBe("number");
+    expect(stored.timestamp).toBeGreaterThan(0);
+  });
+
+  it("returns null when file doesn't exist", () => {
+    expect(readStoredSalt()).toBeNull();
+  });
+
+  it("returns null for corrupted salt file", () => {
+    const saltPath = join(tempDir, ".buddy-reroll.json");
+    writeFileSync(saltPath, "{ invalid json");
+    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, {
+      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();
+  });
+});

package/lib/runtime.js

@@ -0,0 +1,184 @@
+import { accessSync, constants, existsSync, readFileSync, readdirSync, realpathSync, statSync } from "fs";
+import { execFileSync } from "child_process";
+import { join, dirname, isAbsolute } from "path";
+import { homedir, platform } from "os";
+
+const MIN_BINARY_SIZE = 1_000_000;
+const MAX_WRAPPER_SIZE = 64 * 1024;
+const MAX_RESOLVE_DEPTH = 4;
+const SHELL_EXEC_PATTERN = /^\s*exec\s+(?:"([^"]+)"|'([^']+)'|([^\s]+))(?:\s|$)/m;
+
+function isRealBinary(candidatePath) {
+  try {
+    const stats = statSync(candidatePath);
+    return stats.isFile() && stats.size > MIN_BINARY_SIZE;
+  } catch {
+    return false;
+  }
+}
+
+export function getClaudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
+}
+
+export function getClaudeBinaryOverride() {
+  return process.env.CLAUDE_BINARY_PATH?.trim() || null;
+}
+
+function expandShellPath(pathExpression) {
+  if (!pathExpression) return null;
+
+  const expanded = pathExpression
+    .replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] ?? "")
+    .replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, name) => process.env[name] ?? "");
+
+  if (expanded === "~") return homedir();
+  if (expanded.startsWith("~/")) return join(homedir(), expanded.slice(2));
+  return isAbsolute(expanded) ? expanded : null;
+}
+
+export function resolveClaudeExecutable(candidatePath, depth = 0, visited = new Set()) {
+  if (!candidatePath || depth > MAX_RESOLVE_DEPTH) return null;
+
+  const trimmedPath = candidatePath.trim();
+  if (!trimmedPath) return null;
+
+  let resolvedPath;
+  try {
+    resolvedPath = realpathSync(trimmedPath);
+  } catch {
+    resolvedPath = trimmedPath;
+  }
+
+  if (visited.has(resolvedPath)) return null;
+  visited.add(resolvedPath);
+
+  if (!existsSync(resolvedPath)) return null;
+  if (isRealBinary(resolvedPath)) return resolvedPath;
+
+  try {
+    const stats = statSync(resolvedPath);
+    if (!stats.isFile() || stats.size > MAX_WRAPPER_SIZE) return null;
+
+    const script = readFileSync(resolvedPath, "utf-8");
+    const execMatch = script.match(SHELL_EXEC_PATTERN);
+    if (!execMatch) return null;
+
+    const execTarget = expandShellPath(execMatch[1] ?? execMatch[2] ?? execMatch[3]);
+    if (!execTarget) return null;
+
+    return resolveClaudeExecutable(execTarget, depth + 1, visited);
+  } catch {
+    return null;
+  }
+}
+
+function getPathCandidates() {
+  const isWin = platform() === "win32";
+  const override = getClaudeBinaryOverride();
+
+  if (override) return [override];
+
+  try {
+    const command = isWin ? "where.exe" : "which";
+    const args = isWin ? ["claude"] : ["-a", "claude"];
+    return execFileSync(command, args, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    })
+      .split("\n")
+      .map((entry) => entry.trim())
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function getVersionCandidates() {
+  const isWin = platform() === "win32";
+  const versionsDirs = [
+    join(homedir(), ".local", "share", "claude", "versions"),
+    ...(isWin ? [join(process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local"), "Claude", "versions")] : []),
+  ];
+
+  const candidates = [];
+  for (const entry of versionsDirs) {
+    if (!existsSync(entry)) continue;
+
+    try {
+      const stats = statSync(entry);
+      if (stats.isFile()) {
+        candidates.push(entry);
+        continue;
+      }
+
+      const versions = readdirSync(entry)
+        .filter((file) => !file.includes(".backup"))
+        .sort();
+
+      if (versions.length > 0) {
+        candidates.push(join(entry, versions[versions.length - 1]));
+      }
+    } catch {}
+  }
+
+  return candidates;
+}
+
+export function findBinaryPath() {
+  const seen = new Set();
+  const candidates = [...getPathCandidates(), ...getVersionCandidates()];
+
+  for (const candidate of candidates) {
+    const resolved = resolveClaudeExecutable(candidate);
+    if (resolved && !seen.has(resolved)) {
+      seen.add(resolved);
+      return resolved;
+    }
+  }
+
+  return null;
+}
+
+export function findConfigPath() {
+  const claudeDir = getClaudeConfigDir();
+
+  const legacyPath = join(claudeDir, ".config.json");
+  if (existsSync(legacyPath)) return legacyPath;
+
+  const defaultPath = join(homedir(), ".claude.json");
+  if (existsSync(defaultPath)) return defaultPath;
+
+  if (platform() === "win32" && process.env.APPDATA) {
+    const appDataPath = join(process.env.APPDATA, "Claude", "config.json");
+    if (existsSync(appDataPath)) return appDataPath;
+  }
+
+  return null;
+}
+
+export function getPatchability(binaryPath) {
+  if (!binaryPath) {
+    return { ok: false, message: "Claude Code binary path is missing.", backupPath: null };
+  }
+
+  if (!existsSync(binaryPath)) {
+    return { ok: false, message: `Claude Code binary was not found at ${binaryPath}.`, backupPath: null };
+  }
+
+  const backupPath = `${binaryPath}.backup`;
+
+  try {
+    accessSync(binaryPath, constants.W_OK);
+    if (!existsSync(backupPath)) {
+      accessSync(dirname(binaryPath), constants.W_OK);
+    }
+    return { ok: true, message: null, backupPath };
+  } catch {
+    return {
+      ok: false,
+      message: `Claude install found at ${binaryPath}, but it is not writable by the current user. buddy-reroll can show the current companion, but reroll and restore require a user-writable Claude install.`,
+      backupPath,
+    };
+  }
+}

package/lib/runtime.test.js

@@ -0,0 +1,110 @@
+import { describe, it, expect } from "bun:test";
+import { resolveClaudeExecutable, getClaudeBinaryOverride, getClaudeConfigDir, getPatchability } from "./runtime.js";
+import { writeFileSync, mkdirSync, rmSync, chmodSync, realpathSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+function makeTempDir() {
+  const dir = join(realpathSync(tmpdir()), `buddy-reroll-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+describe("getClaudeConfigDir", () => {
+  it("returns ~/.claude by default", () => {
+    const original = process.env.CLAUDE_CONFIG_DIR;
+    delete process.env.CLAUDE_CONFIG_DIR;
+    const result = getClaudeConfigDir();
+    expect(result).toMatch(/\.claude$/);
+    if (original) process.env.CLAUDE_CONFIG_DIR = original;
+  });
+
+  it("respects CLAUDE_CONFIG_DIR env var", () => {
+    const original = process.env.CLAUDE_CONFIG_DIR;
+    process.env.CLAUDE_CONFIG_DIR = "/custom/path";
+    expect(getClaudeConfigDir()).toBe("/custom/path");
+    if (original) process.env.CLAUDE_CONFIG_DIR = original;
+    else delete process.env.CLAUDE_CONFIG_DIR;
+  });
+});
+
+describe("getClaudeBinaryOverride", () => {
+  it("returns null when not set", () => {
+    const original = process.env.CLAUDE_BINARY_PATH;
+    delete process.env.CLAUDE_BINARY_PATH;
+    expect(getClaudeBinaryOverride()).toBeNull();
+    if (original) process.env.CLAUDE_BINARY_PATH = original;
+  });
+
+  it("returns trimmed path when set", () => {
+    const original = process.env.CLAUDE_BINARY_PATH;
+    process.env.CLAUDE_BINARY_PATH = "  /some/path  ";
+    expect(getClaudeBinaryOverride()).toBe("/some/path");
+    if (original) process.env.CLAUDE_BINARY_PATH = original;
+    else delete process.env.CLAUDE_BINARY_PATH;
+  });
+});
+
+describe("resolveClaudeExecutable", () => {
+  it("returns null for non-existent path", () => {
+    expect(resolveClaudeExecutable("/nonexistent/path")).toBeNull();
+  });
+
+  it("returns null for empty input", () => {
+    expect(resolveClaudeExecutable("")).toBeNull();
+    expect(resolveClaudeExecutable(null)).toBeNull();
+  });
+
+  it("returns path for large files (real binary)", () => {
+    const dir = makeTempDir();
+    const fakeBinary = join(dir, "claude");
+    writeFileSync(fakeBinary, Buffer.alloc(2_000_000));
+    expect(resolveClaudeExecutable(fakeBinary)).toBe(fakeBinary);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("follows shell exec wrapper to real binary", () => {
+    const dir = makeTempDir();
+    const realBinary = join(dir, "claude-real");
+    const wrapper = join(dir, "claude");
+    writeFileSync(realBinary, Buffer.alloc(2_000_000));
+    writeFileSync(wrapper, `#!/bin/sh\nexec "${realBinary}" "$@"\n`);
+    chmodSync(wrapper, 0o755);
+    expect(resolveClaudeExecutable(wrapper)).toBe(realBinary);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("prevents infinite loops via cycle detection", () => {
+    const dir = makeTempDir();
+    const a = join(dir, "a");
+    const b = join(dir, "b");
+    writeFileSync(a, `#!/bin/sh\nexec "${b}" "$@"\n`);
+    writeFileSync(b, `#!/bin/sh\nexec "${a}" "$@"\n`);
+    chmodSync(a, 0o755);
+    chmodSync(b, 0o755);
+    expect(resolveClaudeExecutable(a)).toBeNull();
+    rmSync(dir, { recursive: true });
+  });
+});
+
+describe("getPatchability", () => {
+  it("returns ok for writable file", () => {
+    const dir = makeTempDir();
+    const file = join(dir, "claude");
+    writeFileSync(file, "data");
+    const result = getPatchability(file);
+    expect(result.ok).toBe(true);
+    expect(result.backupPath).toBe(`${file}.backup`);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("returns not ok for missing path", () => {
+    const result = getPatchability(null);
+    expect(result.ok).toBe(false);
+  });
+
+  it("returns not ok for non-existent file", () => {
+    const result = getPatchability("/nonexistent/file");
+    expect(result.ok).toBe(false);
+  });
+});