opensteer 0.6.3 → 0.6.4

package/dist/index.cjs

@@ -515,7 +515,13 @@ module.exports = __toCommonJS(index_exports);
 var import_crypto = require("crypto");
 
 // src/browser/pool.ts
-var import_playwright2 = require("playwright");
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_promises = 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
 var import_ws = __toESM(require("ws"), 1);
@@ -854,209 +860,263 @@ function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/browser/chromium-profile.ts
-var import_node_util = require("util");
-var import_node_child_process2 = require("child_process");
-var import_node_crypto = require("crypto");
-var import_promises = require("fs/promises");
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-var import_node_os = require("os");
-var import_playwright = require("playwright");
-
-// src/auth/keychain-store.ts
-var import_node_child_process = require("child_process");
-
 // src/browser/chrome.ts
 var import_os = require("os");
 var import_path = require("path");
+var import_fs = require("fs");
+function detectChromePaths() {
+  const os = (0, import_os.platform)();
+  if (os === "darwin") {
+    const executable2 = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+    return {
+      executable: (0, import_fs.existsSync)(executable2) ? executable2 : null,
+      defaultUserDataDir: (0, import_path.join)(
+        (0, import_os.homedir)(),
+        "Library",
+        "Application Support",
+        "Google",
+        "Chrome"
+      )
+    };
+  }
+  if (os === "win32") {
+    const executable2 = (0, import_path.join)(
+      process.env.PROGRAMFILES || "C:\\Program Files",
+      "Google",
+      "Chrome",
+      "Application",
+      "chrome.exe"
+    );
+    return {
+      executable: (0, import_fs.existsSync)(executable2) ? executable2 : null,
+      defaultUserDataDir: (0, import_path.join)(
+        process.env.LOCALAPPDATA || (0, import_path.join)((0, import_os.homedir)(), "AppData", "Local"),
+        "Google",
+        "Chrome",
+        "User Data"
+      )
+    };
+  }
+  const executable = "/usr/bin/google-chrome";
+  return {
+    executable: (0, import_fs.existsSync)(executable) ? executable : null,
+    defaultUserDataDir: (0, import_path.join)((0, import_os.homedir)(), ".config", "google-chrome")
+  };
+}
 function expandHome(p) {
   if (p.startsWith("~/") || p === "~") {
     return (0, import_path.join)((0, import_os.homedir)(), p.slice(1));
   }
   return p;
 }
