rnxsim 0.1.344 → 0.1.346

package/dist-lib/host/bridge-host.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.344 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.346 | (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;
@@ -116,6 +116,21 @@ var import_net = __toESM(require("net"), 1);
 var import_node_path3 = require("node:path");
 var import_util = require("util");
 
+// src/backend-origin.ts
+var LOOPBACK_PROBE_HOSTNAMES = ["::1", "127.0.0.1"];
+function normalizeHostname(hostname) {
+  return hostname.replace(/^\[|\]$/g, "").toLowerCase();
+}
+function buildLoopbackProbeBaseUrl(protocol, hostname, port) {
+  const normalizedHostname = normalizeHostname(hostname);
+  const urlHost = normalizedHostname.includes(":") ? `[${normalizedHostname}]` : normalizedHostname;
+  return `${protocol}//${urlHost}:${port}`;
+}
+function isLoopbackHost(hostname) {
+  const normalized = normalizeHostname(hostname);
+  return normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "0.0.0.0" || normalized === "::1" || /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}
+
 // src/config.ts
 var SOOTSIM_CONFIG_QUERY_PARAM = "sootsimConfig";
 function hasOwnKeys(value) {
@@ -142,6 +157,19 @@ function isAbsoluteHttpUrl(url) {
 function isNativeDevBundlePath(pathname) {
   return pathname.endsWith(".bundle");
 }
+function alignLoopbackBundleUrlWithProbe(bundleUrl, probeBaseUrl) {
+  try {
+    const bundle = new URL(bundleUrl);
+    const probe = new URL(probeBaseUrl);
+    if (!isLoopbackHost(bundle.hostname) || !isLoopbackHost(probe.hostname)) {
+      return bundleUrl;
+    }
+    bundle.hostname = probe.hostname;
+    return bundle.toString();
+  } catch {
+    return bundleUrl;
+  }
+}
 function applyPreviewProdBundle(parsed) {
   if (!process.env.SOOTSIM_PREVIEW_PROD_BUNDLE) return;
   parsed.searchParams.set("dev", "false");
@@ -514,27 +542,36 @@ var execP = (0, import_util.promisify)(import_child_process.exec);
 var TIMEOUT_MS = 250;
 var MANIFEST_TIMEOUT_MS = 1500;
 var TCP_GATE_MS = 120;
-function tcpPing(port, timeout = TCP_GATE_MS) {
-  return new Promise((resolve2) => {
-    const sock = new import_net.default.Socket();
-    let settled = false;
-    const done = (ok) => {
-      if (settled) return;
-      settled = true;
-      sock.destroy();
-      resolve2(ok);
-    };
-    sock.setTimeout(timeout);
-    sock.once("connect", () => done(true));
-    sock.once("timeout", () => done(false));
-    sock.once("error", () => done(false));
-    sock.connect(port, "localhost");
-  });
+async function tcpPing(port, timeout = TCP_GATE_MS) {
+  try {
+    return await Promise.any(
+      LOOPBACK_PROBE_HOSTNAMES.map(
+        (hostname) => new Promise((resolve2, reject) => {
+          const sock = new import_net.default.Socket();
+          let settled = false;
+          const done = (reachable) => {
+            if (settled) return;
+            settled = true;
+            sock.destroy();
+            if (reachable) resolve2(hostname);
+            else reject(new Error(`unreachable loopback host ${hostname}`));
+          };
+          sock.setTimeout(timeout);
+          sock.once("connect", () => done(true));
+          sock.once("timeout", () => done(false));
+          sock.once("error", () => done(false));
+          sock.connect(port, hostname);
+        })
+      )
+    );
+  } catch {
+    return null;
+  }
 }
-function httpGet(port, path10, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+function httpGet(hostname, port, path10, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
   return new Promise((resolve2) => {
     const req = import_http.default.request(
-      { hostname: "localhost", port, path: path10, method, timeout, headers },
+      { hostname, port, path: path10, method, timeout, headers },
       (res) => {
         let body = "";
         res.on("data", (c) => body += c.toString());
@@ -546,7 +583,12 @@ function httpGet(port, path10, method = "GET", timeout = TIMEOUT_MS, headers = {
         })();
         res.on(
           "end",
-          () => resolve2({ statusCode: res.statusCode || 0, body, contentType })
+          () => resolve2({
+            statusCode: res.statusCode || 0,
+            body,
+            contentType,
+            hostname
+          })
         );
       }
     );
@@ -698,16 +740,16 @@ async function resolveProcessCwd(pid) {
   }
   return null;
 }
-function makeResult(port, framework, owner) {
+function makeResult(hostname, port, framework, owner) {
   return {
     port,
     framework,
     bundleUrl: withRuntimeConfig(
       port,
-      `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`,
+      `${buildLoopbackProbeBaseUrl("http:", hostname, port)}/index.bundle?platform=ios&dev=true&hot=true&minify=false`,
       owner.cwd
     ),
-    hmrUrl: `ws://localhost:${port}/hot`,
+    hmrUrl: `${buildLoopbackProbeBaseUrl("ws:", hostname, port)}/hot`,
     lastSeen: Date.now(),
     ...owner
   };
@@ -738,7 +780,11 @@ function applyManifest(result, manifestRes, buildIconProxyUrl) {
     if (client.name) result.projectName = client.name;
     if (client.ios?.bundleIdentifier) result.bundleId = client.ios.bundleIdentifier;
     if (result.framework === "metro" && client.sdkVersion) result.framework = "expo";
-    const launchUrl2 = manifest?.launchAsset?.url;
+    const rawLaunchUrl = manifest?.launchAsset?.url;
+    const launchUrl2 = typeof rawLaunchUrl === "string" ? alignLoopbackBundleUrlWithProbe(
+      rawLaunchUrl,
+      buildLoopbackProbeBaseUrl("http:", manifestRes.hostname, result.port)
+    ) : rawLaunchUrl;
     if (launchUrl2 && !result.patched && !isDirectOneBundleUrl(result.bundleUrl)) {
       result.bundleUrl = withRuntimeConfig(result.port, launchUrl2, result.cwd);
     }
@@ -751,11 +797,11 @@ function applyManifest(result, manifestRes, buildIconProxyUrl) {
         } else {
           const cleanPath = rawIconUrl.replace(/^\.\//, "");
           result.iconUrl = buildIconProxyUrl(
-            `http://localhost:${result.port}/assets/${cleanPath}`
+            `${buildLoopbackProbeBaseUrl("http:", manifestRes.hostname, result.port)}/assets/${cleanPath}`
           );
         }
       } else {
-        result.iconUrl = rawIconUrl.startsWith("http") ? rawIconUrl : `http://localhost:${result.port}/assets/${rawIconUrl.replace(/^\.\//, "")}`;
+        result.iconUrl = rawIconUrl.startsWith("http") ? rawIconUrl : `${buildLoopbackProbeBaseUrl("http:", manifestRes.hostname, result.port)}/assets/${rawIconUrl.replace(/^\.\//, "")}`;
       }
     }
   } catch {
@@ -779,38 +825,51 @@ function enrichWithManifest(result, buildIconProxyUrl) {
   }
   if (!enrichmentInFlight.has(result.port)) {
     enrichmentInFlight.add(result.port);
-    const port = result.port;
-    void fetchManifestEnrichment(port, buildIconProxyUrl).finally(
-      () => enrichmentInFlight.delete(port)
+    void fetchManifestEnrichment(result, buildIconProxyUrl).finally(
+      () => enrichmentInFlight.delete(result.port)
     );
   }
   return result;
 }
-async function fetchManifestEnrichment(port, buildIconProxyUrl) {
-  const manifestRes = await httpGet(port, "/", "GET", ENRICH_TIMEOUT_MS, {
-    "expo-platform": "ios"
-  });
+async function fetchManifestEnrichment(result, buildIconProxyUrl) {
+  const hostname = normalizeHostname(new URL(result.bundleUrl).hostname);
+  const manifestRes = await httpGet(
+    hostname,
+    result.port,
+    "/",
+    "GET",
+    ENRICH_TIMEOUT_MS,
+    {
+      "expo-platform": "ios"
+    }
+  );
   if (!manifestRes || manifestRes.statusCode !== 200) return;
   const parsed = applyManifest(
-    { port, framework: "one", bundleUrl: "", lastSeen: 0 },
+    {
+      port: result.port,
+      framework: "one",
+      bundleUrl: `${buildLoopbackProbeBaseUrl("http:", hostname, result.port)}/index.bundle`,
+      lastSeen: 0
+    },
     manifestRes,
     buildIconProxyUrl
   );
   if (!parsed.projectName && !parsed.iconUrl) return;
-  enrichmentCache.set(port, {
+  enrichmentCache.set(result.port, {
     projectName: parsed.projectName,
     iconUrl: parsed.iconUrl,
     iconPath: parsed.iconPath,
     bundleId: parsed.bundleId
   });
-  portCache.delete(port);
+  portCache.delete(result.port);
 }
 var knownNonPatched = /* @__PURE__ */ new Set();
 var knownNonExpo = /* @__PURE__ */ new Set();
 var knownOne = /* @__PURE__ */ new Set();
 async function probePort(port, buildIconProxyUrl, listeningProcess) {
   await loadOptionalDemoApps();
-  if (!await tcpPing(port)) return null;
+  const probeHostname = await tcpPing(port);
+  if (!probeHostname) return null;
   const suppliedPid = listeningProcess?.pid;
   const ownerPid = suppliedPid && suppliedPid > 0 ? suppliedPid : await resolveListeningPid(port);
   const ownerCwd = ownerPid ? await resolveProcessCwd(ownerPid) : null;
@@ -820,10 +879,12 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
   };
   const onePath = `/node_modules/one/metro-entry.bundle?platform=ios&dev=true`;
   const [sootsimRes, statusRes, manifestRes, expoRes] = await Promise.all([
-    knownNonPatched.has(port) ? Promise.resolve(null) : httpGet(port, "/__soot/"),
-    httpGet(port, "/status"),
-    knownOne.has(port) ? Promise.resolve(null) : httpGet(port, "/", "GET", MANIFEST_TIMEOUT_MS, { "expo-platform": "ios" }),
-    knownNonExpo.has(port) ? Promise.resolve(null) : httpGet(port, "/_expo/status")
+    knownNonPatched.has(port) ? Promise.resolve(null) : httpGet(probeHostname, port, "/__soot/"),
+    httpGet(probeHostname, port, "/status"),
+    knownOne.has(port) ? Promise.resolve(null) : httpGet(probeHostname, port, "/", "GET", MANIFEST_TIMEOUT_MS, {
+      "expo-platform": "ios"
+    }),
+    knownNonExpo.has(port) ? Promise.resolve(null) : httpGet(probeHostname, port, "/_expo/status")
   ]);
   if (expoRes && expoRes.statusCode === 200) {
     knownNonExpo.delete(port);
@@ -835,7 +896,7 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
   const manifestClient = manifestParsed?.extra?.expoClient || manifestParsed?.extra || {};
   if (manifestParsed && (manifestLaunchUrl || typeof manifestClient.name === "string")) {
     knownNonPatched.add(port);
-    const launchUrl2 = manifestLaunchUrl || `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`;
+    const launchUrl2 = manifestLaunchUrl || `${buildLoopbackProbeBaseUrl("http:", probeHostname, port)}/index.bundle?platform=ios&dev=true&hot=true&minify=false`;
     const framework = launchUrl2.includes(
       "/one/metro-entry.bundle"
     ) ? "one" : "expo";
@@ -844,7 +905,7 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
         port,
         framework,
         bundleUrl: withRuntimeConfig(port, launchUrl2, owner.cwd),
-        hmrUrl: `ws://localhost:${port}/hot`,
+        hmrUrl: `${buildLoopbackProbeBaseUrl("ws:", probeHostname, port)}/hot`,
         lastSeen: Date.now(),
         ...owner
       },
@@ -856,7 +917,12 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
     knownNonPatched.add(port);
     return enrichWithManifest(
       applyManifest(
-        makeResult(port, expoRes && expoRes.statusCode === 200 ? "expo" : "metro", owner),
+        makeResult(
+          probeHostname,
+          port,
+          expoRes && expoRes.statusCode === 200 ? "expo" : "metro",
+          owner
+        ),
         manifestRes,
         buildIconProxyUrl
       ),
@@ -872,10 +938,10 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
           framework: "one",
           bundleUrl: withRuntimeConfig(
             port,
-            `http://localhost:${port}/__soot/bundle.js`,
+            `${buildLoopbackProbeBaseUrl("http:", probeHostname, port)}/__soot/bundle.js`,
             owner.cwd
           ),
-          hmrUrl: `ws://localhost:${port}/hot`,
+          hmrUrl: `${buildLoopbackProbeBaseUrl("ws:", probeHostname, port)}/hot`,
           lastSeen: Date.now(),
           patched: true,
           ...owner
@@ -890,7 +956,7 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
   if (looksLikeMetroPackager) {
     return null;
   }
-  const oneRes = await httpGet(port, onePath, "HEAD");
+  const oneRes = await httpGet(probeHostname, port, onePath, "HEAD");
   if (oneRes && oneRes.statusCode > 0 && oneRes.statusCode < 400 && /application\/javascript/i.test(oneRes.contentType || "")) {
     knownNonPatched.add(port);
     knownOne.add(port);
@@ -901,10 +967,10 @@ async function probePort(port, buildIconProxyUrl, listeningProcess) {
           framework: "one",
           bundleUrl: withRuntimeConfig(
             port,
-            `http://localhost:${port}${onePath}&minify=false`,
+            `${buildLoopbackProbeBaseUrl("http:", probeHostname, port)}${onePath}&minify=false`,
             owner.cwd
           ),
-          hmrUrl: `ws://localhost:${port}/hot`,
+          hmrUrl: `${buildLoopbackProbeBaseUrl("ws:", probeHostname, port)}/hot`,
           lastSeen: Date.now(),
           ...owner
         },
@@ -1064,6 +1130,7 @@ function getCliVersion() {
 }
 
 // src/home-paths.ts
+var import_node_crypto = require("node:crypto");
 var import_node_fs3 = __toESM(require("node:fs"), 1);
 var import_node_os = require("node:os");
 var import_node_path4 = __toESM(require("node:path"), 1);
@@ -1197,6 +1264,7 @@ function activeRuntimeDir() {
   return null;
 }
 var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+var DAEMON_CLAIM_STALE_MS = 3e4;
 function readDaemonLockfile() {
   try {
     const fd = import_node_fs3.default.openSync(daemonLockfilePath(), "r");
@@ -1239,10 +1307,30 @@ function isDaemonLockfileFresh(lock, now = Date.now()) {
 }
 function writeDaemonLockfile(data) {
   ensureSootsimHome();
-  const tmp = `${daemonLockfilePath()}.tmp`;
+  const lockfilePath = daemonLockfilePath();
+  const existing = readDaemonLockfile();
+  if (!existing) {
+    if (createDaemonLockfileExclusive(data)) return;
+    throw new Error("another rnx daemon claimed the lockfile before this write");
+  }
+  if (!sameDaemonOwner(existing, data)) {
+    throw new Error("refusing to overwrite another rnx daemon lockfile");
+  }
+  const tmp = `${lockfilePath}.${data.pid}.${(0, import_node_crypto.randomUUID)()}.tmp`;
   import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
-  import_node_fs3.default.renameSync(tmp, daemonLockfilePath());
+  try {
+    const current = readDaemonLockfile();
+    if (!current || !sameDaemonOwner(current, data)) {
+      throw new Error("rnx daemon lock ownership changed during heartbeat");
+    }
+    import_node_fs3.default.renameSync(tmp, lockfilePath);
+  } finally {
+    try {
+      import_node_fs3.default.unlinkSync(tmp);
+    } catch {
+    }
+  }
 }
 function writeDevBridgeLockfile(data) {
   import_node_fs3.default.mkdirSync(devBridgesDir(), { recursive: true });
@@ -1252,17 +1340,130 @@ function writeDevBridgeLockfile(data) {
 `, "utf8");
   import_node_fs3.default.renameSync(tmp, lockfilePath);
 }
+function sameDaemonOwner(left, right) {
+  return left.pid === right.pid && left.startedAt === right.startedAt;
+}
+function isAlreadyExists(error) {
+  return error instanceof Error && "code" in error && Reflect.get(error, "code") === "EEXIST";
+}
+function createDaemonLockfileExclusive(data) {
+  const lockfilePath = daemonLockfilePath();
+  const tmp = `${lockfilePath}.${data.pid}.${(0, import_node_crypto.randomUUID)()}.claim`;
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+  try {
+    import_node_fs3.default.linkSync(tmp, lockfilePath);
+    return true;
+  } catch (error) {
+    if (isAlreadyExists(error)) return false;
+    throw error;
+  } finally {
+    try {
+      import_node_fs3.default.unlinkSync(tmp);
+    } catch {
+    }
+  }
+}
+function daemonClaimPath() {
+  return `${daemonLockfilePath()}.claim`;
+}
+function parseDaemonClaim(raw) {
+  try {
+    const value = JSON.parse(raw);
+    if (value !== null && typeof value === "object" && typeof Reflect.get(value, "pid") === "number" && typeof Reflect.get(value, "startedAt") === "number" && typeof Reflect.get(value, "createdAt") === "number") {
+      return {
+        pid: Reflect.get(value, "pid"),
+        startedAt: Reflect.get(value, "startedAt"),
+        createdAt: Reflect.get(value, "createdAt")
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function readDaemonClaim() {
+  try {
+    return parseDaemonClaim(import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function isDaemonClaimFresh(claim, now = Date.now()) {
+  if (now - claim.createdAt > DAEMON_CLAIM_STALE_MS) return false;
+  try {
+    process.kill(claim.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireDaemonClaim(data) {
+  const claim = {
+    pid: data.pid,
+    startedAt: data.startedAt,
+    createdAt: Date.now()
+  };
+  const serialized = `${JSON.stringify(claim)}
+`;
+  for (let attempt = 0; attempt < 8; attempt++) {
+    try {
+      import_node_fs3.default.writeFileSync(daemonClaimPath(), serialized, { encoding: "utf8", flag: "wx" });
+      return true;
+    } catch (error) {
+      if (!isAlreadyExists(error)) throw error;
+    }
+    const existing = readDaemonClaim();
+    if (existing && sameDaemonOwner(existing, claim)) return true;
+    if (existing && isDaemonClaimFresh(existing)) return false;
+    let before;
+    try {
+      before = import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8");
+      const latest = parseDaemonClaim(before);
+      if (latest && isDaemonClaimFresh(latest)) return false;
+      if (import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8") !== before) continue;
+      import_node_fs3.default.unlinkSync(daemonClaimPath());
+    } catch {
+    }
+  }
+  return false;
+}
+function releaseDaemonClaim(owner) {
+  try {
+    const claim = readDaemonClaim();
+    if (!claim || !sameDaemonOwner(claim, owner)) return;
+    import_node_fs3.default.unlinkSync(daemonClaimPath());
+  } catch {
+  }
+}
 function claimDaemonLockfile(data) {
   ensureSootsimHome();
-  const existing = readDaemonLockfile();
-  if (existing && isDaemonLockfileFresh(existing) && existing.pid !== data.pid) {
-    return false;
+  if (!acquireDaemonClaim(data)) return false;
+  try {
+    const existing = readDaemonLockfile();
+    if (existing && sameDaemonOwner(existing, data)) {
+      writeDaemonLockfile(data);
+      return true;
+    }
+    if (existing && isDaemonLockfileFresh(existing)) return false;
+    if (existing) {
+      const latest = readDaemonLockfile();
+      if (!latest || !sameDaemonOwner(latest, existing)) return false;
+      if (isDaemonLockfileFresh(latest)) return false;
+      try {
+        import_node_fs3.default.unlinkSync(daemonLockfilePath());
+      } catch {
+        return false;
+      }
+    }
+    return createDaemonLockfileExclusive(data);
+  } finally {
+    releaseDaemonClaim(data);
   }
-  writeDaemonLockfile(data);
-  return true;
 }
-function removeDaemonLockfile() {
+function removeDaemonLockfile(owner) {
   try {
+    const lockfile = readDaemonLockfile();
+    if (!lockfile || !sameDaemonOwner(lockfile, owner)) return;
     import_node_fs3.default.unlinkSync(daemonLockfilePath());
   } catch {
   }
@@ -1284,7 +1485,7 @@ var import_url = require("url");
 
 // ../contrast-runtime-delivery/src/index.ts
 var import_node_child_process = require("node:child_process");
-var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_node_crypto2 = __toESM(require("node:crypto"), 1);
 var import_node_fs5 = __toESM(require("node:fs"), 1);
 var import_node_os2 = __toESM(require("node:os"), 1);
 var import_node_path6 = __toESM(require("node:path"), 1);
@@ -1664,7 +1865,7 @@ async function downloadToFile(url, destPath) {
 }
 function sha256File(filePath) {
   return new Promise((resolve2, reject) => {
-    const hash = import_node_crypto.default.createHash("sha256");
+    const hash = import_node_crypto2.default.createHash("sha256");
     const stream = import_node_fs5.default.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
@@ -1780,7 +1981,7 @@ var import_node_path9 = __toESM(require("node:path"), 1);
 
 // src/agent-sessions.ts
 var import_node_child_process2 = require("node:child_process");
-var import_node_crypto3 = require("node:crypto");
+var import_node_crypto4 = require("node:crypto");
 var import_node_fs7 = __toESM(require("node:fs"), 1);
 var import_node_path8 = __toESM(require("node:path"), 1);
 var import_node_readline = __toESM(require("node:readline"), 1);
@@ -1825,7 +2026,7 @@ function encodeAgentPromptEnvelope(input) {
 }
 
 // src/attached-projects.ts
-var import_node_crypto2 = require("node:crypto");
+var import_node_crypto3 = require("node:crypto");
 var import_node_fs6 = __toESM(require("node:fs"), 1);
 var import_node_path7 = __toESM(require("node:path"), 1);
 var overrideDir = null;
@@ -1899,10 +2100,10 @@ function mutateStore(fn) {
   return store;
 }
 function projectIdForCwd(cwd) {
-  return (0, import_node_crypto2.createHash)("sha256").update(import_node_path7.default.resolve(cwd)).digest("hex").slice(0, 16);
+  return (0, import_node_crypto3.createHash)("sha256").update(import_node_path7.default.resolve(cwd)).digest("hex").slice(0, 16);
 }
 function newSessionId() {
-  return `s_${(0, import_node_crypto2.randomBytes)(10).toString("hex")}`;
+  return `s_${(0, import_node_crypto3.randomBytes)(10).toString("hex")}`;
 }
 function upsertProject(input) {
   const cwd = import_node_path7.default.resolve(input.cwd);
@@ -2326,7 +2527,7 @@ async function startSession(opts) {
         `session already running for project=${project.id} provider=${provider} (session ${existingLive.id}, pid ${existingLive.wrapperPid}). end it first with \`rnx agent end <sessionId>\`.`
       );
     }
-    const claudeSessionUuid = provider === "claude" ? (0, import_node_crypto3.randomUUID)() : void 0;
+    const claudeSessionUuid = provider === "claude" ? (0, import_node_crypto4.randomUUID)() : void 0;
     const session = upsertSession({
       projectId: project.id,
       provider,
@@ -3120,15 +3321,6 @@ var import_http2 = __toESM(require("http"), 1);
 var import_https = __toESM(require("https"), 1);
 var import_promises4 = require("stream/promises");
 
-// src/backend-origin.ts
-function normalizeHostname(hostname) {
-  return hostname.replace(/^\[|\]$/g, "").toLowerCase();
-}
-function isLoopbackHost(hostname) {
-  const normalized = normalizeHostname(hostname);
-  return normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "0.0.0.0" || normalized === "::1" || /^127(?:\.\d{1,3}){3}$/.test(normalized);
-}
-
 // src/host/fetch-proxy-overrides.ts
 var FETCH_PROXY_BROWSER_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
 var HOST_HEADER_OVERRIDES = [
@@ -3594,9 +3786,18 @@ export const Appearance = rn.Appearance
 `;
 }
 function sendJavaScript(req, res, source) {
+  const origin = req.headers.origin;
+  let allowedOrigin;
+  if (origin) {
+    try {
+      if (isLoopbackHost(new URL(origin).hostname)) allowedOrigin = origin;
+    } catch {
+    }
+  }
   res.writeHead(200, {
     "Content-Type": "application/javascript; charset=utf-8",
-    "Cache-Control": "no-cache"
+    "Cache-Control": "no-cache",
+    ...allowedOrigin ? { "Access-Control-Allow-Origin": allowedOrigin, Vary: "Origin" } : {}
   });
   res.end(req.method === "HEAD" ? void 0 : source);
 }
@@ -3617,6 +3818,23 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
   } catch {
     return false;
   }
+  if (options.requireLoopbackOrigin) {
+    const origin = req.headers.origin;
+    const remoteAddress = req.socket.remoteAddress?.replace(/^::ffff:/, "");
+    let allowed = Boolean(remoteAddress && isLoopbackHost(remoteAddress));
+    if (allowed && origin) {
+      try {
+        allowed = isLoopbackHost(new URL(origin).hostname);
+      } catch {
+        allowed = false;
+      }
+    }
+    if (!allowed) {
+      res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("replacement modules are available only to loopback origins");
+      return true;
+    }
+  }
   if (url.pathname === `${REPLACEMENT_RUNTIME_PREFIX}/react`) {
     sendJavaScript(req, res, reactRuntimeSource(options.reactBridgeUrl));
     return true;
@@ -3626,6 +3844,11 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     return true;
   }
   if (url.pathname !== REPLACEMENT_MODULE_ROUTE) return false;
+  if (options.requestToken && url.searchParams.get("token") !== options.requestToken) {
+    res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("replacement module request token is invalid");
+    return true;
+  }
   const targetPath = url.searchParams.get("path");
   if (!targetPath) {
     res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
@@ -3638,17 +3861,42 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     res.end("replacement files must be .js, .jsx, .ts, or .tsx");
     return true;
   }
+  if (!import_node_path10.default.isAbsolute(targetPath)) {
+    res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("replacement file path must be absolute");
+    return true;
+  }
+  let resolvedProjectRoot;
+  if (options.projectRoot) {
+    const lexicalProjectRoot = import_node_path10.default.resolve(options.projectRoot);
+    resolvedProjectRoot = await import_promises5.default.realpath(options.projectRoot);
+    const lexicalTarget = import_node_path10.default.relative(lexicalProjectRoot, targetPath);
+    if (lexicalTarget.startsWith("..") || import_node_path10.default.isAbsolute(lexicalTarget)) {
+      res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("replacement file must be inside the project root");
+      return true;
+    }
+  }
+  let resolvedTargetPath;
   try {
-    await import_promises5.default.access(targetPath);
+    resolvedTargetPath = await import_promises5.default.realpath(targetPath);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
     res.end(`replacement file not found: ${message}`);
     return true;
   }
+  if (resolvedProjectRoot) {
+    const relativeTarget = import_node_path10.default.relative(resolvedProjectRoot, resolvedTargetPath);
+    if (relativeTarget.startsWith("..") || import_node_path10.default.isAbsolute(relativeTarget)) {
+      res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("replacement file must be inside the project root");
+      return true;
+    }
+  }
   try {
     const result = await (0, import_esbuild.build)({
-      entryPoints: [targetPath],
+      entryPoints: [resolvedTargetPath],
       bundle: true,
       write: false,
       format: "esm",
@@ -4911,7 +5159,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
   removeLockfile() {
     if (!this.shouldWriteLockfile) return;
     try {
-      removeDaemonLockfile();
+      removeDaemonLockfile({ pid: process.pid, startedAt: this.startedAt });
     } catch {
     }
   }
@@ -5470,7 +5718,7 @@ var SootSimBridgeHost = class _SootSimBridgeHost {
     }
     if (this.shouldWriteLockfile) {
       try {
-        removeDaemonLockfile();
+        removeDaemonLockfile({ pid: process.pid, startedAt: this.startedAt });
       } catch {
       }
     }