@tonyclaw/agent-inspector 2.1.11 → 2.1.13

package/src/cli.ts

@@ -17,8 +17,14 @@ import { startIdentityProxy } from "./proxy/identityProxy.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+// External-facing port stays at 25947 so existing tooling / AI clients
+// (Claude Code, OpenCode, MiMo Code, etc.) keep working with the
+// unchanged `ANTHROPIC_BASE_URL=http://localhost:25947/proxy`. The
+// identity-injecting proxy listens on that port; the TanStack Start
+// upstream is moved to a private port (25949 by default) and reverse-
+// proxied through.
 const DEFAULT_PORT = 25947;
-const DEFAULT_IDENTITY_PORT = 25949;
+const DEFAULT_UPSTREAM_PORT = 25949;
 const LOCAL_PROBE_TIMEOUT_MS = 2000;
 const BRANDED_WINDOWS_RUNTIME_EXE = "agent-inspector.exe";
 const DEFAULT_CAPTURE_MODE = "simple";
@@ -247,9 +253,9 @@ async function runStart(args: string[]): Promise<void> {
   let captureModeWasSpecified = false;
   let enableIdentityProxy = true;
   let identityProxyPort =
-    process.env["AGENT_INSPECTOR_IDENTITY_PORT"] !== undefined
-      ? Number(process.env["AGENT_INSPECTOR_IDENTITY_PORT"])
-      : DEFAULT_IDENTITY_PORT;
+    process.env["AGENT_INSPECTOR_PORT"] !== undefined
+      ? Number(process.env["AGENT_INSPECTOR_PORT"])
+      : DEFAULT_PORT;
 
   if (envMode !== undefined && envMode !== "") {
     const parsedMode = parseCaptureMode(envMode);
@@ -445,7 +451,12 @@ async function runStart(args: string[]): Promise<void> {
     }
   }
 
-  process.env["PORT"] = String(port);
+  // TanStack Start listens on the private upstream port; the identity
+  // proxy owns the public-facing `port`. When the identity proxy is
+  // disabled (or not yet running) we fall back to TanStack listening on
+  // the public port directly.
+  const upstreamPort = enableIdentityProxy ? DEFAULT_UPSTREAM_PORT : port;
+  process.env["PORT"] = String(upstreamPort);
 
   const url = urlForHost(port, host);
 
@@ -475,7 +486,10 @@ async function runStart(args: string[]): Promise<void> {
 
   if (forceRestart) {
     killProcessOnPort(port);
-    if (enableIdentityProxy) killProcessOnPort(identityProxyPort);
+    if (enableIdentityProxy) {
+      killProcessOnPort(identityProxyPort);
+      killProcessOnPort(upstreamPort);
+    }
   }
 
   console.log(`Server running at ${url}`);
@@ -553,12 +567,14 @@ async function runStart(args: string[]): Promise<void> {
   // still get accurate session attribution. Started only after TanStack
   // Start is healthy, so the upstream is ready by the time clients connect.
   const identityProxy = enableIdentityProxy
-    ? await tryStartIdentityProxy(identityProxyPort, port, host)
+    ? await tryStartIdentityProxy(identityProxyPort, upstreamPort, host)
     : null;
 
   if (background) {
     serverProcess.unref();
-    if (await waitForInspectorHealthy(port, 5000, host)) {
+    // Probe the upstream TanStack port directly — the identity proxy is
+    // not started yet so the public port is not yet accepting traffic.
+    if (await waitForInspectorHealthy(upstreamPort, 5000, host)) {
       console.log(`agent-inspector background server is ready at ${url}`);
       if (identityProxy !== null) {
         console.log(`Identity proxy ready on port ${identityProxyPort} (PID-attributing proxy).`);

package/src/components/proxy-viewer/ConversationGroup.tsx

@@ -77,6 +77,24 @@ function collectProviders(logs: CapturedLog[]): {
   }));
 }
 
+export function getFirstClientPid(logs: readonly CapturedLog[]): number | null {
+  for (const log of logs) {
+    const pid = log.clientPid;
+    if (pid !== null && pid !== undefined) return pid;
+  }
+  return null;
+}
+
+export function getFirstClientProjectFolder(logs: readonly CapturedLog[]): string | null {
+  for (const log of logs) {
+    const projectFolder = log.clientProjectFolder;
+    if (projectFolder !== null && projectFolder !== undefined && projectFolder !== "") {
+      return projectFolder;
+    }
+  }
+  return null;
+}
+
 export const ConversationGroup = memo(function ({
   group,
   viewMode = "simple",
@@ -110,6 +128,8 @@ export const ConversationGroup = memo(function ({
   const endTime = group.logs[group.logs.length - 1]?.timestamp ?? new Date().toISOString();
   const isLoading = group.logs.some((log) => log.responseStatus === null);
   const showTraceRollupMetrics = standalone && !hasPinnedSessionContext;
+  const clientPid = useMemo(() => getFirstClientPid(group.logs), [group.logs]);
+  const clientProjectFolder = useMemo(() => getFirstClientProjectFolder(group.logs), [group.logs]);
 
   // Pre-compute stop reasons for each log — used by turnIndices
   const turnGroups = useMemo(() => buildTurnGroups(group.logs), [group.logs]);
@@ -144,8 +164,8 @@ export const ConversationGroup = memo(function ({
           providers={providers}
           isLoading={isLoading}
           userAgent={group.logs[0]?.userAgent ?? null}
-          clientPid={group.logs[0]?.clientPid ?? null}
-          clientProjectFolder={group.logs[0]?.clientProjectFolder ?? null}
+          clientPid={clientPid}
+          clientProjectFolder={clientProjectFolder}
           timeDisplayFormat={timeDisplayFormat}
           onClear={() => onClearGroup(group.logs.map((l) => l.id))}
         />

package/src/components/proxy-viewer/LogEntryHeader.tsx

@@ -162,6 +162,13 @@ export const LogEntryHeader = memo(function ({
   const tokenRateLabel =
     tokensPerSecond === null || tokensPerSecond <= 0 ? null : formatTokenRate(tokensPerSecond);
   const warningCount = log.warnings?.length ?? 0;
+  const hasClientPid = log.clientPid !== null && log.clientPid !== undefined;
+  const hasClientProjectFolder =
+    log.clientProjectFolder !== null &&
+    log.clientProjectFolder !== undefined &&
+    log.clientProjectFolder !== "";
+  const hasClientCwd =
+    log.clientCwd !== null && log.clientCwd !== undefined && log.clientCwd !== "";
 
   return (
     <TooltipProvider>
@@ -366,12 +373,12 @@ export const LogEntryHeader = memo(function ({
         )}
 
         {/* Client info (PID + project folder) */}
-        {(log.clientPid !== null || log.clientProjectFolder !== null) && (
+        {(hasClientPid || hasClientProjectFolder) && (
           <Tooltip>
             <TooltipTrigger asChild>
               <span className="hidden xl:flex items-center gap-1 text-purple-400/80 text-xs shrink-0">
                 <FileTerminal className="size-3" />
-                {log.clientProjectFolder !== null ? (
+                {hasClientProjectFolder ? (
                   <span className="font-mono tabular-nums">{log.clientProjectFolder}</span>
                 ) : (
                   <span className="font-mono tabular-nums">PID {log.clientPid}</span>
@@ -379,7 +386,7 @@ export const LogEntryHeader = memo(function ({
               </span>
             </TooltipTrigger>
             <TooltipContent>
-              {log.clientCwd !== null
+              {hasClientCwd
                 ? `PID: ${log.clientPid ?? "?"}  CWD: ${log.clientCwd}`
                 : `Process ID: ${log.clientPid ?? "?"}`}
             </TooltipContent>

package/src/proxy/identityProxy.ts

@@ -10,7 +10,6 @@ const IDENTITY_HEADERS = {
 } as const;
 
 const REQUEST_HOP_BY_HOP = new Set([
-  "host",
   "connection",
   "keep-alive",
   "proxy-authenticate",
@@ -34,11 +33,11 @@ const RESPONSE_HOP_BY_HOP = new Set([
 ]);
 
 export type IdentityProxyOptions = {
-  /** Port to listen on (default 25949). Clients point at this. */
+  /** Public port to listen on. Clients point at this. */
   listenPort: number;
   /** Host the upstream TanStack Start server listens on. */
   upstreamHost: string;
-  /** Port the upstream TanStack Start server listens on (default 25947). */
+  /** Port the upstream TanStack Start server listens on. */
   upstreamPort: number;
 };
 
@@ -140,13 +139,6 @@ async function handleRequest(
     }
   }
 
-  process.stderr.write(
-    `[identity-proxy] req ${req.method} ${req.url} remotePort=${remotePort} pid=${identity?.pid ?? "?"}\n`,
-  );
-  process.stderr.write(
-    `[identity-proxy] forwarding headers: pid=${upstreamHeaders[IDENTITY_HEADERS.pid] ?? "?"} cwd=${upstreamHeaders[IDENTITY_HEADERS.cwd] ?? "?"}\n`,
-  );
-
   const proxyReq = http.request(
     {
       hostname: options.upstreamHost,

package/src/proxy/socketTracker.ts

@@ -17,6 +17,11 @@ type CacheEntry = ClientInfo & {
   expiresAt: number;
 };
 
+type NetstatClient = {
+  pid: number;
+  localPort: number;
+};
+
 // Cache entries: port -> { pid, cwd, projectFolder, expiresAt }
 const cache = new Map<number, CacheEntry>();
 const CACHE_TTL_MS = 5 * 60 * 1000;
@@ -316,33 +321,23 @@ async function lookupRecentClient(): Promise<ClientInfo> {
   const platform = process.platform;
   try {
     if (platform === "win32") {
-      // Get-NetTCPConnection gives us CreationTime on the client-side
-      // (-RemotePort) entries, which we sort descending to pick the freshest.
-      const psScript = [
-        `$rows = Get-NetTCPConnection -RemotePort ${port} -State Established -ErrorAction SilentlyContinue`,
-        `if ($rows) {`,
-        `  $rows = $rows | Sort-Object CreationTime -Descending`,
-        `  $top = $rows | Select-Object -First 1`,
-        `  if ($top) { Write-Output ("$($top.OwningProcess)|$($top.LocalPort)") }`,
-        `}`,
-      ].join("; ");
-      const { stdout } = await execFileAsync(
-        "powershell.exe",
-        ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", psScript],
-        { windowsHide: true, timeout: 3000, maxBuffer: 16 * 1024 },
-      );
-      const trimmed = stdout.trim();
-      if (trimmed === "") return { port: null, pid: null, cwd: null, projectFolder: null };
-      const [pidStr, portStr] = trimmed.split("|");
-      const pid = parseInt(pidStr ?? "", 10);
-      const clientPort = parseInt(portStr ?? "", 10);
-      if (!Number.isInteger(pid) || pid <= 0) {
+      // `Get-NetTCPConnection` can take several seconds on busy Windows
+      // machines, which makes direct-port clients (notably MiMo Code) lose
+      // their PID before the fallback completes. `netstat` streams quickly
+      // and includes the owning process id for established loopback rows.
+      const { stdout } = await execFileAsync("netstat.exe", ["-ano", "-p", "TCP"], {
+        windowsHide: true,
+        timeout: 2000,
+        maxBuffer: 2 * 1024 * 1024,
+      });
+      const client = pickNewestClientFromWindowsNetstat(stdout.split("\n"), port);
+      if (client === null) {
         return { port: null, pid: null, cwd: null, projectFolder: null };
       }
-      const { cwd, projectFolder } = await lookupProcessInfo(pid);
+      const { cwd, projectFolder } = await lookupProcessInfo(client.pid);
       return {
-        port: Number.isInteger(clientPort) && clientPort > 0 ? clientPort : null,
-        pid,
+        port: client.localPort,
+        pid: client.pid,
         cwd,
         projectFolder,
       };
@@ -403,6 +398,56 @@ function pickNewestClientPidFromNetstat(lines: string[], proxyPort: number): num
   return candidates[0]?.pid ?? null;
 }
 
+function parseAddressPort(address: string): number | null {
+  const match = address.match(/:(\d+)$/);
+  if (match === null) return null;
+  const parsed = parseInt(match[1] ?? "", 10);
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65_535) return null;
+  return parsed;
+}
+
+function pickNewestClientFromWindowsNetstat(
+  lines: string[],
+  proxyPort: number,
+): NetstatClient | null {
+  const proxyToken = `:${proxyPort}`;
+  type Row = NetstatClient & { order: number };
+  const candidates: Row[] = [];
+  let order = 0;
+
+  for (const line of lines) {
+    order++;
+    const cols = line.trim().split(/\s+/);
+    if (cols.length < 5) continue;
+    const localAddr = cols[1] ?? "";
+    const remoteAddr = cols[2] ?? "";
+    const state = cols[3] ?? "";
+    const pidStr = cols[4] ?? "";
+    if (state !== "ESTABLISHED") continue;
+    if (!remoteAddr.endsWith(proxyToken)) continue;
+
+    const localPort = parseAddressPort(localAddr);
+    if (localPort === null || localPort === proxyPort) continue;
+
+    const pid = parseInt(pidStr, 10);
+    if (!Number.isInteger(pid) || pid <= 0) continue;
+    candidates.push({ pid, localPort, order });
+  }
+
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => b.localPort - a.localPort || b.order - a.order);
+  const selected = candidates[0];
+  if (selected === undefined) return null;
+  return { pid: selected.pid, localPort: selected.localPort };
+}
+
+export function _pickNewestClientFromWindowsNetstatForTests(
+  lines: string[],
+  proxyPort: number,
+): NetstatClient | null {
+  return pickNewestClientFromWindowsNetstat(lines, proxyPort);
+}
+
 /** Custom request headers the client (or a wrapper script) may set so we
  *  can identify the originating process without scanning the OS connection
  *  table. Recognized names:
@@ -473,6 +518,37 @@ export async function getClientInfo(request: Request): Promise<ClientInfo> {
   const fromHeaders = readClientHeaders(request);
   if (fromHeaders !== null) return fromHeaders;
 
+  const remotePort = extractRemotePort(request);
+  if (remotePort !== null) {
+    const cachedPort = getFromCache(remotePort);
+    if (cachedPort !== null) return cachedPort;
+
+    const existingPortLookup = inflight.get(remotePort);
+    if (existingPortLookup !== undefined) return existingPortLookup;
+
+    const portLookup = lookupClientByPort(remotePort)
+      .then((info) => {
+        setCache(remotePort, info);
+        inflight.delete(remotePort);
+        return info;
+      })
+      .catch((err) => {
+        inflight.delete(remotePort);
+        logger.debug(`[socketTracker] Remote-port lookup failed for ${remotePort}:`, String(err));
+        const fallback: ClientInfo = {
+          port: remotePort,
+          pid: null,
+          cwd: null,
+          projectFolder: null,
+        };
+        setCache(remotePort, fallback);
+        return fallback;
+      });
+
+    inflight.set(remotePort, portLookup);
+    return portLookup;
+  }
+
   // Fallback: scan the OS connection table for the most recently opened
   // client→proxy connection. Best-effort — in environments with many
   // long-lived keep-alive connections (browsers, background processes) the

package/.output/public/assets/_sessionId-DAwcZWfu.js

@@ -1 +0,0 @@
-import{R as s,j as e}from"./main-C-lua4Uq.js";import{P as i}from"./ProxyViewerContainer-DFFxBlvO.js";function t(){const{sessionId:o}=s.useParams();return e.jsx(i,{initialSessionId:o},o)}export{t as component};

package/.output/public/assets/index-B6sDoCll.js

@@ -1 +0,0 @@
-import{P as o}from"./ProxyViewerContainer-DFFxBlvO.js";import"./main-C-lua4Uq.js";const r=o;export{r as component};