opensteer 0.6.11 → 0.6.12

package/dist/{chunk-JZF2WC7U.js → chunk-RC4IPQDZ.js}

@@ -25,24 +25,34 @@ import {
 } from "./chunk-3H5RRIMZ.js";
 
 // src/browser/persistent-profile.ts
-import { createHash } from "crypto";
-import { existsSync } from "fs";
+import { createHash, randomUUID } from "crypto";
+import { execFile } from "child_process";
+import { createReadStream, existsSync } from "fs";
 import {
   cp,
   copyFile,
   mkdir,
   mkdtemp,
   readdir,
+  readFile,
   rename,
   rm,
   stat,
   writeFile
 } from "fs/promises";
-import { homedir } from "os";
-import { basename, dirname, join } from "path";
+import { homedir, tmpdir } from "os";
+import { basename, dirname, join, relative, sep } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
 var OPENSTEER_META_FILE = ".opensteer-meta.json";
+var OPENSTEER_RUNTIME_META_FILE = ".opensteer-runtime.json";
+var LOCK_OWNER_FILE = "owner.json";
+var LOCK_RECLAIMER_DIR = "reclaimer";
 var PROCESS_STARTED_AT_MS = Math.floor(Date.now() - process.uptime() * 1e3);
 var PROCESS_START_TIME_TOLERANCE_MS = 1e3;
