@tonyclaw/agent-inspector 3.0.19 → 3.0.20

package/README.md

@@ -130,13 +130,13 @@ The web UI runs at http://localhost:9527. The public proxy endpoint is also
 `http://localhost:9527/proxy`; internally Agent Inspector may run the app on a private helper port,
 but AI tools should use the public URL printed by the CLI.
 
-The legacy `http://localhost:25947` port is closed by default. If you need a temporary alias for
+The legacy `http://localhost:9527` port is closed by default. If you need a temporary alias for
 older AI tool or MCP configs, start with `agent-inspector --legacy-port`.
 
 ## v3.0 Port Migration
 
-Agent Inspector v3.0 changes the default public port from `25947` to `9527`. The packaged CLI now
-opens only `9527` by default. Existing AI coding tool and MCP configs that still point at `25947`
+Agent Inspector v3.0 changes the default public port from `9527` to `9527`. The packaged CLI now
+opens only `9527` by default. Existing AI coding tool and MCP configs that still point at `9527`
 should be moved to `9527`, or you can temporarily start with `agent-inspector --legacy-port`.
 
 Use these endpoints for new configs:
@@ -266,7 +266,7 @@ configure `http://localhost:9527/api/mcp` directly. If it only supports stdio, c
 `agent-inspector-mcp stdio`; that command is only a bridge to `/api/mcp`, not a second Inspector
 server.
 
-Legacy MCP configs that still use `http://localhost:25947/api/mcp` require starting the CLI with
+Legacy MCP configs that still use `http://localhost:9527/api/mcp` require starting the CLI with
 `agent-inspector --legacy-port`; new configs should use `http://localhost:9527/api/mcp`.
 
 Coding agents can use the MCP surface in three ways:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonyclaw/agent-inspector",
-  "version": "3.0.19",
+  "version": "3.0.20",
   "type": "module",
   "description": "Agent observability and knowledge capture layer for AI coding tools.",
   "license": "MIT",

package/src/cli/onboard.ts

@@ -37,7 +37,7 @@ const __dirname = dirname(__filename);
 
 const DEFAULT_PORT = 9527;
 const DEFAULT_MCP_URL = `http://localhost:${DEFAULT_PORT}/api/mcp`;
-const LEGACY_MCP_URL = "http://localhost:25947/api/mcp";
+const LEGACY_MCP_URL = "http://localhost:9527/api/mcp";
 const SKILL_DIR_NAME = "agent-inspector-onboard";
 const SKILL_FILE_NAME = "SKILL.md";
 // Windows reserves `:` for NTFS alternate data streams, so a file named

package/src/cli.ts

@@ -24,12 +24,12 @@ import { findPidsByPort, killPid, openUrlCommand } from "./proxy/platformCommand
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-// v3 defaults the public entrypoint to 9527. The legacy 25947 alias can be
+// v3 defaults the public entrypoint to 9527. The legacy 9527 alias can be
 // enabled explicitly for older AI-tool and MCP configs. The TanStack Start
 // runtime stays on a private upstream port and public ports reverse-proxy to
 // that same runtime, so logs, sessions, and MCP state remain unified.
 const DEFAULT_PORT = 9527;
-const LEGACY_ALIAS_PORT = 25947;
+const LEGACY_ALIAS_PORT = 9527;
 const DEFAULT_UPSTREAM_PORT = 9529;
 const LOCAL_PROBE_TIMEOUT_MS = 2000;
 const BRANDED_WINDOWS_RUNTIME_EXE = "agent-inspector.exe";

package/src/contracts/json.ts

@@ -23,10 +23,15 @@ export const JsonValueSchema: z.ZodType<JsonValue> = z.lazy(() =>
 );
 
 /**
- * Re-types a value as `JsonValue` without re-walking it. Use this ONLY when
- * the value has already been validated and originated from `JSON.parse`.
+ * Re-types a value as `JsonValue` without a full recursive walk. A lightweight
+ * runtime guard rejects the most dangerous non-JSON types (undefined, bigint,
+ * functions) that would crash JSON.stringify downstream. Use when the value
+ * has already been validated by Zod or originated from JSON.parse.
  */
 export function trustAsJsonValue<T>(value: T): JsonValue {
+  if (value === undefined || typeof value === "bigint" || typeof value === "function") {
+    return null;
+  }
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return value as unknown as JsonValue;
 }

