@scrylog/cli 0.2.0 → 0.3.1

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

@@ -1,104 +0,0 @@
-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

@@ -1,179 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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);
-  }
-}