@scrylog/cli 0.1.0

package/src/cli/commands.ts

@@ -0,0 +1,498 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } 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(): 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");
+    process.stdout.write(`OpenCode plugin config present: ${existsSync(join(homedir(), ".config", "opencode", "opencode.json"))}\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 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;
+}
+
+// ── 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 });
+  }
+
+  // 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] ?? [];
+    const alreadyInstalled = existing.some((rule) =>
+      rule.hooks.some((h) => h.command === hookBin || h.command === "scrylog-claude-hook"),
+    );
+    if (!alreadyInstalled) {
+      updatedHooks[event] = [
+        ...existing,
+        { matcher: "", hooks: [{ type: "command", command: hookBin }] },
+      ];
+    }
+  }
+
+  settings.hooks = updatedHooks;
+
+  // Write atomically
+  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 });
+  }
+
+  // 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 alreadyInstalled = existing.some((rule) =>
+      rule.hooks.some((h) => h.command === hookBin || h.command === "scrylog-codex-hook"),
+    );
+    if (!alreadyInstalled) {
+      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
+  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");
+}

package/src/cli/prompt.ts

@@ -0,0 +1,44 @@
+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();
+    },
+  };
+}

package/src/daemon/cli.ts

@@ -0,0 +1,27 @@
+export interface DaemonCliOptions {
+  help: boolean;
+  configPath?: string;
+  logLevel?: string;
+  logFormat?: "pretty" | "json";
+  logFileEnabled: boolean;
+}
+
+export function parseDaemonArgs(args: string[]): DaemonCliOptions {
+  const configFlagIndex = args.indexOf("--config");
+  const logLevelFlagIndex = args.indexOf("--log-level");
+  const logFormatFlagIndex = args.indexOf("--log-format");
+  const rawLogFormat = logFormatFlagIndex >= 0 ? args[logFormatFlagIndex + 1] : undefined;
+  const logFormat = rawLogFormat === "pretty" || rawLogFormat === "json" ? rawLogFormat : undefined;
+
+  if (logFormatFlagIndex >= 0 && rawLogFormat !== "pretty" && rawLogFormat !== "json") {
+    throw new Error("--log-format must be 'pretty' or 'json'");
+  }
+
+  return {
+    help: args.includes("--help") || args.includes("-h"),
+    configPath: configFlagIndex >= 0 ? args[configFlagIndex + 1] : undefined,
+    logLevel: logLevelFlagIndex >= 0 ? args[logLevelFlagIndex + 1] : undefined,
+    logFormat,
+    logFileEnabled: !args.includes("--no-log-file"),
+  };
+}

package/src/daemon/collectors/claude/README.md

@@ -0,0 +1,108 @@
+# Claude Collector
+
+Monitors Claude Code interactive sessions by reading JSONL transcript files and
+optional hook files emitted by the `scrylog-claude-hook` binary.
+
+## Data Flow
+
+```
+  ~/.claude/projects/<slug>/<sessionId>.jsonl   ~/.claude/hooks/<sessionId>.json
+         │                                               │
+         │                                               │
+         ▼                                               ▼
+  ┌──────────────┐                                ┌──────────────┐
+  │  discovery   │  discoverTranscripts()         │    hooks     │  readHookData()
+  │              │                                │              │
+  └──────┬───────┘                                └──────┬───────┘
+         │                                               │
+         │                                               │
+         ▼                                               │
+  ┌──────────────┐                                       │
+  │     jsonl    │  parseJsonlFile() / parseJsonlHead()   │
+  └──────┬───────┘                                       │
+         │                                               │
+         ▼                                               │
+  ┌──────────────┐                                       │
+  │  transcript  │  inferState()                         │
+  │              │  extractSummary()                     │
+  │              │  extractTitle()                       │
+  │              │  isLocalCommandTranscript()           │
+  └──────┬───────┘                                       │
+         │                                               │
+         ▼                                               ▼
+  ┌──────────────────────────────────────────────────────────────┐
+  │                        collector.ts                          │
+  │                                                              │
+  │   ┌──────────────┐      ┌──────────────┐      ┌──────────┐  │
+  │   │ 30s poll     │      │ watchFile    │      │ fs.watch │  │
+  │   │ run()        │      │ (2s interval)│      │ hooksDir │  │
+  │   └──────┬───────┘      └──────┬───────┘      └────┬─────┘  │
+  │          │                     │                    │        │
+  │          │                     │                    │        │
+  │          └────────────┬────────┴────────────────────┘        │
+  │                       │                                       │
+  │                       ▼                                       │
+  │              processTranscript()                                │
+  │                       │                                       │
+  │                       │  ┌───────────────────────────────┐   │
+  │                       └──│ mergeHookIntoModel()          │   │
+  │                          │ (if hook newer than transcript)│   │
+  │                          └───────────────────────────────┘   │
+  │                       │                                       │
+  │                       ▼                                       │
+  │              store.upsertSession()                              │
+  │              store.syncChildSessionIds()                        │
+  └──────────────────────────────────────────────────────────────┘
+         │
+         ▼
+    DaemonStore ──► /api/events SSE ──► TUI
+```
+
+## Modules
+
+| File | Responsibility | Key Exports |
+|------|-------------|-------------|
+| `discovery.ts` | Scan `~/.claude/projects/<slug>/` for `.jsonl` files; decode slug back to absolute path | `discoverTranscripts()`, `decodeClaudeProjectSlug()`, `getClaudeDir()`, `getClaudeProcessPids()` |
+| `jsonl.ts` | Read JSONL tail/head with byte-size limits; parse lines into typed entries | `parseJsonlFile()`, `parseJsonlHead()`, `readTextTail()`, `readTextHead()`, `JsonlEntry`, `ContentBlock` |
+| `transcript.ts` | Infer session state from the last meaningful turn; extract summary/title; detect headless `claude -p` transcripts | `inferState()`, `extractSummary()`, `extractTitle()`, `isLocalCommandTranscript()`, `isQuestionText()` |
+| `hooks.ts` | Read/validate hook JSON files; merge hook data into a session model; merge claude metadata without overwriting existing fields | `readHookData()`, `mergeHookIntoModel()`, `mergeClaudeMeta()`, `isHookNewer()`, `getHookTime()`, `isValidHookData()`, `hasClaudePermissionPrompt()`, `ClaudeHookFileData` |
+| `collector.ts` | Orchestrate discovery, transcript watching, hook watching, deduplication, and store writes | `ClaudeCollector` (implements `Collector`) |
+| `index.ts` | Public re-exports | `ClaudeCollector`, test-accessible pure functions |
+
+## State Inference Rules (`transcript.ts`)
+
+`inferState()` walks the JSONL entries in reverse order looking for the last
+**meaningful** turn, skipping:
+1. Synthetic user entries (tool results, "[Request interrupted by user]")
+2. Thinking-only assistant entries
+3. System/tool events without a role
+
+| Last meaningful turn | State | Reason |
+|----------------------|-------|--------|
+| `assistant` with question text | `waiting-input` | Claude is asking the user something |
+| `assistant` with visible text, no tool_use | `idle` | Claude has replied |
+| `assistant` with tool_use, no visible text | `working` | Claude is executing a tool |
+| `user` (non-synthetic) | `working` | Waiting for Claude's reply |
+| Empty / only synthetic entries | `idle` | Nothing meaningful happened |
+
+## Hook Merge Priority
+
+When both transcript and hook data exist, the collector uses this priority:
+
+1. **Hook newer** (`hookSeq` or `hookEventTime` >= existing): hook data wins for `state`, `hasAttention`, `summary`, `activeTool`
+2. **Hook older**: transcript data wins (except `claude` metadata merged via `mergeClaudeMeta`)
+3. **Hook-managed session** (`detectionSource === "claude-hook"`): transcript can only fill missing metadata (e.g. `transcriptPath`), never override state
+
+## Interactions
+
+| Component | How |
+|-----------|-----|
+| `GitCollector` | Resolves `currentPath` → `project` when hooks/transcript provide a directory |
+| `DaemonStore` | Upserts sessions; clears old bindings via `syncChildSessionIds()` |
+| `Scheduler` | Calls `start()` → sets up `30s` discovery interval + `5s` fallback re-read |
+| `TUI` | Receives updates via SSE from the store |
+
+## Detection Sources Produced
+
+- `"claude-transcript"` — session discovered from `.jsonl` file, state inferred from transcript content
+- `"claude-hook"` — session discovered/enriched from hook JSON, state is authoritative from Claude Code directly