@tonyclaw/agent-inspector 4.0.1 → 4.0.3

package/src/proxy/sessionInfo.ts

@@ -1,266 +0,0 @@
-import type { SessionInfo, SessionLogSummary, SessionTokenUsage } from "../lib/sessionInfoContract";
-import { withBasePath } from "../lib/basePath";
-import { getPublicBasePath } from "../lib/publicBasePathContext";
-import { getSessionPath } from "../lib/sessionUrl";
-import type { CapturedLog } from "./schemas";
-import type { SessionSnapshot } from "./sessionSupervisor";
-
-export const SESSION_INFO_DEFAULT_LATEST_LOG_LIMIT = 10;
-export const SESSION_INFO_MAX_LATEST_LOG_LIMIT = 50;
-
-type SessionStatus = SessionInfo["status"];
-
-type BuildSessionInfoInput = {
-  sessionId: string;
-  baseUrl: string;
-  snapshot: SessionSnapshot | null;
-  summaries: readonly SessionLogSummary[];
-  logCoverage: SessionInfo["logCoverage"];
-  latestLogLimit?: number;
-};
-
-export function clampSessionInfoLogLimit(input: number | undefined): number {
-  if (input === undefined) return SESSION_INFO_DEFAULT_LATEST_LOG_LIMIT;
-  if (!Number.isFinite(input) || input < 1) return 1;
-  return Math.min(Math.floor(input), SESSION_INFO_MAX_LATEST_LOG_LIMIT);
-}
-
-function normalizeString(value: string | null | undefined): string | null {
-  if (value === null || value === undefined || value.length === 0) return null;
-  return value;
-}
-
-function truncateError(value: string | null | undefined): string | null {
-  const normalized = normalizeString(value);
-  if (normalized === null) return null;
-  if (normalized.length <= 500) return normalized;
-  return `${normalized.slice(0, 500)}...`;
-}
-
-function hasLogError(log: CapturedLog): boolean {
-  const error = normalizeString(log.error);
-  if (error !== null) return true;
-  return log.responseStatus !== null && log.responseStatus >= 400;
-}
-
-export function buildSessionLogSummary(log: CapturedLog): SessionLogSummary {
-  return {
-    id: log.id,
-    timestamp: log.timestamp,
-    provider: normalizeString(log.providerName),
-    model: normalizeString(log.model),
-    apiFormat: log.apiFormat,
-    method: log.method,
-    path: log.path,
-    status: log.responseStatus,
-    isStreaming: log.streaming,
-    hasError: hasLogError(log),
-    error: truncateError(log.error),
-    latencyMs: log.elapsedMs,
-    firstChunkMs: log.firstChunkMs ?? null,
-    totalStreamMs: log.totalStreamMs ?? null,
-    tokensPerSecond: log.tokensPerSecond ?? null,
-    tokens: {
-      input: log.inputTokens,
-      output: log.outputTokens,
-      cacheCreate: log.cacheCreationInputTokens,
-      cacheRead: log.cacheReadInputTokens,
-    },
-    sessionId: normalizeString(log.sessionId),
-    userAgent: normalizeString(log.userAgent),
-    clientPid: log.clientPid ?? null,
-    clientProjectFolder: normalizeString(log.clientProjectFolder),
-  };
-}
-
-function nonNegativeInteger(value: number | null): number {
-  if (value === null || !Number.isFinite(value) || value < 0) return 0;
-  return Math.floor(value);
-}
-
-function addTokenUsage(total: SessionTokenUsage, summary: SessionLogSummary): SessionTokenUsage {
-  const input = nonNegativeInteger(summary.tokens.input);
-  const output = nonNegativeInteger(summary.tokens.output);
-  const cacheCreate = nonNegativeInteger(summary.tokens.cacheCreate);
-  const cacheRead = nonNegativeInteger(summary.tokens.cacheRead);
-  return {
-    input: total.input + input,
-    output: total.output + output,
-    cacheCreate: total.cacheCreate + cacheCreate,
-    cacheRead: total.cacheRead + cacheRead,
-    total: total.total + input + output + cacheCreate + cacheRead,
-  };
-}
-
-function buildRelativePath(pathname: string, params: URLSearchParams): string {
-  const query = params.toString();
-  return query.length > 0 ? `${pathname}?${query}` : pathname;
-}
-
-function buildAbsoluteUrl(baseUrl: string, path: string): string {
-  try {
-    return new URL(path, baseUrl).toString();
-  } catch {
-    return path;
-  }
-}
-
-function buildApiPath(sessionId: string): string {
-  return buildRelativePath(
-    withBasePath("/api/sessions", getPublicBasePath()),
-    new URLSearchParams({ sessionId }),
-  );
-}
-
-function buildCompactLogsPath(sessionId: string): string {
-  return buildRelativePath(
-    withBasePath("/api/logs", getPublicBasePath()),
-    new URLSearchParams({ compact: "1", sessionId }),
-  );
-}
-
-function collectSortedValues(values: readonly (string | null)[]): string[] {
-  const set = new Set<string>();
-  for (const value of values) {
-    if (value !== null && value.length > 0) {
-      set.add(value);
-    }
-  }
-  return [...set].sort();
-}
-
-function firstSummaryUserAgent(summaries: readonly SessionLogSummary[]): string | null {
-  for (const summary of summaries) {
-    const value = normalizeString(summary.userAgent);
-    if (value !== null) return value;
-  }
-  return null;
-}
-
-function firstSummaryClientPid(summaries: readonly SessionLogSummary[]): number | null {
-  for (const summary of summaries) {
-    const value = summary.clientPid;
-    if (value !== null && value !== undefined) return value;
-  }
-  return null;
-}
-
-function firstSummaryProjectFolder(summaries: readonly SessionLogSummary[]): string | null {
-  for (const summary of summaries) {
-    const value = normalizeString(summary.clientProjectFolder);
-    if (value !== null) return value;
-  }
-  return null;
-}
-
-function countCompletedLogs(summaries: readonly SessionLogSummary[]): number {
-  let count = 0;
-  for (const summary of summaries) {
-    if (summary.status !== null || summary.latencyMs !== null) {
-      count += 1;
-    }
-  }
-  return count;
-}
-
-function countErrorLogs(summaries: readonly SessionLogSummary[]): number {
-  let count = 0;
-  for (const summary of summaries) {
-    if (summary.hasError) {
-      count += 1;
-    }
-  }
-  return count;
-}
-
-function deriveSessionStatus(input: {
-  activeRequests: number;
-  runningTasks: number;
-  failedRequests: number;
-  errorCount: number;
-  lastTaskError: string | null;
-  completedRequests: number;
-  logCount: number;
-}): SessionStatus {
-  if (input.activeRequests > 0 || input.runningTasks > 0) return "active";
-  if (input.failedRequests > 0 || input.errorCount > 0 || input.lastTaskError !== null) {
-    return "failed";
-  }
-  if (input.completedRequests > 0 || input.logCount > 0) return "completed";
-  return "empty";
-}
-
-export function buildSessionInfo(input: BuildSessionInfoInput): SessionInfo {
-  const latestLogLimit = clampSessionInfoLogLimit(input.latestLogLimit);
-  const summaries = [...input.summaries].sort((left, right) => right.id - left.id);
-  const latestLog = summaries[0] ?? null;
-  const oldestLog = summaries.length > 0 ? summaries[summaries.length - 1] : null;
-  const logCount =
-    input.logCoverage === "history"
-      ? summaries.length
-      : Math.max(input.snapshot?.requestCount ?? 0, summaries.length);
-  const errorCount = Math.max(countErrorLogs(summaries), input.snapshot?.failedRequests ?? 0);
-  const completedLogCount = countCompletedLogs(summaries);
-  const tokenUsage = summaries.reduce<SessionTokenUsage>(
-    (total, summary) => addTokenUsage(total, summary),
-    { input: 0, output: 0, cacheCreate: 0, cacheRead: 0, total: 0 },
-  );
-  const requestCount = Math.max(input.snapshot?.requestCount ?? 0, logCount);
-  const activeRequests = input.snapshot?.activeRequests ?? 0;
-  const completedRequests = Math.max(input.snapshot?.completedRequests ?? 0, completedLogCount);
-  const failedRequests = Math.max(input.snapshot?.failedRequests ?? 0, errorCount);
-  const queuedTasks = input.snapshot?.queuedTasks ?? 0;
-  const runningTasks = input.snapshot?.runningTasks ?? 0;
-  const lastTaskError = normalizeString(input.snapshot?.lastTaskError);
-  const inspectorPath = getSessionPath(input.sessionId, getPublicBasePath());
-  const apiPath = buildApiPath(input.sessionId);
-  const compactLogsPath = buildCompactLogsPath(input.sessionId);
-  const latestLogs = summaries.slice(0, latestLogLimit).map((summary, index) => ({
-    ...summary,
-    sessionLogNumber: Math.max(1, requestCount - index),
-  }));
-
-  return {
-    id: input.sessionId,
-    status: deriveSessionStatus({
-      activeRequests,
-      runningTasks,
-      failedRequests,
-      errorCount,
-      lastTaskError,
-      completedRequests,
-      logCount,
-    }),
-    logCoverage: input.logCoverage,
-    source: input.snapshot?.source ?? null,
-    runtimeMode: input.snapshot?.runtimeMode ?? null,
-    createdAt: input.snapshot?.createdAt ?? oldestLog?.timestamp ?? null,
-    updatedAt: input.snapshot?.updatedAt ?? latestLog?.timestamp ?? null,
-    requestCount,
-    activeRequests,
-    completedRequests,
-    failedRequests,
-    queuedTasks,
-    runningTasks,
-    lastTaskError,
-    logCount,
-    errorCount,
-    models: collectSortedValues(summaries.map((summary) => summary.model)),
-    providers: collectSortedValues(summaries.map((summary) => summary.provider)),
-    tokenUsage,
-    lastLogId: input.snapshot?.lastLogId ?? latestLog?.id ?? null,
-    lastModel: normalizeString(input.snapshot?.lastModel) ?? latestLog?.model ?? null,
-    clientUserAgent: firstSummaryUserAgent(summaries),
-    clientPid: input.snapshot?.clientPid ?? firstSummaryClientPid(summaries),
-    clientProjectFolder:
-      normalizeString(input.snapshot?.clientProjectFolder) ?? firstSummaryProjectFolder(summaries),
-    inspectorPath,
-    inspectorUrl: buildAbsoluteUrl(input.baseUrl, inspectorPath),
-    apiPath,
-    apiUrl: buildAbsoluteUrl(input.baseUrl, apiPath),
-    compactLogsPath,
-    compactLogsUrl: buildAbsoluteUrl(input.baseUrl, compactLogsPath),
-    latestLogLimit,
-    latestLogs,
-  };
-}

