@tonyclaw/agent-inspector 2.1.10 → 2.1.12

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
@@ -498,3 +574,125 @@ export async function getClientInfo(request: Request): Promise<ClientInfo> {
   recentInflight = promise;
   return promise;
 }
+
+/**
+ * Lookup the PID owning a specific client-side local port, then enrich it
+ * with the process's cwd / project folder. Used by the identity-injecting
+ * native HTTP proxy in `identityProxy.ts`, which has access to
+ * `req.socket.remotePort` (the client's ephemeral port) and needs to know
+ * which process opened the connection.
+ *
+ * Results are cached by `clientPort` for `PORT_LOOKUP_TTL_MS` — a single
+ * keep-alive connection typically reuses the same client port for many
+ * requests, so we don't want to spawn a subprocess per request.
+ */
+const PORT_LOOKUP_TTL_MS = 5 * 60 * 1000;
+const portInfoCache = new Map<number, { info: ClientInfo; expiresAt: number }>();
+
+export async function lookupClientByPort(clientPort: number): Promise<ClientInfo> {
+  if (!Number.isInteger(clientPort) || clientPort <= 0 || clientPort > 65_535) {
+    return { port: null, pid: null, cwd: null, projectFolder: null };
+  }
+  const cached = portInfoCache.get(clientPort);
+  if (cached !== undefined && Date.now() < cached.expiresAt) {
+    return cached.info;
+  }
+  try {
+    const pid = await lookupPidByLocalPort(clientPort);
+    if (pid === null) {
+      const fallback: ClientInfo = {
+        port: clientPort,
+        pid: null,
+        cwd: null,
+        projectFolder: null,
+      };
+      portInfoCache.set(clientPort, { info: fallback, expiresAt: Date.now() + PORT_LOOKUP_TTL_MS });
+      return fallback;
+    }
+    const { cwd, projectFolder } = await lookupProcessInfo(pid);
+    const info: ClientInfo = { port: clientPort, pid, cwd, projectFolder };
+    portInfoCache.set(clientPort, { info, expiresAt: Date.now() + PORT_LOOKUP_TTL_MS });
+    return info;
+  } catch (err) {
+    logger.debug(`[socketTracker] lookupClientByPort(${clientPort}) failed:`, String(err));
+    return { port: clientPort, pid: null, cwd: null, projectFolder: null };
+  }
+}
+
+/** Returns the PID owning `clientPort` on the local machine, or `null`
+ *  if the port isn't held by any known process. Cross-platform wrapper
+ *  around the OS-specific connection table. */
+async function lookupPidByLocalPort(clientPort: number): Promise<number | null> {
+  const platform = process.platform;
+  try {
+    if (platform === "win32") {
+      // We deliberately use `netstat -ano | findstr` instead of
+      // `Get-NetTCPConnection -LocalPort`. The PowerShell cmdlet
+      // enumerates the entire socket table before filtering, which on a
+      // busy machine takes 10+ seconds — longer than our per-request
+      // timeout. `netstat -ano` streams its output and `findstr` filters
+      // line by line, completing in ~0.5s.
+      //
+      // `netstat -ano` lists every TCP connection twice — once for each
+      // endpoint. The format is:
+      //
+      //   Proto  LocalAddress        RemoteAddress       State            PID
+      //   TCP    [::1]:25949         [::1]:55193         ESTABLISHED     10936   ← server-side row (proxy owns the listener)
+      //   TCP    [::1]:55193         [::1]:25949         ESTABLISHED     29356   ← client-side row (curl owns the ephemeral port)
+      //
+      // For `clientPort` (the client's ephemeral port) we want the row
+      // whose LOCAL column ends with `:<clientPort>` — that's the row
+      // attributed to the client process.
+      const { stdout } = await execAsync(
+        `netstat -ano | findstr :${clientPort} | findstr ESTABLISHED`,
+        { shell: "cmd.exe", timeout: 2000, windowsHide: true },
+      );
+      const clientToken = `:${clientPort}`;
+      for (const rawLine of stdout.split("\n")) {
+        const line = rawLine.trim();
+        if (line === "") continue;
+        const cols = line.split(/\s+/);
+        if (cols.length < 5) continue;
+        const localAddr = cols[1] ?? "";
+        if (!localAddr.endsWith(clientToken)) continue;
+        const pidStr = cols[cols.length - 1] ?? "";
+        const parsed = parseInt(pidStr, 10);
+        if (Number.isInteger(parsed) && parsed > 0) return parsed;
+      }
+      return null;
+    }
+    // Unix: try `ss` first, fall back to `lsof`. Both need root or
+    // CAP_NET_ADMIN to see PIDs of processes owned by other users; when
+    // permission is denied the command exits non-zero and we return null.
+    try {
+      const { stdout } = await execAsync(
+        `ss -tanp state established 'sport = :${clientPort}' 2>/dev/null | tail -n +2 | head -n 1`,
+        { shell: "/bin/sh" },
+      );
+      const match = stdout.match(/pid=(\d+)/);
+      if (match !== null) {
+        const parsed = parseInt(match[1] ?? "", 10);
+        if (Number.isInteger(parsed) && parsed > 0) return parsed;
+      }
+    } catch {
+      // fall through
+    }
+    try {
+      const { stdout } = await execAsync(
+        `lsof -ti tcp:${clientPort} -sTCP:ESTABLISHED 2>/dev/null`,
+        {
+          shell: "/bin/sh",
+        },
+      );
+      const trimmed = stdout.trim().split("\n")[0] ?? "";
+      const parsed = parseInt(trimmed, 10);
+      if (Number.isInteger(parsed) && parsed > 0) return parsed;
+    } catch {
+      // fall through
+    }
+    return null;
+  } catch (err) {
+    logger.debug(`[socketTracker] lookupPidByLocalPort(${clientPort}) failed:`, String(err));
+    return null;
+  }
+}

package/.output/public/assets/_sessionId-3JCekYV3.js

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

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

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