@scrylog/cli 0.1.0

package/src/hooks/claude.ts

@@ -0,0 +1,596 @@
+#!/usr/bin/env bun
+/**
+ * scrylog-claude-hook — Claude Code lifecycle hook handler.
+ *
+ * Claude Code calls this binary at each lifecycle event (Stop, PreToolUse,
+ * PostToolUse, Notification, SubagentStop) with a JSON payload on stdin.
+ * This script writes a state file for the ClaudeCollector to pick up and,
+ * when running inside tmux, sets the @claude-session pane option so the
+ * TmuxCollector can link the pane to the Claude session.
+ *
+ * Configure in ~/.claude/settings.json via:
+ *   scrylog claude hooks install
+ */
+
+import { writeFileSync, renameSync, readFileSync, existsSync, rmSync } from "node:fs";
+import { join, basename } from "node:path";
+import { spawnSync } from "node:child_process";
+import { getHooksDir, ensureHooksDirSafe } from "../shared/platform";
+import type { SessionState } from "../shared/types";
+
+type AttentionKind = "permission" | "question" | "turn" | "none";
+type ToolResultStatus = "started" | "completed" | "error" | "blocked" | "denied" | "unknown";
+
+// ── Hook payload ──────────────────────────────────────────────────────────────
+
+interface ClaudeHookPayload {
+  session_id: string;
+  transcript_path?: string;
+  cwd?: string;
+  permission_mode?: string;
+  hook_event_name?: string;
+  source?: string;
+  model?: string;
+  prompt?: string;
+  stop_hook_active?: boolean;
+  last_assistant_message?: string;
+  // PreToolUse / PostToolUse
+  tool_name?: string;
+  tool_input?: Record<string, unknown>;
+  tool_response?: unknown;
+  tool_use_id?: string;
+  duration_ms?: number;
+  error?: string;
+  error_details?: string;
+  is_interrupt?: boolean;
+  reason?: string;
+  old_cwd?: string;
+  new_cwd?: string;
+  permission_suggestions?: unknown[];
+  tool_calls?: Array<{
+    tool_name?: string;
+    tool_input?: Record<string, unknown>;
+    tool_use_id?: string;
+    tool_response?: unknown;
+  }>;
+  // Notification / async events
+  message?: string;
+  title?: string;
+  // Subagents
+  agent_id?: string;
+  agent_type?: string;
+  agent_transcript_path?: string;
+  subagent_session_id?: string;
+  subagent_transcript_path?: string;
+}
+
+interface DerivedHookState {
+  state: SessionState;
+  hasAttention: boolean;
+  attentionKind: AttentionKind;
+  activeTool?: string;
+  toolName?: string;
+  toolInputSummary?: string;
+  toolResultStatus?: ToolResultStatus;
+  summary?: string;
+}
+
+// ── Config resolution ─────────────────────────────────────────────────────────
+
+function resolveHooksDir(): string {
+  const envConfig = process.env["SCRYLOG_CONFIG"];
+  if (envConfig && existsSync(envConfig)) {
+    try {
+      const raw = JSON.parse(readFileSync(envConfig, "utf8")) as Record<string, unknown>;
+      const claude = raw["claude"] as Record<string, unknown> | undefined;
+      if (typeof claude?.["hooksDir"] === "string") return claude["hooksDir"];
+    } catch {
+      // fall through to default
+    }
+  }
+  return getHooksDir("claude-hooks");
+}
+
+function resolveDaemonPort(): number {
+  const envConfig = process.env["SCRYLOG_CONFIG"];
+  if (envConfig && existsSync(envConfig)) {
+    try {
+      const raw = JSON.parse(readFileSync(envConfig, "utf8")) as Record<string, unknown>;
+      const api = raw["api"] as Record<string, unknown> | undefined;
+      if (typeof api?.["port"] === "number") return api["port"] as number;
+    } catch {
+      // fall through to default
+    }
+  }
+  return 7788;
+}
+
+async function tryHttpDelivery(payload: HookStateFile & { sessionId: string }): Promise<boolean> {
+  try {
+    const port = resolveDaemonPort();
+    const res = await fetch(`http://127.0.0.1:${port}/api/webhook/claude`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(1500),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+// ── Transcript inspection ─────────────────────────────────────────────────────
+
+function inferPermissionModeFromTranscript(transcriptPath?: string): string | undefined {
+  if (!transcriptPath) return undefined;
+  try {
+    const content = readFileSync(transcriptPath, "utf8");
+    const lines = content.split(/\r?\n/).filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      let entry: Record<string, unknown>;
+      try {
+        entry = JSON.parse(lines[i]!) as Record<string, unknown>;
+      } catch {
+        continue;
+      }
+      if (entry["type"] !== "permission-mode") continue;
+      const mode = entry["permissionMode"];
+      if (typeof mode === "string" && mode.length > 0) return mode;
+    }
+  } catch {
+    // Ignore transcript read issues
+  }
+  return undefined;
+}
+
+function summarizeToolInput(toolName?: string, input?: Record<string, unknown>): string | undefined {
+  if (!toolName) return undefined;
+  const command = typeof input?.["command"] === "string" ? input["command"].slice(0, 120) : undefined;
+  if (command) return command;
+  const filePath = typeof input?.["file_path"] === "string" ? input["file_path"] : undefined;
+  if (filePath) return filePath;
+  const description = typeof input?.["description"] === "string" ? input["description"] : undefined;
+  if (description) return description.slice(0, 120);
+  return undefined;
+}
+
+function summarizeText(text?: string): string | undefined {
+  if (!text) return undefined;
+  const first = text.trim().split("\n")[0] ?? "";
+  return first.length > 0 ? first.slice(0, 120) : undefined;
+}
+
+function isQuestion(text?: string): boolean {
+  if (!text) return false;
+  const trimmed = text.trim();
+  return /\?/.test(trimmed) || /^(would you|do you|can you|should i|which|what|how|please confirm|shall i|want me to)/i.test(trimmed);
+}
+
+function isInterruptedRequestText(text: string): boolean {
+  return /^\[Request interrupted by user(?: for tool use)?\]$/i.test(text.trim());
+}
+
+function classifyAttention(message?: string, title?: string): AttentionKind {
+  const text = `${title ?? ""} ${message ?? ""}`.trim();
+  if (!text) return "turn";
+  if (/(approval|approve|permission|confirm|proceed|allow)/i.test(text)) return "permission";
+  if (/[?]/.test(text) || /^(would you|do you|can you|should i|which|what|how|shall i|want me to)/i.test(text)) {
+    return "question";
+  }
+  return "turn";
+}
+
+function inferStopState(payload: ClaudeHookPayload): SessionState {
+  if (isQuestion(payload.last_assistant_message)) return "waiting-input";
+  return "idle";
+}
+
+// ── State derivation ──────────────────────────────────────────────────────────
+
+interface PreviousState {
+  state?: SessionState;
+  hasAttention?: boolean;
+  attentionKind?: AttentionKind;
+}
+
+function deriveHookState(event: string, payload: ClaudeHookPayload, previous?: PreviousState | null): DerivedHookState {
+  const toolInputSummary = summarizeToolInput(payload.tool_name, payload.tool_input);
+  switch (event) {
+    case "SessionStart":
+      return {
+        state: "idle",
+        hasAttention: false,
+        attentionKind: "none",
+        summary: payload.source ? `Claude session ${payload.source}` : "Claude session started",
+      };
+    case "UserPromptSubmit":
+      return {
+        state: "working",
+        hasAttention: false,
+        attentionKind: "none",
+        summary: summarizeText(payload.prompt) ?? "Claude is working",
+      };
+    case "PreToolUse":
+      return {
+        state: "working",
+        hasAttention: false,
+        attentionKind: "none",
+        activeTool: payload.tool_name,
+        toolName: payload.tool_name,
+        toolInputSummary,
+        toolResultStatus: "started",
+        summary: payload.tool_name ? `Using ${payload.tool_name}${toolInputSummary ? `: ${toolInputSummary}` : ""}` : undefined,
+      };
+    case "PermissionRequest":
+      return {
+        state: "waiting-input",
+        hasAttention: true,
+        attentionKind: "permission",
+        activeTool: payload.tool_name,
+        toolName: payload.tool_name,
+        toolInputSummary,
+        toolResultStatus: "blocked",
+        summary: payload.tool_name ? `Permission required for ${payload.tool_name}${toolInputSummary ? `: ${toolInputSummary}` : ""}` : "Permission required",
+      };
+    case "PermissionDenied":
+      return {
+        state: "working",
+        hasAttention: false,
+        attentionKind: "none",
+        activeTool: payload.tool_name,
+        toolName: payload.tool_name,
+        toolInputSummary,
+        toolResultStatus: "denied",
+        summary: payload.reason?.slice(0, 120) ?? (payload.tool_name ? `Permission denied for ${payload.tool_name}` : "Permission denied"),
+      };
+    case "PostToolUse":
+      return {
+        state: "working",
+        hasAttention: false,
+        attentionKind: "none",
+        activeTool: payload.tool_name,
+        toolName: payload.tool_name,
+        toolInputSummary,
+        toolResultStatus: typeof payload.tool_response === "object" && payload.tool_response !== null && "is_error" in (payload.tool_response as Record<string, unknown>)
+          ? ((payload.tool_response as Record<string, unknown>)["is_error"] === true ? "error" : "completed")
+          : "completed",
+        summary: payload.tool_name ? `Using ${payload.tool_name}${toolInputSummary ? `: ${toolInputSummary}` : ""}` : undefined,
+      };
+    case "PostToolUseFailure":
+      return {
+        state: payload.is_interrupt ? "idle" : "working",
+        hasAttention: false,
+        attentionKind: "none",
+        activeTool: payload.tool_name,
+        toolName: payload.tool_name,
+        toolInputSummary,
+        toolResultStatus: "error",
+        summary: payload.error?.slice(0, 120) ?? (payload.tool_name ? `Failed ${payload.tool_name}` : "Tool failed"),
+      };
+    case "PostToolBatch":
+      return {
+        state: "working",
+        hasAttention: false,
+        attentionKind: "none",
+        summary: "Processing tool results",
+      };
+    case "Stop": {
+      const state = inferStopState(payload);
+      return {
+        state,
+        hasAttention: state === "waiting-input",
+        attentionKind: state === "waiting-input" ? "question" : "none",
+        summary: summarizeText(payload.last_assistant_message),
+      };
+    }
+    case "StopFailure":
+      return {
+        state: "error",
+        hasAttention: true,
+        attentionKind: "turn",
+        summary: summarizeText(payload.last_assistant_message) ?? payload.error_details?.slice(0, 120) ?? payload.error?.slice(0, 120),
+      };
+    case "CwdChanged":
+      return {
+        state: previous?.state ?? "idle",
+        hasAttention: previous?.hasAttention ?? false,
+        attentionKind: previous?.attentionKind ?? "none",
+      };
+    case "SubagentStart":
+      return {
+        state: "working",
+        hasAttention: false,
+        attentionKind: "none",
+        summary: payload.agent_type ? `Subagent ${payload.agent_type}` : "Subagent started",
+      };
+    case "SubagentStop":
+      return {
+        state: "idle",
+        hasAttention: false,
+        attentionKind: "none",
+        summary: summarizeText(payload.last_assistant_message),
+      };
+    case "SessionEnd":
+      return {
+        state: "idle",
+        hasAttention: false,
+        attentionKind: "none",
+        summary: payload.reason ? `Claude session ended: ${payload.reason}` : "Claude session ended",
+      };
+    case "Notification":
+      return {
+        state: previous?.state ?? "idle",
+        hasAttention: true,
+        attentionKind: classifyAttention(payload.message, payload.title),
+        summary: summarizeText(payload.message ?? payload.title),
+      };
+    default:
+      return {
+        state: previous?.state ?? "idle",
+        hasAttention: previous?.hasAttention ?? false,
+        attentionKind: previous?.attentionKind ?? "none",
+      };
+  }
+}
+
+function deriveSummary(event: string, payload: ClaudeHookPayload): string | undefined {
+  if (event === "UserPromptSubmit" && payload.prompt) {
+    return summarizeText(payload.prompt);
+  }
+  if (event === "SessionStart" && payload.source) {
+    return `Claude session ${payload.source}`;
+  }
+  if (event === "PermissionRequest" && payload.tool_name) {
+    const target = summarizeToolInput(payload.tool_name, payload.tool_input);
+    return `Permission required for ${payload.tool_name}${target ? `: ${target}` : ""}`;
+  }
+  if (event === "PermissionDenied") {
+    return payload.reason?.slice(0, 120);
+  }
+  if ((event === "PreToolUse" || event === "PostToolUse") && payload.tool_name) {
+    const cmd = (payload.tool_input?.["command"] as string | undefined)?.slice(0, 60);
+    return cmd ? `Using ${payload.tool_name}: ${cmd}` : `Using ${payload.tool_name}`;
+  }
+  if (event === "PostToolUseFailure") {
+    return payload.error?.slice(0, 120);
+  }
+  if (event === "Stop" || event === "StopFailure" || event === "SubagentStop") {
+    return summarizeText(payload.last_assistant_message);
+  }
+  if (event === "SessionEnd" && payload.reason) {
+    return `Claude session ended: ${payload.reason}`;
+  }
+  return undefined;
+}
+
+// ── Tmux integration ──────────────────────────────────────────────────────────
+
+function setTmuxPaneOption(sessionId: string): void {
+  const tmuxPane = process.env["TMUX_PANE"];
+  if (!tmuxPane) return;
+
+  const result = spawnSync("tmux", ["set-option", "-p", "-t", tmuxPane, "@claude-session", sessionId], {
+    stdio: "ignore",
+    timeout: 2000,
+  });
+
+  if (result.error || result.status !== 0) {
+    // Non-fatal — tmux may not be available or the pane might have closed
+  }
+}
+
+function clearTmuxPaneOption(): void {
+  const tmuxPane = process.env["TMUX_PANE"];
+  if (!tmuxPane) return;
+
+  spawnSync("tmux", ["set-option", "-up", "-t", tmuxPane, "@claude-session"], {
+    stdio: "ignore",
+    timeout: 2000,
+  });
+}
+
+// ── File writing ──────────────────────────────────────────────────────────────
+
+interface HookStateFile {
+  eventType: string;
+  eventTime: number;
+  hookSeq: number;
+  state: SessionState;
+  hasAttention: boolean;
+  attentionKind: AttentionKind;
+  summary?: string;
+  activeTool?: string;
+  toolName?: string;
+  toolInputSummary?: string;
+  toolResultStatus?: ToolResultStatus;
+  permissionMode?: string;
+  startSource?: string;
+  endReason?: string;
+  errorType?: string;
+  agentId?: string;
+  agentType?: string;
+  transcriptPath?: string;
+  currentPath?: string;
+  lastActivity: number;
+  parentSessionId?: string;
+  detectionSource: "claude-hook";
+}
+
+function readExistingHookState(hooksDir: string, sessionId: string): HookStateFile | null {
+  const path = join(hooksDir, `${sessionId}.json`);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8")) as HookStateFile;
+  } catch {
+    return null;
+  }
+}
+
+function writeHookFile(hooksDir: string, sessionId: string, data: HookStateFile): void {
+  ensureHooksDirSafe(hooksDir);
+  const targetPath = join(hooksDir, `${sessionId}.json`);
+  const tmpPath = join(hooksDir, `${sessionId}.json.tmp`);
+  writeFileSync(tmpPath, JSON.stringify(data), "utf8");
+  try {
+    renameSync(tmpPath, targetPath);
+  } catch {
+    writeFileSync(targetPath, JSON.stringify(data), "utf8");
+  }
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  let raw = "";
+  for await (const chunk of Bun.stdin.stream()) {
+    raw += new TextDecoder().decode(chunk);
+  }
+
+  let payload: ClaudeHookPayload;
+  try {
+    payload = JSON.parse(raw) as ClaudeHookPayload;
+  } catch {
+    process.exit(0); // Malformed input — exit cleanly so Claude Code is not disrupted
+  }
+
+  const event = payload.hook_event_name ?? "";
+  const sessionId = payload.session_id;
+  if (!sessionId) process.exit(0);
+
+  const hooksDir = resolveHooksDir();
+  const now = Date.now();
+
+  if (event === "SessionEnd") {
+    await tryHttpDelivery({
+      sessionId,
+      eventType: event,
+      eventTime: now,
+      hookSeq: 0,
+      state: "idle",
+      hasAttention: false,
+      attentionKind: "none",
+      summary: deriveSummary(event, payload),
+      ...(payload.reason ? { endReason: payload.reason } : {}),
+      ...(payload.transcript_path ? { transcriptPath: payload.transcript_path } : {}),
+      currentPath: payload.cwd,
+      lastActivity: now,
+      detectionSource: "claude-hook",
+    });
+    try {
+      rmSync(join(hooksDir, `${sessionId}.json`), { force: true });
+    } catch {
+      // Ignore cleanup issues
+    }
+    clearTmuxPaneOption();
+    process.exit(0);
+  }
+
+  if (event === "SubagentStart" || event === "SubagentStop") {
+    const subTranscriptPath = payload.agent_transcript_path ?? payload.subagent_transcript_path;
+    const subId = payload.agent_id ?? payload.subagent_session_id ?? (subTranscriptPath ? basename(subTranscriptPath, ".jsonl") : undefined);
+
+    if (subId) {
+      const previous = readExistingHookState(hooksDir, subId);
+      const derived = deriveHookState(event, payload, previous);
+      const subBaseSeq = previous?.hookSeq ?? 0;
+      const subNowMs = Math.floor(Date.now() / 100);
+      const subHookSeq = Math.max(subBaseSeq + 1, subNowMs);
+      const subData: HookStateFile = {
+        eventType: event,
+        eventTime: now,
+        hookSeq: subHookSeq,
+        state: derived.state,
+        hasAttention: derived.hasAttention,
+        attentionKind: derived.attentionKind,
+        ...(derived.summary ?? deriveSummary(event, payload) ? { summary: (derived.summary ?? deriveSummary(event, payload)) } : {}),
+        ...(payload.permission_mode ? { permissionMode: payload.permission_mode } : {}),
+        ...(payload.agent_id ? { agentId: payload.agent_id } : {}),
+        ...(payload.agent_type ? { agentType: payload.agent_type } : {}),
+        ...(subTranscriptPath ? { transcriptPath: subTranscriptPath } : {}),
+        currentPath: payload.cwd,
+        lastActivity: now,
+        parentSessionId: `claude:${sessionId}`,
+        detectionSource: "claude-hook",
+      };
+      writeHookFile(hooksDir, subId, subData);
+      await tryHttpDelivery({ sessionId: subId, ...subData });
+    }
+
+    if (event === "SubagentStop") {
+      // Update the parent session metadata (summary, lastActivity) but preserve
+      // its state — SubagentStop is a sub-agent event, not a parent state change.
+      // deriveHookState("SubagentStop") returns "idle" which would incorrectly
+      // set the parent to idle while it may still be working.
+      const parentPrevious = readExistingHookState(hooksDir, sessionId);
+      const parentBaseSeq = parentPrevious?.hookSeq ?? 0;
+      const parentNowMs = Math.floor(Date.now() / 100);
+      const parentHookSeq = Math.max(parentBaseSeq + 1, parentNowMs);
+      const parentSummary = deriveSummary("SubagentStop", payload);
+      const parentData: HookStateFile = {
+        eventType: "SubagentStop",
+        eventTime: now,
+        hookSeq: parentHookSeq,
+        state: parentPrevious?.state ?? "working",
+        hasAttention: parentPrevious?.hasAttention ?? false,
+        attentionKind: parentPrevious?.attentionKind ?? "none",
+        ...(parentSummary ? { summary: parentSummary } : {}),
+        currentPath: payload.new_cwd ?? payload.cwd,
+        lastActivity: now,
+        detectionSource: "claude-hook",
+      };
+      writeHookFile(hooksDir, sessionId, parentData);
+      await tryHttpDelivery({ sessionId, ...parentData });
+      // Ensure tmux pane option is refreshed so the parent session remains linked
+      setTmuxPaneOption(sessionId);
+      process.exit(0);
+    }
+  }
+
+  // For all other events: write state for the current session
+  const previous = readExistingHookState(hooksDir, sessionId);
+  const derived = deriveHookState(event, payload, previous);
+  const summary = derived.summary ?? deriveSummary(event, payload) ?? previous?.summary;
+
+  // Use a timestamp-based hookSeq to avoid collisions when multiple hooks
+  // fire concurrently. The previous seq is used as a floor to ensure monotonicity.
+  const baseSeq = previous?.hookSeq ?? 0;
+  const nowMs = Math.floor(Date.now() / 100);
+  const hookSeq = Math.max(baseSeq + 1, nowMs);
+
+  const hookData: HookStateFile = {
+    eventType: event,
+    eventTime: now,
+    hookSeq,
+    state: derived.state,
+    hasAttention: derived.hasAttention,
+    attentionKind: derived.attentionKind,
+    ...(summary ? { summary } : {}),
+    ...(derived.activeTool ? { activeTool: derived.activeTool } : {}),
+    ...(derived.toolName ? { toolName: derived.toolName } : {}),
+    ...(derived.toolInputSummary ? { toolInputSummary: derived.toolInputSummary } : {}),
+    ...(derived.toolResultStatus ? { toolResultStatus: derived.toolResultStatus } : {}),
+    ...(payload.permission_mode ? { permissionMode: payload.permission_mode } : {}),
+    ...(payload.source ? { startSource: payload.source } : {}),
+    ...(payload.reason ? { endReason: payload.reason } : {}),
+    ...(payload.error ? { errorType: payload.error } : {}),
+    ...(payload.agent_id ? { agentId: payload.agent_id } : {}),
+    ...(payload.agent_type ? { agentType: payload.agent_type } : {}),
+    ...(payload.transcript_path ? { transcriptPath: payload.transcript_path } : {}),
+    currentPath: payload.new_cwd ?? payload.cwd,
+    lastActivity: now,
+    detectionSource: "claude-hook",
+  };
+
+  writeHookFile(hooksDir, sessionId, hookData);
+  await tryHttpDelivery({ sessionId, ...hookData });
+
+  // Update tmux binding for the main session, especially on SessionStart or resume.
+  if (event === "SessionStart" || event === "UserPromptSubmit" || event === "PermissionRequest" || event === "PreToolUse") {
+    setTmuxPaneOption(sessionId);
+  }
+
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));