@scrylog/cli 0.1.0

package/src/daemon/collectors/codex/discovery.ts

@@ -0,0 +1,104 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, basename } from "node:path";
+import type { ScrylogConfig } from "../../../shared/config";
+import type { Logger } from "../../../shared/logger";
+import { maybeRunCommand } from "../../../shared/utils";
+
+export interface DiscoveredTranscript {
+  sessionId: string;
+  path: string;
+  lastModified: number;
+  size: number;
+}
+
+export function getCodexDir(config: ScrylogConfig): string {
+  if (process.env.CODEX_HOME) return process.env.CODEX_HOME;
+  return config.codex.codexDir ?? join(homedir(), ".codex");
+}
+
+export function discoverTranscripts(codexDir: string, hookManagedIds?: ReadonlySet<string>): DiscoveredTranscript[] {
+  const results: DiscoveredTranscript[] = [];
+  const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+
+  // Date-partitioned sessions: sessions/YYYY/MM/DD/*.jsonl
+  const sessionsDir = join(codexDir, "sessions");
+  if (existsSync(sessionsDir)) {
+    try {
+      for (const year of readdirSync(sessionsDir)) {
+        const yearPath = join(sessionsDir, year);
+        if (!statSync(yearPath).isDirectory()) continue;
+        for (const month of readdirSync(yearPath)) {
+          const monthPath = join(yearPath, month);
+          if (!statSync(monthPath).isDirectory()) continue;
+          for (const day of readdirSync(monthPath)) {
+            const dayPath = join(monthPath, day);
+            if (!statSync(dayPath).isDirectory()) continue;
+            for (const file of readdirSync(dayPath)) {
+              if (!file.endsWith(".jsonl")) continue;
+              const fullPath = join(dayPath, file);
+              try {
+                const stat = statSync(fullPath);
+                const sessionId = basename(file, ".jsonl");
+                if (stat.mtimeMs < cutoff && !hookManagedIds?.has(sessionId)) continue;
+                results.push({ sessionId, path: fullPath, lastModified: stat.mtimeMs, size: stat.size });
+              } catch {
+                // Skip unreadable files
+              }
+            }
+          }
+        }
+      }
+    } catch {
+      // sessions dir not accessible
+    }
+  }
+
+  // Archived sessions: archived_sessions/*.jsonl
+  const archivedDir = join(codexDir, "archived_sessions");
+  if (existsSync(archivedDir)) {
+    try {
+      for (const file of readdirSync(archivedDir)) {
+        if (!file.endsWith(".jsonl")) continue;
+        const fullPath = join(archivedDir, file);
+        try {
+          const stat = statSync(fullPath);
+          const sessionId = basename(file, ".jsonl");
+          if (stat.mtimeMs < cutoff && !hookManagedIds?.has(sessionId)) continue;
+          results.push({ sessionId, path: fullPath, lastModified: stat.mtimeMs, size: stat.size });
+        } catch {
+          // Skip unreadable files
+        }
+      }
+    } catch {
+      // archived dir not accessible
+    }
+  }
+
+  return results;
+}
+
+export function getCodexProcessPids(logger: Logger, timeoutMs?: number, processes?: { pid: number; command: string }[]): number[] {
+  const result = maybeRunCommand(["pgrep", "-f", "codex"], timeoutMs);
+  if (result.ok) {
+    return result.output
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map((s) => Number.parseInt(s, 10))
+      .filter((n) => !Number.isNaN(n));
+  }
+
+  logger.debug("codex", "pgrep failed — falling back to process collector data", { error: result.error });
+
+  if (processes && processes.length > 0) {
+    return processes
+      .filter((p) => isCodexProcessCommand(p.command))
+      .map((p) => p.pid);
+  }
+
+  return [];
+}
+
+export function isCodexProcessCommand(command: string): boolean {
+  return /(?:^|[\\/])codex(?:\.exe)?(?:\s|$)/i.test(command) && !/(scrylog|hook)/i.test(command);
+}

package/src/daemon/collectors/codex/hooks.ts

