opensteer 0.6.11 → 0.6.13

package/dist/cli/profile.cjs

@@ -424,8 +424,8 @@ __export(profile_exports, {
   runOpensteerProfileCli: () => runOpensteerProfileCli
 });
 module.exports = __toCommonJS(profile_exports);
-var import_node_path4 = __toESM(require("path"), 1);
-var import_promises5 = require("readline/promises");
+var import_node_path8 = __toESM(require("path"), 1);
+var import_promises8 = require("readline/promises");
 
 // src/config.ts
 var import_fs = __toESM(require("fs"), 1);
@@ -732,9 +732,9 @@ function resolveNamespaceDir(rootDir, namespace) {
   const selectorsRoot = import_path.default.resolve(rootDir, ".opensteer", "selectors");
   const normalizedNamespace = normalizeNamespace(namespace);
   const namespaceDir = import_path.default.resolve(selectorsRoot, normalizedNamespace);
-  const relative = import_path.default.relative(selectorsRoot, namespaceDir);
-  if (relative === "" || relative === ".") return namespaceDir;
-  if (relative.startsWith("..") || import_path.default.isAbsolute(relative)) {
+  const relative2 = import_path.default.relative(selectorsRoot, namespaceDir);
+  if (relative2 === "" || relative2 === ".") return namespaceDir;
+  if (relative2.startsWith("..") || import_path.default.isAbsolute(relative2)) {
     throw new Error(
       `Namespace "${namespace}" resolves outside selectors root.`
     );
@@ -1291,8 +1291,8 @@ function resolveNamespace(config, rootDir) {
   }
   const caller = getCallerFilePath();
   if (!caller) return normalizeNamespace("default");
-  const relative = import_path2.default.relative(rootDir, caller);
-  const cleaned = relative.replace(/\\/g, "/").replace(/\.(ts|tsx|js|mjs|cjs)$/, "");
+  const relative2 = import_path2.default.relative(rootDir, caller);
+  const cleaned = relative2.replace(/\\/g, "/").replace(/\.(ts|tsx|js|mjs|cjs)$/, "");
   return normalizeNamespace(cleaned || "default");
 }
 function getCallerFilePath() {
@@ -1323,10 +1323,7 @@ function getCallerFilePath() {
 var import_crypto = require("crypto");
 
 // src/browser/pool.ts
-var import_node_child_process = require("child_process");
-var import_promises2 = require("fs/promises");
-var import_node_net = require("net");
-var import_playwright = require("playwright");
+var import_playwright2 = require("playwright");
 
 // src/browser/cdp-proxy.ts
 var import_ws = __toESM(require("ws"), 1);
@@ -1819,281 +1816,1892 @@ function listLocalChromeProfiles(userDataDir = detectChromePaths().defaultUserDa
 }
 
 // src/browser/persistent-profile.ts
+var import_node_crypto3 = require("crypto");
+var import_node_child_process2 = require("child_process");
+var import_node_fs3 = require("fs");
+var import_promises4 = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path4 = require("path");
+var import_node_util2 = require("util");
+
+// src/browser/persistent-profile-coordination.ts
+var import_node_path2 = require("path");
+
+// src/browser/dir-lock.ts
 var import_node_crypto = require("crypto");
 var import_node_fs = require("fs");
-var import_promises = require("fs/promises");
-var import_node_os = require("os");
+var import_promises2 = require("fs/promises");
 var import_node_path = require("path");
-var OPENSTEER_META_FILE = ".opensteer-meta.json";
+
+// src/browser/process-owner.ts
+var import_node_child_process = require("child_process");
+var import_promises = require("fs/promises");
+var import_node_util = require("util");
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
 var PROCESS_STARTED_AT_MS = Math.floor(Date.now() - process.uptime() * 1e3);
 var PROCESS_START_TIME_TOLERANCE_MS = 1e3;
-var CHROME_SINGLETON_ENTRIES = /* @__PURE__ */ new Set([
-  "SingletonCookie",
-  "SingletonLock",
-  "SingletonSocket",
-  "DevToolsActivePort",
-  "lockfile"
-]);
-var COPY_SKIP_ENTRIES = /* @__PURE__ */ new Set([
-  ...CHROME_SINGLETON_ENTRIES,
-  OPENSTEER_META_FILE
-]);
-var SKIPPED_ROOT_DIRECTORIES = /* @__PURE__ */ new Set([
-  "Crash Reports",
-  "Crashpad",
-  "BrowserMetrics",
-  "GrShaderCache",
-  "ShaderCache",
-  "GraphiteDawnCache",
-  "component_crx_cache",
-  "Crowd Deny",
-  "hyphen-data",
-  "OnDeviceHeadSuggestModel",
-  "OptimizationGuidePredictionModels",
-  "Segmentation Platform",
-  "SmartCardDeviceNames",
-  "WidevineCdm",
-  "pnacl"
-]);
-async function getOrCreatePersistentProfile(sourceUserDataDir, profileDirectory, profilesRootDir = defaultPersistentProfilesRootDir()) {
-  const resolvedSourceUserDataDir = expandHome(sourceUserDataDir);
-  const targetUserDataDir = (0, import_node_path.join)(
-    expandHome(profilesRootDir),
-    buildPersistentProfileKey(resolvedSourceUserDataDir, profileDirectory)
-  );
-  const sourceProfileDir = (0, import_node_path.join)(resolvedSourceUserDataDir, profileDirectory);
-  const metadata = buildPersistentProfileMetadata(
-    resolvedSourceUserDataDir,
-    profileDirectory
-  );
-  await (0, import_promises.mkdir)((0, import_node_path.dirname)(targetUserDataDir), { recursive: true });
-  await cleanOrphanedTempDirs(
-    (0, import_node_path.dirname)(targetUserDataDir),
-    (0, import_node_path.basename)(targetUserDataDir)
-  );
-  if (!(0, import_node_fs.existsSync)(sourceProfileDir)) {
-    throw new Error(
-      `Chrome profile "${profileDirectory}" was not found in "${resolvedSourceUserDataDir}".`
-    );
+var PROCESS_LIST_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+var PS_COMMAND_ENV = { ...process.env, LC_ALL: "C" };
+var LINUX_STAT_START_TIME_FIELD_INDEX = 19;
+var CURRENT_PROCESS_OWNER = {
+  pid: process.pid,
+  processStartedAtMs: PROCESS_STARTED_AT_MS
+};
+var linuxClockTicksPerSecondPromise = null;
+function parseProcessOwner(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const parsed = value;
+  const pid = Number(parsed.pid);
+  const processStartedAtMs = Number(parsed.processStartedAtMs);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null;
+  }
+  if (!Number.isInteger(processStartedAtMs) || processStartedAtMs <= 0) {
+    return null;
   }
-  const created = await createPersistentProfileClone(
-    resolvedSourceUserDataDir,
-    sourceProfileDir,
-    targetUserDataDir,
-    profileDirectory,
-    metadata
-  );
-  await ensurePersistentProfileMetadata(targetUserDataDir, metadata);
   return {
-    created,
-    userDataDir: targetUserDataDir
+    pid,
+    processStartedAtMs
   };
 }
-async function clearPersistentProfileSingletons(userDataDir) {
-  await Promise.all(
-    [...CHROME_SINGLETON_ENTRIES].map(
-      (entry) => (0, import_promises.rm)((0, import_node_path.join)(userDataDir, entry), {
-        force: true,
-        recursive: true
-      }).catch(() => void 0)
-    )
-  );
+function processOwnersEqual(left, right) {
+  if (!left || !right) {
+    return left === right;
+  }
+  return left.pid === right.pid && left.processStartedAtMs === right.processStartedAtMs;
 }
-function buildPersistentProfileKey(sourceUserDataDir, profileDirectory) {
-  const hash = (0, import_node_crypto.createHash)("sha256").update(`${sourceUserDataDir}\0${profileDirectory}`).digest("hex").slice(0, 16);
-  const sourceLabel = sanitizePathSegment((0, import_node_path.basename)(sourceUserDataDir) || "user-data");
-  const profileLabel = sanitizePathSegment(profileDirectory || "Default");
-  return `${sourceLabel}-${profileLabel}-${hash}`;
+async function getProcessLiveness(owner) {
+  if (owner.pid === process.pid && hasMatchingProcessStartTime(
+    owner.processStartedAtMs,
+    PROCESS_STARTED_AT_MS
+  )) {
+    return "live";
+  }
+  const startedAtMs = await readProcessStartedAtMs(owner.pid);
+  if (typeof startedAtMs === "number") {
+    return hasMatchingProcessStartTime(
+      owner.processStartedAtMs,
+      startedAtMs
+    ) ? "live" : "dead";
+  }
+  return isProcessRunning(owner.pid) ? "unknown" : "dead";
 }
-function defaultPersistentProfilesRootDir() {
-  return (0, import_node_path.join)((0, import_node_os.homedir)(), ".opensteer", "real-browser-profiles");
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+    return code !== "ESRCH";
+  }
 }
-function sanitizePathSegment(value) {
-  const sanitized = value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/-+/g, "-");
-  return sanitized.replace(/^-|-$/g, "") || "profile";
+async function readProcessOwner(pid) {
+  const processStartedAtMs = await readProcessStartedAtMs(pid);
+  if (processStartedAtMs === null) {
+    return null;
+  }
+  return {
+    pid,
+    processStartedAtMs
+  };
 }
-function isProfileDirectory(userDataDir, entry) {
-  return (0, import_node_fs.existsSync)((0, import_node_path.join)(userDataDir, entry, "Preferences"));
+function hasMatchingProcessStartTime(expectedStartedAtMs, actualStartedAtMs) {
+  return Math.abs(expectedStartedAtMs - actualStartedAtMs) <= PROCESS_START_TIME_TOLERANCE_MS;
 }
-async function copyRootLevelEntries(sourceUserDataDir, targetUserDataDir, targetProfileDirectory) {
-  let entries;
+async function readProcessStartedAtMs(pid) {
+  if (pid <= 0) {
+    return null;
+  }
+  if (process.platform === "linux") {
+    return await readLinuxProcessStartedAtMs(pid);
+  }
+  if (process.platform === "win32") {
+    return await readWindowsProcessStartedAtMs(pid);
+  }
+  return await readPsProcessStartedAtMs(pid);
+}
+async function readLinuxProcessStartedAtMs(pid) {
+  let statRaw;
   try {
-    entries = await (0, import_promises.readdir)(sourceUserDataDir);
+    statRaw = await (0, import_promises.readFile)(`/proc/${pid}/stat`, "utf8");
   } catch {
-    return;
+    return null;
   }
-  const copyTasks = [];
-  for (const entry of entries) {
-    if (COPY_SKIP_ENTRIES.has(entry)) continue;
-    if (entry === targetProfileDirectory) continue;
-    const sourcePath = (0, import_node_path.join)(sourceUserDataDir, entry);
-    const targetPath = (0, import_node_path.join)(targetUserDataDir, entry);
-    if ((0, import_node_fs.existsSync)(targetPath)) continue;
-    let entryStat;
-    try {
-      entryStat = await (0, import_promises.stat)(sourcePath);
-    } catch {
-      continue;
-    }
-    if (entryStat.isFile()) {
-      copyTasks.push((0, import_promises.copyFile)(sourcePath, targetPath).catch(() => void 0));
-    } else if (entryStat.isDirectory()) {
-      if (isProfileDirectory(sourceUserDataDir, entry)) continue;
-      if (SKIPPED_ROOT_DIRECTORIES.has(entry)) continue;
-      copyTasks.push(
-        (0, import_promises.cp)(sourcePath, targetPath, { recursive: true }).catch(
-          () => void 0
-        )
-      );
-    }
+  const startTicks = parseLinuxProcessStartTicks(statRaw);
+  if (startTicks === null) {
+    return null;
   }
-  await Promise.all(copyTasks);
-}
-async function writePersistentProfileMetadata(userDataDir, metadata) {
-  await (0, import_promises.writeFile)(
-    (0, import_node_path.join)(userDataDir, OPENSTEER_META_FILE),
-    JSON.stringify(metadata, null, 2)
+  const [bootTimeMs, clockTicksPerSecond] = await Promise.all([
+    readLinuxBootTimeMs(),
+    readLinuxClockTicksPerSecond()
+  ]);
+  if (bootTimeMs === null || clockTicksPerSecond === null) {
+    return null;
+  }
+  return Math.floor(
+    bootTimeMs + startTicks * 1e3 / clockTicksPerSecond
   );
 }
-function buildPersistentProfileMetadata(sourceUserDataDir, profileDirectory) {
-  return {
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    profileDirectory,
-    source: sourceUserDataDir
-  };
+function parseLinuxProcessStartTicks(statRaw) {
+  const closingParenIndex = statRaw.lastIndexOf(")");
+  if (closingParenIndex === -1) {
+    return null;
+  }
+  const fields = statRaw.slice(closingParenIndex + 2).trim().split(/\s+/);
+  const startTicks = Number(fields[LINUX_STAT_START_TIME_FIELD_INDEX]);
+  return Number.isFinite(startTicks) && startTicks >= 0 ? startTicks : null;
 }
-async function createPersistentProfileClone(sourceUserDataDir, sourceProfileDir, targetUserDataDir, profileDirectory, metadata) {
-  if ((0, import_node_fs.existsSync)(targetUserDataDir)) {
-    return false;
+async function readLinuxBootTimeMs() {
+  try {
+    const statRaw = await (0, import_promises.readFile)("/proc/stat", "utf8");
+    const bootTimeLine = statRaw.split("\n").find((line) => line.startsWith("btime "));
+    if (!bootTimeLine) {
+      return null;
+    }
+    const bootTimeSeconds = Number.parseInt(
+      bootTimeLine.slice("btime ".length),
+      10
+    );
+    return Number.isFinite(bootTimeSeconds) ? bootTimeSeconds * 1e3 : null;
+  } catch {
+    return null;
   }
-  const tempUserDataDir = await (0, import_promises.mkdtemp)(
-    buildPersistentProfileTempDirPrefix(targetUserDataDir)
-  );
-  let published = false;
+}
+async function readLinuxClockTicksPerSecond() {
+  if (!linuxClockTicksPerSecondPromise) {
+    linuxClockTicksPerSecondPromise = execFileAsync("getconf", ["CLK_TCK"], {
+      encoding: "utf8",
+      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
+    }).then(({ stdout }) => {
+      const value = Number.parseInt(stdout.trim(), 10);
+      return Number.isFinite(value) && value > 0 ? value : null;
+    }).catch(() => null);
+  }
+  return await linuxClockTicksPerSecondPromise;
+}
+async function readWindowsProcessStartedAtMs(pid) {
   try {
-    await (0, import_promises.cp)(sourceProfileDir, (0, import_node_path.join)(tempUserDataDir, profileDirectory), {
-      recursive: true
-    });
-    await copyRootLevelEntries(
-      sourceUserDataDir,
-      tempUserDataDir,
-      profileDirectory
+    const { stdout } = await execFileAsync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-Command",
+        `(Get-Process -Id ${pid}).StartTime.ToUniversalTime().ToString("o")`
+      ],
+      {
+        encoding: "utf8",
+        maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
+      }
     );
-    await writePersistentProfileMetadata(tempUserDataDir, metadata);
-    try {
-      await (0, import_promises.rename)(tempUserDataDir, targetUserDataDir);
-    } catch (error) {
-      if (wasProfilePublishedByAnotherProcess(error, targetUserDataDir)) {
-        return false;
+    const isoTimestamp = stdout.trim();
+    if (!isoTimestamp) {
+      return null;
+    }
+    const startedAtMs = Date.parse(isoTimestamp);
+    return Number.isFinite(startedAtMs) ? startedAtMs : null;
+  } catch {
+    return null;
+  }
+}
+async function readPsProcessStartedAtMs(pid) {
+  try {
+    const { stdout } = await execFileAsync(
+      "ps",
+      ["-o", "lstart=", "-p", String(pid)],
+      {
+        encoding: "utf8",
+        env: PS_COMMAND_ENV,
+        maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
       }
-      throw error;
+    );
+    const startedAt = stdout.trim();
+    if (!startedAt) {
+      return null;
     }
-    published = true;
-    return true;
+    const startedAtMs = Date.parse(startedAt.replace(/\s+/g, " "));
+    return Number.isFinite(startedAtMs) ? startedAtMs : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/browser/dir-lock.ts
+var LOCK_OWNER_FILE = "owner.json";
+var LOCK_RECLAIMER_DIR = "reclaimer";
+var LOCK_RETRY_DELAY_MS = 50;
+async function withDirLock(lockDirPath, action) {
+  const releaseLock = await acquireDirLock(lockDirPath);
+  try {
+    return await action();
   } finally {
-    if (!published) {
-      await (0, import_promises.rm)(tempUserDataDir, {
+    await releaseLock();
+  }
+}
+async function acquireDirLock(lockDirPath) {
+  while (true) {
+    const releaseLock = await tryAcquireDirLock(lockDirPath);
+    if (releaseLock) {
+      return releaseLock;
+    }
+    await sleep(LOCK_RETRY_DELAY_MS);
+  }
+}
+async function tryAcquireDirLock(lockDirPath) {
+  await (0, import_promises2.mkdir)((0, import_node_path.dirname)(lockDirPath), { recursive: true });
+  while (true) {
+    const tempLockDirPath = `${lockDirPath}-${process.pid}-${CURRENT_PROCESS_OWNER.processStartedAtMs}-${(0, import_node_crypto.randomUUID)()}`;
+    try {
+      await (0, import_promises2.mkdir)(tempLockDirPath);
+      await writeLockOwner(tempLockDirPath, CURRENT_PROCESS_OWNER);
+      try {
+        await (0, import_promises2.rename)(tempLockDirPath, lockDirPath);
+        break;
+      } catch (error) {
+        if (!wasDirPublishedByAnotherProcess(error, lockDirPath)) {
+          throw error;
+        }
+      }
+    } finally {
+      await (0, import_promises2.rm)(tempLockDirPath, {
         recursive: true,
         force: true
       }).catch(() => void 0);
     }
+    const owner = await readLockOwner(lockDirPath);
+    if ((!owner || await getProcessLiveness(owner) === "dead") && await tryReclaimStaleLock(lockDirPath, owner)) {
+      continue;
+    }
+    return null;
   }
+  return async () => {
+    await (0, import_promises2.rm)(lockDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  };
 }
-async function ensurePersistentProfileMetadata(userDataDir, metadata) {
-  if ((0, import_node_fs.existsSync)((0, import_node_path.join)(userDataDir, OPENSTEER_META_FILE))) {
-    return;
+async function isDirLockHeld(lockDirPath) {
+  if (!(0, import_node_fs.existsSync)(lockDirPath)) {
+    return false;
   }
-  await writePersistentProfileMetadata(userDataDir, metadata);
+  const owner = await readLockOwner(lockDirPath);
+  if ((!owner || await getProcessLiveness(owner) === "dead") && await tryReclaimStaleLock(lockDirPath, owner)) {
+    return false;
+  }
+  return (0, import_node_fs.existsSync)(lockDirPath);
 }
-function wasProfilePublishedByAnotherProcess(error, targetUserDataDir) {
-  const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
-  return (0, import_node_fs.existsSync)(targetUserDataDir) && (code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM");
+function getErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
 }
-function buildPersistentProfileTempDirPrefix(targetUserDataDir) {
-  return (0, import_node_path.join)(
-    (0, import_node_path.dirname)(targetUserDataDir),
-    `${(0, import_node_path.basename)(targetUserDataDir)}-tmp-${process.pid}-${PROCESS_STARTED_AT_MS}-`
-  );
+function wasDirPublishedByAnotherProcess(error, targetDirPath) {
+  const code = getErrorCode(error);
+  return (0, import_node_fs.existsSync)(targetDirPath) && (code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM");
 }
-async function cleanOrphanedTempDirs(profilesDir, targetBaseName) {
-  let entries;
+async function writeLockOwner(lockDirPath, owner) {
+  await (0, import_promises2.writeFile)((0, import_node_path.join)(lockDirPath, LOCK_OWNER_FILE), JSON.stringify(owner));
+}
+async function readLockOwner(lockDirPath) {
+  return await readLockParticipant((0, import_node_path.join)(lockDirPath, LOCK_OWNER_FILE));
+}
+async function readLockParticipant(filePath) {
+  return (await readLockParticipantRecord(filePath)).owner;
+}
+async function readLockParticipantRecord(filePath) {
   try {
-    entries = await (0, import_promises.readdir)(profilesDir, {
-      encoding: "utf8",
-      withFileTypes: true
-    });
-  } catch {
-    return;
+    const raw = await (0, import_promises2.readFile)(filePath, "utf8");
+    const owner = parseProcessOwner(JSON.parse(raw));
+    return {
+      exists: true,
+      owner
+    };
+  } catch (error) {
+    return {
+      exists: getErrorCode(error) !== "ENOENT",
+      owner: null
+    };
   }
-  const tempDirPrefix = `${targetBaseName}-tmp-`;
-  await Promise.all(
-    entries.map(async (entry) => {
-      if (!entry.isDirectory() || !entry.name.startsWith(tempDirPrefix)) {
-        return;
-      }
-      if (isTempDirOwnedByLiveProcess(entry.name, tempDirPrefix)) {
-        return;
-      }
-      await (0, import_promises.rm)((0, import_node_path.join)(profilesDir, entry.name), {
-        recursive: true,
-        force: true
-      }).catch(() => void 0);
-    })
+}
+async function readLockReclaimerRecord(lockDirPath) {
+  return await readLockParticipantRecord(
+    (0, import_node_path.join)(buildLockReclaimerDirPath(lockDirPath), LOCK_OWNER_FILE)
   );
 }
-function isTempDirOwnedByLiveProcess(tempDirName, tempDirPrefix) {
-  const owner = parseTempDirOwner(tempDirName, tempDirPrefix);
-  if (!owner) {
+async function tryReclaimStaleLock(lockDirPath, expectedOwner) {
+  if (!await tryAcquireLockReclaimer(lockDirPath)) {
     return false;
   }
-  if (owner.pid === process.pid && Math.abs(owner.processStartedAtMs - PROCESS_STARTED_AT_MS) <= PROCESS_START_TIME_TOLERANCE_MS) {
-    return true;
+  let reclaimed = false;
+  try {
+    const owner = await readLockOwner(lockDirPath);
+    if (!processOwnersEqual(owner, expectedOwner)) {
+      return false;
+    }
+    if (owner && await getProcessLiveness(owner) !== "dead") {
+      return false;
+    }
+    await (0, import_promises2.rm)(lockDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+    reclaimed = !(0, import_node_fs.existsSync)(lockDirPath);
+    return reclaimed;
+  } finally {
+    if (!reclaimed) {
+      await (0, import_promises2.rm)(buildLockReclaimerDirPath(lockDirPath), {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+  }
+}
+async function tryAcquireLockReclaimer(lockDirPath) {
+  const reclaimerDirPath = buildLockReclaimerDirPath(lockDirPath);
+  while (true) {
+    const tempReclaimerDirPath = `${reclaimerDirPath}-${process.pid}-${CURRENT_PROCESS_OWNER.processStartedAtMs}-${(0, import_node_crypto.randomUUID)()}`;
+    try {
+      await (0, import_promises2.mkdir)(tempReclaimerDirPath);
+      await writeLockOwner(tempReclaimerDirPath, CURRENT_PROCESS_OWNER);
+      try {
+        await (0, import_promises2.rename)(tempReclaimerDirPath, reclaimerDirPath);
+        return true;
+      } catch (error) {
+        if (getErrorCode(error) === "ENOENT") {
+          return false;
+        }
+        if (!wasDirPublishedByAnotherProcess(error, reclaimerDirPath)) {
+          throw error;
+        }
+      }
+    } catch (error) {
+      const code = getErrorCode(error);
+      if (code === "ENOENT") {
+        return false;
+      }
+      throw error;
+    } finally {
+      await (0, import_promises2.rm)(tempReclaimerDirPath, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+    const reclaimerRecord = await readLockReclaimerRecord(lockDirPath);
+    if (!reclaimerRecord.exists || !reclaimerRecord.owner) {
+      return false;
+    }
+    if (await getProcessLiveness(reclaimerRecord.owner) !== "dead") {
+      return false;
+    }
+    await (0, import_promises2.rm)(reclaimerDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  }
+}
+function buildLockReclaimerDirPath(lockDirPath) {
+  return (0, import_node_path.join)(lockDirPath, LOCK_RECLAIMER_DIR);
+}
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/browser/persistent-profile-coordination.ts
+var PERSISTENT_PROFILE_LOCK_RETRY_DELAY_MS = 50;
+async function withPersistentProfileControlLock(targetUserDataDir, action) {
+  return await withDirLock(
+    buildPersistentProfileControlLockDirPath(targetUserDataDir),
+    action
+  );
+}
+async function acquirePersistentProfileWriteLock(targetUserDataDir) {
+  const controlLockDirPath = buildPersistentProfileControlLockDirPath(targetUserDataDir);
+  const writeLockDirPath = buildPersistentProfileWriteLockDirPath(
+    targetUserDataDir
+  );
+  while (true) {
+    let releaseWriteLock = null;
+    const releaseControlLock = await acquireDirLock(controlLockDirPath);
+    try {
+      releaseWriteLock = await tryAcquireDirLock(writeLockDirPath);
+    } finally {
+      await releaseControlLock();
+    }
+    if (releaseWriteLock) {
+      return releaseWriteLock;
+    }
+    await sleep2(PERSISTENT_PROFILE_LOCK_RETRY_DELAY_MS);
+  }
+}
+async function isPersistentProfileWriteLocked(targetUserDataDir) {
+  return await isDirLockHeld(
+    buildPersistentProfileWriteLockDirPath(targetUserDataDir)
+  );
+}
+function buildPersistentProfileWriteLockDirPath(targetUserDataDir) {
+  return (0, import_node_path2.join)((0, import_node_path2.dirname)(targetUserDataDir), `${(0, import_node_path2.basename)(targetUserDataDir)}.lock`);
+}
+function buildPersistentProfileControlLockDirPath(targetUserDataDir) {
+  return (0, import_node_path2.join)(
+    (0, import_node_path2.dirname)(targetUserDataDir),
+    `${(0, import_node_path2.basename)(targetUserDataDir)}.control.lock`
+  );
+}
+async function sleep2(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/browser/shared-real-browser-session-state.ts
+var import_node_crypto2 = require("crypto");
+var import_node_fs2 = require("fs");
+var import_promises3 = require("fs/promises");
+var import_node_path3 = require("path");
+var SHARED_SESSION_METADATA_FILE = "session.json";
+var SHARED_SESSION_CLIENTS_DIR = "clients";
+var SHARED_SESSION_RETRY_DELAY_MS = 50;
+var SHARED_SESSION_METADATA_TEMP_FILE_PREFIX = `${SHARED_SESSION_METADATA_FILE}.`;
+var SHARED_SESSION_METADATA_TEMP_FILE_SUFFIX = ".tmp";
+function buildSharedSessionDirPath(persistentUserDataDir) {
+  return (0, import_node_path3.join)(
+    (0, import_node_path3.dirname)(persistentUserDataDir),
+    `${(0, import_node_path3.basename)(persistentUserDataDir)}.session`
+  );
+}
+function buildSharedSessionLockPath(persistentUserDataDir) {
+  return `${buildSharedSessionDirPath(persistentUserDataDir)}.lock`;
+}
+function buildSharedSessionClientsDirPath(persistentUserDataDir) {
+  return (0, import_node_path3.join)(
+    buildSharedSessionDirPath(persistentUserDataDir),
+    SHARED_SESSION_CLIENTS_DIR
+  );
+}
+function buildSharedSessionClientPath(persistentUserDataDir, clientId) {
+  return (0, import_node_path3.join)(
+    buildSharedSessionClientsDirPath(persistentUserDataDir),
+    `${clientId}.json`
+  );
+}
+async function readSharedSessionMetadata(persistentUserDataDir) {
+  return (await readSharedSessionMetadataRecord(persistentUserDataDir)).metadata;
+}
+async function writeSharedSessionMetadata(persistentUserDataDir, metadata) {
+  const sessionDirPath = buildSharedSessionDirPath(persistentUserDataDir);
+  const metadataPath = buildSharedSessionMetadataPath(persistentUserDataDir);
+  const tempPath = buildSharedSessionMetadataTempPath(sessionDirPath);
+  await (0, import_promises3.mkdir)(sessionDirPath, { recursive: true });
+  try {
+    await (0, import_promises3.writeFile)(tempPath, JSON.stringify(metadata, null, 2));
+    await (0, import_promises3.rename)(tempPath, metadataPath);
+  } finally {
+    await (0, import_promises3.rm)(tempPath, { force: true }).catch(() => void 0);
+  }
+}
+async function hasLiveSharedRealBrowserSession(persistentUserDataDir) {
+  const sessionDirPath = buildSharedSessionDirPath(persistentUserDataDir);
+  const metadataRecord = await readSharedSessionMetadataRecord(
+    persistentUserDataDir
+  );
+  if (!metadataRecord.exists) {
+    return await hasLiveSharedSessionPublisherOrClients(sessionDirPath);
+  }
+  if (!metadataRecord.metadata) {
+    return true;
+  }
+  if (await getProcessLiveness(metadataRecord.metadata.browserOwner) === "dead") {
+    await (0, import_promises3.rm)(sessionDirPath, {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+    return false;
+  }
+  return true;
+}
+async function waitForSharedRealBrowserSessionToDrain(persistentUserDataDir) {
+  while (true) {
+    if (!await hasLiveSharedRealBrowserSession(persistentUserDataDir)) {
+      return;
+    }
+    await sleep3(SHARED_SESSION_RETRY_DELAY_MS);
+  }
+}
+async function readSharedSessionMetadataRecord(persistentUserDataDir) {
+  try {
+    const raw = await (0, import_promises3.readFile)(
+      buildSharedSessionMetadataPath(persistentUserDataDir),
+      "utf8"
+    );
+    return {
+      exists: true,
+      metadata: parseSharedSessionMetadata(JSON.parse(raw))
+    };
+  } catch (error) {
+    return {
+      exists: getErrorCode2(error) !== "ENOENT",
+      metadata: null
+    };
+  }
+}
+async function hasLiveSharedSessionPublisherOrClients(sessionDirPath) {
+  if (!(0, import_node_fs2.existsSync)(sessionDirPath)) {
+    return false;
+  }
+  let entries;
+  try {
+    entries = await readDirNames(sessionDirPath);
+  } catch (error) {
+    return getErrorCode2(error) !== "ENOENT";
+  }
+  let hasUnknownEntries = false;
+  for (const entry of entries) {
+    if (entry === SHARED_SESSION_METADATA_FILE) {
+      return true;
+    }
+    if (entry === SHARED_SESSION_CLIENTS_DIR) {
+      if (await hasDirectoryEntries((0, import_node_path3.join)(sessionDirPath, entry))) {
+        return true;
+      }
+      continue;
+    }
+    const owner = parseSharedSessionMetadataTempOwner(entry);
+    if (!owner) {
+      if (isSharedSessionMetadataTempFile(entry)) {
+        continue;
+      }
+      hasUnknownEntries = true;
+      continue;
+    }
+    if (await getProcessLiveness(owner) !== "dead") {
+      return true;
+    }
+  }
+  if (hasUnknownEntries) {
+    return true;
+  }
+  await (0, import_promises3.rm)(sessionDirPath, {
+    force: true,
+    recursive: true
+  }).catch(() => void 0);
+  return false;
+}
+function buildSharedSessionMetadataPath(persistentUserDataDir) {
+  return (0, import_node_path3.join)(
+    buildSharedSessionDirPath(persistentUserDataDir),
+    SHARED_SESSION_METADATA_FILE
+  );
+}
+function buildSharedSessionMetadataTempPath(sessionDirPath) {
+  return (0, import_node_path3.join)(
+    sessionDirPath,
+    [
+      SHARED_SESSION_METADATA_FILE,
+      CURRENT_PROCESS_OWNER.pid,
+      CURRENT_PROCESS_OWNER.processStartedAtMs,
+      (0, import_node_crypto2.randomUUID)(),
+      "tmp"
+    ].join(".")
+  );
+}
+function parseSharedSessionMetadata(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const parsed = value;
+  const browserOwner = parseProcessOwner(parsed.browserOwner);
+  const stateOwner = parseProcessOwner(parsed.stateOwner);
+  const state = parsed.state === "launching" || parsed.state === "ready" || parsed.state === "closing" ? parsed.state : null;
+  if (!browserOwner || !stateOwner || typeof parsed.createdAt !== "string" || typeof parsed.debugPort !== "number" || typeof parsed.executablePath !== "string" || typeof parsed.headless !== "boolean" || typeof parsed.persistentUserDataDir !== "string" || typeof parsed.profileDirectory !== "string" || typeof parsed.sessionId !== "string" || !state) {
+    return null;
+  }
+  return {
+    browserOwner,
+    createdAt: parsed.createdAt,
+    debugPort: parsed.debugPort,
+    executablePath: parsed.executablePath,
+    headless: parsed.headless,
+    persistentUserDataDir: parsed.persistentUserDataDir,
+    profileDirectory: parsed.profileDirectory,
+    sessionId: parsed.sessionId,
+    state,
+    stateOwner
+  };
+}
+function parseSharedSessionMetadataTempOwner(entryName) {
+  if (!isSharedSessionMetadataTempFile(entryName)) {
+    return null;
+  }
+  const segments = entryName.split(".");
+  if (segments.length < 5) {
+    return null;
+  }
+  return parseProcessOwner({
+    pid: Number.parseInt(segments[2] ?? "", 10),
+    processStartedAtMs: Number.parseInt(segments[3] ?? "", 10)
+  });
+}
+function isSharedSessionMetadataTempFile(entryName) {
+  return entryName.startsWith(SHARED_SESSION_METADATA_TEMP_FILE_PREFIX) && entryName.endsWith(SHARED_SESSION_METADATA_TEMP_FILE_SUFFIX);
+}
+function getErrorCode2(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+async function hasDirectoryEntries(dirPath) {
+  try {
+    return (await readDirNames(dirPath)).length > 0;
+  } catch (error) {
+    return getErrorCode2(error) !== "ENOENT";
+  }
+}
+async function readDirNames(dirPath) {
+  return await (0, import_promises3.readdir)(dirPath, { encoding: "utf8" });
+}
+async function sleep3(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/browser/persistent-profile.ts
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+var OPENSTEER_META_FILE = ".opensteer-meta.json";
+var OPENSTEER_RUNTIME_META_FILE = ".opensteer-runtime.json";
+var OPENSTEER_RUNTIME_CREATING_FILE = ".opensteer-runtime-creating.json";
+var PROCESS_LIST_MAX_BUFFER_BYTES2 = 16 * 1024 * 1024;
+var PS_COMMAND_ENV2 = { ...process.env, LC_ALL: "C" };
+var CHROME_SINGLETON_ENTRIES = /* @__PURE__ */ new Set([
+  "SingletonCookie",
+  "SingletonLock",
+  "SingletonSocket",
+  "DevToolsActivePort",
+  "lockfile"
+]);
+var COPY_SKIP_ENTRIES = /* @__PURE__ */ new Set([
+  ...CHROME_SINGLETON_ENTRIES,
+  OPENSTEER_META_FILE,
+  OPENSTEER_RUNTIME_META_FILE,
+  OPENSTEER_RUNTIME_CREATING_FILE
+]);
+var SKIPPED_ROOT_DIRECTORIES = /* @__PURE__ */ new Set([
+  "Crash Reports",
+  "Crashpad",
+  "BrowserMetrics",
+  "GrShaderCache",
+  "ShaderCache",
+  "GraphiteDawnCache",
+  "component_crx_cache",
+  "Crowd Deny",
+  "hyphen-data",
+  "OnDeviceHeadSuggestModel",
+  "OptimizationGuidePredictionModels",
+  "Segmentation Platform",
+  "SmartCardDeviceNames",
+  "WidevineCdm",
+  "pnacl"
+]);
+async function getOrCreatePersistentProfile(sourceUserDataDir, profileDirectory, profilesRootDir = defaultPersistentProfilesRootDir()) {
+  const resolvedSourceUserDataDir = expandHome(sourceUserDataDir);
+  const targetUserDataDir = (0, import_node_path4.join)(
+    expandHome(profilesRootDir),
+    buildPersistentProfileKey(resolvedSourceUserDataDir, profileDirectory)
+  );
+  const sourceProfileDir = (0, import_node_path4.join)(resolvedSourceUserDataDir, profileDirectory);
+  const metadata = buildPersistentProfileMetadata(
+    resolvedSourceUserDataDir,
+    profileDirectory
+  );
+  await (0, import_promises4.mkdir)((0, import_node_path4.dirname)(targetUserDataDir), { recursive: true });
+  if (await isHealthyPersistentProfile(
+    targetUserDataDir,
+    resolvedSourceUserDataDir,
+    profileDirectory
+  ) && !await isPersistentProfileWriteLocked(targetUserDataDir)) {
+    return {
+      created: false,
+      userDataDir: targetUserDataDir
+    };
+  }
+  return await withPersistentProfileWriteAccess(targetUserDataDir, async () => {
+    await recoverPersistentProfileBackup(targetUserDataDir);
+    await cleanOrphanedOwnedDirs(
+      (0, import_node_path4.dirname)(targetUserDataDir),
+      buildPersistentProfileTempDirNamePrefix(targetUserDataDir)
+    );
+    if (!(0, import_node_fs3.existsSync)(sourceProfileDir)) {
+      throw new Error(
+        `Chrome profile "${profileDirectory}" was not found in "${resolvedSourceUserDataDir}".`
+      );
+    }
+    const created = await createPersistentProfileClone(
+      resolvedSourceUserDataDir,
+      sourceProfileDir,
+      targetUserDataDir,
+      profileDirectory,
+      metadata
+    );
+    await ensurePersistentProfileMetadata(targetUserDataDir, metadata);
+    return {
+      created,
+      userDataDir: targetUserDataDir
+    };
+  });
+}
+async function clearPersistentProfileSingletons(userDataDir) {
+  await Promise.all(
+    [...CHROME_SINGLETON_ENTRIES].map(
+      (entry) => (0, import_promises4.rm)((0, import_node_path4.join)(userDataDir, entry), {
+        force: true,
+        recursive: true
+      }).catch(() => void 0)
+    )
+  );
+}
+function buildPersistentProfileKey(sourceUserDataDir, profileDirectory) {
+  const hash = (0, import_node_crypto3.createHash)("sha256").update(`${sourceUserDataDir}\0${profileDirectory}`).digest("hex").slice(0, 16);
+  const sourceLabel = sanitizePathSegment((0, import_node_path4.basename)(sourceUserDataDir) || "user-data");
+  const profileLabel = sanitizePathSegment(profileDirectory || "Default");
+  return `${sourceLabel}-${profileLabel}-${hash}`;
+}
+function defaultPersistentProfilesRootDir() {
+  return (0, import_node_path4.join)((0, import_node_os.homedir)(), ".opensteer", "real-browser-profiles");
+}
+function sanitizePathSegment(value) {
+  const sanitized = value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/-+/g, "-");
+  return sanitized.replace(/^-|-$/g, "") || "profile";
+}
+function isProfileDirectory(userDataDir, entry) {
+  return (0, import_node_fs3.existsSync)((0, import_node_path4.join)(userDataDir, entry, "Preferences"));
+}
+async function copyRootLevelEntries(sourceUserDataDir, targetUserDataDir, targetProfileDirectory) {
+  let entries;
+  try {
+    entries = await (0, import_promises4.readdir)(sourceUserDataDir);
+  } catch {
+    return;
+  }
+  const copyTasks = [];
+  for (const entry of entries) {
+    if (COPY_SKIP_ENTRIES.has(entry)) continue;
+    if (entry === targetProfileDirectory) continue;
+    const sourcePath = (0, import_node_path4.join)(sourceUserDataDir, entry);
+    const targetPath = (0, import_node_path4.join)(targetUserDataDir, entry);
+    if ((0, import_node_fs3.existsSync)(targetPath)) continue;
+    let entryStat;
+    try {
+      entryStat = await (0, import_promises4.stat)(sourcePath);
+    } catch {
+      continue;
+    }
+    if (entryStat.isFile()) {
+      copyTasks.push((0, import_promises4.copyFile)(sourcePath, targetPath).catch(() => void 0));
+    } else if (entryStat.isDirectory()) {
+      if (isProfileDirectory(sourceUserDataDir, entry)) continue;
+      if (SKIPPED_ROOT_DIRECTORIES.has(entry)) continue;
+      copyTasks.push(
+        (0, import_promises4.cp)(sourcePath, targetPath, { recursive: true }).catch(
+          () => void 0
+        )
+      );
+    }
+  }
+  await Promise.all(copyTasks);
+}
+async function writePersistentProfileMetadata(userDataDir, metadata) {
+  await (0, import_promises4.writeFile)(
+    (0, import_node_path4.join)(userDataDir, OPENSTEER_META_FILE),
+    JSON.stringify(metadata, null, 2)
+  );
+}
+function buildPersistentProfileMetadata(sourceUserDataDir, profileDirectory) {
+  return {
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    profileDirectory,
+    source: sourceUserDataDir
+  };
+}
+async function createPersistentProfileClone(sourceUserDataDir, sourceProfileDir, targetUserDataDir, profileDirectory, metadata) {
+  if ((0, import_node_fs3.existsSync)(targetUserDataDir)) {
+    return false;
+  }
+  const tempUserDataDir = await (0, import_promises4.mkdtemp)(
+    buildPersistentProfileTempDirPrefix(targetUserDataDir)
+  );
+  let published = false;
+  try {
+    await materializePersistentProfileSnapshot(
+      sourceUserDataDir,
+      sourceProfileDir,
+      tempUserDataDir,
+      profileDirectory,
+      metadata
+    );
+    try {
+      await (0, import_promises4.rename)(tempUserDataDir, targetUserDataDir);
+    } catch (error) {
+      if (wasDirPublishedByAnotherProcess2(error, targetUserDataDir)) {
+        return false;
+      }
+      throw error;
+    }
+    published = true;
+    return true;
+  } finally {
+    if (!published) {
+      await (0, import_promises4.rm)(tempUserDataDir, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+  }
+}
+async function materializePersistentProfileSnapshot(sourceUserDataDir, sourceProfileDir, targetUserDataDir, profileDirectory, metadata) {
+  if (!(0, import_node_fs3.existsSync)(sourceProfileDir)) {
+    throw new Error(
+      `Chrome profile "${profileDirectory}" was not found in "${sourceUserDataDir}".`
+    );
+  }
+  await (0, import_promises4.cp)(sourceProfileDir, (0, import_node_path4.join)(targetUserDataDir, profileDirectory), {
+    recursive: true
+  });
+  await copyRootLevelEntries(sourceUserDataDir, targetUserDataDir, profileDirectory);
+  await writePersistentProfileMetadata(targetUserDataDir, metadata);
+}
+async function readRuntimeProfileCreationMarker(userDataDir) {
+  try {
+    const raw = await (0, import_promises4.readFile)(
+      (0, import_node_path4.join)(userDataDir, OPENSTEER_RUNTIME_CREATING_FILE),
+      "utf8"
+    );
+    return parseRuntimeProfileCreationMarker(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+async function ensurePersistentProfileMetadata(userDataDir, metadata) {
+  if ((0, import_node_fs3.existsSync)((0, import_node_path4.join)(userDataDir, OPENSTEER_META_FILE))) {
+    return;
+  }
+  await writePersistentProfileMetadata(userDataDir, metadata);
+}
+async function recoverPersistentProfileBackup(targetUserDataDir) {
+  const backupDirPaths = await listPersistentProfileBackupDirs(targetUserDataDir);
+  if (backupDirPaths.length === 0) {
+    return;
+  }
+  if (!(0, import_node_fs3.existsSync)(targetUserDataDir)) {
+    const [latestBackupDirPath, ...staleBackupDirPaths] = backupDirPaths;
+    await (0, import_promises4.rename)(latestBackupDirPath, targetUserDataDir);
+    await Promise.all(
+      staleBackupDirPaths.map(
+        (backupDirPath) => (0, import_promises4.rm)(backupDirPath, {
+          recursive: true,
+          force: true
+        }).catch(() => void 0)
+      )
+    );
+    return;
+  }
+  await Promise.all(
+    backupDirPaths.map(
+      (backupDirPath) => (0, import_promises4.rm)(backupDirPath, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0)
+    )
+  );
+}
+async function listPersistentProfileBackupDirs(targetUserDataDir) {
+  const profilesDir = (0, import_node_path4.dirname)(targetUserDataDir);
+  let entries;
+  try {
+    entries = await (0, import_promises4.readdir)(profilesDir, {
+      encoding: "utf8",
+      withFileTypes: true
+    });
+  } catch {
+    return [];
+  }
+  const backupDirNamePrefix = buildPersistentProfileBackupDirNamePrefix(targetUserDataDir);
+  return entries.filter(
+    (entry) => entry.isDirectory() && entry.name.startsWith(backupDirNamePrefix)
+  ).map((entry) => (0, import_node_path4.join)(profilesDir, entry.name)).sort((leftPath, rightPath) => rightPath.localeCompare(leftPath));
+}
+async function readPersistentProfileMetadata(userDataDir) {
+  try {
+    const raw = await (0, import_promises4.readFile)((0, import_node_path4.join)(userDataDir, OPENSTEER_META_FILE), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.createdAt !== "string" || typeof parsed.profileDirectory !== "string" || typeof parsed.source !== "string") {
+      return null;
+    }
+    return {
+      createdAt: parsed.createdAt,
+      profileDirectory: parsed.profileDirectory,
+      source: parsed.source
+    };
+  } catch {
+    return null;
+  }
+}
+async function isHealthyPersistentProfile(userDataDir, expectedSourceUserDataDir, expectedProfileDirectory) {
+  if (!(0, import_node_fs3.existsSync)(userDataDir) || !(0, import_node_fs3.existsSync)((0, import_node_path4.join)(userDataDir, expectedProfileDirectory))) {
+    return false;
+  }
+  const metadata = await readPersistentProfileMetadata(userDataDir);
+  return metadata?.source === expectedSourceUserDataDir && metadata.profileDirectory === expectedProfileDirectory;
+}
+function wasDirPublishedByAnotherProcess2(error, targetDirPath) {
+  const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+  return (0, import_node_fs3.existsSync)(targetDirPath) && (code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM");
+}
+async function withPersistentProfileWriteAccess(targetUserDataDir, action) {
+  const releaseWriteLock = await acquirePersistentProfileWriteLock(
+    targetUserDataDir
+  );
+  try {
+    await waitForRuntimeProfileCreationsToDrain(targetUserDataDir);
+    await waitForSharedRealBrowserSessionToDrain(targetUserDataDir);
+    return await action();
+  } finally {
+    await releaseWriteLock();
+  }
+}
+function buildPersistentProfileTempDirPrefix(targetUserDataDir) {
+  return (0, import_node_path4.join)(
+    (0, import_node_path4.dirname)(targetUserDataDir),
+    `${buildPersistentProfileTempDirNamePrefix(targetUserDataDir)}${process.pid}-${CURRENT_PROCESS_OWNER.processStartedAtMs}-`
+  );
+}
+function buildPersistentProfileTempDirNamePrefix(targetUserDataDir) {
+  return `${(0, import_node_path4.basename)(targetUserDataDir)}-tmp-`;
+}
+function buildPersistentProfileBackupDirNamePrefix(targetUserDataDir) {
+  return `${(0, import_node_path4.basename)(targetUserDataDir)}-backup-`;
+}
+function buildRuntimeProfileCreationRegistryDirPath(persistentUserDataDir) {
+  return (0, import_node_path4.join)(
+    (0, import_node_path4.dirname)(persistentUserDataDir),
+    `${(0, import_node_path4.basename)(persistentUserDataDir)}.creating`
+  );
+}
+function buildRuntimeProfileCreationRegistrationPath(persistentUserDataDir, runtimeUserDataDir) {
+  const key = (0, import_node_crypto3.createHash)("sha256").update(runtimeUserDataDir).digest("hex").slice(0, 16);
+  return (0, import_node_path4.join)(
+    buildRuntimeProfileCreationRegistryDirPath(persistentUserDataDir),
+    `${key}.json`
+  );
+}
+async function clearRuntimeProfileCreationState(runtimeUserDataDir, persistentUserDataDir) {
+  await Promise.all([
+    (0, import_promises4.rm)((0, import_node_path4.join)(runtimeUserDataDir, OPENSTEER_RUNTIME_CREATING_FILE), {
+      force: true
+    }).catch(() => void 0),
+    (0, import_promises4.rm)(
+      buildRuntimeProfileCreationRegistrationPath(
+        persistentUserDataDir,
+        runtimeUserDataDir
+      ),
+      {
+        force: true
+      }
+    ).catch(() => void 0)
+  ]);
+}
+async function listRuntimeProfileCreationRegistrations(persistentUserDataDir) {
+  const registryDirPath = buildRuntimeProfileCreationRegistryDirPath(
+    persistentUserDataDir
+  );
+  let entries;
+  try {
+    entries = await (0, import_promises4.readdir)(registryDirPath, {
+      encoding: "utf8",
+      withFileTypes: true
+    });
+  } catch {
+    return [];
+  }
+  return await Promise.all(
+    entries.filter((entry) => entry.isFile()).map(async (entry) => {
+      const filePath = (0, import_node_path4.join)(registryDirPath, entry.name);
+      return {
+        filePath,
+        marker: await readRuntimeProfileCreationRegistration(filePath)
+      };
+    })
+  );
+}
+async function readRuntimeProfileCreationRegistration(filePath) {
+  try {
+    const raw = await (0, import_promises4.readFile)(filePath, "utf8");
+    return parseRuntimeProfileCreationMarker(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+async function cleanOrphanedOwnedDirs(rootDir, ownedDirNamePrefix) {
+  let entries;
+  try {
+    entries = await (0, import_promises4.readdir)(rootDir, {
+      encoding: "utf8",
+      withFileTypes: true
+    });
+  } catch {
+    return;
+  }
+  await Promise.all(
+    entries.map(async (entry) => {
+      if (!entry.isDirectory() || !entry.name.startsWith(ownedDirNamePrefix)) {
+        return;
+      }
+      if (await isOwnedDirByLiveProcess(entry.name, ownedDirNamePrefix)) {
+        return;
+      }
+      await (0, import_promises4.rm)((0, import_node_path4.join)(rootDir, entry.name), {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    })
+  );
+}
+async function isOwnedDirByLiveProcess(ownedDirName, ownedDirPrefix) {
+  const owner = parseOwnedDirOwner(ownedDirName, ownedDirPrefix);
+  return owner ? await getProcessLiveness(owner) !== "dead" : false;
+}
+async function hasActiveRuntimeProfileCreations(persistentUserDataDir) {
+  const registrations = await listRuntimeProfileCreationRegistrations(
+    persistentUserDataDir
+  );
+  let hasLiveCreation = false;
+  for (const registration of registrations) {
+    const marker = registration.marker;
+    if (!marker || marker.persistentUserDataDir !== persistentUserDataDir) {
+      await (0, import_promises4.rm)(registration.filePath, {
+        force: true
+      }).catch(() => void 0);
+      continue;
+    }
+    const runtimeMarker = await readRuntimeProfileCreationMarker(
+      marker.runtimeUserDataDir
+    );
+    if (!runtimeMarker || runtimeMarker.persistentUserDataDir !== persistentUserDataDir || runtimeMarker.runtimeUserDataDir !== marker.runtimeUserDataDir) {
+      await clearRuntimeProfileCreationState(
+        marker.runtimeUserDataDir,
+        persistentUserDataDir
+      );
+      continue;
+    }
+    if (await getProcessLiveness(runtimeMarker.creator) === "dead") {
+      await clearRuntimeProfileCreationState(
+        marker.runtimeUserDataDir,
+        persistentUserDataDir
+      );
+      await (0, import_promises4.rm)(marker.runtimeUserDataDir, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+      continue;
+    }
+    hasLiveCreation = true;
+  }
+  return hasLiveCreation;
+}
+async function waitForRuntimeProfileCreationsToDrain(persistentUserDataDir) {
+  while (true) {
+    if (!await hasActiveRuntimeProfileCreations(persistentUserDataDir)) {
+      return;
+    }
+    await sleep4(PERSISTENT_PROFILE_LOCK_RETRY_DELAY_MS);
+  }
+}
+function parseRuntimeProfileCreationMarker(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const parsed = value;
+  const creator = parseProcessOwner(parsed.creator);
+  const persistentUserDataDir = typeof parsed.persistentUserDataDir === "string" ? parsed.persistentUserDataDir : void 0;
+  const profileDirectory = parsed.profileDirectory === null ? null : typeof parsed.profileDirectory === "string" ? parsed.profileDirectory : void 0;
+  const runtimeUserDataDir = typeof parsed.runtimeUserDataDir === "string" ? parsed.runtimeUserDataDir : void 0;
+  if (!creator || persistentUserDataDir === void 0 || profileDirectory === void 0 || runtimeUserDataDir === void 0) {
+    return null;
+  }
+  return {
+    creator,
+    persistentUserDataDir,
+    profileDirectory,
+    runtimeUserDataDir
+  };
+}
+function parseOwnedDirOwner(ownedDirName, ownedDirPrefix) {
+  const remainder = ownedDirName.slice(ownedDirPrefix.length);
+  const firstDashIndex = remainder.indexOf("-");
+  const secondDashIndex = firstDashIndex === -1 ? -1 : remainder.indexOf("-", firstDashIndex + 1);
+  if (firstDashIndex === -1 || secondDashIndex === -1) {
+    return null;
+  }
+  const pid = Number.parseInt(remainder.slice(0, firstDashIndex), 10);
+  const processStartedAtMs = Number.parseInt(
+    remainder.slice(firstDashIndex + 1, secondDashIndex),
+    10
+  );
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null;
+  }
+  if (!Number.isInteger(processStartedAtMs) || processStartedAtMs <= 0) {
+    return null;
+  }
+  return { pid, processStartedAtMs };
+}
+async function sleep4(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/browser/shared-real-browser-session.ts
+var import_node_crypto4 = require("crypto");
+var import_node_child_process3 = require("child_process");
+var import_promises5 = require("fs/promises");
+var import_node_net = require("net");
+var import_node_path5 = require("path");
+var import_playwright = require("playwright");
+var SHARED_SESSION_RETRY_DELAY_MS2 = 50;
+async function acquireSharedRealBrowserSession(options) {
+  const reservation = await reserveSharedSessionClient(options);
+  const sessionContext = await attachToSharedSession(reservation, options);
+  let closed = false;
+  return {
+    browser: sessionContext.browser,
+    context: sessionContext.context,
+    page: sessionContext.page,
+    close: async () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      await releaseSharedSessionClient(sessionContext);
+    }
+  };
+}
+function getOwnedRealBrowserProcessPolicy(platformName = process.platform) {
+  if (platformName === "win32") {
+    return {
+      detached: false,
+      killStrategy: "taskkill",
+      shouldUnref: true
+    };
+  }
+  if (platformName === "darwin") {
+    return {
+      detached: false,
+      killStrategy: "process",
+      shouldUnref: true
+    };
+  }
+  return {
+    detached: true,
+    killStrategy: "process-group",
+    shouldUnref: true
+  };
+}
+async function reserveSharedSessionClient(options) {
+  while (true) {
+    const outcome = await withPersistentProfileControlLock(
+      options.persistentProfile.userDataDir,
+      async () => {
+        if (await isPersistentProfileWriteLocked(
+          options.persistentProfile.userDataDir
+        )) {
+          return { kind: "wait" };
+        }
+        if (await hasActiveRuntimeProfileCreations(
+          options.persistentProfile.userDataDir
+        )) {
+          return { kind: "wait" };
+        }
+        return await withSharedSessionLock(
+          options.persistentProfile.userDataDir,
+          async () => {
+            const state = await inspectSharedSessionState(options);
+            if (state.kind === "wait") {
+              return { kind: "wait" };
+            }
+            if (state.kind === "ready") {
+              return {
+                kind: "ready",
+                reservation: await registerSharedSessionClient(
+                  options.persistentProfile.userDataDir,
+                  state.metadata
+                )
+              };
+            }
+            return {
+              kind: "launch",
+              reservation: await launchSharedSession(options)
+            };
+          }
+        );
+      }
+    );
+    if (outcome.kind === "wait") {
+      await sleep5(SHARED_SESSION_RETRY_DELAY_MS2);
+      continue;
+    }
+    if (outcome.kind === "ready") {
+      return outcome.reservation;
+    }
+    try {
+      await waitForSharedSessionReady(
+        outcome.reservation.metadata,
+        options.timeoutMs
+      );
+    } catch (error) {
+      await cleanupFailedSharedSessionLaunch(outcome.reservation);
+      throw error;
+    }
+    try {
+      return await withSharedSessionLock(
+        options.persistentProfile.userDataDir,
+        async () => {
+          const metadata = await readSharedSessionMetadata(
+            options.persistentProfile.userDataDir
+          );
+          if (!metadata || metadata.sessionId !== outcome.reservation.metadata.sessionId || !processOwnersEqual(
+            metadata.browserOwner,
+            outcome.reservation.launchedBrowserOwner
+          )) {
+            throw new Error(
+              "The shared real-browser session changed before launch finalized."
+            );
+          }
+          const readyMetadata = {
+            ...metadata,
+            state: "ready"
+          };
+          await writeSharedSessionMetadata(
+            options.persistentProfile.userDataDir,
+            readyMetadata
+          );
+          return await registerSharedSessionClient(
+            options.persistentProfile.userDataDir,
+            readyMetadata
+          );
+        }
+      );
+    } catch (error) {
+      await cleanupFailedSharedSessionLaunch(outcome.reservation);
+      throw error;
+    }
+  }
+}
+async function attachToSharedSession(reservation, options) {
+  let browser = null;
+  let page = null;
+  try {
+    const browserWsUrl = await resolveCdpWebSocketUrl(
+      buildSharedSessionDiscoveryUrl(reservation.metadata.debugPort),
+      options.timeoutMs
+    );
+    browser = await import_playwright.chromium.connectOverCDP(browserWsUrl, {
+      timeout: options.timeoutMs
+    });
+    const context = getPrimaryBrowserContext(browser);
+    page = await getSharedSessionPage(context, reservation.reuseExistingPage);
+    if (options.initialUrl) {
+      await page.goto(options.initialUrl, {
+        timeout: options.timeoutMs,
+        waitUntil: "domcontentloaded"
+      });
+    }
+    return {
+      browser,
+      clientId: reservation.client.clientId,
+      context,
+      page,
+      persistentUserDataDir: reservation.metadata.persistentUserDataDir,
+      sessionId: reservation.metadata.sessionId
+    };
+  } catch (error) {
+    if (page) {
+      await page.close().catch(() => void 0);
+    }
+    if (browser) {
+      await browser.close().catch(() => void 0);
+    }
+    await cleanupFailedSharedSessionAttach({
+      clientId: reservation.client.clientId,
+      persistentUserDataDir: reservation.metadata.persistentUserDataDir,
+      sessionId: reservation.metadata.sessionId
+    });
+    throw error;
+  }
+}
+async function releaseSharedSessionClient(context) {
+  const releasePlan = await prepareSharedSessionCloseIfIdle(
+    context.persistentUserDataDir,
+    context.clientId,
+    context.sessionId
+  );
+  if (releasePlan.closeBrowser) {
+    await closeSharedSessionBrowser(
+      context.persistentUserDataDir,
+      releasePlan,
+      context.browser
+    );
+    return;
+  }
+  await context.page.close().catch(() => void 0);
+  await context.browser.close().catch(() => void 0);
+}
+async function inspectSharedSessionState(options) {
+  const persistentUserDataDir = options.persistentProfile.userDataDir;
+  const liveClients = await listLiveSharedSessionClients(persistentUserDataDir);
+  const metadata = await readSharedSessionMetadata(persistentUserDataDir);
+  if (!metadata) {
+    if (liveClients.length > 0) {
+      throw new Error(
+        `Shared real-browser session metadata for "${persistentUserDataDir}" is missing while clients are still attached.`
+      );
+    }
+    await (0, import_promises5.rm)(buildSharedSessionDirPath(persistentUserDataDir), {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+    return { kind: "missing" };
+  }
+  assertSharedSessionCompatibility(metadata, options);
+  const browserState = await getProcessLiveness(metadata.browserOwner);
+  if (browserState === "dead") {
+    await (0, import_promises5.rm)(buildSharedSessionDirPath(persistentUserDataDir), {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+    return { kind: "missing" };
+  }
+  if (metadata.state === "ready") {
+    return {
+      kind: "ready",
+      metadata
+    };
+  }
+  const stateOwnerState = await getProcessLiveness(metadata.stateOwner);
+  if (stateOwnerState === "dead") {
+    const recoveredMetadata = {
+      ...metadata,
+      state: "ready"
+    };
+    await writeSharedSessionMetadata(persistentUserDataDir, recoveredMetadata);
+    return {
+      kind: "ready",
+      metadata: recoveredMetadata
+    };
+  }
+  return { kind: "wait" };
+}
+async function launchSharedSession(options) {
+  const persistentUserDataDir = options.persistentProfile.userDataDir;
+  await clearPersistentProfileSingletons(persistentUserDataDir);
+  const debugPort = await reserveDebugPort();
+  const launchArgs = buildRealBrowserLaunchArgs({
+    debugPort,
+    headless: options.headless,
+    profileDirectory: options.profileDirectory,
+    userDataDir: persistentUserDataDir
+  });
+  const processPolicy = getOwnedRealBrowserProcessPolicy();
+  const processHandle = (0, import_node_child_process3.spawn)(options.executablePath, launchArgs, {
+    detached: processPolicy.detached,
+    stdio: "ignore"
+  });
+  if (processPolicy.shouldUnref) {
+    processHandle.unref();
+  }
+  try {
+    const browserOwner = await waitForSpawnedProcessOwner(
+      processHandle.pid,
+      options.timeoutMs
+    );
+    const metadata = {
+      browserOwner,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      debugPort,
+      executablePath: options.executablePath,
+      headless: options.headless,
+      persistentUserDataDir,
+      profileDirectory: options.profileDirectory,
+      sessionId: (0, import_node_crypto4.randomUUID)(),
+      state: "launching",
+      stateOwner: CURRENT_PROCESS_OWNER
+    };
+    await writeSharedSessionMetadata(persistentUserDataDir, metadata);
+    return {
+      launchedBrowserOwner: browserOwner,
+      metadata
+    };
+  } catch (error) {
+    await killSpawnedBrowserProcess(processHandle);
+    await (0, import_promises5.rm)(buildSharedSessionDirPath(persistentUserDataDir), {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+    throw error;
+  }
+}
+async function cleanupFailedSharedSessionLaunch(reservation) {
+  const shouldPreserveLiveBrowser = await withSharedSessionLock(
+    reservation.metadata.persistentUserDataDir,
+    async () => {
+      const metadata = await readSharedSessionMetadata(
+        reservation.metadata.persistentUserDataDir
+      );
+      if (metadata && metadata.sessionId === reservation.metadata.sessionId && processOwnersEqual(
+        metadata.browserOwner,
+        reservation.launchedBrowserOwner
+      )) {
+        if (await getProcessLiveness(metadata.browserOwner) !== "dead") {
+          const readyMetadata = {
+            ...metadata,
+            state: "ready"
+          };
+          await writeSharedSessionMetadata(
+            reservation.metadata.persistentUserDataDir,
+            readyMetadata
+          );
+          return true;
+        }
+        await (0, import_promises5.rm)(
+          buildSharedSessionDirPath(
+            reservation.metadata.persistentUserDataDir
+          ),
+          {
+            force: true,
+            recursive: true
+          }
+        ).catch(() => void 0);
+      }
+      return false;
+    }
+  );
+  if (shouldPreserveLiveBrowser) {
+    return;
+  }
+  await killOwnedBrowserProcess(reservation.launchedBrowserOwner);
+  await waitForProcessToExit(reservation.launchedBrowserOwner, 2e3);
+}
+async function cleanupFailedSharedSessionAttach(options) {
+  const closePlan = await prepareSharedSessionCloseIfIdle(
+    options.persistentUserDataDir,
+    options.clientId,
+    options.sessionId
+  );
+  if (!closePlan.closeBrowser) {
+    return;
+  }
+  await closeSharedSessionBrowser(options.persistentUserDataDir, closePlan);
+}
+async function waitForSharedSessionReady(metadata, timeoutMs) {
+  await resolveCdpWebSocketUrl(
+    buildSharedSessionDiscoveryUrl(metadata.debugPort),
+    timeoutMs
+  );
+}
+function buildRealBrowserLaunchArgs(options) {
+  const args = [
+    `--user-data-dir=${options.userDataDir}`,
+    `--profile-directory=${options.profileDirectory}`,
+    `--remote-debugging-port=${options.debugPort}`,
+    "--disable-blink-features=AutomationControlled"
+  ];
+  if (options.headless) {
+    args.push("--headless=new");
+  }
+  return args;
+}
+async function requestBrowserShutdown(browser) {
+  let session = null;
+  try {
+    session = await browser.newBrowserCDPSession();
+    await session.send("Browser.close");
+  } catch {
+  } finally {
+    await session?.detach().catch(() => void 0);
+  }
+}
+async function killOwnedBrowserProcess(owner) {
+  if (await getProcessLiveness(owner) === "dead") {
+    return;
+  }
+  await killOwnedBrowserProcessByPid(owner.pid);
+}
+async function killSpawnedBrowserProcess(processHandle) {
+  const pid = processHandle.pid;
+  if (!pid || processHandle.exitCode !== null) {
+    return;
+  }
+  await killOwnedBrowserProcessByPid(pid);
+  await waitForPidToExit(pid, 2e3);
+}
+async function killOwnedBrowserProcessByPid(pid) {
+  const processPolicy = getOwnedRealBrowserProcessPolicy();
+  if (processPolicy.killStrategy === "taskkill") {
+    await new Promise((resolve) => {
+      const killer = (0, import_node_child_process3.spawn)(
+        "taskkill",
+        ["/pid", String(pid), "/t", "/f"],
+        {
+          stdio: "ignore"
+        }
+      );
+      killer.on("error", () => resolve());
+      killer.on("exit", () => resolve());
+    });
+    return;
+  }
+  if (processPolicy.killStrategy === "process-group") {
+    try {
+      process.kill(-pid, "SIGKILL");
+      return;
+    } catch {
+    }
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+}
+async function waitForProcessToExit(owner, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await getProcessLiveness(owner) === "dead") {
+      return;
+    }
+    await sleep5(50);
+  }
+}
+async function waitForPidToExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessRunning(pid)) {
+      return;
+    }
+    await sleep5(50);
+  }
+}
+async function waitForSpawnedProcessOwner(pid, timeoutMs) {
+  if (!pid || pid <= 0) {
+    throw new Error("Chrome did not expose a child process id.");
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const owner = await readProcessOwner(pid);
+    if (owner) {
+      return owner;
+    }
+    await sleep5(50);
+  }
+  throw new Error(
+    `Chrome process ${pid} did not report a stable process start time.`
+  );
+}
+async function withSharedSessionLock(persistentUserDataDir, action) {
+  return await withDirLock(
+    buildSharedSessionLockPath(persistentUserDataDir),
+    action
+  );
+}
+async function registerSharedSessionClient(persistentUserDataDir, metadata) {
+  const liveClients = await listLiveSharedSessionClients(persistentUserDataDir);
+  const client = buildSharedSessionClientRegistration();
+  await (0, import_promises5.mkdir)(buildSharedSessionClientsDirPath(persistentUserDataDir), {
+    recursive: true
+  });
+  await (0, import_promises5.writeFile)(
+    buildSharedSessionClientPath(persistentUserDataDir, client.clientId),
+    JSON.stringify(client, null, 2),
+    {
+      flag: "wx"
+    }
+  );
+  return {
+    client,
+    metadata,
+    reuseExistingPage: liveClients.length === 0
+  };
+}
+async function removeSharedSessionClientRegistration(persistentUserDataDir, clientId) {
+  await (0, import_promises5.rm)(buildSharedSessionClientPath(persistentUserDataDir, clientId), {
+    force: true
+  }).catch(() => void 0);
+}
+async function listLiveSharedSessionClients(persistentUserDataDir) {
+  const clientsDirPath = buildSharedSessionClientsDirPath(persistentUserDataDir);
+  let entries;
+  try {
+    entries = await (0, import_promises5.readdir)(clientsDirPath, {
+      encoding: "utf8",
+      withFileTypes: true
+    });
+  } catch {
+    return [];
+  }
+  const liveClients = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+    const filePath = (0, import_node_path5.join)(clientsDirPath, entry.name);
+    const registration = await readSharedSessionClientRegistration(filePath);
+    if (!registration) {
+      await (0, import_promises5.rm)(filePath, { force: true }).catch(() => void 0);
+      continue;
+    }
+    if (await getProcessLiveness(registration.owner) === "dead") {
+      await (0, import_promises5.rm)(filePath, { force: true }).catch(() => void 0);
+      continue;
+    }
+    liveClients.push(registration);
+  }
+  return liveClients;
+}
+async function readSharedSessionClientRegistration(filePath) {
+  try {
+    const raw = await (0, import_promises5.readFile)(filePath, "utf8");
+    return parseSharedSessionClientRegistration(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function buildSharedSessionClientRegistration() {
+  return {
+    clientId: (0, import_node_crypto4.randomUUID)(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    owner: CURRENT_PROCESS_OWNER
+  };
+}
+function parseSharedSessionClientRegistration(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const parsed = value;
+  const owner = parseProcessOwner(parsed.owner);
+  if (!owner || typeof parsed.clientId !== "string" || typeof parsed.createdAt !== "string") {
+    return null;
+  }
+  return {
+    clientId: parsed.clientId,
+    createdAt: parsed.createdAt,
+    owner
+  };
+}
+function assertSharedSessionCompatibility(metadata, options) {
+  if (metadata.executablePath !== options.executablePath) {
+    throw new Error(
+      `Chrome profile "${options.profileDirectory}" is already running with executable "${metadata.executablePath}", not "${options.executablePath}".`
+    );
+  }
+  if (metadata.headless !== options.headless) {
+    throw new Error(
+      `Chrome profile "${options.profileDirectory}" is already running with headless=${metadata.headless}, not ${options.headless}.`
+    );
+  }
+}
+async function prepareSharedSessionCloseIfIdle(persistentUserDataDir, clientId, sessionId) {
+  return await withSharedSessionLock(persistentUserDataDir, async () => {
+    const metadata = await readSharedSessionMetadata(persistentUserDataDir);
+    await removeSharedSessionClientRegistration(
+      persistentUserDataDir,
+      clientId
+    );
+    if (!metadata || metadata.sessionId !== sessionId) {
+      return {
+        closeBrowser: false,
+        sessionId
+      };
+    }
+    const liveClients = await listLiveSharedSessionClients(
+      persistentUserDataDir
+    );
+    if (liveClients.length > 0) {
+      return {
+        closeBrowser: false,
+        sessionId: metadata.sessionId
+      };
+    }
+    const closingMetadata = {
+      ...metadata,
+      state: "closing",
+      stateOwner: CURRENT_PROCESS_OWNER
+    };
+    await writeSharedSessionMetadata(
+      persistentUserDataDir,
+      closingMetadata
+    );
+    return {
+      browserOwner: closingMetadata.browserOwner,
+      closeBrowser: true,
+      sessionId: closingMetadata.sessionId
+    };
+  });
+}
+async function closeSharedSessionBrowser(persistentUserDataDir, closePlan, browser) {
+  if (browser) {
+    await requestBrowserShutdown(browser);
+    await waitForProcessToExit(closePlan.browserOwner, 1e3);
+  }
+  if (await getProcessLiveness(closePlan.browserOwner) !== "dead") {
+    await killOwnedBrowserProcess(closePlan.browserOwner);
+    await waitForProcessToExit(closePlan.browserOwner, 2e3);
+  }
+  await finalizeSharedSessionClose(persistentUserDataDir, closePlan.sessionId);
+}
+async function finalizeSharedSessionClose(persistentUserDataDir, sessionId) {
+  await withSharedSessionLock(persistentUserDataDir, async () => {
+    const metadata = await readSharedSessionMetadata(persistentUserDataDir);
+    if (!metadata || metadata.sessionId !== sessionId) {
+      return;
+    }
+    const liveClients = await listLiveSharedSessionClients(
+      persistentUserDataDir
+    );
+    if (liveClients.length > 0) {
+      const readyMetadata = {
+        ...metadata,
+        state: "ready"
+      };
+      await writeSharedSessionMetadata(
+        persistentUserDataDir,
+        readyMetadata
+      );
+      return;
+    }
+    if (await getProcessLiveness(metadata.browserOwner) !== "dead") {
+      const readyMetadata = {
+        ...metadata,
+        state: "ready"
+      };
+      await writeSharedSessionMetadata(
+        persistentUserDataDir,
+        readyMetadata
+      );
+      return;
+    }
+    await (0, import_promises5.rm)(buildSharedSessionDirPath(persistentUserDataDir), {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+  });
+}
+function getPrimaryBrowserContext(browser) {
+  const contexts = browser.contexts();
+  if (contexts.length === 0) {
+    throw new Error(
+      "Connection succeeded but no browser contexts were exposed."
+    );
+  }
+  return contexts[0];
+}
+async function getSharedSessionPage(context, reuseExistingPage) {
+  if (reuseExistingPage) {
+    return await getExistingPageOrCreate(context);
+  }
+  return await context.newPage();
+}
+async function getExistingPageOrCreate(context) {
+  const existingPage = context.pages()[0];
+  if (existingPage) {
+    return existingPage;
+  }
+  return await context.newPage();
+}
+function buildSharedSessionDiscoveryUrl(debugPort) {
+  return `http://127.0.0.1:${debugPort}`;
+}
+async function resolveCdpWebSocketUrl(cdpUrl, timeoutMs) {
+  if (cdpUrl.startsWith("ws://") || cdpUrl.startsWith("wss://")) {
+    return cdpUrl;
+  }
+  const versionUrl = normalizeDiscoveryUrl(cdpUrl);
+  const deadline = Date.now() + timeoutMs;
+  let lastError = "CDP discovery did not respond.";
+  while (Date.now() < deadline) {
+    const remaining = Math.max(deadline - Date.now(), 1e3);
+    try {
+      const response = await fetch(versionUrl, {
+        signal: AbortSignal.timeout(Math.min(remaining, 5e3))
+      });
+      if (!response.ok) {
+        lastError = `${response.status} ${response.statusText}`;
+      } else {
+        const payload = await response.json();
+        const wsUrl = payload && typeof payload === "object" && !Array.isArray(payload) && typeof payload.webSocketDebuggerUrl === "string" ? payload.webSocketDebuggerUrl : null;
+        if (wsUrl && wsUrl.trim()) {
+          return wsUrl;
+        }
+        lastError = "CDP discovery response did not include webSocketDebuggerUrl.";
+      }
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : "Unknown error";
+    }
+    await sleep5(100);
   }
-  return isProcessRunning(owner.pid);
+  throw new Error(
+    `Failed to resolve a CDP websocket URL from ${versionUrl.toString()}: ${lastError}`
+  );
 }
-function parseTempDirOwner(tempDirName, tempDirPrefix) {
-  const remainder = tempDirName.slice(tempDirPrefix.length);
-  const firstDashIndex = remainder.indexOf("-");
-  const secondDashIndex = firstDashIndex === -1 ? -1 : remainder.indexOf("-", firstDashIndex + 1);
-  if (firstDashIndex === -1 || secondDashIndex === -1) {
-    return null;
+function normalizeDiscoveryUrl(cdpUrl) {
+  let parsed;
+  try {
+    parsed = new URL(cdpUrl);
+  } catch {
+    throw new Error(
+      `Invalid CDP URL "${cdpUrl}". Use an http(s) or ws(s) endpoint.`
+    );
   }
-  const pid = Number.parseInt(remainder.slice(0, firstDashIndex), 10);
-  const processStartedAtMs = Number.parseInt(
-    remainder.slice(firstDashIndex + 1, secondDashIndex),
-    10
-  );
-  if (!Number.isInteger(pid) || pid <= 0) {
-    return null;
+  if (parsed.protocol === "ws:" || parsed.protocol === "wss:") {
+    return parsed;
   }
-  if (!Number.isInteger(processStartedAtMs) || processStartedAtMs <= 0) {
-    return null;
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(
+      `Unsupported CDP URL protocol "${parsed.protocol}". Use http(s) or ws(s).`
+    );
   }
-  return { pid, processStartedAtMs };
+  const normalized = new URL(parsed.toString());
+  normalized.pathname = "/json/version";
+  normalized.search = "";
+  normalized.hash = "";
+  return normalized;
 }
-function isProcessRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
-    return code !== "ESRCH";
-  }
+async function reserveDebugPort() {
+  return await new Promise((resolve, reject) => {
+    const server = (0, import_node_net.createServer)();
+    server.unref();
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close();
+        reject(new Error("Failed to reserve a local debug port."));
+        return;
+      }
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(address.port);
+      });
+    });
+  });
+}
+async function sleep5(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 // src/browser/pool.ts
 var BrowserPool = class {
   browser = null;
-  cdpProxy = null;
-  launchedProcess = null;
-  managedUserDataDir = null;
-  persistentProfile = false;
+  activeSessionClose = null;
+  closeInFlight = null;
   defaults;
   constructor(defaults = {}) {
     this.defaults = defaults;
   }
   async launch(options = {}) {
-    if (this.browser || this.cdpProxy || this.launchedProcess || this.managedUserDataDir) {
+    if (this.browser || this.activeSessionClose) {
       await this.close();
     }
     const mode = options.mode ?? this.defaults.mode ?? "chromium";
@@ -2140,30 +3748,26 @@ var BrowserPool = class {
     return this.launchSandbox(options);
   }
   async close() {
-    const browser = this.browser;
-    const cdpProxy = this.cdpProxy;
-    const launchedProcess = this.launchedProcess;
-    const managedUserDataDir = this.managedUserDataDir;
-    const persistentProfile = this.persistentProfile;
-    this.browser = null;
-    this.cdpProxy = null;
-    this.launchedProcess = null;
-    this.managedUserDataDir = null;
-    this.persistentProfile = false;
+    if (this.closeInFlight) {
+      await this.closeInFlight;
+      return;
+    }
+    const closeOperation = this.closeCurrent();
+    this.closeInFlight = closeOperation;
     try {
-      if (browser) {
-        await browser.close().catch(() => void 0);
-      }
+      await closeOperation;
+      this.browser = null;
+      this.activeSessionClose = null;
     } finally {
-      cdpProxy?.close();
-      await killProcessTree(launchedProcess);
-      if (managedUserDataDir && !persistentProfile) {
-        await (0, import_promises2.rm)(managedUserDataDir, {
-          recursive: true,
-          force: true
-        }).catch(() => void 0);
-      }
+      this.closeInFlight = null;
+    }
+  }
+  async closeCurrent() {
+    if (this.activeSessionClose) {
+      await this.activeSessionClose();
+      return;
     }
+    await this.browser?.close().catch(() => void 0);
   }
   async connectToRunning(cdpUrl, timeout) {
     let browser = null;
@@ -2178,11 +3782,14 @@ var BrowserPool = class {
       }
       cdpProxy = new CDPProxy(browserWsUrl, targetId);
       const proxyWsUrl = await cdpProxy.start();
-      browser = await import_playwright.chromium.connectOverCDP(proxyWsUrl, {
+      browser = await import_playwright2.chromium.connectOverCDP(proxyWsUrl, {
         timeout: timeout ?? 3e4
       });
       this.browser = browser;
-      this.cdpProxy = cdpProxy;
+      this.activeSessionClose = async () => {
+        await browser?.close().catch(() => void 0);
+        cdpProxy?.close();
+      };
       const { context, page } = await pickBrowserContextAndPage(browser);
       return { browser, context, page, isExternal: true };
     } catch (error) {
@@ -2191,7 +3798,7 @@ var BrowserPool = class {
       }
       cdpProxy?.close();
       this.browser = null;
-      this.cdpProxy = null;
+      this.activeSessionClose = null;
       throw error;
     }
   }
@@ -2211,55 +3818,29 @@ var BrowserPool = class {
       sourceUserDataDir,
       profileDirectory
     );
-    await clearPersistentProfileSingletons(persistentProfile.userDataDir);
-    const debugPort = await reserveDebugPort();
-    const headless = resolveLaunchHeadless(
-      "real",
-      options.headless,
-      this.defaults.headless
-    );
-    const launchArgs = buildRealBrowserLaunchArgs({
-      userDataDir: persistentProfile.userDataDir,
+    const sharedSession = await acquireSharedRealBrowserSession({
+      executablePath,
+      headless: resolveLaunchHeadless(
+        "real",
+        options.headless,
+        this.defaults.headless
+      ),
+      initialUrl: options.initialUrl,
+      persistentProfile,
       profileDirectory,
-      debugPort,
-      headless
-    });
-    const processHandle = (0, import_node_child_process.spawn)(executablePath, launchArgs, {
-      detached: process.platform !== "win32",
-      stdio: "ignore"
+      timeoutMs: options.timeout ?? 3e4
     });
-    processHandle.unref();
-    let browser = null;
-    try {
-      const wsUrl = await resolveCdpWebSocketUrl(
-        `http://127.0.0.1:${debugPort}`,
-        options.timeout ?? 3e4
-      );
-      browser = await import_playwright.chromium.connectOverCDP(wsUrl, {
-        timeout: options.timeout ?? 3e4
-      });
-      const { context, page } = await createOwnedBrowserContextAndPage(
-        browser
-      );
-      if (options.initialUrl) {
-        await page.goto(options.initialUrl, {
-          waitUntil: "domcontentloaded",
-          timeout: options.timeout ?? 3e4
-        });
-      }
-      this.browser = browser;
-      this.launchedProcess = processHandle;
-      this.managedUserDataDir = persistentProfile.userDataDir;
-      this.persistentProfile = true;
-      return { browser, context, page, isExternal: false };
-    } catch (error) {
-      await browser?.close().catch(() => void 0);
-      await killProcessTree(processHandle);
-      throw error;
-    }
+    this.browser = sharedSession.browser;
+    this.activeSessionClose = sharedSession.close;
+    return {
+      browser: sharedSession.browser,
+      context: sharedSession.context,
+      page: sharedSession.page,
+      isExternal: false
+    };
   }
   async launchSandbox(options) {
-    const browser = await import_playwright.chromium.launch({
+    const browser = await import_playwright2.chromium.launch({
       headless: resolveLaunchHeadless(
         "chromium",
         options.headless,
@@ -2272,11 +3853,14 @@ var BrowserPool = class {
     const context = await browser.newContext(options.context || {});
     const page = await context.newPage();
     this.browser = browser;
+    this.activeSessionClose = async () => {
+      await browser.close().catch(() => void 0);
+    };
     return { browser, context, page, isExternal: false };
   }
 };
 async function pickBrowserContextAndPage(browser) {
-  const context = getPrimaryBrowserContext(browser);
+  const context = getPrimaryBrowserContext2(browser);
   const page = await getAttachedPageOrCreate(context);
   return { context, page };
 }
@@ -2289,11 +3873,6 @@ function resolveLaunchHeadless(mode, requestedHeadless, defaultHeadless) {
   }
   return mode === "real";
 }
-async function createOwnedBrowserContextAndPage(browser) {
-  const context = getPrimaryBrowserContext(browser);
-  const page = await getExistingPageOrCreate(context);
-  return { context, page };
-}
 async function getAttachedPageOrCreate(context) {
   const pages = context.pages();
   const inspectablePage = pages.find(
@@ -2308,14 +3887,7 @@ async function getAttachedPageOrCreate(context) {
   }
   return await context.newPage();
 }
-async function getExistingPageOrCreate(context) {
-  const existingPage = context.pages()[0];
-  if (existingPage) {
-    return existingPage;
-  }
-  return await context.newPage();
-}
-function getPrimaryBrowserContext(browser) {
+function getPrimaryBrowserContext2(browser) {
   const contexts = browser.contexts();
   if (contexts.length === 0) {
     throw new Error(
@@ -2334,125 +3906,6 @@ function safePageUrl(page) {
     return "";
   }
 }
-function normalizeDiscoveryUrl(cdpUrl) {
-  let parsed;
-  try {
-    parsed = new URL(cdpUrl);
-  } catch {
-    throw new Error(
-      `Invalid CDP URL "${cdpUrl}". Use an http(s) or ws(s) endpoint.`
-    );
-  }
-  if (parsed.protocol === "ws:" || parsed.protocol === "wss:") {
-    return parsed;
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error(
-      `Unsupported CDP URL protocol "${parsed.protocol}". Use http(s) or ws(s).`
-    );
-  }
-  const normalized = new URL(parsed.toString());
-  normalized.pathname = "/json/version";
-  normalized.search = "";
-  normalized.hash = "";
-  return normalized;
-}
-async function resolveCdpWebSocketUrl(cdpUrl, timeoutMs) {
-  if (cdpUrl.startsWith("ws://") || cdpUrl.startsWith("wss://")) {
-    return cdpUrl;
-  }
-  const versionUrl = normalizeDiscoveryUrl(cdpUrl);
-  const deadline = Date.now() + timeoutMs;
-  let lastError = "CDP discovery did not respond.";
-  while (Date.now() < deadline) {
-    const remaining = Math.max(deadline - Date.now(), 1e3);
-    try {
-      const response = await fetch(versionUrl, {
-        signal: AbortSignal.timeout(Math.min(remaining, 5e3))
-      });
-      if (!response.ok) {
-        lastError = `${response.status} ${response.statusText}`;
-      } else {
-        const payload = await response.json();
-        const wsUrl = payload && typeof payload === "object" && !Array.isArray(payload) && typeof payload.webSocketDebuggerUrl === "string" ? payload.webSocketDebuggerUrl : null;
-        if (wsUrl && wsUrl.trim()) {
-          return wsUrl;
-        }
-        lastError = "CDP discovery response did not include webSocketDebuggerUrl.";
-      }
-    } catch (error) {
-      lastError = error instanceof Error ? error.message : "Unknown error";
-    }
-    await sleep(100);
-  }
-  throw new Error(
-    `Failed to resolve a CDP websocket URL from ${versionUrl.toString()}: ${lastError}`
-  );
-}
-async function reserveDebugPort() {
-  return await new Promise((resolve, reject) => {
-    const server = (0, import_node_net.createServer)();
-    server.unref();
-    server.on("error", reject);
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      if (!address || typeof address === "string") {
-        server.close();
-        reject(new Error("Failed to reserve a local debug port."));
-        return;
-      }
-      server.close((error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve(address.port);
-      });
-    });
-  });
-}
-function buildRealBrowserLaunchArgs(options) {
-  const args = [
-    `--user-data-dir=${options.userDataDir}`,
-    `--profile-directory=${options.profileDirectory}`,
-    `--remote-debugging-port=${options.debugPort}`,
-    "--disable-blink-features=AutomationControlled"
-  ];
-  if (options.headless) {
-    args.push("--headless=new");
-  }
-  return args;
-}
-async function killProcessTree(processHandle) {
-  if (!processHandle || processHandle.pid == null || processHandle.exitCode !== null) {
-    return;
-  }
-  if (process.platform === "win32") {
-    await new Promise((resolve) => {
-      const killer = (0, import_node_child_process.spawn)(
-        "taskkill",
-        ["/pid", String(processHandle.pid), "/t", "/f"],
-        {
-          stdio: "ignore"
-        }
-      );
-      killer.on("error", () => resolve());
-      killer.on("exit", () => resolve());
-    });
-    return;
-  }
-  try {
-    process.kill(-processHandle.pid, "SIGKILL");
-  } catch {
-    try {
-      processHandle.kill("SIGKILL");
-    } catch {
-    }
-  }
-}
-async function sleep(ms) {
-  await new Promise((resolve) => setTimeout(resolve, ms));
-}
 
 // src/navigation.ts
 var DEFAULT_TIMEOUT = 3e4;
@@ -2832,7 +4285,7 @@ var StealthCdpRuntime = class _StealthCdpRuntime {
           TRANSIENT_CONTEXT_RETRY_DELAY_MS,
           Math.max(0, deadline - Date.now())
         );
-        await sleep2(retryDelay);
+        await sleep6(retryDelay);
       }
     }
   }
@@ -2865,7 +4318,7 @@ var StealthCdpRuntime = class _StealthCdpRuntime {
       () => ({ kind: "resolved" }),
       (error) => ({ kind: "rejected", error })
     );
-    const timeoutPromise = sleep2(
+    const timeoutPromise = sleep6(
       timeout + FRAME_EVALUATE_GRACE_MS
     ).then(() => ({ kind: "timeout" }));
     const result = await Promise.race([
@@ -3007,7 +4460,7 @@ function isIgnorableFrameError(error) {
   const message = error.message;
   return message.includes("Frame was detached") || message.includes("Target page, context or browser has been closed") || isTransientExecutionContextError(error) || message.includes("No frame for given id found");
 }
-function sleep2(ms) {
+function sleep6(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -7258,7 +8711,7 @@ async function closeTab(context, activePage, index) {
 }
 
 // src/actions/cookies.ts
-var import_promises3 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 async function getCookies(context, url) {
   return context.cookies(url ? [url] : void 0);
 }
@@ -7270,10 +8723,10 @@ async function clearCookies(context) {
 }
 async function exportCookies(context, filePath, url) {
   const cookies = await context.cookies(url ? [url] : void 0);
-  await (0, import_promises3.writeFile)(filePath, JSON.stringify(cookies, null, 2), "utf-8");
+  await (0, import_promises6.writeFile)(filePath, JSON.stringify(cookies, null, 2), "utf-8");
 }
 async function importCookies(context, filePath) {
-  const raw = await (0, import_promises3.readFile)(filePath, "utf-8");
+  const raw = await (0, import_promises6.readFile)(filePath, "utf-8");
   const cookies = JSON.parse(raw);
   await context.addCookies(cookies);
 }
@@ -7584,7 +9037,7 @@ var AdaptiveNetworkTracker = class {
         this.idleSince = 0;
       }
       const remaining = Math.max(1, options.deadline - now);
-      await sleep3(Math.min(NETWORK_POLL_MS, remaining));
+      await sleep7(Math.min(NETWORK_POLL_MS, remaining));
     }
   }
   handleRequestStarted = (request) => {
@@ -7629,7 +9082,7 @@ var AdaptiveNetworkTracker = class {
     return false;
   }
 };
-async function sleep3(ms) {
+async function sleep7(ms) {
   await new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -9331,13 +10784,13 @@ function dedupeNewest(entries) {
 }
 
 // src/cloud/cdp-client.ts
-var import_playwright2 = require("playwright");
+var import_playwright3 = require("playwright");
 var CloudCdpClient = class {
   async connect(args) {
     const endpoint = withTokenQuery(args.wsUrl, args.token);
     let browser;
     try {
-      browser = await import_playwright2.chromium.connectOverCDP(endpoint);
+      browser = await import_playwright3.chromium.connectOverCDP(endpoint);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Failed to connect to cloud CDP endpoint.";
       throw new OpensteerCloudError("CLOUD_TRANSPORT_ERROR", message);
@@ -11154,7 +12607,7 @@ async function executeAgentAction(page, action) {
     }
     case "wait": {
       const ms = numberOr(action.timeMs, action.time_ms, 1e3);
-      await sleep4(ms);
+      await sleep8(ms);
       return;
     }
     case "goto": {
@@ -11319,7 +12772,7 @@ async function pressKeyCombo(page, combo) {
     }
   }
 }
-function sleep4(ms) {
+function sleep8(ms) {
   return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 }
 
@@ -11350,7 +12803,7 @@ var OpensteerCuaAgentHandler = class {
       if (isMutatingAgentAction(action)) {
         this.onMutatingAction?.(action);
       }
-      await sleep5(this.config.waitBetweenActionsMs);
+      await sleep9(this.config.waitBetweenActionsMs);
     });
     try {
       const result = await this.client.execute({
@@ -11412,7 +12865,7 @@ var OpensteerCuaAgentHandler = class {
     await this.cursorController.preview({ x, y }, "agent");
   }
 };
-function sleep5(ms) {
+function sleep9(ms) {
   return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 }
 
@@ -11848,7 +13301,7 @@ var CursorController = class {
       for (const step of motion.points) {
         await this.renderer.move(step, this.style);
         if (motion.stepDelayMs > 0) {
-          await sleep6(motion.stepDelayMs);
+          await sleep10(motion.stepDelayMs);
         }
       }
       if (shouldPulse(intent)) {
@@ -12006,7 +13459,7 @@ function clamp2(value, min, max) {
 function shouldPulse(intent) {
   return intent === "click" || intent === "dblclick" || intent === "rightclick" || intent === "agent";
 }
-function sleep6(ms) {
+function sleep10(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
@@ -12480,15 +13933,22 @@ var Opensteer = class _Opensteer {
       }
       return;
     }
-    if (this.ownsBrowser) {
-      await this.pool.close();
-    }
-    this.browser = null;
-    this.pageRef = null;
-    this.contextRef = null;
-    this.ownsBrowser = false;
-    if (this.cursorController) {
-      await this.cursorController.dispose().catch(() => void 0);
+    let closedOwnedBrowser = false;
+    try {
+      if (this.ownsBrowser) {
+        await this.pool.close();
+        closedOwnedBrowser = true;
+      }
+    } finally {
+      this.browser = null;
+      this.pageRef = null;
+      this.contextRef = null;
+      if (!this.ownsBrowser || closedOwnedBrowser) {
+        this.ownsBrowser = false;
+      }
+      if (this.cursorController) {
+        await this.cursorController.dispose().catch(() => void 0);
+      }
     }
   }
   async syncLocalSelectorCacheToCloud() {
@@ -14816,19 +16276,19 @@ function buildLocalRunId(namespace) {
 }
 
 // src/browser/chromium-profile.ts
-var import_node_util = require("util");
-var import_node_child_process3 = require("child_process");
-var import_node_crypto2 = require("crypto");
-var import_promises4 = require("fs/promises");
-var import_node_fs2 = require("fs");
-var import_node_path2 = require("path");
+var import_node_util3 = require("util");
+var import_node_child_process5 = require("child_process");
+var import_node_crypto5 = require("crypto");
+var import_promises7 = require("fs/promises");
+var import_node_fs4 = require("fs");
+var import_node_path6 = require("path");
 var import_node_os2 = require("os");
-var import_playwright3 = require("playwright");
+var import_playwright4 = require("playwright");
 
 // src/auth/keychain-store.ts
-var import_node_child_process2 = require("child_process");
+var import_node_child_process4 = require("child_process");
 function commandExists(command) {
-  const result = (0, import_node_child_process2.spawnSync)(command, ["--help"], {
+  const result = (0, import_node_child_process4.spawnSync)(command, ["--help"], {
     encoding: "utf8",
     stdio: "ignore"
   });
@@ -14867,7 +16327,7 @@ function createMacosSecurityStore() {
   return {
     backend: "macos-security",
     get(service, account) {
-      const result = (0, import_node_child_process2.spawnSync)(
+      const result = (0, import_node_child_process4.spawnSync)(
         "security",
         ["find-generic-password", "-s", service, "-a", account, "-w"],
         { encoding: "utf8" }
@@ -14889,14 +16349,14 @@ function createMacosSecurityStore() {
         "-w",
         secret
       ];
-      const result = (0, import_node_child_process2.spawnSync)("security", args, { encoding: "utf8" });
+      const result = (0, import_node_child_process4.spawnSync)("security", args, { encoding: "utf8" });
       if (commandFailed(result)) {
         throw buildCommandError("security", args, result);
       }
     },
     delete(service, account) {
       const args = ["delete-generic-password", "-s", service, "-a", account];
-      const result = (0, import_node_child_process2.spawnSync)("security", args, { encoding: "utf8" });
+      const result = (0, import_node_child_process4.spawnSync)("security", args, { encoding: "utf8" });
       if (commandFailed(result)) {
         return;
       }
@@ -14907,7 +16367,7 @@ function createLinuxSecretToolStore() {
   return {
     backend: "linux-secret-tool",
     get(service, account) {
-      const result = (0, import_node_child_process2.spawnSync)(
+      const result = (0, import_node_child_process4.spawnSync)(
         "secret-tool",
         ["lookup", "service", service, "account", account],
         {
@@ -14930,7 +16390,7 @@ function createLinuxSecretToolStore() {
         "account",
         account
       ];
-      const result = (0, import_node_child_process2.spawnSync)("secret-tool", args, {
+      const result = (0, import_node_child_process4.spawnSync)("secret-tool", args, {
         encoding: "utf8",
         input: secret
       });
@@ -14940,7 +16400,7 @@ function createLinuxSecretToolStore() {
     },
     delete(service, account) {
       const args = ["clear", "service", service, "account", account];
-      (0, import_node_child_process2.spawnSync)("secret-tool", args, {
+      (0, import_node_child_process4.spawnSync)("secret-tool", args, {
         encoding: "utf8"
       });
     }
@@ -14963,7 +16423,7 @@ function createKeychainStore() {
 }
 
 // src/browser/chromium-profile.ts
-var execFileAsync = (0, import_node_util.promisify)(import_node_child_process3.execFile);
+var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process5.execFile);
 var CHROMIUM_EPOCH_MICROS = 11644473600000000n;
 var AES_BLOCK_BYTES = 16;
 var MAC_KEY_ITERATIONS = 1003;
@@ -15022,20 +16482,20 @@ var CHROMIUM_BRANDS = [
 ];
 function directoryExists(filePath) {
   try {
-    return (0, import_node_fs2.statSync)(filePath).isDirectory();
+    return (0, import_node_fs4.statSync)(filePath).isDirectory();
   } catch {
     return false;
   }
 }
 function fileExists(filePath) {
   try {
-    return (0, import_node_fs2.statSync)(filePath).isFile();
+    return (0, import_node_fs4.statSync)(filePath).isFile();
   } catch {
     return false;
   }
 }
 function resolveCookieDbPath(profileDir) {
-  const candidates = [(0, import_node_path2.join)(profileDir, "Network", "Cookies"), (0, import_node_path2.join)(profileDir, "Cookies")];
+  const candidates = [(0, import_node_path6.join)(profileDir, "Network", "Cookies"), (0, import_node_path6.join)(profileDir, "Cookies")];
   for (const candidate of candidates) {
     if (fileExists(candidate)) {
       return candidate;
@@ -15044,10 +16504,10 @@ function resolveCookieDbPath(profileDir) {
   return null;
 }
 async function selectProfileDirFromUserDataDir(userDataDir) {
-  const entries = await (0, import_promises4.readdir)(userDataDir, {
+  const entries = await (0, import_promises7.readdir)(userDataDir, {
     withFileTypes: true
   }).catch(() => []);
-  const candidates = entries.filter((entry) => entry.isDirectory()).map((entry) => (0, import_node_path2.join)(userDataDir, entry.name)).filter((entryPath) => resolveCookieDbPath(entryPath));
+  const candidates = entries.filter((entry) => entry.isDirectory()).map((entry) => (0, import_node_path6.join)(userDataDir, entry.name)).filter((entryPath) => resolveCookieDbPath(entryPath));
   return candidates;
 }
 async function resolveChromiumProfileLocation(inputPath) {
@@ -15055,16 +16515,16 @@ async function resolveChromiumProfileLocation(inputPath) {
   if (!expandedPath) {
     throw new Error("Profile path cannot be empty.");
   }
-  if (fileExists(expandedPath) && (0, import_node_path2.basename)(expandedPath) === "Cookies") {
-    const directParent = (0, import_node_path2.dirname)(expandedPath);
-    const profileDir = (0, import_node_path2.basename)(directParent) === "Network" ? (0, import_node_path2.dirname)(directParent) : directParent;
-    const userDataDir = (0, import_node_path2.dirname)(profileDir);
+  if (fileExists(expandedPath) && (0, import_node_path6.basename)(expandedPath) === "Cookies") {
+    const directParent = (0, import_node_path6.dirname)(expandedPath);
+    const profileDir = (0, import_node_path6.basename)(directParent) === "Network" ? (0, import_node_path6.dirname)(directParent) : directParent;
+    const userDataDir = (0, import_node_path6.dirname)(profileDir);
     return {
       userDataDir,
       profileDir,
-      profileDirectory: (0, import_node_path2.basename)(profileDir),
+      profileDirectory: (0, import_node_path6.basename)(profileDir),
       cookieDbPath: expandedPath,
-      localStatePath: fileExists((0, import_node_path2.join)(userDataDir, "Local State")) ? (0, import_node_path2.join)(userDataDir, "Local State") : null
+      localStatePath: fileExists((0, import_node_path6.join)(userDataDir, "Local State")) ? (0, import_node_path6.join)(userDataDir, "Local State") : null
     };
   }
   if (fileExists(expandedPath)) {
@@ -15079,16 +16539,16 @@ async function resolveChromiumProfileLocation(inputPath) {
   }
   const directCookieDb = resolveCookieDbPath(expandedPath);
   if (directCookieDb) {
-    const userDataDir = (0, import_node_path2.dirname)(expandedPath);
+    const userDataDir = (0, import_node_path6.dirname)(expandedPath);
     return {
       userDataDir,
       profileDir: expandedPath,
-      profileDirectory: (0, import_node_path2.basename)(expandedPath),
+      profileDirectory: (0, import_node_path6.basename)(expandedPath),
       cookieDbPath: directCookieDb,
-      localStatePath: fileExists((0, import_node_path2.join)(userDataDir, "Local State")) ? (0, import_node_path2.join)(userDataDir, "Local State") : null
+      localStatePath: fileExists((0, import_node_path6.join)(userDataDir, "Local State")) ? (0, import_node_path6.join)(userDataDir, "Local State") : null
     };
   }
-  const localStatePath = (0, import_node_path2.join)(expandedPath, "Local State");
+  const localStatePath = (0, import_node_path6.join)(expandedPath, "Local State");
   if (!fileExists(localStatePath)) {
     throw new Error(
       `Unsupported profile source "${inputPath}". Pass a Chromium profile directory, user-data dir, or Cookies database path.`
@@ -15101,7 +16561,7 @@ async function resolveChromiumProfileLocation(inputPath) {
     );
   }
   if (profileDirs.length > 1) {
-    const candidates = profileDirs.map((entry) => (0, import_node_path2.basename)(entry)).join(", ");
+    const candidates = profileDirs.map((entry) => (0, import_node_path6.basename)(entry)).join(", ");
     throw new Error(
       `"${inputPath}" contains multiple Chromium profiles (${candidates}). Pass a specific profile directory such as "${profileDirs[0]}".`
     );
@@ -15116,7 +16576,7 @@ async function resolveChromiumProfileLocation(inputPath) {
   return {
     userDataDir: expandedPath,
     profileDir: selectedProfileDir,
-    profileDirectory: (0, import_node_path2.basename)(selectedProfileDir),
+    profileDirectory: (0, import_node_path6.basename)(selectedProfileDir),
     cookieDbPath,
     localStatePath
   };
@@ -15131,25 +16591,25 @@ function detectChromiumBrand(location) {
   return DEFAULT_CHROMIUM_BRAND;
 }
 async function createSqliteSnapshot(dbPath) {
-  const snapshotDir = await (0, import_promises4.mkdtemp)((0, import_node_path2.join)((0, import_node_os2.tmpdir)(), "opensteer-cookie-db-"));
-  const snapshotPath = (0, import_node_path2.join)(snapshotDir, "Cookies");
-  await (0, import_promises4.copyFile)(dbPath, snapshotPath);
+  const snapshotDir = await (0, import_promises7.mkdtemp)((0, import_node_path6.join)((0, import_node_os2.tmpdir)(), "opensteer-cookie-db-"));
+  const snapshotPath = (0, import_node_path6.join)(snapshotDir, "Cookies");
+  await (0, import_promises7.copyFile)(dbPath, snapshotPath);
   for (const suffix of ["-wal", "-shm", "-journal"]) {
     const source = `${dbPath}${suffix}`;
-    if (!(0, import_node_fs2.existsSync)(source)) {
+    if (!(0, import_node_fs4.existsSync)(source)) {
       continue;
     }
-    await (0, import_promises4.copyFile)(source, `${snapshotPath}${suffix}`);
+    await (0, import_promises7.copyFile)(source, `${snapshotPath}${suffix}`);
   }
   return {
     snapshotPath,
     cleanup: async () => {
-      await (0, import_promises4.rm)(snapshotDir, { recursive: true, force: true });
+      await (0, import_promises7.rm)(snapshotDir, { recursive: true, force: true });
     }
   };
 }
 async function querySqliteJson(dbPath, query) {
-  const result = await execFileAsync("sqlite3", ["-json", dbPath, query], {
+  const result = await execFileAsync3("sqlite3", ["-json", dbPath, query], {
     encoding: "utf8",
     maxBuffer: 64 * 1024 * 1024
   });
@@ -15190,7 +16650,7 @@ function stripDomainHashPrefix(buffer, hostKey) {
   if (buffer.length < 32) {
     return buffer;
   }
-  const domainHash = (0, import_node_crypto2.createHash)("sha256").update(hostKey, "utf8").digest();
+  const domainHash = (0, import_node_crypto5.createHash)("sha256").update(hostKey, "utf8").digest();
   if (buffer.subarray(0, 32).equals(domainHash)) {
     return buffer.subarray(32);
   }
@@ -15199,7 +16659,7 @@ function stripDomainHashPrefix(buffer, hostKey) {
 function decryptChromiumAes128CbcValue(encryptedValue, key, hostKey) {
   const ciphertext = encryptedValue.length > 3 && encryptedValue[0] === 118 && encryptedValue[1] === 49 && (encryptedValue[2] === 48 || encryptedValue[2] === 49) ? encryptedValue.subarray(3) : encryptedValue;
   const iv = Buffer.alloc(AES_BLOCK_BYTES, " ");
-  const decipher = (0, import_node_crypto2.createDecipheriv)("aes-128-cbc", key, iv);
+  const decipher = (0, import_node_crypto5.createDecipheriv)("aes-128-cbc", key, iv);
   const plaintext = Buffer.concat([
     decipher.update(ciphertext),
     decipher.final()
@@ -15212,7 +16672,7 @@ function decryptChromiumAes256GcmValue(encryptedValue, key) {
   const nonce = encryptedValue.subarray(3, 15);
   const ciphertext = encryptedValue.subarray(15, encryptedValue.length - 16);
   const authTag = encryptedValue.subarray(encryptedValue.length - 16);
-  const decipher = (0, import_node_crypto2.createDecipheriv)("aes-256-gcm", key, nonce);
+  const decipher = (0, import_node_crypto5.createDecipheriv)("aes-256-gcm", key, nonce);
   decipher.setAuthTag(authTag);
   return Buffer.concat([
     decipher.update(ciphertext),
@@ -15229,7 +16689,7 @@ async function dpapiUnprotect(buffer) {
     ")",
     "[Convert]::ToBase64String($plainBytes)"
   ].join("\n");
-  const { stdout } = await execFileAsync(
+  const { stdout } = await execFileAsync3(
     "powershell.exe",
     ["-NoProfile", "-NonInteractive", "-Command", script],
     {
@@ -15249,7 +16709,7 @@ async function buildChromiumDecryptor(location) {
         `Unable to read ${brand.macService} from macOS Keychain.`
       );
     }
-    const key = (0, import_node_crypto2.pbkdf2Sync)(password, KEY_SALT, MAC_KEY_ITERATIONS, KEY_LENGTH, "sha1");
+    const key = (0, import_node_crypto5.pbkdf2Sync)(password, KEY_SALT, MAC_KEY_ITERATIONS, KEY_LENGTH, "sha1");
     return async (row) => decryptChromiumAes128CbcValue(
       Buffer.from(row.encrypted_value || "", "hex"),
       key,
@@ -15260,7 +16720,7 @@ async function buildChromiumDecryptor(location) {
     const brand = detectChromiumBrand(location);
     const keychainStore = createKeychainStore();
     const password = keychainStore?.get(brand.macService, brand.macAccount) ?? brand.linuxApplications.map((application) => keychainStore?.get(application, application) ?? null).find(Boolean) ?? null;
-    const key = (0, import_node_crypto2.pbkdf2Sync)(
+    const key = (0, import_node_crypto5.pbkdf2Sync)(
       password || "peanuts",
       KEY_SALT,
       LINUX_KEY_ITERATIONS,
@@ -15280,7 +16740,7 @@ async function buildChromiumDecryptor(location) {
       );
     }
     const localState = JSON.parse(
-      await (0, import_promises4.readFile)(location.localStatePath, "utf8")
+      await (0, import_promises7.readFile)(location.localStatePath, "utf8")
     );
     const encryptedKeyBase64 = localState.os_crypt?.encrypted_key;
     if (!encryptedKeyBase64) {
@@ -15374,22 +16834,22 @@ async function loadCookiesFromSqlite(location) {
   }
 }
 async function loadCookiesFromBrowserSnapshot(location, options) {
-  const snapshotRootDir = await (0, import_promises4.mkdtemp)((0, import_node_path2.join)((0, import_node_os2.tmpdir)(), "opensteer-profile-"));
-  const snapshotProfileDir = (0, import_node_path2.join)(
+  const snapshotRootDir = await (0, import_promises7.mkdtemp)((0, import_node_path6.join)((0, import_node_os2.tmpdir)(), "opensteer-profile-"));
+  const snapshotProfileDir = (0, import_node_path6.join)(
     snapshotRootDir,
-    (0, import_node_path2.basename)(location.profileDir)
+    (0, import_node_path6.basename)(location.profileDir)
   );
   let context = null;
   try {
-    await (0, import_promises4.cp)(location.profileDir, snapshotProfileDir, {
+    await (0, import_promises7.cp)(location.profileDir, snapshotProfileDir, {
       recursive: true
     });
     if (location.localStatePath) {
-      await (0, import_promises4.copyFile)(location.localStatePath, (0, import_node_path2.join)(snapshotRootDir, "Local State"));
+      await (0, import_promises7.copyFile)(location.localStatePath, (0, import_node_path6.join)(snapshotRootDir, "Local State"));
     }
     const brand = detectChromiumBrand(location);
-    const args = [`--profile-directory=${(0, import_node_path2.basename)(snapshotProfileDir)}`];
-    context = await import_playwright3.chromium.launchPersistentContext(snapshotRootDir, {
+    const args = [`--profile-directory=${(0, import_node_path6.basename)(snapshotProfileDir)}`];
+    context = await import_playwright4.chromium.launchPersistentContext(snapshotRootDir, {
       channel: brand.playwrightChannel,
       headless: options.headless ?? true,
       timeout: options.timeout ?? 12e4,
@@ -15398,7 +16858,7 @@ async function loadCookiesFromBrowserSnapshot(location, options) {
     return await context.cookies();
   } finally {
     await context?.close().catch(() => void 0);
-    await (0, import_promises4.rm)(snapshotRootDir, { recursive: true, force: true });
+    await (0, import_promises7.rm)(snapshotRootDir, { recursive: true, force: true });
   }
 }
 function isMissingSqliteBinary(error) {
@@ -15641,10 +17101,10 @@ function toResolvedCloudCredential(source, credential) {
 }
 
 // src/auth/machine-credential-store.ts
-var import_node_crypto3 = require("crypto");
-var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_crypto6 = require("crypto");
+var import_node_fs5 = __toESM(require("fs"), 1);
 var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 var METADATA_VERSION = 2;
 var ACTIVE_TARGET_VERSION = 2;
 var KEYCHAIN_SERVICE = "com.opensteer.cli.cloud";
@@ -15659,7 +17119,7 @@ var MachineCredentialStore = class {
     const appName = options.appName || "opensteer";
     const env = options.env ?? process.env;
     const configDir = resolveConfigDir(appName, env);
-    this.authDir = import_node_path3.default.join(configDir, "auth");
+    this.authDir = import_node_path7.default.join(configDir, "auth");
     this.warn = options.warn ?? (() => void 0);
   }
   readCloudCredential(target) {
@@ -15789,18 +17249,18 @@ function createMachineCredentialStore(options = {}) {
 }
 function resolveCredentialSlot(authDir, target) {
   const normalizedBaseUrl = normalizeCredentialUrl(target.baseUrl);
-  const storageKey = (0, import_node_crypto3.createHash)("sha256").update(normalizedBaseUrl).digest("hex").slice(0, 24);
+  const storageKey = (0, import_node_crypto6.createHash)("sha256").update(normalizedBaseUrl).digest("hex").slice(0, 24);
   return {
     keychainAccount: `${KEYCHAIN_ACCOUNT_PREFIX}${storageKey}`,
-    metadataPath: import_node_path3.default.join(authDir, `cli-login.${storageKey}.json`),
-    fallbackSecretPath: import_node_path3.default.join(
+    metadataPath: import_node_path7.default.join(authDir, `cli-login.${storageKey}.json`),
+    fallbackSecretPath: import_node_path7.default.join(
       authDir,
       `cli-login.${storageKey}.secret.json`
     )
   };
 }
 function resolveActiveTargetPath(authDir) {
-  return import_node_path3.default.join(authDir, ACTIVE_TARGET_FILE_NAME);
+  return import_node_path7.default.join(authDir, ACTIVE_TARGET_FILE_NAME);
 }
 function matchesCredentialTarget(value, target) {
   return normalizeCredentialUrl(value.baseUrl) === normalizeCredentialUrl(target.baseUrl);
@@ -15819,36 +17279,36 @@ function normalizeCloudCredentialTarget(target) {
 }
 function resolveConfigDir(appName, env) {
   if (process.platform === "win32") {
-    const appData = env.APPDATA?.trim() || import_node_path3.default.join(import_node_os3.default.homedir(), "AppData", "Roaming");
-    return import_node_path3.default.join(appData, appName);
+    const appData = env.APPDATA?.trim() || import_node_path7.default.join(import_node_os3.default.homedir(), "AppData", "Roaming");
+    return import_node_path7.default.join(appData, appName);
   }
   if (process.platform === "darwin") {
-    return import_node_path3.default.join(
+    return import_node_path7.default.join(
       import_node_os3.default.homedir(),
       "Library",
       "Application Support",
       appName
     );
   }
-  const xdgConfigHome = env.XDG_CONFIG_HOME?.trim() || import_node_path3.default.join(import_node_os3.default.homedir(), ".config");
-  return import_node_path3.default.join(xdgConfigHome, appName);
+  const xdgConfigHome = env.XDG_CONFIG_HOME?.trim() || import_node_path7.default.join(import_node_os3.default.homedir(), ".config");
+  return import_node_path7.default.join(xdgConfigHome, appName);
 }
 function ensureDirectory(directoryPath) {
-  import_node_fs3.default.mkdirSync(directoryPath, { recursive: true, mode: 448 });
+  import_node_fs5.default.mkdirSync(directoryPath, { recursive: true, mode: 448 });
 }
 function removeFileIfExists(filePath) {
   try {
-    import_node_fs3.default.rmSync(filePath, { force: true });
+    import_node_fs5.default.rmSync(filePath, { force: true });
   } catch {
     return;
   }
 }
 function readMetadata(filePath) {
-  if (!import_node_fs3.default.existsSync(filePath)) {
+  if (!import_node_fs5.default.existsSync(filePath)) {
     return null;
   }
   try {
-    const raw = import_node_fs3.default.readFileSync(filePath, "utf8");
+    const raw = import_node_fs5.default.readFileSync(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== METADATA_VERSION) return null;
     if (parsed.secretBackend !== "keychain" && parsed.secretBackend !== "file") {
@@ -15875,11 +17335,11 @@ function readMetadata(filePath) {
   }
 }
 function readActiveCloudTargetMetadata(filePath) {
-  if (!import_node_fs3.default.existsSync(filePath)) {
+  if (!import_node_fs5.default.existsSync(filePath)) {
     return null;
   }
   try {
-    const raw = import_node_fs3.default.readFileSync(filePath, "utf8");
+    const raw = import_node_fs5.default.readFileSync(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== ACTIVE_TARGET_VERSION) {
       return null;
@@ -15909,22 +17369,22 @@ function parseSecretPayload(raw) {
   }
 }
 function readSecretFile(filePath) {
-  if (!import_node_fs3.default.existsSync(filePath)) {
+  if (!import_node_fs5.default.existsSync(filePath)) {
     return null;
   }
   try {
-    return parseSecretPayload(import_node_fs3.default.readFileSync(filePath, "utf8"));
+    return parseSecretPayload(import_node_fs5.default.readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
 }
 function writeJsonFile(filePath, value, options = {}) {
-  import_node_fs3.default.writeFileSync(filePath, JSON.stringify(value, null, 2), {
+  import_node_fs5.default.writeFileSync(filePath, JSON.stringify(value, null, 2), {
     encoding: "utf8",
     mode: options.mode ?? 384
   });
   if (typeof options.mode === "number") {
-    import_node_fs3.default.chmodSync(filePath, options.mode);
+    import_node_fs5.default.chmodSync(filePath, options.mode);
   }
 }
 
@@ -16258,7 +17718,7 @@ async function ensureCloudCredentialsForCommand(options) {
   const writeProgress = options.writeProgress ?? options.writeStdout ?? ((message) => process.stdout.write(message));
   const writeStderr = options.writeStderr ?? ((message) => process.stderr.write(message));
   const fetchFn = options.fetchFn ?? fetch;
-  const sleep7 = options.sleep ?? (async (ms) => {
+  const sleep11 = options.sleep ?? (async (ms) => {
     await new Promise((resolve) => setTimeout(resolve, ms));
   });
   const now = options.now ?? Date.now;
@@ -16302,7 +17762,7 @@ async function ensureCloudCredentialsForCommand(options) {
         fetchFn,
         writeProgress,
         openExternalUrl,
-        sleep: sleep7,
+        sleep: sleep11,
         now,
         openBrowser: true
       });
@@ -16714,7 +18174,7 @@ function createDefaultDeps() {
     loadLocalProfileCookies: (profileDir, options) => loadCookiesFromLocalProfileDir(profileDir, options),
     isInteractive: () => Boolean(process.stdin.isTTY && process.stdout.isTTY),
     confirm: async (message) => {
-      const rl = (0, import_promises5.createInterface)({
+      const rl = (0, import_promises8.createInterface)({
         input: process.stdin,
         output: process.stderr
       });
@@ -16878,7 +18338,7 @@ async function resolveTargetProfileId(args, deps, client) {
       "Sync target is required in non-interactive mode. Use --to-profile-id <id> or --name <name>."
     );
   }
-  const defaultName = `Synced ${import_node_path4.default.basename(args.fromProfileDir)}`;
+  const defaultName = `Synced ${import_node_path8.default.basename(args.fromProfileDir)}`;
   const shouldCreate = await deps.confirm(
     `No destination profile provided. Create a new cloud profile named "${defaultName}"?`
   );