package/src/lib/providerContract.ts

@@ -1,5 +1,25 @@
 import { z } from "zod";
 
+/**
+ * Validates that a string is a well-formed http(s) URL. Rejects non-HTTP
+ * schemes (file:, ftp:, etc.) that could be used for SSRF. Local/private
+ * addresses are allowed because this tool legitimately proxies to local LLM
+ * servers (Ollama, LM Studio, etc.).
+ */
+function httpUrl(): z.ZodString {
+  return z.string().refine((val) => {
+    // Treat empty strings as "unset" so legacy/in-flight providers that
+    // store empty placeholders instead of null can still round-trip.
+    if (val.length === 0) return true;
+    try {
+      const parsed = new URL(val);
+      return parsed.protocol === "http:" || parsed.protocol === "https:";
+    } catch {
+      return false;
+    }
+  }, "Must be a valid http(s) URL");
+}
+
 export const ProviderModelMetadataSchema = z.object({
   model: z.string().min(1),
   contextWindow: z.number().int().positive().optional(),
@@ -20,12 +40,12 @@ export const ProviderConfigSchema = z.object({
   name: z.string(),
   apiKey: z.string(),
   model: z.string().optional(),
-  models: z.array(z.string()).min(1),
+  models: z.array(z.string()).optional().default([]),
   format: z.enum(["anthropic", "openai"]).optional(),
-  baseUrl: z.string().optional(),
-  anthropicBaseUrl: z.string().optional(),
-  openaiBaseUrl: z.string().optional(),
-  openaiResponsesBaseUrl: z.string().optional(),
+  baseUrl: httpUrl().optional(),
+  anthropicBaseUrl: httpUrl().optional(),
+  openaiBaseUrl: httpUrl().optional(),
+  openaiResponsesBaseUrl: httpUrl().optional(),
   authHeader: z.enum(["bearer", "x-api-key"]).optional().default("bearer"),
   apiDocsUrl: z.string().optional(),
   modelMetadataUrl: z.string().optional(),

package/src/mcp/server.ts

@@ -99,6 +99,7 @@ import {
   updateProviderImpl,
   type ToolResult,
 } from "./toolHandlers";
+import { logger } from "../proxy/logger";
 
 // ---------------------------------------------------------------------------
 // Lazy singleton: build the McpServer + transport on first use.
@@ -122,9 +123,17 @@ function buildServer(): ServerPair {
   const transport = new WebStandardStreamableHTTPServerTransport({
     sessionIdGenerator: undefined, // stateless — see module docstring
   });
-  // The connect() call is async but we don't need to await it here; the SDK
-  // buffers the first request internally.
-  void server.connect(transport);
+  // The connect() call is async — handle rejection so a failed transport
+  // setup doesn't leave a broken singleton that silently fails all requests.
+  void server.connect(transport).then(
+    () => {},
+    (err) => {
+      logger.error(
+        "[mcp] server.connect failed:",
+        err instanceof Error ? err.message : String(err),
+      );
+    },
+  );
   return { server, transport };
 }
 

package/src/mcp/toolHandlers.ts

@@ -777,7 +777,12 @@ export async function diagnoseCaptureImpl(
   const runtime = await getRuntimeConfigImpl(callApi);
   if (runtime.isError === true) return runtime;
   const runtimeText = runtime.content[0]?.text ?? "{}";
-  const runtimePayload: unknown = JSON.parse(runtimeText);
+  let runtimePayload: unknown = {};
+  try {
+    runtimePayload = JSON.parse(runtimeText);
+  } catch {
+    // Non-JSON runtime config text — treat as empty config and continue diagnostics
+  }
   const runtimeRecord = isRecord(runtimePayload) ? runtimePayload : {};
   const configRecord = isRecord(runtimeRecord["config"]) ? runtimeRecord["config"] : {};
   const captureMode = stringField(configRecord, "captureMode");

package/src/proxy/handler.ts

@@ -197,14 +197,24 @@ function handleStreamingResponse(
     return new Response("No response body", { status: STATUS_BAD_GATEWAY });
   }
 
-  const loggedStream = upstreamRes.body.pipeThrough(transform);
-
-  req.signal?.addEventListener("abort", () => {
-    if (log.responseText === null) {
-      logger.info(`[handler] Streaming client aborted: ${log.method} ${log.path}`);
-      scheduleStreamingFinalization("stream-abort");
-    }
+  // pipeTo returns a promise that rejects when either side errors. Without
+  // this catch, an upstream connection drop skips flush() and leaves the log
+  // permanently un-finalized with a leaked temp file.
+  void upstreamRes.body.pipeTo(transform.writable).catch(() => {
+    scheduleStreamingFinalization("streaming");
   });
+  const loggedStream = transform.readable;
+
+  if (req.signal === undefined) {
+    logger.warn("[handler] req.signal is undefined; abort detection disabled for this request");
+  } else {
+    req.signal.addEventListener("abort", () => {
+      if (log.responseText === null) {
+        logger.info(`[handler] Streaming client aborted: ${log.method} ${log.path}`);
+        scheduleStreamingFinalization("stream-abort");
+      }
+    });
+  }
 
   const responseHeaders = new Headers(upstreamRes.headers);
   responseHeaders.delete(HEADER_CONTENT_ENCODING);

package/src/proxy/logFinalizer.ts

@@ -10,6 +10,7 @@ import { getSessionProcess, isSessionProcessAvailable } from "./sessionProcess";
 import { finalizeLogUpdate } from "./store";
 import { computeTokensPerSecond } from "./streamTiming";
 import { analyzeToolSchemaWarnings } from "./toolSchemaWarnings";
+import { isPlainRecord, safeGetOwnProperty } from "../lib/objectUtils";
 
 type BaseFinalizeLogJob = {
   log: CapturedLog;
@@ -151,6 +152,11 @@ function applyOptionalStreamingTiming(log: CapturedLog, job: FinalizeLogJob): vo
         totalStreamMs: job.totalStreamMs,
       });
       return;
+    default: {
+      const _exhaustive: never = job;
+      logger.error(`[logFinalizer] Unhandled job type: ${JSON.stringify(_exhaustive)}`);
+      return;
+    }
   }
 }
 
@@ -241,6 +247,11 @@ function cleanupPathForRawStream(rawStream: string | RawStreamSource): string |
       return null;
     case "file":
       return rawStream.path;
+    default: {
+      const _exhaustive: never = rawStream;
+      logger.error(`[logFinalizer] Unhandled raw stream type: ${JSON.stringify(_exhaustive)}`);
+      return null;
+    }
   }
 }
 
@@ -263,6 +274,11 @@ function rawStreamByteLength(rawStream: string | RawStreamSource): number | null
       } catch {
         return null;
       }
+    default: {
+      const _exhaustive: never = rawStream;
+      logger.error(`[logFinalizer] Unhandled raw stream type: ${JSON.stringify(_exhaustive)}`);
+      return null;
+    }
   }
 }
 
