failproofai 0.0.9-beta.1 → 0.0.9-beta.2

package/.next/standalone/lib/codex-projects.ts

@@ -0,0 +1,250 @@
+/**
+ * Codex (OpenAI) project discovery.
+ *
+ * Codex transcripts are stored at `~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-...jsonl`,
+ * keyed by date — not by working directory. To list "projects" we scan every transcript,
+ * read only the first record (`session_meta`, which carries `payload.cwd`), and group by cwd.
+ *
+ * The encoded cwd doubles as the URL slug for `/project/[name]`, matching Claude Code's
+ * convention (see `encodeFolderName` in `lib/paths.ts`), so a cwd present in both stores
+ * naturally produces the same `name` and can be merged on the Claude side.
+ */
+import { open, readdir } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { encodeFolderName } from "./paths";
+import type { ProjectFolder, SessionFile } from "./projects";
+import { runtimeCache } from "./runtime-cache";
+import { batchAll } from "./concurrency";
+import { formatDate } from "./format-date";
+import { logWarn } from "./logger";
+
+const CODEX_SESSIONS_ROOT = join(homedir(), ".codex", "sessions");
+const SESSION_ID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+// session_meta records can be large (base instructions inlined), but a single record
+// is unlikely to exceed a few hundred KB. 256 KB comfortably covers the first line
+// without slurping a full multi-MB transcript.
+const FIRST_LINE_CHUNK_BYTES = 256 * 1024;
+
+interface CodexSessionMeta {
+  filePath: string;
+  fileName: string;
+  cwd: string;
+  sessionId: string;
+  fileMtime: Date;
+}
+
+async function safeReaddir(dir: string) {
+  try {
+    return await readdir(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
+
+/** Read the first line of a file without loading the rest. */
+async function readFirstLine(filePath: string): Promise<string | null> {
+  let fh: Awaited<ReturnType<typeof open>> | null = null;
+  try {
+    fh = await open(filePath, "r");
+    const buf = Buffer.alloc(FIRST_LINE_CHUNK_BYTES);
+    const { bytesRead } = await fh.read(buf, 0, FIRST_LINE_CHUNK_BYTES, 0);
+    if (bytesRead === 0) return null;
+    const slice = buf.subarray(0, bytesRead);
+    const nl = slice.indexOf(0x0a); // '\n'
+    const end = nl === -1 ? bytesRead : nl;
+    return slice.subarray(0, end).toString("utf-8");
+  } catch {
+    return null;
+  } finally {
+    if (fh) await fh.close().catch(() => {});
+  }
+}
+
+function extractSessionMeta(line: string): { cwd?: string } {
+  try {
+    const obj = JSON.parse(line) as { type?: string; payload?: { cwd?: unknown } };
+    if (obj.type !== "session_meta") return {};
+    const cwd = obj.payload?.cwd;
+    if (typeof cwd !== "string" || cwd.length === 0) return {};
+    return { cwd };
+  } catch {
+    return {};
+  }
+}
+
+function extractSessionId(filename: string): string | null {
+  const m = filename.match(SESSION_ID_RE);
+  return m ? m[0] : null;
+}
+
+async function listJsonlFiles(dir: string): Promise<string[]> {
+  const entries = await safeReaddir(dir);
+  if (!entries) return [];
+  return entries
+    .filter((e) => e.isFile() && e.name.endsWith(".jsonl"))
+    .map((e) => join(dir, e.name));
+}
+
+/**
+ * Walk `~/.codex/sessions/<Y>/<M>/<D>/` for every `*.jsonl` transcript and read each
+ * file's first record to extract `cwd`. Files lacking a parsable `session_meta` or a
+ * UUID-looking sessionId in the filename are skipped.
+ */
+async function scanCodexSessions(): Promise<CodexSessionMeta[]> {
+  const yearDirs = await safeReaddir(CODEX_SESSIONS_ROOT);
+  if (!yearDirs) return [];
+
+  const filePaths: string[] = [];
+  for (const y of yearDirs) {
+    if (!y.isDirectory()) continue;
+    const monthDirs = await safeReaddir(join(CODEX_SESSIONS_ROOT, y.name));
+    if (!monthDirs) continue;
+    for (const m of monthDirs) {
+      if (!m.isDirectory()) continue;
+      const dayDirs = await safeReaddir(join(CODEX_SESSIONS_ROOT, y.name, m.name));
+      if (!dayDirs) continue;
+      for (const d of dayDirs) {
+        if (!d.isDirectory()) continue;
+        const dayPath = join(CODEX_SESSIONS_ROOT, y.name, m.name, d.name);
+        filePaths.push(...(await listJsonlFiles(dayPath)));
+      }
+    }
+  }
+
+  if (filePaths.length === 0) return [];
+
+  const settled = await batchAll(
+    filePaths.map((filePath) => async (): Promise<CodexSessionMeta | null> => {
+      const sessionId = extractSessionId(filePath.split("/").pop() ?? "");
+      if (!sessionId) return null;
+      const line = await readFirstLine(filePath);
+      if (!line) return null;
+      const { cwd } = extractSessionMeta(line);
+      if (!cwd) return null;
+      let fileMtime: Date;
+      try {
+        const fh = await open(filePath, "r");
+        try {
+          const stat = await fh.stat();
+          fileMtime = stat.mtime;
+        } finally {
+          await fh.close().catch(() => {});
+        }
+      } catch {
+        fileMtime = new Date(0);
+      }
+      return {
+        filePath,
+        fileName: filePath.split("/").pop() ?? "",
+        cwd,
+        sessionId,
+        fileMtime,
+      };
+    }),
+    16,
+  );
+  return settled
+    .filter((r): r is PromiseFulfilledResult<CodexSessionMeta | null> => r.status === "fulfilled")
+    .map((r) => r.value)
+    .filter((v): v is CodexSessionMeta => v !== null);
+}
+
+const cachedScan = runtimeCache(scanCodexSessions, 30);
+
+/** Returns one ProjectFolder per unique cwd discovered in Codex transcripts. */
+export async function getCodexProjects(): Promise<ProjectFolder[]> {
+  let metas: CodexSessionMeta[];
+  try {
+    metas = await cachedScan();
+  } catch (error) {
+    logWarn("Failed to scan Codex sessions:", error);
+    return [];
+  }
+
+  const byCwd = new Map<string, { latest: Date; cwd: string }>();
+  for (const m of metas) {
+    const existing = byCwd.get(m.cwd);
+    if (!existing || m.fileMtime.getTime() > existing.latest.getTime()) {
+      byCwd.set(m.cwd, { latest: m.fileMtime, cwd: m.cwd });
+    }
+  }
+
+  const folders: ProjectFolder[] = [];
+  for (const { cwd, latest } of byCwd.values()) {
+    folders.push({
+      name: encodeFolderName(cwd),
+      path: cwd,
+      isDirectory: true,
+      lastModified: latest,
+      lastModifiedFormatted: formatDate(latest),
+      cli: ["codex"],
+    });
+  }
+  folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return folders;
+}
+
+function metasToSessionFiles(metas: CodexSessionMeta[]): SessionFile[] {
+  const files: SessionFile[] = metas.map((m) => ({
+    name: m.fileName.replace(/\.jsonl$/, ""),
+    path: m.filePath,
+    lastModified: m.fileMtime,
+    lastModifiedFormatted: formatDate(m.fileMtime),
+    sessionId: m.sessionId,
+    cli: "codex",
+  }));
+  files.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return files;
+}
+
+/** Returns SessionFile entries for every Codex transcript whose cwd matches `cwd` exactly. */
+export async function getCodexSessionsForCwd(cwd: string): Promise<SessionFile[]> {
+  let metas: CodexSessionMeta[];
+  try {
+    metas = await cachedScan();
+  } catch (error) {
+    logWarn("Failed to scan Codex sessions:", error);
+    return [];
+  }
+  return metasToSessionFiles(metas.filter((m) => m.cwd === cwd));
+}
+
+export interface CodexProjectByName {
+  /** Original cwd recovered from the Codex transcripts (canonical, not the lossy decode). */
+  cwd: string | null;
+  sessions: SessionFile[];
+}
+
+/**
+ * Looks up Codex sessions for a project URL slug. `decodeFolderName` is lossy
+ * (every `-` becomes `/`), so we cannot recover the original cwd from the slug —
+ * instead we re-encode each session's cwd and match in that direction. Returns
+ * both the canonical cwd (first match wins) and the matching sessions.
+ */
+export async function getCodexSessionsByEncodedName(name: string): Promise<CodexProjectByName> {
+  let metas: CodexSessionMeta[];
+  try {
+    metas = await cachedScan();
+  } catch (error) {
+    logWarn("Failed to scan Codex sessions:", error);
+    return { cwd: null, sessions: [] };
+  }
+  const matches = metas.filter((m) => encodeFolderName(m.cwd) === name);
+  return {
+    cwd: matches[0]?.cwd ?? null,
+    sessions: metasToSessionFiles(matches),
+  };
+}
+
+export const getCachedCodexProjects = runtimeCache(getCodexProjects, 30);
+export const getCachedCodexSessionsForCwd = runtimeCache(
+  (cwd: string) => getCodexSessionsForCwd(cwd),
+  30,
+  { maxSize: 50 },
+);
+export const getCachedCodexSessionsByEncodedName = runtimeCache(
+  (name: string) => getCodexSessionsByEncodedName(name),
+  30,
+  { maxSize: 50 },
+);

package/.next/standalone/lib/codex-sessions.ts

@@ -0,0 +1,414 @@
+/**
+ * Codex (OpenAI) session transcript discovery + JSONL parser.
+ *
+ * Codex stores transcripts at:
+ *   ~/.codex/sessions/<YYYY>/<MM>/<DD>/<file containing sessionId>.jsonl
+ *
+ * The schema is uniform `{ timestamp, type, payload }` records:
+ *   - type: session_meta   — metadata (cwd, model, base instructions)
+ *   - type: turn_context   — per-turn config (approval_policy, sandbox)
+ *   - type: response_item  — message / function_call / function_call_output
+ *   - type: event_msg      — task_started, user_message, agent_message,
+ *                            exec_command_begin/end, token_count, …
+ *
+ * `parseCodexLog` maps these into the same `LogEntry` shapes the Claude
+ * parser produces (`lib/log-entries.ts`) so the existing log viewer renders
+ * Codex sessions without any UI-side branching.
+ */
+import { readFileSync, readdirSync, existsSync, writeFileSync, mkdirSync, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { runtimeCache } from "./runtime-cache";
+import {
+  baseEntry,
+  formatTimestamp,
+  type LogEntry,
+  type UserEntry,
+  type AssistantEntry,
+  type GenericEntry,
+  type QueueOperationEntry,
+  type ContentBlock,
+  type ToolUseBlock,
+  type LogSource,
+} from "./log-entries";
+import { formatDuration } from "./format-duration";
+
+// ── Transcript discovery ──
+
+const CACHE_PATH = join(homedir(), ".failproofai", "cache", "codex-session-paths.json");
+
+function readCache(): Record<string, string> {
+  try {
+    if (!existsSync(CACHE_PATH)) return {};
+    return JSON.parse(readFileSync(CACHE_PATH, "utf-8")) as Record<string, string>;
+  } catch {
+    return {};
+  }
+}
+
+function writeCacheEntry(sessionId: string, path: string): void {
+  try {
+    mkdirSync(dirname(CACHE_PATH), { recursive: true });
+    const cache = readCache();
+    cache[sessionId] = path;
+    writeFileSync(CACHE_PATH, JSON.stringify(cache), "utf-8");
+  } catch {
+    // Cache is best-effort
+  }
+}
+
+function dirSearch(dir: string, sessionId: string): string | null {
+  try {
+    for (const f of readdirSync(dir, { withFileTypes: true })) {
+      if (f.isFile() && f.name.includes(sessionId) && f.name.endsWith(".jsonl")) {
+        return join(dir, f.name);
+      }
+    }
+  } catch {
+    // dir doesn't exist or unreadable
+  }
+  return null;
+}
+
+/**
+ * Locate a Codex transcript by sessionId. Tries the cache, then today/
+ * yesterday's date directories, then a full tree scan as fallback.
+ * Synchronous so the hook hot path can call it without awaits.
+ */
+export function findCodexTranscript(sessionId: string): string | null {
+  const cache = readCache();
+  const cached = cache[sessionId];
+  if (cached && existsSync(cached)) return cached;
+
+  const root = join(homedir(), ".codex", "sessions");
+
+  const today = new Date();
+  const yesterday = new Date(today.getTime() - 24 * 60 * 60 * 1000);
+  const datedDirs = [today, yesterday].map((d) => {
+    const y = String(d.getUTCFullYear());
+    const m = String(d.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(d.getUTCDate()).padStart(2, "0");
+    return join(root, y, m, day);
+  });
+  for (const dir of datedDirs) {
+    const hit = dirSearch(dir, sessionId);
+    if (hit) {
+      writeCacheEntry(sessionId, hit);
+      return hit;
+    }
+  }
+
+  try {
+    for (const y of readdirSync(root, { withFileTypes: true })) {
+      if (!y.isDirectory()) continue;
+      for (const m of readdirSync(join(root, y.name), { withFileTypes: true })) {
+        if (!m.isDirectory()) continue;
+        for (const d of readdirSync(join(root, y.name, m.name), { withFileTypes: true })) {
+          if (!d.isDirectory()) continue;
+          const hit = dirSearch(join(root, y.name, m.name, d.name), sessionId);
+          if (hit) {
+            writeCacheEntry(sessionId, hit);
+            return hit;
+          }
+        }
+      }
+    }
+  } catch {
+    // Session may not have flushed yet, or the path doesn't exist
+  }
+  return null;
+}
+
+// ── Parser ──
+
+interface CodexRecord {
+  timestamp?: string;
+  type?: string;
+  payload?: Record<string, unknown>;
+}
+
+interface CodexContentBlock {
+  type?: string;
+  text?: string;
+}
+
+interface CodexParseResult {
+  entries: LogEntry[];
+  rawLines: Record<string, unknown>[];
+  /** Working directory pulled from the first session_meta record, when present. */
+  cwd?: string;
+}
+
+function safeJsonParse(s: string | undefined): Record<string, unknown> {
+  if (!s) return {};
+  try {
+    return JSON.parse(s) as Record<string, unknown>;
+  } catch {
+    return {};
+  }
+}
+
+function joinTexts(blocks: CodexContentBlock[] | undefined, wantedType: "input_text" | "output_text"): string {
+  if (!Array.isArray(blocks)) return "";
+  return blocks
+    .filter((b) => b?.type === wantedType && typeof b.text === "string")
+    .map((b) => b.text as string)
+    .join("\n");
+}
+
+/**
+ * Parse a Codex JSONL transcript into `LogEntry[]` plus the raw lines.
+ * Yields to the event loop every 200 lines so big transcripts don't block.
+ */
+export async function parseCodexLog(
+  fileContent: string,
+  source: LogSource = "session",
+): Promise<CodexParseResult> {
+  const lines = fileContent.split("\n").filter((line) => line.trim() !== "");
+
+  const entries: LogEntry[] = [];
+  const rawLines: Record<string, unknown>[] = [];
+  // call_id → tool_use block, so we can attach exec_command_end results back to the originating call.
+  const toolUseById = new Map<string, ToolUseBlock>();
+  // call_id → tool_use entry timestamp, used to compute durationMs from end records that lack a duration.
+  const toolUseStartMs = new Map<string, number>();
+  let cwd: string | undefined;
+  let seenTaskStart = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (i > 0 && i % 200 === 0) await new Promise<void>((r) => setImmediate(r));
+
+    const line = lines[i];
+    let raw: CodexRecord;
+    try {
+      raw = JSON.parse(line) as CodexRecord;
+    } catch {
+      continue;
+    }
+
+    const rawCopy = { ...(raw as Record<string, unknown>), _source: source };
+    rawLines.push(rawCopy);
+
+    const timestamp = raw.timestamp;
+    if (!timestamp) continue;
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime())) continue;
+
+    const recType = raw.type;
+    const payload = raw.payload ?? {};
+
+    if (recType === "session_meta") {
+      const c = payload.cwd;
+      if (typeof c === "string" && !cwd) cwd = c;
+      entries.push({
+        type: "system",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        raw: rawCopy,
+      } satisfies GenericEntry);
+      continue;
+    }
+
+    if (recType === "response_item") {
+      const subType = payload.type as string | undefined;
+
+      if (subType === "message") {
+        const role = payload.role as string | undefined;
+        const content = payload.content as CodexContentBlock[] | undefined;
+
+        if (role === "user" || role === "developer") {
+          const text = joinTexts(content, "input_text");
+          if (!text) continue;
+          const message = role === "developer" ? `[developer] ${text}` : text;
+          entries.push({
+            type: "user",
+            ...baseEntry(rawCopy, timestamp, date, source),
+            message: { role: "user", content: message },
+          } satisfies UserEntry);
+          continue;
+        }
+
+        if (role === "assistant") {
+          const text = joinTexts(content, "output_text");
+          if (!text) continue;
+          const blocks: ContentBlock[] = [{ type: "text", text }];
+          entries.push({
+            type: "assistant",
+            ...baseEntry(rawCopy, timestamp, date, source),
+            message: { role: "assistant", content: blocks },
+          } satisfies AssistantEntry);
+          continue;
+        }
+
+        // Unknown role — preserve as system so nothing is lost.
+        entries.push({
+          type: "system",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          raw: rawCopy,
+        } satisfies GenericEntry);
+        continue;
+      }
+
+      if (subType === "function_call") {
+        const callId = payload.call_id as string | undefined;
+        const name = (payload.name as string | undefined) ?? "function_call";
+        const input = safeJsonParse(payload.arguments as string | undefined);
+        const toolUse: ToolUseBlock = {
+          type: "tool_use",
+          id: callId ?? `${timestamp}-${name}`,
+          name,
+          input,
+        };
+        const entry: AssistantEntry = {
+          type: "assistant",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          message: { role: "assistant", content: [toolUse] },
+        };
+        entries.push(entry);
+        if (callId) {
+          toolUseById.set(callId, toolUse);
+          toolUseStartMs.set(callId, date.getTime());
+        }
+        continue;
+      }
+
+      if (subType === "function_call_output") {
+        const callId = payload.call_id as string | undefined;
+        const block = callId ? toolUseById.get(callId) : undefined;
+        if (block) {
+          const startMs = toolUseStartMs.get(callId!) ?? date.getTime();
+          const duration = Math.max(0, date.getTime() - startMs);
+          block.result = {
+            timestamp,
+            timestampFormatted: formatTimestamp(date),
+            content: typeof payload.output === "string" ? (payload.output as string) : JSON.stringify(payload.output),
+            durationMs: duration,
+            durationFormatted: formatDuration(duration),
+          };
+          continue;
+        }
+        // Orphan output — preserve as system.
+        entries.push({
+          type: "system",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          raw: rawCopy,
+        } satisfies GenericEntry);
+        continue;
+      }
+
+      // Unknown response_item subtype — preserve raw.
+      entries.push({
+        type: "system",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        raw: rawCopy,
+      } satisfies GenericEntry);
+      continue;
+    }
+
+    if (recType === "event_msg") {
+      const subType = payload.type as string | undefined;
+
+      if (subType === "task_started") {
+        const label: QueueOperationEntry["label"] = seenTaskStart ? "Session Resumed" : "Session Started";
+        seenTaskStart = true;
+        entries.push({
+          type: "queue-operation",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          label,
+        } satisfies QueueOperationEntry);
+        continue;
+      }
+
+      if (subType === "exec_command_end") {
+        const callId = payload.call_id as string | undefined;
+        const block = callId ? toolUseById.get(callId) : undefined;
+        if (block) {
+          const duration = payload.duration as { secs?: number; nanos?: number } | undefined;
+          const durationMs = duration
+            ? (duration.secs ?? 0) * 1000 + Math.round((duration.nanos ?? 0) / 1e6)
+            : Math.max(0, date.getTime() - (toolUseStartMs.get(callId!) ?? date.getTime()));
+          const aggregated = payload.aggregated_output;
+          block.result = {
+            timestamp,
+            timestampFormatted: formatTimestamp(date),
+            content: typeof aggregated === "string" ? aggregated : JSON.stringify(aggregated),
+            durationMs,
+            durationFormatted: formatDuration(durationMs),
+          };
+          continue;
+        }
+        // Orphan exec end — preserve as system.
+        entries.push({
+          type: "system",
+          ...baseEntry(rawCopy, timestamp, date, source),
+          raw: rawCopy,
+        } satisfies GenericEntry);
+        continue;
+      }
+
+      if (subType === "user_message" || subType === "agent_message") {
+        // Already rendered via the corresponding response_item; skip to avoid duplicates.
+        continue;
+      }
+
+      // Other event_msg subtypes (token_count, exec_command_begin, etc.) — preserve raw.
+      entries.push({
+        type: "system",
+        ...baseEntry(rawCopy, timestamp, date, source),
+        raw: rawCopy,
+      } satisfies GenericEntry);
+      continue;
+    }
+
+    // turn_context and any unrecognized type — preserve raw so nothing is silently dropped.
+    entries.push({
+      type: "system",
+      ...baseEntry(rawCopy, timestamp, date, source),
+      raw: rawCopy,
+    } satisfies GenericEntry);
+  }
+
+  if (entries.length > 500) await new Promise<void>((r) => setImmediate(r));
+  entries.sort((a, b) => a.timestampMs - b.timestampMs);
+
+  return { entries, rawLines, cwd };
+}
+
+// ── Public loader ──
+
+export interface CodexSessionLogData {
+  entries: LogEntry[];
+  rawLines: Record<string, unknown>[];
+  cwd?: string;
+  filePath: string;
+}
+
+export async function getCodexSessionLog(sessionId: string): Promise<CodexSessionLogData | null> {
+  const filePath = findCodexTranscript(sessionId);
+  if (!filePath) return null;
+  const fileContent = await readFile(filePath, "utf-8");
+  const { entries, rawLines, cwd } = await parseCodexLog(fileContent, "session");
+  return { entries, rawLines, cwd, filePath };
+}
+
+export const getCachedCodexSessionLog = runtimeCache(
+  (sessionId: string) => getCodexSessionLog(sessionId),
+  60,
+  { maxSize: 50 },
+);
+
+// ── Test helpers ──
+
+/** For tests: inspect cache file path. */
+export function _getCacheFilePath(): string {
+  return CACHE_PATH;
+}
+
+/** For tests: confirm the file exists at a path. Wraps fs to keep tests minimal. */
+export function _statFile(path: string): { isFile: boolean } | null {
+  try {
+    return { isFile: statSync(path).isFile() };
+  } catch {
+    return null;
+  }
+}

package/.next/standalone/lib/format-date.ts

@@ -0,0 +1,21 @@
+/**
+ * Formats a date to a readable string format (e.g., "Jan 15, 2024, 3:45 PM").
+ *
+ * Creates a new Intl.DateTimeFormat on each call intentionally — this runs
+ * server-side where there's no shared state concern. The client-side hot-path
+ * formatter in lib/log-format.ts caches its instance at module scope instead.
+ *
+ * Lives in its own module (rather than lib/utils.ts) so server-side callers
+ * — including the hook handler's transitive imports — don't need to pull in
+ * clsx/tailwind-merge just to format a date.
+ */
+export function formatDate(date: Date): string {
+  return new Intl.DateTimeFormat("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+  }).format(date);
+}