chatccc 0.2.199 → 0.2.200

package/src/adapters/jsonl-stream.ts

@@ -1,157 +1,157 @@
-import { createInterface } from "node:readline";
-
-interface JsonLineSink {
-  writeLine(line: string): void;
-}
-
-export const DEFAULT_BAD_JSON_IDLE_TIMEOUT_MS = 120_000;
-export const BAD_JSON_IDLE_TIMEOUT_CODE = "BAD_JSON_IDLE_TIMEOUT";
-
-export class BadJsonIdleTimeoutError extends Error {
-  readonly code = BAD_JSON_IDLE_TIMEOUT_CODE;
-  readonly tool: string;
-  readonly tag: string;
-  readonly timeoutMs: number;
-  readonly lineNumber: number;
-  readonly lineExcerpt: string;
-  readonly parseError: string;
-
-  constructor(args: {
-    tool: string;
-    tag: string;
-    timeoutMs: number;
-    lineNumber: number;
-    lineExcerpt: string;
-    parseError: string;
-  }) {
-    super(
-      `${args.tool} stream stopped after invalid JSON for ${args.timeoutMs}ms ` +
-        `(tag=${args.tag}, line=${args.lineNumber}): ${args.lineExcerpt}`,
-    );
-    this.name = "BadJsonIdleTimeoutError";
-    this.tool = args.tool;
-    this.tag = args.tag;
-    this.timeoutMs = args.timeoutMs;
-    this.lineNumber = args.lineNumber;
-    this.lineExcerpt = args.lineExcerpt;
-    this.parseError = args.parseError;
-  }
-}
-
-export interface ReadJsonLinesDoneInfo {
-  lineCount: number;
-  signalAborted: boolean;
-  protocolError: BadJsonIdleTimeoutError | null;
-}
-
-export interface ReadJsonLinesOptions<T> {
-  input: NodeJS.ReadableStream;
-  tool: string;
-  tag?: string;
-  signal?: AbortSignal;
-  rawLog?: JsonLineSink | null;
-  idleTimeoutMs?: number;
-  parse?: (line: string) => T;
-  onRawLine?: (line: string, lineNumber: number) => void;
-  onParsedLine?: (value: T, line: string, lineNumber: number) => void;
-  onDone?: (info: ReadJsonLinesDoneInfo) => void;
-}
-
-function isJsonLike(line: string): boolean {
-  return line.startsWith("{") || line.startsWith("[");
-}
-
-function lineExcerpt(line: string): string {
-  const max = 500;
-  return line.length <= max ? line : `${line.slice(0, max)}...`;
-}
-
-function parseErrorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-export async function* readJsonLinesWithBadJsonIdleWatchdog<T>({
-  input,
-  tool,
-  tag = tool,
-  signal,
-  rawLog,
-  idleTimeoutMs = DEFAULT_BAD_JSON_IDLE_TIMEOUT_MS,
-  parse = (line: string) => JSON.parse(line) as T,
-  onRawLine,
-  onParsedLine,
-  onDone,
-}: ReadJsonLinesOptions<T>): AsyncGenerator<T> {
-  const rl = createInterface({ input, crlfDelay: Infinity });
-  let lineCount = 0;
-  let protocolError: BadJsonIdleTimeoutError | null = null;
-  let badJsonIdleTimer: ReturnType<typeof setTimeout> | null = null;
-
-  const clearBadJsonIdleTimer = () => {
-    if (!badJsonIdleTimer) return;
-    clearTimeout(badJsonIdleTimer);
-    badJsonIdleTimer = null;
-  };
-
-  const armBadJsonIdleTimer = (line: string, lineNumber: number, error: unknown) => {
-    if (idleTimeoutMs <= 0) return;
-    clearBadJsonIdleTimer();
-    badJsonIdleTimer = setTimeout(() => {
-      protocolError = new BadJsonIdleTimeoutError({
-        tool,
-        tag,
-        timeoutMs: idleTimeoutMs,
-        lineNumber,
-        lineExcerpt: lineExcerpt(line),
-        parseError: parseErrorMessage(error),
-      });
-      rl.close();
-    }, idleTimeoutMs);
-    const timerWithUnref = badJsonIdleTimer as ReturnType<typeof setTimeout> & {
-      unref?: () => void;
-    };
-    timerWithUnref.unref?.();
-  };
-
-  const onAbort = () => {
-    clearBadJsonIdleTimer();
-    rl.close();
-  };
-  signal?.addEventListener("abort", onAbort, { once: true });
-
-  try {
-    for await (const line of rl) {
-      if (signal?.aborted) break;
-      lineCount++;
-      onRawLine?.(line, lineCount);
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-
-      clearBadJsonIdleTimer();
-      rawLog?.writeLine(trimmed);
-
-      try {
-        const parsed = parse(trimmed);
-        onParsedLine?.(parsed, trimmed, lineCount);
-        yield parsed;
-      } catch (error) {
-        if (isJsonLike(trimmed)) {
-          armBadJsonIdleTimer(trimmed, lineCount, error);
-        }
-      }
-    }
-
-    if (protocolError && !signal?.aborted) {
-      throw protocolError;
-    }
-  } finally {
-    signal?.removeEventListener("abort", onAbort);
-    clearBadJsonIdleTimer();
-    rl.close();
-    onDone?.({
-      lineCount,
-      signalAborted: signal?.aborted ?? false,
-      protocolError,
-    });
-  }
-}
+import { createInterface } from "node:readline";
+
+interface JsonLineSink {
+  writeLine(line: string): void;
+}
+
+export const DEFAULT_BAD_JSON_IDLE_TIMEOUT_MS = 120_000;
+export const BAD_JSON_IDLE_TIMEOUT_CODE = "BAD_JSON_IDLE_TIMEOUT";
+
+export class BadJsonIdleTimeoutError extends Error {
+  readonly code = BAD_JSON_IDLE_TIMEOUT_CODE;
+  readonly tool: string;
+  readonly tag: string;
+  readonly timeoutMs: number;
+  readonly lineNumber: number;
+  readonly lineExcerpt: string;
+  readonly parseError: string;
+
+  constructor(args: {
+    tool: string;
+    tag: string;
+    timeoutMs: number;
+    lineNumber: number;
+    lineExcerpt: string;
+    parseError: string;
+  }) {
+    super(
+      `${args.tool} stream stopped after invalid JSON for ${args.timeoutMs}ms ` +
+        `(tag=${args.tag}, line=${args.lineNumber}): ${args.lineExcerpt}`,
+    );
+    this.name = "BadJsonIdleTimeoutError";
+    this.tool = args.tool;
+    this.tag = args.tag;
+    this.timeoutMs = args.timeoutMs;
+    this.lineNumber = args.lineNumber;
+    this.lineExcerpt = args.lineExcerpt;
+    this.parseError = args.parseError;
+  }
+}
+
+export interface ReadJsonLinesDoneInfo {
+  lineCount: number;
+  signalAborted: boolean;
+  protocolError: BadJsonIdleTimeoutError | null;
+}
+
+export interface ReadJsonLinesOptions<T> {
+  input: NodeJS.ReadableStream;
+  tool: string;
+  tag?: string;
+  signal?: AbortSignal;
+  rawLog?: JsonLineSink | null;
+  idleTimeoutMs?: number;
+  parse?: (line: string) => T;
+  onRawLine?: (line: string, lineNumber: number) => void;
+  onParsedLine?: (value: T, line: string, lineNumber: number) => void;
+  onDone?: (info: ReadJsonLinesDoneInfo) => void;
+}
+
+function isJsonLike(line: string): boolean {
+  return line.startsWith("{") || line.startsWith("[");
+}
+
+function lineExcerpt(line: string): string {
+  const max = 500;
+  return line.length <= max ? line : `${line.slice(0, max)}...`;
+}
+
+function parseErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export async function* readJsonLinesWithBadJsonIdleWatchdog<T>({
+  input,
+  tool,
+  tag = tool,
+  signal,
+  rawLog,
+  idleTimeoutMs = DEFAULT_BAD_JSON_IDLE_TIMEOUT_MS,
+  parse = (line: string) => JSON.parse(line) as T,
+  onRawLine,
+  onParsedLine,
+  onDone,
+}: ReadJsonLinesOptions<T>): AsyncGenerator<T> {
+  const rl = createInterface({ input, crlfDelay: Infinity });
+  let lineCount = 0;
+  let protocolError: BadJsonIdleTimeoutError | null = null;
+  let badJsonIdleTimer: ReturnType<typeof setTimeout> | null = null;
+
+  const clearBadJsonIdleTimer = () => {
+    if (!badJsonIdleTimer) return;
+    clearTimeout(badJsonIdleTimer);
+    badJsonIdleTimer = null;
+  };
+
+  const armBadJsonIdleTimer = (line: string, lineNumber: number, error: unknown) => {
+    if (idleTimeoutMs <= 0) return;
+    clearBadJsonIdleTimer();
+    badJsonIdleTimer = setTimeout(() => {
+      protocolError = new BadJsonIdleTimeoutError({
+        tool,
+        tag,
+        timeoutMs: idleTimeoutMs,
+        lineNumber,
+        lineExcerpt: lineExcerpt(line),
+        parseError: parseErrorMessage(error),
+      });
+      rl.close();
+    }, idleTimeoutMs);
+    const timerWithUnref = badJsonIdleTimer as ReturnType<typeof setTimeout> & {
+      unref?: () => void;
+    };
+    timerWithUnref.unref?.();
+  };
+
+  const onAbort = () => {
+    clearBadJsonIdleTimer();
+    rl.close();
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+
+  try {
+    for await (const line of rl) {
+      if (signal?.aborted) break;
+      lineCount++;
+      onRawLine?.(line, lineCount);
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      clearBadJsonIdleTimer();
+      rawLog?.writeLine(trimmed);
+
+      try {
+        const parsed = parse(trimmed);
+        onParsedLine?.(parsed, trimmed, lineCount);
+        yield parsed;
+      } catch (error) {
+        if (isJsonLike(trimmed)) {
+          armBadJsonIdleTimer(trimmed, lineCount, error);
+        }
+      }
+    }
+
+    if (protocolError && !signal?.aborted) {
+      throw protocolError;
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    clearBadJsonIdleTimer();
+    rl.close();
+    onDone?.({
+      lineCount,
+      signalAborted: signal?.aborted ?? false,
+      protocolError,
+    });
+  }
+}

package/src/adapters/raw-stream-log.ts

@@ -1,124 +1,124 @@
-import { createWriteStream, type Dirent } from "node:fs";
-import { mkdir, readdir, rm, stat, unlink } from "node:fs/promises";
-import { once } from "node:events";
-import { join } from "node:path";
-import { createGzip } from "node:zlib";
-
-export interface RawStreamLogOptions {
-  enabled: boolean;
-  rootDir: string;
-  tool: string;
-  sessionId: string;
-  label: string;
-  maxBytesPerTurn: number;
-  retentionDays: number;
-}
-
-export interface RawStreamLogHandle {
-  filePath: string;
-  writeLine(line: string): void;
-  close(options: { keep: boolean }): Promise<void>;
-}
-
-export function sanitizeLogPathSegment(value: string): string {
-  const safe = value.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^[._]+|_+$/g, "");
-  return safe || "unknown";
-}
-
-async function cleanupOldRawStreamLogs(rootDir: string, retentionDays: number): Promise<void> {
-  if (!Number.isFinite(retentionDays) || retentionDays <= 0) return;
-  const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
-
-  const visit = async (dir: string): Promise<void> => {
-    let entries: Dirent[];
-    try {
-      entries = await readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-
-    await Promise.all(entries.map(async (entry) => {
-      const path = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await visit(path);
-        try {
-          await rm(path, { recursive: false });
-        } catch {
-          // Directory is not empty or already gone.
-        }
-        return;
-      }
-
-      if (!entry.isFile()) return;
-      try {
-        const info = await stat(path);
-        if (info.mtimeMs < cutoff) await rm(path, { force: true });
-      } catch {
-        // Best-effort cleanup only.
-      }
-    }));
-  };
-
-  await visit(rootDir);
-}
-
-export async function createRawStreamLog(options: RawStreamLogOptions): Promise<RawStreamLogHandle | null> {
-  if (!options.enabled) return null;
-
-  const maxBytes = Math.max(0, Math.floor(options.maxBytesPerTurn));
-  const tool = sanitizeLogPathSegment(options.tool);
-  const session = sanitizeLogPathSegment(options.sessionId);
-  const label = sanitizeLogPathSegment(options.label);
-  const dir = join(options.rootDir, tool, session);
-  await mkdir(dir, { recursive: true });
-  void cleanupOldRawStreamLogs(join(options.rootDir, tool), options.retentionDays);
-
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const filePath = join(dir, `${timestamp}-${label}.jsonl.gz`);
-  const output = createWriteStream(filePath);
-  const gzip = createGzip();
-  gzip.pipe(output);
-
-  let bytes = 0;
-  let truncated = false;
-  let ended = false;
-
-  const writeLine = (line: string): void => {
-    if (ended || truncated) return;
-    const payload = `${line}\n`;
-    const payloadBytes = Buffer.byteLength(payload, "utf-8");
-    if (maxBytes > 0 && bytes + payloadBytes > maxBytes) {
-      const marker = JSON.stringify({
-        type: "chatccc_raw_stream_log_truncated",
-        reason: "max_bytes_per_turn_exceeded",
-        maxBytesPerTurn: maxBytes,
-        writtenBytes: bytes,
-      });
-      gzip.write(`${marker}\n`);
-      truncated = true;
-      return;
-    }
-    bytes += payloadBytes;
-    gzip.write(payload);
-  };
-
-  const close = async ({ keep }: { keep: boolean }): Promise<void> => {
-    if (ended) return;
-    ended = true;
-    gzip.end();
-    try {
-      await once(output, "finish");
-    } catch {
-      // Ignore close errors; caller cannot recover from debug log failures.
-    }
-    if (!keep) {
-      try {
-        await unlink(filePath);
-      } catch {
-        // Best-effort cleanup only.
-      }
-    }
-  };
-
-  return { filePath, writeLine, close };
-}
+import { createWriteStream, type Dirent } from "node:fs";
+import { mkdir, readdir, rm, stat, unlink } from "node:fs/promises";
+import { once } from "node:events";
+import { join } from "node:path";
+import { createGzip } from "node:zlib";
+
+export interface RawStreamLogOptions {
+  enabled: boolean;
+  rootDir: string;
+  tool: string;
+  sessionId: string;
+  label: string;
+  maxBytesPerTurn: number;
+  retentionDays: number;
+}
+
+export interface RawStreamLogHandle {
+  filePath: string;
+  writeLine(line: string): void;
+  close(options: { keep: boolean }): Promise<void>;
+}
+
+export function sanitizeLogPathSegment(value: string): string {
+  const safe = value.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^[._]+|_+$/g, "");
+  return safe || "unknown";
+}
+
+async function cleanupOldRawStreamLogs(rootDir: string, retentionDays: number): Promise<void> {
+  if (!Number.isFinite(retentionDays) || retentionDays <= 0) return;
+  const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+
+  const visit = async (dir: string): Promise<void> => {
+    let entries: Dirent[];
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    await Promise.all(entries.map(async (entry) => {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await visit(path);
+        try {
+          await rm(path, { recursive: false });
+        } catch {
+          // Directory is not empty or already gone.
+        }
+        return;
+      }
+
+      if (!entry.isFile()) return;
+      try {
+        const info = await stat(path);
+        if (info.mtimeMs < cutoff) await rm(path, { force: true });
+      } catch {
+        // Best-effort cleanup only.
+      }
+    }));
+  };
+
+  await visit(rootDir);
+}
+
+export async function createRawStreamLog(options: RawStreamLogOptions): Promise<RawStreamLogHandle | null> {
+  if (!options.enabled) return null;
+
+  const maxBytes = Math.max(0, Math.floor(options.maxBytesPerTurn));
+  const tool = sanitizeLogPathSegment(options.tool);
+  const session = sanitizeLogPathSegment(options.sessionId);
+  const label = sanitizeLogPathSegment(options.label);
+  const dir = join(options.rootDir, tool, session);
+  await mkdir(dir, { recursive: true });
+  void cleanupOldRawStreamLogs(join(options.rootDir, tool), options.retentionDays);
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const filePath = join(dir, `${timestamp}-${label}.jsonl.gz`);
+  const output = createWriteStream(filePath);
+  const gzip = createGzip();
+  gzip.pipe(output);
+
+  let bytes = 0;
+  let truncated = false;
+  let ended = false;
+
+  const writeLine = (line: string): void => {
+    if (ended || truncated) return;
+    const payload = `${line}\n`;
+    const payloadBytes = Buffer.byteLength(payload, "utf-8");
+    if (maxBytes > 0 && bytes + payloadBytes > maxBytes) {
+      const marker = JSON.stringify({
+        type: "chatccc_raw_stream_log_truncated",
+        reason: "max_bytes_per_turn_exceeded",
+        maxBytesPerTurn: maxBytes,
+        writtenBytes: bytes,
+      });
+      gzip.write(`${marker}\n`);
+      truncated = true;
+      return;
+    }
+    bytes += payloadBytes;
+    gzip.write(payload);
+  };
+
+  const close = async ({ keep }: { keep: boolean }): Promise<void> => {
+    if (ended) return;
+    ended = true;
+    gzip.end();
+    try {
+      await once(output, "finish");
+    } catch {
+      // Ignore close errors; caller cannot recover from debug log failures.
+    }
+    if (!keep) {
+      try {
+        await unlink(filePath);
+      } catch {
+        // Best-effort cleanup only.
+      }
+    }
+  };
+
+  return { filePath, writeLine, close };
+}