sootsim 0.1.291 → 0.1.293

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

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.291 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.293 | (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;
@@ -142,6 +142,339 @@ function normalizeNativeDevBundleUrl(bundleUrl) {
   }
 }
 
+// src/settings-bundle.ts
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_plist = __toESM(require("@expo/plist"), 1);
+var MAX_PLIST_BYTES = 1048576;
+var MAX_CHILD_DEPTH = 8;
+var MAX_PLIST_FILES = 32;
+var MAX_SPECIFIERS = 512;
+var settingsBundleCache = /* @__PURE__ */ new Map();
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolvePlistParser(value) {
+  if (!isRecord(value)) return null;
+  const direct = value.parse;
+  if (typeof direct === "function") {
+    return (source) => Reflect.apply(direct, value, [source]);
+  }
+  const nested = value.default;
+  if (!isRecord(nested)) return null;
+  const nestedParse = nested.parse;
+  return typeof nestedParse === "function" ? (source) => Reflect.apply(nestedParse, nested, [source]) : null;
+}
+var parsePlist = resolvePlistParser(import_plist.default);
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function requiredString(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized ? normalized : null;
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function preferenceValue(value) {
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  return finiteNumber(value);
+}
+function keyboardType(value) {
+  if (typeof value !== "string") return void 0;
+  switch (value.replaceAll(/[-_\s]/g, "").toLowerCase()) {
+    case "alphabet":
+      return "alphabet";
+    case "numbersandpunctuation":
+      return "numbers-and-punctuation";
+    case "numberpad":
+      return "number-pad";
+    case "url":
+      return "url";
+    case "emailaddress":
+      return "email-address";
+    case "namephonepad":
+      return "name-phone-pad";
+    case "asciicapable":
+      return "ascii-capable";
+    default:
+      return void 0;
+  }
+}
+function autocapitalization(value) {
+  if (typeof value !== "string") return void 0;
+  switch (value.replaceAll(/[-_\s]/g, "").toLowerCase()) {
+    case "none":
+      return "none";
+    case "sentences":
+      return "sentences";
+    case "words":
+      return "words";
+    case "allcharacters":
+      return "all-characters";
+    default:
+      return void 0;
+  }
+}
+function autocorrection(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value !== "string") return void 0;
+  switch (value.trim().toLowerCase()) {
+    case "yes":
+      return true;
+    case "no":
+      return false;
+    default:
+      return void 0;
+  }
+}
+function safeChildPlistName(value) {
+  const file = requiredString(value);
+  if (!file || file.includes("/") || file.includes("\\") || file.includes("..")) {
+    return null;
+  }
+  return {
+    file,
+    name: file.toLowerCase().endsWith(".plist") ? file : `${file}.plist`
+  };
+}
+async function readableSettingsBundle(path9) {
+  try {
+    const root = await (0, import_promises.stat)((0, import_node_path.join)(path9, "Root.plist"));
+    return root.isFile() && root.size <= MAX_PLIST_BYTES;
+  } catch {
+    return false;
+  }
+}
+async function findSettingsBundle(projectRoot) {
+  const directCandidates = [
+    (0, import_node_path.join)(projectRoot, "Settings.bundle"),
+    (0, import_node_path.join)(projectRoot, "ios", "Settings.bundle")
+  ];
+  for (const candidate of directCandidates) {
+    if (await readableSettingsBundle(candidate)) return candidate;
+  }
+  try {
+    const iosRoot = (0, import_node_path.join)(projectRoot, "ios");
+    const children = await (0, import_promises.readdir)(iosRoot, { withFileTypes: true });
+    const candidates = children.filter(
+      (entry) => entry.isDirectory() && entry.name !== "Pods" && entry.name !== "build" && !entry.name.startsWith(".")
+    ).map((entry) => (0, import_node_path.join)(iosRoot, entry.name, "Settings.bundle")).sort();
+    for (const candidate of candidates) {
+      if (await readableSettingsBundle(candidate)) return candidate;
+    }
+  } catch {
+  }
+  return null;
+}
+async function settingsBundleFingerprint(bundlePath) {
+  try {
+    const entries = await (0, import_promises.readdir)(bundlePath, { withFileTypes: true });
+    const names = entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".plist")).map((entry) => entry.name).sort().slice(0, MAX_PLIST_FILES + 1);
+    if (names.length === 0 || names.length > MAX_PLIST_FILES) return null;
+    const parts = await Promise.all(
+      names.map(async (name) => {
+        const metadata = await (0, import_promises.stat)((0, import_node_path.join)(bundlePath, name));
+        if (!metadata.isFile() || metadata.size > MAX_PLIST_BYTES) return null;
+        return `${name}:${metadata.size}:${metadata.mtimeMs}:${metadata.ctimeMs}`;
+      })
+    );
+    if (parts.some((part) => part === null)) return null;
+    return parts.join("|");
+  } catch {
+    return null;
+  }
+}
+async function parsePlistRecord(path9) {
+  try {
+    if (!parsePlist) return null;
+    const metadata = await (0, import_promises.stat)(path9);
+    if (!metadata.isFile() || metadata.size > MAX_PLIST_BYTES) return null;
+    const source = await (0, import_promises.readFile)(path9, "utf8");
+    const parsed = parsePlist(source);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeMultiValue(raw, key, title) {
+  if (!Array.isArray(raw.Values) || !Array.isArray(raw.Titles)) return null;
+  const values = [];
+  const titles = [];
+  let optionType;
+  const pairCount = Math.min(raw.Values.length, raw.Titles.length);
+  for (let index = 0; index < pairCount; index++) {
+    const value = preferenceValue(raw.Values[index]);
+    const optionTitle = optionalString(raw.Titles[index]);
+    if (value === null || optionTitle === void 0) continue;
+    const valueType = typeof value === "string" ? "string" : typeof value === "number" ? "number" : "boolean";
+    if (optionType !== void 0 && valueType !== optionType) continue;
+    optionType = valueType;
+    values.push(value);
+    titles.push(optionTitle);
+  }
+  const firstValue = values[0];
+  if (firstValue === void 0) return null;
+  const declaredDefault = preferenceValue(raw.DefaultValue);
+  const defaultValue = declaredDefault !== null && values.includes(declaredDefault) ? declaredDefault : firstValue;
+  return {
+    type: "multi-value",
+    key,
+    title,
+    defaultValue,
+    currentValue: defaultValue,
+    values,
+    titles
+  };
+}
+async function normalizeSpecifier(raw, context) {
+  if (!isRecord(raw)) return null;
+  if (context.budget.specifiers >= MAX_SPECIFIERS) return null;
+  const type = requiredString(raw.Type);
+  if (!type) return null;
+  context.budget.specifiers += 1;
+  if (type === "PSGroupSpecifier") {
+    const title2 = optionalString(raw.Title);
+    const footer = optionalString(raw.FooterText);
+    return {
+      type: "group",
+      ...title2 !== void 0 ? { title: title2 } : null,
+      ...footer !== void 0 ? { footer } : null
+    };
+  }
+  const key = requiredString(raw.Key);
+  if (type === "PSSliderSpecifier") {
+    if (!key) return null;
+    const minimumValue = finiteNumber(raw.MinimumValue);
+    const maximumValue = finiteNumber(raw.MaximumValue);
+    if (minimumValue === null || maximumValue === null || maximumValue <= minimumValue) {
+      return null;
+    }
+    const declaredDefault = finiteNumber(raw.DefaultValue);
+    const defaultValue = Math.min(
+      maximumValue,
+      Math.max(minimumValue, declaredDefault ?? minimumValue)
+    );
+    const title2 = optionalString(raw.Title);
+    const minimumValueImage = optionalString(raw.MinimumValueImage);
+    const maximumValueImage = optionalString(raw.MaximumValueImage);
+    return {
+      type: "slider",
+      key,
+      defaultValue,
+      currentValue: defaultValue,
+      minimumValue,
+      maximumValue,
+      ...title2 !== void 0 ? { title: title2 } : null,
+      ...minimumValueImage !== void 0 ? { minimumValueImage } : null,
+      ...maximumValueImage !== void 0 ? { maximumValueImage } : null
+    };
+  }
+  if (type === "PSChildPaneSpecifier") {
+    const title2 = requiredString(raw.Title);
+    const child = safeChildPlistName(raw.File);
+    if (!title2 || !child || context.depth >= MAX_CHILD_DEPTH) return null;
+    const childSpecifiers = await parseSpecifierFile(child.name, {
+      ...context,
+      depth: context.depth + 1
+    });
+    if (!childSpecifiers || childSpecifiers.length === 0) return null;
+    return {
+      type: "child-pane",
+      title: title2,
+      file: child.file,
+      specifiers: childSpecifiers
+    };
+  }
+  if (!key) return null;
+  const title = requiredString(raw.Title) ?? key;
+  if (type === "PSToggleSwitchSpecifier") {
+    const defaultValue = typeof raw.DefaultValue === "boolean" ? raw.DefaultValue : false;
+    return {
+      type: "toggle",
+      key,
+      title,
+      defaultValue,
+      currentValue: defaultValue
+    };
+  }
+  if (type === "PSTextFieldSpecifier") {
+    const defaultValue = optionalString(raw.DefaultValue) ?? "";
+    const placeholder = optionalString(raw.Placeholder);
+    const resolvedKeyboardType = keyboardType(raw.KeyboardType);
+    const resolvedAutocapitalization = autocapitalization(raw.AutocapitalizationType);
+    const resolvedAutocorrection = autocorrection(raw.AutocorrectionType);
+    return {
+      type: "text",
+      key,
+      title,
+      defaultValue,
+      currentValue: defaultValue,
+      ...placeholder !== void 0 ? { placeholder } : null,
+      ...typeof raw.IsSecure === "boolean" ? { secure: raw.IsSecure } : null,
+      ...resolvedKeyboardType ? { keyboardType: resolvedKeyboardType } : null,
+      ...resolvedAutocapitalization ? { autocapitalization: resolvedAutocapitalization } : null,
+      ...resolvedAutocorrection !== void 0 ? { autocorrection: resolvedAutocorrection } : null
+    };
+  }
+  if (type === "PSMultiValueSpecifier" || type === "PSRadioGroupSpecifier") {
+    return normalizeMultiValue(raw, key, title);
+  }
+  if (type === "PSTitleValueSpecifier") {
+    const defaultValue = preferenceValue(raw.DefaultValue) ?? "";
+    return {
+      type: "title-value",
+      key,
+      title,
+      defaultValue,
+      currentValue: defaultValue
+    };
+  }
+  return null;
+}
+async function parseSpecifierFile(fileName, context) {
+  const cached3 = context.fileCache.get(fileName);
+  if (cached3 !== void 0) return cached3;
+  if (context.stack.has(fileName) || context.budget.files >= MAX_PLIST_FILES) {
+    return null;
+  }
+  context.budget.files += 1;
+  const root = await parsePlistRecord((0, import_node_path.join)(context.bundlePath, fileName));
+  if (!root || !Array.isArray(root.PreferenceSpecifiers)) {
+    context.fileCache.set(fileName, null);
+    return null;
+  }
+  const stack = new Set(context.stack);
+  stack.add(fileName);
+  const specifiers = [];
+  for (const raw of root.PreferenceSpecifiers) {
+    if (context.budget.specifiers >= MAX_SPECIFIERS) break;
+    const specifier = await normalizeSpecifier(raw, { ...context, stack });
+    if (specifier) specifiers.push(specifier);
+  }
+  context.fileCache.set(fileName, specifiers);
+  return specifiers;
+}
+async function readAppSettingsBundle(projectRoot) {
+  const bundlePath = await findSettingsBundle(projectRoot);
+  if (!bundlePath) return null;
+  const fingerprint = await settingsBundleFingerprint(bundlePath);
+  if (!fingerprint) return null;
+  const cached3 = settingsBundleCache.get(bundlePath);
+  if (cached3?.fingerprint === fingerprint) return cached3.specifiers;
+  const specifiers = await parseSpecifierFile("Root.plist", {
+    bundlePath,
+    depth: 0,
+    budget: { files: 0, specifiers: 0 },
+    stack: /* @__PURE__ */ new Set(),
+    fileCache: /* @__PURE__ */ new Map()
+  });
+  const normalized = specifiers && specifiers.length > 0 ? specifiers : null;
+  settingsBundleCache.set(bundlePath, { fingerprint, specifiers: normalized });
+  return normalized;
+}
+
 // scripts/dev-server-scanner.ts
 init_optional_demo_registry();
 var execP = (0, import_util.promisify)(import_child_process.exec);
@@ -508,6 +841,16 @@ function __shouldReuseScannerCacheEntry(entry, pid, now = Date.now()) {
   if (isWeakCachedResult(entry.result) && ageMs >= WEAK_RESULT_CACHE_TTL_MS) return false;
   return true;
 }
+async function attachAppSettingsBundle(result, projectRoot) {
+  const settingsBundle = await readAppSettingsBundle(projectRoot);
+  if (settingsBundle) {
+    result.settingsBundle = settingsBundle;
+    result.settingsStorageScopeUrl = result.bundleUrl;
+  } else {
+    delete result.settingsBundle;
+    delete result.settingsStorageScopeUrl;
+  }
+}
 async function scanDevServers(opts = {}) {
   await loadOptionalDemoApps();
   const processes = await discoverListeningProcesses(opts.excludePorts);
@@ -563,7 +906,9 @@ async function scanDevServers(opts = {}) {
       if (!pid) return;
       result.pid = pid;
       const cwd = await resolveProcessCwd(pid);
-      if (cwd) result.cwd = cwd;
+      if (!cwd) return;
+      result.cwd = cwd;
+      await attachAppSettingsBundle(result, cwd);
     })
   );
   const livePids = new Set(pidByPort.values());
@@ -606,7 +951,7 @@ function getCliVersion() {
 // src/home-paths.ts
 var import_node_fs2 = __toESM(require("node:fs"), 1);
 var import_node_os = require("node:os");
-var import_node_path = __toESM(require("node:path"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
 var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
 var ACTIVE_RUNTIME_FILE = "active";
 var DAEMON_LOCKFILE = "daemon.json";
@@ -615,8 +960,8 @@ var CONFIG_FILE = "config.json";
 var DAEMON_HEARTBEAT_STALE_MS = 3e4;
 function sootsimHomeDir() {
   const override = process.env[SOOTSIM_HOME_ENV];
-  if (override && override.length > 0) return import_node_path.default.resolve(override);
-  return import_node_path.default.join((0, import_node_os.homedir)(), ".sootsim");
+  if (override && override.length > 0) return import_node_path2.default.resolve(override);
+  return import_node_path2.default.join((0, import_node_os.homedir)(), ".sootsim");
 }
 function isSootsimDevCheckout() {
   if (process.env.SOOTSIM_FORCE_DAEMON_INSTALL === "1") return false;
@@ -627,40 +972,40 @@ function isSootsimDevCheckout() {
   if (!argv1) return false;
   try {
     const real = import_node_fs2.default.realpathSync(argv1);
-    return real.includes(`${import_node_path.default.sep}packages${import_node_path.default.sep}sootsim${import_node_path.default.sep}`);
+    return real.includes(`${import_node_path2.default.sep}packages${import_node_path2.default.sep}sootsim${import_node_path2.default.sep}`);
   } catch {
     return false;
   }
 }
 function runtimesDir() {
-  return import_node_path.default.join(sootsimHomeDir(), "runtimes");
+  return import_node_path2.default.join(sootsimHomeDir(), "runtimes");
 }
 function runtimeDir(version) {
-  return import_node_path.default.join(runtimesDir(), version);
+  return import_node_path2.default.join(runtimesDir(), version);
 }
 function activeRuntimeFile() {
-  return import_node_path.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+  return import_node_path2.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
 }
 function electronDir() {
-  return import_node_path.default.join(sootsimHomeDir(), "electron");
+  return import_node_path2.default.join(sootsimHomeDir(), "electron");
 }
 function electronUserDataDir() {
-  return import_node_path.default.join(electronDir(), "userData");
+  return import_node_path2.default.join(electronDir(), "userData");
 }
 function profilesDir() {
-  return import_node_path.default.join(sootsimHomeDir(), "profiles");
+  return import_node_path2.default.join(sootsimHomeDir(), "profiles");
 }
 function cacheDir() {
-  return import_node_path.default.join(sootsimHomeDir(), "cache");
+  return import_node_path2.default.join(sootsimHomeDir(), "cache");
 }
 function daemonLockfilePath() {
-  return import_node_path.default.join(sootsimHomeDir(), DAEMON_LOCKFILE);
+  return import_node_path2.default.join(sootsimHomeDir(), DAEMON_LOCKFILE);
 }
 function devBridgeLockfilePath() {
-  return import_node_path.default.join(sootsimHomeDir(), DEV_BRIDGE_LOCKFILE);
+  return import_node_path2.default.join(sootsimHomeDir(), DEV_BRIDGE_LOCKFILE);
 }
 function configFilePath() {
-  return import_node_path.default.join(sootsimHomeDir(), CONFIG_FILE);
+  return import_node_path2.default.join(sootsimHomeDir(), CONFIG_FILE);
 }
 function readSharedConfig() {
   try {
@@ -688,7 +1033,7 @@ function writeSharedConfig(patch) {
   return next;
 }
 function runtimeUpgradeNoticePath() {
-  return import_node_path.default.join(sootsimHomeDir(), "runtime-upgraded.json");
+  return import_node_path2.default.join(sootsimHomeDir(), "runtime-upgraded.json");
 }
 function writeRuntimeUpgradeNotice(notice) {
   ensureSootsimHome();
@@ -826,13 +1171,13 @@ function resolveDevCheckoutRuntimeRoot() {
 var import_node_child_process = require("node:child_process");
 var import_node_crypto = __toESM(require("node:crypto"), 1);
 var import_node_fs4 = __toESM(require("node:fs"), 1);
-var import_node_path3 = __toESM(require("node:path"), 1);
+var import_node_path4 = __toESM(require("node:path"), 1);
 var import_node_stream = require("node:stream");
-var import_promises = require("node:stream/promises");
+var import_promises2 = require("node:stream/promises");
 
 // ../contrast-runtime-delivery/src/product.ts
 var import_node_fs3 = __toESM(require("node:fs"), 1);
-var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
 function listInstalledRuntimes(product) {
   try {
     return import_node_fs3.default.readdirSync(product.runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
@@ -841,7 +1186,7 @@ function listInstalledRuntimes(product) {
   }
 }
 function runtimeTarballCacheName(product, version) {
-  return import_node_path2.default.posix.basename(product.tarballPath(version));
+  return import_node_path3.default.posix.basename(product.tarballPath(version));
 }
 function compareSemver(a, b) {
   const parse = (v) => {
@@ -933,7 +1278,7 @@ function createRuntimeDelivery(product) {
     const destDir = product.runtimeDir(version);
     const setActive = opts.setActive !== false;
     pruneLocalRetention({ protectVersions: [version] });
-    if (!opts.force && import_node_fs4.default.existsSync(import_node_path3.default.join(destDir, product.installedMarker))) {
+    if (!opts.force && import_node_fs4.default.existsSync(import_node_path4.default.join(destDir, product.installedMarker))) {
       if (setActive) product.writeActiveRuntime(version);
       pruneLocalRetention({ protectVersions: [version] });
       return {
@@ -947,7 +1292,7 @@ function createRuntimeDelivery(product) {
       };
     }
     const tarUrl = entry.tarball || tarballUrl(version, cdnOrigin);
-    const tarCachePath = import_node_path3.default.join(
+    const tarCachePath = import_node_path4.default.join(
       product.cacheDir(),
       runtimeTarballCacheName(product, version)
     );
@@ -956,8 +1301,8 @@ function createRuntimeDelivery(product) {
     await downloadToFile(tarUrl, tarCachePath);
     process.stderr.write(`${product.id}: extracting runtime ${version}\u2026
 `);
-    const tmpDir = import_node_path3.default.join(
-      import_node_path3.default.dirname(destDir),
+    const tmpDir = import_node_path4.default.join(
+      import_node_path4.default.dirname(destDir),
       `.installing-${version}-${process.pid}`
     );
     import_node_fs4.default.rmSync(tmpDir, { recursive: true, force: true });
@@ -970,7 +1315,7 @@ function createRuntimeDelivery(product) {
       }
       import_node_fs4.default.mkdirSync(tmpDir, { recursive: true });
       await extractTarball(tarCachePath, tmpDir);
-      if (!import_node_fs4.default.existsSync(import_node_path3.default.join(tmpDir, product.installedMarker))) {
+      if (!import_node_fs4.default.existsSync(import_node_path4.default.join(tmpDir, product.installedMarker))) {
         throw new Error(
           `extracted tarball for runtime ${version} is missing ${product.installedMarker}`
         );
@@ -1004,7 +1349,7 @@ function createRuntimeDelivery(product) {
     if (pin) {
       const activeVersion2 = product.readActiveRuntime();
       const pinInstalled = import_node_fs4.default.existsSync(
-        import_node_path3.default.join(product.runtimeDir(pin), product.installedMarker)
+        import_node_path4.default.join(product.runtimeDir(pin), product.installedMarker)
       );
       if (activeVersion2 === pin && pinInstalled) {
         return {
@@ -1052,7 +1397,7 @@ function createRuntimeDelivery(product) {
     }
     const activeVersion = product.readActiveRuntime();
     const activeDir = activeVersion ? product.runtimeDir(activeVersion) : null;
-    const activeInstalled = activeDir ? import_node_fs4.default.existsSync(import_node_path3.default.join(activeDir, product.installedMarker)) : false;
+    const activeInstalled = activeDir ? import_node_fs4.default.existsSync(import_node_path4.default.join(activeDir, product.installedMarker)) : false;
     const shouldInstall = !activeVersion || !activeInstalled || compareSemver(latestVersion, activeVersion) > 0;
     if (!shouldInstall) {
       return {
@@ -1128,7 +1473,7 @@ function createRuntimeDelivery(product) {
           const complete = entry.name.startsWith(cachePrefix) && entry.name.endsWith(cacheSuffix);
           const partial = entry.name.startsWith(cachePrefix) && entry.name.endsWith(`${cacheSuffix}.partial`);
           return complete || partial;
-        }).map((entry) => import_node_path3.default.join(product.cacheDir(), entry.name)).sort();
+        }).map((entry) => import_node_path4.default.join(product.cacheDir(), entry.name)).sort();
       } catch {
       }
     }
@@ -1172,10 +1517,10 @@ async function downloadToFile(url, destPath) {
   if (!res.ok || !res.body) {
     throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`);
   }
-  import_node_fs4.default.mkdirSync(import_node_path3.default.dirname(destPath), { recursive: true });
+  import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(destPath), { recursive: true });
   const tmp = `${destPath}.partial`;
   try {
-    await (0, import_promises.pipeline)(
+    await (0, import_promises2.pipeline)(
       import_node_stream.Readable.fromWeb(res.body),
       import_node_fs4.default.createWriteStream(tmp)
     );
@@ -1238,13 +1583,13 @@ var sootsimRuntime = createRuntimeDelivery(SOOTSIM_RUNTIME_PRODUCT);
 
 // src/host/agent-host.ts
 var import_node_fs7 = __toESM(require("node:fs"), 1);
-var import_node_path6 = __toESM(require("node:path"), 1);
+var import_node_path7 = __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_fs6 = __toESM(require("node:fs"), 1);
-var import_node_path5 = __toESM(require("node:path"), 1);
+var import_node_path6 = __toESM(require("node:path"), 1);
 var import_node_readline = __toESM(require("node:readline"), 1);
 
 // src/agent-events.ts
@@ -1289,7 +1634,7 @@ function encodeAgentPromptEnvelope(input) {
 // src/attached-projects.ts
 var import_node_crypto2 = require("node:crypto");
 var import_node_fs5 = __toESM(require("node:fs"), 1);
-var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
 var overrideDir = null;
 function userDataDir() {
   if (overrideDir) return overrideDir;
@@ -1301,7 +1646,7 @@ function getUserDataDir() {
   return userDataDir();
 }
 function storeFile() {
-  return import_node_path4.default.join(userDataDir(), "attached-projects.json");
+  return import_node_path5.default.join(userDataDir(), "attached-projects.json");
 }
 function cloneEmpty() {
   return {
@@ -1343,7 +1688,7 @@ function loadStore() {
 }
 function writeStore(store) {
   const file = storeFile();
-  import_node_fs5.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true });
+  import_node_fs5.default.mkdirSync(import_node_path5.default.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
   const fd = import_node_fs5.default.openSync(tmp, "w", 384);
   try {
@@ -1361,13 +1706,13 @@ function mutateStore(fn) {
   return store;
 }
 function projectIdForCwd(cwd) {
-  return (0, import_node_crypto2.createHash)("sha256").update(import_node_path4.default.resolve(cwd)).digest("hex").slice(0, 16);
+  return (0, import_node_crypto2.createHash)("sha256").update(import_node_path5.default.resolve(cwd)).digest("hex").slice(0, 16);
 }
 function newSessionId() {
   return `s_${(0, import_node_crypto2.randomBytes)(10).toString("hex")}`;
 }
 function upsertProject(input) {
-  const cwd = import_node_path4.default.resolve(input.cwd);
+  const cwd = import_node_path5.default.resolve(input.cwd);
   const id = projectIdForCwd(cwd);
   let result;
   mutateStore((store) => {
@@ -1393,7 +1738,7 @@ function upsertProject(input) {
     const now = Date.now();
     const created = {
       id,
-      name: input.name ?? import_node_path4.default.basename(cwd),
+      name: input.name ?? import_node_path5.default.basename(cwd),
       cwd,
       repoRoot: input.repoRoot,
       sourceRoots: input.sourceRoots ?? [cwd],
@@ -1540,7 +1885,7 @@ async function seedFromDemoAppRegistry() {
   mutateStore((store) => {
     for (const app of apps) {
       if (!import_node_fs5.default.existsSync(app.dir)) continue;
-      const cwd = import_node_path4.default.resolve(app.dir);
+      const cwd = import_node_path5.default.resolve(app.dir);
       const id = projectIdForCwd(cwd);
       if (store.attachedProjects.some((p) => p.id === id)) continue;
       const now = Date.now();
@@ -1564,16 +1909,16 @@ async function seedFromDemoAppRegistry() {
 
 // src/agent-sessions.ts
 function sessionDir(sessionId) {
-  return import_node_path5.default.join(getUserDataDir(), "sessions", sessionId);
+  return import_node_path6.default.join(getUserDataDir(), "sessions", sessionId);
 }
 function promptFifoPath(sessionId) {
-  return import_node_path5.default.join(sessionDir(sessionId), "prompt.in");
+  return import_node_path6.default.join(sessionDir(sessionId), "prompt.in");
 }
 function eventsFifoPath(sessionId) {
-  return import_node_path5.default.join(sessionDir(sessionId), "events.out");
+  return import_node_path6.default.join(sessionDir(sessionId), "events.out");
 }
 function transcriptPath(sessionId) {
-  return import_node_path5.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
+  return import_node_path6.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
 }
 function pidIsAlive(pid, sessionId) {
   if (!pid) return false;
@@ -1595,8 +1940,8 @@ function resolveSootsimInvocation() {
     const resourcesPath = process.resourcesPath;
     if (resourcesPath) {
       const candidates = [
-        import_node_path5.default.join(resourcesPath, "bin", "sootsim"),
-        import_node_path5.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
+        import_node_path6.default.join(resourcesPath, "bin", "sootsim"),
+        import_node_path6.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
       ];
       for (const c of candidates) {
         if (import_node_fs6.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
@@ -1622,12 +1967,12 @@ function tryWorkspaceSootsim() {
     const sootsimDir = resolveSootsimPackageDir();
     if (!sootsimDir) return null;
     const binaryName = `sootsim-${process.platform}-${process.arch}`;
-    const distBinary = import_node_path5.default.join(sootsimDir, "dist-bin", binaryName);
+    const distBinary = import_node_path6.default.join(sootsimDir, "dist-bin", binaryName);
     if (import_node_fs6.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
-    const distBin = import_node_path5.default.join(sootsimDir, "dist-cli", "bin.js");
+    const distBin = import_node_path6.default.join(sootsimDir, "dist-cli", "bin.js");
     if (import_node_fs6.default.existsSync(distBin)) {
       try {
-        const src = import_node_path5.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
+        const src = import_node_path6.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
         if (import_node_fs6.default.existsSync(src)) {
           const srcMtime = import_node_fs6.default.statSync(src).mtimeMs;
           const buildMtime = import_node_fs6.default.statSync(distBin).mtimeMs;
@@ -1649,14 +1994,14 @@ function tryWorkspaceSootsim() {
 function resolveSootsimPackageDir() {
   try {
     const resolved = require.resolve("sootsim/package.json");
-    return import_node_path5.default.dirname(resolved);
+    return import_node_path6.default.dirname(resolved);
   } catch {
   }
   const here = fileFromImportMeta();
   if (!here) return null;
-  let cur = import_node_path5.default.dirname(here);
+  let cur = import_node_path6.default.dirname(here);
   for (let i = 0; i < 8; i++) {
-    const pkg = import_node_path5.default.join(cur, "package.json");
+    const pkg = import_node_path6.default.join(cur, "package.json");
     try {
       if (import_node_fs6.default.existsSync(pkg)) {
         const parsed = JSON.parse(import_node_fs6.default.readFileSync(pkg, "utf8"));
@@ -1664,7 +2009,7 @@ function resolveSootsimPackageDir() {
       }
     } catch {
     }
-    const parent = import_node_path5.default.dirname(cur);
+    const parent = import_node_path6.default.dirname(cur);
     if (parent === cur) break;
     cur = parent;
   }
@@ -1680,13 +2025,13 @@ function fileFromImportMeta() {
   }
 }
 async function withStartLock(projectId, provider, fn) {
-  const lockDir = import_node_path5.default.join(getUserDataDir(), "locks");
+  const lockDir = import_node_path6.default.join(getUserDataDir(), "locks");
   import_node_fs6.default.mkdirSync(lockDir, { recursive: true });
   try {
     import_node_fs6.default.chmodSync(lockDir, 448);
   } catch {
   }
-  const lockPath = import_node_path5.default.join(lockDir, `start-${projectId}-${provider}.lock`);
+  const lockPath = import_node_path6.default.join(lockDir, `start-${projectId}-${provider}.lock`);
   const deadline = Date.now() + 4e3;
   let fd = null;
   while (fd === null) {
@@ -1737,7 +2082,7 @@ function isProcessAlive(pid) {
   }
 }
 function mkfifoSync(p) {
-  const parent = import_node_path5.default.dirname(p);
+  const parent = import_node_path6.default.dirname(p);
   import_node_fs6.default.mkdirSync(parent, { recursive: true });
   try {
     import_node_fs6.default.chmodSync(parent, 448);
@@ -1745,8 +2090,8 @@ function mkfifoSync(p) {
   }
   if (import_node_fs6.default.existsSync(p)) {
     try {
-      const stat = import_node_fs6.default.statSync(p);
-      if (stat.isFIFO()) {
+      const stat2 = import_node_fs6.default.statSync(p);
+      if (stat2.isFIFO()) {
         try {
           import_node_fs6.default.chmodSync(p, 384);
         } catch {
@@ -1802,7 +2147,7 @@ async function startSession(opts) {
     const transcript = transcriptPath(session.id);
     mkfifoSync(promptIn);
     mkfifoSync(eventsOut);
-    const transcriptDir = import_node_path5.default.dirname(transcript);
+    const transcriptDir = import_node_path6.default.dirname(transcript);
     import_node_fs6.default.mkdirSync(transcriptDir, { recursive: true });
     try {
       import_node_fs6.default.chmodSync(transcriptDir, 448);
@@ -2260,7 +2605,7 @@ var AgentHost = class {
     );
     const project = upsertProject({
       cwd: match.cwd,
-      name: match.projectName ?? import_node_path6.default.basename(match.cwd),
+      name: match.projectName ?? import_node_path7.default.basename(match.cwd),
       preferredProvider: input.provider ?? existing?.preferredProvider,
       sourceRoots: existing?.sourceRoots ?? [match.cwd],
       knownBundleUrls,
@@ -2280,9 +2625,9 @@ var AgentHost = class {
     const dir = getUserDataDir();
     return {
       userDataDir: dir,
-      storeFile: import_node_path6.default.join(dir, "attached-projects.json"),
-      sessionsDir: import_node_path6.default.join(dir, "sessions"),
-      transcriptsDir: import_node_path6.default.join(dir, "transcripts")
+      storeFile: import_node_path7.default.join(dir, "attached-projects.json"),
+      sessionsDir: import_node_path7.default.join(dir, "sessions"),
+      transcriptsDir: import_node_path7.default.join(dir, "transcripts")
     };
   }
   // --- subscription management ---
@@ -2580,7 +2925,7 @@ function mapFrameworkToProjectFramework(fw) {
 // src/host/fetch-proxy-handler.ts
 var import_http2 = __toESM(require("http"), 1);
 var import_https = __toESM(require("https"), 1);
-var import_promises2 = require("stream/promises");
+var import_promises3 = require("stream/promises");
 
 // src/backend-origin.ts
 function normalizeHostname(hostname) {
@@ -2792,7 +3137,7 @@ async function handleFetchProxyRequest(req, res) {
       const switchToGet = (status === 301 || status === 302) && method === "POST" || status === 303 && method !== "GET" && method !== "HEAD";
       const redirectUrl = new URL(location, targetUrl2);
       proxyRes.resume();
-      await (0, import_promises2.finished)(proxyRes);
+      await (0, import_promises3.finished)(proxyRes);
       await proxy(
         redirectUrl,
         switchToGet ? "GET" : method,
@@ -2817,7 +3162,7 @@ async function handleFetchProxyRequest(req, res) {
       );
     }
     res.statusCode = status;
-    await (0, import_promises2.pipeline)(proxyRes, res);
+    await (0, import_promises3.pipeline)(proxyRes, res);
   };
   try {
     await proxy(upstreamUrl, originalMethod, body, 0);