sootsim 0.1.302 → 0.1.304

package/scripts/dev-server-scanner.ts

@@ -14,6 +14,7 @@
 // pid changes. before any HTTP, a TCP connect gate skips unreachable ports.
 
 import { exec } from 'child_process'
+import { readlink } from 'fs/promises'
 import http from 'http'
 import net from 'net'
 import { promisify } from 'util'
@@ -222,27 +223,112 @@ export async function discoverListeningPorts(
   return processes.map((p) => p.port)
 }
 
-// per-pid cwd cache. lsof is fairly cheap but we call it per discovered
-// server per scan (every 5s in the tray), so caching the result until the
-// pid goes away avoids redundant forks.
+/** parse `netstat -anv -p tcp` output for the pid listening on one port.
+ *
+ *  macOS lays a LISTEN row out as
+ *    tcp4 0 0 127.0.0.1.8090 *.* LISTEN 0 0 131072 131072 node:97330 ...
+ *  so the local address is the 4th column with a DOT before the port (which is
+ *  what keeps port 8137 from matching a row for 18137), and the owner is the
+ *  only token shaped "<name>:<pid>".
+ *
+ *  exported because this column layout is the fragile part and a child process
+ *  cannot exercise it under bun's test runner, which hands back empty stdout. */
+export function pidFromNetstat(stdout: string, port: number): number | null {
+  for (const line of stdout.split('\n')) {
+    if (!line.includes('LISTEN')) continue
+    const parts = line.trim().split(/\s+/)
+    if (!parts[3]?.endsWith(`.${port}`)) continue
+    for (const token of parts) {
+      const owner = token.match(/^\S+:(\d+)$/)
+      if (owner) {
+        const pid = Number(owner[1])
+        if (pid > 0) return pid
+      }
+    }
+  }
+  return null
+}
+
+/** resolve the pid of the process listening on one local port.
+ *
+ *  `lsof` walks every descriptor of every process, which measures 2-4s on a
+ *  loaded machine — longer than any timeout worth giving it, so
+ *  `discoverListeningProcesses` above degrades to its pid-less port list
+ *  exactly when the machine is busy. netstat (macOS/BSD) and ss (linux) read
+ *  the kernel socket table instead and answer in well under a second, and both
+ *  carry the owning pid. use this whenever the question is "who owns this one
+ *  port"; `discoverListeningProcesses` answers the different question of what
+ *  is listening at all. */
+export async function resolveListeningPid(port: number): Promise<number | null> {
+  if (!Number.isInteger(port) || port <= 0) return null
+
+  // macOS netstat: "tcp4 0 0 127.0.0.1.8090 *.* LISTEN ... node:97330 ..."
+  // the local address uses a dot before the port, and the owner column is the
+  // only token shaped "<name>:<pid>".
+  try {
+    const { stdout } = await execP('netstat -anv -p tcp 2>/dev/null', {
+      encoding: 'utf8',
+      timeout: 8000,
+      maxBuffer: 16 * 1024 * 1024,
+    })
+    const pid = pidFromNetstat(stdout, port)
+    if (pid !== null) return pid
+  } catch {}
+
+  // linux ss: 'LISTEN 0 511 0.0.0.0:8081 0.0.0.0:* users:(("node",pid=1234,fd=5))'
+  try {
+    const { stdout } = await execP(`ss -tlnp 2>/dev/null`, {
+      encoding: 'utf8',
+      timeout: 8000,
+      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
+}
+
+// per-pid cwd cache. lsof is the only way to read another process's cwd on
+// macOS and it is NOT cheap — measured at 3-8s for a single pid on a machine
+// running a few dozen node processes — so caching the result until the pid
+// goes away is what keeps the 5s tray scan viable.
 const cwdByPid = new Map<number, string>()
 
-/** resolve the current working directory of a pid using `lsof -d cwd`.
- *  macOS + linux both accept this. returns null for pid 0 (unknown owner)
- *  and whenever lsof is unavailable or the fd isn't present.
- *  async — sync exec blocked CrBrowserMain at ~600ms on macOS. */
+/** resolve the current working directory of a pid. returns null for pid 0
+ *  (unknown owner) and whenever neither mechanism below can see the process.
+ *  async — sync exec blocked CrBrowserMain at ~600ms on macOS.
+ *
+ *  `-b -w` skips the blocking stat calls lsof otherwise makes against every
+ *  mount, which roughly halves it. the timeout is generous because the answer
+ *  is cached per pid: too tight a limit silently returns null on exactly the
+ *  busy machines where auto-attaching a project matters most. */
 export async function resolveProcessCwd(pid: number): Promise<string | null> {
   if (pid <= 0) return null
   const cached = cwdByPid.get(pid)
   if (cached) return cached
+
+  // linux publishes the cwd as a symlink, which costs one readlink and no
+  // subprocess at all. macOS has no /proc and has to pay for lsof below.
+  try {
+    const cwd = await readlink(`/proc/${pid}/cwd`)
+    if (cwd) {
+      cwdByPid.set(pid, cwd)
+      return cwd
+    }
+  } catch {}
+
   try {
     // -Fn → machine-readable, one field per line. lines look like:
     //   p<pid>
     //   fcwd
     //   n<absolute path>
-    const { stdout } = await execP(`lsof -p ${pid} -a -d cwd -Fn 2>/dev/null`, {
+    const { stdout } = await execP(`lsof -b -w -p ${pid} -a -d cwd -Fn 2>/dev/null`, {
       encoding: 'utf8',
-      timeout: 1500,
+      timeout: 8000,
     })
     for (const line of stdout.split('\n')) {
       if (line.startsWith('n') && line.length > 1) {

package/skills/sootsim-debug/SKILL.md

@@ -63,6 +63,12 @@ regression test. a pile of ad-hoc logs helps no one and gets deleted.
   query against it.
 - **pin a sim once.** if more than one is live, an unpinned command
   refuses to choose. run `sootsim use <id>` at the start of the workflow.
+- **keep one sim and reuse its browser tab.** before `sootsim open`, run
+  `sootsim list --all`. if the target is already connected, pin it and use
+  `sootsim do reload`; do not open another tab to reload or retry a capture.
+  re-run `list --all` after each reload or reconnect; when another entry appears,
+  run `sootsim close --others` against the pinned sim immediately.
+  if the current sim must be replaced, close it before opening the replacement.
 - **`debug eval` is an escape hatch.** if a top-level command feels
   broken or missing, file an issue — every agent after you benefits from
   a better CLI, not a pile of ad-hoc scripts.

package/skills/sootsim-setup/SKILL.md

@@ -23,6 +23,44 @@ debugging or `/sootsim-test` for writing tests.
 - **an empty `sootsim list` is not "broken sootsim"** — it usually means the
   daemon is down, the dev server port is wrong, or the runtime is missing.
   walk the recovery checklist before reinstalling.
+- **one sim for your whole session. switch APPS by navigating that sim, never by
+  opening another.** `sootsim open <port> --sim <id>` resolves that exact sim and
+  navigates it in place — no new tab, no new browser tree. that is the supported
+  way to move between apps and ports:
+
+  ```sh
+  sootsim open 8086 --sim <id>     # one app, in your sim
+  sootsim open 8090 --sim <id>     # a different app, same tab
+  sootsim reload --sim <id>        # reload whatever it is showing
+  sootsim close <id>               # dispose it when you are done
+  ```
+
+  every `--new` spawns another browser tree, and each abandoned tab holds a
+  renderer process for the life of the browser. these land in somebody's actual
+  desktop Chrome. a run that opened one per app left 14 renderers against 2 live
+  sims on a shared machine and the owner noticed before we did.
+- **sharing a machine with other agents? open ONE sim with `--new`, pin it, and
+  pass `--sim <id>` from then on.** that single `--new` is the only one you get.
+  an unpinned command has no sim of its own, so it falls back to whatever sim is
+  currently PRIMARY — and that can be another agent's live sim, mid-run. a plain
+  `sootsim open <port>` from an unpinned CLI will happily retarget somebody
+  else's sim to your port and take over their session; the warning it prints is
+  easy to miss in a transcript. the current-sim pin is stored per CLI identity
+  (`sootsim-current-sim-<identity>.json`, keyed by your process-tree root), so
+  pinning is genuinely per-agent and does not fight anyone else:
+
+  ```sh
+  sootsim open --new 8086          # your own sim; also records it as yours
+  sootsim list                     # read back its id
+  sootsim use <id>                 # pin it explicitly
+  sootsim describe --sim <id>      # name it on every command after that
+  ```
+
+  `--new`, `--profile`, and `--ephemeral` are rejected outright when combined
+  with `--sim`, so if a command needs one of them you are starting a second sim
+  whether you meant to or not. if yours died, run `sootsim list --all` and adopt
+  an open unlocked sim with `sootsim use <id>` before you consider opening one.
+  always close yours when you finish.
 - **never retry-loop `sootsim open` against a wedged or slow stack.** a
   connect-timeout ("timed out waiting for opened sim to connect") means STOP and
   diagnose — not retry. each retried open spawns a new browser tree (a

package/src/attached-projects.ts

@@ -10,7 +10,7 @@
 import { randomBytes, createHash } from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
-import { electronUserDataDir } from './home-paths'
+import { electronUserDataDir } from './home-paths.ts'
 
 // plan → attached-projects-and-agents.md §data model
 export interface AttachedProject {
@@ -510,7 +510,7 @@ export async function seedFromDemoAppRegistry(): Promise<void> {
   // optional internal-only registry — resolves to [] on a published install
   // (the registry is not shipped), so this seed is a no-op for real users and
   // never pins their ports to internal demo apps.
-  const { loadOptionalDemoApps } = await import('../scripts/optional-demo-registry')
+  const { loadOptionalDemoApps } = await import('../scripts/optional-demo-registry.ts')
   const apps = await loadOptionalDemoApps()
   if (apps.length === 0) return
   mutateStore((store) => {

package/src/host/bridge-host.ts

@@ -44,9 +44,9 @@ import {
   handleFetchProxyRequest,
   isAppApiRequestUrl,
   isFetchProxyRequestUrl,
-} from './fetch-proxy-handler'
+} from './fetch-proxy-handler.ts'
 import { openUrl as openUrlInBrowser, type OpenUrlOptions } from './open-url.ts'
-import { handleWebSocketProxyUpgrade } from './websocket-proxy'
+import { handleWebSocketProxyUpgrade } from './websocket-proxy.ts'
 
 const SOOTSIM_CROSS_ORIGIN_EMBEDDER_POLICY = 'require-corp'
 

package/src/runtime-assets.ts

@@ -6,7 +6,7 @@ import fs from 'fs'
 import path from 'path'
 import { fileURLToPath } from 'url'
 import { isValidRuntimeVersion } from '@contrast/runtime-delivery'
-import { readActiveRuntime, runtimeDir } from './home-paths'
+import { readActiveRuntime, runtimeDir } from './home-paths.ts'
 
 export const SOOTSIM_RUNTIME_MISSING_MESSAGE =
   '[sootsim] no engine runtime installed — run `sootsim setup`, or `sootsim runtime install`'

package/src/runtime-delivery.ts

@@ -19,7 +19,7 @@ import {
   runtimeDir,
   runtimesDir,
   writeActiveRuntime,
-} from './home-paths'
+} from './home-paths.ts'
 
 export const DEFAULT_RUNTIME_CDN_ORIGIN = 'https://contrast.dev'
 

package/src/vite-plugin.ts

@@ -661,7 +661,7 @@ export function reanimatedNativeSeamRedirect(): Plugin {
 // the reanimated plugin above stays separate because it has package-specific
 // edge cases (fabricUtils, validate-worklets-version). new migrations should
 // use the manifest path unless they need similar special handling.
-import { NATIVE_SEAM_MANIFEST } from './native-seam-manifest'
+import { NATIVE_SEAM_MANIFEST } from './native-seam-manifest.ts'
 export function manifestNativeSeamRedirect(): Plugin {
   // build a fast lookup: pkg → { basenames, target }
   const byPkg = new Map<

package/dist-cli/chunks/app-fonts-VPJDIM5M.js

@@ -1,4 +0,0 @@
-/*! sootsim v0.1.302 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
-import { createRequire as __sootsimCreateRequire } from 'node:module'
-var require = __sootsimCreateRequire(import.meta.url)
-import{d as p}from"./chunk-GRMK3BZY.js";import"./chunk-VEOPRCNX.js";import"./chunk-C36FJ7OB.js";import{existsSync as h,mkdirSync as d,readFileSync as y,writeFileSync as g}from"node:fs";import{join as m}from"node:path";import{gzipSync as w}from"node:zlib";function f(t,e){let o=t.indexOf(`--${e}`);if(o!==-1&&o+1<t.length)return t[o+1];let i=t.find(r=>r.startsWith(`--${e}=`));return i?i.slice(e.length+3):void 0}async function S(t){let e=f(t,"wire")||"",o=f(t,"out-dir"),i=f(t,"manifest");if((!o||!i)&&(console.error("  usage: sootsim app-fonts stage --wire <wire> --out-dir <dir> --manifest <path>"),process.exit(1)),!e.trim()){console.log("no app fonts declared \u2014 nothing to stage");return}d(o,{recursive:!0});let r=await p(e,{onStaged:({url:n,byteLength:s})=>console.log(`  staged app font: ${n} (${(s/1024).toFixed(1)} KiB)`),onError:(n,s)=>console.error(`  warning: failed to fetch app font ${n}: ${s instanceof Error?s.message:s}`)}),a=[];for(let n of r){let s=w(n.bytes);g(m(o,n.urlhash),s),a.push({url:n.url,urlhash:n.urlhash,contentType:n.contentType,encoding:"gzip",sizeBytes:s.length,rawBytes:n.bytes.byteLength})}let c=[];if(h(i))try{let n=JSON.parse(y(i,"utf8"));Array.isArray(n)&&(c=n)}catch{}let u=new Set(c.map(n=>n.urlhash)),l=[...c,...a.filter(n=>!u.has(n.urlhash))];g(i,JSON.stringify(l)),console.log(`staged ${a.length} app font(s); manifest now has ${l.length} file(s)`)}async function E(t){let e=t[0];if(e==="stage"){await S(t.slice(1));return}console.error(`  unknown app-fonts subcommand: ${e??"(none)"}`),console.error("  available: stage"),process.exit(1)}export{E as runAppFonts};