syntaur 0.17.0 → 0.17.1

package/dist/dashboard/server.js

@@ -4270,13 +4270,16 @@ __export(scanner_exports, {
   autoLinkPane: () => autoLinkPane,
   checkTmuxAvailable: () => checkTmuxAvailable,
   clearScanCache: () => clearScanCache,
+  descendantPidsFromSnapshot: () => descendantPidsFromSnapshot,
   execQuiet: () => execQuiet,
   findListeningPorts: () => findListeningPorts,
   getDescendantPids: () => getDescendantPids,
   getGitInfo: () => getGitInfo,
   getLsofOutput: () => getLsofOutput,
+  getProcessSnapshot: () => getProcessSnapshot,
   listTmuxPanes: () => listTmuxPanes,
   loadWorkspaceRecords: () => loadWorkspaceRecords,
+  parseProcessSnapshot: () => parseProcessSnapshot,
   parseTmuxPaneOutput: () => parseTmuxPaneOutput,
   resolveAndNormalize: () => resolveAndNormalize,
   scanAllSessions: () => scanAllSessions,
@@ -4289,6 +4292,23 @@ import { resolve as resolve12 } from "path";
 import { realpath, readdir as readdir7, readFile as readFile9 } from "fs/promises";
 function clearScanCache() {
   cache = null;
+  forceFreshNext = true;
+  scanEpoch++;
+  inFlight = null;
+}
+function emptyScan() {
+  return { sessions: [], tmuxAvailable: false };
+}
+function scanKey(serversDir2, projectsDir, assignmentsDir2) {
+  return `${serversDir2}\0${projectsDir}\0${assignmentsDir2 ?? ""}`;
+}
+function delay(ms) {
+  return new Promise((resolve29) => {
+    const timer2 = setTimeout(resolve29, ms);
+    if (typeof timer2.unref === "function") {
+      timer2.unref();
+    }
+  });
 }
 function parseTmuxPaneOutput(output) {
   return output.trim().split("\n").filter((line) => line.length > 0).map((line) => {
@@ -4322,7 +4342,10 @@ function findListeningPorts(lsofOutput, pids) {
 }
 async function execQuiet(cmd, args) {
   try {
-    const { stdout } = await exec(cmd, args);
+    const { stdout } = await exec(cmd, args, {
+      timeout: PROBE_TIMEOUT_MS,
+      maxBuffer: PROBE_MAX_BUFFER
+    });
     return stdout.trim();
   } catch {
     return "";
@@ -4370,6 +4393,40 @@ async function getDescendantPids(rootPid, maxDepth = 4) {
   }
   return all;
 }
+function parseProcessSnapshot(psOutput) {
+  const childrenOf = /* @__PURE__ */ new Map();
+  for (const line of psOutput.split("\n")) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 2) continue;
+    const pid = parseInt(parts[0], 10);
+    const ppid = parseInt(parts[1], 10);
+    if (isNaN(pid) || isNaN(ppid)) continue;
+    const siblings = childrenOf.get(ppid);
+    if (siblings) siblings.push(pid);
+    else childrenOf.set(ppid, [pid]);
+  }
+  return { childrenOf };
+}
+async function getProcessSnapshot() {
+  return parseProcessSnapshot(await execQuiet("ps", ["-axo", "pid=,ppid="]));
+}
+function descendantPidsFromSnapshot(rootPid, snapshot, maxDepth = 4) {
+  const all = /* @__PURE__ */ new Set([rootPid]);
+  let frontier = [rootPid];
+  for (let depth = 0; depth < maxDepth && frontier.length > 0; depth++) {
+    const nextFrontier = [];
+    for (const pid of frontier) {
+      for (const child of snapshot.childrenOf.get(pid) ?? []) {
+        if (!all.has(child)) {
+          all.add(child);
+          nextFrontier.push(child);
+        }
+      }
+    }
+    frontier = nextFrontier;
+  }
+  return all;
+}
 async function getLsofOutput() {
   return execQuiet("lsof", ["-i", "-P", "-n", "-sTCP:LISTEN"]);
 }
@@ -4475,7 +4532,7 @@ async function autoLinkPane(cwd, branch, records) {
   }
   return null;
 }
-async function scanSession(sessionData, lsofOutput, workspaceRecords) {
+async function scanSession(sessionData, lsofOutput, workspaceRecords, procSnapshot) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const alive = await sessionAlive(sessionData.session);
   if (!alive) {
@@ -4498,13 +4555,13 @@ async function scanSession(sessionData, lsofOutput, workspaceRecords) {
     windowMap.get(rp.windowIndex).panes.push(rp);
   }
   const cwdSet = new Set(rawPanes.map((p) => p.cwd));
-  const gitInfoCache = /* @__PURE__ */ new Map();
-  for (const cwd of cwdSet) {
-    gitInfoCache.set(cwd, await getGitInfo(cwd));
-  }
+  const gitInfoEntries = await Promise.all(
+    [...cwdSet].map(async (cwd) => [cwd, await getGitInfo(cwd)])
+  );
+  const gitInfoCache = new Map(gitInfoEntries);
   const pidToPaneKey = /* @__PURE__ */ new Map();
   for (const rp of rawPanes) {
-    const descendants = await getDescendantPids(rp.pid);
+    const descendants = descendantPidsFromSnapshot(rp.pid, procSnapshot);
     const key = `${rp.windowIndex}:${rp.paneIndex}`;
     for (const pid of descendants) {
       pidToPaneKey.set(pid, key);
@@ -4529,37 +4586,38 @@ async function scanSession(sessionData, lsofOutput, workspaceRecords) {
   }
   const windows = [];
   for (const [windowIndex, { name, panes: rawPanesInWindow }] of windowMap) {
-    const panes = [];
-    for (const rp of rawPanesInWindow) {
-      const key = `${rp.windowIndex}:${rp.paneIndex}`;
-      const gitInfo = gitInfoCache.get(rp.cwd) ?? { branch: null, worktree: false };
-      const ports = panePorts.get(key) ?? [];
-      const urls = ports.map((p) => `http://localhost:${p}`);
-      const override = sessionData.overrides[key];
-      let assignment = null;
-      if (override) {
-        const rec = workspaceRecords.find(
-          (r) => r.projectSlug === override.project && r.assignmentSlug === override.assignment
-        );
-        assignment = {
-          project: override.project,
-          slug: override.assignment,
-          title: rec?.assignmentTitle ?? override.assignment
+    const panes = await Promise.all(
+      rawPanesInWindow.map(async (rp) => {
+        const key = `${rp.windowIndex}:${rp.paneIndex}`;
+        const gitInfo = gitInfoCache.get(rp.cwd) ?? { branch: null, worktree: false };
+        const ports = panePorts.get(key) ?? [];
+        const urls = ports.map((p) => `http://localhost:${p}`);
+        const override = sessionData.overrides[key];
+        let assignment = null;
+        if (override) {
+          const rec = workspaceRecords.find(
+            (r) => r.projectSlug === override.project && r.assignmentSlug === override.assignment
+          );
+          assignment = {
+            project: override.project,
+            slug: override.assignment,
+            title: rec?.assignmentTitle ?? override.assignment
+          };
+        } else {
+          assignment = await autoLinkPane(rp.cwd, gitInfo.branch, workspaceRecords);
+        }
+        return {
+          index: rp.paneIndex,
+          command: rp.command,
+          cwd: rp.cwd,
+          branch: gitInfo.branch,
+          worktree: gitInfo.worktree,
+          ports,
+          urls,
+          assignment
         };
-      } else {
-        assignment = await autoLinkPane(rp.cwd, gitInfo.branch, workspaceRecords);
-      }
-      panes.push({
-        index: rp.paneIndex,
-        command: rp.command,
-        cwd: rp.cwd,
-        branch: gitInfo.branch,
-        worktree: gitInfo.worktree,
-        ports,
-        urls,
-        assignment
-      });
-    }
+      })
+    );
     windows.push({ index: windowIndex, name, panes });
   }
   windows.sort((a, b) => a.index - b.index);
@@ -4631,39 +4689,92 @@ async function scanProcessSession(sessionData, lsofOutput, workspaceRecords) {
     windows: [{ index: 0, name: "process", panes: [pane] }]
   };
 }
+async function performScan(serversDir2, projectsDir, options) {
+  const epoch = scanEpoch;
+  const [tmuxAvailable, names, lsofOutput, workspaceRecords, procSnapshot] = await Promise.all([
+    checkTmuxAvailable(),
+    listSessionFiles(serversDir2),
+    getLsofOutput(),
+    loadWorkspaceRecords(projectsDir, options?.assignmentsDir),
+    getProcessSnapshot()
+  ]);
+  const datas = await Promise.all(names.map((name) => readSessionFile(serversDir2, name)));
+  const scanned = await Promise.all(
+    datas.map(async (data) => {
+      if (!data) return null;
+      if (data.kind === "process") {
+        return scanProcessSession(data, lsofOutput, workspaceRecords);
+      }
+      if (tmuxAvailable) {
+        return scanSession(data, lsofOutput, workspaceRecords, procSnapshot);
+      }
+      return null;
+    })
+  );
+  const result = {
+    sessions: scanned.filter((s) => s !== null),
+    tmuxAvailable
+  };
+  if (epoch === scanEpoch) {
+    cache = { data: result, expiry: Date.now() + CACHE_TTL_MS };
+    lastKnown = result;
+    forceFreshNext = false;
+  }
+  return result;
+}
+function refreshInBackground(serversDir2, projectsDir, options) {
+  if (!inFlight) {
+    const p = performScan(serversDir2, projectsDir, options);
+    p.finally(() => {
+      if (inFlight === p) inFlight = null;
+    }).catch(() => {
+    });
+    inFlight = p;
+  }
+  return inFlight;
+}
 async function scanAllSessions(serversDir2, projectsDir, options) {
+  const key = scanKey(serversDir2, projectsDir, options?.assignmentsDir);
+  if (key !== cacheKey) {
+    cache = null;
+    lastKnown = null;
+    inFlight = null;
+    forceFreshNext = false;
+    scanEpoch++;
+    cacheKey = key;
+  }
   if (!options?.bypassCache && cache && Date.now() < cache.expiry) {
     return cache.data;
   }
-  const tmuxAvailable = await checkTmuxAvailable();
-  const names = await listSessionFiles(serversDir2);
-  const lsofOutput = await getLsofOutput();
-  const workspaceRecords = await loadWorkspaceRecords(projectsDir, options?.assignmentsDir);
-  const sessions = [];
-  for (const name of names) {
-    const data = await readSessionFile(serversDir2, name);
-    if (!data) continue;
-    if (data.kind === "process") {
-      sessions.push(await scanProcessSession(data, lsofOutput, workspaceRecords));
-    } else if (tmuxAvailable) {
-      sessions.push(await scanSession(data, lsofOutput, workspaceRecords));
-    }
+  const refresh = refreshInBackground(serversDir2, projectsDir, options);
+  const canServeStale = lastKnown !== null && !options?.bypassCache && !forceFreshNext;
+  if (canServeStale) {
+    void refresh.catch(() => {
+    });
+    return lastKnown;
   }
-  const result = { sessions, tmuxAvailable };
-  cache = { data: result, expiry: Date.now() + CACHE_TTL_MS };
-  return result;
+  if (options?.nonBlocking) {
+    return Promise.race([
+      refresh.catch(() => emptyScan()),
+      delay(COLD_WAIT_BUDGET_MS).then(() => emptyScan())
+    ]);
+  }
+  return refresh;
 }
 async function scanSingleSession(serversDir2, projectsDir, name, options) {
   const data = await readSessionFile(serversDir2, name);
   if (!data) return null;
-  const lsofOutput = await getLsofOutput();
-  const workspaceRecords = await loadWorkspaceRecords(projectsDir, options?.assignmentsDir);
+  const [lsofOutput, workspaceRecords, procSnapshot] = await Promise.all([
+    getLsofOutput(),
+    loadWorkspaceRecords(projectsDir, options?.assignmentsDir),
+    getProcessSnapshot()
+  ]);
   if (data.kind === "process") {
     return scanProcessSession(data, lsofOutput, workspaceRecords);
   }
-  return scanSession(data, lsofOutput, workspaceRecords);
+  return scanSession(data, lsofOutput, workspaceRecords, procSnapshot);
 }
-var exec, cache, CACHE_TTL_MS;
+var exec, cache, lastKnown, inFlight, forceFreshNext, scanEpoch, cacheKey, CACHE_TTL_MS, COLD_WAIT_BUDGET_MS, PROBE_TIMEOUT_MS, PROBE_MAX_BUFFER;
 var init_scanner = __esm({
   "src/dashboard/scanner.ts"() {
     "use strict";
@@ -4672,7 +4783,15 @@ var init_scanner = __esm({
     init_parser();
     exec = promisify(execFile);
     cache = null;
+    lastKnown = null;
+    inFlight = null;
+    forceFreshNext = false;
+    scanEpoch = 0;
+    cacheKey = null;
     CACHE_TTL_MS = 1e4;
+    COLD_WAIT_BUDGET_MS = 2500;
+    PROBE_TIMEOUT_MS = 15e3;
+    PROBE_MAX_BUFFER = 32 * 1024 * 1024;
   }
 });
 
@@ -4927,7 +5046,12 @@ async function getOverview(projectsDir, serversDir2, assignmentsDir2, options =
       const servers = await timed(
         traces,
         "scan-tmux-sessions",
-        () => scanAllSessions2(serversDir2, projectsDir, { assignmentsDir: assignmentsDir2 })
+        () => (
+          // Overview only needs aggregate counts — never block its render on a
+          // live scan; serve last-known stats and let the scan refresh in the
+          // background (stale-while-revalidate).
+          scanAllSessions2(serversDir2, projectsDir, { assignmentsDir: assignmentsDir2, nonBlocking: true })
+        )
       );
       if (servers.tmuxAvailable) {
         const alive = servers.sessions.filter((s) => s.alive).length;