@tonyclaw/agent-inspector 3.0.7 → 3.0.9

package/src/components/proxy-viewer/log-formats/openai.ts

@@ -7,6 +7,7 @@ import {
 import { safeGetOwnProperty } from "../../../lib/objectUtils";
 import type { AnatomySegment } from "../anatomy/types";
 import { countCharacters, estimateTokens } from "../anatomy/tokenEstimate";
+import { parseRequestTools } from "../requestTools";
 import type { LogFormatAdapter } from "./types";
 import { emptyRequestAnalysis, EMPTY_RESPONSE_ANALYSIS } from "./types";
 
@@ -146,28 +147,24 @@ export const openAILogFormatAdapter: LogFormatAdapter = {
   analyzeRequest(rawBody) {
     if (rawBody === null) return emptyRequestAnalysis(rawBody);
     try {
-      const result = OpenAIRequestSchema.safeParse(JSON.parse(rawBody));
+      const parsedBody: unknown = JSON.parse(rawBody);
+      const toolCount = parseRequestTools(parsedBody)?.tools.length ?? null;
+      const result = OpenAIRequestSchema.safeParse(parsedBody);
       if (!result.success) {
-        const responsesResult = OpenAIResponsesRequestSchema.safeParse(JSON.parse(rawBody));
+        const responsesResult = OpenAIResponsesRequestSchema.safeParse(parsedBody);
         if (!responsesResult.success) return emptyRequestAnalysis(rawBody);
         return {
           parsed: responsesResult.data,
           comparisonValue: responsesResult.data,
           messageCount: countResponsesInput(responsesResult.data.input),
-          toolCount:
-            responsesResult.data.tools !== undefined && responsesResult.data.tools.length > 0
-              ? responsesResult.data.tools.length
-              : null,
+          toolCount,
         };
       }
       return {
         parsed: result.data,
         comparisonValue: result.data,
         messageCount: result.data.messages.length,
-        toolCount:
-          result.data.tools !== undefined && result.data.tools.length > 0
-            ? result.data.tools.length
-            : null,
+        toolCount,
       };
     } catch {
       return emptyRequestAnalysis(rawBody);

package/src/components/proxy-viewer/requestTools.ts

@@ -145,8 +145,11 @@ function parseAnthropicTool(tool: unknown): RequestToolDefinition | null {
 function parseOpenAITool(tool: unknown): RequestToolDefinition | null {
   const fn = safeGetOwnProperty(tool, "function");
   const toolType = safeGetOwnProperty(tool, "type");
-  if (fn === undefined && toolType !== "function") return null;
-  const name = safeGetOwnProperty(fn, "name") ?? safeGetOwnProperty(tool, "name");
+  if (fn === undefined && typeof toolType !== "string") return null;
+  const name =
+    safeGetOwnProperty(fn, "name") ??
+    safeGetOwnProperty(tool, "name") ??
+    (typeof toolType === "string" ? toolType : undefined);
   if (typeof name !== "string" || name.length === 0) return null;
   const description =
     safeGetOwnProperty(fn, "description") ?? safeGetOwnProperty(tool, "description");

package/src/lib/apiClient.ts

@@ -61,28 +61,61 @@ export class ApiTimeoutError extends Error {
 }
 
 /**
- * Fetch a JSON resource with a browser-side timeout. This prevents UI loading
- * states from waiting forever when a tab keeps a stale connection across a
- * local server force-restart.
+ * Fetch any resource with a browser-side timeout while preserving a caller
+ * supplied abort signal. The timeout is reported as `ApiTimeoutError`; caller
+ * cancellations keep the native abort shape so UI code can distinguish them.
  */
-export async function fetchJsonWithTimeout<T>(
+export async function fetchWithTimeout(
   input: RequestInfo | URL,
-  schema: z.ZodType<T>,
   timeoutMs: number,
   init?: RequestInit,
-  errorFallback?: (response: Response) => string,
-): Promise<T> {
+): Promise<Response> {
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  let timedOut = false;
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+
+  const callerSignal = init?.signal ?? undefined;
+  const abortFromCaller = (): void => controller.abort();
+  if (callerSignal !== undefined) {
+    if (callerSignal.aborted) {
+      controller.abort();
+    } else {
+      callerSignal.addEventListener("abort", abortFromCaller, { once: true });
+    }
+  }
 
   try {
-    return await fetchJson(input, schema, { ...init, signal: controller.signal }, errorFallback);
+    return await fetch(input, { ...init, signal: controller.signal });
   } catch (error) {
-    if (error instanceof DOMException && error.name === "AbortError") {
+    if (timedOut && error instanceof DOMException && error.name === "AbortError") {
       throw new ApiTimeoutError(timeoutMs);
     }
     throw error;
   } finally {
     clearTimeout(timeout);
+    callerSignal?.removeEventListener("abort", abortFromCaller);
   }
 }
+
+/**
+ * Fetch a JSON resource with a browser-side timeout. This prevents UI loading
+ * states from waiting forever when a tab keeps a stale connection across a
+ * local server force-restart.
+ */
+export async function fetchJsonWithTimeout<T>(
+  input: RequestInfo | URL,
+  schema: z.ZodType<T>,
+  timeoutMs: number,
+  init?: RequestInit,
+  errorFallback?: (response: Response) => string,
+): Promise<T> {
+  const response = await fetchWithTimeout(input, timeoutMs, init);
+  if (!response.ok) {
+    const fallback = errorFallback?.(response) ?? `Request failed with status ${response.status}`;
+    throw new Error(await readApiError(response, fallback));
+  }
+  return parseJsonResponse(response, schema);
+}

package/src/lib/ecosystemContract.ts

@@ -41,7 +41,39 @@ export const EcosystemPackagesResponseSchema = z.object({
   runnerPresets: z.array(EcosystemRunnerPresetSchema),
 });
 
+export const EcosystemTaskActionSchema = z.enum(["install", "upgrade", "help", "runner-presets"]);
+
+export const EcosystemTaskStatusSchema = z.enum(["queued", "running", "succeeded", "failed"]);
+
+export const EcosystemTaskSchema = z.object({
+  id: z.string(),
+  packageId: z.string(),
+  npmName: z.string(),
+  action: EcosystemTaskActionSchema,
+  status: EcosystemTaskStatusSchema,
+  command: z.string(),
+  output: z.string(),
+  createdAt: z.string(),
+  startedAt: z.string().nullable(),
+  finishedAt: z.string().nullable(),
+  exitCode: z.number().nullable(),
+  error: z.string().nullable(),
+});
+
+export const EcosystemTaskResponseSchema = z.object({
+  task: EcosystemTaskSchema,
+});
+
+export const EcosystemTasksResponseSchema = z.object({
+  tasks: z.array(EcosystemTaskSchema),
+});
+
 export type EcosystemPackageState = z.infer<typeof EcosystemPackageStateSchema>;
 export type EcosystemPackage = z.infer<typeof EcosystemPackageSchema>;
 export type EcosystemRunnerPreset = z.infer<typeof EcosystemRunnerPresetSchema>;
 export type EcosystemPackagesResponse = z.infer<typeof EcosystemPackagesResponseSchema>;
+export type EcosystemTaskAction = z.infer<typeof EcosystemTaskActionSchema>;
+export type EcosystemTaskStatus = z.infer<typeof EcosystemTaskStatusSchema>;
+export type EcosystemTask = z.infer<typeof EcosystemTaskSchema>;
+export type EcosystemTaskResponse = z.infer<typeof EcosystemTaskResponseSchema>;
+export type EcosystemTasksResponse = z.infer<typeof EcosystemTasksResponseSchema>;

package/src/lib/export-logs.ts

@@ -1,5 +1,6 @@
 import JSZip from "jszip";
 import type { CapturedLog } from "../contracts";
+import { fetchWithTimeout } from "./apiClient";
 import packageJson from "../../package.json";
 
 export type ExportMode = "redacted" | "raw";
@@ -8,6 +9,7 @@ export type ExportLogsResult =
   | {
       ok: false;
       message: string;
+      canceled?: boolean;
     };
 
 const REDACTED = "[REDACTED]";
@@ -23,6 +25,7 @@ const SECRET_TEXT_PATTERNS: readonly RegExp[] = [
 const MAX_EXPORT_LOGS = 200;
 const MAX_EXPORT_TEXT_CHARS = 25_000_000;
 const MAX_STREAMING_CHUNK_EXPORTS = 50;
+const STREAMING_CHUNK_EXPORT_TIMEOUT_MS = 10_000;
 
 export type ExportManifest = {
   version: string;
@@ -65,9 +68,27 @@ function exportLimitMessage(logs: readonly CapturedLog[]): string | null {
   return null;
 }
 
-async function fetchStreamingChunks(logId: number): Promise<string | null> {
+type ExportLogsOptions = {
+  signal?: AbortSignal;
+};
+
+function exportCanceled(signal: AbortSignal | undefined): ExportLogsResult | null {
+  if (signal?.aborted === true) {
+    return { ok: false, message: "Export canceled.", canceled: true };
+  }
+  return null;
+}
+
+async function fetchStreamingChunks(
+  logId: number,
+  signal: AbortSignal | undefined,
+): Promise<string | null> {
   try {
-    const response = await fetch(`/api/logs/${logId}/chunks`);
+    const response = await fetchWithTimeout(
+      `/api/logs/${logId}/chunks`,
+      STREAMING_CHUNK_EXPORT_TIMEOUT_MS,
+      { signal },
+    );
     if (!response.ok) return null;
     const data: unknown = await response.json();
     return JSON.stringify(data, null, 2);
@@ -145,7 +166,11 @@ export function buildExportManifest(
 export async function exportLogsAsZip(
   logs: CapturedLog[],
   mode: ExportMode = "redacted",
+  options: ExportLogsOptions = {},
 ): Promise<ExportLogsResult> {
+  const initialCancel = exportCanceled(options.signal);
+  if (initialCancel !== null) return initialCancel;
+
   const limitMessage = exportLimitMessage(logs);
   if (limitMessage !== null) return { ok: false, message: limitMessage };
 
@@ -167,6 +192,9 @@ export async function exportLogsAsZip(
 
   // Add regular request/response files
   for (const log of logs) {
+    const canceled = exportCanceled(options.signal);
+    if (canceled !== null) return canceled;
+
     if (log.rawRequestBody !== null) {
       zip.file(`#${log.id}.Request.json`, exportText(log.rawRequestBody, mode));
     }
@@ -177,7 +205,10 @@ export async function exportLogsAsZip(
 
   // Fetch SSE chunks sequentially so exports do not spike browser memory.
   for (const log of streamingLogs) {
-    const chunks = await fetchStreamingChunks(log.id);
+    const canceled = exportCanceled(options.signal);
+    if (canceled !== null) return canceled;
+
+    const chunks = await fetchStreamingChunks(log.id, options.signal);
     if (chunks !== null) {
       zip.file(`#${log.id}.SSE.Response.json`, exportText(chunks, mode));
     }
@@ -185,6 +216,9 @@ export async function exportLogsAsZip(
 
   // Generate and download ZIP
   const blob = await zip.generateAsync({ type: "blob" });
+  const canceled = exportCanceled(options.signal);
+  if (canceled !== null) return canceled;
+
   const url = URL.createObjectURL(blob);
 
   const anchor = document.createElement("a");

package/src/proxy/ecosystemRegistry.ts

@@ -0,0 +1,244 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import packageJson from "../../package.json";
+import type {
+  EcosystemPackage,
+  EcosystemPackageState,
+  EcosystemRunnerPreset,
+} from "../lib/ecosystemContract";
+import { npmSpawnCommand } from "./platformCommands";
+
+export type PackageDefinition = {
+  id: string;
+  name: string;
+  npmName: string;
+  capability: string;
+  description: string;
+  workflow: string;
+  primary: boolean;
+};
+
+type NpmResult = {
+  ok: boolean;
+  stdout: string;
+};
+
+export const ECOSYSTEM_PACKAGES: PackageDefinition[] = [
+  {
+    id: "inspector",
+    name: "Agent Inspector",
+    npmName: "@tonyclaw/agent-inspector",
+    capability: "Observe",
+    description: "Captures proxy traffic, sessions, turns, tools, providers, and raw bodies.",
+    workflow: "Keep every agent run visible and reloadable.",
+    primary: true,
+  },
+  {
+    id: "mcp",
+    name: "Inspector MCP",
+    npmName: "@tonyclaw/agent-inspector-mcp",
+    capability: "Connect",
+    description: "Exposes sessions, logs, providers, runs, and evidence to MCP clients.",
+    workflow: "Let Codex, OpenCode, MiMo Code, and other tools query Inspector as memory.",
+    primary: true,
+  },
+  {
+    id: "eval-harness",
+    name: "Eval Harness",
+    npmName: "@tonyclaw/eval-harness",
+    capability: "Evaluate",
+    description:
+      "Runs MCP-aware agent evaluations, runner presets, regressions, and model bakeoffs.",
+    workflow: "Promote Inspector evidence into repeatable evaluation batches.",
+    primary: false,
+  },
+];
+
+export const RUNNER_PRESETS: EcosystemRunnerPreset[] = [
+  {
+    id: "opencode",
+    name: "OpenCode",
+    validatedVersion: "1.17.11",
+    binary: "opencode",
+    modelFlag: "--model",
+    variantFlag: "--variant",
+    tools: ["opencode", "node"],
+    logDir: "opencode",
+    skillsDir: ".opencode/skills",
+    agentsDir: ".opencode/agents",
+  },
+  {
+    id: "mimo",
+    name: "MiMo Code",
+    validatedVersion: "0.1.4",
+    binary: "mimo",
+    modelFlag: "--model",
+    variantFlag: "--agent",
+    tools: ["mimo", "node"],
+    logDir: "mimocode",
+    skillsDir: ".mimocode/skills",
+    agentsDir: ".mimocode/agents",
+  },
+  {
+    id: "codex",
+    name: "Codex CLI",
+    validatedVersion: "0.142.5",
+    binary: "codex",
+    modelFlag: "--model",
+    variantFlag: null,
+    tools: ["codex"],
+    logDir: "codex",
+    skillsDir: ".codex/skills",
+    agentsDir: ".codex/agents",
+  },
+  {
+    id: "claude",
+    name: "Claude Code",
+    validatedVersion: "2.1.195",
+    binary: "claude",
+    modelFlag: "--model",
+    variantFlag: null,
+    tools: ["claude"],
+    logDir: "claude",
+    skillsDir: ".claude/skills",
+    agentsDir: ".claude/agents",
+  },
+];
+
+const NPM_TIMEOUT_MS = 4000;
+
+function runNpm(args: readonly string[]): Promise<NpmResult> {
+  return new Promise((resolve) => {
+    const command = npmSpawnCommand(args);
+    try {
+      execFile(
+        command.command,
+        command.args,
+        { timeout: NPM_TIMEOUT_MS, windowsHide: true },
+        (error, stdout) => {
+          resolve({
+            ok: error === null,
+            stdout: String(stdout).trim(),
+          });
+        },
+      );
+    } catch {
+      resolve({ ok: false, stdout: "" });
+    }
+  });
+}
+
+async function readGlobalNpmRoot(): Promise<string | null> {
+  const result = await runNpm(["root", "-g"]);
+  if (!result.ok || result.stdout.length === 0) return null;
+  return result.stdout;
+}
+
+function readGlobalNpmRootFallback(): string | null {
+  switch (process.platform) {
+    case "win32": {
+      const appData = process.env["APPDATA"];
+      if (appData === undefined || appData.length === 0) return null;
+      return join(appData, "npm", "node_modules");
+    }
+    case "darwin":
+    case "linux":
+    case "aix":
+    case "freebsd":
+    case "openbsd":
+    case "sunos": {
+      const prefix = process.env["PREFIX"];
+      if (prefix !== undefined && prefix.length > 0) return join(prefix, "lib", "node_modules");
+      return "/usr/local/lib/node_modules";
+    }
+    case "android":
+    case "cygwin":
+    case "haiku":
+    case "netbsd":
+      return null;
+  }
+
+  return null;
+}
+
+function packageJsonPath(globalRoot: string, npmName: string): string {
+  const parts = npmName.split("/");
+  return join(globalRoot, ...parts, "package.json");
+}
+
+function readJsonStringField(raw: unknown, field: string): string | null {
+  if (typeof raw !== "object" || raw === null) return null;
+  const descriptor = Object.getOwnPropertyDescriptor(raw, field);
+  if (descriptor === undefined) return null;
+  return typeof descriptor.value === "string" ? descriptor.value : null;
+}
+
+async function readInstalledVersion(
+  globalRoot: string | null,
+  npmName: string,
+): Promise<string | null> {
+  if (npmName === packageJson.name) return packageJson.version;
+  if (globalRoot === null) return null;
+
+  try {
+    const raw = await readFile(packageJsonPath(globalRoot, npmName), "utf8");
+    return readJsonStringField(JSON.parse(raw), "version");
+  } catch {
+    return null;
+  }
+}
+
+async function readLatestVersion(npmName: string): Promise<string | null> {
+  const result = await runNpm(["view", npmName, "version", "--json"]);
+  if (!result.ok || result.stdout.length === 0) return null;
+
+  try {
+    const parsed: unknown = JSON.parse(result.stdout);
+    return typeof parsed === "string" && parsed.length > 0 ? parsed : null;
+  } catch {
+    return result.stdout.length > 0 ? result.stdout : null;
+  }
+}
+
+function packageState(
+  installedVersion: string | null,
+  latestVersion: string | null,
+): EcosystemPackageState {
+  if (installedVersion !== null && latestVersion !== null && installedVersion !== latestVersion) {
+    return "update-available";
+  }
+  if (installedVersion !== null) return "installed";
+  if (latestVersion !== null) return "available";
+  return "planned";
+}
+
+async function describePackage(
+  definition: PackageDefinition,
+  globalRoot: string | null,
+): Promise<EcosystemPackage> {
+  const [installedVersion, latestVersion] = await Promise.all([
+    readInstalledVersion(globalRoot, definition.npmName),
+    readLatestVersion(definition.npmName),
+  ]);
+  const state = packageState(installedVersion, latestVersion);
+
+  return {
+    ...definition,
+    installCommand: `npm install -g ${definition.npmName}`,
+    installedVersion,
+    latestVersion,
+    state,
+  };
+}
+
+export async function listEcosystemPackages(): Promise<EcosystemPackage[]> {
+  const globalRoot = (await readGlobalNpmRoot()) ?? readGlobalNpmRootFallback();
+  return Promise.all(
+    ECOSYSTEM_PACKAGES.map((definition) => describePackage(definition, globalRoot)),
+  );
+}
+
+export function findEcosystemPackage(packageId: string): PackageDefinition | null {
+  return ECOSYSTEM_PACKAGES.find((definition) => definition.id === packageId) ?? null;
+}

package/src/proxy/ecosystemTasks.ts

@@ -0,0 +1,153 @@
+import { Buffer } from "node:buffer";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import type {
+  EcosystemTask,
+  EcosystemTaskAction,
+  EcosystemTaskStatus,
+} from "../lib/ecosystemContract";
+import { findEcosystemPackage } from "./ecosystemRegistry";
+import { npmCommand, npmSpawnCommand } from "./platformCommands";
+
+const MAX_TASKS = 50;
+const OUTPUT_LIMIT = 40_000;
+const INSTALL_TIMEOUT_MS = 120_000;
+const HELP_TIMEOUT_MS = 30_000;
+
+const tasks = new Map<string, EcosystemTask>();
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function trimOutput(output: string): string {
+  if (output.length <= OUTPUT_LIMIT) return output;
+  return output.slice(output.length - OUTPUT_LIMIT);
+}
+
+function appendTaskOutput(task: EcosystemTask, chunk: string): void {
+  task.output = trimOutput(`${task.output}${chunk}`);
+}
+
+function rememberTask(task: EcosystemTask): void {
+  tasks.set(task.id, task);
+  while (tasks.size > MAX_TASKS) {
+    const oldest = tasks.keys().next().value;
+    if (typeof oldest !== "string") return;
+    tasks.delete(oldest);
+  }
+}
+
+function packageActionArgs(action: EcosystemTaskAction, npmName: string): string[] {
+  switch (action) {
+    case "install":
+    case "upgrade":
+      return ["install", "-g", npmName];
+    case "help":
+      return ["exec", "--yes", npmName, "--", "--help"];
+    case "runner-presets":
+      return ["exec", "--yes", "@tonyclaw/eval-harness", "--", "runner-presets"];
+  }
+}
+
+function packageActionTimeout(action: EcosystemTaskAction): number {
+  switch (action) {
+    case "install":
+    case "upgrade":
+      return INSTALL_TIMEOUT_MS;
+    case "help":
+    case "runner-presets":
+      return HELP_TIMEOUT_MS;
+  }
+}
+
+function taskCommand(args: readonly string[]): string {
+  return `${npmCommand()} ${args.join(" ")}`;
+}
+
+function completeTask(
+  task: EcosystemTask,
+  status: Exclude<EcosystemTaskStatus, "queued" | "running">,
+  exitCode: number | null,
+  error: string | null,
+): void {
+  task.status = status;
+  task.exitCode = exitCode;
+  task.error = error;
+  task.finishedAt = nowIso();
+}
+
+export function getEcosystemTask(taskId: string): EcosystemTask | null {
+  return tasks.get(taskId) ?? null;
+}
+
+export function listEcosystemTasks(): EcosystemTask[] {
+  return [...tasks.values()].sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+}
+
+export function startEcosystemTask(
+  packageId: string,
+  action: EcosystemTaskAction,
+): EcosystemTask | null {
+  const definition =
+    action === "runner-presets"
+      ? findEcosystemPackage("eval-harness")
+      : findEcosystemPackage(packageId);
+  if (definition === null) return null;
+  if (action === "runner-presets" && packageId !== "eval-harness") return null;
+
+  const args = packageActionArgs(action, definition.npmName);
+  const task: EcosystemTask = {
+    id: randomUUID(),
+    packageId: definition.id,
+    npmName: definition.npmName,
+    action,
+    status: "queued",
+    command: taskCommand(args),
+    output: "",
+    createdAt: nowIso(),
+    startedAt: null,
+    finishedAt: null,
+    exitCode: null,
+    error: null,
+  };
+  rememberTask(task);
+
+  const spawnCommand = npmSpawnCommand(args);
+  const child = spawn(spawnCommand.command, spawnCommand.args, {
+    windowsHide: true,
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  const timeout = setTimeout(() => {
+    child.kill();
+    appendTaskOutput(task, `\nTimed out after ${String(packageActionTimeout(action) / 1000)}s.\n`);
+  }, packageActionTimeout(action));
+
+  task.status = "running";
+  task.startedAt = nowIso();
+  appendTaskOutput(task, `$ ${task.command}\n`);
+
+  child.stdout.on("data", (chunk: Buffer) => {
+    appendTaskOutput(task, chunk.toString("utf8"));
+  });
+  child.stderr.on("data", (chunk: Buffer) => {
+    appendTaskOutput(task, chunk.toString("utf8"));
+  });
+  child.on("error", (error) => {
+    clearTimeout(timeout);
+    appendTaskOutput(task, `\n${error.message}\n`);
+    completeTask(task, "failed", null, error.message);
+  });
+  child.on("close", (code) => {
+    clearTimeout(timeout);
+    if (task.status === "failed") return;
+    if (code === 0) {
+      completeTask(task, "succeeded", code, null);
+      return;
+    }
+    completeTask(task, "failed", code, `Command exited with code ${String(code ?? "unknown")}`);
+  });
+
+  return task;
+}