@@ -0,0 +1,179 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { SessionModel, SessionState, CodexSessionMeta } from "../../../shared/types";
+
+export interface CodexHookFileData {
+  eventType?: string;
+  eventTime?: number;
+  hookSeq?: number;
+  state?: SessionState;
+  hasAttention?: boolean;
+  attentionKind?: "permission" | "question" | "turn" | "none";
+  summary?: string;
+  activeTool?: string;
+  toolName?: string;
+  toolInputSummary?: string;
+  toolResultStatus?: "started" | "completed" | "error" | "blocked" | "denied" | "unknown";
+  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";
+}
+
+export function isValidHookData(data: CodexHookFileData): boolean {
+  return typeof data.eventType === "string"
+    && data.eventType.length > 0
+    && typeof data.eventTime === "number"
+    && Number.isFinite(data.eventTime)
+    && typeof data.hookSeq === "number"
+    && Number.isFinite(data.hookSeq)
+    && data.state !== undefined
+    && typeof data.hasAttention === "boolean"
+    && typeof data.attentionKind === "string";
+}
+
+export function readHookData(hooksDir: string, sessionId: string): Partial<SessionModel> | null {
+  if (!existsSync(hooksDir)) return null;
+  const hookFile = join(hooksDir, `${sessionId}.json`);
+  if (!existsSync(hookFile)) return null;
+  try {
+    const raw = readFileSync(hookFile, "utf8");
+    const data = JSON.parse(raw) as CodexHookFileData;
+    if (!isValidHookData(data)) return null;
+    return {
+      ...(data.state !== undefined ? { state: data.state } : {}),
+      ...(data.hasAttention !== undefined ? { hasAttention: data.hasAttention } : {}),
+      ...(data.summary !== undefined ? { summary: data.summary } : {}),
+      ...(data.activeTool !== undefined ? { activeTool: data.activeTool } : {}),
+      ...(data.currentPath !== undefined ? { currentPath: data.currentPath } : {}),
+      ...(data.lastActivity !== undefined ? { lastActivity: data.lastActivity } : {}),
+      ...(data.parentSessionId !== undefined ? { parentSessionId: data.parentSessionId } : {}),
+      ...(data.detectionSource !== undefined ? { detectionSource: data.detectionSource } : {}),
+      codex: {
+        sessionId,
+        transcriptPath: data.transcriptPath ?? "",
+        ...(data.eventType !== undefined ? { hookEventType: data.eventType } : {}),
+        ...(data.eventTime !== undefined ? { hookEventTime: data.eventTime } : {}),
+        ...(data.hookSeq !== undefined ? { hookSeq: data.hookSeq } : {}),
+        ...(data.permissionMode !== undefined ? { permissionMode: data.permissionMode } : {}),
+        ...(data.startSource !== undefined ? { startSource: data.startSource } : {}),
+        ...(data.model !== undefined ? { model: data.model } : {}),
+        ...(data.endReason !== undefined ? { endReason: data.endReason } : {}),
+        ...(data.toolName !== undefined ? { toolName: data.toolName } : {}),
+        ...(data.toolInputSummary !== undefined ? { toolInputSummary: data.toolInputSummary } : {}),
+        ...(data.toolResultStatus !== undefined ? { toolResultStatus: data.toolResultStatus } : {}),
+        ...(data.agentId !== undefined ? { agentId: data.agentId } : {}),
+        ...(data.agentType !== undefined ? { agentType: data.agentType } : {}),
+        ...(data.turnId !== undefined ? { turnId: data.turnId } : {}),
+        ...(data.parentSessionId !== undefined ? { parentSessionId: data.parentSessionId } : {}),
+      },
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function isHookNewer(existing: SessionModel | undefined, hookData: Partial<SessionModel>): boolean {
+  const incomingSeq = hookData.codex?.hookSeq;
+  const existingSeq = existing?.codex?.hookSeq;
+  if (typeof incomingSeq === "number" && typeof existingSeq === "number") {
+    return incomingSeq >= existingSeq;
+  }
+
+  const incomingTime = hookData.codex?.hookEventTime ?? hookData.lastActivity ?? 0;
+  const existingTime = existing?.codex?.hookEventTime ?? existing?.lastActivity ?? 0;
+  return incomingTime >= existingTime;
+}
+
+export function getHookTime(session: Partial<SessionModel> | undefined): number {
+  return session?.codex?.hookEventTime ?? session?.lastActivity ?? 0;
+}
+
+export function getExistingHookData(existing: SessionModel | undefined): Partial<SessionModel> | null {
+  if (!existing) return null;
+  if (existing.detectionSource !== "codex-hook") return null;
+  if (!existing.codex?.hookEventType || typeof existing.codex.hookEventTime !== "number" || typeof existing.codex.hookSeq !== "number") {
+    return null;
+  }
+
+  return {
+    state: existing.state,
+    hasAttention: existing.hasAttention,
+    summary: existing.summary,
+    activeTool: existing.activeTool,
+    currentPath: existing.currentPath,
+    lastActivity: existing.lastActivity,
+    parentSessionId: existing.parentSessionId,
+    detectionSource: "codex-hook",
+    codex: {
+      sessionId: existing.codex.sessionId,
+      transcriptPath: existing.codex.transcriptPath,
+      hookEventType: existing.codex.hookEventType,
+      hookEventTime: existing.codex.hookEventTime,
+      hookSeq: existing.codex.hookSeq,
+      ...(existing.codex.permissionMode ? { permissionMode: existing.codex.permissionMode } : {}),
+      ...(existing.codex.startSource ? { startSource: existing.codex.startSource } : {}),
+      ...(existing.codex.model ? { model: existing.codex.model } : {}),
+      ...(existing.codex.endReason ? { endReason: existing.codex.endReason } : {}),
+      ...(existing.codex.toolName ? { toolName: existing.codex.toolName } : {}),
+      ...(existing.codex.toolInputSummary ? { toolInputSummary: existing.codex.toolInputSummary } : {}),
+      ...(existing.codex.toolResultStatus ? { toolResultStatus: existing.codex.toolResultStatus } : {}),
+      ...(existing.codex.agentId ? { agentId: existing.codex.agentId } : {}),
+      ...(existing.codex.agentType ? { agentType: existing.codex.agentType } : {}),
+      ...(existing.codex.parentSessionId ? { parentSessionId: existing.codex.parentSessionId } : {}),
+      ...(existing.codex.forkedFromId ? { forkedFromId: existing.codex.forkedFromId } : {}),
+    },
+  };
+}
+
+const MERGEABLE_FIELDS: (keyof CodexSessionMeta)[] = [
+  "hookEventType", "hookEventTime", "hookSeq",
+  "permissionMode", "startSource", "endReason",
+  "toolName", "toolInputSummary", "toolResultStatus",
+  "model", "parentSessionId", "forkedFromId",
+  "turnId", "attentionKind", "agentId", "agentType", "agentNickname", "agentRole",
+];
+
+export function mergeCodexMeta(
+  base: CodexSessionMeta,
+  incoming: Partial<CodexSessionMeta>,
+): CodexSessionMeta {
+  const result = { ...base };
+  for (const key of MERGEABLE_FIELDS) {
+    if (incoming[key] !== undefined) {
+      (result as Record<string, unknown>)[key] = incoming[key];
+    }
+  }
+  return result;
+}
+
+export function mergeHookIntoModel(model: SessionModel, hookData: Partial<SessionModel>, transcriptPath: string): SessionModel {
+  const hookCodex = hookData.codex ?? { sessionId: model.codex?.sessionId ?? model.id.replace(/^codex:/, ""), transcriptPath };
+  return {
+    ...model,
+    ...hookData,
+    state: (hookData.state as SessionState | undefined) ?? model.state,
+    hasAttention: hookData.hasAttention ?? model.hasAttention,
+    id: model.id,
+    source: model.source,
+    summary: hookData.summary ?? model.summary,
+    lastActivity: typeof hookData.lastActivity === "number" ? hookData.lastActivity : model.lastActivity,
+    activeTool: hookData.activeTool ?? model.activeTool,
+    detectionSource: "codex-hook",
+    codex: mergeCodexMeta(
+      {
+        sessionId: hookCodex.sessionId ?? model.codex?.sessionId ?? model.id.replace(/^codex:/, ""),
+        transcriptPath: hookCodex.transcriptPath || transcriptPath,
+      },
+      hookCodex,
+    ),
+  };
+}

package/src/daemon/collectors/codex/index.ts

@@ -0,0 +1,7 @@
+export { CodexCollector } from "./collector";
+export type { CodexHookFileData } from "./hooks";
+
+// Test-accessible pure functions (not part of collector public API,
+// but exported for direct unit testing without replicating logic)
+export { extractMeta } from "./transcript";
+export { mergeCodexMeta } from "./hooks";

package/src/daemon/collectors/codex/jsonl.ts

@@ -0,0 +1,108 @@
+import { closeSync, openSync, readFileSync, readSync, statSync } from "node:fs";
+
+export interface CodexJsonlEntry {
+  type?: string;
+  timestamp?: string;
+  model?: string;
+  payload?: Record<string, unknown>;
+  session_id?: string;
+  sessionId?: string;
+  id?: string;
+}
+
+export interface CodexResponseItem extends CodexJsonlEntry {
+  type: "response_item";
+  payload: {
+    type: string;
+    role?: string;
+    name?: string;
+    content?: unknown;
+    phase?: string;
+    [key: string]: unknown;
+  };
+}
+
+export interface CodexEventMsg extends CodexJsonlEntry {
+  type: "event_msg";
+  payload: {
+    type: string;
+    message?: string;
+    [key: string]: unknown;
+  };
+}
+
+export function isResponseItem(entry: CodexJsonlEntry): entry is CodexResponseItem {
+  return entry.type === "response_item";
+}
+
+export function isEventMsg(entry: CodexJsonlEntry): entry is CodexEventMsg {
+  return entry.type === "event_msg";
+}
+
+export function getResponseItemText(item: CodexResponseItem): string | undefined {
+  const content = item.payload.content;
+  if (!Array.isArray(content)) return undefined;
+  for (const block of content) {
+    if (
+      typeof block === "object" && block !== null
+      && ("type" in block)
+      && (
+        (block as { type: string }).type === "output_text"
+        || (block as { type: string }).type === "input_text"
+      )
+      && typeof (block as { text?: string }).text === "string"
+    ) {
+      return (block as { text: string }).text;
+    }
+  }
+  return undefined;
+}
+
+export function getResponseItemRole(item: CodexResponseItem): string | undefined {
+  return item.payload.role;
+}
+
+export function getFunctionCallName(item: CodexResponseItem): string | undefined {
+  if (item.payload.type !== "function_call") return undefined;
+  return typeof item.payload.name === "string" ? item.payload.name : undefined;
+}
+
+export function parseJsonlFile(path: string, maxBytes?: number): CodexJsonlEntry[] {
+  try {
+    const content = readTextTail(path, maxBytes);
+    return parseJsonlContent(content);
+  } catch {
+    return [];
+  }
+}
+
+export function parseJsonlContent(content: string): CodexJsonlEntry[] {
+  return content
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line) as CodexJsonlEntry;
+      } catch {
+        return null;
+      }
+    })
+    .filter((entry): entry is CodexJsonlEntry => entry !== null);
+}
+
+export function readTextTail(path: string, maxBytes?: number): string {
+  if (!maxBytes || maxBytes <= 0) return readFileSync(path, "utf8");
+  const stat = statSync(path);
+  if (stat.size <= maxBytes) return readFileSync(path, "utf8");
+
+  const fd = openSync(path, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(maxBytes);
+    readSync(fd, buffer, 0, maxBytes, stat.size - maxBytes);
+    const text = buffer.toString("utf8");
+    const firstNewline = text.indexOf("\n");
+    return firstNewline >= 0 ? text.slice(firstNewline + 1) : text;
+  } finally {
+    closeSync(fd);
+  }
+}