@tonyclaw/agent-inspector 2.0.0

package/src/proxy/sessionWorkerEntry.ts

@@ -0,0 +1,26 @@
+import {
+  buildFinalizeLogResult,
+  type FinalizeLogJob,
+  type FinalizeLogResult,
+} from "./logFinalizer";
+
+// Child-process entry point for session finalization.
+// Communicates with the parent via IPC (process.send / process.on("message")).
+// Each job is { id: string; job: FinalizeLogJob }, each response is { id: string; result: FinalizeLogResult }.
+
+process.on("message", (msg: { id: string; job: FinalizeLogJob }) => {
+  let result: FinalizeLogResult;
+  try {
+    result = buildFinalizeLogResult(msg.job);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    result = {
+      log: msg.job.log,
+      upstreamUrl: msg.job.upstreamUrl,
+      error: message,
+    };
+  }
+  if (process.send !== undefined) {
+    process.send({ id: msg.id, result });
+  }
+});

package/src/proxy/socketTracker.ts

@@ -0,0 +1,255 @@
+import { exec, execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { logger } from "./logger";
+
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+
+type ClientInfo = {
+  port: number | null;
+  pid: number | null;
+  cwd: string | null;
+  projectFolder: string | null;
+};
+
+type CacheEntry = ClientInfo & {
+  expiresAt: number;
+};
+
+// Cache entries: port -> { pid, cwd, projectFolder, expiresAt }
+const cache = new Map<number, CacheEntry>();
+const CACHE_TTL_MS = 5 * 60 * 1000;
+const MAX_CACHE_SIZE = 200;
+
+// Deduplicate concurrent lookups for the same port
+const inflight = new Map<number, Promise<ClientInfo>>();
+
+function evictCacheIfNeeded(): void {
+  while (cache.size > MAX_CACHE_SIZE) {
+    const oldestKey = cache.keys().next().value;
+    if (oldestKey === undefined) break;
+    cache.delete(oldestKey);
+  }
+}
+
+function getFromCache(port: number): ClientInfo | null {
+  const entry = cache.get(port);
+  if (entry && Date.now() < entry.expiresAt) {
+    return { port: entry.port, pid: entry.pid, cwd: entry.cwd, projectFolder: entry.projectFolder };
+  }
+  if (entry) cache.delete(port);
+  return null;
+}
+
+function setCache(port: number, info: ClientInfo): void {
+  cache.set(port, { ...info, expiresAt: Date.now() + CACHE_TTL_MS });
+  evictCacheIfNeeded();
+}
+
+/**
+ * Get the remote port from a Request's underlying socket.
+ * Works with Bun, Node.js, and Nitro's event.node.req.
+ */
+function extractRemotePort(request: Request): number | null {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+  const socket = (request as any).socket;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+  const remotePort = (socket as any)?.remotePort;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  if (remotePort !== undefined && remotePort !== null) return remotePort;
+  return null;
+}
+
+/**
+ * Combined lookup: PID from port, then process info from PID.
+ * On Windows, uses a single PowerShell call to get PID + command line.
+ */
+async function lookupClientInfo(port: number): Promise<ClientInfo> {
+  const platform = process.platform;
+
+  try {
+    if (platform === "win32") {
+      // Single PowerShell call: get PID and command line in one shot
+      const psScript = [
+        `$conn = Get-NetTCPConnection -LocalPort ${port} -State Established -ErrorAction SilentlyContinue | Select-Object -First 1`,
+        `if ($conn) {`,
+        `  $pid = $conn.OwningProcess`,
+        `  $proc = Get-CimInstance Win32_Process -Filter "ProcessId=$pid" -ErrorAction SilentlyContinue`,
+        `  $cmd = if ($proc) { $proc.CommandLine } else { "" }`,
+        `  Write-Output "$pid|$cmd"`,
+        `}`,
+      ].join("; ");
+      const { stdout } = await execFileAsync(
+        "powershell.exe",
+        ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", psScript],
+        {
+          windowsHide: true,
+          timeout: 3000,
+          maxBuffer: 64 * 1024,
+        },
+      );
+      const trimmed = stdout.trim();
+      if (trimmed === "") {
+        return { port, pid: null, cwd: null, projectFolder: null };
+      }
+      const [pidStr, ...cmdParts] = trimmed.split("|");
+      const pid = parseInt(pidStr ?? "", 10);
+      if (isNaN(pid) || pid <= 0) {
+        return { port, pid: null, cwd: null, projectFolder: null };
+      }
+      const commandLine = cmdParts.join("|").trim();
+      const { cwd, projectFolder } = parseCommandLine(commandLine, "\\");
+      return { port, pid, cwd, projectFolder };
+    }
+
+    // Unix: two-step lookup (PID from port, then process info from PID)
+    let pid: number | null = null;
+
+    if (platform === "darwin") {
+      const { stdout } = await execAsync(`lsof -i :${port} -sTCP:ESTABLISHED -t 2>/dev/null`, {
+        shell: "/bin/sh",
+      });
+      const parsed = parseInt(stdout.trim(), 10);
+      if (!isNaN(parsed) && parsed > 0) pid = parsed;
+    } else {
+      try {
+        const { stdout } = await execAsync(
+          `ss -tlnp 'sport = :${port}' 2>/dev/null | grep ESTAB | awk '{print $6}' | grep -o 'pid=[0-9]*' | cut -d= -f2`,
+          { shell: "/bin/sh" },
+        );
+        const parsed = parseInt(stdout.trim(), 10);
+        if (!isNaN(parsed) && parsed > 0) pid = parsed;
+      } catch {
+        // Fall back to netstat
+      }
+      if (pid === null) {
+        const { stdout } = await execAsync(
+          `netstat -tan 2>/dev/null | grep ':${port}' | grep ESTABLISHED | awk '{print $7}' | cut -d/ -f1`,
+          { shell: "/bin/sh" },
+        );
+        const parsed = parseInt(stdout.trim(), 10);
+        if (!isNaN(parsed) && parsed > 0) pid = parsed;
+      }
+    }
+
+    if (pid === null) {
+      return { port, pid: null, cwd: null, projectFolder: null };
+    }
+
+    const { cwd, projectFolder } = await lookupProcessInfo(pid);
+    return { port, pid, cwd, projectFolder };
+  } catch (err) {
+    logger.debug(`[socketTracker] Failed to lookup info for port ${port}:`, String(err));
+    return { port, pid: null, cwd: null, projectFolder: null };
+  }
+}
+
+function parseCommandLine(
+  commandLine: string,
+  sep: string,
+): { cwd: string | null; projectFolder: string | null } {
+  if (!commandLine) return { cwd: null, projectFolder: null };
+  const exeMatch = commandLine.match(/^"([^"]+)"/) || commandLine.match(/^([^\s]+)/);
+  if (exeMatch?.[1] !== undefined) {
+    const exePath = exeMatch[1];
+    const lastSep = exePath.lastIndexOf(sep);
+    if (lastSep > 0) {
+      const exeDir = exePath.substring(0, lastSep);
+      return { cwd: exeDir, projectFolder: exeDir.split(sep).pop() ?? null };
+    }
+  }
+  return { cwd: null, projectFolder: null };
+}
+
+/**
+ * Get the working directory and command line for a process by PID.
+ */
+async function lookupProcessInfo(
+  pid: number,
+): Promise<{ cwd: string | null; projectFolder: string | null }> {
+  const platform = process.platform;
+
+  try {
+    if (platform === "win32") {
+      const { stdout } = await execFileAsync(
+        "wmic.exe",
+        ["process", "where", `processid=${pid}`, "get", "commandline", "/value"],
+        {
+          windowsHide: true,
+          timeout: 3000,
+          maxBuffer: 64 * 1024,
+        },
+      );
+      const lines = stdout.trim().split("\n").filter(Boolean);
+      for (const line of lines) {
+        if (line.includes("=")) {
+          const commandLine = (line.split("=")[1] ?? "").trim();
+          if (commandLine) {
+            return parseCommandLine(commandLine, "\\");
+          }
+        }
+      }
+    } else {
+      try {
+        const { stdout } = await execAsync(`cat /proc/${pid}/cmdline 2>/dev/null | tr '\\0' ' '`, {
+          shell: "/bin/sh",
+        });
+        const commandLine = stdout.trim();
+        if (commandLine) {
+          return parseCommandLine(commandLine, "/");
+        }
+      } catch {
+        // Fall back to ps
+      }
+
+      if (platform === "darwin") {
+        const { stdout } = await execAsync(`ps -p ${pid} -o comm= 2>/dev/null`, {
+          shell: "/bin/sh",
+        });
+        const exePath = stdout.trim();
+        if (exePath) {
+          return parseCommandLine(exePath, "/");
+        }
+      }
+    }
+    return { cwd: null, projectFolder: null };
+  } catch {
+    return { cwd: null, projectFolder: null };
+  }
+}
+
+/**
+ * Get client info (PID, CWD, project folder) from a request's source port.
+ * Deduplicates concurrent lookups for the same port and caches results.
+ */
+export async function getClientInfo(request: Request): Promise<ClientInfo> {
+  const port = extractRemotePort(request);
+  if (port === null) {
+    return { port: null, pid: null, cwd: null, projectFolder: null };
+  }
+
+  // Check cache first
+  const cached = getFromCache(port);
+  if (cached) return cached;
+
+  // Deduplicate concurrent lookups for the same port
+  const existing = inflight.get(port);
+  if (existing) return existing;
+
+  const promise = lookupClientInfo(port)
+    .then((info) => {
+      setCache(port, info);
+      inflight.delete(port);
+      return info;
+    })
+    .catch((err) => {
+      inflight.delete(port);
+      logger.debug(`[socketTracker] Lookup failed for port ${port}:`, String(err));
+      const fallback: ClientInfo = { port, pid: null, cwd: null, projectFolder: null };
+      setCache(port, fallback);
+      return fallback;
+    });
+
+  inflight.set(port, promise);
+  return promise;
+}

