opensteer 0.6.5 → 0.6.7

package/dist/cli/server.cjs

@@ -425,11 +425,8 @@ var import_crypto = require("crypto");
 
 // src/browser/pool.ts
 var import_node_child_process = require("child_process");
-var import_node_fs = require("fs");
-var import_promises = require("fs/promises");
+var import_promises2 = require("fs/promises");
 var import_node_net = require("net");
-var import_node_os = require("os");
-var import_node_path = require("path");
 var import_playwright = require("playwright");
 
 // src/browser/cdp-proxy.ts
@@ -437,6 +434,8 @@ var import_ws = __toESM(require("ws"), 1);
 var CDP_DISCOVERY_TIMEOUT_MS = 3e3;
 var LOCAL_PROXY_HOST = "127.0.0.1";
 var INTERNAL_COMMAND_ID_START = 1e9;
+var CREATE_BLANK_TARGET_COMMAND_ID = 1;
+var CREATE_BLANK_TARGET_TIMEOUT_MS = 5e3;
 async function discoverTargets(cdpUrl) {
   const baseUrl = resolveHttpDiscoveryBase(cdpUrl);
   const [targetsPayload, versionPayload] = await Promise.all([
@@ -448,6 +447,81 @@ async function discoverTargets(cdpUrl) {
     targets: readPageTargets(targetsPayload)
   };
 }
+function createBlankTarget(browserWsUrl) {
+  return new Promise((resolve, reject) => {
+    const ws = new import_ws.default(browserWsUrl);
+    let settled = false;
+    function settle(handler) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      ws.close();
+      handler();
+    }
+    const timeout = setTimeout(() => {
+      settle(
+        () => reject(new Error("Timed out creating a blank tab via CDP."))
+      );
+    }, CREATE_BLANK_TARGET_TIMEOUT_MS);
+    ws.once("open", () => {
+      ws.send(
+        JSON.stringify({
+          id: CREATE_BLANK_TARGET_COMMAND_ID,
+          method: "Target.createTarget",
+          params: { url: "about:blank" }
+        })
+      );
+    });
+    ws.on("message", (data, isBinary) => {
+      if (isBinary) {
+        return;
+      }
+      const message = parseMessage(data);
+      if (!message || asNumber(message.id) !== CREATE_BLANK_TARGET_COMMAND_ID) {
+        return;
+      }
+      const cdpError = asObject(message.error);
+      if (cdpError) {
+        settle(
+          () => reject(
+            new Error(
+              `Target.createTarget failed: ${asString(cdpError.message) ?? JSON.stringify(cdpError)}`
+            )
+          )
+        );
+        return;
+      }
+      const targetId = asString(asObject(message.result)?.targetId);
+      if (targetId) {
+        settle(() => resolve(targetId));
+        return;
+      }
+      settle(
+        () => reject(
+          new Error(
+            "Target.createTarget succeeded but no targetId was returned."
+          )
+        )
+      );
+    });
+    ws.once("error", (err) => {
+      settle(
+        () => reject(new Error(`Failed to create blank tab: ${errorMessage(err)}`))
+      );
+    });
+    ws.once("close", () => {
+      settle(
+        () => reject(
+          new Error(
+            "CDP browser websocket closed before blank tab creation completed."
+          )
+        )
+      );
+    });
+  });
+}
 var CDPProxy = class {
   constructor(browserWsUrl, targetId) {
     this.browserWsUrl = browserWsUrl;
@@ -845,18 +919,282 @@ function listLocalChromeProfiles(userDataDir = detectChromePaths().defaultUserDa
   }
 }
 
+// src/browser/persistent-profile.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_node_path = require("path");
+var OPENSTEER_META_FILE = ".opensteer-meta.json";
+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}".`
+    );
+  }
+  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_promises.rm)((0, import_node_path.join)(userDataDir, entry), {
+        force: true,
+        recursive: true
+      }).catch(() => void 0)
+    )
+  );
+}
+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}`;
+}
+function defaultPersistentProfilesRootDir() {
+  return (0, import_node_path.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_fs.existsSync)((0, import_node_path.join)(userDataDir, entry, "Preferences"));
+}
+async function copyRootLevelEntries(sourceUserDataDir, targetUserDataDir, targetProfileDirectory) {
+  let entries;
+  try {
+    entries = await (0, import_promises.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_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
+        )
+      );
+    }
+  }
+  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)
+  );
+}
+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_fs.existsSync)(targetUserDataDir)) {
+    return false;
+  }
+  const tempUserDataDir = await (0, import_promises.mkdtemp)(
+    buildPersistentProfileTempDirPrefix(targetUserDataDir)
+  );
+  let published = false;
+  try {
+    await (0, import_promises.cp)(sourceProfileDir, (0, import_node_path.join)(tempUserDataDir, profileDirectory), {
+      recursive: true
+    });
+    await copyRootLevelEntries(
+      sourceUserDataDir,
+      tempUserDataDir,
+      profileDirectory
+    );
+    await writePersistentProfileMetadata(tempUserDataDir, metadata);
+    try {
+      await (0, import_promises.rename)(tempUserDataDir, targetUserDataDir);
+    } catch (error) {
+      if (wasProfilePublishedByAnotherProcess(error, targetUserDataDir)) {
+        return false;
+      }
+      throw error;
+    }
+    published = true;
+    return true;
+  } finally {
+    if (!published) {
+      await (0, import_promises.rm)(tempUserDataDir, {
+        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;
+  }
+  await writePersistentProfileMetadata(userDataDir, metadata);
+}
+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 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}-`
+  );
+}
+async function cleanOrphanedTempDirs(profilesDir, targetBaseName) {
+  let entries;
+  try {
+    entries = await (0, import_promises.readdir)(profilesDir, {
+      encoding: "utf8",
+      withFileTypes: true
+    });
+  } catch {
+    return;
+  }
+  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);
+    })
+  );
+}
+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);
+}
+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;
+  }
+  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 };
+}
+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";
+  }
+}
+
 // src/browser/pool.ts
 var BrowserPool = class {
   browser = null;
   cdpProxy = null;
   launchedProcess = null;
-  tempUserDataDir = null;
+  managedUserDataDir = null;
+  persistentProfile = false;
   defaults;
   constructor(defaults = {}) {
     this.defaults = defaults;
   }
   async launch(options = {}) {
-    if (this.browser || this.cdpProxy || this.launchedProcess || this.tempUserDataDir) {
+    if (this.browser || this.cdpProxy || this.launchedProcess || this.managedUserDataDir) {
       await this.close();
     }
     const mode = options.mode ?? this.defaults.mode ?? "chromium";
@@ -906,11 +1244,13 @@ var BrowserPool = class {
     const browser = this.browser;
     const cdpProxy = this.cdpProxy;
     const launchedProcess = this.launchedProcess;
-    const tempUserDataDir = this.tempUserDataDir;
+    const managedUserDataDir = this.managedUserDataDir;
+    const persistentProfile = this.persistentProfile;
     this.browser = null;
     this.cdpProxy = null;
     this.launchedProcess = null;
-    this.tempUserDataDir = null;
+    this.managedUserDataDir = null;
+    this.persistentProfile = false;
     try {
       if (browser) {
         await browser.close().catch(() => void 0);
@@ -918,8 +1258,8 @@ var BrowserPool = class {
     } finally {
       cdpProxy?.close();
       await killProcessTree(launchedProcess);
-      if (tempUserDataDir) {
-        await (0, import_promises.rm)(tempUserDataDir, {
+      if (managedUserDataDir && !persistentProfile) {
+        await (0, import_promises2.rm)(managedUserDataDir, {
           recursive: true,
           force: true
         }).catch(() => void 0);
@@ -931,12 +1271,13 @@ var BrowserPool = class {
     let cdpProxy = null;
     try {
       const { browserWsUrl, targets } = await discoverTargets(cdpUrl);
-      if (targets.length === 0) {
-        throw new Error(
-          "No page targets found. Is the browser running with an open window?"
-        );
+      let targetId;
+      if (targets.length > 0) {
+        targetId = targets[0].id;
+      } else {
+        targetId = await createBlankTarget(browserWsUrl);
       }
-      cdpProxy = new CDPProxy(browserWsUrl, targets[0].id);
+      cdpProxy = new CDPProxy(browserWsUrl, targetId);
       const proxyWsUrl = await cdpProxy.start();
       browser = await import_playwright.chromium.connectOverCDP(proxyWsUrl, {
         timeout: timeout ?? 3e4
@@ -967,10 +1308,11 @@ var BrowserPool = class {
       options.userDataDir ?? chromePaths.defaultUserDataDir
     );
     const profileDirectory = options.profileDirectory ?? "Default";
-    const tempUserDataDir = await cloneProfileToTempDir(
+    const persistentProfile = await getOrCreatePersistentProfile(
       sourceUserDataDir,
       profileDirectory
     );
+    await clearPersistentProfileSingletons(persistentProfile.userDataDir);
     const debugPort = await reserveDebugPort();
     const headless = resolveLaunchHeadless(
       "real",
@@ -978,7 +1320,7 @@ var BrowserPool = class {
       this.defaults.headless
     );
     const launchArgs = buildRealBrowserLaunchArgs({
-      userDataDir: tempUserDataDir,
+      userDataDir: persistentProfile.userDataDir,
       profileDirectory,
       debugPort,
       headless
@@ -998,24 +1340,22 @@ var BrowserPool = class {
         timeout: options.timeout ?? 3e4
       });
       const { context, page } = await createOwnedBrowserContextAndPage(
-        browser,
-        {
-          headless,
-          initialUrl: options.initialUrl,
-          timeoutMs: options.timeout ?? 3e4
-        }
+        browser
       );
+      if (options.initialUrl) {
+        await page.goto(options.initialUrl, {
+          waitUntil: "domcontentloaded",
+          timeout: options.timeout ?? 3e4
+        });
+      }
       this.browser = browser;
       this.launchedProcess = processHandle;
-      this.tempUserDataDir = tempUserDataDir;
+      this.managedUserDataDir = persistentProfile.userDataDir;
+      this.persistentProfile = true;
       return { browser, context, page, isExternal: false };
     } catch (error) {
       await browser?.close().catch(() => void 0);
       await killProcessTree(processHandle);
-      await (0, import_promises.rm)(tempUserDataDir, {
-        recursive: true,
-        force: true
-      }).catch(() => void 0);
       throw error;
     }
   }
@@ -1038,8 +1378,7 @@ var BrowserPool = class {
 };
 async function pickBrowserContextAndPage(browser) {
   const context = getPrimaryBrowserContext(browser);
-  const pages = context.pages();
-  const page = pages.find((candidate) => isInspectablePageUrl2(candidate.url())) || pages[0] || await context.newPage();
+  const page = await getAttachedPageOrCreate(context);
   return { context, page };
 }
 function resolveLaunchHeadless(mode, requestedHeadless, defaultHeadless) {
@@ -1051,77 +1390,31 @@ function resolveLaunchHeadless(mode, requestedHeadless, defaultHeadless) {
   }
   return mode === "real";
 }
-async function createOwnedBrowserContextAndPage(browser, options) {
+async function createOwnedBrowserContextAndPage(browser) {
   const context = getPrimaryBrowserContext(browser);
-  const page = await createOwnedBrowserPage(browser, context, options);
+  const page = await getExistingPageOrCreate(context);
   return { context, page };
 }
-async function createOwnedBrowserPage(browser, context, options) {
-  const targetUrl = options.initialUrl ?? "about:blank";
-  const existingPages = new Set(context.pages());
-  const browserSession = await browser.newBrowserCDPSession();
-  try {
-    const { targetId } = await browserSession.send("Target.createTarget", {
-      url: targetUrl,
-      newWindow: !options.headless
-    });
-    await browserSession.send("Target.activateTarget", { targetId }).catch(() => void 0);
-    const page = await waitForOwnedBrowserPage(context, {
-      existingPages,
-      targetUrl,
-      timeoutMs: options.timeoutMs
-    });
-    if (targetUrl !== "about:blank") {
-      await page.waitForLoadState("domcontentloaded", {
-        timeout: options.timeoutMs
-      });
-    }
-    await closeDisposableStartupTargets(browserSession, targetId);
-    return page;
-  } finally {
-    await browserSession.detach().catch(() => void 0);
-  }
-}
-async function closeDisposableStartupTargets(browserSession, preservedTargetId) {
-  const response = await browserSession.send("Target.getTargets").catch(() => null);
-  if (!response) {
-    return;
+async function getAttachedPageOrCreate(context) {
+  const pages = context.pages();
+  const inspectablePage = pages.find(
+    (candidate) => isInspectablePageUrl2(safePageUrl(candidate))
+  );
+  if (inspectablePage) {
+    return inspectablePage;
   }
-  for (const targetInfo of response.targetInfos) {
-    if (targetInfo.targetId === preservedTargetId || targetInfo.type !== "page" || !isDisposableStartupPageUrl(targetInfo.url)) {
-      continue;
-    }
-    await browserSession.send("Target.closeTarget", { targetId: targetInfo.targetId }).catch(() => void 0);
+  const attachedPage = pages[0];
+  if (attachedPage) {
+    return attachedPage;
   }
+  return await context.newPage();
 }
-async function waitForOwnedBrowserPage(context, options) {
-  const deadline = Date.now() + options.timeoutMs;
-  let fallbackPage = null;
-  while (Date.now() < deadline) {
-    for (const candidate of context.pages()) {
-      if (options.existingPages.has(candidate)) {
-        continue;
-      }
-      const url = candidate.url();
-      if (!isInspectablePageUrl2(url)) {
-        continue;
-      }
-      fallbackPage ??= candidate;
-      if (options.targetUrl === "about:blank") {
-        return candidate;
-      }
-      if (pageLooselyMatchesUrl(url, options.targetUrl)) {
-        return candidate;
-      }
-    }
-    await sleep(100);
-  }
-  if (fallbackPage) {
-    return fallbackPage;
+async function getExistingPageOrCreate(context) {
+  const existingPage = context.pages()[0];
+  if (existingPage) {
+    return existingPage;
   }
-  throw new Error(
-    `Chrome created a target for ${options.targetUrl}, but Playwright did not expose the page in time.`
-  );
+  return await context.newPage();
 }
 function getPrimaryBrowserContext(browser) {
   const contexts = browser.contexts();
@@ -1135,19 +1428,11 @@ function getPrimaryBrowserContext(browser) {
 function isInspectablePageUrl2(url) {
   return url === "about:blank" || url.startsWith("http://") || url.startsWith("https://");
 }
-function isDisposableStartupPageUrl(url) {
-  return url === "about:blank" || url === "chrome://newtab/" || url === "chrome://new-tab-page/";
-}
-function pageLooselyMatchesUrl(currentUrl, initialUrl) {
+function safePageUrl(page) {
   try {
-    const current = new URL(currentUrl);
-    const requested = new URL(initialUrl);
-    if (current.href === requested.href) {
-      return true;
-    }
-    return current.hostname === requested.hostname && current.pathname === requested.pathname;
+    return page.url();
   } catch {
-    return currentUrl === initialUrl;
+    return "";
   }
 }
 function normalizeDiscoveryUrl(cdpUrl) {
@@ -1227,38 +1512,12 @@ async function reserveDebugPort() {
     });
   });
 }
-async function cloneProfileToTempDir(userDataDir, profileDirectory) {
-  const resolvedUserDataDir = expandHome(userDataDir);
-  const tempUserDataDir = await (0, import_promises.mkdtemp)(
-    (0, import_node_path.join)((0, import_node_os.tmpdir)(), "opensteer-real-browser-")
-  );
-  const sourceProfileDir = (0, import_node_path.join)(resolvedUserDataDir, profileDirectory);
-  const targetProfileDir = (0, import_node_path.join)(tempUserDataDir, profileDirectory);
-  if ((0, import_node_fs.existsSync)(sourceProfileDir)) {
-    await (0, import_promises.cp)(sourceProfileDir, targetProfileDir, {
-      recursive: true
-    });
-  } else {
-    await (0, import_promises.mkdir)(targetProfileDir, {
-      recursive: true
-    });
-  }
-  const localStatePath = (0, import_node_path.join)(resolvedUserDataDir, "Local State");
-  if ((0, import_node_fs.existsSync)(localStatePath)) {
-    await (0, import_promises.copyFile)(localStatePath, (0, import_node_path.join)(tempUserDataDir, "Local State"));
-  }
-  return tempUserDataDir;
-}
 function buildRealBrowserLaunchArgs(options) {
   const args = [
     `--user-data-dir=${options.userDataDir}`,
     `--profile-directory=${options.profileDirectory}`,
     `--remote-debugging-port=${options.debugPort}`,
-    "--no-first-run",
-    "--no-default-browser-check",
-    "--disable-background-networking",
-    "--disable-sync",
-    "--disable-popup-blocking"
+    "--disable-blink-features=AutomationControlled"
   ];
   if (options.headless) {
     args.push("--headless=new");
@@ -6968,7 +7227,7 @@ async function closeTab(context, activePage, index) {
 }
 
 // src/actions/cookies.ts
-var import_promises2 = require("fs/promises");
+var import_promises3 = require("fs/promises");
 async function getCookies(context, url) {
   return context.cookies(url ? [url] : void 0);
 }
@@ -6980,10 +7239,10 @@ async function clearCookies(context) {
 }
 async function exportCookies(context, filePath, url) {
   const cookies = await context.cookies(url ? [url] : void 0);
-  await (0, import_promises2.writeFile)(filePath, JSON.stringify(cookies, null, 2), "utf-8");
+  await (0, import_promises3.writeFile)(filePath, JSON.stringify(cookies, null, 2), "utf-8");
 }
 async function importCookies(context, filePath) {
-  const raw = await (0, import_promises2.readFile)(filePath, "utf-8");
+  const raw = await (0, import_promises3.readFile)(filePath, "utf-8");
   const cookies = JSON.parse(raw);
   await context.addCookies(cookies);
 }
@@ -7734,31 +7993,31 @@ function buildVariantDescriptorFromCluster(descriptors) {
   const keyStats = /* @__PURE__ */ new Map();
   for (const descriptor of descriptors) {
     for (const field of descriptor.fields) {
-      const stat = keyStats.get(field.path) || {
+      const stat2 = keyStats.get(field.path) || {
         indices: /* @__PURE__ */ new Set(),
         pathNodes: [],
         attributes: [],
         sources: []
       };
-      stat.indices.add(descriptor.index);
+      stat2.indices.add(descriptor.index);
       if (isPersistedValueNode(field.node)) {
-        stat.pathNodes.push(field.node.$path);
-        stat.attributes.push(field.node.attribute);
+        stat2.pathNodes.push(field.node.$path);
+        stat2.attributes.push(field.node.attribute);
       } else if (isPersistedSourceNode(field.node)) {
-        stat.sources.push("current_url");
+        stat2.sources.push("current_url");
       }
-      keyStats.set(field.path, stat);
+      keyStats.set(field.path, stat2);
     }
   }
   const mergedFields = [];
-  for (const [fieldPath, stat] of keyStats) {
-    if (stat.indices.size < threshold) continue;
-    if (stat.pathNodes.length >= threshold) {
+  for (const [fieldPath, stat2] of keyStats) {
+    if (stat2.indices.size < threshold) continue;
+    if (stat2.pathNodes.length >= threshold) {
       let mergedFieldPath = null;
-      if (stat.pathNodes.length === 1) {
-        mergedFieldPath = sanitizeElementPath(stat.pathNodes[0]);
+      if (stat2.pathNodes.length === 1) {
+        mergedFieldPath = sanitizeElementPath(stat2.pathNodes[0]);
       } else {
-        mergedFieldPath = mergeElementPathsByMajority(stat.pathNodes);
+        mergedFieldPath = mergeElementPathsByMajority(stat2.pathNodes);
       }
       if (!mergedFieldPath) continue;
       if (clusterSize === 1) {
@@ -7771,17 +8030,17 @@ function buildVariantDescriptorFromCluster(descriptors) {
         mergedFieldPath,
         "field"
       );
-      const attrThreshold = stat.pathNodes.length === 1 ? 1 : majorityThreshold(stat.pathNodes.length);
+      const attrThreshold = stat2.pathNodes.length === 1 ? 1 : majorityThreshold(stat2.pathNodes.length);
       mergedFields.push({
         path: fieldPath,
         node: createValueNode({
           elementPath: mergedFieldPath,
-          attribute: pickModeString(stat.attributes, attrThreshold)
+          attribute: pickModeString(stat2.attributes, attrThreshold)
         })
       });
       continue;
     }
-    const dominantSource = pickModeString(stat.sources, threshold);
+    const dominantSource = pickModeString(stat2.sources, threshold);
     if (dominantSource === "current_url") {
       mergedFields.push({
         path: fieldPath,
@@ -8982,7 +9241,7 @@ function selectPreferredContextPage(browser, contexts) {
   let aboutBlankCandidate = null;
   for (const context of contexts) {
     for (const page of context.pages()) {
-      const url = safePageUrl(page);
+      const url = safePageUrl2(page);
       if (!isInternalOrEmptyUrl(url)) {
         return { browser, context, page };
       }
@@ -8993,7 +9252,7 @@ function selectPreferredContextPage(browser, contexts) {
   }
   return aboutBlankCandidate;
 }
-function safePageUrl(page) {
+function safePageUrl2(page) {
   try {
     return page.url();
   } catch {
@@ -14427,7 +14686,7 @@ function getMetadataPath(session2) {
 }
 
 // src/cli/commands.ts
-var import_promises3 = require("fs/promises");
+var import_promises4 = require("fs/promises");
 var commands = {
   async navigate(opensteer, args) {
     const url = args.url;
@@ -14481,7 +14740,7 @@ var commands = {
       fullPage: args.fullPage,
       type
     });
-    await (0, import_promises3.writeFile)(file, buffer);
+    await (0, import_promises4.writeFile)(file, buffer);
     return { file };
   },
   async click(opensteer, args) {