@tonyclaw/agent-inspector 4.0.1 → 4.0.2

package/src/proxy/logSearch.ts

@@ -1,122 +0,0 @@
-import type { CapturedLog } from "./schemas";
-import { listLogsPage } from "./store";
-
-export const LOG_SEARCH_DEFAULT_LIMIT = 10;
-export const LOG_SEARCH_MAX_LIMIT = 50;
-export const LOG_SEARCH_DEFAULT_SCAN_LIMIT = 200;
-export const LOG_SEARCH_MAX_SCAN_LIMIT = 1_000;
-
-export type LogSearchOptions = {
-  query: string;
-  sessionId?: string;
-  model?: string;
-  clientPid?: number;
-  offset: number;
-  limit: number;
-  scanLimit: number;
-};
-
-export type LogSearchResult = {
-  query: string;
-  logs: CapturedLog[];
-  total: number;
-  offset: number;
-  limit: number;
-  scanned: number;
-};
-
-function clampPositiveInt(value: number, fallback: number, max: number): number {
-  if (!Number.isInteger(value) || value < 1) return fallback;
-  return Math.min(value, max);
-}
-
-export function clampLogSearchLimit(value: number): number {
-  return clampPositiveInt(value, LOG_SEARCH_DEFAULT_LIMIT, LOG_SEARCH_MAX_LIMIT);
-}
-
-export function clampLogSearchScanLimit(value: number): number {
-  return clampPositiveInt(value, LOG_SEARCH_DEFAULT_SCAN_LIMIT, LOG_SEARCH_MAX_SCAN_LIMIT);
-}
-
-function queryTerms(query: string): string[] {
-  return query
-    .trim()
-    .toLowerCase()
-    .split(/\s+/)
-    .filter((term) => term.length > 0);
-}
-
-function optionalText(value: string | number | boolean | null | undefined): string | null {
-  if (value === null || value === undefined) return null;
-  return String(value);
-}
-
-function searchableFields(log: CapturedLog): string[] {
-  return [
-    String(log.id),
-    log.timestamp,
-    log.method,
-    log.path,
-    optionalText(log.model),
-    optionalText(log.sessionId),
-    optionalText(log.responseStatus),
-    optionalText(log.elapsedMs),
-    optionalText(log.streaming),
-    log.streaming ? "streaming" : "non-streaming",
-    log.apiFormat,
-    optionalText(log.providerName),
-    optionalText(log.userAgent),
-    optionalText(log.origin),
-    optionalText(log.clientPid),
-    optionalText(log.clientCwd),
-    optionalText(log.clientProjectFolder),
-    optionalText(log.error),
-    ...(log.warnings ?? []),
-  ].filter((value): value is string => value !== null && value.length > 0);
-}
-
-function matchesTerms(log: CapturedLog, terms: readonly string[]): boolean {
-  if (terms.length === 0) return true;
-  const haystack = searchableFields(log).join("\n").toLowerCase();
-  return terms.every((term) => haystack.includes(term));
-}
-
-function sortNewestFirst(logs: CapturedLog[]): CapturedLog[] {
-  return logs.sort((left, right) => {
-    const timestampCompare = right.timestamp.localeCompare(left.timestamp);
-    return timestampCompare !== 0 ? timestampCompare : right.id - left.id;
-  });
-}
-
-export async function searchLogsPage(options: LogSearchOptions): Promise<LogSearchResult> {
-  const limit = clampLogSearchLimit(options.limit);
-  const scanLimit = clampLogSearchScanLimit(Math.max(options.scanLimit, options.offset + limit));
-  const firstPage = await listLogsPage({
-    sessionId: options.sessionId,
-    model: options.model,
-    clientPid: options.clientPid,
-    offset: 0,
-    limit: 1,
-    includeBodies: false,
-  });
-  const scanOffset = Math.max(firstPage.total - scanLimit, 0);
-  const scanPage = await listLogsPage({
-    sessionId: options.sessionId,
-    model: options.model,
-    clientPid: options.clientPid,
-    offset: scanOffset,
-    limit: scanLimit,
-    includeBodies: false,
-  });
-  const terms = queryTerms(options.query);
-  const matches = sortNewestFirst(scanPage.logs.filter((log) => matchesTerms(log, terms)));
-
-  return {
-    query: options.query,
-    logs: matches.slice(options.offset, options.offset + limit),
-    total: matches.length,
-    offset: options.offset,
-    limit,
-    scanned: scanPage.logs.length,
-  };
-}