package/src/proxy/sessionProcess.ts

@@ -1,194 +0,0 @@
-import { spawn, type ChildProcess } from "node:child_process";
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { join } from "node:path";
-import { logger } from "./logger";
-import type { FinalizeLogJob, FinalizeLogResult } from "./logFinalizer";
-import { isPlainRecord, safeGetOwnProperty } from "../lib/objectUtils";
-
-const IDLE_TIMEOUT_MS = Number(process.env["SESSION_PROCESS_IDLE_MS"]) || 5 * 60 * 1000; // 5 min default
-const MAX_RESTARTS = 3;
-
-const _processes = new Map<string, SessionProcess>();
-
-type PendingJob = {
-  resolve: (result: FinalizeLogResult) => void;
-  reject: (err: Error) => void;
-};
-
-function errorMessage(err: unknown): string {
-  return err instanceof Error ? err.message : String(err);
-}
-
-function resolveSessionWorkerPath(): string {
-  const workerDir = process.env["AGENT_INSPECTOR_WORKER_DIR"];
-  if (workerDir !== undefined && workerDir.trim().length > 0) {
-    const builtWorkerPath = join(workerDir, "sessionWorkerEntry.js");
-    if (existsSync(builtWorkerPath)) return builtWorkerPath;
-  }
-  return fileURLToPath(new URL("./sessionWorkerEntry.ts", import.meta.url));
-}
-
-export function isSessionProcessAvailable(): boolean {
-  return existsSync(resolveSessionWorkerPath());
-}
-
-export class SessionProcess {
-  private child: ChildProcess | null = null;
-  private pending = new Map<string, PendingJob>();
-  private nextId = 0;
-  private idleTimer: ReturnType<typeof setTimeout> | null = null;
-  private restartCount = 0;
-  private destroyed = false;
-
-  constructor(private sessionId: string) {}
-
-  /** Number of outstanding jobs sent to this process. */
-  get pendingCount(): number {
-    return this.pending.size;
-  }
-
-  private ensureRunning(): ChildProcess {
-    if (this.child !== null && this.child.connected) return this.child;
-
-    const resolvedPath = resolveSessionWorkerPath();
-
-    this.child = spawn(process.execPath, [...process.execArgv, resolvedPath], {
-      stdio: ["pipe", "pipe", "pipe", "ipc"],
-      windowsHide: true,
-    });
-
-    this.restartCount += 1;
-
-    this.child.on("message", (raw: unknown) => {
-      if (!isPlainRecord(raw)) {
-        logger.error("[sessionProcess] Received malformed IPC message from worker, discarding");
-        return;
-      }
-      const id = safeGetOwnProperty(raw, "id");
-      const result = safeGetOwnProperty(raw, "result");
-      if (typeof id !== "string" || !isPlainRecord(result)) {
-        logger.error("[sessionProcess] Received malformed IPC message from worker, discarding");
-        return;
-      }
-      // Runtime shape validated above; the cast bridges unknown → FinalizeLogResult.
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const msg = { id, result: result as FinalizeLogResult };
-      const pending = this.pending.get(msg.id);
-      if (pending !== undefined) {
-        this.pending.delete(msg.id);
-        pending.resolve(msg.result);
-      }
-      this.resetIdleTimer();
-    });
-
-    this.child.on("error", (err) => {
-      logger.error(`[sessionProcess] Session ${this.sessionId} process error:`, err.message);
-    });
-
-    this.child.on("exit", (code, signal) => {
-      const wasConnected = this.child !== null;
-      this.child = null;
-
-      if (this.destroyed) return;
-
-      // Reject all pending jobs on unexpected exit
-      for (const [, pending] of this.pending) {
-        pending.reject(
-          new Error(
-            `Session process exited with code ${code ?? signal}, session=${this.sessionId}`,
-          ),
-        );
-      }
-      this.pending.clear();
-
-      if (wasConnected && this.restartCount <= MAX_RESTARTS) {
-        logger.warn(
-          `[sessionProcess] Session ${this.sessionId} worker exited (code=${code ?? signal}), ` +
-            `restart ${this.restartCount}/${MAX_RESTARTS}`,
-        );
-      }
-    });
-
-    this.resetIdleTimer();
-    return this.child;
-  }
-
-  enqueue(job: FinalizeLogJob): Promise<FinalizeLogResult> {
-    return new Promise((resolve, reject) => {
-      const child = this.ensureRunning();
-      const id = String(++this.nextId);
-      this.pending.set(id, { resolve, reject });
-      try {
-        child.send({ id, job }, (err) => {
-          if (err === null || err === undefined) return;
-          this.pending.delete(id);
-          reject(
-            new Error(
-              `Session process send failed for session=${this.sessionId}: ${errorMessage(err)}`,
-            ),
-          );
-        });
-      } catch (err) {
-        this.pending.delete(id);
-        reject(
-          new Error(
-            `Session process send failed for session=${this.sessionId}: ${errorMessage(err)}`,
-          ),
-        );
-      }
-    });
-  }
-
-  private resetIdleTimer(): void {
-    if (this.idleTimer !== null) clearTimeout(this.idleTimer);
-    this.idleTimer = setTimeout(() => {
-      if (this.pending.size === 0) {
-        this.destroy();
-      }
-    }, IDLE_TIMEOUT_MS);
-  }
-
-  destroy(): void {
-    this.destroyed = true;
-    if (this.idleTimer !== null) {
-      clearTimeout(this.idleTimer);
-      this.idleTimer = null;
-    }
-    if (this.child !== null) {
-      this.child.kill();
-      this.child = null;
-    }
-    for (const [, pending] of this.pending) {
-      pending.reject(new Error(`Session process shut down, session=${this.sessionId}`));
-    }
-    this.pending.clear();
-    _processes.delete(this.sessionId);
-  }
-}
-
-/** Get or create a dedicated child process for a session. */
-export function getSessionProcess(sessionId: string): SessionProcess {
-  const existing = _processes.get(sessionId);
-  if (existing !== undefined) return existing;
-
-  const sp = new SessionProcess(sessionId);
-  _processes.set(sessionId, sp);
-  return sp;
-}
-
-/** Aggregate only queue depth for readiness; session identifiers remain private. */
-export function getSessionProcessPendingCount(): number {
-  let pending = 0;
-  for (const processWorker of _processes.values()) {
-    pending += processWorker.pendingCount;
-  }
-  return pending;
-}
-
-/** Forcefully tear down all session processes (e.g. on server shutdown). */
-export function destroyAllSessionProcesses(): void {
-  for (const [, sp] of _processes) {
-    sp.destroy();
-  }
-}