-
-// src/browser/chromium-profile.ts
-var execFileAsync = (0, import_node_util.promisify)(import_node_child_process2.execFile);
-function directoryExists(filePath) {
-  try {
-    return (0, import_node_fs.statSync)(filePath).isDirectory();
-  } catch {
-    return false;
+function listLocalChromeProfiles(userDataDir = detectChromePaths().defaultUserDataDir) {
+  const resolvedUserDataDir = expandHome(userDataDir);
+  const localStatePath = (0, import_path.join)(resolvedUserDataDir, "Local State");
+  if (!(0, import_fs.existsSync)(localStatePath)) {
+    return [];
   }
-}
-function fileExists(filePath) {
   try {
-    return (0, import_node_fs.statSync)(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-function resolveCookieDbPath(profileDir) {
-  const candidates = [(0, import_node_path.join)(profileDir, "Network", "Cookies"), (0, import_node_path.join)(profileDir, "Cookies")];
-  for (const candidate of candidates) {
-    if (fileExists(candidate)) {
-      return candidate;
+    const raw = JSON.parse((0, import_fs.readFileSync)(localStatePath, "utf-8"));
+    const infoCache = raw && typeof raw === "object" && !Array.isArray(raw) && raw.profile && typeof raw.profile === "object" && !Array.isArray(raw.profile) ? raw.profile.info_cache : void 0;
+    if (!infoCache || typeof infoCache !== "object") {
+      return [];
     }
+    return Object.entries(infoCache).map(([directory, info]) => {
+      const record = info && typeof info === "object" && !Array.isArray(info) ? info : {};
+      const name = typeof record.name === "string" && record.name.trim() ? record.name.trim() : directory;
+      return {
+        directory,
+        name
+      };
+    }).filter((profile) => profile.directory.trim().length > 0).sort(
+      (left, right) => left.directory.localeCompare(right.directory)
+    );
+  } catch {
+    return [];
   }
-  return null;
-}
-function resolvePersistentChromiumLaunchProfile(inputPath) {
-  const expandedPath = expandHome(inputPath.trim());
-  if (!expandedPath) {
-    return {
-      userDataDir: inputPath
-    };
-  }
-  if (fileExists(expandedPath) && (0, import_node_path.basename)(expandedPath) === "Cookies") {
-    const directParent = (0, import_node_path.dirname)(expandedPath);
-    const profileDir = (0, import_node_path.basename)(directParent) === "Network" ? (0, import_node_path.dirname)(directParent) : directParent;
-    return {
-      userDataDir: (0, import_node_path.dirname)(profileDir),
-      profileDirectory: (0, import_node_path.basename)(profileDir)
-    };
-  }
-  if (directoryExists(expandedPath) && resolveCookieDbPath(expandedPath) && fileExists((0, import_node_path.join)((0, import_node_path.dirname)(expandedPath), "Local State"))) {
-    return {
-      userDataDir: (0, import_node_path.dirname)(expandedPath),
-      profileDirectory: (0, import_node_path.basename)(expandedPath)
-    };
-  }
-  return {
-    userDataDir: expandedPath
-  };
 }
 
 // src/browser/pool.ts
 var BrowserPool = class {
   browser = null;
-  persistentContext = null;
   cdpProxy = null;
+  launchedProcess = null;
+  tempUserDataDir = null;
   defaults;
   constructor(defaults = {}) {
     this.defaults = defaults;
   }
   async launch(options = {}) {
-    if (this.browser || this.cdpProxy) {
+    if (this.browser || this.cdpProxy || this.launchedProcess || this.tempUserDataDir) {
       await this.close();
     }
-    const connectUrl = options.connectUrl ?? this.defaults.connectUrl;
-    const channel = options.channel ?? this.defaults.channel;
-    const profileDir = options.profileDir ?? this.defaults.profileDir;
-    if (connectUrl) {
-      return this.connectToRunning(connectUrl, options.timeout);
+    const mode = options.mode ?? this.defaults.mode ?? "chromium";
+    const cdpUrl = options.cdpUrl ?? this.defaults.cdpUrl;
+    const userDataDir = options.userDataDir ?? this.defaults.userDataDir;
+    const profileDirectory = options.profileDirectory ?? this.defaults.profileDirectory;
+    const executablePath = options.executablePath ?? this.defaults.executablePath;
+    if (cdpUrl) {
+      if (mode === "real") {
+        throw new Error(
+          'cdpUrl cannot be combined with mode "real". Use one browser launch path at a time.'
+        );
+      }
+      if (userDataDir || profileDirectory) {
+        throw new Error(
+          "userDataDir/profileDirectory cannot be combined with cdpUrl."
+        );
+      }
+      if (options.context && Object.keys(options.context).length > 0) {
+        throw new Error(
+          "context launch options are not supported when attaching over CDP."
+        );
+      }
+      return this.connectToRunning(cdpUrl, options.timeout);
     }
-    if (profileDir) {
-      return this.launchPersistentProfile(options, channel, profileDir);
+    if (mode !== "real" && (userDataDir || profileDirectory)) {
+      throw new Error(
+        'userDataDir/profileDirectory require mode "real".'
+      );
     }
-    if (channel) {
-      return this.launchWithChannel(options, channel);
+    if (mode === "real") {
+      if (options.context && Object.keys(options.context).length > 0) {
+        throw new Error(
+          "context launch options are not supported for real-browser mode."
+        );
+      }
+      return this.launchOwnedRealBrowser({
+        ...options,
+        executablePath,
+        userDataDir,
+        profileDirectory
+      });
     }
     return this.launchSandbox(options);
   }
   async close() {
     const browser = this.browser;
-    const persistentContext = this.persistentContext;
+    const cdpProxy = this.cdpProxy;
+    const launchedProcess = this.launchedProcess;
+    const tempUserDataDir = this.tempUserDataDir;
     this.browser = null;
-    this.persistentContext = null;
+    this.cdpProxy = null;
+    this.launchedProcess = null;
+    this.tempUserDataDir = null;
     try {
-      if (persistentContext) {
-        await persistentContext.close();
-      } else if (browser) {
-        await browser.close();
+      if (browser) {
+        await browser.close().catch(() => void 0);
       }
     } finally {
-      this.cdpProxy?.close();
-      this.cdpProxy = null;
+      cdpProxy?.close();
+      await killProcessTree(launchedProcess);
+      if (tempUserDataDir) {
+        await (0, import_promises.rm)(tempUserDataDir, {
+          recursive: true,
+          force: true
+        }).catch(() => void 0);
+      }
     }
   }
-  async connectToRunning(connectUrl, timeout) {
-    this.cdpProxy?.close();
-    this.cdpProxy = null;
+  async connectToRunning(cdpUrl, timeout) {
     let browser = null;
+    let cdpProxy = null;
     try {
-      const { browserWsUrl, targets } = await discoverTargets(connectUrl);
+      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?"
         );
       }
-      const target = targets[0];
-      this.cdpProxy = new CDPProxy(browserWsUrl, target.id);
-      const proxyWsUrl = await this.cdpProxy.start();
-      browser = await import_playwright2.chromium.connectOverCDP(proxyWsUrl, {
+      cdpProxy = new CDPProxy(browserWsUrl, targets[0].id);
+      const proxyWsUrl = await cdpProxy.start();
+      browser = await import_playwright.chromium.connectOverCDP(proxyWsUrl, {
         timeout: timeout ?? 3e4
       });
       this.browser = browser;
-      this.persistentContext = null;
-      const contexts = browser.contexts();
-      if (contexts.length === 0) {
-        throw new Error(
-          "Connection succeeded but no browser contexts found. Is the browser running with an open window?"
-        );
-      }
-      const context = contexts[0];
-      const pages = context.pages();
-      const page = pages.length > 0 ? pages[0] : await context.newPage();
+      this.cdpProxy = cdpProxy;
+      const { context, page } = await pickBrowserContextAndPage(browser);
       return { browser, context, page, isExternal: true };
     } catch (error) {
       if (browser) {
         await browser.close().catch(() => void 0);
       }
+      cdpProxy?.close();
       this.browser = null;
-      this.persistentContext = null;
-      this.cdpProxy?.close();
       this.cdpProxy = null;
       throw error;
     }
   }
-  async launchPersistentProfile(options, channel, profileDir) {
-    const args = [];
-    const launchProfile = resolvePersistentChromiumLaunchProfile(profileDir);
-    if (launchProfile.profileDirectory) {
-      args.push(`--profile-directory=${launchProfile.profileDirectory}`);
-    }
-    const context = await import_playwright2.chromium.launchPersistentContext(
-      launchProfile.userDataDir,
-      {
-        channel,
-        headless: options.headless ?? this.defaults.headless,
-        executablePath: options.executablePath ?? this.defaults.executablePath ?? void 0,
-        slowMo: options.slowMo ?? this.defaults.slowMo ?? 0,
-        timeout: options.timeout,
-        ...options.context || {},
-        args
-      }
-    );
-    const browser = context.browser();
-    if (!browser) {
-      await context.close().catch(() => void 0);
-      throw new Error("Persistent browser launch did not expose a browser instance.");
+  async launchOwnedRealBrowser(options) {
+    const chromePaths = detectChromePaths();
+    const executablePath = options.executablePath ?? chromePaths.executable ?? void 0;
+    if (!executablePath) {
+      throw new Error(
+        "Chrome was not found. Set browser.executablePath or install Chrome in a supported location."
+      );
     }
-    this.browser = browser;
-    this.persistentContext = context;
-    const pages = context.pages();
-    const page = pages.length > 0 ? pages[0] : await context.newPage();
-    return { browser, context, page, isExternal: false };
-  }
-  async launchWithChannel(options, channel) {
-    const browser = await import_playwright2.chromium.launch({
-      channel,
-      headless: options.headless ?? this.defaults.headless,
-      executablePath: options.executablePath ?? this.defaults.executablePath ?? void 0,
-      slowMo: options.slowMo ?? this.defaults.slowMo ?? 0,
-      timeout: options.timeout
+    const sourceUserDataDir = expandHome(
+      options.userDataDir ?? chromePaths.defaultUserDataDir
+    );
+    const profileDirectory = options.profileDirectory ?? "Default";
+    const tempUserDataDir = await cloneProfileToTempDir(
+      sourceUserDataDir,
+      profileDirectory
+    );
+    const debugPort = await reserveDebugPort();
+    const headless = resolveLaunchHeadless(
+      "real",
+      options.headless,
+      this.defaults.headless
+    );
+    const launchArgs = buildRealBrowserLaunchArgs({
+      userDataDir: tempUserDataDir,
+      profileDirectory,
+      debugPort,
+      headless
     });
-    this.browser = browser;
-    this.persistentContext = null;
-    const context = await browser.newContext(options.context || {});
-    const page = await context.newPage();
-    return { browser, context, page, isExternal: false };
+    const processHandle = (0, import_node_child_process.spawn)(executablePath, launchArgs, {
+      detached: process.platform !== "win32",
+      stdio: "ignore"
+    });
+    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,
+        {
+          headless,
+          initialUrl: options.initialUrl,
+          timeoutMs: options.timeout ?? 3e4
+        }
+      );
+      this.browser = browser;
+      this.launchedProcess = processHandle;
+      this.tempUserDataDir = tempUserDataDir;
+      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;
+    }
   }
   async launchSandbox(options) {
-    const browser = await import_playwright2.chromium.launch({
-      headless: options.headless ?? this.defaults.headless,
+    const browser = await import_playwright.chromium.launch({
+      headless: resolveLaunchHeadless(
+        "chromium",
+        options.headless,
+        this.defaults.headless
+      ),
       executablePath: options.executablePath ?? this.defaults.executablePath ?? void 0,
       slowMo: options.slowMo ?? this.defaults.slowMo ?? 0,
       timeout: options.timeout
@@ -1064,13 +1124,271 @@ var BrowserPool = class {
     const context = await browser.newContext(options.context || {});
     const page = await context.newPage();
     this.browser = browser;
-    this.persistentContext = null;
     return { browser, context, page, isExternal: false };
   }
 };
+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();
+  return { context, page };
+}
+function resolveLaunchHeadless(mode, requestedHeadless, defaultHeadless) {
+  if (requestedHeadless !== void 0) {
+    return requestedHeadless;
+  }
+  if (defaultHeadless !== void 0) {
+    return defaultHeadless;
+  }
+  return mode === "real";
+}
+async function createOwnedBrowserContextAndPage(browser, options) {
+  const context = getPrimaryBrowserContext(browser);
+  const page = await createOwnedBrowserPage(browser, context, options);
+  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;
+  }
+  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);
+  }
+}
+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;
+  }
+  throw new Error(
+    `Chrome created a target for ${options.targetUrl}, but Playwright did not expose the page in time.`
+  );
+}
+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];
+}
+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) {
+  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;
+  } catch {
+    return currentUrl === initialUrl;
+  }
+}
+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);
+      });
+    });
+  });
+}
+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"
+  ];
+  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/config.ts
-var import_fs = __toESM(require("fs"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
 var import_path3 = __toESM(require("path"), 1);
 var import_url = require("url");
 var import_dotenv = require("dotenv");
@@ -1398,9 +1716,10 @@ var DEFAULT_CONFIG = {
     headless: false,
     executablePath: void 0,
     slowMo: 0,
-    connectUrl: void 0,
-    channel: void 0,
-    profileDir: void 0
+    mode: void 0,
+    cdpUrl: void 0,
+    userDataDir: void 0,
+    profileDirectory: void 0
   },
   storage: {
     rootDir: process.cwd()
@@ -1437,9 +1756,9 @@ function loadDotenvValues(rootDir, baseEnv, options = {}) {
   const nodeEnv = baseEnv.NODE_ENV?.trim() || "";
   for (const filename of dotenvFileOrder(nodeEnv)) {
     const filePath = import_path3.default.join(baseDir, filename);
-    if (!import_fs.default.existsSync(filePath)) continue;
+    if (!import_fs2.default.existsSync(filePath)) continue;
     try {
-      const raw = import_fs.default.readFileSync(filePath, "utf8");
+      const raw = import_fs2.default.readFileSync(filePath, "utf8");
       const parsed = (0, import_dotenv.parse)(raw);
       for (const [key, value] of Object.entries(parsed)) {
         if (values[key] === void 0) {
@@ -1509,9 +1828,9 @@ function assertNoLegacyRuntimeConfig(source, config) {
 }
 function loadConfigFile(rootDir, options = {}) {
   const configPath = import_path3.default.join(rootDir, ".opensteer", "config.json");
-  if (!import_fs.default.existsSync(configPath)) return {};
+  if (!import_fs2.default.existsSync(configPath)) return {};
   try {
-    const raw = import_fs.default.readFileSync(configPath, "utf8");
+    const raw = import_fs2.default.readFileSync(configPath, "utf8");
     return JSON.parse(raw);
   } catch (error) {
     const message = extractErrorMessage(
@@ -1744,6 +2063,8 @@ function resolveConfigWithEnv(input = {}, options = {}) {
   const fileHasCloudApiKey = hasOwn(fileCloudOptions, "apiKey");
   const fileHasCloudAccessToken = hasOwn(fileCloudOptions, "accessToken");
   const fileRootDir = typeof fileConfig.storage?.rootDir === "string" ? fileConfig.storage.rootDir : void 0;
+  assertNoRemovedBrowserConfig(input.browser, "Opensteer constructor config");
+  assertNoRemovedBrowserConfig(fileConfig.browser, ".opensteer/config.json");
   const envRootDir = input.storage?.rootDir ?? fileRootDir ?? initialRootDir;
   const env = resolveEnv(envRootDir, {
     debug: debugHint,
@@ -1759,14 +2080,30 @@ function resolveConfigWithEnv(input = {}, options = {}) {
       "OPENSTEER_RUNTIME is no longer supported. Use OPENSTEER_MODE instead."
     );
   }
+  if (env.OPENSTEER_CONNECT_URL != null) {
+    throw new Error(
+      "OPENSTEER_CONNECT_URL is no longer supported. Use OPENSTEER_CDP_URL instead."
+    );
+  }
+  if (env.OPENSTEER_CHANNEL != null) {
+    throw new Error(
+      "OPENSTEER_CHANNEL is no longer supported. Use OPENSTEER_BROWSER plus OPENSTEER_BROWSER_PATH when needed."
+    );
+  }
+  if (env.OPENSTEER_PROFILE_DIR != null) {
+    throw new Error(
+      "OPENSTEER_PROFILE_DIR is no longer supported. Use OPENSTEER_USER_DATA_DIR and OPENSTEER_PROFILE_DIRECTORY instead."
+    );
+  }
   const envConfig = {
     browser: {
       headless: parseBool(env.OPENSTEER_HEADLESS),
       executablePath: env.OPENSTEER_BROWSER_PATH || void 0,
       slowMo: parseNumber(env.OPENSTEER_SLOW_MO),
-      connectUrl: env.OPENSTEER_CONNECT_URL || void 0,
-      channel: env.OPENSTEER_CHANNEL || void 0,
-      profileDir: env.OPENSTEER_PROFILE_DIR || void 0
+      mode: env.OPENSTEER_BROWSER === "real" || env.OPENSTEER_BROWSER === "chromium" ? env.OPENSTEER_BROWSER : void 0,
+      cdpUrl: env.OPENSTEER_CDP_URL || void 0,
+      userDataDir: env.OPENSTEER_USER_DATA_DIR || void 0,
+      profileDirectory: env.OPENSTEER_PROFILE_DIRECTORY || void 0
     },
     cursor: {
       enabled: parseBool(env.OPENSTEER_CURSOR)
@@ -1777,6 +2114,34 @@ function resolveConfigWithEnv(input = {}, options = {}) {
   const mergedWithFile = mergeDeep(runtimeDefaults, fileConfig);
   const mergedWithEnv = mergeDeep(mergedWithFile, envConfig);
   const resolved = mergeDeep(mergedWithEnv, input);
+  const browserHeadlessExplicit = input.browser?.headless !== void 0 || fileConfig.browser?.headless !== void 0 || envConfig.browser?.headless !== void 0;
+  if (!browserHeadlessExplicit && resolved.browser?.mode === "real") {
+    resolved.browser = {
+      ...resolved.browser,
+      headless: true
+    };
+  }
+  function assertNoRemovedBrowserConfig(value, source) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return;
+    }
+    const record = value;
+    if (record.connectUrl !== void 0) {
+      throw new Error(
+        `${source}.browser.connectUrl is no longer supported. Use browser.cdpUrl instead.`
+      );
+    }
+    if (record.channel !== void 0) {
+      throw new Error(
+        `${source}.browser.channel is no longer supported. Use browser.mode plus browser.executablePath instead.`
+      );
+    }
+    if (record.profileDir !== void 0) {
+      throw new Error(
+        `${source}.browser.profileDir is no longer supported. Use browser.userDataDir and browser.profileDirectory instead.`
+      );
+    }
+  }
   const envApiKey = resolveOpensteerApiKey(env);
   const envAccessTokenRaw = resolveOpensteerAccessToken(env);
   const envBaseUrl = resolveOpensteerBaseUrl(env);
@@ -2292,7 +2657,7 @@ var StealthCdpRuntime = class _StealthCdpRuntime {
           TRANSIENT_CONTEXT_RETRY_DELAY_MS,
           Math.max(0, deadline - Date.now())
         );
-        await sleep(retryDelay);
+        await sleep2(retryDelay);
       }
     }
   }
@@ -2325,7 +2690,7 @@ var StealthCdpRuntime = class _StealthCdpRuntime {
       () => ({ kind: "resolved" }),
       (error) => ({ kind: "rejected", error })
     );
-    const timeoutPromise = sleep(
+    const timeoutPromise = sleep2(
       timeout + FRAME_EVALUATE_GRACE_MS
     ).then(() => ({ kind: "timeout" }));
     const result = await Promise.race([
@@ -2467,14 +2832,14 @@ 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 sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
 }
 
 // src/storage/local.ts
-var import_fs2 = __toESM(require("fs"), 1);
+var import_fs3 = __toESM(require("fs"), 1);
 var import_path4 = __toESM(require("path"), 1);
 
 // src/storage/registry.ts
@@ -2518,14 +2883,14 @@ var LocalSelectorStorage = class {
     return import_path4.default.join(this.getNamespaceDir(), this.getSelectorFileName(id));
   }
   ensureDirs() {
-    import_fs2.default.mkdirSync(this.getNamespaceDir(), { recursive: true });
+    import_fs3.default.mkdirSync(this.getNamespaceDir(), { recursive: true });
   }
   loadRegistry() {
     this.ensureDirs();
     const file = this.getRegistryPath();
-    if (!import_fs2.default.existsSync(file)) return createEmptyRegistry(this.namespace);
+    if (!import_fs3.default.existsSync(file)) return createEmptyRegistry(this.namespace);
     try {
-      const raw = import_fs2.default.readFileSync(file, "utf8");
+      const raw = import_fs3.default.readFileSync(file, "utf8");
       return JSON.parse(raw);
     } catch (error) {
       const message = extractErrorMessage(
@@ -2542,16 +2907,16 @@ var LocalSelectorStorage = class {
   }
   saveRegistry(registry) {
     this.ensureDirs();
-    import_fs2.default.writeFileSync(
+    import_fs3.default.writeFileSync(
       this.getRegistryPath(),
       JSON.stringify(registry, null, 2)
     );
   }
   readSelector(id) {
     const file = this.getSelectorPath(id);
-    if (!import_fs2.default.existsSync(file)) return null;
+    if (!import_fs3.default.existsSync(file)) return null;
     try {
-      const raw = import_fs2.default.readFileSync(file, "utf8");
+      const raw = import_fs3.default.readFileSync(file, "utf8");
       return JSON.parse(raw);
     } catch (error) {
       const message = extractErrorMessage(
@@ -2568,15 +2933,15 @@ var LocalSelectorStorage = class {
   }
   writeSelector(payload) {
     this.ensureDirs();
-    import_fs2.default.writeFileSync(
+    import_fs3.default.writeFileSync(
       this.getSelectorPath(payload.id),
       JSON.stringify(payload, null, 2)
     );
   }
   clearNamespace() {
     const dir = this.getNamespaceDir();
-    if (!import_fs2.default.existsSync(dir)) return;
-    import_fs2.default.rmSync(dir, { recursive: true, force: true });
+    if (!import_fs3.default.existsSync(dir)) return;
+    import_fs3.default.rmSync(dir, { recursive: true, force: true });
   }
 };
 
@@ -7030,7 +7395,7 @@ var AdaptiveNetworkTracker = class {
         this.idleSince = 0;
       }
       const remaining = Math.max(1, options.deadline - now);
-      await sleep2(Math.min(NETWORK_POLL_MS, remaining));
+      await sleep3(Math.min(NETWORK_POLL_MS, remaining));
     }
   }
   handleRequestStarted = (request) => {
@@ -7075,7 +7440,7 @@ var AdaptiveNetworkTracker = class {
     return false;
   }
 };
-async function sleep2(ms) {
+async function sleep3(ms) {
   await new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -8552,15 +8917,15 @@ function withTokenQuery(wsUrl, token) {
 }
 
 // src/cloud/local-cache-sync.ts
-var import_fs3 = __toESM(require("fs"), 1);
+var import_fs4 = __toESM(require("fs"), 1);
 var import_path5 = __toESM(require("path"), 1);
 function collectLocalSelectorCacheEntries(storage, options = {}) {
   const debug = options.debug === true;
   const namespace = storage.getNamespace();
   const namespaceDir = storage.getNamespaceDir();
-  if (!import_fs3.default.existsSync(namespaceDir)) return [];
+  if (!import_fs4.default.existsSync(namespaceDir)) return [];
   const entries = [];
-  const fileNames = import_fs3.default.readdirSync(namespaceDir);
+  const fileNames = import_fs4.default.readdirSync(namespaceDir);
   for (const fileName of fileNames) {
     if (fileName === "index.json" || !fileName.endsWith(".json")) continue;
     const filePath = import_path5.default.join(namespaceDir, fileName);
@@ -8591,7 +8956,7 @@ function collectLocalSelectorCacheEntries(storage, options = {}) {
 }
 function readSelectorFile(filePath, debug) {
   try {
-    const raw = import_fs3.default.readFileSync(filePath, "utf8");
+    const raw = import_fs4.default.readFileSync(filePath, "utf8");
     return JSON.parse(raw);
   } catch (error) {
     const message = extractErrorMessage(
@@ -8686,13 +9051,13 @@ function dedupeNewest(entries) {
 }
 
 // src/cloud/cdp-client.ts
-var import_playwright3 = require("playwright");
+var import_playwright2 = require("playwright");
 var CloudCdpClient = class {
   async connect(args) {
     const endpoint = withTokenQuery2(args.wsUrl, args.token);
     let browser;
     try {
-      browser = await import_playwright3.chromium.connectOverCDP(endpoint);
+      browser = await import_playwright2.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);
@@ -10485,7 +10850,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": {
@@ -10650,7 +11015,7 @@ async function pressKeyCombo(page, combo) {
     }
   }
 }
-function sleep3(ms) {
+function sleep4(ms) {
   return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 }
 
@@ -10681,7 +11046,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({
@@ -10743,7 +11108,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)));
 }
 
@@ -11179,7 +11544,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)) {
@@ -11337,7 +11702,7 @@ 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));
 }
 
@@ -11722,9 +12087,11 @@ var Opensteer = class _Opensteer {
     }
     const session = await this.pool.launch({
       ...options,
-      connectUrl: options.connectUrl ?? this.config.browser?.connectUrl,
-      channel: options.channel ?? this.config.browser?.channel,
-      profileDir: options.profileDir ?? this.config.browser?.profileDir
+      mode: options.mode ?? this.config.browser?.mode,
+      cdpUrl: options.cdpUrl ?? this.config.browser?.cdpUrl,
+      userDataDir: options.userDataDir ?? this.config.browser?.userDataDir,
+      profileDirectory: options.profileDirectory ?? this.config.browser?.profileDirectory,
+      executablePath: options.executablePath ?? this.config.browser?.executablePath
     });
     this.browser = session.browser;
     this.contextRef = session.context;
@@ -11755,6 +12122,32 @@ var Opensteer = class _Opensteer {
     instance.snapshotCache = null;
     return instance;
   }
+  static listLocalProfiles(userDataDir) {
+    return listLocalChromeProfiles(userDataDir);
+  }
+  static fromSystemChrome(browser = {}, config = {}) {
+    const chromePaths = detectChromePaths();
+    const executablePath = browser.executablePath ?? config.browser?.executablePath ?? chromePaths.executable ?? void 0;
+    if (!executablePath) {
+      throw new Error(
+        "Chrome was not found. Pass executablePath explicitly or install Chrome in a supported location."
+      );
+    }
+    const userDataDir = browser.userDataDir ?? config.browser?.userDataDir ?? chromePaths.defaultUserDataDir;
+    const autoDetectedProfiles = listLocalChromeProfiles(userDataDir);
+    const profileDirectory = browser.profileDirectory ?? config.browser?.profileDirectory ?? autoDetectedProfiles[0]?.directory ?? "Default";
+    return new _Opensteer({
+      ...config,
+      browser: {
+        ...config.browser || {},
+        mode: "real",
+        headless: browser.headless ?? config.browser?.headless ?? true,
+        executablePath,
+        userDataDir,
+        profileDirectory
+      }
+    });
+  }
   async close() {
     this.snapshotCache = null;
     if (this.cloud) {
@@ -14245,7 +14638,7 @@ var CdpOverlayCursorRenderer = class {
         outlineColor: toProtocolRgba(pulseOutline)
       });
     });
-    await sleep6(PULSE_DELAY_MS);
+    await sleep7(PULSE_DELAY_MS);
     await this.move(point, style);
   }
   async clear() {
@@ -14369,7 +14762,7 @@ function clampAlpha(value) {
 function roundPointValue(value) {
   return Math.round(value * 100) / 100;
 }
-function sleep6(ms) {
+function sleep7(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 // Annotate the CommonJS export names for ESM import in node: