peachsim 0.1.1469 → 0.1.1481

package/dist-lib/scripts/dev-server-scanner.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1469 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1481 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __create = Object.create;
@@ -280,6 +280,7 @@ __export(dev_server_scanner_exports, {
   __shouldReuseScannerCacheEntry: () => __shouldReuseScannerCacheEntry,
   discoverListeningPorts: () => discoverListeningPorts,
   discoverListeningProcesses: () => discoverListeningProcesses,
+  pinSharedListenerScan: () => pinSharedListenerScan,
   probePort: () => probePort,
   resolveListeningPid: () => resolveListeningPid,
   resolveProcessCwd: () => resolveProcessCwd,
@@ -292,161 +293,9 @@ var import_promises2 = require("fs/promises");
 var import_http = __toESM(require("http"), 1);
 var import_net = __toESM(require("net"), 1);
 var import_node_fs2 = require("node:fs");
+var import_node_os = require("node:os");
 var import_node_path3 = require("node:path");
 
-// ../contrast/src/runtime/process-group.ts
-var import_node_child_process = require("node:child_process");
-
-// ../contrast/src/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-
-// ../contrast/src/runtime/process-group.ts
-var GRACEFUL_TIMEOUT_MS = 3e3;
-var FORCED_EXIT_TIMEOUT_MS = 1e3;
-function signalProcessGroup(child, signal) {
-  if (!child.pid) return;
-  try {
-    process.kill(-child.pid, signal);
-  } catch {
-    try {
-      process.kill(child.pid, signal);
-    } catch {
-    }
-  }
-}
-function runningPids(pids) {
-  return pids.filter((pid) => {
-    try {
-      process.kill(pid, 0);
-      return true;
-    } catch (error) {
-      return error instanceof Error && "code" in error && error.code === "EPERM";
-    }
-  });
-}
-function groupIsEmpty(pgid) {
-  try {
-    process.kill(-pgid, 0);
-  } catch (error) {
-    if (!(error instanceof Error && "code" in error && error.code === "EPERM"))
-      return true;
-  }
-  const result = (0, import_node_child_process.spawnSync)("ps", ["-A", "-o", "pgid=,stat="], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  if (result.error || result.status !== 0) return false;
-  return !result.stdout.split("\n").some((line) => {
-    const [group, state] = line.trim().split(/\s+/);
-    return Number(group) === pgid && state !== void 0 && !state.startsWith("Z");
-  });
-}
-async function waitForExit(pids, pgid, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  const gone = () => runningPids(pids).length === 0 && groupIsEmpty(pgid);
-  while (Date.now() < deadline) {
-    if (gone()) return true;
-    await sleep(50);
-  }
-  return gone();
-}
-async function terminateProcessGroup(child, signal = "SIGTERM", gracefulTimeoutMs = GRACEFUL_TIMEOUT_MS) {
-  if (!child.pid) {
-    try {
-      child.kill(signal);
-    } catch {
-    }
-    return;
-  }
-  signalProcessGroup(child, "SIGSTOP");
-  const descendants = /* @__PURE__ */ new Set();
-  let parents = [child.pid];
-  let inspectionError = null;
-  while (parents.length > 0) {
-    const result = (0, import_node_child_process.spawnSync)("pgrep", ["-P", parents.join(",")], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    if (result.error || result.status !== 0 && result.status !== 1) {
-      inspectionError = new Error(
-        `could not inspect descendants of processes ${parents.join(",")}: ${result.error?.message || result.stderr.trim() || `pgrep exited ${result.status}`}`
-      );
-      break;
-    }
-    const next = [];
-    for (const line of result.stdout.split("\n")) {
-      const descendantPid = Number(line.trim());
-      if (Number.isInteger(descendantPid) && descendantPid > 1 && !descendants.has(descendantPid)) {
-        descendants.add(descendantPid);
-        next.push(descendantPid);
-        try {
-          process.kill(descendantPid, "SIGSTOP");
-        } catch {
-        }
-      }
-    }
-    parents = next;
-  }
-  const pids = [child.pid, ...descendants];
-  const gracefulDeadline = Date.now() + gracefulTimeoutMs;
-  try {
-    process.kill(child.pid, signal);
-  } catch {
-  }
-  signalProcessGroup(child, "SIGCONT");
-  for (const pid of descendants) {
-    try {
-      process.kill(pid, "SIGCONT");
-    } catch {
-    }
-  }
-  let rootExited = child.exitCode !== null || child.signalCode !== null;
-  if (!rootExited) {
-    rootExited = await new Promise((resolveExit) => {
-      const onExit = () => {
-        clearTimeout(deadlineTimer);
-        resolveExit(true);
-      };
-      const deadlineTimer = setTimeout(
-        () => {
-          child.removeListener("exit", onExit);
-          resolveExit(false);
-        },
-        Math.max(0, gracefulDeadline - Date.now())
-      );
-      child.once("exit", onExit);
-      if (child.exitCode !== null || child.signalCode !== null) {
-        child.removeListener("exit", onExit);
-        onExit();
-      }
-    });
-  }
-  if (rootExited) {
-    signalProcessGroup(child, signal);
-    for (const pid of descendants) {
-      try {
-        process.kill(pid, signal);
-      } catch {
-      }
-    }
-  }
-  if (await waitForExit(pids, child.pid, Math.max(0, gracefulDeadline - Date.now()))) {
-    if (inspectionError) throw inspectionError;
-    return;
-  }
-  for (const pid of pids) {
-    try {
-      process.kill(pid, "SIGKILL");
-    } catch {
-    }
-  }
-  signalProcessGroup(child, "SIGKILL");
-  await waitForExit(pids, child.pid, FORCED_EXIT_TIMEOUT_MS);
-  if (inspectionError) throw inspectionError;
-}
-
 // src/backend-origin.ts
 var LOOPBACK_PROBE_HOSTNAMES = ["127.0.0.1", "::1"];
 function normalizeHostname(hostname) {
@@ -990,52 +839,211 @@ function optionalDemoAppsSync() {
 }
 
 // scripts/dev-server-scanner.ts
-function execGuarded(command, timeout, extra = {}) {
-  const maxBuffer = extra.maxBuffer ?? 1024 * 1024;
-  return new Promise((resolve2, reject) => {
-    const child = (0, import_child_process.spawn)("/bin/sh", ["-c", command], {
-      detached: true,
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    let stdout = "";
-    let settled = false;
-    let killing = false;
-    const settle = (err) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(deadline);
-      if (err) reject(err);
-      else resolve2({ stdout });
-    };
-    const killThenSettle = (err) => {
-      if (killing) return;
-      killing = true;
-      clearTimeout(deadline);
-      terminateProcessGroup(child, "SIGKILL", 0).finally(() => settle(err));
-    };
-    const deadline = setTimeout(() => {
-      killThenSettle(
-        Object.assign(new Error(`\`${command}\` did not exit within ${timeout}ms`), {
-          killed: true
-        })
-      );
-    }, timeout);
-    child.stdout.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-      if (stdout.length > maxBuffer) {
-        killThenSettle(new Error(`\`${command}\` exceeded maxBuffer ${maxBuffer}`));
+var LISTENER_LOCK_PATH = (0, import_node_path3.join)((0, import_node_os.tmpdir)(), "peach-listener-scan.lock");
+var LISTENER_RESULT_PATH = (0, import_node_path3.join)((0, import_node_os.tmpdir)(), "peach-listener-scan.result");
+var LISTENER_LOCK_STALE_MS = 25e3;
+var LISTENER_LOCK_WAIT_MS = 8e3;
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function pidIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+    return code !== "ESRCH";
+  }
+}
+function readLockOwner() {
+  try {
+    const raw = (0, import_node_fs2.readFileSync)(LISTENER_LOCK_PATH, "utf8");
+    const mtimeMs = (0, import_node_fs2.statSync)(LISTENER_LOCK_PATH).mtimeMs;
+    const pid = Number(raw.split("-")[0]);
+    return { raw, pid: Number.isInteger(pid) ? pid : -1, mtimeMs };
+  } catch {
+    return null;
+  }
+}
+function lockIsAbandoned(owner) {
+  if (owner.pid <= 0 || !pidIsAlive(owner.pid)) return true;
+  return Date.now() - owner.mtimeMs > LISTENER_LOCK_STALE_MS;
+}
+function clearLock(raw) {
+  try {
+    if ((0, import_node_fs2.readFileSync)(LISTENER_LOCK_PATH, "utf8") !== raw) return;
+    (0, import_node_fs2.unlinkSync)(LISTENER_LOCK_PATH);
+  } catch {
+  }
+}
+function readResult() {
+  try {
+    const parsed = JSON.parse(
+      (0, import_node_fs2.readFileSync)(LISTENER_RESULT_PATH, "utf8")
+    );
+    if (!parsed || typeof parsed.token !== "string" || typeof parsed.key !== "string")
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function publishResult(payload) {
+  const tmp = `${LISTENER_RESULT_PATH}.${process.pid}.tmp`;
+  (0, import_node_fs2.writeFileSync)(tmp, JSON.stringify(payload));
+  (0, import_node_fs2.renameSync)(tmp, LISTENER_RESULT_PATH);
+}
+function throwPublished(payload) {
+  throw Object.assign(new Error(payload.message || "listener scan failed"), {
+    killed: payload.killed === true
+  });
+}
+async function waitForSharedResult(owner, key) {
+  const cap = Date.now() + LISTING_TIMEOUT_MS;
+  let current = owner;
+  while (Date.now() < cap) {
+    const published = readResult();
+    if (published && published.token === current.raw) {
+      if (published.key !== key) return { kind: "retry" };
+      if (!published.ok) throwPublished(published);
+      return { kind: "value", value: published.value };
+    }
+    const latest = readLockOwner();
+    if (!latest) {
+      const again = readResult();
+      if (again && again.token === current.raw && again.key === key) {
+        if (!again.ok) throwPublished(again);
+        return { kind: "value", value: again.value };
       }
-    });
-    child.on("error", (err) => {
-      if (!killing) settle(err);
-    });
-    child.on("close", (code) => {
-      if (killing) return;
-      settle(code === 0 ? null : new Error(`\`${command}\` exited with ${code}`));
-    });
+      return { kind: "retry" };
+    }
+    if (latest.raw !== current.raw) current = latest;
+    if (lockIsAbandoned(latest)) {
+      clearLock(latest.raw);
+      return { kind: "retry" };
+    }
+    await sleep(25);
+  }
+  throw Object.assign(new Error("listener scan lock was held past the wait"), {
+    killed: true
   });
 }
+async function withListenerLock(key, body) {
+  const token = `${process.pid}-${Date.now()}-${Math.random()}`;
+  const deadline = Date.now() + LISTENER_LOCK_WAIT_MS;
+  for (; ; ) {
+    let fd = null;
+    try {
+      fd = (0, import_node_fs2.openSync)(LISTENER_LOCK_PATH, "wx");
+    } catch (error) {
+      const code = error instanceof Error && "code" in error ? error.code : "";
+      if (code !== "EEXIST") throw error;
+      const owner = readLockOwner();
+      if (!owner || lockIsAbandoned(owner)) {
+        if (owner) clearLock(owner.raw);
+        else {
+          try {
+            (0, import_node_fs2.unlinkSync)(LISTENER_LOCK_PATH);
+          } catch {
+          }
+        }
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        const shared = await waitForSharedResult(owner, key);
+        if (shared.kind === "value") return shared.value;
+        continue;
+      }
+      await sleep(25);
+      continue;
+    }
+    if (fd === null) continue;
+    try {
+      (0, import_node_fs2.writeSync)(fd, token);
+      try {
+        const value = await body();
+        publishResult({ token, key, ok: true, value });
+        return value;
+      } catch (error) {
+        publishResult({
+          token,
+          key,
+          ok: false,
+          message: error instanceof Error ? error.message : String(error),
+          killed: !!(error && typeof error === "object" && error.killed)
+        });
+        throw error;
+      }
+    } finally {
+      try {
+        (0, import_node_fs2.closeSync)(fd);
+      } catch {
+      }
+      clearLock(token);
+    }
+  }
+}
+function spawnReaped(file, args, timeoutMs, maxBuffer = 1024 * 1024) {
+  return withListenerLock(
+    `${file}\0${args.join("\0")}`,
+    () => new Promise((resolvePromise, reject) => {
+      const child = (0, import_child_process.spawn)(file, args, {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let settled = false;
+      let timedOut = false;
+      let overflow = false;
+      let spawnError = null;
+      const timeoutError = () => Object.assign(new Error(`\`${file}\` did not exit within ${timeoutMs}ms`), {
+        killed: true
+      });
+      const finish = (err, code) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(deadline);
+        clearTimeout(backup);
+        if (err) reject(err);
+        else resolvePromise({ stdout, code });
+      };
+      const killChild = () => {
+        if (child.exitCode !== null || child.signalCode !== null) return;
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      };
+      let backup;
+      const deadline = setTimeout(() => {
+        timedOut = true;
+        killChild();
+        backup = setTimeout(() => finish(timeoutError(), null), 1e3);
+      }, timeoutMs);
+      child.stdout?.setEncoding("utf8");
+      child.stderr?.on("data", () => {
+      });
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk;
+        if (stdout.length > maxBuffer) {
+          overflow = true;
+          killChild();
+        }
+      });
+      child.on("error", (err) => {
+        spawnError = err;
+        killChild();
+      });
+      child.on("close", (code) => {
+        if (timedOut) finish(timeoutError(), code);
+        else if (overflow)
+          finish(new Error(`\`${file}\` exceeded maxBuffer ${maxBuffer}`), code);
+        else if (spawnError && !stdout) finish(spawnError, code);
+        else finish(null, code);
+      });
+    })
+  );
+}
 var TIMEOUT_MS = 250;
 var MANIFEST_TIMEOUT_MS = 1500;
 var TCP_GATE_MS = 120;
@@ -1155,57 +1163,145 @@ async function scanListeningProcesses(excludePorts = []) {
     processes: listing.processes.filter((p) => acceptPort(p.port, excluded))
   };
 }
+var LISTENER_CACHE_MS = 2e3;
+var listenerCache = null;
 var inflightListing = null;
+var listenerHolds = 0;
+function pinSharedListenerScan() {
+  listenerHolds += 1;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    listenerHolds -= 1;
+    if (listenerHolds === 0) listenerCache = null;
+  };
+}
+function cachedPidsAlive(scan) {
+  if (scan.state !== "looked") return true;
+  return scan.processes.every((entry) => entry.pid <= 0 || pidIsAlive(entry.pid));
+}
+async function cachedPortsStillHeld(scan) {
+  if (scan.state !== "looked") return true;
+  const owned = scan.processes.filter((entry) => entry.pid > 0);
+  if (owned.length === 0) return true;
+  const pids = [...new Set(owned.map((entry) => entry.pid))];
+  try {
+    const { stdout, code } = await spawnReaped(
+      "lsof",
+      ["-nP", "-b", "-w", "-a", "-p", pids.join(","), "-iTCP", "-sTCP:LISTEN", "-Fpcn"],
+      8e3,
+      16 * 1024 * 1024
+    );
+    if (code !== 0 && code !== 1) return false;
+    const live = new Set(
+      parseLsofListeners(stdout).map((entry) => `${entry.port}:${entry.pid}`)
+    );
+    return owned.every((entry) => live.has(`${entry.port}:${entry.pid}`));
+  } catch {
+    return false;
+  }
+}
 function listListenersShared() {
-  inflightListing ??= listListeners().finally(() => {
+  inflightListing ??= loadListeners().finally(() => {
     inflightListing = null;
   });
   return inflightListing;
 }
+async function loadListeners() {
+  const cached2 = listenerCache;
+  if (cached2 && (listenerHolds > 0 || Date.now() - cached2.at < LISTENER_CACHE_MS) && cachedPidsAlive(cached2.scan) && await cachedPortsStillHeld(cached2.scan)) {
+    return cached2.scan;
+  }
+  listenerCache = null;
+  const scan = await listListeners();
+  listenerCache = { at: Date.now(), scan };
+  return scan;
+}
+function isSpawnMissing(err) {
+  return !!(err && typeof err === "object" && err.code === "ENOENT");
+}
+function parseLsofListeners(stdout) {
+  const seen = /* @__PURE__ */ new Map();
+  let pid = 0;
+  let command = "";
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("p")) {
+      pid = Number(line.slice(1));
+      command = "";
+      continue;
+    }
+    if (line.startsWith("c")) {
+      command = line.slice(1);
+      continue;
+    }
+    if (!line.startsWith("n") || pid <= 0) continue;
+    if (!/^(node|bun|peach|vite)/.test(command)) continue;
+    const match = line.match(/:(\d+)$/);
+    if (!match) continue;
+    const port = Number(match[1]);
+    if (!seen.has(port)) seen.set(port, pid);
+  }
+  return [...seen.entries()].map(([port, owner]) => ({ port, pid: owner }));
+}
+function parseSsListeners(stdout) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const line of stdout.split("\n")) {
+    if (!/"(node|bun|peach|vite)/.test(line)) continue;
+    const portMatch = line.match(/:(\d+)\s/);
+    const pidMatch = line.match(/pid=(\d+)/);
+    if (!portMatch) continue;
+    const port = Number(portMatch[1]);
+    const pid = pidMatch ? Number(pidMatch[1]) : 0;
+    if (!seen.has(port)) seen.set(port, pid);
+  }
+  return [...seen.entries()].map(([port, pid]) => ({ port, pid }));
+}
 async function listListeners() {
   let timedOut = false;
   try {
-    const { stdout } = await execGuarded(
-      `lsof -a -c node -c bun -c peach -iTCP -sTCP:LISTEN -P -n 2>/dev/null | grep -E '^(node|bun|peach)'`,
-      LISTING_TIMEOUT_MS
+    const { stdout, code } = await spawnReaped(
+      "lsof",
+      [
+        "-nP",
+        "-a",
+        "-c",
+        "node",
+        "-c",
+        "bun",
+        "-c",
+        "peach",
+        "-c",
+        "vite",
+        "-iTCP",
+        "-sTCP:LISTEN",
+        "-Fpcn"
+      ],
+      LISTING_TIMEOUT_MS,
+      16 * 1024 * 1024
     );
-    const seen = /* @__PURE__ */ new Map();
-    for (const line of stdout.trim() ? stdout.trim().split("\n") : []) {
-      const parts = line.trim().split(/\s+/);
-      if (parts.length < 9) continue;
-      const pid = Number(parts[1]);
-      const m = parts[8].match(/:(\d+)$/);
-      if (!m) continue;
-      const port = Number(m[1]);
-      if (!seen.has(port)) seen.set(port, pid);
+    if (code === 0 || code === 1) {
+      return { state: "looked", processes: parseLsofListeners(stdout) };
     }
-    return {
-      state: "looked",
-      processes: [...seen.entries()].map(([port, pid]) => ({ port, pid }))
-    };
   } catch (err) {
     if (wasKilledByTimeout(err)) timedOut = true;
+    else if (!isSpawnMissing(err)) return { state: "could-not-look" };
   }
-  try {
-    const { stdout } = await execGuarded(
-      `ss -tlnp 2>/dev/null | grep -E '"(node|bun|peach)"'`,
-      LISTING_TIMEOUT_MS
-    );
-    const seen = /* @__PURE__ */ new Map();
-    for (const line of stdout.trim() ? stdout.trim().split("\n") : []) {
-      const portMatch = line.match(/:(\d+)\s/);
-      const pidMatch = line.match(/pid=(\d+)/);
-      if (!portMatch) continue;
-      const port = Number(portMatch[1]);
-      const pid = pidMatch ? Number(pidMatch[1]) : 0;
-      if (!seen.has(port)) seen.set(port, pid);
+  if (!timedOut) {
+    try {
+      const { stdout, code } = await spawnReaped(
+        "ss",
+        ["-H", "-ltnp"],
+        LISTING_TIMEOUT_MS,
+        16 * 1024 * 1024
+      );
+      if (code === 0 || code === 1) {
+        return { state: "looked", processes: parseSsListeners(stdout) };
+      }
+    } catch (err) {
+      if (wasKilledByTimeout(err)) timedOut = true;
+      else if (!isSpawnMissing(err)) return { state: "could-not-look" };
     }
-    return {
-      state: "looked",
-      processes: [...seen.entries()].map(([port, pid]) => ({ port, pid }))
-    };
-  } catch (err) {
-    if (wasKilledByTimeout(err)) timedOut = true;
   }
   if (timedOut) return { state: "could-not-look" };
   return { state: "looked", processes: FALLBACK_PORTS };
@@ -1216,61 +1312,86 @@ async function discoverListeningPorts(excludePorts = []) {
 }
 async function resolveListeningPid(port) {
   if (!Number.isInteger(port) || port <= 0) return null;
-  if (process.platform === "darwin") {
-    try {
-      const { stdout } = await execGuarded(
-        `lsof -nP -a -iTCP:${port} -sTCP:LISTEN -t 2>/dev/null`,
-        8e3
-      );
-      const pids = [...new Set(stdout.trim().split(/\s+/).map(Number))];
-      return pids.length === 1 && Number.isInteger(pids[0]) && pids[0] > 0 ? pids[0] : null;
-    } catch {
-      return null;
-    }
-  }
-  try {
-    const { stdout } = await execGuarded(`ss -tlnp 2>/dev/null`, 8e3, {
-      maxBuffer: 16 * 1024 * 1024
-    });
-    for (const line of stdout.split("\n")) {
-      if (!new RegExp(`:${port}\\s`).test(line)) continue;
-      const pid = Number(line.match(/pid=(\d+)/)?.[1]);
-      if (pid > 0) return pid;
-    }
-  } catch {
-  }
-  return null;
+  const scan = await listListenersShared();
+  if (scan.state !== "looked") return null;
+  const pids = [
+    ...new Set(
+      scan.processes.filter((entry) => entry.port === port && entry.pid > 0).map((entry) => entry.pid)
+    )
+  ];
+  return pids.length === 1 && pids[0] !== void 0 ? pids[0] : null;
 }
 var cwdByPid = /* @__PURE__ */ new Map();
-async function resolveProcessCwd(pid) {
-  if (pid <= 0) return null;
-  const cached2 = cwdByPid.get(pid);
-  if (cached2) return cached2;
-  try {
-    const cwd = await (0, import_promises2.readlink)(`/proc/${pid}/cwd`);
-    if (cwd) {
-      cwdByPid.set(pid, cwd);
-      return cwd;
-    }
-  } catch {
-  }
-  try {
-    const { stdout } = await execGuarded(
-      `lsof -b -w -p ${pid} -a -d cwd -Fn 2>/dev/null`,
-      8e3
+var cwdQueue = [];
+var cwdFlushing = false;
+function kickCwdFlush() {
+  if (cwdFlushing || cwdQueue.length === 0) return;
+  cwdFlushing = true;
+  void flushCwdQueue().finally(() => {
+    cwdFlushing = false;
+    kickCwdFlush();
+  });
+}
+async function flushCwdQueue() {
+  await Promise.resolve();
+  while (cwdQueue.length > 0) {
+    const batch = cwdQueue.splice(0, cwdQueue.length);
+    const pending = [...new Set(batch.map((waiter) => waiter.pid))].filter(
+      (pid) => !cwdByPid.has(pid)
     );
-    for (const line of stdout.split("\n")) {
-      if (line.startsWith("n") && line.length > 1) {
-        const cwd = line.slice(1).trim();
+    const needLsof = [];
+    for (const pid of pending) {
+      try {
+        const cwd = await (0, import_promises2.readlink)(`/proc/${pid}/cwd`);
         if (cwd) {
           cwdByPid.set(pid, cwd);
-          return cwd;
+          continue;
         }
+      } catch {
       }
+      needLsof.push(pid);
     }
-  } catch {
+    if (needLsof.length > 0) {
+      let looked = false;
+      try {
+        const { stdout, code } = await spawnReaped(
+          "lsof",
+          ["-b", "-w", "-nP", "-a", "-d", "cwd", "-p", needLsof.join(","), "-Fn"],
+          8e3,
+          4 * 1024 * 1024
+        );
+        if (code === 0 || code === 1) {
+          looked = true;
+          let current = 0;
+          for (const line of stdout.split("\n")) {
+            if (line.startsWith("p")) {
+              current = Number(line.slice(1));
+              continue;
+            }
+            if (!line.startsWith("n") || line.length <= 1 || !needLsof.includes(current))
+              continue;
+            const cwd = line.slice(1).trim();
+            if (cwd) cwdByPid.set(current, cwd);
+          }
+        }
+      } catch {
+      }
+      if (looked) {
+        for (const pid of needLsof) {
+          if (!cwdByPid.has(pid)) cwdByPid.set(pid, null);
+        }
+      }
+    }
+    for (const waiter of batch) waiter.resolve(cwdByPid.get(waiter.pid) ?? null);
   }
-  return null;
+}
+function resolveProcessCwd(pid) {
+  if (pid <= 0) return Promise.resolve(null);
+  if (cwdByPid.has(pid)) return Promise.resolve(cwdByPid.get(pid) ?? null);
+  return new Promise((resolveCwd) => {
+    cwdQueue.push({ pid, resolve: resolveCwd });
+    kickCwdFlush();
+  });
 }
 function makeResult(hostname, port, framework, owner) {
   return {
@@ -1678,6 +1799,8 @@ function __resetScannerCache() {
   enrichmentCache.clear();
   enrichmentInFlight.clear();
   portCacheInvalidatedAt.clear();
+  listenerCache = null;
+  cwdByPid.clear();
   __resetAppSettingsBundleCacheForTests();
 }
 async function attachAppSettingsBundle(result, projectRoot) {
@@ -1696,6 +1819,7 @@ async function scanDevServers(opts = {}) {
   const scan = await scanListeningProcesses(opts.excludePorts);
   if (scan.state === "could-not-look") throw new DevServerScanUnavailableError();
   const processes = scan.processes;
+  await Promise.all(processes.map((entry) => resolveProcessCwd(entry.pid)));
   const currentPorts = new Set(processes.map((p) => p.port));
   for (const p of [...portCache.keys()]) {
     if (!currentPorts.has(p)) portCache.delete(p);
@@ -1785,6 +1909,7 @@ async function scanDevServers(opts = {}) {
   __shouldReuseScannerCacheEntry,
   discoverListeningPorts,
   discoverListeningProcesses,
+  pinSharedListenerScan,
   probePort,
   resolveListeningPid,
   resolveProcessCwd,