package/src/proxy/sessionRuntime.ts

@@ -1,121 +0,0 @@
-import { logger } from "./logger";
-import { executeFinalizeLogJob, type FinalizeLogJob } from "./logFinalizer";
-import { DEFAULT_RUNTIME_BUDGET_POLICY } from "../lib/resourceLimits";
-import {
-  getLogSessionId,
-  markSessionTaskFinished,
-  markSessionTaskQueued,
-  markSessionTaskStarted,
-} from "./sessionSupervisor";
-
-const UNASSIGNED_SESSION_QUEUE = "__unassigned__";
-
-export type SessionTaskName = "finalize-log";
-
-type SessionTask<T> = () => Promise<T> | T;
-
-const queues = new Map<string, Promise<void>>();
-let queuedTaskCount = 0;
-
-export class SessionTaskQueueRejectedError extends Error {
-  constructor(limit: number) {
-    super(`Session task queue is full; limit=${String(limit)}`);
-    this.name = "SessionTaskQueueRejectedError";
-  }
-}
-
-function queueKeyForSession(sessionId: string | null): string {
-  return sessionId ?? UNASSIGNED_SESSION_QUEUE;
-}
-
-function resolveSessionTaskQueueLimit(): number {
-  const configured = Number(process.env["SESSION_TASK_QUEUE_LIMIT"]);
-  if (Number.isSafeInteger(configured) && configured > 0) return configured;
-  return DEFAULT_RUNTIME_BUDGET_POLICY.queues.finalizerJobs;
-}
-
-function errorMessage(err: unknown): string {
-  return err instanceof Error ? err.message : String(err);
-}
-
-async function runSessionTask<T>(
-  sessionId: string | null,
-  taskName: SessionTaskName,
-  task: SessionTask<T>,
-): Promise<T> {
-  markSessionTaskStarted(sessionId);
-  try {
-    const result = await task();
-    markSessionTaskFinished(sessionId, null);
-    return result;
-  } catch (err) {
-    const message = errorMessage(err);
-    logger.error(`[sessionRuntime] ${taskName} failed for session ${sessionId ?? "unassigned"}`);
-    markSessionTaskFinished(sessionId, message);
-    return Promise.reject(err);
-  }
-}
-
-export function enqueueSessionTask<T>(
-  sessionId: string | null,
-  taskName: SessionTaskName,
-  task: SessionTask<T>,
-): Promise<T> {
-  const queueLimit = resolveSessionTaskQueueLimit();
-  if (queuedTaskCount >= queueLimit) {
-    logger.warn(
-      `[sessionRuntime] Rejecting ${taskName} for session ${sessionId ?? "unassigned"}: ` +
-        `queue full (${String(queuedTaskCount)}/${String(queueLimit)})`,
-    );
-    return Promise.reject(new SessionTaskQueueRejectedError(queueLimit));
-  }
-
-  const queueKey = queueKeyForSession(sessionId);
-  const previous = queues.get(queueKey) ?? Promise.resolve();
-
-  queuedTaskCount += 1;
-  markSessionTaskQueued(sessionId);
-
-  const current = previous
-    .catch(() => undefined)
-    .then(() => runSessionTask(sessionId, taskName, task));
-  const settled = current.then(
-    () => undefined,
-    () => undefined,
-  );
-
-  queues.set(queueKey, settled);
-  void settled.then(() => {
-    queuedTaskCount = Math.max(0, queuedTaskCount - 1);
-    if (queues.get(queueKey) === settled) {
-      queues.delete(queueKey);
-    }
-  });
-
-  return current;
-}
-
-export function enqueueFinalizeLogJob(job: FinalizeLogJob): Promise<void> {
-  return enqueueSessionTask(getLogSessionId(job.log), "finalize-log", () =>
-    executeFinalizeLogJob(job),
-  );
-}
-
-/** Wait until every per-session finalizer queue has settled. */
-export async function flushSessionTasks(): Promise<void> {
-  while (queues.size > 0) {
-    await Promise.all([...queues.values()]);
-  }
-}
-
-export function getSessionRuntimeQueueHealth(): {
-  activeQueues: number;
-  queuedTasks: number;
-  queueLimit: number;
-} {
-  return {
-    activeQueues: queues.size,
-    queuedTasks: queuedTaskCount,
-    queueLimit: resolveSessionTaskQueueLimit(),
-  };
-}