sootsim 0.0.1 → 0.0.3

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

@@ -0,0 +1,3458 @@
+/*! sootsim v0.0.3 | (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;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/host/bridge-host.ts
+var bridge_host_exports = {};
+__export(bridge_host_exports, {
+  SootSimBridgeHost: () => SootSimBridgeHost
+});
+module.exports = __toCommonJS(bridge_host_exports);
+var import_child_process2 = require("child_process");
+var import_fs2 = __toESM(require("fs"), 1);
+var import_http2 = require("http");
+var import_path2 = __toESM(require("path"), 1);
+var import_ws = require("ws");
+
+// src/bridge-constants.ts
+var DEFAULT_SOOTSIM_BRIDGE_PORT = 7668;
+
+// src/home-paths.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_os = require("os");
+var import_path = __toESM(require("path"), 1);
+var SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
+var ACTIVE_RUNTIME_FILE = "active";
+var DAEMON_LOCKFILE = "daemon.json";
+var DAEMON_HEARTBEAT_STALE_MS = 3e4;
+function sootsimHomeDir() {
+  const override = process.env[SOOTSIM_HOME_ENV];
+  if (override && override.length > 0) return import_path.default.resolve(override);
+  return import_path.default.join((0, import_os.homedir)(), ".sootsim");
+}
+function runtimesDir() {
+  return import_path.default.join(sootsimHomeDir(), "runtimes");
+}
+function runtimeDir(version) {
+  return import_path.default.join(runtimesDir(), version);
+}
+function activeRuntimeFile() {
+  return import_path.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+}
+function cacheDir() {
+  return import_path.default.join(sootsimHomeDir(), "cache");
+}
+function daemonLockfilePath() {
+  return import_path.default.join(sootsimHomeDir(), DAEMON_LOCKFILE);
+}
+function ensureSootsimHome() {
+  import_fs.default.mkdirSync(sootsimHomeDir(), { recursive: true });
+  import_fs.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_fs.default.mkdirSync(cacheDir(), { recursive: true });
+}
+function readActiveRuntime() {
+  try {
+    const value = import_fs.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+function writeActiveRuntime(version) {
+  import_fs.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_fs.default.writeFileSync(activeRuntimeFile(), `${version}
+`, "utf8");
+}
+function listInstalledRuntimes() {
+  try {
+    return import_fs.default.readdirSync(runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
+  } catch {
+    return [];
+  }
+}
+function compareSemver(a, b) {
+  const parse = (v) => {
+    const hyphen = v.indexOf("-");
+    const core = hyphen >= 0 ? v.slice(0, hyphen) : v;
+    const pre = hyphen >= 0 ? v.slice(hyphen + 1) : "";
+    const parts = core.split(".").map((n) => Number.parseInt(n, 10));
+    if (parts.some((n) => !Number.isFinite(n))) return [[Number.POSITIVE_INFINITY], v];
+    return [parts, pre];
+  };
+  const [an, ap] = parse(a);
+  const [bn, bp] = parse(b);
+  for (let i = 0; i < Math.max(an.length, bn.length); i++) {
+    const av = an[i] ?? 0;
+    const bv = bn[i] ?? 0;
+    if (av !== bv) return av - bv;
+  }
+  if (ap === bp) return 0;
+  if (!ap) return 1;
+  if (!bp) return -1;
+  return ap < bp ? -1 : 1;
+}
+function activeRuntimeDir() {
+  const version = readActiveRuntime();
+  if (!version) return null;
+  const dir = runtimeDir(version);
+  try {
+    if (import_fs.default.statSync(dir).isDirectory()) return dir;
+  } catch {
+  }
+  return null;
+}
+var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+function readDaemonLockfile() {
+  try {
+    const fd = import_fs.default.openSync(daemonLockfilePath(), "r");
+    try {
+      const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
+      const bytesRead = import_fs.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") {
+        return parsed;
+      }
+      return null;
+    } finally {
+      import_fs.default.closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+function isDaemonLockfileFresh(lock, now = Date.now()) {
+  if (!lock) return false;
+  if (now - lock.heartbeatAt > DAEMON_HEARTBEAT_STALE_MS) return false;
+  try {
+    process.kill(lock.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeDaemonLockfile(data) {
+  ensureSootsimHome();
+  const tmp = `${daemonLockfilePath()}.tmp`;
+  import_fs.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+  import_fs.default.renameSync(tmp, daemonLockfilePath());
+}
+function claimDaemonLockfile(data) {
+  ensureSootsimHome();
+  const existing = readDaemonLockfile();
+  if (existing && isDaemonLockfileFresh(existing) && existing.pid !== data.pid) {
+    return false;
+  }
+  writeDaemonLockfile(data);
+  return true;
+}
+function removeDaemonLockfile() {
+  try {
+    import_fs.default.unlinkSync(daemonLockfilePath());
+  } catch {
+  }
+}
+
+// src/host/agent-host.ts
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_path4 = __toESM(require("node:path"), 1);
+
+// scripts/dev-server-scanner.ts
+var import_child_process = require("child_process");
+var import_http = __toESM(require("http"), 1);
+var import_net = __toESM(require("net"), 1);
+var import_util = require("util");
+
+// src/config.ts
+var SOOTSIM_CONFIG_QUERY_PARAM = "sootsimConfig";
+function hasOwnKeys(value) {
+  return !!value && Object.keys(value).length > 0;
+}
+function hasSootSimConfig(config) {
+  if (!config) return false;
+  return hasOwnKeys(config.modules) || hasOwnKeys(config.turboModules) || hasOwnKeys(config.env) || hasOwnKeys(config.settings) || hasOwnKeys(config.initialState);
+}
+function applySootSimConfigToUrl(url, config) {
+  const parsed = new URL(url);
+  if (hasSootSimConfig(config)) {
+    parsed.searchParams.set(SOOTSIM_CONFIG_QUERY_PARAM, JSON.stringify(config));
+  } else {
+    parsed.searchParams.delete(SOOTSIM_CONFIG_QUERY_PARAM);
+  }
+  return parsed.toString();
+}
+
+// src/native-dev-bundle-url.ts
+function isAbsoluteHttpUrl(url) {
+  return /^https?:\/\//i.test(url);
+}
+function isNativeDevBundlePath(pathname) {
+  return pathname.endsWith(".bundle");
+}
+function normalizeNativeDevBundleUrl(bundleUrl) {
+  try {
+    const isAbsolute = isAbsoluteHttpUrl(bundleUrl);
+    const parsed = new URL(bundleUrl, "http://soot.local");
+    if (!isNativeDevBundlePath(parsed.pathname)) return bundleUrl;
+    if (!parsed.searchParams.has("dev")) parsed.searchParams.set("dev", "true");
+    if (!parsed.searchParams.has("minify")) {
+      parsed.searchParams.set("minify", "false");
+    }
+    if (isAbsolute) return parsed.toString();
+    return `${parsed.pathname}${parsed.search}${parsed.hash}`;
+  } catch {
+    return bundleUrl;
+  }
+}
+
+// scripts/demo-app-registry.ts
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var HOME = (0, import_node_os.homedir)();
+function findWorkspaceRoot(startDir) {
+  let dir = startDir;
+  while (true) {
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "pnpm-workspace.yaml")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "turbo.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "nx.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "lerna.json"))) {
+      return dir;
+    }
+    const packageJsonPath = (0, import_node_path.join)(dir, "package.json");
+    if ((0, import_node_fs.existsSync)(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse((0, import_node_fs.readFileSync)(packageJsonPath, "utf8"));
+        if (pkg.workspaces) return dir;
+      } catch {
+      }
+    }
+    const parent = (0, import_node_path.dirname)(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function resolveWorkspaceScriptPath(workspaceRelativePath, packageRelativePath) {
+  const workspaceRoot = findWorkspaceRoot(process.cwd());
+  const candidates = [
+    workspaceRoot ? (0, import_node_path.resolve)(workspaceRoot, workspaceRelativePath) : null,
+    (0, import_node_path.resolve)(process.cwd(), workspaceRelativePath),
+    (0, import_node_path.resolve)(process.cwd(), packageRelativePath)
+  ].filter((candidate) => Boolean(candidate));
+  for (const candidate of candidates) {
+    if ((0, import_node_fs.existsSync)(candidate)) return candidate;
+  }
+  return candidates[0] ?? (0, import_node_path.resolve)(process.cwd(), workspaceRelativePath);
+}
+var getExpensifyProxyScript = () => resolveWorkspaceScriptPath(
+  "packages/sootsim-engine/scripts/expensify-web-proxy.ts",
+  "scripts/expensify-web-proxy.ts"
+);
+var EXPENSIFY_NATIVE_PROXY_ENV = {
+  USE_NGROK: "true",
+  NGROK_URL: "http://localhost:9000/",
+  SECURE_NGROK_URL: "http://localhost:9000/"
+};
+var UNISWAP_REPO_DIR = (0, import_node_path.join)(HOME, "github/uniswap-interface");
+var UNISWAP_APP_DIR = (0, import_node_path.join)(UNISWAP_REPO_DIR, "apps/mobile");
+var UNISWAP_ENV_LOCAL_FILE = (0, import_node_path.join)(UNISWAP_REPO_DIR, ".env.defaults.local");
+var UNISWAP_PLACEHOLDER = "stored-in-.env.local";
+var UNISWAP_DEMO_ENV_MARKER = "# sootsim demo env overrides";
+var UNISWAP_FORCE_UPGRADE_HOOK_FILE = (0, import_node_path.join)(
+  UNISWAP_REPO_DIR,
+  "packages/uniswap/src/features/forceUpgrade/hooks/useForceUpgradeStatus.ts"
+);
+var UNISWAP_FORCE_UPGRADE_NOTIFICATION_FILE = (0, import_node_path.join)(
+  UNISWAP_REPO_DIR,
+  "apps/mobile/src/notification-service/data-sources/createForceUpgradeNotificationDataSource.ts"
+);
+var UNISWAP_FORCE_UPGRADE_PATCH_MARKER = "SOOTSIM_DEMO_DISABLE_FORCE_UPGRADE";
+function parseEnvFile(filePath) {
+  if (!(0, import_node_fs.existsSync)(filePath)) return {};
+  const env = {};
+  const source = (0, import_node_fs.readFileSync)(filePath, "utf8");
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+    if (!match) continue;
+    let value = match[2].trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    env[match[1]] = value;
+  }
+  return env;
+}
+function isUsableUniswapEnvValue(value) {
+  if (!value) return false;
+  const trimmed = value.trim();
+  if (!trimmed) return false;
+  if (trimmed.includes(UNISWAP_PLACEHOLDER)) return false;
+  if (trimmed === "TRADING_API_KEY" || trimmed === "UNISWAP_API_KEY") return false;
+  return true;
+}
+function pickEnvValue(sources, keys) {
+  for (const source of sources) {
+    for (const key of keys) {
+      const value = source[key];
+      if (isUsableUniswapEnvValue(value)) return value.trim();
+    }
+  }
+  return void 0;
+}
+function resolveUniswapDemoEnv() {
+  const localEnv = parseEnvFile(UNISWAP_ENV_LOCAL_FILE);
+  const webEnv = parseEnvFile((0, import_node_path.join)(UNISWAP_REPO_DIR, "apps/web/.env"));
+  const sources = [
+    process.env,
+    localEnv,
+    webEnv
+  ];
+  const env = {};
+  const bindings = [
+    ["AMPLITUDE_PROXY_URL_OVERRIDE", ["REACT_APP_AMPLITUDE_PROXY_URL"]],
+    ["QUICKNODE_ENDPOINT_NAME", ["REACT_APP_QUICKNODE_ENDPOINT_NAME"]],
+    ["QUICKNODE_ENDPOINT_TOKEN", ["REACT_APP_QUICKNODE_ENDPOINT_TOKEN"]],
+    ["INFURA_KEY", ["REACT_APP_INFURA_KEY"]],
+    ["STATSIG_API_KEY", ["REACT_APP_STATSIG_API_KEY"]],
+    ["STATSIG_PROXY_URL_OVERRIDE", ["REACT_APP_STATSIG_PROXY_URL"]],
+    ["WALLETCONNECT_PROJECT_ID", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
+    ["WALLETCONNECT_PROJECT_ID_BETA", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
+    ["WALLETCONNECT_PROJECT_ID_DEV", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
+    ["TRADING_API_KEY", ["REACT_APP_TRADING_API_KEY"]],
+    ["UNISWAP_API_KEY", []]
+  ];
+  for (const [target, aliases] of bindings) {
+    const value = pickEnvValue(sources, [target, ...aliases]);
+    if (!value) continue;
+    env[target] = value;
+    for (const alias of aliases) {
+      env[alias] = value;
+    }
+  }
+  const hasPrivateGatewayKeys = isUsableUniswapEnvValue(env.TRADING_API_KEY) && isUsableUniswapEnvValue(env.UNISWAP_API_KEY);
+  if (!hasPrivateGatewayKeys) {
+    const publicGraphqlUrl = pickEnvValue(sources, ["GRAPHQL_URL_OVERRIDE", "REACT_APP_AWS_API_ENDPOINT"]) || "https://interface.gateway.uniswap.org/v1/graphql";
+    env.API_BASE_URL_OVERRIDE = "https://interface.gateway.uniswap.org";
+    env.API_BASE_URL_V2_OVERRIDE = "https://interface.gateway.uniswap.org/v2";
+    env.GRAPHQL_URL_OVERRIDE = publicGraphqlUrl;
+    env.TRADING_API_URL_OVERRIDE = "https://trading-api-labs.interface.gateway.uniswap.org";
+    env.FOR_API_URL_OVERRIDE = "https://for.interface.gateway.uniswap.org/v2/FOR.v1.FORService";
+  }
+  return env;
+}
+function ensureUniswapDemoEnvLocal() {
+  const existingSource = (0, import_node_fs.existsSync)(UNISWAP_ENV_LOCAL_FILE) ? (0, import_node_fs.readFileSync)(UNISWAP_ENV_LOCAL_FILE, "utf8") : "";
+  if (existingSource && !existingSource.includes(UNISWAP_DEMO_ENV_MARKER)) {
+    return;
+  }
+  const env = resolveUniswapDemoEnv();
+  const lines = [UNISWAP_DEMO_ENV_MARKER];
+  for (const [key, value] of Object.entries(env).sort(([a], [b]) => a.localeCompare(b))) {
+    lines.push(`${key}=${JSON.stringify(value)}`);
+  }
+  lines.push("");
+  (0, import_node_fs.writeFileSync)(UNISWAP_ENV_LOCAL_FILE, `${lines.join("\n")}
+`);
+}
+function ensureUniswapForceUpgradePatched() {
+  const hookNeedle = `export function useForceUpgradeStatus(): ForceUpgradeStatus {
+`;
+  const hookPatch = `  // sootsim demo: bypass the force-upgrade gate during local engine demos.
+  return 'not-required'
+
+`;
+  const hookLegacyPatch = `  // sootsim demo: bypass the force-upgrade gate during local engine demos.
+  if (process.env.${UNISWAP_FORCE_UPGRADE_PATCH_MARKER} === 'true') {
+    return 'not-required'
+  }
+
+`;
+  const notificationNeedle = `  const getForceUpgradeStatus = (): ForceUpgradeStatus => {
+`;
+  const notificationPatch = `    // sootsim demo: bypass the force-upgrade gate during local engine demos.
+    return 'not-required'
+
+`;
+  const notificationLegacyPatch = `    // sootsim demo: bypass the force-upgrade gate during local engine demos.
+    if (process.env.${UNISWAP_FORCE_UPGRADE_PATCH_MARKER} === 'true') {
+      return 'not-required'
+    }
+
+`;
+  const patchWithMigration = (filePath, needle, patch, legacyPatch) => {
+    const source = (0, import_node_fs.readFileSync)(filePath, "utf8");
+    if (source.includes(patch)) return;
+    if (source.includes(legacyPatch)) {
+      (0, import_node_fs.writeFileSync)(filePath, source.replace(legacyPatch, patch));
+      return;
+    }
+    if (!source.includes(needle)) {
+      throw new Error(
+        `uniswap demo patch failed: expected snippet not found in ${filePath}`
+      );
+    }
+    (0, import_node_fs.writeFileSync)(filePath, source.replace(needle, `${needle}${patch}`));
+  };
+  patchWithMigration(
+    UNISWAP_FORCE_UPGRADE_HOOK_FILE,
+    hookNeedle,
+    hookPatch,
+    hookLegacyPatch
+  );
+  patchWithMigration(
+    UNISWAP_FORCE_UPGRADE_NOTIFICATION_FILE,
+    notificationNeedle,
+    notificationPatch,
+    notificationLegacyPatch
+  );
+}
+var ARTSY_DIR = (0, import_node_path.join)(HOME, "github/eigen");
+var ARTSY_KEYS_FILE = (0, import_node_path.join)(ARTSY_DIR, "keys.shared.json");
+var ARTSY_METAFLAGS_FILE = (0, import_node_path.join)(ARTSY_DIR, "metaflags.json");
+var ARTSY_RELAY_SENTINEL = (0, import_node_path.join)(ARTSY_DIR, "src/__generated__/.relay-complete");
+function readArtsyKeysPayload() {
+  if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE)) return void 0;
+  try {
+    const parsed = JSON.parse((0, import_node_fs.readFileSync)(ARTSY_KEYS_FILE, "utf8"));
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const secure = parsed.secure && typeof parsed.secure === "object" ? parsed.secure : void 0;
+    const publicKeys = parsed.public && typeof parsed.public === "object" ? parsed.public : void 0;
+    if (!secure && !publicKeys) return void 0;
+    return { secure, public: publicKeys };
+  } catch {
+    return void 0;
+  }
+}
+function resolveArtsyRuntimeConfig() {
+  const email = process.env.SOOTSIM_ARTSY_EMAIL ?? process.env.MAESTRO_TEST_EMAIL;
+  const password = process.env.SOOTSIM_ARTSY_PASSWORD ?? process.env.MAESTRO_TEST_PASSWORD;
+  const keys = readArtsyKeysPayload();
+  const env = {};
+  if (email && password) {
+    env.SOOTSIM_LAUNCH_ARGUMENTS = JSON.stringify({
+      email,
+      password,
+      useMaestroInit: true
+    });
+  }
+  if (keys) {
+    env.SOOTSIM_REACT_NATIVE_KEYS_JSON = JSON.stringify(keys);
+  }
+  if (Object.keys(env).length === 0) return void 0;
+  return {
+    env
+  };
+}
+function ensureArtsySetup() {
+  if (!(0, import_node_fs.existsSync)(ARTSY_DIR)) return;
+  const { execSync } = require("node:child_process");
+  const yarnRelease = (0, import_node_path.join)(ARTSY_DIR, ".yarn/releases/yarn-4.10.3.cjs");
+  if ((0, import_node_fs.existsSync)(yarnRelease)) {
+    const src = (0, import_node_fs.readFileSync)(yarnRelease, "utf8");
+    const needle = '["clone","-c core.autocrlf=false",';
+    if (src.includes(needle)) {
+      (0, import_node_fs.writeFileSync)(
+        yarnRelease,
+        src.replace(needle, '["clone","-c","core.autocrlf=false",')
+      );
+    }
+  }
+  if (!(0, import_node_fs.existsSync)((0, import_node_path.join)(ARTSY_DIR, "node_modules/.yarn-state.yml"))) {
+    execSync("yarn install", {
+      cwd: ARTSY_DIR,
+      stdio: "inherit",
+      env: { ...process.env, YARN_CHECKSUM_BEHAVIOR: "update" }
+    });
+  }
+  if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE) || !(0, import_node_fs.existsSync)(ARTSY_METAFLAGS_FILE)) {
+    try {
+      execSync("yarn setup:oss", { cwd: ARTSY_DIR, stdio: "inherit" });
+    } catch {
+      if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE) || !(0, import_node_fs.existsSync)(ARTSY_METAFLAGS_FILE)) {
+        throw new Error("artsy demo: setup:oss did not create keys/metaflags");
+      }
+    }
+  }
+  const rnlaPkgJson = (0, import_node_path.join)(
+    ARTSY_DIR,
+    "node_modules/react-native-launch-arguments/package.json"
+  );
+  if ((0, import_node_fs.existsSync)(rnlaPkgJson)) {
+    const raw = (0, import_node_fs.readFileSync)(rnlaPkgJson, "utf8");
+    if (raw.includes('"dist/index.js"')) {
+      (0, import_node_fs.writeFileSync)(rnlaPkgJson, raw.replace('"dist/index.js"', '"src/index.ts"'));
+    }
+  }
+  if (!(0, import_node_fs.existsSync)(ARTSY_RELAY_SENTINEL)) {
+    execSync("yarn relay", { cwd: ARTSY_DIR, stdio: "inherit" });
+    (0, import_node_fs.writeFileSync)(ARTSY_RELAY_SENTINEL, "");
+  }
+}
+var APPS = [
+  {
+    name: "bluesky",
+    label: "Bluesky",
+    dir: (0, import_node_path.join)(HOME, "github/bluesky"),
+    preferredPort: 8082,
+    framework: "expo",
+    command: (p) => ({ cmd: `npx expo start --port ${p}` }),
+    credentials: {
+      envVars: ["SOOTSIM_BLUESKY_PASSWORD"],
+      known: { HANDLE: "natew.bsky.social" }
+    }
+  },
+  {
+    name: "3pc",
+    label: "3PunchConvo",
+    dir: (0, import_node_path.join)(HOME, "lightstrike-labs/three-punch-convo-app/apps/one"),
+    preferredPort: 8081,
+    framework: "one",
+    command: (p) => ({ cmd: "npx one dev", env: { ONE_PORT: String(p) } })
+  },
+  {
+    name: "uniswap",
+    label: "Uniswap",
+    dir: UNISWAP_APP_DIR,
+    preferredPort: 8085,
+    framework: "expo",
+    prepare: () => {
+      ensureUniswapDemoEnvLocal();
+      ensureUniswapForceUpgradePatched();
+    },
+    command: (p) => ({
+      cmd: `npx expo start --clear --port ${p}`,
+      // prefer the real local mobile env when present, otherwise fall back
+      // to Uniswap's checked-in public web RPC settings so demo boots cleanly.
+      env: resolveUniswapDemoEnv()
+    })
+  },
+  {
+    name: "takeout",
+    label: "Takeout",
+    dir: (0, import_node_path.join)(HOME, "takeout"),
+    preferredPort: 8086,
+    framework: "one",
+    command: (p) => ({ cmd: "npx one dev", env: { ONE_PORT: String(p) } })
+  },
+  {
+    name: "expensify",
+    label: "Expensify",
+    dir: (0, import_node_path.join)(HOME, "github/expensify"),
+    preferredPort: 8087,
+    framework: "rock",
+    runtimeConfig: {
+      env: EXPENSIFY_NATIVE_PROXY_ENV
+    },
+    sidecars: [
+      {
+        name: "web-proxy",
+        port: 9e3,
+        readyPath: "/api/Ping",
+        command: () => ({
+          cmd: `bun ${JSON.stringify(getExpensifyProxyScript())}`,
+          env: EXPENSIFY_NATIVE_PROXY_ENV
+        })
+      }
+    ],
+    command: (p) => ({
+      cmd: `fnm exec --using=20.20.0 npx rock start --port ${p} --no-interactive`,
+      env: EXPENSIFY_NATIVE_PROXY_ENV
+    })
+  },
+  {
+    name: "artsy",
+    label: "Artsy",
+    dir: ARTSY_DIR,
+    preferredPort: 8088,
+    framework: "expo",
+    runtimeConfig: resolveArtsyRuntimeConfig(),
+    prepare: () => {
+      ensureArtsySetup();
+    },
+    command: (p) => ({
+      // eigen's `yarn start` wraps `react-native start` with a relay watcher
+      // via concurrently; for the demo we run relay once in prepare and
+      // invoke the metro server directly so --port is respected.
+      cmd: `npx react-native start --port ${p}`
+    }),
+    credentials: {
+      envVars: ["SOOTSIM_ARTSY_EMAIL", "SOOTSIM_ARTSY_PASSWORD"],
+      note: "auto-login reuses Artsy\u2019s built-in Maestro launch-arguments hook"
+    }
+  }
+];
+
+// scripts/dev-server-scanner.ts
+var execP = (0, import_util.promisify)(import_child_process.exec);
+var TIMEOUT_MS = 250;
+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");
+  });
+}
+function httpGet(port, path6, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+  return new Promise((resolve2) => {
+    const req = import_http.default.request(
+      { hostname: "localhost", port, path: path6, method, timeout, headers },
+      (res) => {
+        let body = "";
+        res.on("data", (c) => body += c.toString());
+        res.on("end", () => resolve2({ statusCode: res.statusCode || 0, body }));
+      }
+    );
+    req.on("error", () => resolve2(null));
+    req.setTimeout(timeout, () => {
+      req.destroy();
+      resolve2(null);
+    });
+    req.end();
+  });
+}
+var FALLBACK_PORTS = [
+  8081,
+  8082,
+  8083,
+  8084,
+  8085,
+  8086,
+  3e3,
+  3001,
+  19e3
+].map((port) => ({ port, pid: 0 }));
+function acceptPort(port, excluded) {
+  if (port <= 0 || port >= 2e4) return false;
+  if (excluded.has(port)) return false;
+  if (port >= 5170 && port <= 5200) return false;
+  return true;
+}
+async function discoverListeningProcesses(excludePorts = []) {
+  const excluded = new Set(excludePorts);
+  try {
+    const { stdout } = await execP(
+      `lsof -iTCP -sTCP:LISTEN -P -n 2>/dev/null | grep -E '^(node|bun)'`,
+      { encoding: "utf8", timeout: 2e3 }
+    );
+    if (stdout.trim()) {
+      const seen = /* @__PURE__ */ new Map();
+      for (const line of stdout.trim().split("\n")) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 9) continue;
+        const pid = Number(parts[1]);
+        const addr = parts[8];
+        const m = addr.match(/:(\d+)$/);
+        if (!m) continue;
+        const port = Number(m[1]);
+        if (!acceptPort(port, excluded)) continue;
+        if (!seen.has(port)) seen.set(port, pid);
+      }
+      if (seen.size > 0) {
+        return [...seen.entries()].map(([port, pid]) => ({ port, pid }));
+      }
+    }
+  } catch {
+  }
+  try {
+    const { stdout } = await execP(`ss -tlnp 2>/dev/null | grep -E '"(node|bun)"'`, {
+      encoding: "utf8",
+      timeout: 2e3
+    });
+    if (stdout.trim()) {
+      const seen = /* @__PURE__ */ new Map();
+      for (const line of stdout.trim().split("\n")) {
+        const portMatch = line.match(/:(\d+)\s/);
+        const pidMatch = line.match(/pid=(\d+)/);
+        if (!portMatch) continue;
+        const port = Number(portMatch[1]);
+        const pid = pidMatch ? Number(pidMatch[1]) : 0;
+        if (!acceptPort(port, excluded)) continue;
+        if (!seen.has(port)) seen.set(port, pid);
+      }
+      if (seen.size > 0) {
+        return [...seen.entries()].map(([port, pid]) => ({ port, pid }));
+      }
+    }
+  } catch {
+  }
+  return FALLBACK_PORTS.filter((p) => acceptPort(p.port, excluded));
+}
+var cwdByPid = /* @__PURE__ */ new Map();
+async function resolveProcessCwd(pid) {
+  if (pid <= 0) return null;
+  const cached = cwdByPid.get(pid);
+  if (cached) return cached;
+  try {
+    const { stdout } = await execP(`lsof -p ${pid} -a -d cwd -Fn 2>/dev/null`, {
+      encoding: "utf8",
+      timeout: 1500
+    });
+    for (const line of stdout.split("\n")) {
+      if (line.startsWith("n") && line.length > 1) {
+        const cwd = line.slice(1).trim();
+        if (cwd) {
+          cwdByPid.set(pid, cwd);
+          return cwd;
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function makeResult(port, framework) {
+  return {
+    port,
+    framework,
+    bundleUrl: withRuntimeConfig(
+      port,
+      `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`
+    ),
+    hmrUrl: `ws://localhost:${port}/hot`,
+    lastSeen: Date.now()
+  };
+}
+function withRuntimeConfig(port, bundleUrl) {
+  const knownApp = APPS.find((app) => app.preferredPort === port);
+  const configured = knownApp?.runtimeConfig ? applySootSimConfigToUrl(bundleUrl, knownApp.runtimeConfig) : bundleUrl;
+  return normalizeNativeDevBundleUrl(configured);
+}
+function isDirectOneBundleUrl(bundleUrl) {
+  return bundleUrl.includes("/node_modules/one/metro-entry.bundle");
+}
+function applyManifest(result, manifestRes, buildIconProxyUrl) {
+  if (!manifestRes) return result;
+  try {
+    const manifest = JSON.parse(manifestRes.body);
+    const client = manifest?.extra?.expoClient || manifest?.extra || {};
+    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 launchUrl = manifest?.launchAsset?.url;
+    if (launchUrl && !result.patched && !isDirectOneBundleUrl(result.bundleUrl)) {
+      result.bundleUrl = withRuntimeConfig(result.port, launchUrl);
+    }
+    const rawIconUrl = client.iconUrl || client.ios?.iconUrl || client.icon || client.ios?.icon;
+    if (rawIconUrl) {
+      result.iconPath = rawIconUrl;
+      if (buildIconProxyUrl) {
+        if (rawIconUrl.startsWith("http")) {
+          result.iconUrl = buildIconProxyUrl(rawIconUrl);
+        } else {
+          const cleanPath = rawIconUrl.replace(/^\.\//, "");
+          result.iconUrl = buildIconProxyUrl(
+            `http://localhost:${result.port}/assets/${cleanPath}`
+          );
+        }
+      } else {
+        result.iconUrl = rawIconUrl.startsWith("http") ? rawIconUrl : `http://localhost:${result.port}/assets/${rawIconUrl.replace(/^\.\//, "")}`;
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+var knownNonPatched = /* @__PURE__ */ new Set();
+var knownNonExpo = /* @__PURE__ */ new Set();
+async function probePort(port, buildIconProxyUrl) {
+  if (!await tcpPing(port)) return null;
+  const onePath = `/node_modules/one/metro-entry.bundle?platform=ios&dev=true`;
+  const [sootsimRes, statusRes, oneRes, manifestRes, expoRes] = await Promise.all([
+    knownNonPatched.has(port) ? Promise.resolve(null) : httpGet(port, "/__soot/"),
+    httpGet(port, "/status"),
+    httpGet(port, onePath, "HEAD"),
+    httpGet(port, "/", "GET", TIMEOUT_MS, { "expo-platform": "ios" }),
+    knownNonExpo.has(port) ? Promise.resolve(null) : httpGet(port, "/_expo/status")
+  ]);
+  if (expoRes && expoRes.statusCode === 200) {
+    knownNonExpo.delete(port);
+  } else if (!knownNonExpo.has(port)) {
+    knownNonExpo.add(port);
+  }
+  if (oneRes && oneRes.statusCode > 0 && oneRes.statusCode < 400) {
+    knownNonPatched.add(port);
+    return applyManifest(
+      {
+        port,
+        framework: "one",
+        bundleUrl: withRuntimeConfig(
+          port,
+          `http://localhost:${port}${onePath}&minify=false`
+        ),
+        hmrUrl: `ws://localhost:${port}/hot`,
+        lastSeen: Date.now()
+      },
+      manifestRes,
+      buildIconProxyUrl
+    );
+  }
+  if (statusRes && statusRes.body.includes("packager-status:running")) {
+    knownNonPatched.add(port);
+    return applyManifest(
+      makeResult(port, expoRes && expoRes.statusCode === 200 ? "expo" : "metro"),
+      manifestRes,
+      buildIconProxyUrl
+    );
+  }
+  if (manifestRes) {
+    try {
+      const manifest = JSON.parse(manifestRes.body);
+      const client = manifest?.extra?.expoClient || {};
+      if (client.name) {
+        const launchUrl = manifest?.launchAsset?.url || `http://localhost:${port}/index.bundle?platform=ios&dev=true&hot=true&minify=false`;
+        knownNonPatched.add(port);
+        return applyManifest(
+          {
+            port,
+            framework: "one",
+            bundleUrl: withRuntimeConfig(port, launchUrl),
+            hmrUrl: `ws://localhost:${port}/hot`,
+            lastSeen: Date.now()
+          },
+          manifestRes,
+          buildIconProxyUrl
+        );
+      }
+    } catch {
+    }
+  }
+  if (sootsimRes && sootsimRes.statusCode === 200 && sootsimRes.body.includes("sootsim-patched")) {
+    knownNonPatched.delete(port);
+    return applyManifest(
+      {
+        port,
+        framework: "one",
+        bundleUrl: withRuntimeConfig(port, `http://localhost:${port}/__soot/bundle.js`),
+        hmrUrl: `ws://localhost:${port}/hot`,
+        lastSeen: Date.now(),
+        patched: true
+      },
+      manifestRes,
+      buildIconProxyUrl
+    );
+  }
+  knownNonPatched.add(port);
+  return null;
+}
+function isSootSelfServer(server) {
+  const projectName = server.projectName?.trim().toLowerCase();
+  if (projectName === "soot" || projectName === "sootsim") return true;
+  const bundleId = server.bundleId?.trim().toLowerCase();
+  if (bundleId?.startsWith("dev.soot")) return true;
+  return false;
+}
+var portCache = /* @__PURE__ */ new Map();
+var NEGATIVE_CACHE_TTL_MS = 3e4;
+var WEAK_RESULT_CACHE_TTL_MS = 1500;
+function isWeakCachedResult(result) {
+  if (!result) return true;
+  if (result.framework === "metro" || result.framework === "unknown") return true;
+  return false;
+}
+function hasCurrentRuntimeConfig(result) {
+  if (!result) return true;
+  return withRuntimeConfig(result.port, result.bundleUrl) === result.bundleUrl;
+}
+function __shouldReuseScannerCacheEntry(entry, pid, now = Date.now()) {
+  if (pid === 0) return false;
+  if (entry.pid !== pid) return false;
+  if (!hasCurrentRuntimeConfig(entry.result)) return false;
+  const ageMs = now - entry.cachedAt;
+  if (entry.result === null && ageMs >= NEGATIVE_CACHE_TTL_MS) return false;
+  if (isWeakCachedResult(entry.result) && ageMs >= WEAK_RESULT_CACHE_TTL_MS) return false;
+  return true;
+}
+async function scanDevServers(opts = {}) {
+  const processes = await discoverListeningProcesses(opts.excludePorts);
+  const currentPorts = new Set(processes.map((p) => p.port));
+  for (const p of [...portCache.keys()]) {
+    if (!currentPorts.has(p)) portCache.delete(p);
+  }
+  for (const p of [...knownNonPatched]) {
+    if (!currentPorts.has(p)) knownNonPatched.delete(p);
+  }
+  for (const p of [...knownNonExpo]) {
+    if (!currentPorts.has(p)) knownNonExpo.delete(p);
+  }
+  const results = [];
+  const toProbe = [];
+  for (const { port, pid } of processes) {
+    const cached = portCache.get(port);
+    if (cached && __shouldReuseScannerCacheEntry(cached, pid)) {
+      if (cached.result) results.push(cached.result);
+      continue;
+    }
+    if (cached && cached.pid !== pid) {
+      knownNonPatched.delete(port);
+      knownNonExpo.delete(port);
+    }
+    toProbe.push({ port, pid });
+  }
+  if (toProbe.length > 0) {
+    const probed = await Promise.all(
+      toProbe.map((p) => probePort(p.port, opts.buildIconProxyUrl))
+    );
+    probed.forEach((result, i) => {
+      const { port, pid } = toProbe[i];
+      if (pid !== 0) portCache.set(port, { pid, result, cachedAt: Date.now() });
+      if (result) results.push(result);
+    });
+  }
+  const pidByPort = /* @__PURE__ */ new Map();
+  for (const { port, pid } of processes) {
+    if (pid > 0) pidByPort.set(port, pid);
+  }
+  await Promise.all(
+    results.map(async (result) => {
+      const pid = pidByPort.get(result.port);
+      if (!pid) return;
+      result.pid = pid;
+      const cwd = await resolveProcessCwd(pid);
+      if (cwd) result.cwd = cwd;
+    })
+  );
+  const livePids = new Set(pidByPort.values());
+  for (const pid of [...cwdByPid.keys()]) {
+    if (!livePids.has(pid)) cwdByPid.delete(pid);
+  }
+  return results.filter((r) => !isSootSelfServer(r));
+}
+
+// src/agent-sessions.ts
+var import_node_child_process = require("node:child_process");
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
+var import_node_readline = __toESM(require("node:readline"), 1);
+
+// src/agent-events.ts
+function isAgentEvent(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v.type === "string" && typeof v.ts === "number";
+}
+function parseAgentEventLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return isAgentEvent(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/agent-prompt.ts
+var ENVELOPE_MARKER = "sootsim-agent-prompt-v1";
+function cleanPromptText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function encodeAgentPromptEnvelope(input) {
+  const text = cleanPromptText(input.text);
+  if (!text) return "";
+  const displayText = cleanPromptText(input.displayText);
+  const inspectSummary = cleanPromptText(input.inspectSummary);
+  const inspectTrace = cleanPromptText(input.inspectTrace);
+  const needsEnvelope = !!inspectSummary || !!inspectTrace || /[\r\n]/.test(text) || !!displayText && displayText !== text;
+  if (!needsEnvelope) return text;
+  return JSON.stringify({
+    __sootsimAgentPrompt: ENVELOPE_MARKER,
+    text,
+    displayText,
+    inspectSummary,
+    inspectTrace
+  });
+}
+
+// src/attached-projects.ts
+var import_node_crypto = require("node:crypto");
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_node_os2 = __toESM(require("node:os"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+var overrideDir = null;
+function userDataDir() {
+  if (overrideDir) return overrideDir;
+  const fromEnv = process.env.SOOTSIM_USER_DATA_DIR;
+  if (fromEnv) return fromEnv;
+  try {
+    const electron = require("electron");
+    if (electron.app?.getPath) return electron.app.getPath("userData");
+  } catch {
+  }
+  return platformDefaultUserDataDir();
+}
+function platformDefaultUserDataDir() {
+  const home = import_node_os2.default.homedir();
+  if (process.platform === "darwin") {
+    return import_node_path2.default.join(home, "Library", "Application Support", "sootsim");
+  }
+  if (process.platform === "win32") {
+    return import_node_path2.default.join(process.env.APPDATA || home, "sootsim");
+  }
+  const xdg = process.env.XDG_CONFIG_HOME || import_node_path2.default.join(home, ".config");
+  return import_node_path2.default.join(xdg, "sootsim");
+}
+function getUserDataDir() {
+  return userDataDir();
+}
+function storeFile() {
+  return import_node_path2.default.join(userDataDir(), "attached-projects.json");
+}
+function cloneEmpty() {
+  return {
+    version: 1,
+    attachedProjects: [],
+    previewAttachments: [],
+    agentSessions: []
+  };
+}
+function loadStore() {
+  const file = storeFile();
+  let raw;
+  try {
+    raw = import_node_fs2.default.readFileSync(file, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return cloneEmpty();
+    throw err;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") throw new Error("not an object");
+    return {
+      version: 1,
+      attachedProjects: Array.isArray(parsed.attachedProjects) ? parsed.attachedProjects : [],
+      previewAttachments: Array.isArray(parsed.previewAttachments) ? parsed.previewAttachments : [],
+      agentSessions: Array.isArray(parsed.agentSessions) ? parsed.agentSessions : []
+    };
+  } catch (err) {
+    const quarantine = `${file}.corrupt-${Date.now()}`;
+    try {
+      import_node_fs2.default.renameSync(file, quarantine);
+      console.warn(
+        `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. original error: ${err.message}`
+      );
+    } catch {
+    }
+    return cloneEmpty();
+  }
+}
+function writeStore(store) {
+  const file = storeFile();
+  import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  const fd = import_node_fs2.default.openSync(tmp, "w", 384);
+  try {
+    import_node_fs2.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs2.default.fsyncSync(fd);
+  } finally {
+    import_node_fs2.default.closeSync(fd);
+  }
+  import_node_fs2.default.renameSync(tmp, file);
+}
+function mutateStore(fn) {
+  const store = loadStore();
+  fn(store);
+  writeStore(store);
+  return store;
+}
+function projectIdForCwd(cwd) {
+  return (0, import_node_crypto.createHash)("sha256").update(import_node_path2.default.resolve(cwd)).digest("hex").slice(0, 16);
+}
+function newSessionId() {
+  return `s_${(0, import_node_crypto.randomBytes)(10).toString("hex")}`;
+}
+function upsertProject(input) {
+  const cwd = import_node_path2.default.resolve(input.cwd);
+  const id = projectIdForCwd(cwd);
+  let result;
+  mutateStore((store) => {
+    const existing = store.attachedProjects.find((p) => p.id === id);
+    if (existing) {
+      const merged = {
+        ...existing,
+        ...input,
+        id,
+        cwd,
+        sourceRoots: input.sourceRoots ?? existing.sourceRoots,
+        knownBundleUrls: input.knownBundleUrls ?? existing.knownBundleUrls,
+        pinnedSourceResolutions: input.pinnedSourceResolutions ?? existing.pinnedSourceResolutions,
+        telemetry: input.telemetry ?? existing.telemetry,
+        updatedAt: Date.now(),
+        createdAt: existing.createdAt
+      };
+      const idx = store.attachedProjects.indexOf(existing);
+      store.attachedProjects[idx] = merged;
+      result = merged;
+      return;
+    }
+    const now = Date.now();
+    const created = {
+      id,
+      name: input.name ?? import_node_path2.default.basename(cwd),
+      cwd,
+      repoRoot: input.repoRoot,
+      sourceRoots: input.sourceRoots ?? [cwd],
+      framework: input.framework ?? "unknown",
+      bundleId: input.bundleId,
+      knownBundleUrls: input.knownBundleUrls ?? [],
+      preferredProvider: input.preferredProvider ?? "codex",
+      preferredTransport: input.preferredTransport ?? "tmux",
+      editorOpenCommand: input.editorOpenCommand,
+      moshiWebhookToken: input.moshiWebhookToken,
+      pinnedSourceResolutions: input.pinnedSourceResolutions ?? {},
+      isolateDiscovery: input.isolateDiscovery,
+      git: input.git,
+      telemetry: input.telemetry ?? { lastOpened: 0, runsCompleted: 0 },
+      createdAt: now,
+      updatedAt: now
+    };
+    store.attachedProjects.push(created);
+    result = created;
+  });
+  return result;
+}
+function findProjectById(id) {
+  return loadStore().attachedProjects.find((p) => p.id === id) ?? null;
+}
+function listProjects() {
+  return loadStore().attachedProjects;
+}
+var COST_HISTORY_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+function recordTurnTelemetry(projectId, input = {}) {
+  mutateStore((store) => {
+    const project = store.attachedProjects.find((p) => p.id === projectId);
+    if (!project) return;
+    const ts = input.ts ?? Date.now();
+    project.telemetry.runsCompleted = (project.telemetry.runsCompleted ?? 0) + 1;
+    if (typeof input.usd === "number" && Number.isFinite(input.usd) && input.usd >= 0) {
+      const history = project.telemetry.costHistory ?? [];
+      const cutoff = ts - COST_HISTORY_MAX_AGE_MS;
+      const trimmed = history.filter((e) => e.ts >= cutoff);
+      trimmed.push({ ts, usd: input.usd });
+      project.telemetry.costHistory = trimmed;
+    }
+    project.updatedAt = ts;
+  });
+}
+function deleteProject(id) {
+  mutateStore((store) => {
+    store.attachedProjects = store.attachedProjects.filter((p) => p.id !== id);
+    store.agentSessions = store.agentSessions.filter((s) => s.projectId !== id);
+    store.previewAttachments = store.previewAttachments.filter(
+      (pa) => pa.projectId !== id
+    );
+  });
+}
+function upsertSession(input) {
+  let result;
+  mutateStore((store) => {
+    if (input.id) {
+      const existing = store.agentSessions.find((s) => s.id === input.id);
+      if (existing) {
+        const merged = {
+          ...existing,
+          ...input,
+          lastSeenAt: Date.now()
+        };
+        const idx = store.agentSessions.indexOf(existing);
+        store.agentSessions[idx] = merged;
+        result = merged;
+        return;
+      }
+    }
+    const project = store.attachedProjects.find((p) => p.id === input.projectId);
+    if (!project) {
+      throw new Error(`upsertSession: no AttachedProject with id=${input.projectId}`);
+    }
+    const now = Date.now();
+    const created = {
+      id: input.id ?? newSessionId(),
+      projectId: input.projectId,
+      provider: input.provider,
+      transport: input.transport ?? project.preferredTransport,
+      cwd: input.cwd ?? project.cwd,
+      claudeSessionUuid: input.claudeSessionUuid,
+      tmuxSessionName: input.tmuxSessionName,
+      wrapperPid: input.wrapperPid,
+      status: input.status ?? "idle",
+      needsAttention: input.needsAttention ?? false,
+      lastPrompt: input.lastPrompt,
+      lastSummary: input.lastSummary,
+      lastTurnFiles: input.lastTurnFiles,
+      currentlyEditing: input.currentlyEditing,
+      lastSeenAt: now,
+      createdAt: now
+    };
+    store.agentSessions.push(created);
+    result = created;
+  });
+  return result;
+}
+function findSessionById(id) {
+  return loadStore().agentSessions.find((s) => s.id === id) ?? null;
+}
+function listSessions(projectId) {
+  const all = loadStore().agentSessions;
+  return projectId ? all.filter((s) => s.projectId === projectId) : all;
+}
+function updateSessionStatus(id, patch) {
+  mutateStore((store) => {
+    const existing = store.agentSessions.find((s) => s.id === id);
+    if (!existing) return;
+    const idx = store.agentSessions.indexOf(existing);
+    store.agentSessions[idx] = {
+      ...existing,
+      ...patch,
+      id: existing.id,
+      projectId: existing.projectId,
+      createdAt: existing.createdAt,
+      lastSeenAt: Date.now()
+    };
+  });
+}
+async function seedFromDemoAppRegistry() {
+  const existing = loadStore().attachedProjects;
+  if (existing.length > 0) return;
+  let APPS2;
+  try {
+    const mod = await import("sootsim/scripts/demo-app-registry");
+    APPS2 = mod.APPS;
+  } catch (err) {
+    console.warn(
+      "[sootsim] seedFromDemoAppRegistry: could not load demo registry:",
+      err.message
+    );
+    return;
+  }
+  if (!Array.isArray(APPS2)) return;
+  const apps = APPS2;
+  mutateStore((store) => {
+    for (const app of apps) {
+      if (!import_node_fs2.default.existsSync(app.dir)) continue;
+      const cwd = import_node_path2.default.resolve(app.dir);
+      const id = projectIdForCwd(cwd);
+      if (store.attachedProjects.some((p) => p.id === id)) continue;
+      const now = Date.now();
+      store.attachedProjects.push({
+        id,
+        name: app.label,
+        cwd,
+        sourceRoots: [cwd],
+        framework: app.framework,
+        knownBundleUrls: [`http://localhost:${app.preferredPort}/index.bundle`],
+        preferredProvider: "codex",
+        preferredTransport: "tmux",
+        pinnedSourceResolutions: {},
+        telemetry: { lastOpened: 0, runsCompleted: 0 },
+        createdAt: now,
+        updatedAt: now
+      });
+    }
+  });
+}
+
+// src/agent-sessions.ts
+function sessionDir(sessionId) {
+  return import_node_path3.default.join(getUserDataDir(), "sessions", sessionId);
+}
+function promptFifoPath(sessionId) {
+  return import_node_path3.default.join(sessionDir(sessionId), "prompt.in");
+}
+function eventsFifoPath(sessionId) {
+  return import_node_path3.default.join(sessionDir(sessionId), "events.out");
+}
+function transcriptPath(sessionId) {
+  return import_node_path3.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
+}
+function pidIsAlive(pid, sessionId) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return false;
+  }
+  if (sessionId) {
+    if (!import_node_fs3.default.existsSync(sessionDir(sessionId))) return false;
+  }
+  return true;
+}
+function resolveSootsimInvocation() {
+  if (process.env.SOOTSIM_BIN) {
+    return { cmd: process.env.SOOTSIM_BIN, prefixArgs: [] };
+  }
+  if (process.versions.electron) {
+    const resourcesPath = process.resourcesPath;
+    if (resourcesPath) {
+      const candidates = [
+        import_node_path3.default.join(resourcesPath, "bin", "sootsim"),
+        import_node_path3.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
+      ];
+      for (const c of candidates) {
+        if (import_node_fs3.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
+      }
+    }
+  }
+  const workspace = tryWorkspaceSootsim();
+  if (workspace) return workspace;
+  const argv0 = process.argv[0];
+  const argv1 = process.argv[1];
+  if (argv1 && /\.(ts|tsx|mjs|cjs|js)$/.test(argv1)) {
+    return { cmd: argv0, prefixArgs: [argv1] };
+  }
+  if (!argv1 || argv1.includes("/.bin/")) {
+    throw new Error(
+      "sootsim CLI not found. set SOOTSIM_BIN to the path of the sootsim binary, or build the workspace CLI via `bun run --cwd packages/sootsim build:cli`."
+    );
+  }
+  return { cmd: argv0, prefixArgs: [] };
+}
+function tryWorkspaceSootsim() {
+  try {
+    const sootsimDir = resolveSootsimPackageDir();
+    if (!sootsimDir) return null;
+    const binaryName = `sootsim-${process.platform}-${process.arch}`;
+    const distBinary = import_node_path3.default.join(sootsimDir, "dist-bin", binaryName);
+    if (import_node_fs3.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
+    const distBin = import_node_path3.default.join(sootsimDir, "dist-cli", "bin.js");
+    if (import_node_fs3.default.existsSync(distBin)) {
+      try {
+        const src = import_node_path3.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
+        if (import_node_fs3.default.existsSync(src)) {
+          const srcMtime = import_node_fs3.default.statSync(src).mtimeMs;
+          const buildMtime = import_node_fs3.default.statSync(distBin).mtimeMs;
+          if (buildMtime < srcMtime) {
+            console.warn(
+              `[sootsim] dist-cli/bin.js is older than agent-wrapper.ts \u2014 rebuild with \`bun run --cwd packages/sootsim build:cli\` (watch:cli:binary builds dist-bin/ instead).`
+            );
+          }
+        }
+      } catch {
+      }
+      return { cmd: process.execPath, prefixArgs: [distBin] };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function resolveSootsimPackageDir() {
+  try {
+    const resolved = require.resolve("sootsim/package.json");
+    return import_node_path3.default.dirname(resolved);
+  } catch {
+  }
+  const here = fileFromImportMeta();
+  if (!here) return null;
+  let cur = import_node_path3.default.dirname(here);
+  for (let i = 0; i < 8; i++) {
+    const pkg = import_node_path3.default.join(cur, "package.json");
+    try {
+      if (import_node_fs3.default.existsSync(pkg)) {
+        const parsed = JSON.parse(import_node_fs3.default.readFileSync(pkg, "utf8"));
+        if (parsed.name === "sootsim") return cur;
+      }
+    } catch {
+    }
+    const parent = import_node_path3.default.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return null;
+}
+function fileFromImportMeta() {
+  try {
+    const url = __sootsim_import_meta_url;
+    if (!url || !url.startsWith("file://")) return null;
+    return decodeURIComponent(url.slice("file://".length));
+  } catch {
+    return null;
+  }
+}
+async function withStartLock(projectId, provider, fn) {
+  const lockDir = import_node_path3.default.join(getUserDataDir(), "locks");
+  import_node_fs3.default.mkdirSync(lockDir, { recursive: true });
+  try {
+    import_node_fs3.default.chmodSync(lockDir, 448);
+  } catch {
+  }
+  const lockPath = import_node_path3.default.join(lockDir, `start-${projectId}-${provider}.lock`);
+  const deadline = Date.now() + 4e3;
+  let fd = null;
+  while (fd === null) {
+    try {
+      fd = import_node_fs3.default.openSync(
+        lockPath,
+        import_node_fs3.constants.O_WRONLY | import_node_fs3.constants.O_CREAT | import_node_fs3.constants.O_EXCL,
+        384
+      );
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      try {
+        const stale = Number(import_node_fs3.default.readFileSync(lockPath, "utf8").trim());
+        if (stale && !isProcessAlive(stale)) {
+          import_node_fs3.default.unlinkSync(lockPath);
+          continue;
+        }
+      } catch {
+      }
+      if (Date.now() > deadline) {
+        throw new Error(
+          `another start is in progress for project=${projectId} provider=${provider} (lock: ${lockPath})`
+        );
+      }
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+  try {
+    import_node_fs3.default.writeFileSync(fd, String(process.pid));
+    return await fn();
+  } finally {
+    try {
+      import_node_fs3.default.closeSync(fd);
+    } catch {
+    }
+    try {
+      import_node_fs3.default.unlinkSync(lockPath);
+    } catch {
+    }
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function mkfifoSync(p) {
+  const parent = import_node_path3.default.dirname(p);
+  import_node_fs3.default.mkdirSync(parent, { recursive: true });
+  try {
+    import_node_fs3.default.chmodSync(parent, 448);
+  } catch {
+  }
+  if (import_node_fs3.default.existsSync(p)) {
+    try {
+      const stat = import_node_fs3.default.statSync(p);
+      if (stat.isFIFO()) {
+        try {
+          import_node_fs3.default.chmodSync(p, 384);
+        } catch {
+        }
+        return;
+      }
+      import_node_fs3.default.unlinkSync(p);
+    } catch {
+      import_node_fs3.default.unlinkSync(p);
+    }
+  }
+  const result = (0, import_node_child_process.spawnSync)("mkfifo", ["-m", "600", p]);
+  if (result.status !== 0) {
+    throw new Error(
+      `mkfifo(${p}) failed: ${result.stderr?.toString().trim() || "unknown error"}`
+    );
+  }
+}
+var AgentSessionError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+async function startSession(opts) {
+  const project = findProjectById(opts.projectId);
+  if (!project) {
+    throw new AgentSessionError("NO_PROJECT", `no project with id=${opts.projectId}`);
+  }
+  const provider = opts.provider || project.preferredProvider || "codex";
+  return withStartLock(project.id, provider, async () => {
+    const existingLive = listSessions(project.id).find(
+      (s) => s.provider === provider && s.status !== "ended" && pidIsAlive(s.wrapperPid, s.id)
+    );
+    if (existingLive) {
+      throw new AgentSessionError(
+        "ALREADY_RUNNING",
+        `session already running for project=${project.id} provider=${provider} (session ${existingLive.id}, pid ${existingLive.wrapperPid}). end it first with \`sootsim agent end <sessionId>\`.`
+      );
+    }
+    const claudeSessionUuid = provider === "claude" ? (0, import_node_crypto2.randomUUID)() : void 0;
+    const session = upsertSession({
+      projectId: project.id,
+      provider,
+      transport: "pty",
+      cwd: project.cwd,
+      status: "idle",
+      claudeSessionUuid
+    });
+    const promptIn = promptFifoPath(session.id);
+    const eventsOut = eventsFifoPath(session.id);
+    const transcript = transcriptPath(session.id);
+    mkfifoSync(promptIn);
+    mkfifoSync(eventsOut);
+    const transcriptDir = import_node_path3.default.dirname(transcript);
+    import_node_fs3.default.mkdirSync(transcriptDir, { recursive: true });
+    try {
+      import_node_fs3.default.chmodSync(transcriptDir, 448);
+    } catch {
+    }
+    const { cmd, prefixArgs } = resolveSootsimInvocation();
+    const wrapperArgs = [
+      ...prefixArgs,
+      "agent-wrapper",
+      "--session-id",
+      session.id,
+      "--project-id",
+      project.id,
+      "--provider",
+      provider,
+      "--cwd",
+      project.cwd,
+      "--prompt-in",
+      promptIn,
+      "--events-out",
+      eventsOut,
+      "--transcript",
+      transcript
+    ];
+    if (opts.codexBin) wrapperArgs.push("--codex-bin", opts.codexBin);
+    if (opts.claudeBin) wrapperArgs.push("--claude-bin", opts.claudeBin);
+    if (claudeSessionUuid) {
+      wrapperArgs.push("--claude-session-uuid", claudeSessionUuid);
+    }
+    const child = (0, import_node_child_process.spawn)(cmd, wrapperArgs, {
+      detached: true,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        SOOTSIM_USER_DATA_DIR: getUserDataDir()
+      }
+    });
+    child.unref();
+    const readyTimeout = opts.readyTimeoutMs ?? 6e3;
+    const boot = await waitForFirstEvent(
+      eventsOut,
+      (e) => e.type === "ready" || e.type === "error",
+      readyTimeout
+    );
+    if (!boot || boot.type === "error") {
+      if (child.pid) {
+        try {
+          process.kill(child.pid, "SIGTERM");
+        } catch {
+        }
+      }
+      try {
+        import_node_fs3.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
+      } catch {
+      }
+      updateSessionStatus(session.id, { status: "ended" });
+      const reason = boot && boot.type === "error" ? boot.message : `no ready event within ${readyTimeout}ms`;
+      throw new AgentSessionError("WRAPPER_FAILED", reason);
+    }
+    updateSessionStatus(session.id, {
+      wrapperPid: child.pid,
+      status: "idle"
+    });
+    const updated = findSessionById(session.id);
+    return { session: updated, wrapperPid: child.pid };
+  });
+}
+async function sendPrompt(sessionId, prompt) {
+  const session = findSessionById(sessionId);
+  if (!session) {
+    throw new AgentSessionError("NO_SESSION", `no session with id=${sessionId}`);
+  }
+  if (!pidIsAlive(session.wrapperPid, sessionId)) {
+    updateSessionStatus(sessionId, { status: "ended" });
+    throw new AgentSessionError(
+      "NOT_ALIVE",
+      `session wrapper is not alive (pid=${session.wrapperPid}). start a new session.`
+    );
+  }
+  const fifo = promptFifoPath(sessionId);
+  if (!import_node_fs3.default.existsSync(fifo)) {
+    throw new AgentSessionError("NO_FIFO", `prompt FIFO missing: ${fifo}`);
+  }
+  const fd = import_node_fs3.default.openSync(fifo, import_node_fs3.constants.O_WRONLY);
+  try {
+    const wireText = encodeAgentPromptEnvelope(prompt);
+    if (!wireText) {
+      throw new AgentSessionError("EMPTY_PROMPT", "prompt text is empty");
+    }
+    import_node_fs3.default.writeSync(fd, wireText + "\n");
+  } finally {
+    import_node_fs3.default.closeSync(fd);
+  }
+  updateSessionStatus(sessionId, {
+    lastPrompt: prompt.displayText ?? prompt.text,
+    status: "working"
+  });
+}
+async function endSession(sessionId) {
+  const session = findSessionById(sessionId);
+  if (!session) {
+    throw new AgentSessionError("NO_SESSION", `no session with id=${sessionId}`);
+  }
+  if (pidIsAlive(session.wrapperPid, sessionId)) {
+    try {
+      process.kill(session.wrapperPid, "SIGTERM");
+    } catch {
+    }
+  }
+  const dir = sessionDir(sessionId);
+  const base = getUserDataDir();
+  if (dir.startsWith(base)) {
+    try {
+      import_node_fs3.default.rmSync(dir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  updateSessionStatus(sessionId, { status: "ended", wrapperPid: void 0 });
+}
+function subscribeEvents(sessionId, onEvent) {
+  const fifo = eventsFifoPath(sessionId);
+  if (!import_node_fs3.default.existsSync(fifo)) {
+    throw new AgentSessionError("NO_FIFO", `events FIFO missing: ${fifo}`);
+  }
+  const fd = import_node_fs3.default.openSync(fifo, import_node_fs3.constants.O_RDWR);
+  const stream = import_node_fs3.default.createReadStream("", { fd, autoClose: true });
+  const rl = import_node_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
+  rl.on("line", (line) => {
+    const event = parseAgentEventLine(line);
+    if (event) onEvent(event);
+  });
+  let closed = false;
+  return () => {
+    if (closed) return;
+    closed = true;
+    try {
+      rl.close();
+    } catch {
+    }
+    try {
+      stream.destroy();
+    } catch {
+    }
+  };
+}
+async function waitForFirstEvent(fifo, predicate, timeoutMs) {
+  const fd = import_node_fs3.default.openSync(fifo, import_node_fs3.constants.O_RDWR | import_node_fs3.constants.O_NONBLOCK);
+  const buf = Buffer.alloc(8192);
+  let leftover = "";
+  const deadline = Date.now() + timeoutMs;
+  try {
+    while (Date.now() < deadline) {
+      let n = 0;
+      try {
+        n = import_node_fs3.default.readSync(fd, buf, 0, buf.length, null);
+      } catch (err) {
+        if (err.code !== "EAGAIN") throw err;
+        n = 0;
+      }
+      if (n > 0) {
+        leftover += buf.subarray(0, n).toString("utf8");
+        let idx;
+        while ((idx = leftover.indexOf("\n")) >= 0) {
+          const line = leftover.slice(0, idx);
+          leftover = leftover.slice(idx + 1);
+          const event = parseAgentEventLine(line);
+          if (event && predicate(event)) return event;
+        }
+      } else {
+        await new Promise((r) => setTimeout(r, 30));
+      }
+    }
+    return null;
+  } finally {
+    import_node_fs3.default.closeSync(fd);
+  }
+}
+
+// src/host/agent-host.ts
+var WS_OPEN = 1;
+function defaultExcludePorts() {
+  return [
+    Number(process.env.VITE_PORT_WEB || process.env.PORT || 3e3),
+    Number(process.env.VITE_PORT_ZERO || 7849),
+    Number(process.env.VITE_PORT_POSTGRES || 7432),
+    Number(process.env.VITE_PORT_R2 || 9500)
+  ].filter((p) => Number.isFinite(p) && p > 0);
+}
+var AgentHost = class {
+  // live fan-out, keyed by sessionId. refcount tracks how many sockets have
+  // subscribed; the FIFO reader stays open as long as refcount > 0.
+  subscriptions = /* @__PURE__ */ new Map();
+  // per-socket subscription set so ws.close can clean up without scanning
+  // every session.
+  sessionsBySocket = /* @__PURE__ */ new Map();
+  // every connected socket (regardless of role) — gets session-status
+  // pushes so a CLI `sootsim agent sessions --watch` can react to state
+  // changes driven by another client.
+  allSockets = /* @__PURE__ */ new Set();
+  // agent wrappers also emit prompt-received from the FIFO reader, but the
+  // shell/daemon already knows the user-facing display text when send-prompt
+  // is accepted. emit the friendly prompt immediately and suppress the raw
+  // wrapper echoes that follow a moment later.
+  pendingPromptEchoes = /* @__PURE__ */ new Map();
+  // accepted prompts serialize inside the wrapper, so a second send while the
+  // session is already working becomes queued follow-up work. keep a small
+  // in-memory count so session status stays `working` until that backlog
+  // truly drains.
+  pendingTurns = /* @__PURE__ */ new Map();
+  opts;
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  registerSocket(ws) {
+    this.allSockets.add(ws);
+  }
+  unregisterSocket(ws) {
+    const sessions = this.sessionsBySocket.get(ws);
+    if (sessions) {
+      for (const sessionId of sessions) {
+        this.decrementSubscription(sessionId);
+      }
+      this.sessionsBySocket.delete(ws);
+    }
+    this.allSockets.delete(ws);
+  }
+  /** handle an agent:* message. returns true iff the message was recognized
+   *  as an agent message (so the caller knows to stop dispatching). */
+  async handleMessage(ws, msg) {
+    const type = msg?.type;
+    if (typeof type !== "string" || !type.startsWith("agent:")) return false;
+    const id = msg.id;
+    try {
+      const result = await this.dispatch(ws, type, msg);
+      this.respond(ws, id, result);
+    } catch (err) {
+      if (err instanceof AgentSessionError) {
+        this.respondError(ws, id, err.message, err.code);
+      } else {
+        this.respondError(ws, id, err instanceof Error ? err.message : String(err));
+      }
+    }
+    return true;
+  }
+  /** run once on daemon boot. idempotent — `seedFromDemoAppRegistry` no-ops
+   *  when the store already has projects. */
+  async seedOnBoot() {
+    try {
+      await seedFromDemoAppRegistry();
+    } catch (err) {
+      process.stderr.write(
+        `[sootsim-agent] seedFromDemoAppRegistry failed: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  /** terminate every subscription and drop every socket reference. called
+   *  by the bridge host during shutdown. */
+  close() {
+    for (const sub of this.subscriptions.values()) {
+      try {
+        sub.unsubscribe();
+      } catch {
+      }
+    }
+    this.subscriptions.clear();
+    this.sessionsBySocket.clear();
+    this.allSockets.clear();
+  }
+  // --- dispatch ---
+  async dispatch(ws, type, msg) {
+    switch (type) {
+      case "agent:list-projects":
+        return listProjects();
+      case "agent:upsert-project":
+        return upsertProject(msg.input ?? {});
+      case "agent:delete-project":
+        deleteProject(String(msg.projectId));
+        return { ok: true };
+      case "agent:auto-attach-for-url":
+        return this.autoAttachForUrl(msg.input ?? {});
+      case "agent:list-sessions":
+        return listSessions(msg.projectId ? String(msg.projectId) : void 0);
+      case "agent:start-session":
+        return this.doStartSession(msg.input ?? {});
+      case "agent:send-prompt": {
+        const sessionId = String(msg.sessionId);
+        const session = findSessionById(sessionId);
+        if (!session) {
+          throw new AgentSessionError("NO_SESSION", `no session: ${sessionId}`);
+        }
+        const prompt = this.normalizePromptEnvelope(msg);
+        await sendPrompt(sessionId, prompt);
+        return this.notePromptAccepted(sessionId, prompt, session.status === "working");
+      }
+      case "agent:end-session":
+        this.dropSessionFanout(String(msg.sessionId));
+        await endSession(String(msg.sessionId));
+        const ended = findSessionById(String(msg.sessionId));
+        if (ended) {
+          this.broadcastSessionStatus(ended);
+        }
+        return { ok: true };
+      case "agent:get-transcript":
+        return this.getTranscript(String(msg.sessionId));
+      case "agent:get-paths":
+        return this.getPaths();
+      case "agent:subscribe-events":
+        return this.subscribeSocket(ws, String(msg.sessionId));
+      case "agent:unsubscribe-events":
+        return this.unsubscribeSocket(ws, String(msg.sessionId));
+      default:
+        throw new AgentSessionError("UNKNOWN_AGENT_MSG", `unknown agent message: ${type}`);
+    }
+  }
+  // --- operation impls ---
+  async doStartSession(input) {
+    const project = findProjectById(input.projectId);
+    if (!project) {
+      throw new AgentSessionError("NO_PROJECT", `no project: ${input.projectId}`);
+    }
+    const result = await startSession(input);
+    this.broadcastSessionStatus(result.session);
+    return result;
+  }
+  async autoAttachForUrl(input) {
+    const bundleUrl = input.bundleUrl ?? "";
+    const targetPort = (() => {
+      try {
+        return new URL(bundleUrl).port || null;
+      } catch {
+        return null;
+      }
+    })();
+    if (!targetPort) return { project: null };
+    const excludePorts = this.opts.getExcludePorts?.() ?? defaultExcludePorts();
+    const servers = await scanDevServers({ excludePorts });
+    const match = servers.find((s) => String(s.port) === targetPort);
+    if (!match || !match.cwd) return { project: null };
+    const existing = listProjects().find((p) => p.cwd === match.cwd) ?? null;
+    const knownBundleUrls = Array.from(
+      /* @__PURE__ */ new Set([...existing?.knownBundleUrls ?? [], match.bundleUrl, bundleUrl])
+    );
+    const project = upsertProject({
+      cwd: match.cwd,
+      name: match.projectName ?? import_node_path4.default.basename(match.cwd),
+      preferredProvider: input.provider ?? existing?.preferredProvider,
+      sourceRoots: existing?.sourceRoots ?? [match.cwd],
+      knownBundleUrls,
+      framework: existing?.framework ?? mapFrameworkToProjectFramework(match.framework),
+      bundleId: match.bundleId ?? existing?.bundleId
+    });
+    return { project };
+  }
+  getTranscript(sessionId) {
+    const p = transcriptPath(sessionId);
+    if (!import_node_fs4.default.existsSync(p)) {
+      return { error: "transcript not found", code: "NO_TRANSCRIPT" };
+    }
+    return import_node_fs4.default.readFileSync(p, "utf8");
+  }
+  getPaths() {
+    const dir = getUserDataDir();
+    return {
+      userDataDir: dir,
+      storeFile: import_node_path4.default.join(dir, "attached-projects.json"),
+      sessionsDir: import_node_path4.default.join(dir, "sessions"),
+      transcriptsDir: import_node_path4.default.join(dir, "transcripts")
+    };
+  }
+  // --- subscription management ---
+  subscribeSocket(ws, sessionId) {
+    let sockets = this.sessionsBySocket.get(ws);
+    if (!sockets) {
+      sockets = /* @__PURE__ */ new Set();
+      this.sessionsBySocket.set(ws, sockets);
+    }
+    if (sockets.has(sessionId)) {
+      return { ok: true, refCount: this.subscriptions.get(sessionId)?.refCount ?? 1 };
+    }
+    sockets.add(sessionId);
+    const existing = this.subscriptions.get(sessionId);
+    if (existing) {
+      existing.refCount++;
+      return { ok: true, refCount: existing.refCount };
+    }
+    const unsubscribe = subscribeEvents(sessionId, (event) => {
+      const coalesced = this.coalescePromptEcho(sessionId, event);
+      if (coalesced) {
+        this.applySessionEvent(sessionId, coalesced);
+        this.fanOutEvent(sessionId, coalesced);
+      }
+      if (event.type === "turn-completed") {
+        const session = findSessionById(sessionId);
+        if (session) {
+          try {
+            recordTurnTelemetry(session.projectId, {
+              usd: event.costUsd,
+              ts: event.ts
+            });
+          } catch (err) {
+            process.stderr.write(
+              `[sootsim-agent] recordTurnTelemetry failed: ${err instanceof Error ? err.message : String(err)}
+`
+            );
+          }
+        }
+      }
+    });
+    this.subscriptions.set(sessionId, { unsubscribe, refCount: 1 });
+    return { ok: true, refCount: 1 };
+  }
+  unsubscribeSocket(ws, sessionId) {
+    const sockets = this.sessionsBySocket.get(ws);
+    if (!sockets || !sockets.has(sessionId)) return { ok: true, refCount: 0 };
+    sockets.delete(sessionId);
+    return this.decrementSubscription(sessionId);
+  }
+  decrementSubscription(sessionId) {
+    const existing = this.subscriptions.get(sessionId);
+    if (!existing) return { ok: true, refCount: 0 };
+    existing.refCount--;
+    if (existing.refCount <= 0) {
+      try {
+        existing.unsubscribe();
+      } catch {
+      }
+      this.subscriptions.delete(sessionId);
+      return { ok: true, refCount: 0 };
+    }
+    return { ok: true, refCount: existing.refCount };
+  }
+  /** end-session tears the FIFO down, so drop our reader before it
+   *  disappears regardless of remaining subscriber refcount. */
+  dropSessionFanout(sessionId) {
+    const existing = this.subscriptions.get(sessionId);
+    if (existing) {
+      try {
+        existing.unsubscribe();
+      } catch {
+      }
+      this.subscriptions.delete(sessionId);
+    }
+    for (const sockets of this.sessionsBySocket.values()) {
+      sockets.delete(sessionId);
+    }
+    this.clearPromptTracking(sessionId);
+  }
+  // --- wire pushes + responses ---
+  normalizePromptEnvelope(msg) {
+    if (msg?.prompt && typeof msg.prompt === "object") {
+      const prompt = msg.prompt;
+      return {
+        text: String(prompt.text ?? ""),
+        ...typeof prompt.displayText === "string" ? { displayText: prompt.displayText } : {},
+        ...typeof prompt.inspectSummary === "string" ? { inspectSummary: prompt.inspectSummary } : {},
+        ...typeof prompt.inspectTrace === "string" ? { inspectTrace: prompt.inspectTrace } : {}
+      };
+    }
+    return {
+      text: String(msg?.text ?? ""),
+      ...typeof msg?.displayText === "string" ? { displayText: msg.displayText } : {},
+      ...typeof msg?.inspectSummary === "string" ? { inspectSummary: msg.inspectSummary } : {},
+      ...typeof msg?.inspectTrace === "string" ? { inspectTrace: msg.inspectTrace } : {}
+    };
+  }
+  notePromptAccepted(sessionId, prompt, assumeQueued) {
+    const now = Date.now();
+    const echoes = this.pendingPromptEchoes.get(sessionId) ?? [];
+    echoes.push({ sentAt: now });
+    this.pendingPromptEchoes.set(sessionId, echoes);
+    const pendingTurns = Math.max(this.pendingTurns.get(sessionId) ?? 0, assumeQueued ? 1 : 0) + 1;
+    this.pendingTurns.set(sessionId, pendingTurns);
+    const promptText = prompt.displayText ?? prompt.text;
+    this.patchSession(sessionId, {
+      lastPrompt: promptText,
+      status: "working",
+      needsAttention: false
+    });
+    this.fanOutEvent(sessionId, {
+      type: "prompt-received",
+      text: promptText,
+      ...prompt.inspectSummary ? { inspectSummary: prompt.inspectSummary } : {},
+      ...prompt.inspectTrace ? { inspectTrace: prompt.inspectTrace } : {},
+      ts: now
+    });
+    return {
+      ok: true,
+      queued: pendingTurns > 1,
+      pendingTurns,
+      queueDepth: Math.max(0, pendingTurns - 1)
+    };
+  }
+  applySessionEvent(sessionId, event) {
+    switch (event.type) {
+      case "prompt-received":
+      case "turn-started":
+        this.patchSession(sessionId, {
+          status: "working",
+          needsAttention: false
+        });
+        return;
+      case "turn-completed": {
+        const pendingTurns = this.consumeSettledTurn(sessionId);
+        this.patchSession(sessionId, {
+          status: pendingTurns > 0 ? "working" : "idle",
+          needsAttention: false,
+          lastTurnFiles: event.filesTouched,
+          currentlyEditing: void 0
+        });
+        return;
+      }
+      case "approval-needed":
+        this.patchSession(sessionId, {
+          status: "needs-attention",
+          needsAttention: true
+        });
+        return;
+      case "error": {
+        const pendingTurns = this.consumeSettledTurn(sessionId);
+        this.patchSession(sessionId, {
+          status: pendingTurns > 0 ? "working" : "needs-attention",
+          needsAttention: pendingTurns <= 0,
+          currentlyEditing: void 0
+        });
+        return;
+      }
+      case "exited":
+        this.clearPromptTracking(sessionId);
+        this.patchSession(sessionId, {
+          status: "ended",
+          needsAttention: false,
+          wrapperPid: void 0,
+          currentlyEditing: void 0
+        });
+        return;
+      case "ready":
+      case "turn-reasoning":
+      case "turn-message":
+      case "turn-plan":
+      case "tool-call":
+      case "file-edited":
+      case "file-diff-delta":
+        return;
+    }
+  }
+  patchSession(sessionId, patch) {
+    updateSessionStatus(sessionId, patch);
+    const updated = findSessionById(sessionId);
+    if (updated) {
+      this.broadcastSessionStatus(updated);
+    }
+  }
+  coalescePromptEcho(sessionId, event) {
+    if (event.type !== "prompt-received") return event;
+    const pending = this.pendingPromptEchoes.get(sessionId);
+    if (!pending || pending.length === 0) return event;
+    while (pending.length > 0 && Date.now() - pending[0].sentAt > 15e3) {
+      pending.shift();
+    }
+    if (pending.length === 0) {
+      this.pendingPromptEchoes.delete(sessionId);
+      return event;
+    }
+    pending.shift();
+    if (pending.length === 0) {
+      this.pendingPromptEchoes.delete(sessionId);
+    } else {
+      this.pendingPromptEchoes.set(sessionId, pending);
+    }
+    return null;
+  }
+  consumeSettledTurn(sessionId) {
+    const pendingTurns = Math.max(0, (this.pendingTurns.get(sessionId) ?? 1) - 1);
+    if (pendingTurns > 0) {
+      this.pendingTurns.set(sessionId, pendingTurns);
+    } else {
+      this.pendingTurns.delete(sessionId);
+    }
+    return pendingTurns;
+  }
+  clearPromptTracking(sessionId) {
+    this.pendingPromptEchoes.delete(sessionId);
+    this.pendingTurns.delete(sessionId);
+  }
+  fanOutEvent(sessionId, event) {
+    const payload = JSON.stringify({ type: "agent:event", sessionId, event });
+    for (const [ws, sessions] of this.sessionsBySocket) {
+      if (!sessions.has(sessionId)) continue;
+      if (ws.readyState !== WS_OPEN) continue;
+      try {
+        ws.send(payload);
+      } catch {
+      }
+    }
+  }
+  broadcastSessionStatus(session) {
+    const payload = JSON.stringify({ type: "agent:session-status", session });
+    for (const ws of this.allSockets) {
+      if (ws.readyState !== WS_OPEN) continue;
+      try {
+        ws.send(payload);
+      } catch {
+      }
+    }
+  }
+  respond(ws, id, result) {
+    if (ws.readyState !== WS_OPEN) return;
+    try {
+      ws.send(JSON.stringify({ id, result }));
+    } catch {
+    }
+  }
+  respondError(ws, id, error, code) {
+    if (ws.readyState !== WS_OPEN) return;
+    try {
+      ws.send(JSON.stringify({ id, error, ...code ? { code } : {} }));
+    } catch {
+    }
+  }
+};
+function mapFrameworkToProjectFramework(fw) {
+  if (fw === "expo") return "expo";
+  if (fw === "one" || fw === "vxrn") return "one";
+  return "unknown";
+}
+
+// src/host/bridge-host.ts
+var WRITE_COMMAND_TYPES = /* @__PURE__ */ new Set(["tap", "keyboard", "close"]);
+function shouldAcquireLease(msg) {
+  if (!msg || typeof msg.type !== "string") return false;
+  if (msg.acquireLock === true) return true;
+  if (msg.readOnly === true) return false;
+  return WRITE_COMMAND_TYPES.has(msg.type);
+}
+var DAEMON_HEARTBEAT_INTERVAL_MS = 5e3;
+var HTTP_MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript",
+  ".cjs": "application/javascript",
+  ".mjs": "application/javascript",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".wasm": "application/wasm",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".map": "application/json",
+  ".txt": "text/plain; charset=utf-8"
+};
+var SootSimBridgeHost = class _SootSimBridgeHost {
+  port;
+  openUrlHandler;
+  httpServer = null;
+  wss = null;
+  nextCommandId = 1;
+  nextBrowserId = 1;
+  browsers = /* @__PURE__ */ new Map();
+  primaryBrowserId = null;
+  pendingCommands = /* @__PURE__ */ new Map();
+  cliBySentId = /* @__PURE__ */ new Map();
+  cliBrowserBySocket = /* @__PURE__ */ new Map();
+  cliLastCommandAt = /* @__PURE__ */ new Map();
+  cliSessionKeyBySocket = /* @__PURE__ */ new Map();
+  cliLabelBySocket = /* @__PURE__ */ new Map();
+  restorableBrowsers = /* @__PURE__ */ new Map();
+  nextCliFallbackId = 1;
+  cliIdleTimer = null;
+  agentHost;
+  static CLI_IDLE_TIMEOUT_MS = 6e4;
+  static CLI_LEASE_TTL_MS = 6e5;
+  static USER_ACTIVE_LEASE_TTL_MS = 8e3;
+  static BROWSER_RECONNECT_TTL_MS = 3e4;
+  preferredPort;
+  portFallbackCount;
+  shouldWriteLockfile;
+  effectivePort = 0;
+  startedAt = 0;
+  heartbeatTimer = null;
+  activeRuntimeVersion = null;
+  activeRuntimeDirPath = null;
+  constructor(opts = {}) {
+    this.preferredPort = opts.port || DEFAULT_SOOTSIM_BRIDGE_PORT;
+    this.port = this.preferredPort;
+    this.shouldWriteLockfile = opts.writeLockfile === true;
+    const defaultFallback = this.shouldWriteLockfile ? 1 : 10;
+    this.portFallbackCount = Math.max(1, opts.portFallbackCount ?? defaultFallback);
+    this.openUrlHandler = opts.openUrl;
+    this.agentHost = new AgentHost({ getExcludePorts: opts.agentScanExcludes });
+  }
+  /** expose the agent host so tests and embedders can inspect state or
+   *  inject behavior. not part of the public WS protocol. */
+  getAgentHost() {
+    return this.agentHost;
+  }
+  /** synchronous wrapper around startAsync for callers that don't care
+   *  about port fallback outcomes. returns immediately; actual binding
+   *  happens on the event loop. callers that need to know the bound port
+   *  should await startAsync() instead. */
+  start(options) {
+    void this.startAsync(options);
+  }
+  async startAsync(options) {
+    if (this.httpServer || this.wss) return this.effectivePort;
+    this.refreshActiveRuntime();
+    for (let attempt = 0; attempt < this.portFallbackCount; attempt++) {
+      const candidate = this.preferredPort + attempt;
+      try {
+        await this.bindOnce(candidate, options?.silent === true);
+        this.effectivePort = candidate;
+        this.port = candidate;
+        this.startedAt = Date.now();
+        if (attempt > 0 && !options?.silent) {
+          process.stderr.write(
+            `ws bridge bound to port ${candidate} (preferred ${this.preferredPort} was taken)
+`
+          );
+        }
+        this.afterBind();
+        return candidate;
+      } catch (err) {
+        const e = err;
+        if (e?.code !== "EADDRINUSE") {
+          throw err;
+        }
+        if (!options?.silent) {
+          process.stderr.write(
+            `ws bridge port ${candidate} already in use, trying ${candidate + 1}
+`
+          );
+        }
+      }
+    }
+    throw new Error(
+      `could not bind ws bridge after ${this.portFallbackCount} attempts starting at ${this.preferredPort}`
+    );
+  }
+  bindOnce(port, _silent) {
+    return new Promise((resolve2, reject) => {
+      const server = (0, import_http2.createServer)((req, res) => this.handleHttpRequest(req, res));
+      let settled = false;
+      const onError = (err) => {
+        if (settled) return;
+        settled = true;
+        try {
+          server.close();
+        } catch {
+        }
+        this.httpServer = null;
+        this.wss = null;
+        reject(err);
+      };
+      server.once("error", onError);
+      server.listen(port, "127.0.0.1", () => {
+        if (settled) return;
+        settled = true;
+        server.removeListener("error", onError);
+        server.on("error", (err) => {
+          process.stderr.write(`ws bridge http error: ${String(err)}
+`);
+        });
+        this.httpServer = server;
+        this.wss = new import_ws.WebSocketServer({ server });
+        this.wireWebSocketServer();
+        resolve2();
+      });
+    });
+  }
+  /** attach the WS connection handler to the current wss. called from
+   *  bindOnce() after WebSocketServer is freshly created. */
+  wireWebSocketServer() {
+    if (!this.wss) return;
+    this.wss.on("connection", (ws, req) => {
+      const origin = req.headers.origin;
+      const role = origin ? "browser" : "cli";
+      let browser = null;
+      this.agentHost.registerSocket(ws);
+      if (role === "browser") {
+        browser = {
+          id: `tab-${this.nextBrowserId++}`,
+          ws,
+          origin,
+          connectedAt: Date.now(),
+          lastSeenAt: Date.now(),
+          lastActiveAt: 0,
+          recentActions: []
+        };
+        this.browsers.set(browser.id, browser);
+        if (this.shouldPromoteBrowser(browser)) {
+          this.primaryBrowserId = browser.id;
+        }
+        this.broadcastBrowserAssignments();
+        this.broadcastBrowserClientStates();
+      } else {
+        const fallbackKey = `ws-${this.nextCliFallbackId++}`;
+        this.cliSessionKeyBySocket.set(ws, fallbackKey);
+      }
+      ws.on("message", (data) => {
+        let msg;
+        try {
+          msg = JSON.parse(data.toString());
+        } catch {
+          return;
+        }
+        if (!msg || typeof msg !== "object") return;
+        if (typeof msg.type === "string" && msg.type.startsWith("agent:")) {
+          void this.agentHost.handleMessage(ws, msg);
+          return;
+        }
+        if (msg.type === "runtime:list") {
+          const versions = listInstalledRuntimes();
+          const active = this.getActiveRuntime();
+          const reply = {
+            type: "runtime:list:ok",
+            id: msg.id,
+            installed: versions,
+            active: active.version,
+            activeRuntimeDir: active.runtimeDir
+          };
+          try {
+            ws.send(JSON.stringify(reply));
+          } catch {
+          }
+          return;
+        }
+        if (msg.type === "runtime:use") {
+          const version = typeof msg.version === "string" ? msg.version : "";
+          const installed = listInstalledRuntimes();
+          if (!installed.includes(version)) {
+            try {
+              ws.send(
+                JSON.stringify({
+                  type: "runtime:use:error",
+                  id: msg.id,
+                  error: `runtime ${version || "(missing)"} is not installed`
+                })
+              );
+            } catch {
+            }
+            return;
+          }
+          const result = this.setActiveRuntime(version);
+          try {
+            ws.send(
+              JSON.stringify({
+                type: "runtime:use:ok",
+                id: msg.id,
+                version: result.version,
+                runtimeDir: result.runtimeDir
+              })
+            );
+          } catch {
+          }
+          return;
+        }
+        if (msg.type === "runtime:get") {
+          const active = this.getActiveRuntime();
+          try {
+            ws.send(
+              JSON.stringify({
+                type: "runtime:get:ok",
+                id: msg.id,
+                active: active.version,
+                activeRuntimeDir: active.runtimeDir
+              })
+            );
+          } catch {
+          }
+          return;
+        }
+        if (role === "browser") {
+          if (browser) {
+            browser.lastSeenAt = Date.now();
+          }
+          if (msg.type === "bridge:register" && browser) {
+            const registration = msg;
+            const restored = this.tryRestoreBrowserId(browser, registration.browserId);
+            browser.url = registration.url;
+            browser.title = registration.title;
+            browser.userAgent = registration.userAgent;
+            if (restored) {
+              this.broadcastBrowserAssignments();
+              this.broadcastBrowserClientStates();
+            }
+            return;
+          }
+          if (msg.type === "bridge:user-focus-state" && browser) {
+            const focusState = msg;
+            this.updateUserFocusLease(browser, focusState.focused === true);
+            return;
+          }
+          if (msg.type === "bridge:user-interact" && browser) {
+            this.updateUserActivity(browser);
+            return;
+          }
+          if (msg.type === "bridge:open-path") {
+            const filePath = typeof msg.path === "string" ? msg.path : "";
+            const line = typeof msg.line === "number" && Number.isFinite(msg.line) ? msg.line : void 0;
+            const column = typeof msg.column === "number" && Number.isFinite(msg.column) ? msg.column : void 0;
+            if (filePath) {
+              void this.openPathInEditor(filePath, line, column);
+            }
+            return;
+          }
+          if (msg.type === "bridge:boot-clients" && browser) {
+            const booted = [];
+            for (const [cliWs, attachedBrowserId] of this.cliBrowserBySocket) {
+              if (attachedBrowserId === browser.id) {
+                booted.push(cliWs);
+              }
+            }
+            for (const cliWs of booted) {
+              this.cliBrowserBySocket.delete(cliWs);
+              try {
+                cliWs.close(1e3, "booted by browser");
+              } catch {
+              }
+            }
+            const hadLease = !!browser.cliLease;
+            browser.cliLease = void 0;
+            if (booted.length > 0 || hadLease) {
+              process.stderr.write(
+                `sootsim booted ${booted.length} cli client(s)${hadLease ? " + cleared lease" : ""} from [${browser.id}]
+`
+              );
+              this.recordBrowserAction(browser.id, "browser booted cli clients");
+              this.broadcastBrowserClientStates();
+            }
+            return;
+          }
+          const internalPending = this.pendingCommands.get(msg.id);
+          if (internalPending) {
+            this.pendingCommands.delete(msg.id);
+            if (msg.error) internalPending.reject(new Error(msg.error));
+            else internalPending.resolve(msg.result);
+            return;
+          }
+          const entry = this.cliBySentId.get(msg.id);
+          if (entry) {
+            this.cliBySentId.delete(msg.id);
+            if (entry.ws.readyState === import_ws.WebSocket.OPEN) {
+              const otherCliCount = this.getOtherCliSessionCount(
+                entry.ws,
+                entry.browserId
+              );
+              const response = otherCliCount > 0 ? { ...msg, id: entry.originalId, _otherCliCount: otherCliCount } : { ...msg, id: entry.originalId };
+              entry.ws.send(JSON.stringify(response));
+            }
+          }
+          return;
+        }
+        void (async () => {
+          this.cliLastCommandAt.set(ws, Date.now());
+          try {
+            if (msg.type === "bridge:bye") {
+              const hadBrowser = this.cliBrowserBySocket.delete(ws);
+              this.cliLastCommandAt.delete(ws);
+              this.cliSessionKeyBySocket.delete(ws);
+              this.cliLabelBySocket.delete(ws);
+              for (const [sentId2, entry] of this.cliBySentId) {
+                if (entry.ws === ws) this.cliBySentId.delete(sentId2);
+              }
+              if (hadBrowser) this.broadcastBrowserClientStates();
+              return;
+            }
+            if (msg.type === "bridge:hello") {
+              const key = typeof msg.cliSessionKey === "string" && msg.cliSessionKey.trim() ? msg.cliSessionKey.trim() : this.cliSessionKeyBySocket.get(ws) || `ws-${this.nextCliFallbackId++}`;
+              this.cliSessionKeyBySocket.set(ws, key);
+              if (typeof msg.cliLabel === "string" && msg.cliLabel.trim()) {
+                this.cliLabelBySocket.set(ws, msg.cliLabel.trim());
+              }
+              if (ws.readyState === import_ws.WebSocket.OPEN) {
+                ws.send(
+                  JSON.stringify({
+                    id: msg.id,
+                    result: {
+                      cliSessionKey: key,
+                      leaseTtlMs: _SootSimBridgeHost.CLI_LEASE_TTL_MS,
+                      leasing: true
+                    }
+                  })
+                );
+              }
+              return;
+            }
+            if (msg.type === "bridge:list-browsers") {
+              if (ws.readyState === import_ws.WebSocket.OPEN) {
+                ws.send(
+                  JSON.stringify({
+                    id: msg.id,
+                    result: this.listBrowsers()
+                  })
+                );
+              }
+              return;
+            }
+            if (msg.type === "bridge:open") {
+              if (typeof msg.url !== "string" || !msg.url) {
+                throw new Error("bridge:open requires a url");
+              }
+              await this.openUrl(msg.url);
+              if (ws.readyState === import_ws.WebSocket.OPEN) {
+                ws.send(
+                  JSON.stringify({
+                    id: msg.id,
+                    result: { ok: true, url: msg.url }
+                  })
+                );
+              }
+              return;
+            }
+            if (msg.type === "bridge:claim") {
+              const targetBrowser2 = await this.waitForBrowser(msg.browserId);
+              const outcome = this.tryAcquireLease(ws, targetBrowser2, {
+                force: msg.force === true
+              });
+              if (!outcome.granted) {
+                if (ws.readyState === import_ws.WebSocket.OPEN) {
+                  ws.send(
+                    JSON.stringify({
+                      id: msg.id,
+                      error: `tab ${targetBrowser2.id} is locked by another cli`,
+                      _locked: outcome.lock
+                    })
+                  );
+                }
+                return;
+              }
+              this.setCliBrowserTarget(ws, targetBrowser2.id);
+              this.recordBrowserAction(
+                targetBrowser2.id,
+                outcome.bootedCount > 0 ? `cli force-claimed tab (booted ${outcome.bootedCount})` : "cli claimed tab"
+              );
+              if (ws.readyState === import_ws.WebSocket.OPEN) {
+                ws.send(
+                  JSON.stringify({
+                    id: msg.id,
+                    result: {
+                      browserId: targetBrowser2.id,
+                      lockedBy: outcome.lease.cliSessionKey,
+                      lockExpiresAt: outcome.lease.expiresAt,
+                      bootedCount: outcome.bootedCount
+                    }
+                  })
+                );
+              }
+              return;
+            }
+            const targetBrowser = await this.waitForBrowser(msg.browserId);
+            if (shouldAcquireLease(msg)) {
+              const outcome = this.tryAcquireLease(ws, targetBrowser);
+              if (!outcome.granted) {
+                if (ws.readyState === import_ws.WebSocket.OPEN) {
+                  ws.send(
+                    JSON.stringify({
+                      id: msg.id,
+                      error: `tab ${targetBrowser.id} is locked by another cli \u2014 use \`sootsim claim ${targetBrowser.id} --force\` or \`sootsim open --new\``,
+                      _locked: outcome.lock
+                    })
+                  );
+                }
+                return;
+              }
+            } else {
+              this.ensureCliSessionKey(ws);
+            }
+            this.setCliBrowserTarget(ws, targetBrowser.id);
+            this.recordBrowserAction(targetBrowser.id, this.describeForwardedCommand(msg));
+            const sentId = this.nextCommandId++;
+            this.cliBySentId.set(sentId, {
+              browserId: targetBrowser.id,
+              ws,
+              originalId: msg.id
+            });
+            const { browserId: _browserId, ...forwarded } = msg;
+            targetBrowser.ws.send(JSON.stringify({ ...forwarded, id: sentId }));
+          } catch (err) {
+            if (ws.readyState === import_ws.WebSocket.OPEN) {
+              ws.send(
+                JSON.stringify({
+                  id: msg.id,
+                  error: err instanceof Error ? err.message : String(err)
+                })
+              );
+            }
+          }
+        })();
+      });
+      ws.on("close", () => {
+        this.agentHost.unregisterSocket(ws);
+        if (role === "browser" && browser) {
+          this.rememberDisconnectedBrowser(browser);
+          if (this.primaryBrowserId === browser.id) {
+            this.primaryBrowserId = this.getOpenBrowser()?.id ?? null;
+          }
+          for (const [id, pending] of this.pendingCommands) {
+            if (pending.browserId !== browser.id) continue;
+            pending.reject(new Error("browser disconnected"));
+            this.pendingCommands.delete(id);
+          }
+          for (const [sentId, entry] of this.cliBySentId) {
+            if (entry.browserId !== browser.id) continue;
+            if (entry.ws.readyState === import_ws.WebSocket.OPEN) {
+              entry.ws.send(
+                JSON.stringify({
+                  id: entry.originalId,
+                  error: "browser disconnected before responding"
+                })
+              );
+            }
+            this.cliBySentId.delete(sentId);
+          }
+          this.broadcastBrowserAssignments();
+          this.broadcastBrowserClientStates();
+        } else if (role === "cli") {
+          const detached = this.cliBrowserBySocket.delete(ws);
+          this.cliLastCommandAt.delete(ws);
+          this.cliSessionKeyBySocket.delete(ws);
+          this.cliLabelBySocket.delete(ws);
+          for (const [sentId, entry] of this.cliBySentId) {
+            if (entry.ws === ws) this.cliBySentId.delete(sentId);
+          }
+          if (detached) {
+            this.broadcastBrowserClientStates();
+          }
+        }
+      });
+    });
+  }
+  /** after a successful bind: start the cli idle sweep, write the daemon
+   *  lockfile (if this host owns it), seed the agent host, kick off the
+   *  heartbeat loop. idempotent across rebinds because close() tears down
+   *  every timer and the lockfile. */
+  afterBind() {
+    process.stderr.write(`ws bridge listening on port ${this.port}
+`);
+    this.cliIdleTimer = setInterval(
+      () => this.sweepIdleCliClients(),
+      3e4
+    );
+    this.cliIdleTimer.unref();
+    if (this.shouldWriteLockfile) {
+      try {
+        ensureSootsimHome();
+        const claimed = claimDaemonLockfile(this.buildLockfileSnapshot());
+        if (!claimed) {
+          throw new Error(
+            "another sootsim daemon wrote the lockfile during startup \u2014 aborting"
+          );
+        }
+      } catch (err) {
+        process.stderr.write(
+          `ws bridge failed to claim daemon lockfile: ${String(err)}
+`
+        );
+        throw err;
+      }
+      this.heartbeatTimer = setInterval(() => {
+        try {
+          this.writeLockfileSnapshot();
+        } catch {
+        }
+      }, DAEMON_HEARTBEAT_INTERVAL_MS);
+      this.heartbeatTimer.unref();
+    }
+    void this.agentHost.seedOnBoot();
+  }
+  buildLockfileSnapshot() {
+    return {
+      schema: 1,
+      pid: process.pid,
+      platform: process.platform,
+      bridgePort: this.effectivePort,
+      runtimePort: this.effectivePort,
+      activeRuntime: this.activeRuntimeVersion,
+      activeRuntimeDir: this.activeRuntimeDirPath,
+      startedAt: this.startedAt,
+      heartbeatAt: Date.now()
+    };
+  }
+  writeLockfileSnapshot() {
+    writeDaemonLockfile(this.buildLockfileSnapshot());
+  }
+  refreshActiveRuntime() {
+    this.activeRuntimeVersion = readActiveRuntime();
+    this.activeRuntimeDirPath = activeRuntimeDir();
+  }
+  /** update the active runtime on disk + in memory. the caller guarantees
+   *  the version directory exists. pushes a runtime:changed message to all
+   *  connected browsers so electron (or any renderer) can reload. */
+  setActiveRuntime(version) {
+    writeActiveRuntime(version);
+    this.refreshActiveRuntime();
+    if (this.shouldWriteLockfile && this.httpServer) {
+      try {
+        this.writeLockfileSnapshot();
+      } catch {
+      }
+    }
+    const payload = JSON.stringify({
+      type: "runtime:changed",
+      version,
+      runtimeDir: this.activeRuntimeDirPath
+    });
+    for (const browser of this.browsers.values()) {
+      if (browser.ws.readyState === import_ws.WebSocket.OPEN) {
+        try {
+          browser.ws.send(payload);
+        } catch {
+        }
+      }
+    }
+    return { version, runtimeDir: this.activeRuntimeDirPath };
+  }
+  getActiveRuntime() {
+    return {
+      version: this.activeRuntimeVersion,
+      runtimeDir: this.activeRuntimeDirPath
+    };
+  }
+  /** last-ditch lockfile cleanup. safe to call from a synchronous
+   *  `process.on('exit', ...)` handler since it only does a fs.unlinkSync. */
+  removeLockfile() {
+    if (!this.shouldWriteLockfile) return;
+    try {
+      removeDaemonLockfile();
+    } catch {
+    }
+  }
+  /** minimal HTTP request handler attached to the same node http server
+   *  that hosts the WS upgrade. handles:
+   *    GET /healthz        json status for supervisors / curl
+   *    GET / + everything  serves from the active runtime dist, SPA fallback
+   *  non-upgrade routes that don't match serve index.html (SPA behavior) so
+   *  electron's webContents can navigate freely inside the runtime. */
+  handleHttpRequest(req, res) {
+    const method = (req.method || "GET").toUpperCase();
+    if (method !== "GET" && method !== "HEAD") {
+      res.writeHead(405, { Allow: "GET, HEAD" });
+      res.end("method not allowed");
+      return;
+    }
+    const url = new URL(req.url || "/", "http://localhost");
+    if (url.pathname === "/__bundle-proxy") {
+      const target = url.searchParams.get("url");
+      if (!target) {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("bundle-proxy: missing url query param");
+        return;
+      }
+      let parsedTarget;
+      try {
+        parsedTarget = new URL(target);
+      } catch {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("bundle-proxy: invalid url");
+        return;
+      }
+      const host = parsedTarget.hostname;
+      const isLoopback = host === "localhost" || host === "127.0.0.1" || host === "::1" || host.endsWith(".localhost");
+      if (!isLoopback) {
+        res.writeHead(403, { "Content-Type": "text/plain" });
+        res.end("bundle-proxy: only loopback targets allowed");
+        return;
+      }
+      void (async () => {
+        try {
+          const upstream = await fetch(parsedTarget.toString(), {
+            redirect: "follow"
+          });
+          const headers = {};
+          const ct = upstream.headers.get("content-type");
+          if (ct) headers["Content-Type"] = ct;
+          headers["Cache-Control"] = "no-store";
+          res.writeHead(upstream.status, headers);
+          if (!upstream.body) {
+            res.end();
+            return;
+          }
+          const reader = upstream.body.getReader();
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            res.write(Buffer.from(value));
+          }
+          res.end();
+        } catch (err) {
+          res.writeHead(502, { "Content-Type": "text/plain" });
+          res.end(
+            `bundle-proxy: upstream fetch failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      })();
+      return;
+    }
+    if (url.pathname === "/healthz") {
+      res.writeHead(200, {
+        "Content-Type": "application/json",
+        "Cache-Control": "no-store"
+      });
+      res.end(
+        JSON.stringify({
+          ok: true,
+          pid: process.pid,
+          platform: process.platform,
+          bridgePort: this.effectivePort,
+          runtimePort: this.effectivePort,
+          activeRuntime: this.activeRuntimeVersion,
+          startedAt: this.startedAt,
+          uptimeMs: this.startedAt > 0 ? Date.now() - this.startedAt : 0
+        })
+      );
+      return;
+    }
+    this.refreshActiveRuntime();
+    const baseDir = this.activeRuntimeDirPath;
+    if (!baseDir) {
+      res.writeHead(503, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end(
+        "sootsim: no active runtime installed. run `sootsim runtime install` to fetch one."
+      );
+      return;
+    }
+    let rel = url.pathname;
+    if (rel === "/runtime" || rel === "/runtime/") rel = "/";
+    else if (rel.startsWith("/runtime/")) rel = rel.slice("/runtime".length);
+    if (rel === "" || rel === "/") rel = "/index.html";
+    if (rel.includes("\0")) {
+      res.writeHead(400);
+      res.end("bad request");
+      return;
+    }
+    if (process.platform !== "win32" && rel.includes("\\")) {
+      res.writeHead(400);
+      res.end("bad request");
+      return;
+    }
+    for (const segment of rel.split("/")) {
+      if (segment === "..") {
+        res.writeHead(403);
+        res.end("forbidden");
+        return;
+      }
+    }
+    const resolved = import_path2.default.resolve(baseDir, "." + rel);
+    const baseWithSep = baseDir.endsWith(import_path2.default.sep) ? baseDir : baseDir + import_path2.default.sep;
+    if (!resolved.startsWith(baseWithSep) && resolved !== baseDir) {
+      res.writeHead(403);
+      res.end("forbidden");
+      return;
+    }
+    import_fs2.default.realpath(resolved, (realErr, realResolved) => {
+      const servePath = realErr ? resolved : realResolved;
+      const servePathWithSep = servePath.endsWith(import_path2.default.sep) ? servePath : servePath + import_path2.default.sep;
+      if (!realErr) {
+        const realBaseWithSep = (() => {
+          try {
+            const rb = import_fs2.default.realpathSync(baseDir);
+            return rb.endsWith(import_path2.default.sep) ? rb : rb + import_path2.default.sep;
+          } catch {
+            return baseWithSep;
+          }
+        })();
+        if (!servePathWithSep.startsWith(realBaseWithSep) && servePath + import_path2.default.sep !== realBaseWithSep) {
+          res.writeHead(403);
+          res.end("forbidden");
+          return;
+        }
+      }
+      import_fs2.default.stat(servePath, (err, stats) => {
+        if (err || !stats?.isFile()) {
+          const ext2 = import_path2.default.extname(rel).toLowerCase();
+          if (ext2 && ext2 !== ".html") {
+            res.writeHead(404);
+            res.end("not found");
+            return;
+          }
+          const indexPath = import_path2.default.join(baseDir, "index.html");
+          import_fs2.default.readFile(indexPath, (err2, data) => {
+            if (err2) {
+              res.writeHead(404);
+              res.end("not found");
+              return;
+            }
+            res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+            if (method === "HEAD") {
+              res.end();
+              return;
+            }
+            res.end(data);
+          });
+          return;
+        }
+        const ext = import_path2.default.extname(servePath).toLowerCase();
+        const contentType = HTTP_MIME_TYPES[ext] || "application/octet-stream";
+        res.writeHead(200, { "Content-Type": contentType });
+        if (method === "HEAD") {
+          res.end();
+          return;
+        }
+        const stream = import_fs2.default.createReadStream(servePath);
+        stream.pipe(res);
+        stream.on("error", () => {
+          try {
+            res.end();
+          } catch {
+          }
+        });
+      });
+    });
+  }
+  sweepIdleCliClients() {
+    const now = Date.now();
+    let swept = false;
+    for (const [ws, browserId] of this.cliBrowserBySocket) {
+      const lastCommand = this.cliLastCommandAt.get(ws) ?? 0;
+      if (now - lastCommand < _SootSimBridgeHost.CLI_IDLE_TIMEOUT_MS) continue;
+      this.cliBrowserBySocket.delete(ws);
+      this.cliLastCommandAt.delete(ws);
+      for (const [sentId, entry] of this.cliBySentId) {
+        if (entry.ws === ws) this.cliBySentId.delete(sentId);
+      }
+      try {
+        ws.close(1e3, "idle timeout");
+      } catch {
+      }
+      swept = true;
+    }
+    if (swept) {
+      this.broadcastBrowserClientStates();
+    }
+    this.sweepRestorableBrowsers(now);
+  }
+  listBrowsers() {
+    return Array.from(this.browsers.values()).sort((a, b) => {
+      if (a.id === this.primaryBrowserId) return -1;
+      if (b.id === this.primaryBrowserId) return 1;
+      return a.connectedAt - b.connectedAt;
+    }).map((browser) => this.describeBrowser(browser));
+  }
+  async sendCommand(cmd) {
+    const browser = await this.waitForBrowser(cmd.browserId);
+    const id = this.nextCommandId++;
+    return new Promise((resolve2, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingCommands.delete(id);
+        this.broadcastBrowserClientStates();
+        reject(new Error("command timed out after 30s"));
+      }, 3e4);
+      this.pendingCommands.set(id, {
+        browserId: browser.id,
+        resolve: (value) => {
+          clearTimeout(timeout);
+          this.pendingCommands.delete(id);
+          this.broadcastBrowserClientStates();
+          resolve2(value);
+        },
+        reject: (error) => {
+          clearTimeout(timeout);
+          this.pendingCommands.delete(id);
+          this.broadcastBrowserClientStates();
+          reject(error);
+        }
+      });
+      this.broadcastBrowserClientStates();
+      const { browserId: _browserId, ...forwarded } = cmd;
+      browser.ws.send(JSON.stringify({ ...forwarded, id }));
+    });
+  }
+  async evaluate(code, browserId) {
+    return this.sendCommand({ type: "evaluate", code, browserId });
+  }
+  async focusBrowser(browserId) {
+    return this.sendCommand({ type: "focus", browserId });
+  }
+  async closeBrowser(browserId) {
+    return this.sendCommand({ type: "close", browserId });
+  }
+  async openPathInEditor(filePath, line, column) {
+    const loc = line != null ? `:${line}${column != null ? `:${column}` : ""}` : "";
+    const target = `${filePath}${loc}`;
+    const trySpawn = (cmd, args) => new Promise((resolve2) => {
+      try {
+        const child = (0, import_child_process2.spawn)(cmd, args, { detached: true, stdio: "ignore" });
+        let settled = false;
+        child.on("error", () => {
+          if (settled) return;
+          settled = true;
+          resolve2(false);
+        });
+        child.on("spawn", () => {
+          if (settled) return;
+          settled = true;
+          child.unref();
+          resolve2(true);
+        });
+      } catch {
+        resolve2(false);
+      }
+    });
+    const envEditor = process.env.REACT_EDITOR || process.env.EDITOR;
+    if (envEditor) {
+      const parts = envEditor.split(" ").filter(Boolean);
+      if (parts.length && await trySpawn(parts[0], [...parts.slice(1), "-g", target]))
+        return;
+    }
+    if (await trySpawn("cursor", ["-g", target])) return;
+    if (await trySpawn("code", ["-g", target])) return;
+    await this.openUrl(filePath);
+  }
+  async openUrl(url) {
+    if (this.openUrlHandler) {
+      await this.openUrlHandler(url);
+      return;
+    }
+    if (process.platform === "darwin") {
+      const child2 = (0, import_child_process2.spawn)("open", ["-g", url], { detached: true, stdio: "ignore" });
+      child2.unref();
+      return;
+    }
+    if (process.platform === "win32") {
+      const child2 = (0, import_child_process2.spawn)("cmd", ["/c", "start", "", url], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child2.unref();
+      return;
+    }
+    const child = (0, import_child_process2.spawn)("xdg-open", [url], { detached: true, stdio: "ignore" });
+    child.unref();
+  }
+  async close() {
+    if (this.cliIdleTimer) {
+      clearInterval(this.cliIdleTimer);
+      this.cliIdleTimer = null;
+    }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.shouldWriteLockfile) {
+      try {
+        removeDaemonLockfile();
+      } catch {
+      }
+    }
+    this.effectivePort = 0;
+    this.startedAt = 0;
+    this.agentHost.close();
+    for (const [id, pending] of this.pendingCommands) {
+      pending.reject(new Error("server closing"));
+      this.pendingCommands.delete(id);
+    }
+    for (const browser of this.browsers.values()) {
+      browser.ws.close();
+    }
+    this.browsers.clear();
+    this.primaryBrowserId = null;
+    const wss = this.wss;
+    const httpServer = this.httpServer;
+    this.wss = null;
+    this.httpServer = null;
+    if (wss) {
+      try {
+        wss.close();
+      } catch {
+      }
+    }
+    if (httpServer) {
+      try {
+        httpServer.close();
+      } catch {
+      }
+    }
+  }
+  describeBrowser(browser) {
+    let readyState;
+    try {
+      readyState = browser.ws.readyState;
+    } catch {
+      readyState = import_ws.WebSocket.CLOSED;
+    }
+    const lease = this.getActiveLease(browser);
+    return {
+      id: browser.id,
+      origin: browser.origin,
+      url: browser.url,
+      title: browser.title,
+      userAgent: browser.userAgent,
+      connectedAt: browser.connectedAt,
+      lastSeenAt: browser.lastSeenAt,
+      lastActiveAt: browser.lastActiveAt || void 0,
+      isPrimary: browser.id === this.primaryBrowserId,
+      readyState: readyState === import_ws.WebSocket.OPEN ? "open" : readyState === import_ws.WebSocket.CLOSING ? "closing" : "closed",
+      attachedCliCount: this.getAttachedCliCount(browser.id),
+      lockedBy: lease ? lease.cliLabel || lease.cliSessionKey : void 0,
+      lockedByKind: lease ? lease.kind : void 0,
+      lockExpiresAt: lease ? lease.expiresAt : void 0,
+      userFocused: browser.userFocused || void 0
+    };
+  }
+  getActiveLease(browser) {
+    const lease = browser.cliLease;
+    if (!lease) return null;
+    if (Date.now() >= lease.expiresAt) {
+      browser.cliLease = void 0;
+      return null;
+    }
+    return lease;
+  }
+  tryAcquireLease(ws, browser, opts = {}) {
+    const cliSessionKey = this.cliSessionKeyBySocket.get(ws) ?? (() => {
+      const fallback = `ws-${this.nextCliFallbackId++}`;
+      this.cliSessionKeyBySocket.set(ws, fallback);
+      return fallback;
+    })();
+    const cliLabel = this.cliLabelBySocket.get(ws);
+    const now = Date.now();
+    const existing = this.getActiveLease(browser);
+    const ownerMatches = existing && existing.cliSessionKey === cliSessionKey;
+    let bootedCount = 0;
+    if (existing && !ownerMatches && !opts.force) {
+      return {
+        granted: false,
+        lease: existing,
+        lock: {
+          by: existing.cliLabel || existing.cliSessionKey,
+          expiresInMs: Math.max(0, existing.expiresAt - now)
+        },
+        bootedCount: 0
+      };
+    }
+    if (existing && !ownerMatches && opts.force) {
+      for (const [cliWs, attachedBrowserId] of this.cliBrowserBySocket) {
+        if (attachedBrowserId !== browser.id) continue;
+        const otherKey = this.cliSessionKeyBySocket.get(cliWs);
+        if (otherKey && otherKey !== cliSessionKey) {
+          this.cliBrowserBySocket.delete(cliWs);
+          try {
+            cliWs.close(1e3, "lease claimed by another cli");
+          } catch {
+          }
+          bootedCount++;
+        }
+      }
+    }
+    const lease = {
+      kind: "cli",
+      cliSessionKey,
+      cliLabel,
+      expiresAt: now + _SootSimBridgeHost.CLI_LEASE_TTL_MS
+    };
+    browser.cliLease = lease;
+    return { granted: true, lease, bootedCount };
+  }
+  // user focus is advisory: we track it on the browser record so list/UI can
+  // show "focused" alongside any cli lease, but focus alone never creates a
+  // blocking lease. the old 15s user-focus lease meant clicking on the tab
+  // locked out agent inspect calls for 15s — the opposite of what you want
+  // when debugging something the user is actively looking at. use
+  // updateUserActivity() to lock on real interaction instead.
+  updateUserFocusLease(browser, focused) {
+    const next = focused;
+    if (browser.userFocused === next) return;
+    browser.userFocused = next;
+    this.broadcastBrowserClientStates();
+  }
+  // called when the browser reports a real user interaction (pointerdown,
+  // keydown, wheel, touch). creates or refreshes a short `user-active` lease
+  // that keeps agent writes from trampling a user who is driving the tab.
+  // reads still pass through — shouldAcquireLease only blocks on writes.
+  updateUserActivity(browser) {
+    const existing = this.getActiveLease(browser);
+    if (existing && existing.kind === "cli") {
+      return;
+    }
+    browser.cliLease = {
+      kind: "user-active",
+      cliSessionKey: "__user-active__",
+      cliLabel: "active user",
+      expiresAt: Date.now() + _SootSimBridgeHost.USER_ACTIVE_LEASE_TTL_MS
+    };
+    this.broadcastBrowserClientStates();
+  }
+  ensureCliSessionKey(ws) {
+    const existing = this.cliSessionKeyBySocket.get(ws);
+    if (existing) return existing;
+    const fallback = `ws-${this.nextCliFallbackId++}`;
+    this.cliSessionKeyBySocket.set(ws, fallback);
+    return fallback;
+  }
+  getOpenBrowser(browserId) {
+    if (browserId) {
+      const browser = this.browsers.get(browserId);
+      if (browser?.ws.readyState === import_ws.WebSocket.OPEN) return browser;
+      return null;
+    }
+    const primary = this.primaryBrowserId != null ? this.browsers.get(this.primaryBrowserId) : null;
+    if (primary?.ws.readyState === import_ws.WebSocket.OPEN) return primary;
+    for (const browser of this.browsers.values()) {
+      if (browser.ws.readyState === import_ws.WebSocket.OPEN) return browser;
+    }
+    return null;
+  }
+  async waitForBrowser(browserId, options = {}) {
+    const attempts = options.attempts ?? 10;
+    const intervalMs = options.intervalMs ?? 200;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      const browser = this.getOpenBrowser(browserId);
+      if (browser) return browser;
+      await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
+    }
+    throw new Error(
+      browserId ? `no browser connected with id ${browserId}` : "no browser connected"
+    );
+  }
+  shouldPromoteBrowser(browser) {
+    const current = this.primaryBrowserId ? this.browsers.get(this.primaryBrowserId) : null;
+    const isPrimaryCandidate = browser.origin?.includes(":5173");
+    const currentIsPrimary = current?.origin?.includes(":5173");
+    return !current || current.ws.readyState !== import_ws.WebSocket.OPEN || !!isPrimaryCandidate || !currentIsPrimary;
+  }
+  broadcastBrowserAssignments() {
+    for (const browser of this.browsers.values()) {
+      if (browser.ws.readyState !== import_ws.WebSocket.OPEN) continue;
+      browser.ws.send(
+        JSON.stringify({
+          type: "bridge:welcome",
+          browserId: browser.id,
+          isPrimary: browser.id === this.primaryBrowserId
+        })
+      );
+    }
+  }
+  broadcastBrowserClientStates() {
+    for (const browser of this.browsers.values()) {
+      if (browser.ws.readyState !== import_ws.WebSocket.OPEN) continue;
+      const lease = this.getActiveLease(browser);
+      const message = {
+        type: "bridge:client-state",
+        attachedCliCount: this.getAttachedCliCount(browser.id),
+        activeAgentCommandCount: this.getActiveAgentCommandCount(browser.id),
+        recentActions: browser.recentActions,
+        lockedBy: lease ? lease.cliLabel || lease.cliSessionKey : void 0,
+        lockedByKind: lease ? lease.kind : void 0,
+        lockExpiresAt: lease ? lease.expiresAt : void 0,
+        userFocused: browser.userFocused || void 0
+      };
+      browser.ws.send(JSON.stringify(message));
+    }
+  }
+  setCliBrowserTarget(ws, browserId) {
+    const prevBrowserId = this.cliBrowserBySocket.get(ws);
+    if (prevBrowserId === browserId) return;
+    this.cliBrowserBySocket.set(ws, browserId);
+    this.recordBrowserAction(
+      browserId,
+      prevBrowserId ? "cli switched tabs" : "cli connected",
+      false
+    );
+    this.broadcastBrowserClientStates();
+  }
+  recordBrowserAction(browserId, label, broadcast = true) {
+    const normalized = label?.trim();
+    if (!normalized) return;
+    const browser = this.browsers.get(browserId);
+    if (!browser) return;
+    const now = Date.now();
+    browser.lastActiveAt = now;
+    browser.recentActions = [
+      { label: normalized, at: now },
+      ...browser.recentActions.filter((entry) => entry.label !== normalized)
+    ].slice(0, 4);
+    if (broadcast) this.broadcastBrowserClientStates();
+  }
+  describeForwardedCommand(msg) {
+    switch (msg?.type) {
+      case "evaluate":
+        return "evaluated page state";
+      case "screenshot":
+        return "captured screenshot";
+      case "tap":
+        return "sent tap event";
+      case "keyboard":
+        return msg?.action === "type" ? "typed text" : "used keyboard";
+      case "tree":
+        return "dumped tree";
+      case "focus":
+        return "focused tab";
+      case "close":
+        return "requested close";
+      default:
+        return typeof msg?.type === "string" ? msg.type : null;
+    }
+  }
+  // count distinct cli session keys attached to a browser, not raw sockets.
+  // a single agent firing sequential cli commands opens a new ws per call —
+  // counting sockets would report phantom peers until idle cleanup catches up.
+  getAttachedCliCount(browserId) {
+    const keys = /* @__PURE__ */ new Set();
+    for (const [ws, attachedBrowserId] of this.cliBrowserBySocket) {
+      if (attachedBrowserId !== browserId) continue;
+      if (ws.readyState !== import_ws.WebSocket.OPEN) continue;
+      const key = this.cliSessionKeyBySocket.get(ws);
+      keys.add(key ?? `ws-unknown-${keys.size}`);
+    }
+    return keys.size;
+  }
+  // count distinct session keys attached to this browser other than `selfWs`.
+  // used to warn a cli that other agents/sessions are also targeting the tab.
+  getOtherCliSessionCount(selfWs, browserId) {
+    const selfKey = this.cliSessionKeyBySocket.get(selfWs);
+    const keys = /* @__PURE__ */ new Set();
+    for (const [ws, attachedBrowserId] of this.cliBrowserBySocket) {
+      if (attachedBrowserId !== browserId) continue;
+      if (ws.readyState !== import_ws.WebSocket.OPEN) continue;
+      const key = this.cliSessionKeyBySocket.get(ws);
+      if (key && key === selfKey) continue;
+      keys.add(key ?? `ws-unknown-${keys.size}`);
+    }
+    return keys.size;
+  }
+  getActiveAgentCommandCount(browserId) {
+    let count = 0;
+    for (const pending of this.pendingCommands.values()) {
+      if (pending.browserId === browserId) count++;
+    }
+    return count;
+  }
+  tryRestoreBrowserId(browser, requestedId) {
+    const nextId = requestedId?.trim();
+    if (!nextId || nextId === browser.id) return false;
+    const existing = this.browsers.get(nextId);
+    if (existing && existing !== browser && existing.ws.readyState === import_ws.WebSocket.OPEN) {
+      return false;
+    }
+    const restorable = this.getRestorableBrowserState(nextId);
+    const prevId = browser.id;
+    this.browsers.delete(prevId);
+    browser.id = nextId;
+    if (restorable) {
+      browser.recentActions = restorable.recentActions.map((entry) => ({ ...entry }));
+      browser.lastActiveAt = restorable.lastActiveAt;
+      browser.cliLease = restorable.cliLease ? { ...restorable.cliLease } : void 0;
+      this.restorableBrowsers.delete(nextId);
+    }
+    this.browsers.set(browser.id, browser);
+    if (this.primaryBrowserId === prevId) {
+      this.primaryBrowserId = browser.id;
+    }
+    for (const [ws, attachedBrowserId] of this.cliBrowserBySocket) {
+      if (attachedBrowserId === prevId) {
+        this.cliBrowserBySocket.set(ws, browser.id);
+      }
+    }
+    return true;
+  }
+  rememberDisconnectedBrowser(browser) {
+    const lease = this.getActiveLease(browser);
+    this.restorableBrowsers.set(browser.id, {
+      recentActions: browser.recentActions.map((entry) => ({ ...entry })),
+      lastActiveAt: browser.lastActiveAt,
+      cliLease: lease && lease.kind === "cli" ? { ...lease } : void 0,
+      expiresAt: Date.now() + _SootSimBridgeHost.BROWSER_RECONNECT_TTL_MS
+    });
+    this.browsers.delete(browser.id);
+  }
+  getRestorableBrowserState(browserId) {
+    const snapshot = this.restorableBrowsers.get(browserId);
+    if (!snapshot) return null;
+    if (snapshot.expiresAt <= Date.now()) {
+      this.restorableBrowsers.delete(browserId);
+      return null;
+    }
+    if (snapshot.cliLease && snapshot.cliLease.expiresAt <= Date.now()) {
+      snapshot.cliLease = void 0;
+    }
+    return snapshot;
+  }
+  sweepRestorableBrowsers(now = Date.now()) {
+    for (const [browserId, snapshot] of this.restorableBrowsers) {
+      if (snapshot.expiresAt > now) continue;
+      this.restorableBrowsers.delete(browserId);
+      for (const [cliWs, attachedBrowserId] of this.cliBrowserBySocket) {
+        if (attachedBrowserId === browserId) {
+          this.cliBrowserBySocket.delete(cliWs);
+        }
+      }
+    }
+  }
+  resetServerState() {
+    if (this.cliIdleTimer) {
+      clearInterval(this.cliIdleTimer);
+      this.cliIdleTimer = null;
+    }
+    const wss = this.wss;
+    const httpServer = this.httpServer;
+    this.wss = null;
+    this.httpServer = null;
+    if (wss) {
+      try {
+        wss.close();
+      } catch {
+      }
+    }
+    if (httpServer) {
+      try {
+        httpServer.close();
+      } catch {
+      }
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SootSimBridgeHost
+});