package/src/proxy/logger.ts

@@ -1,537 +0,0 @@
-import { Buffer } from "node:buffer";
-import { closeSync, constants, fsyncSync, openSync, writeSync } from "node:fs";
-import { appendFile, readdir, rename, stat, unlink } from "node:fs/promises";
-import path from "node:path";
-import { getDataDir } from "./dataDir";
-import {
-  ensurePrivateDirectorySync,
-  PRIVATE_FILE_MODE,
-  securePrivateFileSync,
-  securePrivateTreeSync,
-} from "./privateDataPath";
-import {
-  canAppendCapturedLogFileOnExit,
-  markCapturedLogFileAppended,
-  recoverCapturedLogFileBeforeAppend,
-  recoverCapturedLogStorage,
-} from "./jsonlRecovery";
-
-const DAY_MS = 24 * 60 * 60 * 1000;
-const DEFAULT_RETENTION_DAYS = 7;
-const DEFAULT_APP_LOG_MAX_BYTES = 10 * 1024 * 1024;
-const DEFAULT_APP_LOG_MAX_FILES = 5;
-
-type ApplicationLogPolicy = {
-  maxBytes: number;
-  maxFiles: number;
-  retentionMs: number;
-};
-
-type ApplicationLogFile = {
-  generation: number;
-  modifiedAt: number;
-  path: string;
-};
-
-function writeStderrFallback(message: string, error: unknown): void {
-  process.stderr.write(`${message} ${String(error)}\n`);
-}
-
-export function resolveLogDir(): string {
-  const logDirEnv = process.env["LOG_DIR"];
-  if (logDirEnv !== undefined && logDirEnv !== "") {
-    return path.isAbsolute(logDirEnv) ? logDirEnv : path.join(getDataDir(), logDirEnv);
-  }
-  return path.join(getDataDir(), "logs");
-}
-
-export function getLogFilePath(): string {
-  const date = new Date();
-  const yyyy = date.getUTCFullYear();
-  const mm = String(date.getUTCMonth() + 1).padStart(2, "0");
-  const dd = String(date.getUTCDate()).padStart(2, "0");
-  return path.join(resolveLogDir(), `${yyyy}-${mm}-${dd}.jsonl`);
-}
-
-function getInspectorLogPath(): string {
-  const logFileEnv = process.env["AGENT_INSPECTOR_LOG_FILE"];
-  if (logFileEnv !== undefined && logFileEnv !== "") {
-    return logFileEnv;
-  }
-  return path.join(getDataDir(), "logs", "inspector.log");
-}
-
-export function resolveApplicationLogPath(): string {
-  return getInspectorLogPath();
-}
-
-function readBoundedInteger(
-  name: string,
-  fallback: number,
-  minimum: number,
-  maximum: number,
-): number {
-  const raw = process.env[name];
-  if (raw === undefined || raw === "") return fallback;
-  const parsed = Number(raw);
-  if (!Number.isInteger(parsed) || parsed < minimum || parsed > maximum) return fallback;
-  return parsed;
-}
-
-function getApplicationLogPolicy(): ApplicationLogPolicy {
-  const retentionDays = readBoundedInteger("LOG_RETENTION_DAYS", DEFAULT_RETENTION_DAYS, 1, 3650);
-  return {
-    maxBytes: readBoundedInteger(
-      "AGENT_INSPECTOR_APP_LOG_MAX_BYTES",
-      DEFAULT_APP_LOG_MAX_BYTES,
-      1,
-      1024 * 1024 * 1024,
-    ),
-    maxFiles: readBoundedInteger(
-      "AGENT_INSPECTOR_APP_LOG_MAX_FILES",
-      DEFAULT_APP_LOG_MAX_FILES,
-      1,
-      100,
-    ),
-    retentionMs: retentionDays * DAY_MS,
-  };
-}
-
-function getRotatedGeneration(entry: string, baseName: string): number | null {
-  const prefix = `${baseName}.`;
-  if (!entry.startsWith(prefix)) return null;
-  const suffix = entry.slice(prefix.length);
-  if (!/^\d+$/.test(suffix)) return null;
-  const generation = Number(suffix);
-  if (!Number.isSafeInteger(generation) || generation < 1) return null;
-  return generation;
-}
-
-async function listApplicationLogFiles(logPath: string): Promise<ApplicationLogFile[]> {
-  const directory = path.dirname(logPath);
-  const baseName = path.basename(logPath);
-  const entries = await readdir(directory);
-  const files: ApplicationLogFile[] = [];
-
-  for (const entry of entries) {
-    const generation = entry === baseName ? 0 : getRotatedGeneration(entry, baseName);
-    if (generation === null) continue;
-    const filePath = path.join(directory, entry);
-    try {
-      const fileStat = await stat(filePath);
-      if (!fileStat.isFile()) continue;
-      files.push({ generation, modifiedAt: fileStat.mtimeMs, path: filePath });
-    } catch {
-      // The file may have been removed by another maintenance pass.
-    }
-  }
-
-  return files;
-}
-
-async function removeApplicationLog(filePath: string): Promise<boolean> {
-  try {
-    await stat(filePath);
-  } catch {
-    return true;
-  }
-  try {
-    await unlink(filePath);
-    return true;
-  } catch {
-    // Retention is best-effort; a later maintenance pass retries failed removals.
-    return false;
-  }
-}
-
-async function maintainApplicationLogs(
-  logPath: string,
-  policy: ApplicationLogPolicy,
-): Promise<boolean> {
-  const directory = path.dirname(logPath);
-  if (!ensurePrivateDirectorySync(directory)) return false;
-
-  let files: ApplicationLogFile[];
-  try {
-    files = await listApplicationLogFiles(logPath);
-  } catch {
-    return false;
-  }
-
-  for (const file of files) {
-    if (!securePrivateFileSync(file.path)) return false;
-  }
-
-  const cutoff = Date.now() - policy.retentionMs;
-  const retained = files.filter((file) => file.modifiedAt >= cutoff);
-  let maintained = true;
-  for (const file of files) {
-    if (file.modifiedAt < cutoff && !(await removeApplicationLog(file.path))) maintained = false;
-  }
-
-  const rotated = retained
-    .filter((file) => file.generation > 0)
-    .sort((left, right) => right.modifiedAt - left.modifiedAt);
-  const retainedRotatedCount = Math.max(0, policy.maxFiles - 1);
-  for (const file of rotated.slice(retainedRotatedCount)) {
-    if (!(await removeApplicationLog(file.path))) maintained = false;
-  }
-
-  return maintained;
-}
-
-async function moveApplicationLog(source: string, destination: string): Promise<boolean> {
-  try {
-    await stat(source);
-  } catch {
-    return true;
-  }
-  try {
-    await rename(source, destination);
-    if (!securePrivateFileSync(destination)) {
-      writeStderrFallback("[logger] Failed to secure rotated application log:", destination);
-      return false;
-    }
-    return true;
-  } catch (error) {
-    writeStderrFallback("[logger] Failed to rotate application log:", error);
-    return false;
-  }
-}
-
-async function rotateApplicationLog(logPath: string, maxFiles: number): Promise<boolean> {
-  if (maxFiles === 1) {
-    return await removeApplicationLog(logPath);
-  }
-
-  if (!(await removeApplicationLog(`${logPath}.${String(maxFiles - 1)}`))) return false;
-  for (let generation = maxFiles - 2; generation >= 1; generation -= 1) {
-    if (
-      !(await moveApplicationLog(
-        `${logPath}.${String(generation)}`,
-        `${logPath}.${String(generation + 1)}`,
-      ))
-    ) {
-      return false;
-    }
-  }
-  return await moveApplicationLog(logPath, `${logPath}.1`);
-}
-
-async function rotateApplicationLogIfNeeded(
-  logPath: string,
-  incomingBytes: number,
-  policy: ApplicationLogPolicy,
-): Promise<boolean> {
-  try {
-    const fileStat = await stat(logPath);
-    if (fileStat.size > 0 && fileStat.size + incomingBytes > policy.maxBytes) {
-      return await rotateApplicationLog(logPath, policy.maxFiles);
-    }
-    return true;
-  } catch {
-    // The active file does not exist yet.
-    return true;
-  }
-}
-
-export async function initLogger(): Promise<void> {
-  const dir = resolveLogDir();
-  const policy = getApplicationLogPolicy();
-  const cutoff = Date.now() - policy.retentionMs;
-
-  try {
-    if (!ensurePrivateDirectorySync(dir)) {
-      writeStderrFallback("[logger] Failed to secure log directory:", dir);
-    } else if (!securePrivateTreeSync(dir)) {
-      writeStderrFallback("[logger] Failed to secure existing log files:", dir);
-    } else {
-      const recovery = await recoverCapturedLogStorage(dir);
-      if (recovery.level === "unavailable") {
-        writeStderrFallback(
-          "[logger] Captured-log recovery blocked readiness:",
-          recovery.diagnostic ?? "unknown recovery failure",
-        );
-      } else {
-        const entries = await readdir(dir);
-        for (const entry of entries) {
-          if (!entry.endsWith(".jsonl")) continue;
-          const fullPath = path.join(dir, entry);
-          try {
-            const s = await stat(fullPath);
-            if (s.mtimeMs < cutoff) {
-              await unlink(fullPath);
-            }
-          } catch {
-            // Skip files that can't be stat - not critical
-          }
-        }
-      }
-    }
-  } catch (err) {
-    // Log directory initialization errors but don't fail startup
-    writeStderrFallback("[logger] Failed to initialize log directory:", err);
-  }
-
-  const applicationLogPath = getInspectorLogPath();
-  if (!(await maintainApplicationLogs(applicationLogPath, policy))) {
-    writeStderrFallback(
-      "[logger] Failed to initialize application log lifecycle:",
-      applicationLogPath,
-    );
-  }
-}
-
-// File-based logger for application logs (not log entries)
-let loggerInitialization: Promise<void> | null = null;
-let applicationLogWriteQueue: Promise<void> = Promise.resolve();
-let lastApplicationLogWriteFailureKey: string | null = null;
-let lastApplicationLogWriteFailureAt = 0;
-const APPLICATION_LOG_WRITE_FAILURE_SUPPRESS_MS = 5_000;
-
-type ApplicationLogWriteResult = { ok: true } | { ok: false; reason: unknown };
-
-function ensureLoggerInitialized(): Promise<void> {
-  if (loggerInitialization === null) loggerInitialization = initLogger();
-  return loggerInitialization;
-}
-
-async function appendApplicationLogLine(
-  logPath: string,
-  line: string,
-  policy: ApplicationLogPolicy,
-): Promise<ApplicationLogWriteResult> {
-  const logDirPath = path.dirname(logPath);
-  if (!ensurePrivateDirectorySync(logDirPath)) {
-    return { ok: false, reason: "application log directory is not private" };
-  }
-  try {
-    if (!(await rotateApplicationLogIfNeeded(logPath, Buffer.byteLength(line, "utf-8"), policy))) {
-      return { ok: false, reason: "application log rotation failed" };
-    }
-    await appendFile(logPath, line, { encoding: "utf-8", mode: PRIVATE_FILE_MODE });
-    if (!securePrivateFileSync(logPath)) {
-      return { ok: false, reason: "application log permissions could not be secured" };
-    }
-    return { ok: true };
-  } catch (error) {
-    return { ok: false, reason: error };
-  }
-}
-
-/** Isolated lifecycle hook used by the rotation tests without mutating process-wide environment. */
-export async function appendApplicationLogLineForTests(
-  logPath: string,
-  line: string,
-  maxBytes: number,
-  maxFiles: number,
-): Promise<boolean> {
-  const result = await appendApplicationLogLine(logPath, line, {
-    maxBytes,
-    maxFiles,
-    retentionMs: DEFAULT_RETENTION_DAYS * DAY_MS,
-  });
-  return result.ok;
-}
-
-async function writeAppLog(message: string): Promise<void> {
-  const logPath = getInspectorLogPath();
-  const line = `[${new Date().toISOString()}] ${message}\n`;
-  const initialization = ensureLoggerInitialized();
-  const write = async (): Promise<void> => {
-    await initialization;
-    const result = await appendApplicationLogLine(logPath, line, getApplicationLogPolicy());
-    if (!result.ok) {
-      const key = `${logPath}:${String(result.reason)}`;
-      const now = Date.now();
-      if (
-        key !== lastApplicationLogWriteFailureKey ||
-        now - lastApplicationLogWriteFailureAt >= APPLICATION_LOG_WRITE_FAILURE_SUPPRESS_MS
-      ) {
-        lastApplicationLogWriteFailureKey = key;
-        lastApplicationLogWriteFailureAt = now;
-        writeStderrFallback(`[logger] Failed to write to ${logPath}:`, result.reason);
-      }
-      return;
-    }
-    if (lastApplicationLogWriteFailureKey !== null) {
-      writeStderrFallback(`[logger] Application log writes recovered for ${logPath}:`, "ok");
-      lastApplicationLogWriteFailureKey = null;
-      lastApplicationLogWriteFailureAt = 0;
-    }
-  };
-
-  applicationLogWriteQueue = applicationLogWriteQueue.then(write, write);
-  await applicationLogWriteQueue;
-}
-
-/** Wait for all queued application-log writes and rotations. */
-export async function flushApplicationLog(): Promise<void> {
-  await applicationLogWriteQueue;
-}
-
-// Application logger - writes to inspector.log
-export const logger = {
-  debug(message: string, ...args: unknown[]): void {
-    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
-    void writeAppLog(`[DEBUG] ${msg}`);
-  },
-  info(message: string, ...args: unknown[]): void {
-    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
-    void writeAppLog(`[INFO] ${msg}`);
-  },
-  warn(message: string, ...args: unknown[]): void {
-    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
-    void writeAppLog(`[WARN] ${msg}`);
-  },
-  error(message: string, ...args: unknown[]): void {
-    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
-    void writeAppLog(`[ERROR] ${msg}`);
-  },
-};
-
-// Write buffer for batching async writes
-const MAX_BUFFER_SIZE = 1000;
-const BUFFER_FLUSH_DELAY_MS = 10;
-let writeBuffer: string[] = [];
-let writeQueue: Promise<void> = Promise.resolve();
-let logWriteLock: Promise<void> = Promise.resolve();
-let scheduledBufferFlush: ReturnType<typeof setTimeout> | null = null;
-
-function queueBufferedFlush(): void {
-  writeQueue = writeQueue.then(() => runWithLogWriteLock(flushWriteBufferUnlocked));
-}
-
-function cancelScheduledBufferFlush(): void {
-  if (scheduledBufferFlush === null) return;
-  clearTimeout(scheduledBufferFlush);
-  scheduledBufferFlush = null;
-}
-
-function scheduleBufferedFlush(): void {
-  if (scheduledBufferFlush !== null) return;
-  scheduledBufferFlush = setTimeout(() => {
-    scheduledBufferFlush = null;
-    queueBufferedFlush();
-  }, BUFFER_FLUSH_DELAY_MS);
-}
-
-export async function runWithLogWriteLock<T>(fn: () => Promise<T>): Promise<T> {
-  const previousLock = logWriteLock;
-  let releaseLock = (): void => {};
-  logWriteLock = new Promise<void>((resolve) => {
-    releaseLock = resolve;
-  });
-
-  await previousLock;
-  try {
-    return await fn();
-  } finally {
-    releaseLock();
-  }
-}
-
-function drainBuffer(): string {
-  const toWrite = writeBuffer.join("");
-  writeBuffer = [];
-  return toWrite;
-}
-
-async function flushWriteBufferUnlocked(): Promise<void> {
-  let toWrite: string;
-  {
-    toWrite = drainBuffer();
-  }
-  if (toWrite.length === 0) return;
-
-  try {
-    const filePath = getLogFilePath();
-    if (!ensurePrivateDirectorySync(path.dirname(filePath))) {
-      writeBuffer.unshift(toWrite);
-      writeStderrFallback("[logger] Failed to secure captured-log directory:", filePath);
-      return;
-    }
-    const recovery = await recoverCapturedLogFileBeforeAppend(resolveLogDir(), filePath);
-    if (recovery.level === "unavailable") {
-      writeBuffer.unshift(toWrite);
-      writeStderrFallback(
-        "[logger] Refused captured-log append until recovery succeeds:",
-        recovery.diagnostic ?? "unknown recovery failure",
-      );
-      return;
-    }
-    await appendFile(filePath, toWrite, { encoding: "utf-8", mode: PRIVATE_FILE_MODE });
-    if (!securePrivateFileSync(filePath)) {
-      writeStderrFallback("[logger] Failed to secure captured-log file:", filePath);
-    }
-    await markCapturedLogFileAppended(resolveLogDir(), filePath);
-  } catch (err) {
-    // On failure, re-queue the data so it is not lost
-    writeBuffer.unshift(toWrite);
-    writeStderrFallback("[logger] Failed to flush write buffer, re-queued:", err);
-  }
-}
-
-export function appendLogEntry(entry: Record<string, unknown>): void {
-  const line = JSON.stringify(entry) + "\n";
-  writeBuffer.push(line);
-  if (writeBuffer.length >= MAX_BUFFER_SIZE) {
-    cancelScheduledBufferFlush();
-    queueBufferedFlush();
-  } else if (writeBuffer.length === 1) {
-    scheduleBufferedFlush();
-  }
-}
-
-/**
- * Flush all buffered log entries to disk. Call before process exit
- * to avoid losing unflushed data.
- */
-export async function flushLogBuffer(): Promise<void> {
-  cancelScheduledBufferFlush();
-  await writeQueue;
-  if (writeBuffer.length > 0) {
-    await runWithLogWriteLock(flushWriteBufferUnlocked);
-  }
-}
-
-export async function runWithFlushedLogWriteLock<T>(fn: () => Promise<T>): Promise<T> {
-  await flushLogBuffer();
-  return await runWithLogWriteLock(async () => {
-    await flushWriteBufferUnlocked();
-    return await fn();
-  });
-}
-
-// Ensure buffered logs are written before the process exits
-process.on("exit", () => {
-  if (writeBuffer.length > 0) {
-    const toWrite = drainBuffer();
-    try {
-      // Synchronous write required in 'exit' handler (async I/O not allowed)
-      const filePath = getLogFilePath();
-      if (!ensurePrivateDirectorySync(path.dirname(filePath))) return;
-      if (!canAppendCapturedLogFileOnExit(resolveLogDir(), filePath)) return;
-      const descriptor = openSync(
-        filePath,
-        constants.O_WRONLY | constants.O_APPEND | constants.O_NOFOLLOW,
-        PRIVATE_FILE_MODE,
-      );
-      try {
-        const payload = Buffer.from(toWrite, "utf-8");
-        let written = 0;
-        while (written < payload.length) {
-          const writeCount = writeSync(descriptor, payload, written, payload.length - written);
-          if (writeCount === 0) return;
-          written += writeCount;
-        }
-        fsyncSync(descriptor);
-      } finally {
-        closeSync(descriptor);
-      }
-      void securePrivateFileSync(filePath);
-    } catch {
-      // Best-effort: nothing we can do in an exit handler
-    }
-  }
-});