@cursor/bdk 0.2.3 → 0.2.4

package/src/internal/event-log.ts

@@ -1,342 +0,0 @@
-/**
- * Durable, replayable per-session event log. `events.ndjson` is the source
- * of truth. The process keeps `nextIndex`, live subscribers, and a short
- * unflushed tail — not a cache of the full transcript. Replay reads the
- * file on demand; live streams subscribe first, then catch up by index.
- *
- * Hosted engines mint thousands of sessions (one per PR under
- * agentic-owners). Retaining every streamed tool output in RAM for the
- * process lifetime is what OOM'd those engines at the ~4 GB heap cap.
- */
-
-import { appendFile, type FileHandle, mkdir, open } from "node:fs/promises";
-import { dirname } from "node:path";
-import { createInterface } from "node:readline";
-import type { SessionEvent, SessionEventPayload } from "../types.js";
-
-export type AppendableEvent = SessionEventPayload & { turnId?: string };
-
-function isEnoent(error: unknown): boolean {
-  return (
-    typeof error === "object" &&
-    error !== null &&
-    "code" in error &&
-    (error as { code: unknown }).code === "ENOENT"
-  );
-}
-
-function parseEventLine(line: string): SessionEvent | undefined {
-  const trimmed = line.trim();
-  if (trimmed === "") {
-    return undefined;
-  }
-  try {
-    return JSON.parse(trimmed) as SessionEvent;
-  } catch {
-    // Skip torn trailing writes from a crashed process.
-    return undefined;
-  }
-}
-
-async function readNdjsonEvents(
-  filePath: string,
-  onEvent: (event: SessionEvent) => void,
-): Promise<void> {
-  let fh: FileHandle;
-  try {
-    fh = await open(filePath, "r");
-  } catch (error) {
-    if (isEnoent(error)) {
-      return;
-    }
-    throw error;
-  }
-  const stream = fh.createReadStream({ encoding: "utf8" });
-  const rl = createInterface({ input: stream, crlfDelay: Infinity });
-  try {
-    for await (const line of rl) {
-      const event = parseEventLine(line);
-      if (event !== undefined) {
-        onEvent(event);
-      }
-    }
-  } finally {
-    rl.close();
-    stream.destroy();
-    await fh.close().catch(() => {});
-  }
-}
-
-export class SessionEventLog {
-  private nextIndex = 0;
-  private readonly listeners = new Set<(event: SessionEvent) => void>();
-  private persistChain: Promise<void> = Promise.resolve();
-  /** Appended events whose `appendFile` has not finished. */
-  private readonly inflight: SessionEvent[] = [];
-  /**
-   * In-process patches (cloud cost backfill) that are not rewritten to
-   * `events.ndjson`. Applied on read.
-   */
-  private readonly replacements = new Map<number, SessionEvent>();
-
-  private constructor(
-    private readonly sessionId: string,
-    private readonly filePath: string,
-    private readonly onPersistError: (error: unknown) => void,
-  ) {}
-
-  static async open(args: {
-    sessionId: string;
-    filePath: string;
-    onPersistError?: (error: unknown) => void;
-  }): Promise<SessionEventLog> {
-    const log = new SessionEventLog(
-      args.sessionId,
-      args.filePath,
-      args.onPersistError ?? (() => {}),
-    );
-    await log.readNextIndex();
-    return log;
-  }
-
-  private async readNextIndex(): Promise<void> {
-    let next = 0;
-    await readNdjsonEvents(this.filePath, event => {
-      if (typeof event.index === "number" && event.index >= next) {
-        next = event.index + 1;
-      }
-    });
-    this.nextIndex = next;
-  }
-
-  get count(): number {
-    return this.nextIndex;
-  }
-
-  /**
-   * In-process residency vs recorded length. `eventsTotal` is the durable
-   * count (`nextIndex`). `eventsRetained` is the unflushed tail — the
-   * transcript is not cached after `appendFile` lands.
-   */
-  memoryStats(): { eventsRetained: number; eventsTotal: number } {
-    return {
-      eventsRetained: this.inflight.length,
-      eventsTotal: this.nextIndex,
-    };
-  }
-
-  /**
-   * Assign the next index and fan out to live subscribers. Ordering is
-   * synchronous; file persistence is chained in the background and awaited
-   * by {@link flush}. The event is not retained after the write lands.
-   */
-  append(payload: AppendableEvent): SessionEvent {
-    const { turnId, ...rest } = payload;
-    const event = {
-      index: this.nextIndex,
-      sessionId: this.sessionId,
-      ...(turnId === undefined ? {} : { turnId }),
-      at: new Date().toISOString(),
-      ...rest,
-    } as SessionEvent;
-    this.nextIndex += 1;
-    this.inflight.push(event);
-    for (const listener of [...this.listeners]) {
-      try {
-        listener(event);
-      } catch {
-        // Subscriber errors must not break the log.
-      }
-    }
-    const line = `${JSON.stringify(event)}\n`;
-    const index = event.index;
-    this.persistChain = this.persistChain
-      .then(() => appendFile(this.filePath, line, "utf8"))
-      .then(() => {
-        this.dropInflight(index);
-      })
-      .catch(error => this.onPersistError(error));
-    return event;
-  }
-
-  private dropInflight(index: number): void {
-    if (this.inflight[0]?.index === index) {
-      this.inflight.shift();
-      return;
-    }
-    const i = this.inflight.findIndex(event => event.index === index);
-    if (i >= 0) {
-      this.inflight.splice(i, 1);
-    }
-  }
-
-  /** Wait for pending file writes (used on close). */
-  async flush(): Promise<void> {
-    await this.persistChain;
-  }
-
-  /**
-   * Read recorded events from `startIndex`. Does not retain the result on
-   * the log; callers own the returned array.
-   */
-  async snapshot(startIndex = 0): Promise<SessionEvent[]> {
-    const byIndex = new Map<number, SessionEvent>();
-    await readNdjsonEvents(this.filePath, event => {
-      if (event.index >= startIndex) {
-        byIndex.set(event.index, event);
-      }
-    });
-    for (const event of this.inflight) {
-      if (event.index >= startIndex) {
-        byIndex.set(event.index, event);
-      }
-    }
-    for (const [index, event] of this.replacements) {
-      if (index >= startIndex) {
-        byIndex.set(index, event);
-      }
-    }
-    return [...byIndex.values()].sort((a, b) => a.index - b.index);
-  }
-
-  /**
-   * Replace one already-recorded event in this process. Used to backfill
-   * usage/cost onto historical `turn.completed` rows without rewriting
-   * `events.ndjson`. Live subscribers are not notified — patch before
-   * opening a replay stream.
-   */
-  replace(index: number, event: SessionEvent): boolean {
-    if (index < 0 || index >= this.nextIndex || event.index !== index) {
-      return false;
-    }
-    this.replacements.set(index, event);
-    return true;
-  }
-
-  subscribe(listener: (event: SessionEvent) => void): () => void {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-
-  /**
-   * NDJSON stream: replays recorded events from `startIndex`, then follows
-   * live events until the consumer cancels.
-   *
-   * Subscribe first (buffer live events), then read the file, then drain
-   * the buffer by index so an async file read cannot drop or duplicate
-   * events that arrive during catch-up.
-   */
-  stream(startIndex = 0): ReadableStream<Uint8Array> {
-    const encoder = new TextEncoder();
-    let unsubscribe: (() => void) | undefined;
-    return new ReadableStream<Uint8Array>({
-      start: async controller => {
-        const push = (event: SessionEvent): void => {
-          try {
-            controller.enqueue(encoder.encode(`${JSON.stringify(event)}\n`));
-          } catch {
-            unsubscribe?.();
-          }
-        };
-        let following = false;
-        const buffered: SessionEvent[] = [];
-        unsubscribe = this.subscribe(event => {
-          if (event.index < startIndex) {
-            return;
-          }
-          if (following) {
-            push(event);
-          } else {
-            buffered.push(event);
-          }
-        });
-        try {
-          const prefix = await this.snapshot(startIndex);
-          let maxSeen = startIndex - 1;
-          for (const event of prefix) {
-            push(event);
-            if (event.index > maxSeen) {
-              maxSeen = event.index;
-            }
-          }
-          following = true;
-          for (const event of buffered) {
-            if (event.index > maxSeen) {
-              push(event);
-              maxSeen = event.index;
-            }
-          }
-        } catch (error) {
-          unsubscribe?.();
-          controller.error(error);
-        }
-      },
-      cancel: () => {
-        unsubscribe?.();
-      },
-    });
-  }
-}
-
-export type EventLogMemoryStats = {
-  residentSessions: number;
-  eventsRetained: number;
-  eventsTotal: number;
-};
-
-/** Lazily opens one {@link SessionEventLog} per session. */
-export class EventLogStore {
-  private readonly logs = new Map<string, Promise<SessionEventLog>>();
-  private readonly opened = new Map<string, SessionEventLog>();
-
-  constructor(
-    private readonly eventFilePathFor: (sessionId: string) => string,
-    private readonly onPersistError: (sessionId: string, error: unknown) => void = () => {},
-  ) {}
-
-  get(sessionId: string): Promise<SessionEventLog> {
-    let log = this.logs.get(sessionId);
-    if (log === undefined) {
-      const filePath = this.eventFilePathFor(sessionId);
-      log = mkdir(dirname(filePath), { recursive: true })
-        .then(() =>
-          SessionEventLog.open({
-            sessionId,
-            filePath,
-            onPersistError: error => this.onPersistError(sessionId, error),
-          }),
-        )
-        .then(opened => {
-          this.opened.set(sessionId, opened);
-          return opened;
-        });
-      this.logs.set(sessionId, log);
-    }
-    return log;
-  }
-
-  memoryStats(): EventLogMemoryStats {
-    let eventsRetained = 0;
-    let eventsTotal = 0;
-    for (const log of this.opened.values()) {
-      const stats = log.memoryStats();
-      eventsRetained += stats.eventsRetained;
-      eventsTotal += stats.eventsTotal;
-    }
-    return {
-      residentSessions: this.logs.size,
-      eventsRetained,
-      eventsTotal,
-    };
-  }
-
-  async flushAll(): Promise<void> {
-    await Promise.all(
-      [...this.logs.values()].map(logPromise =>
-        logPromise.then(log => log.flush()).catch(() => {}),
-      ),
-    );
-  }
-}