rnxsim 0.1.375 → 0.1.376

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

@@ -1,4 +1,4 @@
-/*! rnx v0.1.375 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.376 | (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;
@@ -113,6 +113,7 @@ var import_child_process = require("child_process");
 var import_promises2 = require("fs/promises");
 var import_http = __toESM(require("http"), 1);
 var import_net = __toESM(require("net"), 1);
+var import_node_fs2 = require("node:fs");
 var import_node_path3 = require("node:path");
 
 // src/backend-origin.ts
@@ -802,9 +803,22 @@ function makeResult(hostname, port, framework, owner) {
   };
 }
 function withRuntimeConfig(port, bundleUrl, projectCwd) {
-  const knownApp = projectCwd ? optionalDemoAppsSync().find(
-    (app) => app.preferredPort === port && (0, import_node_path3.resolve)(app.dir) === (0, import_node_path3.resolve)(projectCwd)
-  ) : void 0;
+  let physicalProjectCwd;
+  if (projectCwd) {
+    try {
+      physicalProjectCwd = (0, import_node_fs2.realpathSync)((0, import_node_path3.resolve)(projectCwd));
+    } catch {
+    }
+  }
+  const knownApps = physicalProjectCwd ? optionalDemoAppsSync().filter((app) => {
+    try {
+      return (0, import_node_fs2.realpathSync)((0, import_node_path3.resolve)(app.dir)) === physicalProjectCwd;
+    } catch {
+      return false;
+    }
+  }) : [];
+  const exactKnownApps = knownApps.filter((app) => app.preferredPort === port);
+  const knownApp = exactKnownApps.length === 1 ? exactKnownApps[0] : exactKnownApps.length === 0 && knownApps.length === 1 ? knownApps[0] : void 0;
   const configured = knownApp?.runtimeConfig ? applySootSimConfigToUrl(bundleUrl, knownApp.runtimeConfig) : bundleUrl;
   return normalizeNativeDevBundleUrl(configured);
 }
@@ -1141,7 +1155,7 @@ var SOOTSIM_BRIDGE_SIM_CLOSE_CODE = 4001;
 var SOOTSIM_BRIDGE_SIM_CLOSE_REASON = "sootsim close";
 
 // src/cli-version.ts
-var import_node_fs2 = require("node:fs");
+var import_node_fs3 = require("node:fs");
 var import_node_url2 = require("node:url");
 
 // src/public-brand.ts
@@ -1165,7 +1179,7 @@ function getCliVersion() {
   ];
   for (const resolve2 of candidates) {
     try {
-      const version = JSON.parse((0, import_node_fs2.readFileSync)(resolve2(), "utf8")).version;
+      const version = JSON.parse((0, import_node_fs3.readFileSync)(resolve2(), "utf8")).version;
       if (typeof version === "string" && version) {
         cached2 = version;
         return cached2;
@@ -1179,7 +1193,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_fs4 = __toESM(require("node:fs"), 1);
 var import_node_os = require("node:os");
 var import_node_path4 = __toESM(require("node:path"), 1);
 var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
@@ -1201,7 +1215,7 @@ function isSootsimDevCheckout() {
   const argv1 = process.argv[1];
   if (!argv1) return false;
   try {
-    const real = import_node_fs3.default.realpathSync(argv1);
+    const real = import_node_fs4.default.realpathSync(argv1);
     return real.includes(`${import_node_path4.default.sep}packages${import_node_path4.default.sep}sootsim${import_node_path4.default.sep}`);
   } catch {
     return false;
@@ -1248,7 +1262,7 @@ function configFilePath() {
 }
 function readSharedConfig() {
   try {
-    const raw = import_node_fs3.default.readFileSync(configFilePath(), "utf8");
+    const raw = import_node_fs4.default.readFileSync(configFilePath(), "utf8");
     const parsed = JSON.parse(raw);
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
@@ -1266,9 +1280,9 @@ function writeSharedConfig(patch) {
     };
   }
   const tmp = `${configFilePath()}.tmp`;
-  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
+  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
 `, "utf8");
-  import_node_fs3.default.renameSync(tmp, configFilePath());
+  import_node_fs4.default.renameSync(tmp, configFilePath());
   return next;
 }
 function runtimeUpgradeNoticePath() {
@@ -1277,28 +1291,28 @@ function runtimeUpgradeNoticePath() {
 function writeRuntimeUpgradeNotice(notice) {
   ensureSootsimHome();
   const tmp = `${runtimeUpgradeNoticePath()}.tmp`;
-  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(notice)}
+  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(notice)}
 `, "utf8");
-  import_node_fs3.default.renameSync(tmp, runtimeUpgradeNoticePath());
+  import_node_fs4.default.renameSync(tmp, runtimeUpgradeNoticePath());
 }
 function ensureSootsimHome() {
-  import_node_fs3.default.mkdirSync(sootsimHomeDir(), { recursive: true });
-  import_node_fs3.default.mkdirSync(runtimesDir(), { recursive: true });
-  import_node_fs3.default.mkdirSync(electronDir(), { recursive: true });
-  import_node_fs3.default.mkdirSync(profilesDir(), { recursive: true });
-  import_node_fs3.default.mkdirSync(cacheDir(), { recursive: true });
+  import_node_fs4.default.mkdirSync(sootsimHomeDir(), { recursive: true });
+  import_node_fs4.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs4.default.mkdirSync(electronDir(), { recursive: true });
+  import_node_fs4.default.mkdirSync(profilesDir(), { recursive: true });
+  import_node_fs4.default.mkdirSync(cacheDir(), { recursive: true });
 }
 function readActiveRuntime() {
   try {
-    const value = import_node_fs3.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    const value = import_node_fs4.default.readFileSync(activeRuntimeFile(), "utf8").trim();
     return value.length > 0 ? value : null;
   } catch {
     return null;
   }
 }
 function writeActiveRuntime(version) {
-  import_node_fs3.default.mkdirSync(runtimesDir(), { recursive: true });
-  import_node_fs3.default.writeFileSync(activeRuntimeFile(), `${version}
+  import_node_fs4.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs4.default.writeFileSync(activeRuntimeFile(), `${version}
 `, "utf8");
 }
 function activeRuntimeDir() {
@@ -1306,7 +1320,7 @@ function activeRuntimeDir() {
   if (!version) return null;
   const dir = runtimeDir(version);
   try {
-    if (import_node_fs3.default.statSync(dir).isDirectory()) return dir;
+    if (import_node_fs4.default.statSync(dir).isDirectory()) return dir;
   } catch {
   }
   return null;
@@ -1315,10 +1329,10 @@ 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");
+    const fd = import_node_fs4.default.openSync(daemonLockfilePath(), "r");
     try {
       const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
-      const bytesRead = import_node_fs3.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
+      const bytesRead = import_node_fs4.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
       const raw = buf.subarray(0, bytesRead).toString("utf8");
       const parsed = JSON.parse(raw);
       if (parsed && parsed.schema === 1 && typeof parsed.pid === "number" && typeof parsed.bridgePort === "number" && typeof parsed.runtimePort === "number" && typeof parsed.startedAt === "number" && typeof parsed.heartbeatAt === "number" && (parsed.servedRuntimes === void 0 || Array.isArray(parsed.servedRuntimes) && parsed.servedRuntimes.every((version) => typeof version === "string"))) {
@@ -1326,7 +1340,7 @@ function readDaemonLockfile() {
       }
       return null;
     } finally {
-      import_node_fs3.default.closeSync(fd);
+      import_node_fs4.default.closeSync(fd);
     }
   } catch {
     return null;
@@ -1365,28 +1379,28 @@ function writeDaemonLockfile(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)}
+  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   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);
+    import_node_fs4.default.renameSync(tmp, lockfilePath);
   } finally {
     try {
-      import_node_fs3.default.unlinkSync(tmp);
+      import_node_fs4.default.unlinkSync(tmp);
     } catch {
     }
   }
 }
 function writeDevBridgeLockfile(data) {
-  import_node_fs3.default.mkdirSync(devBridgesDir(), { recursive: true });
+  import_node_fs4.default.mkdirSync(devBridgesDir(), { recursive: true });
   const lockfilePath = devBridgeLockfilePath(data.bridgePort);
   const tmp = `${lockfilePath}.${data.pid}.tmp`;
-  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
-  import_node_fs3.default.renameSync(tmp, lockfilePath);
+  import_node_fs4.default.renameSync(tmp, lockfilePath);
 }
 function sameDaemonOwner(left, right) {
   return left.pid === right.pid && left.startedAt === right.startedAt;
@@ -1397,17 +1411,17 @@ function isAlreadyExists(error) {
 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)}
+  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    import_node_fs3.default.linkSync(tmp, lockfilePath);
+    import_node_fs4.default.linkSync(tmp, lockfilePath);
     return true;
   } catch (error) {
     if (isAlreadyExists(error)) return false;
     throw error;
   } finally {
     try {
-      import_node_fs3.default.unlinkSync(tmp);
+      import_node_fs4.default.unlinkSync(tmp);
     } catch {
     }
   }
@@ -1431,7 +1445,7 @@ function parseDaemonClaim(raw) {
 }
 function readDaemonClaim() {
   try {
-    return parseDaemonClaim(import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8"));
+    return parseDaemonClaim(import_node_fs4.default.readFileSync(daemonClaimPath(), "utf8"));
   } catch {
     return null;
   }
@@ -1455,7 +1469,7 @@ function acquireDaemonClaim(data) {
 `;
   for (let attempt = 0; attempt < 8; attempt++) {
     try {
-      import_node_fs3.default.writeFileSync(daemonClaimPath(), serialized, { encoding: "utf8", flag: "wx" });
+      import_node_fs4.default.writeFileSync(daemonClaimPath(), serialized, { encoding: "utf8", flag: "wx" });
       return true;
     } catch (error) {
       if (!isAlreadyExists(error)) throw error;
@@ -1465,11 +1479,11 @@ function acquireDaemonClaim(data) {
     if (existing && isDaemonClaimFresh(existing)) return false;
     let before;
     try {
-      before = import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8");
+      before = import_node_fs4.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());
+      if (import_node_fs4.default.readFileSync(daemonClaimPath(), "utf8") !== before) continue;
+      import_node_fs4.default.unlinkSync(daemonClaimPath());
     } catch {
     }
   }
@@ -1479,7 +1493,7 @@ function releaseDaemonClaim(owner) {
   try {
     const claim = readDaemonClaim();
     if (!claim || !sameDaemonOwner(claim, owner)) return;
-    import_node_fs3.default.unlinkSync(daemonClaimPath());
+    import_node_fs4.default.unlinkSync(daemonClaimPath());
   } catch {
   }
 }
@@ -1498,7 +1512,7 @@ function claimDaemonLockfile(data) {
       if (!latest || !sameDaemonOwner(latest, existing)) return false;
       if (isDaemonLockfileFresh(latest)) return false;
       try {
-        import_node_fs3.default.unlinkSync(daemonLockfilePath());
+        import_node_fs4.default.unlinkSync(daemonLockfilePath());
       } catch {
         return false;
       }
@@ -1512,16 +1526,16 @@ function removeDaemonLockfile(owner) {
   try {
     const lockfile = readDaemonLockfile();
     if (!lockfile || !sameDaemonOwner(lockfile, owner)) return;
-    import_node_fs3.default.unlinkSync(daemonLockfilePath());
+    import_node_fs4.default.unlinkSync(daemonLockfilePath());
   } catch {
   }
 }
 function removeDevBridgeLockfile(owner) {
   try {
     const lockfilePath = devBridgeLockfilePath(owner.bridgePort);
-    const lockfile = parseDevBridgeLockfile(import_node_fs3.default.readFileSync(lockfilePath, "utf8"));
+    const lockfile = parseDevBridgeLockfile(import_node_fs4.default.readFileSync(lockfilePath, "utf8"));
     if (lockfile?.pid !== owner.pid || lockfile.startedAt !== owner.startedAt) return;
-    import_node_fs3.default.unlinkSync(lockfilePath);
+    import_node_fs4.default.unlinkSync(lockfilePath);
   } catch {
   }
 }
@@ -1534,21 +1548,21 @@ var import_url = require("url");
 // ../contrast-runtime-delivery/src/index.ts
 var import_node_child_process = require("node:child_process");
 var import_node_crypto2 = __toESM(require("node:crypto"), 1);
-var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_fs6 = __toESM(require("node:fs"), 1);
 var import_node_os2 = __toESM(require("node:os"), 1);
 var import_node_path6 = __toESM(require("node:path"), 1);
 var import_node_stream = require("node:stream");
 var import_promises3 = require("node:stream/promises");
 
 // ../contrast-runtime-delivery/src/product.ts
-var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_fs5 = __toESM(require("node:fs"), 1);
 var import_node_path5 = __toESM(require("node:path"), 1);
 function isValidRuntimeVersion(value) {
   return value.length <= 100 && /^[0-9A-Za-z][0-9A-Za-z._+-]*$/.test(value);
 }
 function listInstalledRuntimes(product) {
   try {
-    return import_node_fs4.default.readdirSync(product.runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
+    return import_node_fs5.default.readdirSync(product.runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
   } catch {
     return [];
   }
@@ -1584,7 +1598,7 @@ function createRuntimeDelivery(product) {
   function readConfig() {
     try {
       const parsed = JSON.parse(
-        import_node_fs5.default.readFileSync(product.configFile(), "utf8")
+        import_node_fs6.default.readFileSync(product.configFile(), "utf8")
       );
       return parsed && typeof parsed === "object" ? parsed : {};
     } catch {
@@ -1657,7 +1671,7 @@ function createRuntimeDelivery(product) {
     const setActive = opts.setActive !== false;
     const protectVersions = [version, ...opts.protectVersions ?? []];
     pruneLocalRetention({ protectVersions });
-    if (!opts.force && import_node_fs5.default.existsSync(import_node_path6.default.join(destDir, product.installedMarker))) {
+    if (!opts.force && import_node_fs6.default.existsSync(import_node_path6.default.join(destDir, product.installedMarker))) {
       if (setActive) product.writeActiveRuntime(version);
       pruneLocalRetention({ protectVersions });
       return {
@@ -1671,7 +1685,7 @@ function createRuntimeDelivery(product) {
       };
     }
     const tarUrl = entry.tarball || tarballUrl(version, cdnOrigin);
-    const downloadDir = import_node_fs5.default.mkdtempSync(
+    const downloadDir = import_node_fs6.default.mkdtempSync(
       import_node_path6.default.join(import_node_os2.default.tmpdir(), `${product.id}-runtime-download-`)
     );
     const runtimeArchivePath = import_node_path6.default.join(
@@ -1682,7 +1696,7 @@ function createRuntimeDelivery(product) {
       import_node_path6.default.dirname(destDir),
       `.installing-${version}-${process.pid}`
     );
-    import_node_fs5.default.rmSync(tmpDir, { recursive: true, force: true });
+    import_node_fs6.default.rmSync(tmpDir, { recursive: true, force: true });
     try {
       process.stderr.write(`${product.id}: downloading runtime ${version}\u2026
 `);
@@ -1695,20 +1709,20 @@ function createRuntimeDelivery(product) {
           `sha256 mismatch for runtime ${version}: expected ${entry.sha256}, actual ${actualSha}`
         );
       }
-      import_node_fs5.default.mkdirSync(tmpDir, { recursive: true });
+      import_node_fs6.default.mkdirSync(tmpDir, { recursive: true });
       await extractTarball(runtimeArchivePath, tmpDir);
-      if (!import_node_fs5.default.existsSync(import_node_path6.default.join(tmpDir, product.installedMarker))) {
+      if (!import_node_fs6.default.existsSync(import_node_path6.default.join(tmpDir, product.installedMarker))) {
         throw new Error(
           `extracted tarball for runtime ${version} is missing ${product.installedMarker}`
         );
       }
-      import_node_fs5.default.rmSync(destDir, { recursive: true, force: true });
-      import_node_fs5.default.renameSync(tmpDir, destDir);
+      import_node_fs6.default.rmSync(destDir, { recursive: true, force: true });
+      import_node_fs6.default.renameSync(tmpDir, destDir);
     } catch (err) {
-      import_node_fs5.default.rmSync(tmpDir, { recursive: true, force: true });
+      import_node_fs6.default.rmSync(tmpDir, { recursive: true, force: true });
       throw err;
     } finally {
-      import_node_fs5.default.rmSync(downloadDir, { recursive: true, force: true });
+      import_node_fs6.default.rmSync(downloadDir, { recursive: true, force: true });
     }
     if (setActive) product.writeActiveRuntime(version);
     pruneLocalRetention({ protectVersions });
@@ -1730,7 +1744,7 @@ function createRuntimeDelivery(product) {
     const pin = resolvePin();
     if (pin) {
       const activeVersion2 = product.readActiveRuntime();
-      const pinInstalled = import_node_fs5.default.existsSync(
+      const pinInstalled = import_node_fs6.default.existsSync(
         import_node_path6.default.join(product.runtimeDir(pin), product.installedMarker)
       );
       if (activeVersion2 === pin && pinInstalled) {
@@ -1780,7 +1794,7 @@ function createRuntimeDelivery(product) {
     }
     const activeVersion = product.readActiveRuntime();
     const activeDir = activeVersion ? product.runtimeDir(activeVersion) : null;
-    const activeInstalled = activeDir ? import_node_fs5.default.existsSync(import_node_path6.default.join(activeDir, product.installedMarker)) : false;
+    const activeInstalled = activeDir ? import_node_fs6.default.existsSync(import_node_path6.default.join(activeDir, product.installedMarker)) : false;
     const shouldInstall = !activeVersion || !activeInstalled || compareSemver(latestVersion, activeVersion) > 0;
     if (!shouldInstall) {
       return {
@@ -1855,7 +1869,7 @@ function createRuntimeDelivery(product) {
     let removeCacheFiles = [];
     if (markerOffset >= 0) {
       try {
-        removeCacheFiles = import_node_fs5.default.readdirSync(product.cacheDir(), { withFileTypes: true }).filter((entry) => {
+        removeCacheFiles = import_node_fs6.default.readdirSync(product.cacheDir(), { withFileTypes: true }).filter((entry) => {
           if (!entry.isFile()) return false;
           const complete = entry.name.startsWith(cachePrefix) && entry.name.endsWith(cacheSuffix);
           const partial = entry.name.startsWith(cachePrefix) && entry.name.endsWith(`${cacheSuffix}.partial`);
@@ -1875,10 +1889,10 @@ function createRuntimeDelivery(product) {
   function pruneLocalRetention(opts = {}) {
     const plan = planLocalRetention(opts);
     for (const version of plan.removeVersions) {
-      import_node_fs5.default.rmSync(product.runtimeDir(version), { recursive: true, force: true });
+      import_node_fs6.default.rmSync(product.runtimeDir(version), { recursive: true, force: true });
     }
     for (const cacheFile of plan.removeCacheFiles) {
-      import_node_fs5.default.rmSync(cacheFile, { force: true });
+      import_node_fs6.default.rmSync(cacheFile, { force: true });
     }
     return plan;
   }
@@ -1904,17 +1918,17 @@ async function downloadToFile(url, destPath) {
   if (!res.ok || !res.body) {
     throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`);
   }
-  import_node_fs5.default.mkdirSync(import_node_path6.default.dirname(destPath), { recursive: true });
+  import_node_fs6.default.mkdirSync(import_node_path6.default.dirname(destPath), { recursive: true });
   const tmp = `${destPath}.partial`;
   try {
     await (0, import_promises3.pipeline)(
       import_node_stream.Readable.fromWeb(res.body),
-      import_node_fs5.default.createWriteStream(tmp)
+      import_node_fs6.default.createWriteStream(tmp)
     );
-    import_node_fs5.default.renameSync(tmp, destPath);
+    import_node_fs6.default.renameSync(tmp, destPath);
   } catch (err) {
     try {
-      import_node_fs5.default.unlinkSync(tmp);
+      import_node_fs6.default.unlinkSync(tmp);
     } catch {
     }
     throw err;
@@ -1923,7 +1937,7 @@ async function downloadToFile(url, destPath) {
 function sha256File(filePath) {
   return new Promise((resolve2, reject) => {
     const hash = import_node_crypto2.default.createHash("sha256");
-    const stream = import_node_fs5.default.createReadStream(filePath);
+    const stream = import_node_fs6.default.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve2(hash.digest("hex")));
@@ -2033,13 +2047,13 @@ var SOOTSIM_RUNTIME_PRODUCT = {
 var sootsimRuntime = createRuntimeDelivery(SOOTSIM_RUNTIME_PRODUCT);
 
 // src/host/agent-host.ts
-var import_node_fs8 = __toESM(require("node:fs"), 1);
+var import_node_fs9 = __toESM(require("node:fs"), 1);
 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_crypto4 = require("node:crypto");
-var import_node_fs7 = __toESM(require("node:fs"), 1);
+var import_node_fs8 = __toESM(require("node:fs"), 1);
 var import_node_path8 = __toESM(require("node:path"), 1);
 var import_node_readline = __toESM(require("node:readline"), 1);
 
@@ -2084,7 +2098,7 @@ function encodeAgentPromptEnvelope(input) {
 
 // src/attached-projects.ts
 var import_node_crypto3 = require("node:crypto");
-var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_fs7 = __toESM(require("node:fs"), 1);
 var import_node_path7 = __toESM(require("node:path"), 1);
 var overrideDir = null;
 function userDataDir() {
@@ -2111,7 +2125,7 @@ function loadStore() {
   const file = storeFile();
   let raw;
   try {
-    raw = import_node_fs6.default.readFileSync(file, "utf8");
+    raw = import_node_fs7.default.readFileSync(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return cloneEmpty();
     throw err;
@@ -2128,7 +2142,7 @@ function loadStore() {
   } catch (err) {
     const quarantine = `${file}.corrupt-${Date.now()}`;
     try {
-      import_node_fs6.default.renameSync(file, quarantine);
+      import_node_fs7.default.renameSync(file, quarantine);
       console.warn(
         `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. original error: ${err.message}`
       );
@@ -2139,16 +2153,16 @@ function loadStore() {
 }
 function writeStore(store) {
   const file = storeFile();
-  import_node_fs6.default.mkdirSync(import_node_path7.default.dirname(file), { recursive: true });
+  import_node_fs7.default.mkdirSync(import_node_path7.default.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  const fd = import_node_fs6.default.openSync(tmp, "w", 384);
+  const fd = import_node_fs7.default.openSync(tmp, "w", 384);
   try {
-    import_node_fs6.default.writeFileSync(fd, JSON.stringify(store, null, 2));
-    import_node_fs6.default.fsyncSync(fd);
+    import_node_fs7.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs7.default.fsyncSync(fd);
   } finally {
-    import_node_fs6.default.closeSync(fd);
+    import_node_fs7.default.closeSync(fd);
   }
-  import_node_fs6.default.renameSync(tmp, file);
+  import_node_fs7.default.renameSync(tmp, file);
 }
 function mutateStore(fn) {
   const store = loadStore();
@@ -2335,7 +2349,7 @@ async function seedFromDemoAppRegistry() {
   if (apps.length === 0) return;
   mutateStore((store) => {
     for (const app of apps) {
-      if (!import_node_fs6.default.existsSync(app.dir)) continue;
+      if (!import_node_fs7.default.existsSync(app.dir)) continue;
       const cwd = import_node_path7.default.resolve(app.dir);
       const id = projectIdForCwd(cwd);
       if (store.attachedProjects.some((p) => p.id === id)) continue;
@@ -2379,7 +2393,7 @@ function pidIsAlive(pid, sessionId) {
     return false;
   }
   if (sessionId) {
-    if (!import_node_fs7.default.existsSync(sessionDir(sessionId))) return false;
+    if (!import_node_fs8.default.existsSync(sessionDir(sessionId))) return false;
   }
   return true;
 }
@@ -2395,7 +2409,7 @@ function resolveSootsimInvocation() {
         import_node_path8.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
       ];
       for (const c of candidates) {
-        if (import_node_fs7.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
+        if (import_node_fs8.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
       }
     }
   }
@@ -2419,14 +2433,14 @@ function tryWorkspaceSootsim() {
     if (!sootsimDir) return null;
     const binaryName = `sootsim-${process.platform}-${process.arch}`;
     const distBinary = import_node_path8.default.join(sootsimDir, "dist-bin", binaryName);
-    if (import_node_fs7.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
+    if (import_node_fs8.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
     const distBin = import_node_path8.default.join(sootsimDir, "dist-cli", "bin.js");
-    if (import_node_fs7.default.existsSync(distBin)) {
+    if (import_node_fs8.default.existsSync(distBin)) {
       try {
         const src = import_node_path8.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
-        if (import_node_fs7.default.existsSync(src)) {
-          const srcMtime = import_node_fs7.default.statSync(src).mtimeMs;
-          const buildMtime = import_node_fs7.default.statSync(distBin).mtimeMs;
+        if (import_node_fs8.default.existsSync(src)) {
+          const srcMtime = import_node_fs8.default.statSync(src).mtimeMs;
+          const buildMtime = import_node_fs8.default.statSync(distBin).mtimeMs;
           if (buildMtime < srcMtime) {
             console.warn(
               `[rnx] dist-cli/bin.js is older than agent-wrapper.ts \u2014 rebuild with \`bun run --cwd packages/sootsim build:cli\`.`
@@ -2454,8 +2468,8 @@ function resolveSootsimPackageDir() {
   for (let i = 0; i < 8; i++) {
     const pkg = import_node_path8.default.join(cur, "package.json");
     try {
-      if (import_node_fs7.default.existsSync(pkg)) {
-        const parsed = JSON.parse(import_node_fs7.default.readFileSync(pkg, "utf8"));
+      if (import_node_fs8.default.existsSync(pkg)) {
+        const parsed = JSON.parse(import_node_fs8.default.readFileSync(pkg, "utf8"));
         if (parsed.name === rnxPublicBrand.packageName) return cur;
       }
     } catch {
@@ -2477,9 +2491,9 @@ function fileFromImportMeta() {
 }
 async function withStartLock(projectId, provider, fn) {
   const lockDir = import_node_path8.default.join(getUserDataDir(), "locks");
-  import_node_fs7.default.mkdirSync(lockDir, { recursive: true });
+  import_node_fs8.default.mkdirSync(lockDir, { recursive: true });
   try {
-    import_node_fs7.default.chmodSync(lockDir, 448);
+    import_node_fs8.default.chmodSync(lockDir, 448);
   } catch {
   }
   const lockPath = import_node_path8.default.join(lockDir, `start-${projectId}-${provider}.lock`);
@@ -2487,17 +2501,17 @@ async function withStartLock(projectId, provider, fn) {
   let fd = null;
   while (fd === null) {
     try {
-      fd = import_node_fs7.default.openSync(
+      fd = import_node_fs8.default.openSync(
         lockPath,
-        import_node_fs7.constants.O_WRONLY | import_node_fs7.constants.O_CREAT | import_node_fs7.constants.O_EXCL,
+        import_node_fs8.constants.O_WRONLY | import_node_fs8.constants.O_CREAT | import_node_fs8.constants.O_EXCL,
         384
       );
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       try {
-        const stale = Number(import_node_fs7.default.readFileSync(lockPath, "utf8").trim());
+        const stale = Number(import_node_fs8.default.readFileSync(lockPath, "utf8").trim());
         if (stale && !isProcessAlive(stale)) {
-          import_node_fs7.default.unlinkSync(lockPath);
+          import_node_fs8.default.unlinkSync(lockPath);
           continue;
         }
       } catch {
@@ -2511,15 +2525,15 @@ async function withStartLock(projectId, provider, fn) {
     }
   }
   try {
-    import_node_fs7.default.writeFileSync(fd, String(process.pid));
+    import_node_fs8.default.writeFileSync(fd, String(process.pid));
     return await fn();
   } finally {
     try {
-      import_node_fs7.default.closeSync(fd);
+      import_node_fs8.default.closeSync(fd);
     } catch {
     }
     try {
-      import_node_fs7.default.unlinkSync(lockPath);
+      import_node_fs8.default.unlinkSync(lockPath);
     } catch {
     }
   }
@@ -2534,24 +2548,24 @@ function isProcessAlive(pid) {
 }
 function mkfifoSync(p) {
   const parent = import_node_path8.default.dirname(p);
-  import_node_fs7.default.mkdirSync(parent, { recursive: true });
+  import_node_fs8.default.mkdirSync(parent, { recursive: true });
   try {
-    import_node_fs7.default.chmodSync(parent, 448);
+    import_node_fs8.default.chmodSync(parent, 448);
   } catch {
   }
-  if (import_node_fs7.default.existsSync(p)) {
+  if (import_node_fs8.default.existsSync(p)) {
     try {
-      const stat2 = import_node_fs7.default.statSync(p);
+      const stat2 = import_node_fs8.default.statSync(p);
       if (stat2.isFIFO()) {
         try {
-          import_node_fs7.default.chmodSync(p, 384);
+          import_node_fs8.default.chmodSync(p, 384);
         } catch {
         }
         return;
       }
-      import_node_fs7.default.unlinkSync(p);
+      import_node_fs8.default.unlinkSync(p);
     } catch {
-      import_node_fs7.default.unlinkSync(p);
+      import_node_fs8.default.unlinkSync(p);
     }
   }
   const result = (0, import_node_child_process2.spawnSync)("mkfifo", ["-m", "600", p]);
@@ -2599,9 +2613,9 @@ async function startSession(opts) {
     mkfifoSync(promptIn);
     mkfifoSync(eventsOut);
     const transcriptDir = import_node_path8.default.dirname(transcript);
-    import_node_fs7.default.mkdirSync(transcriptDir, { recursive: true });
+    import_node_fs8.default.mkdirSync(transcriptDir, { recursive: true });
     try {
-      import_node_fs7.default.chmodSync(transcriptDir, 448);
+      import_node_fs8.default.chmodSync(transcriptDir, 448);
     } catch {
     }
     const { cmd, prefixArgs } = resolveSootsimInvocation();
@@ -2652,7 +2666,7 @@ async function startSession(opts) {
         }
       }
       try {
-        import_node_fs7.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
+        import_node_fs8.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
       } catch {
       }
       updateSessionStatus(session.id, { status: "ended" });
@@ -2680,18 +2694,18 @@ async function sendPrompt(sessionId, prompt) {
     );
   }
   const fifo = promptFifoPath(sessionId);
-  if (!import_node_fs7.default.existsSync(fifo)) {
+  if (!import_node_fs8.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `prompt FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs7.default.openSync(fifo, import_node_fs7.constants.O_WRONLY);
+  const fd = import_node_fs8.default.openSync(fifo, import_node_fs8.constants.O_WRONLY);
   try {
     const wireText = encodeAgentPromptEnvelope(prompt);
     if (!wireText) {
       throw new AgentSessionError("EMPTY_PROMPT", "prompt text is empty");
     }
-    import_node_fs7.default.writeSync(fd, wireText + "\n");
+    import_node_fs8.default.writeSync(fd, wireText + "\n");
   } finally {
-    import_node_fs7.default.closeSync(fd);
+    import_node_fs8.default.closeSync(fd);
   }
   updateSessionStatus(sessionId, {
     lastPrompt: prompt.displayText ?? prompt.text,
@@ -2713,7 +2727,7 @@ async function endSession(sessionId) {
   const base = getUserDataDir();
   if (dir.startsWith(base)) {
     try {
-      import_node_fs7.default.rmSync(dir, { recursive: true, force: true });
+      import_node_fs8.default.rmSync(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -2721,11 +2735,11 @@ async function endSession(sessionId) {
 }
 function subscribeEvents(sessionId, onEvent) {
   const fifo = eventsFifoPath(sessionId);
-  if (!import_node_fs7.default.existsSync(fifo)) {
+  if (!import_node_fs8.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `events FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs7.default.openSync(fifo, import_node_fs7.constants.O_RDWR);
-  const stream = import_node_fs7.default.createReadStream("", { fd, autoClose: true });
+  const fd = import_node_fs8.default.openSync(fifo, import_node_fs8.constants.O_RDWR);
+  const stream = import_node_fs8.default.createReadStream("", { fd, autoClose: true });
   const rl = import_node_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
   rl.on("line", (line) => {
     const event = parseAgentEventLine(line);
@@ -2736,7 +2750,7 @@ function subscribeEvents(sessionId, onEvent) {
     if (closed) return;
     closed = true;
     try {
-      import_node_fs7.default.writeSync(fd, "\n");
+      import_node_fs8.default.writeSync(fd, "\n");
     } catch {
     }
     try {
@@ -2750,7 +2764,7 @@ function subscribeEvents(sessionId, onEvent) {
   };
 }
 async function waitForFirstEvent(fifo, predicate, timeoutMs) {
-  const fd = import_node_fs7.default.openSync(fifo, import_node_fs7.constants.O_RDWR | import_node_fs7.constants.O_NONBLOCK);
+  const fd = import_node_fs8.default.openSync(fifo, import_node_fs8.constants.O_RDWR | import_node_fs8.constants.O_NONBLOCK);
   const buf = Buffer.alloc(8192);
   let leftover = "";
   const deadline = Date.now() + timeoutMs;
@@ -2758,7 +2772,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     while (Date.now() < deadline) {
       let n = 0;
       try {
-        n = import_node_fs7.default.readSync(fd, buf, 0, buf.length, null);
+        n = import_node_fs8.default.readSync(fd, buf, 0, buf.length, null);
       } catch (err) {
         if (err.code !== "EAGAIN") throw err;
         n = 0;
@@ -2778,7 +2792,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     }
     return null;
   } finally {
-    import_node_fs7.default.closeSync(fd);
+    import_node_fs8.default.closeSync(fd);
   }
 }
 
@@ -3067,10 +3081,10 @@ var AgentHost = class {
   }
   getTranscript(sessionId) {
     const p = transcriptPath(sessionId);
-    if (!import_node_fs8.default.existsSync(p)) {
+    if (!import_node_fs9.default.existsSync(p)) {
       return { error: "transcript not found", code: "NO_TRANSCRIPT" };
     }
-    return import_node_fs8.default.readFileSync(p, "utf8");
+    return import_node_fs9.default.readFileSync(p, "utf8");
   }
   getPaths() {
     const dir = getUserDataDir();
@@ -3766,13 +3780,13 @@ async function openUrl(url, options = {}) {
 }
 
 // src/host/plane-host.ts
-var import_node_fs10 = __toESM(require("node:fs"), 1);
+var import_node_fs11 = __toESM(require("node:fs"), 1);
 var import_node_path11 = __toESM(require("node:path"), 1);
 var import_plane = require("@contrast/harness/plane");
 
 // cli/commands/box/checkout-plane.ts
 var import_node_child_process4 = require("node:child_process");
-var import_node_fs9 = __toESM(require("node:fs"), 1);
+var import_node_fs10 = __toESM(require("node:fs"), 1);
 var import_node_path10 = __toESM(require("node:path"), 1);
 var CheckoutRequiresGitError = class extends Error {
 };
@@ -3782,14 +3796,14 @@ function looksBinary(filePath, size) {
   if (size === 0) return false;
   let fd;
   try {
-    fd = import_node_fs9.default.openSync(filePath, "r");
+    fd = import_node_fs10.default.openSync(filePath, "r");
     const buffer = Buffer.alloc(Math.min(BINARY_SNIFF_BYTES, size));
-    const read = import_node_fs9.default.readSync(fd, buffer, 0, buffer.length, 0);
+    const read = import_node_fs10.default.readSync(fd, buffer, 0, buffer.length, 0);
     return buffer.subarray(0, read).includes(0);
   } catch {
     return false;
   } finally {
-    if (fd !== void 0) import_node_fs9.default.closeSync(fd);
+    if (fd !== void 0) import_node_fs10.default.closeSync(fd);
   }
 }
 var CheckoutFilePlane = class {
@@ -3839,7 +3853,7 @@ var CheckoutFilePlane = class {
       if (!relative) continue;
       let stat2;
       try {
-        stat2 = import_node_fs9.default.statSync(import_node_path10.default.join(this.root, relative));
+        stat2 = import_node_fs10.default.statSync(import_node_path10.default.join(this.root, relative));
       } catch {
         continue;
       }
@@ -3866,15 +3880,15 @@ var CheckoutFilePlane = class {
     return resolved;
   }
   async read(planePath) {
-    return import_node_fs9.default.promises.readFile(this.absolute(planePath), "utf8");
+    return import_node_fs10.default.promises.readFile(this.absolute(planePath), "utf8");
   }
   async readBytes(planePath) {
-    return import_node_fs9.default.promises.readFile(this.absolute(planePath));
+    return import_node_fs10.default.promises.readFile(this.absolute(planePath));
   }
   async write(planePath, content) {
     const absolute = this.absolute(planePath);
-    await import_node_fs9.default.promises.mkdir(import_node_path10.default.dirname(absolute), { recursive: true });
-    await import_node_fs9.default.promises.writeFile(absolute, content);
+    await import_node_fs10.default.promises.mkdir(import_node_path10.default.dirname(absolute), { recursive: true });
+    await import_node_fs10.default.promises.writeFile(absolute, content);
     this.entries.set(planePath, {
       size: content.byteLength,
       readOnly: false,
@@ -3883,7 +3897,7 @@ var CheckoutFilePlane = class {
     });
   }
   async delete(planePath) {
-    await import_node_fs9.default.promises.rm(this.absolute(planePath), { force: true });
+    await import_node_fs10.default.promises.rm(this.absolute(planePath), { force: true });
     this.entries.delete(planePath);
   }
 };
@@ -4012,11 +4026,11 @@ var PlaneHost = class {
     const resolved = import_node_path11.default.resolve(root);
     let real;
     try {
-      real = import_node_fs10.default.realpathSync(resolved);
+      real = import_node_fs11.default.realpathSync(resolved);
     } catch {
       throw new Error(`no such directory: ${resolved}`);
     }
-    if (!import_node_fs10.default.statSync(real).isDirectory()) throw new Error(`not a directory: ${real}`);
+    if (!import_node_fs11.default.statSync(real).isDirectory()) throw new Error(`not a directory: ${real}`);
     return real;
   }
   respond(ws, id, result) {