@scrylog/cli 0.3.0 → 0.3.1

package/src/cli/commands.ts

@@ -1,714 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, copyFileSync } from "node:fs";
-import { randomBytes } from "node:crypto";
-import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { loadConfig, getResolvedConfigPath, updateConfig } from "../shared/config";
-import type { ScrylogConfig } from "../shared/config";
-import { getDaemonLogPath } from "../shared/paths";
-import { createPromptSession } from "./prompt";
-import { getServiceManagerOrThrow } from "../service/manager";
-import { createDaemonFetch, getSocketPath } from "../shared/ipc";
-import { adviseProviderIcons, probeTerminalGraphics } from "../shared/terminal-capabilities";
-import { IS_MAC, IS_WINDOWS, whichCommand } from "../shared/platform";
-import { formatVersionDiagnostics, getInstalledVersion } from "../shared/version";
-import { listSessions } from "@joeldmtz/prtl-core";
-import type { ListSessionsOptions, PrtlListResult } from "@joeldmtz/prtl-core";
-
-export interface GlobalCliOptions {
-  configPath?: string;
-}
-
-type HerdrList = (options?: ListSessionsOptions) => Promise<PrtlListResult>;
-
-export async function isHerdrAvailable(timeoutMs: number, list: HerdrList = listSessions): Promise<boolean> {
-  try {
-    const result = await list({ provider: "herdr", timeoutMs });
-    return result.metadata.providers.herdr?.available === true;
-  } catch {
-    return false;
-  }
-}
-
-export async function runDaemonCommand(action: string, options: GlobalCliOptions): Promise<void> {
-  const manager = getServiceManagerOrThrow();
-  if (action === "install") {
-    manager.install(options.configPath);
-    process.stdout.write("Installed daemon user service.\n");
-    return;
-  }
-  if (action === "uninstall") {
-    manager.uninstall();
-    process.stdout.write("Uninstalled daemon user service.\n");
-    return;
-  }
-  if (action === "start") {
-    manager.start();
-    process.stdout.write("Started daemon user service.\n");
-    return;
-  }
-  if (action === "stop") {
-    manager.stop();
-    process.stdout.write("Stopped daemon user service.\n");
-    return;
-  }
-  if (action === "restart") {
-    manager.restart();
-    process.stdout.write("Restarted daemon user service.\n");
-    return;
-  }
-  if (action === "status") {
-    const status = manager.status();
-    process.stdout.write(`Platform: ${status.platform}\nInstalled: ${status.installed}\nRunning: ${status.running}\n${status.detail}\n`);
-    return;
-  }
-  throw new Error(`Unknown daemon action: ${action}`);
-}
-
-export function runConfigCommand(action: string, options: GlobalCliOptions): void {
-  if (action === "path") {
-    process.stdout.write(`${getResolvedConfigPath(options.configPath)}\n`);
-    return;
-  }
-  if (action === "show") {
-    process.stdout.write(`${JSON.stringify(loadConfig(options.configPath), null, 2)}\n`);
-    return;
-  }
-  throw new Error(`Unknown config action: ${action}`);
-}
-
-export function runTokenCommand(target: "mcp" | "api" | "both", action: string, options: GlobalCliOptions): void {
-  if (action === "clear") {
-    updateConfig((current) => {
-      const next: ScrylogConfig = { ...current, mcp: { ...current.mcp }, api: { ...current.api } };
-      if (target === "mcp" || target === "both") next.mcp.bearerToken = undefined;
-      if (target === "api" || target === "both") next.api.bearerToken = undefined;
-      return next;
-    }, options.configPath);
-    process.stdout.write(`Cleared ${target === "both" ? "API and MCP" : target.toUpperCase()} bearer token.\n`);
-    return;
-  }
-
-  if (action === "generate" || action === "rotate") {
-    const token = generateToken();
-    updateConfig((current) => {
-      const next: ScrylogConfig = { ...current, mcp: { ...current.mcp }, api: { ...current.api } };
-      if (target === "mcp" || target === "both") next.mcp.bearerToken = token;
-      if (target === "api" || target === "both") next.api.bearerToken = token;
-      return next;
-    }, options.configPath);
-    process.stdout.write(`${token}\n`);
-    return;
-  }
-
-  throw new Error(`Unknown token action: ${action}`);
-}
-
-export async function runLogsCommand(_options: GlobalCliOptions): Promise<void> {
-  const logPath = getDaemonLogPath();
-  process.stdout.write(`Log path: ${logPath}\n`);
-  if (!existsSync(logPath)) {
-    process.stdout.write("No daemon log file found.\n");
-    return;
-  }
-  const content = await readFile(logPath, "utf8");
-  const lines = content.trim().split(/\r?\n/);
-  const recent = lines.slice(Math.max(0, lines.length - 40));
-  process.stdout.write(`${recent.join("\n")}\n`);
-}
-
-interface ClaudeCredentialDiagnostics {
-  state: "missing" | "expired" | "valid";
-}
-
-/**
- * Claude credential state for doctor diagnostics, derived from the running
- * daemon's usage state. Reports only the state — never prints token material.
- * Returns null when the daemon is unreachable (no line is printed).
- */
-async function claudeCredentialState(daemonFetch: Awaited<ReturnType<typeof createDaemonFetch>>): Promise<ClaudeCredentialDiagnostics | null> {
-  try {
-    const usage = await daemonFetch("/api/usage") as { providers?: Array<{ provider: string; status: string; errors?: string[] }> };
-    const claude = usage.providers?.find((provider) => provider.provider === "claude");
-    if (!claude) return null;
-    if (claude.status === "ok") return { state: "valid" };
-    if (claude.status === "unavailable") {
-      const expired = (claude.errors ?? []).some((message) => message.includes("expired") || message.includes("re-login"));
-      return { state: expired ? "expired" : "missing" };
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-export async function runDoctor(options: GlobalCliOptions): Promise<void> {  const configPath = getResolvedConfigPath(options.configPath);
-  const config = loadConfig(options.configPath);
-  const daemonFetch = createDaemonFetch({
-    host: config.api.host,
-    port: config.api.port,
-    socketPath: IS_WINDOWS ? undefined : getSocketPath(config.daemon.socketPath),
-  });
-
-  process.stdout.write(`Config path: ${configPath}\n`);
-  process.stdout.write(`Config exists: ${existsSync(configPath)}\n`);
-  process.stdout.write(`Socket path: ${IS_WINDOWS ? "n/a" : getSocketPath(config.daemon.socketPath)}\n`);
-  process.stdout.write(`Log path: ${config.daemon.logFilePath}\n`);
-  process.stdout.write(`Log file enabled: ${config.daemon.logFileEnabled}\n`);
-  process.stdout.write(`Command timeout ms: ${config.daemon.commandTimeoutMs}\n`);
-  process.stdout.write(`Network timeout ms: ${config.daemon.networkTimeoutMs}\n`);
-  process.stdout.write(`Retention max sessions: ${config.retention.maxSessions}\n`);
-  process.stdout.write(`Retention standalone max age hours: ${config.retention.standaloneMaxAgeHours}\n`);
-  process.stdout.write(`Usage enabled: ${config.usage.enabled}\n`);
-  if (IS_MAC && config.usage.enabled) {
-    process.stdout.write(`Keychain prompts allowed: ${config.usage.auth.allowKeychainPrompts}\n`);
-    process.stdout.write("Keychain items the daemon may read: claude-api-oauth, Claude Code-credentials, Claude Safe Storage, per-browser Safe Storage (Chrome, Brave, Edge, Arc, Vivaldi, Chromium)\n");
-    process.stdout.write("Keychain note: macOS authorization is granted per item — you have about 90 seconds to answer each dialog; click \"Always Allow\" once per item. Successful reads are memoized for the daemon's lifetime, so each item prompts at most once per daemon run, and an unanswered dialog retries after 10 minutes. Set usage.auth.allowKeychainPrompts to false to suppress all keychain prompts.\n");
-
-    const claudeCredential = await claudeCredentialState(daemonFetch);
-    if (claudeCredential?.state === "valid") {
-      process.stdout.write("Claude credential: valid (OAuth session active)\n");
-    } else if (claudeCredential?.state === "expired") {
-      process.stdout.write("Claude credential: expired — run \"claude\" and log in to refresh, then restart the daemon\n");
-    } else if (claudeCredential?.state === "missing") {
-      process.stdout.write("Claude credential: not found — run \"claude\" and log in to enable the Claude OAuth usage source\n");
-    }
-  }
-
-  try {
-    const health = await daemonFetch("/api/health");
-    process.stdout.write(`Local daemon reachable: ${health.ok}\n`);
-    if (health.ok) {
-      const body = await health.json().catch(() => ({})) as { version?: string };
-      process.stdout.write(formatVersionDiagnostics(getInstalledVersion(), body.version));
-    } else {
-      process.stdout.write(`CLI version: ${getInstalledVersion()}\n`);
-    }
-  } catch {
-    process.stdout.write("Local daemon reachable: false\n");
-    process.stdout.write(`CLI version: ${getInstalledVersion()}\n`);
-  }
-
-  process.stdout.write(`TCP API enabled: ${config.api.tcpEnabled}\n`);
-  process.stdout.write(`API bearer token configured: ${Boolean(config.api.bearerToken)}\n`);
-  if (config.api.tcpEnabled) {
-    try {
-      const response = await fetch(`http://${config.api.host}:${config.api.port}/api/health`);
-      process.stdout.write(`TCP API reachable: ${response.ok}\n`);
-    } catch {
-      process.stdout.write("TCP API reachable: false\n");
-    }
-    if (config.api.bearerToken) {
-      try {
-        const response = await fetch(`http://${config.api.host}:${config.api.port}/api/status`, {
-          headers: { Authorization: `Bearer ${config.api.bearerToken}` },
-        });
-        process.stdout.write(`TCP API auth test: ${response.ok}\n`);
-      } catch {
-        process.stdout.write("TCP API auth test: false\n");
-      }
-    }
-  }
-
-  process.stdout.write(`CORS enabled: ${config.cors.enabled}\n`);
-  if (config.cors.enabled) {
-    process.stdout.write(`CORS origins: ${config.cors.origins.join(", ")}\n`);
-  }
-
-  const graphics = await probeTerminalGraphics();
-  const advice = adviseProviderIcons(graphics);
-  process.stdout.write("\nTerminal graphics:\n");
-  if (graphics.probeFailed) {
-    const reason = graphics.probeFailedReason === "raw-unavailable"
-      ? "raw mode is unavailable in this stdin (try the interactive scrylog binary)"
-      : graphics.probeFailedReason === "no-answer"
-      ? "the terminal did not answer any probe (graphics detection is unknown)"
-      : "stdin is not an interactive TTY — attach one to test";
-    process.stdout.write(`  Probe: unavailable (${reason})\n`);
-  } else {
-    process.stdout.write(`  Terminal: ${graphics.terminalName ?? "(no XTVERSION response)"}\n`);
-    process.stdout.write(`  TERM: ${graphics.term ?? "(unset)"}\n`);
-    process.stdout.write(`  Multiplexer: ${graphics.multiplexer}\n`);
-    process.stdout.write(`  Kitty graphics: ${graphics.kittyGraphics}\n`);
-    process.stdout.write(`  Sixel: ${graphics.sixel}\n`);
-    process.stdout.write(`  Window pixel resolution: ${graphics.pixelResolution ? `${graphics.pixelResolution.width}x${graphics.pixelResolution.height}` : "(not reported)"}\n`);
-  }
-  process.stdout.write(`  providerIcons config: ${config.tui.providerIcons}\n`);
-  process.stdout.write(`  Recommended providerIcons: ${graphics.probeFailed ? `run again from an interactive terminal (${advice} is the safe default)` : advice}\n`);
-
-  process.stdout.write(`MCP HTTP enabled: ${config.mcp.httpEnabled}\n`);
-  if (config.mcp.httpEnabled) {
-    try {
-      const response = await fetch(`http://${config.mcp.host}:${config.mcp.port}`, {
-        method: "POST",
-        headers: {
-          Accept: "application/json, text/event-stream",
-          "Content-Type": "application/json",
-          ...(config.mcp.bearerToken ? { Authorization: `Bearer ${config.mcp.bearerToken}` } : {}),
-        },
-        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "ping", params: {} }),
-      });
-      process.stdout.write(`MCP HTTP reachable: ${response.status >= 200 && response.status < 500}\n`);
-      process.stdout.write(`MCP bearer token configured: ${Boolean(config.mcp.bearerToken)}\n`);
-    } catch {
-      process.stdout.write("MCP HTTP reachable: false\n");
-    }
-  }
-
-  try {
-    const manager = getServiceManagerOrThrow();
-    const status = manager.status();
-    process.stdout.write(`Service platform: ${status.platform}\nInstalled: ${status.installed}\nRunning: ${status.running}\n`);
-  } catch (error) {
-    process.stdout.write(`Service manager: ${error instanceof Error ? error.message : String(error)}\n`);
-  }
-
-  const tmux = Bun.spawnSync(["tmux", "-V"], { stdout: "pipe", stderr: "pipe" });
-  process.stdout.write(`tmux available: ${tmux.exitCode === 0}\n`);
-  process.stdout.write(`herdr available: ${await isHerdrAvailable(config.daemon.commandTimeoutMs)}\n`);
-
-  if (config.opencode.mode === "hooks") {
-    process.stdout.write("OpenCode mode: hooks\n");
-    const opencodeSettingsPath = join(homedir(), ".config", "opencode", "opencode.json");
-    process.stdout.write(`OpenCode plugin config present: ${existsSync(opencodeSettingsPath)}\n`);
-    let pluginRegistered = false;
-    if (existsSync(opencodeSettingsPath)) {
-      try {
-        const opencodeSettings = JSON.parse(readFileSync(opencodeSettingsPath, "utf8")) as OpenCodeSettings;
-        pluginRegistered = (opencodeSettings.plugin ?? []).some(
-          (plugin) => typeof plugin === "string" && plugin.includes(OPENCODE_PLUGIN_NAME),
-        );
-      } catch {
-        // ignore parse errors; pluginRegistered stays false
-      }
-    }
-    process.stdout.write(`OpenCode plugin registered: ${pluginRegistered}\n`);
-  } else {
-    process.stdout.write(`OpenCode mode: sse\nOpenCode auto-discover: ${config.opencode.autoDiscover}\nConfigured instances: ${config.opencode.instances.length}\n`);
-  }
-
-  process.stdout.write(`Claude hooks enabled: ${config.claude.hooksEnabled}\n`);
-  if (config.claude.hooksEnabled) {
-    const claudeSettingsPath = join(homedir(), ".claude", "settings.json");
-    process.stdout.write(`Claude settings config present: ${existsSync(claudeSettingsPath)}\n`);
-  }
-
-  process.stdout.write(`Codex hooks enabled: ${config.codex.hooksEnabled}\n`);
-  if (config.codex.hooksEnabled) {
-    const codexHooksPath = join(homedir(), ".codex", "hooks.json");
-    process.stdout.write(`Codex hooks config present: ${existsSync(codexHooksPath)}\n`);
-  }
-}
-
-export async function runSetupWizard(options: GlobalCliOptions): Promise<void> {
-  const prompt = createPromptSession();
-  try {
-    const resolvedPath = getResolvedConfigPath(options.configPath);
-    const current = loadConfig(options.configPath);
-    process.stdout.write(`Config path: ${resolvedPath}\n`);
-
-    const configureOpenCode = await prompt.yesNo("Configure OpenCode now?", false);
-    let next: ScrylogConfig = { ...current, api: { ...current.api }, mcp: { ...current.mcp }, opencode: { ...current.opencode }, daemon: { ...current.daemon }, cors: { ...current.cors }, retention: { ...current.retention }, usage: { ...current.usage } };
-
-    if (configureOpenCode) {
-      const mode = await prompt.choose("Select OpenCode mode", ["hooks", "sse"], current.opencode.mode === "hooks" ? 0 : 1);
-      next.opencode.mode = mode as "hooks" | "sse";
-      if (mode === "sse") {
-        next.opencode.autoDiscover = await prompt.yesNo("Enable OpenCode auto-discovery?", current.opencode.autoDiscover);
-        const instances = await prompt.text("Comma-separated OpenCode instance URLs", current.opencode.instances.join(","));
-        next.opencode.instances = instances
-          .split(",")
-          .map((value) => value.trim())
-          .filter(Boolean);
-      } else {
-        process.stdout.write("Hooks mode requires the @scrylog/opencode-plugin plugin in your OpenCode config.\n");
-        const installPlugin = await prompt.yesNo("Run scrylog opencode hooks install now?", false);
-        if (installPlugin) {
-          await runOpenCodeHooksInstall(options);
-        }
-      }
-    }
-
-    if (isClaudeHooksInstalled()) {
-      process.stdout.write("Claude hooks already installed.\n");
-    } else {
-      const installClaude = await prompt.yesNo("Install Claude hooks now?", false);
-      if (installClaude) {
-        await runClaudeHooksInstall(options);
-      }
-    }
-
-    if (isCodexHooksInstalled()) {
-      process.stdout.write("Codex hooks already installed.\n");
-    } else {
-      const installCodex = await prompt.yesNo("Install Codex hooks now?", false);
-      if (installCodex) {
-        await runCodexHooksInstall(options);
-      }
-    }
-
-    const pollInterval = await prompt.text("Daemon poll interval (ms)", String(current.daemon.pollIntervalMs));
-    const logLevel = await prompt.choose("Daemon log level", ["debug", "info", "warn", "error"], ["debug", "info", "warn", "error"].indexOf(current.daemon.logLevel));
-    next.daemon.pollIntervalMs = parseOptionalInt(pollInterval, current.daemon.pollIntervalMs);
-    next.daemon.logLevel = logLevel as ScrylogConfig["daemon"]["logLevel"];
-    next.daemon.commandTimeoutMs = parseOptionalInt(await prompt.text("Command timeout (ms)", String(current.daemon.commandTimeoutMs)), current.daemon.commandTimeoutMs);
-    next.daemon.networkTimeoutMs = parseOptionalInt(await prompt.text("Network timeout (ms)", String(current.daemon.networkTimeoutMs)), current.daemon.networkTimeoutMs);
-    const socketPath = await prompt.text("Unix socket path (blank = default)", current.daemon.socketPath ?? "");
-    next.daemon.socketPath = socketPath.trim() || undefined;
-
-    next.retention.maxSessions = parseOptionalInt(await prompt.text("Retention max sessions", String(current.retention.maxSessions)), current.retention.maxSessions);
-    next.retention.standaloneMaxAgeHours = parseOptionalInt(await prompt.text("Retention standalone max age (hours, 0 = disabled)", String(current.retention.standaloneMaxAgeHours)), current.retention.standaloneMaxAgeHours);
-    next.usage.enabled = await prompt.yesNo("Enable usage collection?", current.usage.enabled);
-
-    next.api.tcpEnabled = await prompt.yesNo("Enable TCP API listener?", current.api.tcpEnabled);
-    if (next.api.tcpEnabled) {
-      next.api.host = await prompt.text("TCP API host", current.api.host);
-      next.api.port = parseOptionalInt(await prompt.text("TCP API port", String(current.api.port)), current.api.port);
-      const tokenAction = await prompt.choose("API bearer token", ["generate", "keep current", "clear"], current.api.bearerToken ? 1 : 0);
-      if (tokenAction === "generate") {
-        next.api.bearerToken = generateToken();
-        process.stdout.write(`Generated API token: ${next.api.bearerToken}\n`);
-      } else if (tokenAction === "clear") {
-        next.api.bearerToken = undefined;
-      }
-    }
-
-    next.cors.enabled = await prompt.yesNo("Enable CORS for browser access?", current.cors.enabled);
-    if (next.cors.enabled) {
-      const originsRaw = await prompt.text("Allowed origins (comma-separated, or * for all)", current.cors.origins.join(",") || "*");
-      next.cors.origins = originsRaw === "*"
-        ? ["*"]
-        : originsRaw.split(",").map((s) => s.trim()).filter(Boolean);
-      next.cors.credentials = await prompt.yesNo("Allow credentials in CORS requests?", current.cors.credentials);
-    }
-
-    next.mcp.httpEnabled = await prompt.yesNo("Enable MCP HTTP listener?", current.mcp.httpEnabled);
-    if (next.mcp.httpEnabled) {
-      next.mcp.host = await prompt.text("MCP HTTP host", current.mcp.host);
-      next.mcp.port = parseOptionalInt(await prompt.text("MCP HTTP port", String(current.mcp.port)), current.mcp.port);
-      const tokenAction = await prompt.choose("MCP token", ["generate", "keep current", "clear"], current.mcp.bearerToken ? 1 : 0);
-      if (tokenAction === "generate") {
-        next.mcp.bearerToken = generateToken();
-        process.stdout.write(`Generated MCP token: ${next.mcp.bearerToken}\n`);
-      } else if (tokenAction === "clear") {
-        next.mcp.bearerToken = undefined;
-      }
-    }
-
-    updateConfig(() => next, options.configPath);
-    process.stdout.write(`Wrote config to ${resolvedPath}\n`);
-
-    const installService = await prompt.yesNo("Install daemon as a user service?", true);
-    if (installService) {
-      const manager = getServiceManagerOrThrow();
-      manager.install(options.configPath);
-      process.stdout.write("Installed daemon service.\n");
-      if (await prompt.yesNo("Start or restart the service now?", true)) {
-        manager.restart();
-        process.stdout.write("Service restarted.\n");
-      }
-    }
-
-    await runDoctor(options);
-  } finally {
-    prompt.close();
-  }
-}
-
-export function generateToken(): string {
-  return randomBytes(24).toString("base64url");
-}
-
-function parseOptionalInt(value: string, fallback: number): number {
-  const parsed = Number.parseInt(value, 10);
-  return Number.isNaN(parsed) ? fallback : parsed;
-}
-
-const OPENCODE_PLUGIN_NAME = "@scrylog/opencode-plugin";
-
-export function isClaudeHooksInstalled(homeDir = homedir()): boolean {
-  const settingsPath = join(homeDir, ".claude", "settings.json");
-  if (!existsSync(settingsPath)) return false;
-  try {
-    const settings = JSON.parse(readFileSync(settingsPath, "utf8")) as ClaudeSettings;
-    const hooks = settings.hooks ?? {};
-    return Object.values(hooks).some((rules) =>
-      rules.some((rule) =>
-        rule.hooks.some((h) => typeof h.command === "string" && h.command.includes("scrylog-claude-hook")),
-      ),
-    );
-  } catch {
-    return false;
-  }
-}
-
-export function isCodexHooksInstalled(homeDir = homedir()): boolean {
-  const codexDir = process.env.CODEX_HOME ? process.env.CODEX_HOME : join(homeDir, ".codex");
-  const hooksPath = join(codexDir, "hooks.json");
-  if (!existsSync(hooksPath)) return false;
-  try {
-    const config = JSON.parse(readFileSync(hooksPath, "utf8")) as CodexHooksConfig;
-    const hooks = config.hooks ?? {};
-    return Object.values(hooks).some((rules) =>
-      rules.some((rule) =>
-        rule.hooks.some((h) => typeof h.command === "string" && h.command.includes("scrylog-codex-hook")),
-      ),
-    );
-  } catch {
-    return false;
-  }
-}
-
-export function isOpencodePluginRegistered(homeDir = homedir()): boolean {
-  const settingsPath = join(homeDir, ".config", "opencode", "opencode.json");
-  if (!existsSync(settingsPath)) return false;
-  try {
-    const settings = JSON.parse(readFileSync(settingsPath, "utf8")) as OpenCodeSettings;
-    return (settings.plugin ?? []).some(
-      (plugin) => typeof plugin === "string" && plugin.includes(OPENCODE_PLUGIN_NAME),
-    );
-  } catch {
-    return false;
-  }
-}
-
-function backupBeforeWrite(path: string): void {
-  if (!existsSync(path)) return;
-  const bak = `${path}.bak`;
-  copyFileSync(path, bak);
-}
-
-interface OpenCodeSettings {
-  plugin?: string[];
-  [key: string]: unknown;
-}
-
-// ── Claude hooks setup ────────────────────────────────────────────────────────
-
-const CLAUDE_HOOK_EVENTS = [
-  "SessionStart",
-  "SessionEnd",
-  "UserPromptSubmit",
-  "PreToolUse",
-  "PermissionRequest",
-  "PermissionDenied",
-  "PostToolUse",
-  "PostToolUseFailure",
-  "PostToolBatch",
-  "Stop",
-  "StopFailure",
-  "SubagentStart",
-  "SubagentStop",
-  "CwdChanged",
-] as const;
-
-interface ClaudeSettingsHookEntry {
-  type: "command";
-  command: string;
-}
-
-interface ClaudeSettingsHookRule {
-  matcher: string;
-  hooks: ClaudeSettingsHookEntry[];
-}
-
-interface ClaudeSettings {
-  hooks?: Record<string, ClaudeSettingsHookRule[]>;
-  [key: string]: unknown;
-}
-
-export async function runClaudeHooksInstall(options: GlobalCliOptions): Promise<void> {
-  const claudeDir = join(homedir(), ".claude");
-  const settingsPath = join(claudeDir, "settings.json");
-
-  // Verify scrylog-claude-hook is in PATH
-  const hookBin = whichCommand("scrylog-claude-hook") ?? "scrylog-claude-hook";
-  const hookBinFound = hookBin !== "scrylog-claude-hook";
-
-  if (!hookBinFound) {
-    process.stderr.write(
-      "Warning: scrylog-claude-hook not found in PATH. Make sure it is installed before Claude Code runs hooks.\n",
-    );
-  }
-
-  // Load or create settings.json
-  let settings: ClaudeSettings = {};
-  if (existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(readFileSync(settingsPath, "utf8")) as ClaudeSettings;
-    } catch {
-      process.stderr.write(`Warning: could not parse ${settingsPath} — starting with empty settings.\n`);
-    }
-  } else {
-    mkdirSync(claudeDir, { recursive: true });
-  }
-
-  if (isClaudeHooksInstalled()) {
-    process.stdout.write("Claude hooks are already installed.\n");
-    return;
-  }
-
-  // Merge hooks — add scrylog entries without removing existing ones
-  const existingHooks = settings.hooks ?? {};
-  const updatedHooks: Record<string, ClaudeSettingsHookRule[]> = { ...existingHooks };
-
-  for (const event of CLAUDE_HOOK_EVENTS) {
-    const existing = updatedHooks[event] ?? [];
-    updatedHooks[event] = [
-      ...existing,
-      { matcher: "", hooks: [{ type: "command", command: hookBin }] },
-    ];
-  }
-
-  settings.hooks = updatedHooks;
-
-  // Write atomically with backup
-  backupBeforeWrite(settingsPath);
-  const tmp = `${settingsPath}.tmp`;
-  writeFileSync(tmp, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
-  renameSync(tmp, settingsPath);
-
-  process.stdout.write(`Wrote Claude hooks to ${settingsPath}\n`);
-  process.stdout.write(`Hooks installed: ${CLAUDE_HOOK_EVENTS.join(", ")}\n`);
-  process.stdout.write(`Hook command: ${hookBin}\n`);
-
-  // Enable hooksEnabled in scrylog config
-  const { path: configPath } = updateConfig(
-    (current) => ({ ...current, claude: { ...current.claude, hooksEnabled: true } }),
-    options.configPath,
-  );
-  process.stdout.write(`Enabled claude.hooksEnabled in scrylog config: ${configPath}\n`);
-  process.stdout.write("Done. Restart the scrylog daemon to apply changes.\n");
-}
-
-// ── Codex hooks setup ─────────────────────────────────────────────────────────
-
-const CODEX_HOOK_EVENTS = [
-  "SessionStart",
-  "PreToolUse",
-  "PermissionRequest",
-  "PostToolUse",
-  "UserPromptSubmit",
-  "SubagentStart",
-  "SubagentStop",
-  "Stop",
-] as const;
-
-interface CodexHookEntry {
-  type: "command";
-  command: string;
-  timeout?: number;
-}
-
-interface CodexHookRule {
-  matcher?: string;
-  hooks: CodexHookEntry[];
-}
-
-interface CodexHooksConfig {
-  hooks?: Record<string, CodexHookRule[]>;
-  [key: string]: unknown;
-}
-
-export async function runCodexHooksInstall(options: GlobalCliOptions): Promise<void> {
-  const codexDir = process.env.CODEX_HOME ? process.env.CODEX_HOME : join(homedir(), ".codex");
-  const hooksPath = join(codexDir, "hooks.json");
-
-  // Verify scrylog-codex-hook is in PATH
-  const hookBin = whichCommand("scrylog-codex-hook") ?? "scrylog-codex-hook";
-  const hookBinFound = hookBin !== "scrylog-codex-hook";
-
-  if (!hookBinFound) {
-    process.stderr.write(
-      "Warning: scrylog-codex-hook not found in PATH. Make sure it is installed before Codex CLI runs hooks.\n",
-    );
-  }
-
-  // Load or create hooks.json
-  let config: CodexHooksConfig = {};
-  if (existsSync(hooksPath)) {
-    try {
-      config = JSON.parse(readFileSync(hooksPath, "utf8")) as CodexHooksConfig;
-    } catch {
-      process.stderr.write(`Warning: could not parse ${hooksPath} — starting with empty config.\n`);
-    }
-  } else {
-    mkdirSync(codexDir, { recursive: true });
-  }
-
-  if (isCodexHooksInstalled()) {
-    process.stdout.write("Codex hooks are already installed.\n");
-    return;
-  }
-
-  // Merge hooks — add scrylog entries without removing existing ones
-  const existingHooks = config.hooks ?? {};
-  const updatedHooks: Record<string, CodexHookRule[]> = { ...existingHooks };
-
-  for (const event of CODEX_HOOK_EVENTS) {
-    const existing = updatedHooks[event] ?? [];
-    const entry: CodexHookRule = {
-      matcher: event === "UserPromptSubmit" || event === "Stop" ? undefined : "",
-      hooks: [{ type: "command", command: hookBin, ...(event === "Stop" ? { timeout: 30 } : {}) }],
-    };
-    updatedHooks[event] = [...existing, entry];
-  }
-
-  config.hooks = updatedHooks;
-
-  // Write atomically with backup
-  backupBeforeWrite(hooksPath);
-  const tmp = `${hooksPath}.tmp`;
-  writeFileSync(tmp, `${JSON.stringify(config, null, 2)}\n`, "utf8");
-  renameSync(tmp, hooksPath);
-
-  process.stdout.write(`Wrote Codex hooks to ${hooksPath}\n`);
-  process.stdout.write(`Hooks installed: ${CODEX_HOOK_EVENTS.join(", ")}\n`);
-  process.stdout.write(`Hook command: ${hookBin}\n`);
-
-  // Enable hooksEnabled in scrylog config
-  const { path: configPath } = updateConfig(
-    (current) => ({ ...current, codex: { ...current.codex, hooksEnabled: true } }),
-    options.configPath,
-  );
-  process.stdout.write(`Enabled codex.hooksEnabled in scrylog config: ${configPath}\n`);
-  process.stdout.write("Done. Restart the scrylog daemon to apply changes.\n");
-}
-
-// ── OpenCode hooks setup ──────────────────────────────────────────────────────
-
-export async function runOpenCodeHooksInstall(options: GlobalCliOptions): Promise<void> {
-  const opencodeDir = join(homedir(), ".config", "opencode");
-  const settingsPath = join(opencodeDir, "opencode.json");
-
-  // Load or create opencode.json
-  let settings: OpenCodeSettings = {};
-  if (existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(readFileSync(settingsPath, "utf8")) as OpenCodeSettings;
-    } catch {
-      process.stderr.write(`Warning: could not parse ${settingsPath} — starting with empty settings.\n`);
-    }
-  } else {
-    mkdirSync(opencodeDir, { recursive: true });
-  }
-
-  // Merge plugin entry without removing existing ones
-  const existingPlugins = settings.plugin ?? [];
-  const alreadyInstalled = isOpencodePluginRegistered();
-
-  if (!alreadyInstalled) {
-    settings.plugin = [...existingPlugins, OPENCODE_PLUGIN_NAME];
-
-    // Write atomically with backup
-    backupBeforeWrite(settingsPath);
-    const tmp = `${settingsPath}.tmp`;
-    writeFileSync(tmp, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
-    renameSync(tmp, settingsPath);
-    process.stdout.write(`Registered ${OPENCODE_PLUGIN_NAME} in ${settingsPath}\n`);
-  } else {
-    process.stdout.write(`${OPENCODE_PLUGIN_NAME} is already registered in ${settingsPath}\n`);
-  }
-
-  process.stdout.write("Done. Make sure the plugin is installed globally and restart OpenCode.\n");
-}