@scrylog/cli 0.2.0 → 0.3.1

package/src/cli/commands.ts

@@ -1,632 +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 { IS_WINDOWS, whichCommand } from "../shared/platform";
-
-export interface GlobalCliOptions {
-  configPath?: string;
-}
-
-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`);
-}
-
-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`);
-
-  try {
-    const health = await daemonFetch("/api/health");
-    process.stdout.write(`Local daemon reachable: ${health.ok}\n`);
-  } catch {
-    process.stdout.write("Local daemon reachable: false\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`);
-  }
-
-  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`);
-
-  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");
-}

package/src/cli/prompt.ts

@@ -1,44 +0,0 @@
-import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
-
-export interface PromptSession {
-  text(message: string, defaultValue?: string): Promise<string>;
-  yesNo(message: string, defaultValue?: boolean): Promise<boolean>;
-  choose(message: string, options: string[], defaultIndex?: number): Promise<string>;
-  close(): void;
-}
-
-export function createPromptSession(): PromptSession {
-  const rl = createInterface({ input, output });
-
-  return {
-    async text(message: string, defaultValue?: string): Promise<string> {
-      const suffix = defaultValue !== undefined ? ` [${defaultValue}]` : "";
-      const answer = (await rl.question(`${message}${suffix}: `)).trim();
-      return answer || defaultValue || "";
-    },
-    async yesNo(message: string, defaultValue = true): Promise<boolean> {
-      const label = defaultValue ? "Y/n" : "y/N";
-      const answer = (await rl.question(`${message} [${label}]: `)).trim().toLowerCase();
-      if (!answer) return defaultValue;
-      return answer === "y" || answer === "yes";
-    },
-    async choose(message: string, options: string[], defaultIndex = 0): Promise<string> {
-      output.write(`${message}\n`);
-      for (const [index, option] of options.entries()) {
-        output.write(`  ${index + 1}. ${option}\n`);
-      }
-      while (true) {
-        const answer = (await rl.question(`Select [${defaultIndex + 1}]: `)).trim();
-        const value = answer || String(defaultIndex + 1);
-        const index = Number.parseInt(value, 10) - 1;
-        if (!Number.isNaN(index) && index >= 0 && index < options.length) {
-          return options[index]!;
-        }
-      }
-    },
-    close(): void {
-      rl.close();
-    },
-  };
-}