@tonyclaw/llm-inspector 1.17.1 → 1.18.0

package/src/proxy/sessionSupervisor.ts

@@ -0,0 +1,282 @@
+import type { CapturedLog } from "./schemas";
+
+export const PROVIDER_TEST_SESSION_ID = "provider-test";
+
+export type SessionClientInfo = {
+  port: number | null;
+  pid: number | null;
+  cwd: string | null;
+  projectFolder: string | null;
+};
+
+export type SessionSource = "explicit" | "client-process" | "client-connection" | "provider-test";
+
+export type SessionIdentity = {
+  id: string | null;
+  source: SessionSource | null;
+};
+
+export type SessionRuntimeMode = "in-process" | "worker-thread" | "child-process";
+
+function getRuntimeMode(): SessionRuntimeMode {
+  if (process.env["FINALIZER_USE_WORKER"] === "0") return "in-process";
+  const mode = process.env["FINALIZER_RUNTIME"];
+  if (mode === "worker") return "worker-thread";
+  if (mode === "inline") return "in-process";
+  // Default: per-session child process
+  return "child-process";
+}
+
+export type SessionSnapshot = {
+  id: string;
+  source: SessionSource;
+  runtimeMode: SessionRuntimeMode;
+  createdAt: string;
+  updatedAt: string;
+  requestCount: number;
+  activeRequests: number;
+  completedRequests: number;
+  failedRequests: number;
+  queuedTasks: number;
+  runningTasks: number;
+  lastTaskError: string | null;
+  lastLogId: number | null;
+  lastModel: string | null;
+  clientPid: number | null;
+  clientProjectFolder: string | null;
+};
+
+type SessionRecord = SessionSnapshot;
+
+const sessions = new Map<string, SessionRecord>();
+const knownLogSessions = new Map<number, string>();
+const completedLogIds = new Set<number>();
+const failedLogIds = new Set<number>();
+
+function normalizeExplicitSessionId(sessionId: string | null | undefined): string | null {
+  if (sessionId === null || sessionId === undefined) return null;
+  const trimmed = sessionId.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function buildClientSessionId(clientInfo: SessionClientInfo): SessionIdentity {
+  const projectFolder = normalizeExplicitSessionId(clientInfo.projectFolder);
+
+  if (clientInfo.pid !== null) {
+    return {
+      id:
+        projectFolder !== null
+          ? `process:${clientInfo.pid}:${projectFolder}`
+          : `process:${clientInfo.pid}`,
+      source: "client-process",
+    };
+  }
+
+  if (clientInfo.port !== null) {
+    return {
+      id: `connection:${clientInfo.port}`,
+      source: "client-connection",
+    };
+  }
+
+  return { id: null, source: null };
+}
+
+export function resolveSessionIdentity(input: {
+  explicitSessionId: string | null;
+  clientInfo?: SessionClientInfo;
+  isTest?: boolean;
+}): SessionIdentity {
+  if (input.isTest === true) {
+    return { id: PROVIDER_TEST_SESSION_ID, source: "provider-test" };
+  }
+
+  const explicit = normalizeExplicitSessionId(input.explicitSessionId);
+  if (explicit !== null) {
+    return { id: explicit, source: "explicit" };
+  }
+
+  if (input.clientInfo !== undefined) {
+    return buildClientSessionId(input.clientInfo);
+  }
+
+  return { id: null, source: null };
+}
+
+export function getLogSessionIdentity(log: CapturedLog): SessionIdentity {
+  return resolveSessionIdentity({
+    explicitSessionId: log.sessionId,
+    clientInfo: {
+      port: log.clientPort ?? null,
+      pid: log.clientPid ?? null,
+      cwd: log.clientCwd ?? null,
+      projectFolder: log.clientProjectFolder ?? null,
+    },
+    isTest: log.isTest,
+  });
+}
+
+export function getLogSessionId(log: CapturedLog): string | null {
+  return getLogSessionIdentity(log).id;
+}
+
+function getTimestamp(log: CapturedLog): string {
+  return log.timestamp.length > 0 ? log.timestamp : new Date().toISOString();
+}
+
+function createSessionRecord(id: string, source: SessionSource, log: CapturedLog): SessionRecord {
+  const timestamp = getTimestamp(log);
+  return {
+    id,
+    source,
+    runtimeMode: getRuntimeMode(),
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    requestCount: 0,
+    activeRequests: 0,
+    completedRequests: 0,
+    failedRequests: 0,
+    queuedTasks: 0,
+    runningTasks: 0,
+    lastTaskError: null,
+    lastLogId: null,
+    lastModel: null,
+    clientPid: log.clientPid ?? null,
+    clientProjectFolder: log.clientProjectFolder ?? null,
+  };
+}
+
+function upsertSession(
+  log: CapturedLog,
+  sourceOverride?: SessionSource | null,
+): SessionRecord | null {
+  const identity = getLogSessionIdentity(log);
+  if (identity.id === null) return null;
+
+  const source = sourceOverride ?? identity.source;
+  if (source === null) return null;
+
+  const existing = sessions.get(identity.id);
+  const session = existing ?? createSessionRecord(identity.id, source, log);
+  session.updatedAt = new Date().toISOString();
+  session.lastLogId = log.id;
+  session.lastModel = log.model ?? session.lastModel;
+  session.clientPid = log.clientPid ?? session.clientPid;
+  session.clientProjectFolder = log.clientProjectFolder ?? session.clientProjectFolder;
+
+  sessions.set(identity.id, session);
+  return session;
+}
+
+function rememberLogSession(log: CapturedLog): boolean {
+  const sessionId = getLogSessionId(log);
+  if (sessionId === null) return false;
+
+  const knownSessionId = knownLogSessions.get(log.id);
+  if (knownSessionId === sessionId) return false;
+
+  knownLogSessions.set(log.id, sessionId);
+  return true;
+}
+
+function isFailedLog(log: CapturedLog): boolean {
+  const hasError = log.error !== null && log.error !== undefined && log.error.length > 0;
+  const hasErrorStatus = log.responseStatus !== null && log.responseStatus >= 400;
+  return hasError || hasErrorStatus;
+}
+
+export function markSessionStarted(log: CapturedLog, sourceOverride?: SessionSource | null): void {
+  const session = upsertSession(log, sourceOverride);
+  if (session === null) return;
+
+  const isNewLog = rememberLogSession(log);
+  if (isNewLog) {
+    session.requestCount += 1;
+  }
+  session.activeRequests += 1;
+}
+
+export function markSessionFinished(log: CapturedLog, sourceOverride?: SessionSource | null): void {
+  const session = upsertSession(log, sourceOverride);
+  if (session === null) return;
+
+  if (session.activeRequests > 0) {
+    session.activeRequests -= 1;
+  }
+
+  if (completedLogIds.has(log.id) === false) {
+    completedLogIds.add(log.id);
+    session.completedRequests += 1;
+  }
+
+  if (isFailedLog(log) && failedLogIds.has(log.id) === false) {
+    failedLogIds.add(log.id);
+    session.failedRequests += 1;
+  }
+}
+
+export function markSessionTaskQueued(sessionId: string | null): void {
+  if (sessionId === null) return;
+  const session = sessions.get(sessionId);
+  if (session === undefined) return;
+  session.queuedTasks += 1;
+  session.updatedAt = new Date().toISOString();
+}
+
+export function markSessionTaskStarted(sessionId: string | null): void {
+  if (sessionId === null) return;
+  const session = sessions.get(sessionId);
+  if (session === undefined) return;
+  if (session.queuedTasks > 0) {
+    session.queuedTasks -= 1;
+  }
+  session.runningTasks += 1;
+  session.updatedAt = new Date().toISOString();
+}
+
+export function markSessionTaskFinished(sessionId: string | null, error: string | null): void {
+  if (sessionId === null) return;
+  const session = sessions.get(sessionId);
+  if (session === undefined) return;
+  if (session.runningTasks > 0) {
+    session.runningTasks -= 1;
+  }
+  session.lastTaskError = error;
+  session.updatedAt = new Date().toISOString();
+}
+
+export function observeSessionLog(log: CapturedLog, sourceOverride?: SessionSource | null): void {
+  const session = upsertSession(log, sourceOverride);
+  if (session === null) return;
+
+  const isNewLog = rememberLogSession(log);
+  if (isNewLog) {
+    session.requestCount += 1;
+  }
+
+  if (log.responseStatus !== null || log.responseText !== null) {
+    markSessionFinished(log, sourceOverride);
+  }
+}
+
+export function clearSessionRegistry(): void {
+  sessions.clear();
+  knownLogSessions.clear();
+  completedLogIds.clear();
+  failedLogIds.clear();
+}
+
+export function rebuildSessionRegistry(logs: Iterable<CapturedLog>): void {
+  clearSessionRegistry();
+  for (const log of logs) {
+    observeSessionLog(log);
+  }
+}
+
+export function getSessionIds(): string[] {
+  return [...sessions.values()].map((session) => session.id);
+}
+
+export function getSessionSnapshots(): SessionSnapshot[] {
+  return [...sessions.values()].map((session) => ({ ...session }));
+}

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/store.ts

@@ -16,9 +16,21 @@ import {
 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;
 
@@ -34,12 +46,19 @@ function evictOldestIfNeeded(): void {
   }
 }
 
+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(log.id)) {
-    memoryCache.delete(log.id);
+  if (memoryCache.has(cachedLog.id)) {
+    memoryCache.delete(cachedLog.id);
   }
-  memoryCache.set(log.id, log);
+  memoryCache.set(cachedLog.id, cachedLog);
   evictOldestIfNeeded();
 }
 
