holo-codex 0.1.0

package/plugins/autonomous-pr-loop/core/hook-capture.ts

@@ -0,0 +1,115 @@
+import { existsSync } from "node:fs";
+import { statePath } from "./config.js";
+import { codexHomePath, listHookBindings, type HookBinding } from "./hook-router.js";
+import { SqliteAgentLoopStorage } from "./storage.js";
+
+export type HookCaptureStatus = "captured" | "not_seen" | "stale" | "ambiguous" | "unavailable";
+
+export interface HookCaptureReport {
+  status: HookCaptureStatus;
+  reason: string;
+  currentRepoBindings?: number;
+  sessionScopedBindings?: number;
+  activeBindings?: number;
+  lastSeenAt?: string;
+  latestHookEventAt?: string;
+  latestHookEventKind?: string;
+  runId?: string;
+}
+
+const RECENT_CAPTURE_MS = 5 * 60 * 1000;
+
+export function inspectHookCapture(repoRoot: string, codexHome = codexHomePath()): HookCaptureReport {
+  let bindings: HookBinding[];
+  try {
+    bindings = listHookBindings(codexHome);
+  } catch (error) {
+    return unavailable(`Hook binding registry could not be read: ${errorMessage(error)}`);
+  }
+  const active = bindings.filter((binding) => binding.status === "active");
+  const current = active.filter((binding) => binding.repoRoot === repoRoot);
+  if (current.length === 0) {
+    return {
+      status: "unavailable",
+      reason: "No active hook binding exists for this repo.",
+      currentRepoBindings: 0,
+      sessionScopedBindings: 0,
+      activeBindings: active.length
+    };
+  }
+  if (current.length > 1) {
+    return {
+      status: "ambiguous",
+      reason: "Multiple active hook bindings exist for this repo.",
+      currentRepoBindings: current.length,
+      sessionScopedBindings: current.filter((binding) => binding.sessionIdHash).length,
+      activeBindings: active.length
+    };
+  }
+  const binding = current[0]!;
+  const hookEvent = latestHookEvent(repoRoot, binding.runId);
+  const hookEventRecent = hookEvent ? Date.now() - Date.parse(hookEvent.createdAt) <= RECENT_CAPTURE_MS : false;
+  const base = {
+    currentRepoBindings: current.length,
+    sessionScopedBindings: current.filter((item) => item.sessionIdHash).length,
+    activeBindings: active.length,
+    ...(binding.lastSeenAt ? { lastSeenAt: binding.lastSeenAt } : {}),
+    ...(hookEvent ? { latestHookEventAt: hookEvent.createdAt, latestHookEventKind: hookEvent.kind } : {}),
+    ...(binding.runId ? { runId: binding.runId } : {})
+  };
+  if (hookEventRecent) {
+    return {
+      status: "captured",
+      reason: "Recent hook event was captured for this repo.",
+      ...base
+    };
+  }
+  if (hookEvent) {
+    return {
+      status: "stale",
+      reason: "Hook events were captured before, but not recently.",
+      ...base
+    };
+  }
+  if (binding.lastSeenAt) {
+    return {
+      status: "not_seen",
+      reason: "Hook routing matched this repo, but no hook event has been captured.",
+      ...base
+    };
+  }
+  return {
+    status: "not_seen",
+    reason: "Hook router is installed, but this repo binding has not observed the current Codex session.",
+    ...base
+  };
+}
+
+function latestHookEvent(repoRoot: string, runId: string | undefined): { kind: string; createdAt: string } | undefined {
+  const path = statePath(repoRoot);
+  if (!existsSync(path)) return undefined;
+  const storage = new SqliteAgentLoopStorage(path, { mode: "ro" });
+  try {
+    return storage
+      .listEvents(1000)
+      .filter((event) => event.kind.startsWith("hook_") && (!runId || event.runId === runId))
+      .map((event) => ({ kind: event.kind, createdAt: event.createdAt }))
+      .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
+  } finally {
+    storage.close();
+  }
+}
+
+function unavailable(reason: string): HookCaptureReport {
+  return {
+    status: "unavailable",
+    reason,
+    currentRepoBindings: 0,
+    sessionScopedBindings: 0,
+    activeBindings: 0
+  };
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/plugins/autonomous-pr-loop/core/hook-events.ts

@@ -0,0 +1,22 @@
+export const CODEX_HOOK_EVENTS = [
+  "PreToolUse",
+  "PostToolUse",
+  "UserPromptSubmit",
+  "Stop",
+  "SessionStart",
+  "PreCompact",
+  "PostCompact",
+  "PermissionRequest"
+] as const;
+
+export type CodexHookEvent = typeof CODEX_HOOK_EVENTS[number];
+
+export const OBSERVE_ONLY_HOOK_EVENTS = CODEX_HOOK_EVENTS.filter((event) => event !== "PreToolUse") as Exclude<CodexHookEvent, "PreToolUse">[];
+
+export function hookScriptName(event: CodexHookEvent): string {
+  return `${event.replaceAll(/([a-z])([A-Z])/g, "$1-$2").toLowerCase()}.js`;
+}
+
+export function hookEventKind(event: CodexHookEvent): string {
+  return `hook_${event.replaceAll(/([a-z])([A-Z])/g, "$1_$2").toLowerCase()}`;
+}

package/plugins/autonomous-pr-loop/core/hook-installation.ts

@@ -0,0 +1,85 @@
+import { join } from "node:path";
+import { CODEX_HOOK_EVENTS, hookScriptName, type CodexHookEvent } from "./hook-events.js";
+import { defaultPackageRoot, hookDistRoot } from "./plugin-paths.js";
+
+/** Return the installed command used by Codex to invoke one agent-loop hook. */
+export function agentLoopHookCommand(repoRoot: string, event: CodexHookEvent, packageRoot = defaultPackageRoot()): string {
+  return `AGENT_LOOP_REPO_ROOT=${shellQuote(repoRoot)} node ${shellQuote(join(hookDistRoot(packageRoot), hookScriptName(event)))}`;
+}
+
+/** Return the installed router command used by Codex to invoke one agent-loop hook. */
+export function agentLoopRouterHookCommand(event: CodexHookEvent, packageRoot = defaultPackageRoot()): string {
+  return `node ${shellQuote(join(hookDistRoot(packageRoot), hookScriptName(event)))}`;
+}
+
+/** Return the legacy per-repo Codex hook entries installed before router isolation. */
+export function agentLoopHookEntries(repoRoot: string, packageRoot = defaultPackageRoot()): Record<string, unknown[]> {
+  return Object.fromEntries(CODEX_HOOK_EVENTS.map((event) => [
+    event,
+    [{
+      matcher: "*",
+      hooks: [{
+        type: "command",
+        command: agentLoopHookCommand(repoRoot, event, packageRoot),
+        timeout: event === "PreToolUse" ? 1000 : 500,
+        statusMessage: hookStatusMessage(event)
+      }]
+    }]
+  ]));
+}
+
+/** Return canonical router entries for `hooks.json` under the root `hooks` key. */
+export function agentLoopRouterHookEntries(packageRoot = defaultPackageRoot()): Record<string, unknown[]> {
+  return Object.fromEntries(CODEX_HOOK_EVENTS.map((event) => [
+    event,
+    [{
+      matcher: "*",
+      hooks: [{
+        type: "command",
+        command: agentLoopRouterHookCommand(event, packageRoot),
+        timeout: event === "PreToolUse" ? 1000 : 500,
+        statusMessage: hookStatusMessage(event)
+      }]
+    }]
+  ]));
+}
+
+/** True for agent-loop hook commands managed by this plugin. */
+export function isAgentLoopHookCommand(command: string): boolean {
+  return command.includes("autonomous-pr-loop/hooks/dist/") && CODEX_HOOK_EVENTS.some((event) => command.includes(hookScriptName(event)));
+}
+
+/** True for old per-repo agent-loop hook commands that used `AGENT_LOOP_REPO_ROOT`. */
+export function isLegacyAgentLoopHookCommand(command: string): boolean {
+  return isAgentLoopHookCommand(command) && command.includes("AGENT_LOOP_REPO_ROOT=");
+}
+
+/** Recursively collect command hook strings from supported Codex hooks config shapes. */
+export function collectHookCommands(value: unknown): string[] {
+  if (Array.isArray(value)) {
+    return value.flatMap(collectHookCommands);
+  }
+  if (typeof value !== "object" || value === null) {
+    return [];
+  }
+  const record = value as Record<string, unknown>;
+  const direct = Array.isArray(record.hooks)
+    ? record.hooks.flatMap((hook) => typeof hook === "object" && hook !== null && typeof (hook as { command?: unknown }).command === "string"
+      ? [(hook as { command: string }).command]
+      : [])
+    : [];
+  return [
+    ...direct,
+    ...Object.values(record).flatMap(collectHookCommands)
+  ];
+}
+
+function hookStatusMessage(event: CodexHookEvent): string {
+  return event === "PreToolUse"
+    ? "Checking agent-loop command policy"
+    : `Recording agent-loop ${event} event`;
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}

package/plugins/autonomous-pr-loop/core/hook-observer.ts

@@ -0,0 +1,84 @@
+import { createHash } from "node:crypto";
+import { isRecord, statePath } from "./config.js";
+import { hookEventKind, type CodexHookEvent } from "./hook-events.js";
+import { resolveHookRoute } from "./hook-router.js";
+import { redactSecrets } from "./redaction.js";
+import { SqliteAgentLoopStorage } from "./storage.js";
+
+export interface ObserveHookResult {
+  continue: true;
+  observed: boolean;
+  error?: string;
+}
+
+/** Persist a lightweight observe-only Codex hook event without affecting tool execution. */
+export function observeCodexHook(event: CodexHookEvent, payload: unknown, repoRoot?: string): ObserveHookResult {
+  try {
+    const route = resolveHookRoute(payload, { legacyRepoRoot: repoRoot });
+    if (route.status === "no_match") {
+      return { continue: true, observed: false };
+    }
+    if (route.status === "ambiguous") {
+      return { continue: true, observed: false, error: route.reason };
+    }
+    if (route.status === "route_error") {
+      return { continue: true, observed: false, error: route.reason };
+    }
+    const storage = new SqliteAgentLoopStorage(statePath(route.binding.repoRoot));
+    try {
+      const run = route.binding.runId ? storage.listRuns(200).find((item) => item.id === route.binding.runId) : storage.getCurrentRun();
+      storage.appendEvent({
+        ...(run ? { runId: run.id } : {}),
+        kind: hookEventKind(event),
+        message: `Codex ${event} hook observed.`,
+        payload: {
+          ...normalizeHookPayload(event, payload),
+          hookRouting: route.legacy ? "legacy" : "binding",
+          worktreeRoot: route.context.worktreeRoot
+        }
+      });
+    } finally {
+      storage.close();
+    }
+    return { continue: true, observed: true };
+  } catch (error) {
+    return { continue: true, observed: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function normalizeHookPayload(event: CodexHookEvent, payload: unknown): Record<string, unknown> {
+  const text = JSON.stringify(payload ?? {});
+  const base = {
+    event,
+    payloadLength: text.length,
+    payloadSha256: createHash("sha256").update(text).digest("hex")
+  };
+  if (event === "UserPromptSubmit" || event === "PermissionRequest") {
+    return { ...base, redacted: true };
+  }
+  if (!isRecord(payload)) {
+    return base;
+  }
+  return {
+    ...base,
+    redacted: true,
+    toolName: stringValue(payload.tool_name) ?? stringValue(payload.toolName) ?? stringValue(payload.tool),
+    matcher: stringValue(payload.matcher),
+    sessionIdHash: hashOptional(stringValue(payload.session_id) ?? stringValue(payload.sessionId)),
+    command: summarizeCommand(payload)
+  };
+}
+
+function summarizeCommand(payload: Record<string, unknown>): string | undefined {
+  const toolInput = isRecord(payload.tool_input) ? payload.tool_input : payload;
+  const command = stringValue(toolInput.command) ?? stringValue(toolInput.cmd) ?? stringValue(toolInput.input);
+  return command ? redactSecrets(command.slice(0, 500)) : undefined;
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function hashOptional(value: string | undefined): string | undefined {
+  return value ? createHash("sha256").update(value).digest("hex") : undefined;
+}