package/src/proxy/store.ts

@@ -0,0 +1,412 @@
+import { readFileSync, existsSync, createReadStream } from "node:fs";
+import { open } from "node:fs/promises";
+import { readdir as readdirCallback } from "node:fs/promises";
+import { createInterface } from "node:readline";
+import { Buffer } from "node:buffer";
+import { join } from "node:path";
+import { appendLogEntry, resolveLogDir, logger } from "./logger";
+import {
+  addToIndex,
+  findInIndex,
+  getNextLogId,
+  getCurrentLogFile,
+  saveIndex,
+  loadIndex,
+} from "./logIndex";
+import { writeChunks } from "./chunkStorage";
+import type { CapturedLog } from "./schemas";
+import { CapturedLogSchema } from "./schemas";
+import {
+  clearSessionRegistry,
+  getLogSessionId,
+  getSessionIds,
+  markSessionFinished,
+  markSessionStarted,
+  observeSessionLog,
+  rebuildSessionRegistry,
+  resolveSessionIdentity,
+  type SessionClientInfo,
+} from "./sessionSupervisor";
+
+export type { CapturedLog };
+export { getNextLogId };
+export { getLogSessionId, getSessionSnapshots } from "./sessionSupervisor";
+
+const MAX_MEMORY_CACHE = 100;
+
+// Memory cache: id -> CapturedLog (recent logs only, FIFO eviction)
+const memoryCache: Map<number, CapturedLog> = new Map();
+
+function evictOldestIfNeeded(): void {
+  while (memoryCache.size > MAX_MEMORY_CACHE) {
+    // Map preserves insertion order; first key = oldest
+    const oldestKey = memoryCache.keys().next().value;
+    if (oldestKey === undefined) break;
+    memoryCache.delete(oldestKey);
+  }
+}
+
+function normalizeLogSession(log: CapturedLog): CapturedLog {
+  const sessionId = getLogSessionId(log);
+  if (sessionId === log.sessionId) return log;
+  return { ...log, sessionId };
+}
+
+function addToCache(log: CapturedLog): void {
+  const cachedLog = normalizeLogSession(log);
+  // If updating an existing entry, remove first to reset insertion order
+  if (memoryCache.has(cachedLog.id)) {
+    memoryCache.delete(cachedLog.id);
+  }
+  memoryCache.set(cachedLog.id, cachedLog);
+  evictOldestIfNeeded();
+}
+
+function removeFromCache(id: number): void {
+  memoryCache.delete(id);
+}
+
+/**
+ * Add a test log entry directly to the in-memory store (for dashboard display).
+ * This is used by the provider test endpoint alongside appendLogEntry (file logging).
+ */
+export async function addTestLogEntry(entry: Omit<CapturedLog, "id">): Promise<CapturedLog> {
+  const id = await getNextLogId();
+  // Update the index with the new maxId so subsequent calls get unique IDs
+  const index = await loadIndex();
+  if (id > index.maxId) {
+    index.maxId = id;
+    await saveIndex(index);
+  }
+
+  // Persist streaming chunks to disk if present
+  let streamingChunksPath: string | null = null;
+  if (entry.streamingChunks !== undefined && entry.streamingChunks.chunks.length > 0) {
+    streamingChunksPath = writeChunks(
+      id,
+      entry.streamingChunks.chunks,
+      entry.streamingChunks.truncated,
+    );
+  }
+
+  const session = resolveSessionIdentity({
+    explicitSessionId: entry.sessionId,
+    isTest: entry.isTest,
+  });
+
+  const log: CapturedLog = {
+    id,
+    ...entry,
+    sessionId: session.id,
+    streamingChunksPath,
+  };
+  addToCache(log);
+  observeSessionLog(log, session.source);
+  emitLogUpdate(log);
+  return log;
+}
+
+type ClientInfo = SessionClientInfo;
+
+export async function createLog(
+  method: string,
+  path: string,
+  requestBody: string | null,
+  headers: Headers,
+  clientInfo?: ClientInfo,
+  rawHeaders?: Record<string, string>,
+  upstreamHeaders?: Record<string, string>,
+  apiFormat: "anthropic" | "openai" | "unknown" = "unknown",
+  model: string | null = null,
+  sessionId: string | null = null,
+  /** Pre-acquired log id; if omitted, `getNextLogId` is awaited internally. */
+  preAcquiredId?: number,
+): Promise<CapturedLog> {
+  const userAgent = headers.get("user-agent");
+  const origin = headers.get("origin");
+
+  const id = preAcquiredId ?? (await getNextLogId());
+  const session = resolveSessionIdentity({
+    explicitSessionId: sessionId,
+    clientInfo,
+  });
+
+  const log: CapturedLog = {
+    id,
+    timestamp: new Date().toISOString(),
+    method,
+    path,
+    model,
+    sessionId: session.id,
+    rawRequestBody: requestBody,
+    responseStatus: null,
+    responseText: null,
+    inputTokens: null,
+    outputTokens: null,
+    cacheCreationInputTokens: null,
+    cacheReadInputTokens: null,
+    elapsedMs: null,
+    streaming: false,
+    userAgent,
+    origin,
+    rawHeaders: rawHeaders,
+    headers: upstreamHeaders,
+    apiFormat,
+    isTest: false,
+    providerName: null,
+    clientPort: clientInfo?.port ?? null,
+    clientPid: clientInfo?.pid ?? null,
+    clientCwd: clientInfo?.cwd ?? null,
+    clientProjectFolder: clientInfo?.projectFolder ?? null,
+    streamingChunksPath: null,
+  };
+
+  // Write to disk and update index
+  const logFile = getCurrentLogFile();
+  appendLogEntry(log);
+  await addToIndex(id, logFile, -1, -1); // line numbers not tracked precisely
+
+  // Add to memory cache
+  addToCache(log);
+  markSessionStarted(log, session.source);
+  emitLogUpdate(log);
+
+  return log;
+}
+
+export function finalizeLogUpdate(log: CapturedLog): void {
+  addToCache(log);
+  markSessionFinished(log);
+  emitLogUpdate(log);
+}
+
+/**
+ * Get a log by ID, checking memory cache first then disk.
+ * Uses byte-offset index for efficient single-line reads.
+ */
+export async function getLogById(id: number): Promise<CapturedLog | null> {
+  // Check memory cache first
+  const cached = memoryCache.get(id);
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  // Look up in index and load from disk
+  const entry = await findInIndex(id);
+  if (entry === null) {
+    return null;
+  }
+
+  // Load from disk using byte-offset index
+  try {
+    const filePath = join(resolveLogDir(), entry.file);
+    if (!existsSync(filePath)) {
+      return null;
+    }
+
+    // Use byte offset for direct read when available
+    if (entry.byteOffset >= 0 && entry.byteLength > 0) {
+      const fh = await open(filePath, "r");
+      try {
+        const buffer = Buffer.alloc(entry.byteLength);
+        const { bytesRead } = await fh.read(buffer, 0, entry.byteLength, entry.byteOffset);
+        if (bytesRead === 0) return null;
+        const line = buffer.toString("utf-8", 0, bytesRead).trimEnd();
+        if (line === "") return null;
+        const parsed: unknown = JSON.parse(line);
+        const result = CapturedLogSchema.safeParse(parsed);
+        if (result.success) {
+          const log = normalizeLogSession(result.data);
+          addToCache(log);
+          observeSessionLog(log);
+          return log;
+        }
+      } finally {
+        await fh.close();
+      }
+      return null;
+    }
+
+    // Fallback: scan file for matching ID (for entries written before index rebuild)
+    const content = readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+
+    let lastMatch: CapturedLog | null = null;
+    for (const line of lines) {
+      if (line.trim() === "") continue;
+      try {
+        const parsed: unknown = JSON.parse(line);
+        if (typeof parsed === "object" && parsed !== null) {
+          const desc = Object.getOwnPropertyDescriptor(parsed, "id");
+          if (desc !== undefined && typeof desc.value === "number" && desc.value === id) {
+            const result = CapturedLogSchema.safeParse(parsed);
+            if (result.success) {
+              lastMatch = normalizeLogSession(result.data);
+              if (result.data.responseStatus !== null) {
+                addToCache(lastMatch);
+                observeSessionLog(lastMatch);
+                return lastMatch;
+              }
+            }
+          }
+        }
+      } catch {
+        // Skip malformed lines
+      }
+    }
+    if (lastMatch !== null) {
+      addToCache(lastMatch);
+      observeSessionLog(lastMatch);
+      return lastMatch;
+    }
+  } catch (err) {
+    logger.error("[store] Failed to read log from disk:", String(err));
+  }
+
+  return null;
+}
+
+export function getFilteredLogs(sessionId?: string, model?: string): CapturedLog[] {
+  // Cache maintains insertion order (sorted by ID since logs are added in ID order)
+  // Use spread instead of Array.from for slightly better performance
+  return [...memoryCache.values()].filter((l) => {
+    if (sessionId !== undefined && getLogSessionId(l) !== sessionId) return false;
+    if (model !== undefined && l.model !== model) return false;
+    return true;
+  });
+}
+
+export function getSessions(): string[] {
+  return getSessionIds();
+}
+
+export function getModels(): string[] {
+  const set = new Set<string>();
+  for (const l of memoryCache.values()) {
+    if (l.model !== null && l.model !== "") set.add(l.model);
+  }
+  return [...set];
+}
+
+/**
+ * Load recent completed log entries from all log files into the memory cache.
+ * Called on server startup so the frontend shows existing logs.
+ *
+ * Strategy: stream files forward, keep the LAST completed entry per ID,
+ * then only retain the newest MAX_MEMORY_CACHE entries in cache.
+ */
+export async function loadLogsIntoMemory(): Promise<void> {
+  const logDir = resolveLogDir();
+  if (!existsSync(logDir)) return;
+
+  // lastCompletedById: id -> CapturedLog (overwrite on each occurrence)
+  const lastCompletedById = new Map<number, CapturedLog>();
+
+  try {
+    const entries = await readdirCallback(logDir);
+    const filesWithExt = entries.filter((f: string) => f.endsWith(".jsonl")).sort();
+    for (const file of filesWithExt) {
+      const filePath = join(logDir, file);
+      await loadLogFile(filePath, lastCompletedById);
+    }
+  } catch (err) {
+    logger.error("[store] Failed to read log directory:", String(err));
+  }
+
+  // Sort by id descending, keep only MAX_MEMORY_CACHE newest completed entries
+  const sorted = [...lastCompletedById.values()].sort((a, b) => b.id - a.id);
+  for (let i = 0; i < Math.min(sorted.length, MAX_MEMORY_CACHE); i++) {
+    const entry = sorted[i];
+    if (entry !== undefined) addToCache(entry);
+  }
+
+  rebuildSessionRegistry(memoryCache.values());
+}
+
+async function loadLogFile(
+  filePath: string,
+  lastCompletedById: Map<number, CapturedLog>,
+): Promise<void> {
+  if (!existsSync(filePath)) return;
+
+  try {
+    const fileStream = createInterface({
+      input: createReadStream(filePath),
+      crlfDelay: Infinity,
+    });
+
+    for await (const line of fileStream) {
+      if (line.trim() === "") continue;
+      try {
+        const parsed: unknown = JSON.parse(line);
+        if (typeof parsed === "object" && parsed !== null) {
+          const desc = Object.getOwnPropertyDescriptor(parsed, "id");
+          if (desc !== undefined && typeof desc.value === "number") {
+            const statusDesc = Object.getOwnPropertyDescriptor(parsed, "responseStatus");
+            if (statusDesc !== undefined && statusDesc.value !== null) {
+              const result = CapturedLogSchema.safeParse(parsed);
+              if (result.success) {
+                lastCompletedById.set(desc.value, result.data);
+              }
+            }
+          }
+        }
+      } catch {
+        // Skip malformed lines
+      }
+    }
+  } catch (err) {
+    logger.error("[store] Failed to load logs into memory:", String(err));
+  }
+}
+
+export function clearAllLogs(): { cleared: number } {
+  const count = memoryCache.size;
+  memoryCache.clear();
+  clearSessionRegistry();
+  return { cleared: count };
+}
+
+/**
+ * Remove a specific set of log IDs from the in-memory cache. Returns the
+ * number of logs actually removed. IDs not present in the cache are ignored.
+ * This is used by the per-conversation-group "Clear" button in the UI.
+ */
+export function clearLogsByIds(ids: readonly number[]): { cleared: number } {
+  const unique = new Set<number>();
+  for (const id of ids) {
+    if (memoryCache.has(id)) unique.add(id);
+  }
+  for (const id of unique) {
+    removeFromCache(id);
+  }
+  rebuildSessionRegistry(memoryCache.values());
+  return { cleared: unique.size };
+}
+
+// SSE event system for real-time log updates
+type LogUpdateHandler = (log: CapturedLog) => void;
+const sseHandlers: Set<LogUpdateHandler> = new Set();
+
+export function onLogUpdate(handler: LogUpdateHandler): () => void {
+  sseHandlers.add(handler);
+  return () => {
+    sseHandlers.delete(handler);
+  };
+}
+
+export function emitLogUpdate(log: CapturedLog): void {
+  const failedHandlers: LogUpdateHandler[] = [];
+  for (const handler of sseHandlers) {
+    try {
+      handler(log);
+    } catch {
+      // Collect failed handlers to remove after iteration
+      failedHandlers.push(handler);
+    }
+  }
+  // Remove failed handlers after iteration to avoid Set mutation during for...of
+  for (const handler of failedHandlers) {
+    sseHandlers.delete(handler);
+  }
+}