@@ -70,22 +89,24 @@ export async function addTestLogEntry(entry: Omit<CapturedLog, "id">): Promise<C
     );
   }
 
+  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 = {
-  port: number | null;
-  pid: number | null;
-  cwd: string | null;
-  projectFolder: string | null;
-};
+type ClientInfo = SessionClientInfo;
 
 export async function createLog(
   method: string,
@@ -105,13 +126,18 @@ export async function createLog(
   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,
+    sessionId: session.id,
     rawRequestBody: requestBody,
     responseStatus: null,
     responseText: null,
@@ -142,11 +168,18 @@ export async function createLog(
 
   // 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.
@@ -182,7 +215,12 @@ export async function getLogById(id: number): Promise<CapturedLog | null> {
         if (line === "") return null;
         const parsed: unknown = JSON.parse(line);
         const result = CapturedLogSchema.safeParse(parsed);
-        if (result.success) return result.data;
+        if (result.success) {
+          const log = normalizeLogSession(result.data);
+          addToCache(log);
+          observeSessionLog(log);
+          return log;
+        }
       } finally {
         await fh.close();
       }
@@ -203,9 +241,11 @@ export async function getLogById(id: number): Promise<CapturedLog | null> {
           if (desc !== undefined && typeof desc.value === "number" && desc.value === id) {
             const result = CapturedLogSchema.safeParse(parsed);
             if (result.success) {
-              lastMatch = result.data;
+              lastMatch = normalizeLogSession(result.data);
               if (result.data.responseStatus !== null) {
-                return result.data;
+                addToCache(lastMatch);
+                observeSessionLog(lastMatch);
+                return lastMatch;
               }
             }
           }
@@ -214,7 +254,11 @@ export async function getLogById(id: number): Promise<CapturedLog | null> {
         // Skip malformed lines
       }
     }
-    if (lastMatch !== null) return lastMatch;
+    if (lastMatch !== null) {
+      addToCache(lastMatch);
+      observeSessionLog(lastMatch);
+      return lastMatch;
+    }
   } catch (err) {
     logger.error("[store] Failed to read log from disk:", String(err));
   }
@@ -226,18 +270,14 @@ 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 && l.sessionId !== sessionId) return false;
+    if (sessionId !== undefined && getLogSessionId(l) !== sessionId) return false;
     if (model !== undefined && l.model !== model) return false;
     return true;
   });
 }
 
 export function getSessions(): string[] {
-  const set = new Set<string>();
-  for (const l of memoryCache.values()) {
-    if (l.sessionId !== null && l.sessionId !== "") set.add(l.sessionId);
-  }
-  return [...set];
+  return getSessionIds();
 }
 
 export function getModels(): string[] {
@@ -279,6 +319,8 @@ export async function loadLogsIntoMemory(): Promise<void> {
     const entry = sorted[i];
     if (entry !== undefined) addToCache(entry);
   }
+
+  rebuildSessionRegistry(memoryCache.values());
 }
 
 async function loadLogFile(
@@ -321,6 +363,7 @@ async function loadLogFile(
 export function clearAllLogs(): { cleared: number } {
   const count = memoryCache.size;
   memoryCache.clear();
+  clearSessionRegistry();
   return { cleared: count };
 }
 
@@ -337,6 +380,7 @@ export function clearLogsByIds(ids: readonly number[]): { cleared: number } {
   for (const id of unique) {
     removeFromCache(id);
   }
+  rebuildSessionRegistry(memoryCache.values());
   return { cleared: unique.size };
 }
 

package/src/routes/api/logs.stream.ts

@@ -1,5 +1,5 @@
 import { createFileRoute } from "@tanstack/react-router";
-import { onLogUpdate, getFilteredLogs } from "../../proxy/store";
+import { onLogUpdate, getFilteredLogs, getLogSessionId } from "../../proxy/store";
 import { type CapturedLog } from "../../proxy/schemas";
 
 export const Route = createFileRoute("/api/logs/stream")({
@@ -16,7 +16,7 @@ export const Route = createFileRoute("/api/logs/stream")({
         const unsubscribe = onLogUpdate((log: CapturedLog) => {
           if (controllerRef === null) return;
           // Filter by session/model if specified
-          if (sessionId !== undefined && log.sessionId !== sessionId) return;
+          if (sessionId !== undefined && getLogSessionId(log) !== sessionId) return;
           if (model !== undefined && log.model !== model) return;
           try {
             const data = `data: ${JSON.stringify({ type: "update", log })}\n\n`;

package/src/routes/api/sessions.ts

@@ -1,10 +1,17 @@
 import { createFileRoute } from "@tanstack/react-router";
-import { getSessions } from "../../proxy/store";
+import { getSessionSnapshots, getSessions } from "../../proxy/store";
 
 export const Route = createFileRoute("/api/sessions")({
   server: {
     handlers: {
-      GET: () => Response.json(getSessions()),
+      GET: ({ request }: { request: Request }) => {
+        const url = new URL(request.url);
+        const details = url.searchParams.get("details");
+        if (details === "true" || details === "1") {
+          return Response.json(getSessionSnapshots());
+        }
+        return Response.json(getSessions());
+      },
     },
   },
 });