@scrylog/cli 0.1.0

package/src/hooks/codex.ts

@@ -0,0 +1,517 @@
+#!/usr/bin/env bun
+/**
+ * scrylog-codex-hook — Codex CLI lifecycle hook handler.
+ *
+ * Codex CLI calls this binary at each lifecycle event (SessionStart, PreToolUse,
+ * PermissionRequest, PostToolUse, UserPromptSubmit, SubagentStart,
+ * SubagentStop, Stop) with a JSON payload on stdin.
+ * This script writes a state file for the CodexCollector to pick up and,
+ * when running inside tmux, sets the @codex-session pane option so the
+ * TmuxCollector can link the pane to the Codex session.
+ *
+ * Configure in ~/.codex/hooks.json via:
+ *   scrylog codex hooks install
+ */
+
+import { writeFileSync, renameSync, readFileSync, existsSync, rmSync } from "node:fs";
+import { join } 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 CodexHookPayload {
+  session_id: string;
+  transcript_path?: string;
+  cwd?: string;
+  permission_mode?: string;
+  hook_event_name?: string;
+  model?: string;
+  prompt?: string;
+  stop_hook_active?: boolean;
+  last_assistant_message?: string;
+  source?: string;
+  turn_id?: string;
+  // Subagents
+  agent_id?: string;
+  agent_type?: string;
+  agent_transcript_path?: string;
+  // PreToolUse / PermissionRequest / PostToolUse
+  tool_name?: string;
+  tool_input?: Record<string, unknown>;
+  tool_response?: unknown;
+  tool_use_id?: string;
+  tool_input_description?: 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 codex = raw["codex"] as Record<string, unknown> | undefined;
+      if (typeof codex?.["hooksDir"] === "string") return codex["hooksDir"];
+    } catch {
+      // fall through to default
+    }
+  }
+  return getHooksDir("codex-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/codex`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(1500),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+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 /^(would you|do you|can you|should i|please confirm|shall i|want me to|implement this plan|implemente this plan|apply this plan|continue with this plan|proceed with this plan)\b/i.test(trimmed)
+    || /^(quieres que|debo|puedo|confirmas|por favor confirma|contin[uú]o|procedo)\b/i.test(trimmed)
+    || /^¿?(qu[eé]|cu[aá]l|cu[aá]les|c[oó]mo|d[oó]nde|cu[aá]ndo|por qu[eé])(?:\s|\?|$)/i.test(trimmed);
+}
+
+function deriveStopState(payload: CodexHookPayload): SessionState {
+  if (payload.stop_hook_active === true) return "working";
+  if (isQuestion(payload.last_assistant_message)) return "waiting-input";
+  return "idle";
+}
+
+// ── State derivation ──────────────────────────────────────────────────────────
+
+function deriveHookState(event: string, payload: CodexHookPayload, 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 ? `Codex session ${payload.source}` : "Codex session started",
+      };
+    case "UserPromptSubmit":
+      return {
+        state: "working",
+        hasAttention: false,
+        attentionKind: "none",
+        summary: summarizeText(payload.prompt) ?? "Codex 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 "PostToolUse": {
+      // request_user_input means the agent asked a question and is waiting for
+      // the user to respond — this is waiting-input, not working.
+      if (payload.tool_name === "request_user_input") {
+        const question = typeof payload.tool_input?.["question"] === "string"
+          ? (payload.tool_input["question"] as string).slice(0, 120)
+          : undefined;
+        return {
+          state: "waiting-input",
+          hasAttention: true,
+          attentionKind: "question",
+          activeTool: payload.tool_name,
+          toolName: payload.tool_name,
+          toolInputSummary: question,
+          toolResultStatus: "completed",
+          summary: question ? `Waiting for input: ${question}` : "Waiting for user input",
+        };
+      }
+      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 "SubagentStart":
+      return {
+        state: "working",
+        hasAttention: false,
+        attentionKind: "none",
+        summary: payload.agent_type ? `Codex sub-agent ${payload.agent_type}` : "Codex sub-agent",
+      };
+    case "SubagentStop": {
+      const state = deriveStopState(payload);
+      return {
+        state,
+        hasAttention: state === "waiting-input",
+        attentionKind: state === "waiting-input" ? "question" : "none",
+        summary: summarizeText(payload.last_assistant_message) ?? (payload.agent_type ? `Codex sub-agent ${payload.agent_type}` : "Codex sub-agent"),
+      };
+    }
+    case "Stop": {
+      const state = deriveStopState(payload);
+      return {
+        state,
+        hasAttention: state === "waiting-input",
+        attentionKind: state === "waiting-input" ? "question" : "none",
+        summary: summarizeText(payload.last_assistant_message),
+      };
+    }
+    default:
+      return {
+        state: previous?.state ?? "idle",
+        hasAttention: previous?.hasAttention ?? false,
+        attentionKind: previous?.attentionKind ?? "none",
+      };
+  }
+}
+
+function deriveSummary(event: string, payload: CodexHookPayload): string | undefined {
+  if (event === "UserPromptSubmit" && payload.prompt) {
+    return summarizeText(payload.prompt);
+  }
+  if (event === "SessionStart" && payload.source) {
+    return `Codex 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 === "PreToolUse" || event === "PostToolUse") && payload.tool_name) {
+    if (event === "PostToolUse" && payload.tool_name === "request_user_input") {
+      const question = typeof payload.tool_input?.["question"] === "string"
+        ? (payload.tool_input["question"] as string).slice(0, 120)
+        : undefined;
+      return question ? `Waiting for input: ${question}` : "Waiting for user input";
+    }
+    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 === "Stop") {
+    return summarizeText(payload.last_assistant_message);
+  }
+  if (event === "SubagentStart" || event === "SubagentStop") {
+    return summarizeText(payload.last_assistant_message) ?? (payload.agent_type ? `Codex sub-agent ${payload.agent_type}` : "Codex sub-agent");
+  }
+  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, "@codex-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, "@codex-session"], {
+    stdio: "ignore",
+    timeout: 2000,
+  });
+}
+
+// ── File writing ──────────────────────────────────────────────────────────────
+
+interface PreviousState {
+  state?: SessionState;
+  hasAttention?: boolean;
+  attentionKind?: AttentionKind;
+}
+
+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;
+  model?: string;
+  endReason?: string;
+  transcriptPath?: string;
+  currentPath?: string;
+  turnId?: string;
+  agentId?: string;
+  agentType?: string;
+  lastActivity: number;
+  parentSessionId?: string;
+  detectionSource: "codex-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: CodexHookPayload;
+  try {
+    payload = JSON.parse(raw) as CodexHookPayload;
+  } catch {
+    process.exit(0); // Malformed input — exit cleanly so Codex CLI 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();
+  const previous = readExistingHookState(hooksDir, sessionId);
+  const previousState: PreviousState | null = previous
+    ? { state: previous.state, hasAttention: previous.hasAttention, attentionKind: previous.attentionKind }
+    : null;
+  const baseSeq = previous?.hookSeq ?? 0;
+  const nowMs = Math.floor(Date.now() / 100);
+  const hookSeq = Math.max(baseSeq + 1, nowMs);
+
+  if (event === "SubagentStart" || event === "SubagentStop") {
+    const childSessionId = payload.agent_id;
+    if (!childSessionId) {
+      if (event === "SubagentStop") process.stdout.write("{}\n");
+      process.exit(0);
+    }
+
+    const childPrevious = readExistingHookState(hooksDir, childSessionId);
+    const childPreviousState: PreviousState | null = childPrevious
+      ? { state: childPrevious.state, hasAttention: childPrevious.hasAttention, attentionKind: childPrevious.attentionKind }
+      : null;
+    const childBaseSeq = childPrevious?.hookSeq ?? 0;
+    const childHookSeq = Math.max(childBaseSeq + 1, hookSeq);
+    const derived = deriveHookState(event, payload, childPreviousState);
+    const summary = derived.summary ?? deriveSummary(event, payload) ?? childPrevious?.summary;
+    const hookData: HookStateFile = {
+      eventType: event,
+      eventTime: now,
+      hookSeq: childHookSeq,
+      state: derived.state,
+      hasAttention: derived.hasAttention,
+      attentionKind: derived.attentionKind,
+      ...(summary ? { summary } : {}),
+      ...(payload.permission_mode ? { permissionMode: payload.permission_mode } : {}),
+      ...(payload.model ? { model: payload.model } : {}),
+      transcriptPath: payload.agent_transcript_path ?? childPrevious?.transcriptPath ?? "",
+      ...(payload.turn_id ? { turnId: payload.turn_id } : {}),
+      ...(payload.agent_id ? { agentId: payload.agent_id } : {}),
+      ...(payload.agent_type ? { agentType: payload.agent_type } : {}),
+      currentPath: payload.cwd,
+      parentSessionId: `codex:${sessionId}`,
+      lastActivity: now,
+      detectionSource: "codex-hook",
+    };
+
+    writeHookFile(hooksDir, childSessionId, hookData);
+    await tryHttpDelivery({ sessionId: childSessionId, ...hookData });
+    setTmuxPaneOption(sessionId);
+
+    if (event === "SubagentStop") {
+      process.stdout.write("{}\n");
+    }
+    process.exit(0);
+  }
+
+  // Stop with stop_hook_active=false signals the end of a turn, not the session itself.
+  // We delete the state file but leave the @codex-session pane option so the pane
+  // remains linked to the Codex session between turns.
+  if (event === "Stop" && payload.stop_hook_active === false) {
+    const derived = deriveHookState(event, payload, previousState);
+    const summary = derived.summary ?? deriveSummary(event, payload) ?? previous?.summary;
+    const hookData: HookStateFile = {
+      eventType: event,
+      eventTime: now,
+      hookSeq,
+      state: derived.state,
+      hasAttention: derived.hasAttention,
+      attentionKind: derived.attentionKind,
+      ...(summary ? { summary } : {}),
+      ...(payload.transcript_path ? { transcriptPath: payload.transcript_path } : {}),
+      currentPath: payload.cwd,
+      lastActivity: now,
+      detectionSource: "codex-hook",
+    };
+
+    await tryHttpDelivery({
+      sessionId,
+      ...hookData,
+    });
+
+    if (derived.state === "waiting-input") {
+      writeHookFile(hooksDir, sessionId, hookData);
+      setTmuxPaneOption(sessionId);
+    } else {
+      try {
+        rmSync(join(hooksDir, `${sessionId}.json`), { force: true });
+      } catch {
+        // Ignore cleanup issues
+      }
+    }
+    // Codex expects JSON on stdout for Stop events
+    process.stdout.write("{}\n");
+    process.exit(0);
+  }
+
+  // For all other events: write state for the current session
+  const derived = deriveHookState(event, payload, previousState);
+  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 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.model ? { model: payload.model } : {}),
+    ...(payload.transcript_path ? { transcriptPath: payload.transcript_path } : {}),
+    ...(payload.turn_id ? { turnId: payload.turn_id } : {}),
+    currentPath: payload.cwd,
+    lastActivity: now,
+    detectionSource: "codex-hook",
+  };
+
+  writeHookFile(hooksDir, sessionId, hookData);
+  await tryHttpDelivery({ sessionId, ...hookData });
+
+  // Update tmux binding on session start, prompt, and tool use events
+  if (event === "SessionStart" || event === "UserPromptSubmit" || event === "PreToolUse" || event === "PermissionRequest") {
+    setTmuxPaneOption(sessionId);
+  }
+
+  // Codex expects JSON on stdout for Stop events
+  if (event === "Stop") {
+    process.stdout.write("{}\n");
+  }
+
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));