fix(setup): survive a vanished port owner, and stop flagging our own containers

Two failures from one compose re-run:

- 'Kill it for me' crashed setup with 'kill() failed: ESRCH: No such process'. The owner list is an lsof snapshot, so the process can exit before the signal lands — which is the outcome we wanted, not an error. ESRCH now counts as freed, EPERM warns that it must be stopped by hand, and anything else warns; the loop re-probes either way instead of aborting a setup that had already written .env.

- Compose mode demanded 3000/3002 be free even when this stack was the one holding them, so re-running setup against a running install reported its own realtime container as a blocker and offered to kill Docker's listener. 'docker compose up -d' reconciles its own containers, so skip the check when the project already has some. A foreign process is still caught, and a foreign container still surfaces as a bind error from compose.

Author: TheodoreSpeaks

scripts/setup/modes/compose.ts

@@ -25,6 +25,20 @@ import { glyph, theme } from '../theme.ts'
  * is fatal here: compose can't come up while the ports are held.
  */
 async function ensureComposePortsFree(composeFile: string): Promise<void> {
+  // This stack already holding 3000/3002 is not a conflict — `docker compose up
+  // -d` reconciles its own containers. Without this, re-running setup against a
+  // running install reports its own realtime container as a blocker and offers
+  // to kill Docker's listener, which is never the right move. A genuinely
+  // foreign process still gets caught below, and a foreign *container* surfaces
+  // as a clear bind error from compose itself.
+  const ours = spawnSync('docker', ['compose', '-f', composeFile, 'ps', '-q'], {
+    cwd: ROOT,
+    encoding: 'utf8',
+  })
+  if (ours.status === 0 && ours.stdout.trim()) {
+    p.log.step('Existing Sim containers hold :3000/:3002 — compose will reconcile them')
+    return
+  }
   if (await ensurePortsFree([3000, 3002])) return
   throw new SetupError('ports 3000/3002 are in use', [
     `free the ports, then re-run: ${theme.command('bun run setup')}`,

scripts/setup/ports.ts

@@ -1,3 +1,4 @@
+import { getErrorMessage } from '@sim/utils/errors'
 import { type PortOwnerInfo, portOpen, portOwner } from './detect.ts'
 import { waitFor } from './probes.ts'
 import * as p from './prompter.ts'
@@ -54,12 +55,30 @@ export async function ensurePortsFree(ports: number[]): Promise<boolean> {
 
     if (choice === 'abort') return false
     if (choice === 'kill') {
+      const killed: string[] = []
       for (const b of killable) {
-        if (b.owner) process.kill(b.owner.pid, 'SIGKILL')
+        if (!b.owner) continue
+        const label = `${b.owner.command} (pid ${b.owner.pid})`
+        try {
+          process.kill(b.owner.pid, 'SIGKILL')
+          killed.push(label)
+        } catch (error) {
+          // The owner list came from an lsof snapshot, so the process may have
+          // exited in between — that is the outcome we wanted, not a failure.
+          // A signal we're not allowed to send is worth saying out loud, but
+          // never fatal: the loop re-probes and offers the choice again.
+          const code = (error as NodeJS.ErrnoException).code
+          if (code === 'ESRCH') killed.push(`${label} — already gone`)
+          else if (code === 'EPERM') {
+            p.log.warn(
+              `Not allowed to kill ${label} — stop it yourself, then choose "check again".`
+            )
+          } else {
+            p.log.warn(`Could not kill ${label}: ${getErrorMessage(error)}`)
+          }
+        }
       }
-      p.log.step(
-        `Killed ${killable.map((b) => `${b.owner?.command} (pid ${b.owner?.pid})`).join(', ')}`
-      )
+      if (killed.length > 0) p.log.step(`Killed ${killed.join(', ')}`)
       // SIGKILL is async — the kernel releases the listening socket a beat after
       // the process dies, so re-checking immediately would still see the port
       // held. Wait for the killed ports to actually free before looping.