@@ -304,6 +320,11 @@ function readRawStream(rawStream: string | RawStreamSource): {
         rawStreamText: readFileSync(rawStream.path, "utf-8"),
         cleanupRawStreamPath: rawStream.path,
       };
+    default: {
+      const _exhaustive: never = rawStream;
+      logger.error(`[logFinalizer] Unhandled raw stream type: ${JSON.stringify(_exhaustive)}`);
+      return { rawStreamText: "", cleanupRawStreamPath: null };
+    }
   }
 }
 
@@ -423,6 +444,7 @@ function finalizeStreamAbort(job: FinalizeStreamAbortLogJob, log: CapturedLog):
 
 export function buildFinalizeLogResult(job: FinalizeLogJob): FinalizeLogResult {
   const log = cloneLog(job.log);
+  const upstreamUrl = job.upstreamUrl;
 
   switch (job.type) {
     case "non-streaming":
@@ -431,6 +453,16 @@ export function buildFinalizeLogResult(job: FinalizeLogJob): FinalizeLogResult {
       return finalizeStreaming(job, log);
     case "stream-abort":
       return finalizeStreamAbort(job, log);
+    default: {
+      const _exhaustive: never = job;
+      logger.error(`[logFinalizer] Unhandled job type: ${JSON.stringify(_exhaustive)}`);
+      return {
+        log,
+        upstreamUrl,
+        error: "Unhandled job type",
+        cleanupRawStreamPath: null,
+      };
+    }
   }
 }
 
@@ -504,12 +536,25 @@ function resolveBuildPromise(job: FinalizeLogJob): Promise<FinalizeLogResult> {
       return executeBuildInWorker(job);
     case "inline":
       return Promise.resolve(buildFinalizeLogResult(job));
+    default: {
+      const _exhaustive: never = RUNTIME;
+      logger.error(`[logFinalizer] Unhandled runtime: ${JSON.stringify(_exhaustive)}`);
+      return Promise.resolve({
+        log: job.log,
+        upstreamUrl: job.upstreamUrl,
+        error: "Unhandled runtime",
+        cleanupRawStreamPath: null,
+      });
+    }
   }
 }
 
 const WORKER_COUNT = Math.max(1, Number(process.env["FINALIZER_WORKER_COUNT"]) || 4);
 let _workers: Worker[] | null = null;