+var PROFILE_LOCK_RETRY_DELAY_MS = 50;
+var PS_COMMAND_ENV = { ...process.env, LC_ALL: "C" };
+var LINUX_STAT_START_TIME_FIELD_INDEX = 19;
 var CHROME_SINGLETON_ENTRIES = /* @__PURE__ */ new Set([
   "SingletonCookie",
   "SingletonLock",
@@ -52,7 +62,8 @@ var CHROME_SINGLETON_ENTRIES = /* @__PURE__ */ new Set([
 ]);
 var COPY_SKIP_ENTRIES = /* @__PURE__ */ new Set([
   ...CHROME_SINGLETON_ENTRIES,
-  OPENSTEER_META_FILE
+  OPENSTEER_META_FILE,
+  OPENSTEER_RUNTIME_META_FILE
 ]);
 var SKIPPED_ROOT_DIRECTORIES = /* @__PURE__ */ new Set([
   "Crash Reports",
@@ -71,6 +82,11 @@ var SKIPPED_ROOT_DIRECTORIES = /* @__PURE__ */ new Set([
   "WidevineCdm",
   "pnacl"
 ]);
+var CURRENT_PROCESS_LOCK_OWNER = {
+  pid: process.pid,
+  processStartedAtMs: PROCESS_STARTED_AT_MS
+};
+var linuxClockTicksPerSecondPromise = null;
 async function getOrCreatePersistentProfile(sourceUserDataDir, profileDirectory, profilesRootDir = defaultPersistentProfilesRootDir()) {
   const resolvedSourceUserDataDir = expandHome(sourceUserDataDir);
   const targetUserDataDir = join(
@@ -83,27 +99,29 @@ async function getOrCreatePersistentProfile(sourceUserDataDir, profileDirectory,
     profileDirectory
   );
   await mkdir(dirname(targetUserDataDir), { recursive: true });
-  await cleanOrphanedTempDirs(
-    dirname(targetUserDataDir),
-    basename(targetUserDataDir)
-  );
-  if (!existsSync(sourceProfileDir)) {
-    throw new Error(
-      `Chrome profile "${profileDirectory}" was not found in "${resolvedSourceUserDataDir}".`
+  return await withPersistentProfileLock(targetUserDataDir, async () => {
+    await cleanOrphanedOwnedDirs(
+      dirname(targetUserDataDir),
+      buildPersistentProfileTempDirNamePrefix(targetUserDataDir)
     );
-  }
-  const created = await createPersistentProfileClone(
-    resolvedSourceUserDataDir,
-    sourceProfileDir,
-    targetUserDataDir,
-    profileDirectory,
-    metadata
-  );
-  await ensurePersistentProfileMetadata(targetUserDataDir, metadata);
-  return {
-    created,
-    userDataDir: targetUserDataDir
-  };
+    if (!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(
@@ -115,6 +133,80 @@ async function clearPersistentProfileSingletons(userDataDir) {
     )
   );
 }
+async function createIsolatedRuntimeProfile(sourceUserDataDir, runtimesRootDir = defaultRuntimeProfilesRootDir()) {
+  const resolvedSourceUserDataDir = expandHome(sourceUserDataDir);
+  const runtimeRootDir = expandHome(runtimesRootDir);
+  await mkdir(runtimeRootDir, { recursive: true });
+  return await withPersistentProfileLock(
+    resolvedSourceUserDataDir,
+    async () => {
+      const sourceMetadata = await readPersistentProfileMetadata(
+        resolvedSourceUserDataDir
+      );
+      await cleanOrphanedOwnedDirs(
+        runtimeRootDir,
+        buildRuntimeProfileDirNamePrefix(resolvedSourceUserDataDir)
+      );
+      const runtimeUserDataDir = await mkdtemp(
+        buildRuntimeProfileDirPrefix(
+          runtimeRootDir,
+          resolvedSourceUserDataDir
+        )
+      );
+      try {
+        await copyUserDataDirSnapshot(
+          resolvedSourceUserDataDir,
+          runtimeUserDataDir
+        );
+        await writeRuntimeProfileMetadata(
+          runtimeUserDataDir,
+          await buildRuntimeProfileMetadata(
+            runtimeUserDataDir,
+            sourceMetadata?.profileDirectory ?? null
+          )
+        );
+        return {
+          persistentUserDataDir: resolvedSourceUserDataDir,
+          userDataDir: runtimeUserDataDir
+        };
+      } catch (error) {
+        await rm(runtimeUserDataDir, {
+          recursive: true,
+          force: true
+        }).catch(() => void 0);
+        throw error;
+      }
+    }
+  );
+}
+async function persistIsolatedRuntimeProfile(runtimeUserDataDir, persistentUserDataDir) {
+  const resolvedRuntimeUserDataDir = expandHome(runtimeUserDataDir);
+  const resolvedPersistentUserDataDir = expandHome(persistentUserDataDir);
+  await withPersistentProfileLock(resolvedPersistentUserDataDir, async () => {
+    await mkdir(dirname(resolvedPersistentUserDataDir), { recursive: true });
+    await cleanOrphanedOwnedDirs(
+      dirname(resolvedPersistentUserDataDir),
+      buildPersistentProfileTempDirNamePrefix(resolvedPersistentUserDataDir)
+    );
+    const metadata = await requirePersistentProfileMetadata(
+      resolvedPersistentUserDataDir
+    );
+    const runtimeMetadata = await requireRuntimeProfileMetadata(
+      resolvedRuntimeUserDataDir,
+      metadata.profileDirectory
+    );
+    await mergePersistentProfileSnapshot(
+      resolvedRuntimeUserDataDir,
+      resolvedPersistentUserDataDir,
+      metadata,
+      runtimeMetadata
+    );
+  });
+  await rm(resolvedRuntimeUserDataDir, {
+    recursive: true,
+    force: true
+  });
+}
 function buildPersistentProfileKey(sourceUserDataDir, profileDirectory) {
   const hash = createHash("sha256").update(`${sourceUserDataDir}\0${profileDirectory}`).digest("hex").slice(0, 16);
   const sourceLabel = sanitizePathSegment(basename(sourceUserDataDir) || "user-data");
@@ -124,6 +216,9 @@ function buildPersistentProfileKey(sourceUserDataDir, profileDirectory) {
 function defaultPersistentProfilesRootDir() {
   return join(homedir(), ".opensteer", "real-browser-profiles");
 }
+function defaultRuntimeProfilesRootDir() {
+  return join(tmpdir(), "opensteer-real-browser-runtimes");
+}
 function sanitizePathSegment(value) {
   const sanitized = value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/-+/g, "-");
   return sanitized.replace(/^-|-$/g, "") || "profile";
@@ -131,6 +226,23 @@ function sanitizePathSegment(value) {
 function isProfileDirectory(userDataDir, entry) {
   return existsSync(join(userDataDir, entry, "Preferences"));
 }
+async function copyUserDataDirSnapshot(sourceUserDataDir, targetUserDataDir) {
+  await cp(sourceUserDataDir, targetUserDataDir, {
+    recursive: true,
+    filter: (candidatePath) => shouldCopyRuntimeSnapshotEntry(sourceUserDataDir, candidatePath)
+  });
+}
+function shouldCopyRuntimeSnapshotEntry(userDataDir, candidatePath) {
+  const candidateRelativePath = relative(userDataDir, candidatePath);
+  if (!candidateRelativePath) {
+    return true;
+  }
+  const segments = candidateRelativePath.split(sep).filter(Boolean);
+  if (segments.length !== 1) {
+    return true;
+  }
+  return !COPY_SKIP_ENTRIES.has(segments[0]);
+}
 async function copyRootLevelEntries(sourceUserDataDir, targetUserDataDir, targetProfileDirectory) {
   let entries;
   try {
@@ -187,19 +299,17 @@ async function createPersistentProfileClone(sourceUserDataDir, sourceProfileDir,
   );
   let published = false;
   try {
-    await cp(sourceProfileDir, join(tempUserDataDir, profileDirectory), {
-      recursive: true
-    });
-    await copyRootLevelEntries(
+    await materializePersistentProfileSnapshot(
       sourceUserDataDir,
+      sourceProfileDir,
       tempUserDataDir,
-      profileDirectory
+      profileDirectory,
+      metadata
     );
-    await writePersistentProfileMetadata(tempUserDataDir, metadata);
     try {
       await rename(tempUserDataDir, targetUserDataDir);
     } catch (error) {
-      if (wasProfilePublishedByAnotherProcess(error, targetUserDataDir)) {
+      if (wasDirPublishedByAnotherProcess(error, targetUserDataDir)) {
         return false;
       }
       throw error;
@@ -215,60 +325,621 @@ async function createPersistentProfileClone(sourceUserDataDir, sourceProfileDir,
     }
   }
 }
+async function materializePersistentProfileSnapshot(sourceUserDataDir, sourceProfileDir, targetUserDataDir, profileDirectory, metadata) {
+  if (!existsSync(sourceProfileDir)) {
+    throw new Error(
+      `Chrome profile "${profileDirectory}" was not found in "${sourceUserDataDir}".`
+    );
+  }
+  await cp(sourceProfileDir, join(targetUserDataDir, profileDirectory), {
+    recursive: true
+  });
+  await copyRootLevelEntries(sourceUserDataDir, targetUserDataDir, profileDirectory);
+  await writePersistentProfileMetadata(targetUserDataDir, metadata);
+}
+async function mergePersistentProfileSnapshot(runtimeUserDataDir, persistentUserDataDir, metadata, runtimeMetadata) {
+  const tempUserDataDir = await mkdtemp(
+    buildPersistentProfileTempDirPrefix(persistentUserDataDir)
+  );
+  let published = false;
+  try {
+    const baseEntries = deserializeSnapshotManifestEntries(
+      runtimeMetadata.baseEntries
+    );
+    const currentEntries = await collectPersistentSnapshotEntries(
+      persistentUserDataDir,
+      metadata.profileDirectory
+    );
+    const runtimeEntries = await collectPersistentSnapshotEntries(
+      runtimeUserDataDir,
+      metadata.profileDirectory
+    );
+    const mergedEntries = resolveMergedSnapshotEntries(
+      baseEntries,
+      currentEntries,
+      runtimeEntries
+    );
+    await materializeMergedPersistentProfileSnapshot(
+      tempUserDataDir,
+      currentEntries,
+      runtimeEntries,
+      mergedEntries
+    );
+    await writePersistentProfileMetadata(tempUserDataDir, metadata);
+    await replaceProfileDirectory(persistentUserDataDir, tempUserDataDir);
+    published = true;
+  } finally {
+    if (!published) {
+      await rm(tempUserDataDir, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+  }
+}
+async function buildRuntimeProfileMetadata(runtimeUserDataDir, profileDirectory) {
+  if (!profileDirectory) {
+    return {
+      baseEntries: {},
+      profileDirectory: null
+    };
+  }
+  const baseEntries = await collectPersistentSnapshotEntries(
+    runtimeUserDataDir,
+    profileDirectory
+  );
+  return {
+    baseEntries: serializeSnapshotManifestEntries(baseEntries),
+    profileDirectory
+  };
+}
+async function writeRuntimeProfileMetadata(userDataDir, metadata) {
+  await writeFile(
+    join(userDataDir, OPENSTEER_RUNTIME_META_FILE),
+    JSON.stringify(metadata, null, 2)
+  );
+}
+async function readRuntimeProfileMetadata(userDataDir) {
+  try {
+    const raw = await readFile(
+      join(userDataDir, OPENSTEER_RUNTIME_META_FILE),
+      "utf8"
+    );
+    const parsed = JSON.parse(raw);
+    const profileDirectory = parsed.profileDirectory === null ? null : typeof parsed.profileDirectory === "string" ? parsed.profileDirectory : void 0;
+    if (profileDirectory === void 0 || typeof parsed.baseEntries !== "object" || parsed.baseEntries === null || Array.isArray(parsed.baseEntries)) {
+      return null;
+    }
+    const baseEntries = deserializeSnapshotManifestEntries(
+      parsed.baseEntries
+    );
+    return {
+      baseEntries: Object.fromEntries(baseEntries),
+      profileDirectory
+    };
+  } catch {
+    return null;
+  }
+}
+async function requireRuntimeProfileMetadata(userDataDir, expectedProfileDirectory) {
+  const metadata = await readRuntimeProfileMetadata(userDataDir);
+  if (!metadata) {
+    throw new Error(
+      `Runtime profile metadata was not found for "${userDataDir}".`
+    );
+  }
+  if (metadata.profileDirectory !== expectedProfileDirectory) {
+    throw new Error(
+      `Runtime profile "${userDataDir}" was created for profile "${metadata.profileDirectory ?? "unknown"}", expected "${expectedProfileDirectory}".`
+    );
+  }
+  return metadata;
+}
+async function collectPersistentSnapshotEntries(userDataDir, profileDirectory) {
+  let rootEntries;
+  try {
+    rootEntries = await readdir(userDataDir, {
+      encoding: "utf8",
+      withFileTypes: true
+    });
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+  rootEntries.sort((left, right) => left.name.localeCompare(right.name));
+  const collected = /* @__PURE__ */ new Map();
+  for (const entry of rootEntries) {
+    if (!shouldIncludePersistentRootEntry(
+      userDataDir,
+      profileDirectory,
+      entry.name
+    )) {
+      continue;
+    }
+    await collectSnapshotEntry(
+      join(userDataDir, entry.name),
+      entry.name,
+      collected
+    );
+  }
+  return collected;
+}
+function shouldIncludePersistentRootEntry(userDataDir, profileDirectory, entry) {
+  if (entry === profileDirectory) {
+    return true;
+  }
+  if (COPY_SKIP_ENTRIES.has(entry)) {
+    return false;
+  }
+  if (SKIPPED_ROOT_DIRECTORIES.has(entry)) {
+    return false;
+  }
+  return !isProfileDirectory(userDataDir, entry);
+}
+async function collectSnapshotEntry(sourcePath, relativePath, collected) {
+  let entryStat;
+  try {
+    entryStat = await stat(sourcePath);
+  } catch {
+    return;
+  }
+  if (entryStat.isDirectory()) {
+    collected.set(relativePath, {
+      kind: "directory",
+      hash: null,
+      sourcePath
+    });
+    let children;
+    try {
+      children = await readdir(sourcePath, {
+        encoding: "utf8",
+        withFileTypes: true
+      });
+    } catch {
+      return;
+    }
+    children.sort((left, right) => left.name.localeCompare(right.name));
+    for (const child of children) {
+      await collectSnapshotEntry(
+        join(sourcePath, child.name),
+        join(relativePath, child.name),
+        collected
+      );
+    }
+    return;
+  }
+  if (entryStat.isFile()) {
+    collected.set(relativePath, {
+      kind: "file",
+      hash: await hashFile(sourcePath),
+      sourcePath
+    });
+  }
+}
+function serializeSnapshotManifestEntries(entries) {
+  return Object.fromEntries(
+    [...entries.entries()].sort(([leftPath], [rightPath]) => leftPath.localeCompare(rightPath)).map(([relativePath, entry]) => [
+      relativePath,
+      {
+        kind: entry.kind,
+        hash: entry.hash
+      }
+    ])
+  );
+}
+function deserializeSnapshotManifestEntries(entries) {
+  const manifestEntries = /* @__PURE__ */ new Map();
+  for (const [relativePath, entry] of Object.entries(entries)) {
+    if (!entry || entry.kind !== "directory" && entry.kind !== "file" || !(entry.hash === null || typeof entry.hash === "string")) {
+      throw new Error(
+        `Runtime profile metadata for "${relativePath}" is invalid.`
+      );
+    }
+    manifestEntries.set(relativePath, {
+      kind: entry.kind,
+      hash: entry.hash
+    });
+  }
+  return manifestEntries;
+}
+function resolveMergedSnapshotEntries(baseEntries, currentEntries, runtimeEntries) {
+  const mergedEntries = /* @__PURE__ */ new Map();
+  const relativePaths = /* @__PURE__ */ new Set([
+    ...baseEntries.keys(),
+    ...currentEntries.keys(),
+    ...runtimeEntries.keys()
+  ]);
+  for (const relativePath of [...relativePaths].sort(compareSnapshotPaths)) {
+    mergedEntries.set(
+      relativePath,
+      resolveMergedSnapshotEntrySelection(
+        relativePath,
+        baseEntries.get(relativePath) ?? null,
+        currentEntries.get(relativePath) ?? null,
+        runtimeEntries.get(relativePath) ?? null
+      )
+    );
+  }
+  return mergedEntries;
+}
+function resolveMergedSnapshotEntrySelection(relativePath, baseEntry, currentEntry, runtimeEntry) {
+  if (snapshotEntriesEqual(runtimeEntry, baseEntry)) {
+    return currentEntry ? "current" : null;
+  }
+  if (snapshotEntriesEqual(currentEntry, baseEntry)) {
+    return runtimeEntry ? "runtime" : null;
+  }
+  if (!baseEntry) {
+    if (!currentEntry) {
+      return runtimeEntry ? "runtime" : null;
+    }
+    if (!runtimeEntry) {
+      return "current";
+    }
+    if (snapshotEntriesEqual(currentEntry, runtimeEntry)) {
+      return "current";
+    }
+    throw new Error(
+      `Concurrent runtime updates changed "${relativePath}" differently; refusing to overwrite the persistent profile.`
+    );
+  }
+  if (!currentEntry && !runtimeEntry) {
+    return null;
+  }
+  if (snapshotEntriesEqual(currentEntry, runtimeEntry)) {
+    return currentEntry ? "current" : null;
+  }
+  throw new Error(
+    `Concurrent runtime updates changed "${relativePath}" differently; refusing to overwrite the persistent profile.`
+  );
+}
+function snapshotEntriesEqual(left, right) {
+  if (!left || !right) {
+    return left === right;
+  }
+  return left.kind === right.kind && left.hash === right.hash;
+}
+async function materializeMergedPersistentProfileSnapshot(targetUserDataDir, currentEntries, runtimeEntries, mergedEntries) {
+  const selectedEntries = [...mergedEntries.entries()].filter(([, selection]) => selection !== null).sort(
+    ([leftPath], [rightPath]) => compareSnapshotPaths(leftPath, rightPath)
+  );
+  for (const [relativePath, selection] of selectedEntries) {
+    const entry = (selection === "current" ? currentEntries.get(relativePath) : runtimeEntries.get(relativePath)) ?? null;
+    if (!entry) {
+      continue;
+    }
+    const targetPath = join(targetUserDataDir, relativePath);
+    if (entry.kind === "directory") {
+      await mkdir(targetPath, { recursive: true });
+      continue;
+    }
+    await mkdir(dirname(targetPath), { recursive: true });
+    await copyFile(entry.sourcePath, targetPath);
+  }
+}
+function compareSnapshotPaths(left, right) {
+  const leftDepth = left.split(sep).length;
+  const rightDepth = right.split(sep).length;
+  if (leftDepth !== rightDepth) {
+    return leftDepth - rightDepth;
+  }
+  return left.localeCompare(right);
+}
+async function hashFile(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(filePath);
+    stream.on("data", (chunk) => {
+      hash.update(chunk);
+    });
+    stream.on("error", reject);
+    stream.on("end", () => {
+      resolve(hash.digest("hex"));
+    });
+  });
+}
 async function ensurePersistentProfileMetadata(userDataDir, metadata) {
   if (existsSync(join(userDataDir, OPENSTEER_META_FILE))) {
     return;
   }
   await writePersistentProfileMetadata(userDataDir, metadata);
 }
-function wasProfilePublishedByAnotherProcess(error, targetUserDataDir) {
+async function readPersistentProfileMetadata(userDataDir) {
+  try {
+    const raw = await readFile(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 requirePersistentProfileMetadata(userDataDir) {
+  const metadata = await readPersistentProfileMetadata(userDataDir);
+  if (!metadata) {
+    throw new Error(
+      `Persistent profile metadata was not found for "${userDataDir}".`
+    );
+  }
+  return metadata;
+}
+function wasDirPublishedByAnotherProcess(error, targetDirPath) {
   const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
-  return existsSync(targetUserDataDir) && (code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM");
+  return existsSync(targetDirPath) && (code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM");
+}
+async function replaceProfileDirectory(targetUserDataDir, replacementUserDataDir) {
+  if (!existsSync(targetUserDataDir)) {
+    await rename(replacementUserDataDir, targetUserDataDir);
+    return;
+  }
+  const backupUserDataDir = buildPersistentProfileBackupDirPath(targetUserDataDir);
+  let targetMovedToBackup = false;
+  let replacementPublished = false;
+  try {
+    await rename(targetUserDataDir, backupUserDataDir);
+    targetMovedToBackup = true;
+    await rename(replacementUserDataDir, targetUserDataDir);
+    replacementPublished = true;
+  } catch (error) {
+    if (targetMovedToBackup && !existsSync(targetUserDataDir)) {
+      await rename(backupUserDataDir, targetUserDataDir).catch(() => void 0);
+    }
+    throw error;
+  } finally {
+    if (replacementPublished && targetMovedToBackup && existsSync(backupUserDataDir)) {
+      await rm(backupUserDataDir, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+  }
+}
+async function withPersistentProfileLock(targetUserDataDir, action) {
+  const lockDirPath = buildPersistentProfileLockDirPath(targetUserDataDir);
+  await mkdir(dirname(lockDirPath), { recursive: true });
+  while (true) {
+    const tempLockDirPath = `${lockDirPath}-${process.pid}-${PROCESS_STARTED_AT_MS}-${randomUUID()}`;
+    try {
+      await mkdir(tempLockDirPath);
+      await writeLockOwner(tempLockDirPath, CURRENT_PROCESS_LOCK_OWNER);
+      try {
+        await rename(tempLockDirPath, lockDirPath);
+        break;
+      } catch (error) {
+        if (!wasDirPublishedByAnotherProcess(error, lockDirPath)) {
+          throw error;
+        }
+      }
+    } finally {
+      await 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;
+    }
+    await sleep(PROFILE_LOCK_RETRY_DELAY_MS);
+  }
+  try {
+    return await action();
+  } finally {
+    await rm(lockDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  }
+}
+async function writeLockOwner(lockDirPath, owner) {
+  await writeLockParticipant(join(lockDirPath, LOCK_OWNER_FILE), owner);
+}
+async function readLockOwner(lockDirPath) {
+  return await readLockParticipant(join(lockDirPath, LOCK_OWNER_FILE));
+}
+async function writeLockParticipant(filePath, owner, options) {
+  await writeFile(filePath, JSON.stringify(owner), options);
+}
+async function readLockParticipant(filePath) {
+  return (await readLockParticipantRecord(filePath)).owner;
+}
+async function readLockReclaimerRecord(lockDirPath) {
+  return await readLockParticipantRecord(
+    join(buildLockReclaimerDirPath(lockDirPath), LOCK_OWNER_FILE)
+  );
+}
+async function readLockParticipantRecord(filePath) {
+  try {
+    const raw = await readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const pid = Number(parsed.pid);
+    const processStartedAtMs = Number(parsed.processStartedAtMs);
+    if (!Number.isInteger(pid) || !Number.isInteger(processStartedAtMs)) {
+      return {
+        exists: true,
+        owner: null
+      };
+    }
+    return {
+      exists: true,
+      owner: {
+        pid,
+        processStartedAtMs
+      }
+    };
+  } catch (error) {
+    return {
+      exists: getErrorCode(error) !== "ENOENT",
+      owner: null
+    };
+  }
+}
+async function tryReclaimStaleLock(lockDirPath, expectedOwner) {
+  if (!await tryAcquireLockReclaimer(lockDirPath)) {
+    return false;
+  }
+  let reclaimed = false;
+  try {
+    const owner = await readLockOwner(lockDirPath);
+    if (!lockOwnersEqual(owner, expectedOwner)) {
+      return false;
+    }
+    if (owner && await getProcessLiveness(owner) !== "dead") {
+      return false;
+    }
+    await rm(lockDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+    reclaimed = !existsSync(lockDirPath);
+    return reclaimed;
+  } finally {
+    if (!reclaimed) {
+      await 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}-${PROCESS_STARTED_AT_MS}-${randomUUID()}`;
+    try {
+      await mkdir(tempReclaimerDirPath);
+      await writeLockOwner(tempReclaimerDirPath, CURRENT_PROCESS_LOCK_OWNER);
+      try {
+        await 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 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 rm(reclaimerDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  }
+}
+function lockOwnersEqual(left, right) {
+  if (!left || !right) {
+    return left === right;
+  }
+  return left.pid === right.pid && left.processStartedAtMs === right.processStartedAtMs;
+}
+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 hasMatchingProcessStartTime(expectedStartedAtMs, actualStartedAtMs) {
+  return Math.abs(expectedStartedAtMs - actualStartedAtMs) <= PROCESS_START_TIME_TOLERANCE_MS;
 }
 function buildPersistentProfileTempDirPrefix(targetUserDataDir) {
   return join(
     dirname(targetUserDataDir),
-    `${basename(targetUserDataDir)}-tmp-${process.pid}-${PROCESS_STARTED_AT_MS}-`
+    `${buildPersistentProfileTempDirNamePrefix(targetUserDataDir)}${process.pid}-${PROCESS_STARTED_AT_MS}-`
+  );
+}
+function buildPersistentProfileTempDirNamePrefix(targetUserDataDir) {
+  return `${basename(targetUserDataDir)}-tmp-`;
+}
+function buildPersistentProfileBackupDirPath(targetUserDataDir) {
+  return join(
+    dirname(targetUserDataDir),
+    `${buildPersistentProfileTempDirNamePrefix(targetUserDataDir)}${process.pid}-${PROCESS_STARTED_AT_MS}-backup-${Date.now()}`
+  );
+}
+function buildPersistentProfileLockDirPath(targetUserDataDir) {
+  return join(dirname(targetUserDataDir), `${basename(targetUserDataDir)}.lock`);
+}
+function buildLockReclaimerDirPath(lockDirPath) {
+  return join(lockDirPath, LOCK_RECLAIMER_DIR);
+}
+function buildRuntimeProfileKey(sourceUserDataDir) {
+  const hash = createHash("sha256").update(sourceUserDataDir).digest("hex").slice(0, 16);
+  return `${sanitizePathSegment(basename(sourceUserDataDir) || "profile")}-${hash}`;
+}
+function buildRuntimeProfileDirNamePrefix(sourceUserDataDir) {
+  return `${buildRuntimeProfileKey(sourceUserDataDir)}-runtime-`;
+}
+function buildRuntimeProfileDirPrefix(runtimesRootDir, sourceUserDataDir) {
+  return join(
+    runtimesRootDir,
+    `${buildRuntimeProfileDirNamePrefix(sourceUserDataDir)}${process.pid}-${PROCESS_STARTED_AT_MS}-`
   );
 }
-async function cleanOrphanedTempDirs(profilesDir, targetBaseName) {
+async function cleanOrphanedOwnedDirs(rootDir, ownedDirNamePrefix) {
   let entries;
   try {
-    entries = await readdir(profilesDir, {
+    entries = await readdir(rootDir, {
       encoding: "utf8",
       withFileTypes: true
     });
   } catch {
     return;
   }
-  const tempDirPrefix = `${targetBaseName}-tmp-`;
   await Promise.all(
     entries.map(async (entry) => {
-      if (!entry.isDirectory() || !entry.name.startsWith(tempDirPrefix)) {
+      if (!entry.isDirectory() || !entry.name.startsWith(ownedDirNamePrefix)) {
         return;
       }
-      if (isTempDirOwnedByLiveProcess(entry.name, tempDirPrefix)) {
+      if (await isOwnedDirByLiveProcess(entry.name, ownedDirNamePrefix)) {
         return;
       }
-      await rm(join(profilesDir, entry.name), {
+      await rm(join(rootDir, entry.name), {
         recursive: true,
         force: true
       }).catch(() => void 0);
     })
   );
 }
-function isTempDirOwnedByLiveProcess(tempDirName, tempDirPrefix) {
-  const owner = parseTempDirOwner(tempDirName, tempDirPrefix);
-  if (!owner) {
-    return false;
-  }
-  if (owner.pid === process.pid && Math.abs(owner.processStartedAtMs - PROCESS_STARTED_AT_MS) <= PROCESS_START_TIME_TOLERANCE_MS) {
-    return true;
-  }
-  return isProcessRunning(owner.pid);
+async function isOwnedDirByLiveProcess(ownedDirName, ownedDirPrefix) {
+  const owner = parseOwnedDirOwner(ownedDirName, ownedDirPrefix);
+  return owner ? await getProcessLiveness(owner) !== "dead" : false;
 }
-function parseTempDirOwner(tempDirName, tempDirPrefix) {
-  const remainder = tempDirName.slice(tempDirPrefix.length);
+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) {
@@ -296,6 +967,120 @@ function isProcessRunning(pid) {
     return code !== "ESRCH";
   }
 }
+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 {
+    statRaw = await readFile(`/proc/${pid}/stat`, "utf8");
+  } catch (error) {
+    return null;
+  }
+  const startTicks = parseLinuxProcessStartTicks(statRaw);
+  if (startTicks === null) {
+    return null;
+  }
+  const [bootTimeMs, clockTicksPerSecond] = await Promise.all([
+    readLinuxBootTimeMs(),
+    readLinuxClockTicksPerSecond()
+  ]);
+  if (bootTimeMs === null || clockTicksPerSecond === null) {
+    return null;
+  }
+  return Math.floor(
+    bootTimeMs + startTicks * 1e3 / clockTicksPerSecond
+  );
+}
+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 readLinuxBootTimeMs() {
+  try {
+    const statRaw = await 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;
+  }
+}
+async function readLinuxClockTicksPerSecond() {
+  linuxClockTicksPerSecondPromise ??= execFileAsync(
+    "getconf",
+    ["CLK_TCK"]
+  ).then(
+    ({ stdout }) => {
+      const value = Number.parseInt(stdout.trim(), 10);
+      return Number.isFinite(value) && value > 0 ? value : null;
+    },
+    () => null
+  );
+  return await linuxClockTicksPerSecondPromise;
+}
+async function readPsProcessStartedAtMs(pid) {
+  try {
+    const { stdout } = await execFileAsync(
+      "ps",
+      ["-p", String(pid), "-o", "lstart="],
+      { env: PS_COMMAND_ENV }
+    );
+    return parsePsStartedAtMs(stdout);
+  } catch (error) {
+    return null;
+  }
+}
+function parsePsStartedAtMs(stdout) {
+  const raw = stdout.trim();
+  if (!raw) {
+    return null;
+  }
+  const startedAtMs = Date.parse(raw);
+  return Number.isNaN(startedAtMs) ? null : startedAtMs;
+}
+async function readWindowsProcessStartedAtMs(pid) {
+  const script = [
+    "$process = Get-Process -Id " + String(pid) + " -ErrorAction SilentlyContinue",
+    "if ($null -eq $process) { exit 3 }",
+    '$process.StartTime.ToUniversalTime().ToString("o")'
+  ].join("; ");
+  try {
+    const { stdout } = await execFileAsync(
+      "powershell.exe",
+      ["-NoLogo", "-NoProfile", "-Command", script]
+    );
+    return parsePsStartedAtMs(stdout);
+  } catch (error) {
+    return null;
+  }
+}
+function getErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && (typeof error.code === "string" || typeof error.code === "number") ? error.code : void 0;
+}
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 // src/browser/pool.ts
 import { spawn } from "child_process";
@@ -724,14 +1509,13 @@ var BrowserPool = class {
   browser = null;
   cdpProxy = null;
   launchedProcess = null;
-  managedUserDataDir = null;
-  persistentProfile = false;
+  managedRuntimeProfile = null;
   defaults;
   constructor(defaults = {}) {
     this.defaults = defaults;
   }
   async launch(options = {}) {
-    if (this.browser || this.cdpProxy || this.launchedProcess || this.managedUserDataDir) {
+    if (this.browser || this.cdpProxy || this.launchedProcess || this.managedRuntimeProfile) {
       await this.close();
     }
     const mode = options.mode ?? this.defaults.mode ?? "chromium";
@@ -781,13 +1565,10 @@ var BrowserPool = class {
     const browser = this.browser;
     const cdpProxy = this.cdpProxy;
     const launchedProcess = this.launchedProcess;
-    const managedUserDataDir = this.managedUserDataDir;
-    const persistentProfile = this.persistentProfile;
+    const managedRuntimeProfile = this.managedRuntimeProfile;
     this.browser = null;
     this.cdpProxy = null;
     this.launchedProcess = null;
-    this.managedUserDataDir = null;
-    this.persistentProfile = false;
     try {
       if (browser) {
         await browser.close().catch(() => void 0);
@@ -795,11 +1576,14 @@ var BrowserPool = class {
     } finally {
       cdpProxy?.close();
       await killProcessTree(launchedProcess);
-      if (managedUserDataDir && !persistentProfile) {
-        await rm2(managedUserDataDir, {
-          recursive: true,
-          force: true
-        }).catch(() => void 0);
+      if (managedRuntimeProfile) {
+        await persistIsolatedRuntimeProfile(
+          managedRuntimeProfile.userDataDir,
+          managedRuntimeProfile.persistentUserDataDir
+        );
+        if (this.managedRuntimeProfile === managedRuntimeProfile) {
+          this.managedRuntimeProfile = null;
+        }
       }
     }
   }
@@ -849,7 +1633,9 @@ var BrowserPool = class {
       sourceUserDataDir,
       profileDirectory
     );
-    await clearPersistentProfileSingletons(persistentProfile.userDataDir);
+    const runtimeProfile = await createIsolatedRuntimeProfile(
+      persistentProfile.userDataDir
+    );
     const debugPort = await reserveDebugPort();
     const headless = resolveLaunchHeadless(
       "real",
@@ -857,7 +1643,7 @@ var BrowserPool = class {
       this.defaults.headless
     );
     const launchArgs = buildRealBrowserLaunchArgs({
-      userDataDir: persistentProfile.userDataDir,
+      userDataDir: runtimeProfile.userDataDir,
       profileDirectory,
       debugPort,
       headless
@@ -887,12 +1673,15 @@ var BrowserPool = class {
       }
       this.browser = browser;
       this.launchedProcess = processHandle;
-      this.managedUserDataDir = persistentProfile.userDataDir;
-      this.persistentProfile = true;
+      this.managedRuntimeProfile = runtimeProfile;
       return { browser, context, page, isExternal: false };
     } catch (error) {
       await browser?.close().catch(() => void 0);
       await killProcessTree(processHandle);
+      await rm2(runtimeProfile.userDataDir, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
       throw error;
     }
   }
@@ -1021,7 +1810,7 @@ async function resolveCdpWebSocketUrl(cdpUrl, timeoutMs) {
     } catch (error) {
       lastError = error instanceof Error ? error.message : "Unknown error";
     }
-    await sleep(100);
+    await sleep2(100);
   }
   throw new Error(
     `Failed to resolve a CDP websocket URL from ${versionUrl.toString()}: ${lastError}`
@@ -1088,7 +1877,7 @@ async function killProcessTree(processHandle) {
     }
   }
 }
-async function sleep(ms) {
+async function sleep2(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
 
@@ -1470,7 +2259,7 @@ var StealthCdpRuntime = class _StealthCdpRuntime {
           TRANSIENT_CONTEXT_RETRY_DELAY_MS,
           Math.max(0, deadline - Date.now())
         );
-        await sleep2(retryDelay);
+        await sleep3(retryDelay);
       }
     }
   }
@@ -1503,7 +2292,7 @@ var StealthCdpRuntime = class _StealthCdpRuntime {
       () => ({ kind: "resolved" }),
       (error) => ({ kind: "rejected", error })
     );
-    const timeoutPromise = sleep2(
+    const timeoutPromise = sleep3(
       timeout + FRAME_EVALUATE_GRACE_MS
     ).then(() => ({ kind: "timeout" }));
     const result = await Promise.race([
@@ -1645,7 +2434,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 sleep3(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -5897,7 +6686,7 @@ async function closeTab(context, activePage, index) {
 }
 
 // src/actions/cookies.ts
-import { readFile, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 async function getCookies(context, url) {
   return context.cookies(url ? [url] : void 0);
 }
@@ -5912,7 +6701,7 @@ async function exportCookies(context, filePath, url) {
   await writeFile2(filePath, JSON.stringify(cookies, null, 2), "utf-8");
 }
 async function importCookies(context, filePath) {
-  const raw = await readFile(filePath, "utf-8");
+  const raw = await readFile2(filePath, "utf-8");
   const cookies = JSON.parse(raw);
   await context.addCookies(cookies);
 }
@@ -7740,7 +8529,7 @@ async function executeAgentAction(page, action) {
     }
     case "wait": {
       const ms = numberOr(action.timeMs, action.time_ms, 1e3);
-      await sleep3(ms);
+      await sleep4(ms);
       return;
     }
     case "goto": {
@@ -7905,7 +8694,7 @@ async function pressKeyCombo(page, combo) {
     }
   }
 }
-function sleep3(ms) {
+function sleep4(ms) {
   return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 }
 
@@ -7936,7 +8725,7 @@ var OpensteerCuaAgentHandler = class {
       if (isMutatingAgentAction(action)) {
         this.onMutatingAction?.(action);
       }
-      await sleep4(this.config.waitBetweenActionsMs);
+      await sleep5(this.config.waitBetweenActionsMs);
     });
     try {
       const result = await this.client.execute({
@@ -7998,7 +8787,7 @@ var OpensteerCuaAgentHandler = class {
     await this.cursorController.preview({ x, y }, "agent");
   }
 };
-function sleep4(ms) {
+function sleep5(ms) {
   return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 }
 
@@ -8434,7 +9223,7 @@ var CursorController = class {
       for (const step of motion.points) {
         await this.renderer.move(step, this.style);
         if (motion.stepDelayMs > 0) {
-          await sleep5(motion.stepDelayMs);
+          await sleep6(motion.stepDelayMs);
         }
       }
       if (shouldPulse(intent)) {
@@ -8592,12 +9381,12 @@ function clamp2(value, min, max) {
 function shouldPulse(intent) {
   return intent === "click" || intent === "dblclick" || intent === "rightclick" || intent === "agent";
 }
-function sleep5(ms) {
+function sleep6(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 // src/opensteer.ts
-import { createHash as createHash2, randomUUID } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
 
 // src/action-wait.ts
 var ROBUST_PROFILE = {
@@ -8792,7 +9581,7 @@ var AdaptiveNetworkTracker = class {
         this.idleSince = 0;
       }
       const remaining = Math.max(1, options.deadline - now);
-      await sleep6(Math.min(NETWORK_POLL_MS, remaining));
+      await sleep7(Math.min(NETWORK_POLL_MS, remaining));
     }
   }
   handleRequestStarted = (request) => {
@@ -8837,7 +9626,7 @@ var AdaptiveNetworkTracker = class {
     return false;
   }
 };
-async function sleep6(ms) {
+async function sleep7(ms) {
   await new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -10617,15 +11406,18 @@ 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);
+    try {
+      if (this.ownsBrowser) {
+        await this.pool.close();
+      }
+    } finally {
+      this.browser = null;
+      this.pageRef = null;
+      this.contextRef = null;
+      this.ownsBrowser = false;
+      if (this.cursorController) {
+        await this.cursorController.dispose().catch(() => void 0);
+      }
     }
   }
   async syncLocalSelectorCacheToCloud() {
@@ -12949,12 +13741,14 @@ function normalizeCloudBrowserProfilePreference(value, source) {
 }
 function buildLocalRunId(namespace) {
   const normalized = namespace.trim() || "default";
-  return `${normalized}-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+  return `${normalized}-${Date.now().toString(36)}-${randomUUID2().slice(0, 8)}`;
 }
 
 export {
   getOrCreatePersistentProfile,
   clearPersistentProfileSingletons,
+  createIsolatedRuntimeProfile,
+  persistIsolatedRuntimeProfile,
   BrowserPool,
   waitForVisualStability,
   createEmptyRegistry,