rnxsim 0.1.313 → 0.1.314

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.313 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.314 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __create = Object.create;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "rnxsim",
-  "version": "0.1.313",
+  "version": "0.1.314",
   "description": "rnxsim CLI, Vite and Metro plugins, and agent skills for driving React Native apps in the browser.",
   "author": "Tamagui LLC",
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/sootbean/soot.git",
@@ -88,6 +88,11 @@
       "source": "./src/backend-origin.ts",
       "default": "./dist-lib/backend-origin.cjs"
     },
+    "./bridge-contract": {
+      "types": "./src/bridge-contract.ts",
+      "source": "./src/bridge-contract.ts",
+      "default": "./dist-lib/bridge-contract.cjs"
+    },
     "./bridge-constants": {
       "source": "./src/bridge-constants.ts",
       "default": "./dist-lib/bridge-constants.cjs"
@@ -155,6 +160,7 @@
     "dist-cli/",
     "dist-lib/",
     "src/",
+    "cli/",
     "skills/",
     "scripts/dev-server-scanner.ts",
     "scripts/optional-demo-registry.ts",

package/src/bridge-constants.ts

@@ -74,10 +74,9 @@ function closestLocalDevBaseHttpPort(httpPort: number): number | null {
 /** the vite dev shell that shares a world with a bridge port. the two are one
  *  offset apart by construction (bridge 7668 + N, shell 5173 + N), so a caller
  *  that pinned an explicit bridge port can name its own shell directly. that
- *  matters because the dev-bridge lockfile records only the stack that
- *  heartbeated last: on a machine running several worktree stacks it routinely
- *  names someone else's shell, and a page opened there while we poll our own
- *  bridge never connects. null when the port is not a local dev bridge port. */
+ *  keeps explicit ports independent from default-world selection and lets a
+ *  page register on the exact bridge its caller will poll. null when the port
+ *  is not a local dev bridge port. */
 export function resolveSootsimShellBaseUrlForBridgePort(
   bridgePort: number,
 ): string | null {

package/src/bridge-contract.ts

@@ -0,0 +1,251 @@
+// the wire contract for the sootsim ws bridge. the engine implements it in
+// sootsim-engine/src/mcp/ws-bridge.ts; the rnxsim cli client, the SimClient
+// sdk, and the flow runner speak it. it is the single owner of these shapes,
+// and neither side redeclares them.
+//
+// it lives in rnxsim rather than the engine because rnxsim is published and
+// sootsim-engine is `private: true`. the engine already depends on rnxsim
+// (see its `rnxsim` dependency and its `rnxsim/bridge-constants` import), so
+// this is the direction that ships.
+
+import type { SootSimAgentActionDetail } from '@sootsim/globals'
+
+export type BridgeCommandType =
+  | 'evaluate'
+  | 'call'
+  | 'screenshot'
+  | 'tap'
+  | 'longPress'
+  | 'keyboard'
+  | 'tree'
+  | 'focus'
+  | 'close'
+  | 'flowStatus'
+  | 'perform'
+  | 'state'
+  | 'reset'
+  | 'camera'
+
+export interface WsCommand {
+  id: string | number
+  type: BridgeCommandType
+  // flowStatus — live flow-runner progress payload (see flow-run-store)
+  status?: Record<string, unknown>
+  code?: string
+  path?: string
+  args?: unknown[]
+  x?: number
+  y?: number
+  durationMs?: number
+  target?: SootSimAgentActionDetail['target']
+  action?: string
+  text?: string
+  depth?: number
+  // screenshot — which canvas layers to composite. omit for full (today's
+  // default: everything including iOS chrome). 'tenant' excludes the shell
+  // overlay for a clean app capture.
+  layers?: 'full' | 'tenant' | 'shell'
+  // screenshot — engine-side layer isolation (hide subtrees / solo one
+  // subtree on transparency). see SootSimCaptureOptions.captureFilter.
+  captureFilter?: { hideTestIds?: string[]; soloTestId?: string }
+  // screenshot — optional crop rect in logical sootsim coords. the capture
+  // module scales x/y/w/h by device pixel ratio before cropping.
+  crop?: { x: number; y: number; w: number; h: number }
+  // perform — ordered batch executed inside the page, no round trips
+  steps?: PerformStep[]
+  performOptions?: PerformOptions
+  // state — compound screenshot + tree + route + errors
+  stateOptions?: SimStateOptions
+  // reset — two-tier app state wipe
+  resetOptions?: ResetOptions
+  // camera — fixture injection into the host camera pipeline
+  camera?: CameraCommand
+}
+
+// ---------------------------------------------------------------------------
+// perform — batched input
+// ---------------------------------------------------------------------------
+
+// every step maps onto a primitive that already exists on
+// SootSim.bridges.interact / .keyboard / .test. the batch runs entirely inside
+// the page so gesture timing is real wall-clock timing, not ws round-trips.
+//
+// deliberately absent: text-based tap resolution. matching by visible text is
+// fuzzy, needs ranking and failure diagnostics, and lives once in the cli's
+// tapByText. the sdk resolves text to coordinates before it builds a batch.
+// testID lookup is exact, so tapId resolves in-engine.
+export type PerformStep =
+  // raw pointer steps — full control over gesture physics
+  | { type: 'touchDown'; x: number; y: number; pointerId?: number }
+  | { type: 'touchMove'; x: number; y: number; pointerId?: number }
+  | { type: 'touchUp'; x: number; y: number; pointerId?: number }
+  | { type: 'touchCancel'; pointerId?: number }
+  // semantic steps
+  | { type: 'tap'; x: number; y: number; target?: SootSimAgentActionDetail['target'] }
+  | { type: 'tapId'; id: string }
+  | { type: 'doubleTap'; x: number; y: number; gapMs?: number }
+  | {
+      type: 'longPress'
+      x: number
+      y: number
+      durationMs?: number
+      target?: SootSimAgentActionDetail['target']
+    }
+  | {
+      type: 'drag'
+      fromX: number
+      fromY: number
+      toX: number
+      toY: number
+      steps?: number
+      stepMs?: number
+    }
+  | {
+      type: 'pinch'
+      fromX1: number
+      fromY1: number
+      fromX2: number
+      fromY2: number
+      toX1: number
+      toY1: number
+      toX2: number
+      toY2: number
+      steps?: number
+      stepMs?: number
+    }
+  | { type: 'scroll'; id: string; x?: number; y?: number; animated?: boolean }
+  | { type: 'type'; text: string }
+  | { type: 'key'; key: string }
+  | { type: 'dismissKeyboard' }
+  | { type: 'wait'; ms: number }
+  | { type: 'waitFor'; testID?: string; id?: string; timeoutMs?: number }
+
+export interface PerformOptions {
+  // stop the batch at the first failing step. default true — a gesture whose
+  // touchDown missed should not keep dragging.
+  stopOnError?: boolean
+  // ceiling on batch PROGRESS, checked between steps: once it passes, the
+  // batch starts no further steps and reports which one it reached. a step
+  // already running is always awaited to completion, never abandoned, because
+  // a gesture that keeps dispatching pointer events after the caller has been
+  // told the batch failed is worse than a late reply. every step is bounded on
+  // its own (drag and pinch by steps * stepMs, wait by ms, waitFor by its own
+  // timeout), and a wedged worker is caught by the CLI client's per-command
+  // timeout one layer up. default 30000.
+  timeoutMs?: number
+}
+
+export interface PerformStepResult {
+  index: number
+  type: PerformStep['type']
+  ok: boolean
+  // step-specific payload: tap hit info, waitFor match, resolved coordinates
+  value?: unknown
+  error?: string
+  // wall-clock ms this step took inside the page
+  durationMs: number
+}
+
+export interface PerformResult {
+  ok: boolean
+  steps: PerformStepResult[]
+  // number of steps that ran. less than steps.length when the batch aborted.
+  completed: number
+  durationMs: number
+  error?: string
+}
+
+// ---------------------------------------------------------------------------
+// state — one round-trip situational awareness
+// ---------------------------------------------------------------------------
+
+export interface SimStateOptions {
+  // omit a section an agent does not need this turn
+  screenshot?: boolean
+  tree?: boolean
+  route?: boolean
+  errors?: boolean
+  // tree depth, matching the standalone `tree` command. default 5.
+  depth?: number
+  layers?: WsCommand['layers']
+  // cap on recentErrors entries. default 20.
+  errorLimit?: number
+}
+
+export interface SimStateResult {
+  // png data uri, same encoding the `screenshot` command returns
+  screenshot?: unknown
+  tree?: unknown
+  route?: { url?: string; screen?: string | null; stack?: string[] } | null
+  recentErrors?: Array<{ level: string; text: string; at?: number }>
+  keyboard?: { visible: boolean; mode?: string | null }
+  capturedAt: number
+}
+
+// ---------------------------------------------------------------------------
+// reset — two-tier app state wipe
+// ---------------------------------------------------------------------------
+
+// 'data' clears what a user could clear from inside the app: async storage,
+// sqlite, cache dirs. 'full' also clears what only a fresh install would:
+// simulated keychain, user defaults, granted permissions.
+//
+// an in-worker remount is preferred over restarting the tenant worker, because
+// a restart is what makes reset too slow to run between tests. it is not
+// guaranteed: the result reports which one actually happened rather than
+// claiming the fast path.
+export type ResetStrategy = 'data' | 'full'
+
+export interface ResetOptions {
+  strategy?: ResetStrategy
+  // relaunch the app after wiping. default true.
+  relaunch?: boolean
+}
+
+export interface ResetResult {
+  ok: boolean
+  strategy: ResetStrategy
+  // stores verified empty after the wipe, read back rather than assumed
+  cleared: string[]
+  // stores this strategy deliberately did NOT clear, each with the reason.
+  // a named gap is not a failure, so this leaves `ok` true and stays out of
+  // `error`; a caller that cares can branch on it.
+  skipped?: Array<{ store: string; reason: string }>
+  relaunched: boolean
+  // true when reset had to restart the tenant worker instead of doing an
+  // in-worker cold remount. a restart is correct but slow, so a caller running
+  // reset between tests needs to see which path it got.
+  workerReloaded?: boolean
+  error?: string
+}
+
+// ---------------------------------------------------------------------------
+// camera — fixture injection
+// ---------------------------------------------------------------------------
+
+// the host thread owns the camera pipeline (hidden <video> -> <canvas> ->
+// ImageBitmap -> worker). injection replaces the source of that <video>, so
+// every downstream consumer — expo-camera's live frame texture and the
+// BarcodeDetector scan loop — sees the fixture with no seam of its own.
+export interface CameraPlayOptions {
+  // url the host can fetch. the cli serves the local file from the daemon.
+  url: string
+  loop?: boolean
+  // playback rate, for making a slow fixture scan faster in ci
+  rate?: number
+}
+
+export type CameraCommand =
+  | ({ action: 'play' } & CameraPlayOptions)
+  | { action: 'stop' }
+  | { action: 'status' }
+
+export interface CameraResult {
+  ok: boolean
+  // 'live' = real getUserMedia, 'fixture' = injected video, 'idle' = no session
+  source: 'live' | 'fixture' | 'idle'
+  url?: string
+  loop?: boolean
+  rate?: number
+  error?: string
+}

package/src/connect.ts

@@ -0,0 +1,83 @@
+// `connect()` — the node entrypoint of the rnxsim SDK. resolves the running
+// bridge world the same way the CLI does (development bridge registry, then
+// daemon, then default port), picks a sim, and returns a connected SimClient
+// over the shared ws transport. node-only by design: sim-client.ts stays
+// browser-safe.
+
+import { readCurrentSimId } from '../cli/current-sim'
+import { createBridge, resolveBridgeWorld, type BridgeSimInfo } from '../cli/ws-bridge'
+import { SimClient, SimConnectError } from './sim-client'
+
+export interface ConnectOptions {
+  /** ws bridge port. default: the resolved bridge world (lockfiles). */
+  port?: number
+  /** sim id to attach to (as shown by `rnxsim list`). default: the primary sim. */
+  sim?: string
+  /** per-command bridge timeout in ms. default 15000. */
+  timeoutMs?: number
+}
+
+function pickSim(
+  sims: BridgeSimInfo[],
+  wanted: string | undefined,
+  port: number,
+): BridgeSimInfo {
+  const open = sims.filter((sim) => sim.readyState === 'open')
+  if (wanted) {
+    const match = open.find((sim) => sim.id === wanted)
+    if (!match) {
+      throw new SimConnectError(
+        `no sim connected with id ${wanted} on bridge :${port}` +
+          (open.length
+            ? ` — connected: ${open.map((sim) => sim.id).join(', ')}`
+            : ' — no sims connected; open one with `rnxsim open <port>`'),
+      )
+    }
+    return match
+  }
+  // same session affinity as the CLI: a sim pinned by `rnxsim open` /
+  // `rnxsim use` in this terminal wins over the primary election, so a script
+  // run next to CLI commands drives the sim the terminal is working with. a
+  // stale pin (sim gone) falls through to the primary.
+  const pinned = readCurrentSimId()
+  if (pinned) {
+    const match = open.find((sim) => sim.id === pinned)
+    if (match) return match
+  }
+  const primary = open.find((sim) => sim.isPrimary) ?? open[0]
+  if (!primary) {
+    throw new SimConnectError(
+      `no sims connected on bridge :${port} — open one with \`rnxsim open <port>\``,
+    )
+  }
+  return primary
+}
+
+export async function connect(options: ConnectOptions = {}): Promise<SimClient> {
+  const port = options.port ?? resolveBridgeWorld().bridgePort
+  const commandTimeoutMs = options.timeoutMs ?? 15_000
+
+  // discovery socket: list sims and pick the target. closed before the pinned
+  // client socket is opened so a failed connect never leaks a connection.
+  const discovery = createBridge(port, { commandTimeoutMs, cliLabel: 'sdk' })
+  let picked: BridgeSimInfo
+  try {
+    picked = pickSim(await discovery.listSims(), options.sim, port)
+  } catch (error) {
+    discovery.close()
+    if (error instanceof SimConnectError) throw error
+    const message = error instanceof Error ? error.message : String(error)
+    throw new SimConnectError(`${message} — is the rnxsim daemon or dev shell running?`)
+  }
+  discovery.close()
+
+  // pinned socket: every command targets exactly the picked sim, immune to the
+  // CLI's saved-pin re-resolution.
+  const bridge = createBridge(port, {
+    commandTimeoutMs,
+    cliLabel: 'sdk',
+    simId: picked.id,
+    simIdSource: 'flag',
+  })
+  return new SimClient(bridge, picked.id, { commandTimeoutMs })
+}

package/src/disk-cleanup.ts

@@ -11,6 +11,7 @@ const AUTOMATIC_CLEANUP_LOCK_STALE_MS = 6 * 60 * 60 * 1000
 
 export type SootsimCleanupKind =
   | 'browser-cache'
+  | 'camera-fixture'
   | 'recording'
   | 'runtime-archive'
   | 'runtime-version'
@@ -177,6 +178,34 @@ function collectRecordingEntries(
   })
 }
 
+// videos staged by `rnxsim camera play`. a fixture is only a copy of a file
+// the user still has, so it is cheap to reclaim, but the automatic sweep must
+// not pull one out from under a sim that is playing it right now. aggressive
+// only, matching recordings.
+function collectCameraFixtureEntries(
+  home: string,
+  aggressive: boolean,
+): SootsimCleanupEntry[] {
+  const root = path.join(home, 'camera-fixtures')
+  let fixtures: fs.Dirent[]
+  try {
+    fixtures = fs.readdirSync(root, { withFileTypes: true })
+  } catch {
+    return []
+  }
+  return fixtures.map((fixture) => {
+    const fixturePath = path.join(root, fixture.name)
+    return {
+      path: fixturePath,
+      bytes: allocatedBytes(fixturePath),
+      kind: 'camera-fixture',
+      state: 'aggressive',
+      selected: aggressive,
+      detail: 'staged camera fixture video',
+    }
+  })
+}
+
 function runtimeEntries(aggressive: boolean): {
   activeRuntime: string | null
   entries: SootsimCleanupEntry[]
@@ -255,6 +284,7 @@ export function planSootsimCleanup(
     ...collectPlaywrightCaches(home),
     ...collectElectronCaches(home),
     ...collectRecordingEntries(home, aggressive),
+    ...collectCameraFixtureEntries(home, aggressive),
   ].sort((left, right) => right.bytes - left.bytes || left.path.localeCompare(right.path))
   return {
     home,

package/src/home-paths.ts

@@ -14,7 +14,7 @@
 //   ├── cache/
 //   │   └── sootsim-runtime-<version>.tar.gz
 //   ├── daemon.json        lockfile: pid, ports, active runtime, heartbeat
-//   ├── dev-bridge.json    live Vite dev bridge pointer for local CLI commands
+//   ├── dev-bridges/       live Vite dev bridge records, keyed by bound port
 //   ├── runtime-upgraded.json  one-shot notice written by the daemon's
 //   │                      background updater, consumed (printed + deleted)
 //   │                      by the next interactive CLI run
@@ -31,7 +31,7 @@ import path from 'node:path'
 export const SOOTSIM_HOME_ENV = 'SOOTSIM_HOME'
 export const ACTIVE_RUNTIME_FILE = 'active'
 export const DAEMON_LOCKFILE = 'daemon.json'
-export const DEV_BRIDGE_LOCKFILE = 'dev-bridge.json'
+export const DEV_BRIDGES_DIR = 'dev-bridges'
 export const CONFIG_FILE = 'config.json'
 export const DAEMON_HEARTBEAT_STALE_MS = 30_000
 
@@ -128,6 +128,13 @@ export function profilesDir(): string {
   return path.join(sootsimHomeDir(), 'profiles')
 }
 
+// video fixtures staged for `rnxsim camera play`. the CLI copies the user's
+// file in here and the daemon serves it by basename from this one directory,
+// so the route can never be talked into reading anywhere else on disk.
+export function cameraFixturesDir(): string {
+  return path.join(sootsimHomeDir(), 'camera-fixtures')
+}
+
 // the launchd-managed daemon spawns ProgramArguments[0] directly, and macOS
 // Background Task Management attributes the entry to whoever code-signed
 // that binary. pointing launchd at bun directly makes Login Items say
@@ -154,8 +161,15 @@ export function daemonLockfilePath(): string {
   return path.join(sootsimHomeDir(), DAEMON_LOCKFILE)
 }
 
-export function devBridgeLockfilePath(): string {
-  return path.join(sootsimHomeDir(), DEV_BRIDGE_LOCKFILE)
+export function devBridgesDir(): string {
+  return path.join(sootsimHomeDir(), DEV_BRIDGES_DIR)
+}
+
+export function devBridgeLockfilePath(bridgePort: number): string {
+  if (!Number.isInteger(bridgePort) || bridgePort <= 0) {
+    throw new Error(`invalid development bridge port: ${bridgePort}`)
+  }
+  return path.join(devBridgesDir(), `${bridgePort}.json`)
 }
 
 export function configFilePath(): string {
@@ -421,40 +435,63 @@ export function readDaemonLockfile(): DaemonLockfile | null {
   }
 }
 
-export function readDevBridgeLockfile(): DevBridgeLockfile | null {
+function parseDevBridgeLockfile(raw: string): DevBridgeLockfile | null {
   try {
-    const fd = fs.openSync(devBridgeLockfilePath(), 'r')
-    try {
-      const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES)
-      const bytesRead = fs.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0)
-      const raw = buf.subarray(0, bytesRead).toString('utf8')
-      const parsed = JSON.parse(raw) as Partial<DevBridgeLockfile>
-      if (
-        parsed &&
-        parsed.schema === 1 &&
-        parsed.source === 'vite-dev' &&
-        typeof parsed.pid === 'number' &&
-        typeof parsed.bridgePort === 'number' &&
-        typeof parsed.runtimePort === 'number' &&
-        typeof parsed.cwd === 'string' &&
-        typeof parsed.startedAt === 'number' &&
-        typeof parsed.heartbeatAt === 'number' &&
-        (parsed.shellPort === undefined || typeof parsed.shellPort === 'number') &&
-        (parsed.servedRuntimes === undefined ||
-          (Array.isArray(parsed.servedRuntimes) &&
-            parsed.servedRuntimes.every((version) => typeof version === 'string')))
-      ) {
-        return parsed as DevBridgeLockfile
-      }
-      return null
-    } finally {
-      fs.closeSync(fd)
+    const parsed = JSON.parse(raw)
+    if (
+      parsed &&
+      parsed.schema === 1 &&
+      parsed.source === 'vite-dev' &&
+      typeof parsed.pid === 'number' &&
+      typeof parsed.bridgePort === 'number' &&
+      typeof parsed.runtimePort === 'number' &&
+      typeof parsed.cwd === 'string' &&
+      typeof parsed.startedAt === 'number' &&
+      typeof parsed.heartbeatAt === 'number' &&
+      (parsed.shellPort === undefined || typeof parsed.shellPort === 'number') &&
+      (parsed.servedRuntimes === undefined ||
+        (Array.isArray(parsed.servedRuntimes) &&
+          parsed.servedRuntimes.every((version: unknown) => typeof version === 'string')))
+    ) {
+      return parsed
     }
+    return null
   } catch {
     return null
   }
 }
 
+export function readDevBridgeLockfiles(): DevBridgeLockfile[] {
+  let entries: fs.Dirent[]
+  try {
+    entries = fs.readdirSync(devBridgesDir(), { withFileTypes: true })
+  } catch {
+    return []
+  }
+
+  const lockfiles: DevBridgeLockfile[] = []
+  for (const entry of entries) {
+    if (!entry.isFile() || !/^\d+\.json$/.test(entry.name)) continue
+    try {
+      const filePath = path.join(devBridgesDir(), entry.name)
+      const fd = fs.openSync(filePath, 'r')
+      try {
+        const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES)
+        const bytesRead = fs.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0)
+        const lockfile = parseDevBridgeLockfile(
+          buf.subarray(0, bytesRead).toString('utf8'),
+        )
+        if (lockfile && entry.name === `${lockfile.bridgePort}.json`) {
+          lockfiles.push(lockfile)
+        }
+      } finally {
+        fs.closeSync(fd)
+      }
+    } catch {}
+  }
+  return lockfiles.sort((left, right) => left.bridgePort - right.bridgePort)
+}
+
 /** true when the lockfile exists, the named pid is alive, and the heartbeat
  *  is recent. callers should reach for this before trusting any of the
  *  ports inside.
@@ -503,8 +540,8 @@ export function readLiveRuntimeVersions(): string[] {
     if (daemon.activeRuntime) versions.add(daemon.activeRuntime)
     for (const version of daemon.servedRuntimes ?? []) versions.add(version)
   }
-  const devBridge = readDevBridgeLockfile()
-  if (isDevBridgeLockfileFresh(devBridge)) {
+  for (const devBridge of readDevBridgeLockfiles()) {
+    if (!isDevBridgeLockfileFresh(devBridge)) continue
     for (const version of devBridge.servedRuntimes ?? []) versions.add(version)
   }
   return [...versions].sort()
@@ -518,10 +555,11 @@ export function writeDaemonLockfile(data: DaemonLockfile): void {
 }
 
 export function writeDevBridgeLockfile(data: DevBridgeLockfile): void {
-  ensureSootsimHome()
-  const tmp = `${devBridgeLockfilePath()}.tmp`
+  fs.mkdirSync(devBridgesDir(), { recursive: true })
+  const lockfilePath = devBridgeLockfilePath(data.bridgePort)
+  const tmp = `${lockfilePath}.${data.pid}.tmp`
   fs.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`, 'utf8')
-  fs.renameSync(tmp, devBridgeLockfilePath())
+  fs.renameSync(tmp, lockfilePath)
 }
 
 /** try to claim the lockfile atomically on daemon boot. returns true if
@@ -545,8 +583,13 @@ export function removeDaemonLockfile(): void {
   } catch {}
 }
 
-export function removeDevBridgeLockfile(): void {
+export function removeDevBridgeLockfile(
+  owner: Pick<DevBridgeLockfile, 'bridgePort' | 'pid' | 'startedAt'>,
+): void {
   try {
-    fs.unlinkSync(devBridgeLockfilePath())
+    const lockfilePath = devBridgeLockfilePath(owner.bridgePort)
+    const lockfile = parseDevBridgeLockfile(fs.readFileSync(lockfilePath, 'utf8'))
+    if (lockfile?.pid !== owner.pid || lockfile.startedAt !== owner.startedAt) return
+    fs.unlinkSync(lockfilePath)
   } catch {}
 }