-const _pending = new Map<string, (result: FinalizeLogResult) => void>();
+const _pending = new Map<
+  string,
+  { resolve: (result: FinalizeLogResult) => void; reject: (err: Error) => void }
+>();
 let _nextWorker = 0;
 let _jobSeq = 0;
 
@@ -518,11 +563,24 @@ function getWorkers(): Worker[] {
   _workers = [];
   for (let i = 0; i < WORKER_COUNT; i++) {
     const w = new Worker(new URL("./logFinalizer.worker.ts", import.meta.url));
-    w.on("message", (msg: { id: string; result: FinalizeLogResult }) => {
-      const resolve = _pending.get(msg.id);
-      if (resolve !== undefined) {
+    w.on("message", (raw: unknown) => {
+      if (!isPlainRecord(raw)) {
+        logger.error("[logFinalizer] 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("[logFinalizer] 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 entry = _pending.get(msg.id);
+      if (entry !== undefined) {
         _pending.delete(msg.id);
-        resolve(msg.result);
+        entry.resolve(msg.result);
       }
     });
     w.on("error", (err) => {
@@ -530,6 +588,13 @@ function getWorkers(): Worker[] {
         "[logFinalizer] Worker error:",
         err instanceof Error ? err.message : String(err),
       );
+      // Reject all pending jobs for this worker so callers don't hang forever
+      for (const [id, entry] of _pending) {
+        _pending.delete(id);
+        entry.reject(
+          new Error(`Worker crashed: ${err instanceof Error ? err.message : String(err)}`),
+        );
+      }
     });
     _workers.push(w);
   }
@@ -537,15 +602,18 @@ function getWorkers(): Worker[] {
 }
 
 export function executeBuildInWorker(job: FinalizeLogJob): Promise<FinalizeLogResult> {
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
     const list = getWorkers();
     // getWorkers() always returns at least 1 worker; the array index is safe
     const idx = _nextWorker % list.length;
     _nextWorker++;
     const w = list[idx];
-    if (w === undefined) return; // unreachable, satisfies type-checker
+    if (w === undefined) {
+      reject(new Error("No workers available"));
+      return;
+    }
     const id = String(++_jobSeq);
-    _pending.set(id, resolve);
+    _pending.set(id, { resolve, reject });
     w.postMessage({ id, job });
   });
 }

package/src/proxy/logIndex.ts

@@ -468,38 +468,24 @@ export async function rebuildIndex(): Promise<LogIndex> {
   return newIndex;
 }
 
-// Async mutex for atomic ID generation to prevent race conditions
-// Uses a promise queue instead of busy-waiting
-let idGenerationPromise: Promise<void> | null = null;
-let releaseLock: (() => void) | null = null;
-
-async function acquireLock(): Promise<void> {
-  if (releaseLock === null) {
-    idGenerationPromise = new Promise<void>((resolve) => {
-      releaseLock = resolve;
-    });
-  } else {
-    // Wait for the previous lock to be released
-    await idGenerationPromise;
-    // After waiting, we need to create a new promise for the next waiter
-    idGenerationPromise = new Promise<void>((resolve) => {
-      releaseLock = resolve;
-    });
-  }
-}
-
-function releaseLockFn(): void {
-  if (releaseLock) {
-    const resolve = releaseLock;
-    releaseLock = null;
-    idGenerationPromise = null;
-    resolve();
-  }
+// Promise-chaining queue for atomic ID generation. Each caller chains on the
+// previous promise, guaranteeing mutual exclusion without the broken
+// releaseLock pattern that allowed concurrent entry when 3+ callers waited.
+let idGenerationChain: Promise<void> = Promise.resolve();
+
+async function withIdLock<T>(fn: () => Promise<T>): Promise<T> {
+  const run = idGenerationChain.then(fn);
+  // Keep the chain alive regardless of success/failure so the next caller
+  // never sees a rejected antecedent.
+  idGenerationChain = run.then(
+    () => {},
+    () => {},
+  );
+  return run;
 }
 
 export async function getNextLogId(): Promise<number> {
-  await acquireLock();
-  try {
+  return withIdLock(async () => {
     const index = await loadIndex();
     const sqliteMaxId = await getSqliteLogIndexMaxId();
     const nextId = Math.max(index.maxId, sqliteMaxId ?? 0) + 1;
@@ -507,9 +493,7 @@ export async function getNextLogId(): Promise<number> {
     // Synchronously update the index in memory (disk write is deferred via batching)
     cachedIndex = index;
     return nextId;
-  } finally {
-    releaseLockFn();
-  }
+  });
 }
 
 export function getCurrentLogFile(): string {

package/src/proxy/providers.ts

@@ -379,7 +379,28 @@ if (providersJson !== undefined) {
 }
 
 export function getProviders(): ProviderConfig[] {
-  return store.get("providers", []);
+  const raw = store.get("providers", []);
+  // Validate the on-disk store entry-by-entry so a single corrupted record
+  // cannot wipe out the entire provider list. The whole-store safeParse was
+  // too strict — once any legacy/in-flight provider failed validation the
+  // whole list was discarded, which broke `updateProvider` and routing.
+  const valid: ProviderConfig[] = [];
+  for (const candidate of raw) {
+    const entry = ProviderConfigSchema.safeParse(candidate);
+    if (entry.success) {
+      valid.push(entry.data);
+      continue;
+    }
+    let candidateName = "<unknown>";
+    if (typeof candidate === "object" && candidate !== null) {
+      const nameResult = z.object({ name: z.string() }).safeParse(candidate);
+      if (nameResult.success) candidateName = nameResult.data.name;
+    }
+    logger.warn(
+      `[providers] Skipping invalid on-disk provider "${candidateName}": ${entry.error.message}`,
+    );
+  }
+  return valid;
 }
 
 export function getProvider(id: string): ProviderConfig | undefined {

package/src/proxy/sessionProcess.ts

@@ -3,6 +3,7 @@ import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 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;
@@ -53,7 +54,20 @@ export class SessionProcess {
 
     this.restartCount += 1;
 
-    this.child.on("message", (msg: { id: string; result: FinalizeLogResult }) => {
+    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);

package/src/proxy/upstream.ts

@@ -1,4 +1,5 @@
 import type { ProviderConfig } from "./providers";
+import { logger } from "./logger";
 import {
   AUTH_HEADER_X_API_KEY,
   DEFAULT_OPENAI_UPSTREAM,
@@ -77,8 +78,9 @@ export function setUpstreamHost(headers: Headers, upstreamBase: string): void {
   try {
     headers.set(HEADER_HOST, new URL(upstreamBase).host);
   } catch {
-    // Invalid provider URLs are rejected by the UI. Retain the historical default
-    // for imported or manually edited config that bypassed that validation.
+    logger.warn(
+      `[upstream] Invalid provider URL "${upstreamBase}" — falling back to api.anthropic.com for Host header`,
+    );
     headers.set(HEADER_HOST, "api.anthropic.com");
   }
 }