opensteer 0.6.2 → 0.6.4

package/dist/{chunk-F2VDVOJO.js → chunk-G6V2DJRN.js}

@@ -3,7 +3,6 @@ import {
   cloudNotLaunchedError,
   cloudUnsupportedMethodError,
   createCloudRuntimeState,
-  createKeychainStore,
   extractErrorMessage,
   normalizeError,
   normalizeNamespace,
@@ -11,507 +10,18 @@ import {
   resolveCloudSelection,
   resolveConfigWithEnv,
   resolveNamespace,
-  resolveNamespaceDir
-} from "./chunk-WDRMHPWL.js";
+  resolveNamespaceDir,
+  selectCloudCredential
+} from "./chunk-KPPOTU3D.js";
+import {
+  detectChromePaths,
+  expandHome,
+  listLocalChromeProfiles
+} from "./chunk-K5CL76MG.js";
 import {
   flattenExtractionDataToFieldPlan
 } from "./chunk-3H5RRIMZ.js";
 
-// src/browser/chrome.ts
-import { homedir, platform } from "os";
-import { join } from "path";
-function expandHome(p) {
-  if (p.startsWith("~/") || p === "~") {
-    return join(homedir(), p.slice(1));
-  }
-  return p;
-}
-
-// src/browser/chromium-profile.ts
-import { promisify } from "util";
-import { execFile } from "child_process";
-import { createDecipheriv, createHash, pbkdf2Sync } from "crypto";
-import {
-  cp,
-  copyFile,
-  mkdtemp,
-  readdir,
-  readFile,
-  rm
-} from "fs/promises";
-import { existsSync, statSync } from "fs";
-import { basename, dirname, join as join2 } from "path";
-import { tmpdir } from "os";
-import { chromium } from "playwright";
-var execFileAsync = promisify(execFile);
-var CHROMIUM_EPOCH_MICROS = 11644473600000000n;
-var AES_BLOCK_BYTES = 16;
-var MAC_KEY_ITERATIONS = 1003;
-var LINUX_KEY_ITERATIONS = 1;
-var KEY_LENGTH = 16;
-var KEY_SALT = "saltysalt";
-var DEFAULT_CHROMIUM_BRAND = {
-  macService: "Chrome Safe Storage",
-  macAccount: "Chrome",
-  linuxApplications: ["chrome", "google-chrome"]
-};
-var CHROMIUM_BRANDS = [
-  {
-    match: ["bravesoftware", "brave-browser"],
-    brand: {
-      macService: "Brave Safe Storage",
-      macAccount: "Brave",
-      linuxApplications: ["brave-browser", "brave"]
-    }
-  },
-  {
-    match: ["microsoft", "edge"],
-    brand: {
-      macService: "Microsoft Edge Safe Storage",
-      macAccount: "Microsoft Edge",
-      linuxApplications: ["microsoft-edge"],
-      playwrightChannel: "msedge"
-    }
-  },
-  {
-    match: ["google", "chrome beta"],
-    brand: {
-      macService: "Chrome Beta Safe Storage",
-      macAccount: "Chrome Beta",
-      linuxApplications: ["chrome-beta"],
-      playwrightChannel: "chrome-beta"
-    }
-  },
-  {
-    match: ["google", "chrome"],
-    brand: {
-      macService: "Chrome Safe Storage",
-      macAccount: "Chrome",
-      linuxApplications: ["chrome", "google-chrome"],
-      playwrightChannel: "chrome"
-    }
-  },
-  {
-    match: ["chromium"],
-    brand: {
-      macService: "Chromium Safe Storage",
-      macAccount: "Chromium",
-      linuxApplications: ["chromium"]
-    }
-  }
-];
-function directoryExists(filePath) {
-  try {
-    return statSync(filePath).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function fileExists(filePath) {
-  try {
-    return statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-function resolveCookieDbPath(profileDir) {
-  const candidates = [join2(profileDir, "Network", "Cookies"), join2(profileDir, "Cookies")];
-  for (const candidate of candidates) {
-    if (fileExists(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
-}
-async function selectProfileDirFromUserDataDir(userDataDir) {
-  const entries = await readdir(userDataDir, {
-    withFileTypes: true
-  }).catch(() => []);
-  const candidates = entries.filter((entry) => entry.isDirectory()).map((entry) => join2(userDataDir, entry.name)).filter((entryPath) => resolveCookieDbPath(entryPath));
-  return candidates;
-}
-async function resolveChromiumProfileLocation(inputPath) {
-  const expandedPath = expandHome(inputPath.trim());
-  if (!expandedPath) {
-    throw new Error("Profile path cannot be empty.");
-  }
-  if (fileExists(expandedPath) && basename(expandedPath) === "Cookies") {
-    const directParent = dirname(expandedPath);
-    const profileDir = basename(directParent) === "Network" ? dirname(directParent) : directParent;
-    const userDataDir = dirname(profileDir);
-    return {
-      userDataDir,
-      profileDir,
-      profileDirectory: basename(profileDir),
-      cookieDbPath: expandedPath,
-      localStatePath: fileExists(join2(userDataDir, "Local State")) ? join2(userDataDir, "Local State") : null
-    };
-  }
-  if (fileExists(expandedPath)) {
-    throw new Error(
-      `Unsupported profile source "${inputPath}". Pass a Chromium profile directory, user-data dir, or Cookies database path.`
-    );
-  }
-  if (!directoryExists(expandedPath)) {
-    throw new Error(
-      `Could not find a Chromium profile at "${inputPath}".`
-    );
-  }
-  const directCookieDb = resolveCookieDbPath(expandedPath);
-  if (directCookieDb) {
-    const userDataDir = dirname(expandedPath);
-    return {
-      userDataDir,
-      profileDir: expandedPath,
-      profileDirectory: basename(expandedPath),
-      cookieDbPath: directCookieDb,
-      localStatePath: fileExists(join2(userDataDir, "Local State")) ? join2(userDataDir, "Local State") : null
-    };
-  }
-  const localStatePath = join2(expandedPath, "Local State");
-  if (!fileExists(localStatePath)) {
-    throw new Error(
-      `Unsupported profile source "${inputPath}". Pass a Chromium profile directory, user-data dir, or Cookies database path.`
-    );
-  }
-  const profileDirs = await selectProfileDirFromUserDataDir(expandedPath);
-  if (profileDirs.length === 0) {
-    throw new Error(
-      `No Chromium profile with a Cookies database was found under "${inputPath}".`
-    );
-  }
-  if (profileDirs.length > 1) {
-    const candidates = profileDirs.map((entry) => basename(entry)).join(", ");
-    throw new Error(
-      `"${inputPath}" contains multiple Chromium profiles (${candidates}). Pass a specific profile directory such as "${profileDirs[0]}".`
-    );
-  }
-  const selectedProfileDir = profileDirs[0];
-  const cookieDbPath = resolveCookieDbPath(selectedProfileDir);
-  if (!cookieDbPath) {
-    throw new Error(
-      `No Chromium Cookies database was found for "${inputPath}".`
-    );
-  }
-  return {
-    userDataDir: expandedPath,
-    profileDir: selectedProfileDir,
-    profileDirectory: basename(selectedProfileDir),
-    cookieDbPath,
-    localStatePath
-  };
-}
-function resolvePersistentChromiumLaunchProfile(inputPath) {
-  const expandedPath = expandHome(inputPath.trim());
-  if (!expandedPath) {
-    return {
-      userDataDir: inputPath
-    };
-  }
-  if (fileExists(expandedPath) && basename(expandedPath) === "Cookies") {
-    const directParent = dirname(expandedPath);
-    const profileDir = basename(directParent) === "Network" ? dirname(directParent) : directParent;
-    return {
-      userDataDir: dirname(profileDir),
-      profileDirectory: basename(profileDir)
-    };
-  }
-  if (directoryExists(expandedPath) && resolveCookieDbPath(expandedPath) && fileExists(join2(dirname(expandedPath), "Local State"))) {
-    return {
-      userDataDir: dirname(expandedPath),
-      profileDirectory: basename(expandedPath)
-    };
-  }
-  return {
-    userDataDir: expandedPath
-  };
-}
-function detectChromiumBrand(location) {
-  const normalizedPath = location.userDataDir.toLowerCase();
-  for (const candidate of CHROMIUM_BRANDS) {
-    if (candidate.match.every((fragment) => normalizedPath.includes(fragment))) {
-      return candidate.brand;
-    }
-  }
-  return DEFAULT_CHROMIUM_BRAND;
-}
-async function createSqliteSnapshot(dbPath) {
-  const snapshotDir = await mkdtemp(join2(tmpdir(), "opensteer-cookie-db-"));
-  const snapshotPath = join2(snapshotDir, "Cookies");
-  await copyFile(dbPath, snapshotPath);
-  for (const suffix of ["-wal", "-shm", "-journal"]) {
-    const source = `${dbPath}${suffix}`;
-    if (!existsSync(source)) {
-      continue;
-    }
-    await copyFile(source, `${snapshotPath}${suffix}`);
-  }
-  return {
-    snapshotPath,
-    cleanup: async () => {
-      await rm(snapshotDir, { recursive: true, force: true });
-    }
-  };
-}
-async function querySqliteJson(dbPath, query) {
-  const result = await execFileAsync("sqlite3", ["-json", dbPath, query], {
-    encoding: "utf8",
-    maxBuffer: 64 * 1024 * 1024
-  });
-  const stdout = result.stdout;
-  const trimmed = stdout.trim();
-  if (!trimmed) {
-    return [];
-  }
-  return JSON.parse(trimmed);
-}
-function convertChromiumTimestampToUnixSeconds(value) {
-  if (!value || value === "0") {
-    return -1;
-  }
-  const micros = BigInt(value);
-  if (micros <= CHROMIUM_EPOCH_MICROS) {
-    return -1;
-  }
-  return Number((micros - CHROMIUM_EPOCH_MICROS) / 1000000n);
-}
-function mapChromiumSameSite(value) {
-  if (value === 2) {
-    return "Strict";
-  }
-  if (value === 0) {
-    return "None";
-  }
-  return "Lax";
-}
-function stripChromiumPadding(buffer) {
-  const paddingLength = buffer[buffer.length - 1];
-  if (paddingLength <= 0 || paddingLength > AES_BLOCK_BYTES) {
-    return buffer;
-  }
-  return buffer.subarray(0, buffer.length - paddingLength);
-}
-function stripDomainHashPrefix(buffer, hostKey) {
-  if (buffer.length < 32) {
-    return buffer;
-  }
-  const domainHash = createHash("sha256").update(hostKey, "utf8").digest();
-  if (buffer.subarray(0, 32).equals(domainHash)) {
-    return buffer.subarray(32);
-  }
-  return buffer;
-}
-function decryptChromiumAes128CbcValue(encryptedValue, key, hostKey) {
-  const ciphertext = encryptedValue.length > 3 && encryptedValue[0] === 118 && encryptedValue[1] === 49 && (encryptedValue[2] === 48 || encryptedValue[2] === 49) ? encryptedValue.subarray(3) : encryptedValue;
-  const iv = Buffer.alloc(AES_BLOCK_BYTES, " ");
-  const decipher = createDecipheriv("aes-128-cbc", key, iv);
-  const plaintext = Buffer.concat([
-    decipher.update(ciphertext),
-    decipher.final()
-  ]);
-  return stripDomainHashPrefix(stripChromiumPadding(plaintext), hostKey).toString(
-    "utf8"
-  );
-}
-function decryptChromiumAes256GcmValue(encryptedValue, key) {
-  const nonce = encryptedValue.subarray(3, 15);
-  const ciphertext = encryptedValue.subarray(15, encryptedValue.length - 16);
-  const authTag = encryptedValue.subarray(encryptedValue.length - 16);
-  const decipher = createDecipheriv("aes-256-gcm", key, nonce);
-  decipher.setAuthTag(authTag);
-  return Buffer.concat([
-    decipher.update(ciphertext),
-    decipher.final()
-  ]).toString("utf8");
-}
-async function dpapiUnprotect(buffer) {
-  const script = [
-    `$inputBytes = [Convert]::FromBase64String('${buffer.toString("base64")}')`,
-    "$plainBytes = [System.Security.Cryptography.ProtectedData]::Unprotect(",
-    "  $inputBytes,",
-    "  $null,",
-    "  [System.Security.Cryptography.DataProtectionScope]::CurrentUser",
-    ")",
-    "[Convert]::ToBase64String($plainBytes)"
-  ].join("\n");
-  const { stdout } = await execFileAsync(
-    "powershell.exe",
-    ["-NoProfile", "-NonInteractive", "-Command", script],
-    {
-      encoding: "utf8",
-      maxBuffer: 8 * 1024 * 1024
-    }
-  );
-  return Buffer.from(stdout.trim(), "base64");
-}
-async function buildChromiumDecryptor(location) {
-  if (process.platform === "darwin") {
-    const brand = detectChromiumBrand(location);
-    const keychainStore = createKeychainStore();
-    const password = keychainStore?.get(brand.macService, brand.macAccount) ?? null;
-    if (!password) {
-      throw new Error(
-        `Unable to read ${brand.macService} from macOS Keychain.`
-      );
-    }
-    const key = pbkdf2Sync(password, KEY_SALT, MAC_KEY_ITERATIONS, KEY_LENGTH, "sha1");
-    return async (row) => decryptChromiumAes128CbcValue(
-      Buffer.from(row.encrypted_value || "", "hex"),
-      key,
-      row.host_key
-    );
-  }
-  if (process.platform === "linux") {
-    const brand = detectChromiumBrand(location);
-    const keychainStore = createKeychainStore();
-    const password = keychainStore?.get(brand.macService, brand.macAccount) ?? brand.linuxApplications.map((application) => keychainStore?.get(application, application) ?? null).find(Boolean) ?? null;
-    const key = pbkdf2Sync(
-      password || "peanuts",
-      KEY_SALT,
-      LINUX_KEY_ITERATIONS,
-      KEY_LENGTH,
-      "sha1"
-    );
-    return async (row) => decryptChromiumAes128CbcValue(
-      Buffer.from(row.encrypted_value || "", "hex"),
-      key,
-      row.host_key
-    );
-  }
-  if (process.platform === "win32") {
-    if (!location.localStatePath) {
-      throw new Error(
-        `Unable to locate Chromium Local State for profile: ${location.profileDir}`
-      );
-    }
-    const localState = JSON.parse(
-      await readFile(location.localStatePath, "utf8")
-    );
-    const encryptedKeyBase64 = localState.os_crypt?.encrypted_key;
-    if (!encryptedKeyBase64) {
-      throw new Error(
-        `Local State did not include os_crypt.encrypted_key for ${location.userDataDir}`
-      );
-    }
-    const encryptedKey = Buffer.from(encryptedKeyBase64, "base64");
-    const masterKey = await dpapiUnprotect(encryptedKey.subarray(5));
-    return async (row) => {
-      const encryptedValue = Buffer.from(row.encrypted_value || "", "hex");
-      if (encryptedValue.length > 4 && encryptedValue[0] === 1 && encryptedValue[1] === 0 && encryptedValue[2] === 0 && encryptedValue[3] === 0) {
-        const decrypted = await dpapiUnprotect(encryptedValue);
-        return decrypted.toString("utf8");
-      }
-      return decryptChromiumAes256GcmValue(encryptedValue, masterKey);
-    };
-  }
-  throw new Error(
-    `Local Chromium cookie sync is not supported on ${process.platform}.`
-  );
-}
-function buildPlaywrightCookie(row, value) {
-  if (!row.name.trim()) {
-    return null;
-  }
-  if (!row.host_key.trim()) {
-    return null;
-  }
-  const expires = row.has_expires === 1 ? convertChromiumTimestampToUnixSeconds(row.expires_utc) : -1;
-  if (expires !== -1 && expires <= Math.floor(Date.now() / 1e3)) {
-    return null;
-  }
-  return {
-    name: row.name,
-    value,
-    domain: row.host_key,
-    path: row.path || "/",
-    expires,
-    httpOnly: row.is_httponly === 1,
-    secure: row.is_secure === 1,
-    sameSite: mapChromiumSameSite(row.samesite)
-  };
-}
-async function loadCookiesFromLocalProfileDir(inputPath, options = {}) {
-  const location = await resolveChromiumProfileLocation(inputPath);
-  try {
-    return await loadCookiesFromSqlite(location);
-  } catch (error) {
-    if (!isMissingSqliteBinary(error)) {
-      throw error;
-    }
-  }
-  return await loadCookiesFromBrowserSnapshot(location, options);
-}
-async function loadCookiesFromSqlite(location) {
-  const snapshot = await createSqliteSnapshot(location.cookieDbPath);
-  try {
-    const rows = await querySqliteJson(
-      snapshot.snapshotPath,
-      [
-        "SELECT",
-        "  host_key,",
-        "  name,",
-        "  value,",
-        "  hex(encrypted_value) AS encrypted_value,",
-        "  path,",
-        "  CAST(expires_utc AS TEXT) AS expires_utc,",
-        "  is_secure,",
-        "  is_httponly,",
-        "  has_expires,",
-        "  samesite",
-        "FROM cookies"
-      ].join(" ")
-    );
-    const decryptValue = await buildChromiumDecryptor(location);
-    const cookies = [];
-    for (const row of rows) {
-      let value = row.value || "";
-      if (!value && row.encrypted_value) {
-        value = await decryptValue(row);
-      }
-      const cookie = buildPlaywrightCookie(row, value);
-      if (cookie) {
-        cookies.push(cookie);
-      }
-    }
-    return cookies;
-  } finally {
-    await snapshot.cleanup();
-  }
-}
-async function loadCookiesFromBrowserSnapshot(location, options) {
-  const snapshotRootDir = await mkdtemp(join2(tmpdir(), "opensteer-profile-"));
-  const snapshotProfileDir = join2(
-    snapshotRootDir,
-    basename(location.profileDir)
-  );
-  let context = null;
-  try {
-    await cp(location.profileDir, snapshotProfileDir, {
-      recursive: true
-    });
-    if (location.localStatePath) {
-      await copyFile(location.localStatePath, join2(snapshotRootDir, "Local State"));
-    }
-    const brand = detectChromiumBrand(location);
-    const args = [`--profile-directory=${basename(snapshotProfileDir)}`];
-    context = await chromium.launchPersistentContext(snapshotRootDir, {
-      channel: brand.playwrightChannel,
-      headless: options.headless ?? true,
-      timeout: options.timeout ?? 12e4,
-      args
-    });
-    return await context.cookies();
-  } finally {
-    await context?.close().catch(() => void 0);
-    await rm(snapshotRootDir, { recursive: true, force: true });
-  }
-}
-function isMissingSqliteBinary(error) {
-  return Boolean(
-    error && typeof error === "object" && "code" in error && error.code === "ENOENT"
-  );
-}
-
 // src/navigation.ts
 var DEFAULT_TIMEOUT = 3e4;
 var DEFAULT_SETTLE_MS = 750;
@@ -5293,7 +4803,7 @@ async function closeTab(context, activePage, index) {
 }
 
 // src/actions/cookies.ts
-import { readFile as readFile2, writeFile } from "fs/promises";
+import { readFile, writeFile } from "fs/promises";
 async function getCookies(context, url) {
   return context.cookies(url ? [url] : void 0);
 }
@@ -5308,7 +4818,7 @@ async function exportCookies(context, filePath, url) {
   await writeFile(filePath, JSON.stringify(cookies, null, 2), "utf-8");
 }
 async function importCookies(context, filePath) {
-  const raw = await readFile2(filePath, "utf-8");
+  const raw = await readFile(filePath, "utf-8");
   const cookies = JSON.parse(raw);
   await context.addCookies(cookies);
 }
@@ -8001,11 +7511,17 @@ function sleep4(ms) {
 }
 
 // src/opensteer.ts
-import { createHash as createHash2, randomUUID } from "crypto";
+import { createHash, randomUUID } from "crypto";
 
 // src/browser/pool.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { copyFile, cp, mkdir, mkdtemp, rm } from "fs/promises";
+import { createServer } from "net";
+import { tmpdir } from "os";
+import { join } from "path";
 import {
-  chromium as chromium2
+  chromium
 } from "playwright";
 
 // src/browser/cdp-proxy.ts
@@ -8348,132 +7864,184 @@ function errorMessage(error) {
 // 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 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 chromium2.connectOverCDP(proxyWsUrl, {
+      cdpProxy = new CDPProxy(browserWsUrl, targets[0].id);
+      const proxyWsUrl = await cdpProxy.start();
+      browser = await 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}`);
+  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."
+      );
     }
-    const context = await chromium2.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 sourceUserDataDir = expandHome(
+      options.userDataDir ?? chromePaths.defaultUserDataDir
     );
-    const browser = context.browser();
-    if (!browser) {
-      await context.close().catch(() => void 0);
-      throw new Error("Persistent browser launch did not expose a browser instance.");
-    }
-    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 chromium2.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 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 = 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 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 rm(tempUserDataDir, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+      throw error;
+    }
   }
   async launchSandbox(options) {
-    const browser = await chromium2.launch({
-      headless: options.headless ?? this.defaults.headless,
+    const browser = await 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
@@ -8481,10 +8049,268 @@ 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 sleep5(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 sleep5(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 = 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 mkdtemp(
+    join(tmpdir(), "opensteer-real-browser-")
+  );
+  const sourceProfileDir = join(resolvedUserDataDir, profileDirectory);
+  const targetProfileDir = join(tempUserDataDir, profileDirectory);
+  if (existsSync(sourceProfileDir)) {
+    await cp(sourceProfileDir, targetProfileDir, {
+      recursive: true
+    });
+  } else {
+    await mkdir(targetProfileDir, {
+      recursive: true
+    });
+  }
+  const localStatePath = join(resolvedUserDataDir, "Local State");
+  if (existsSync(localStatePath)) {
+    await copyFile(localStatePath, 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 = 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 sleep5(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 // src/action-wait.ts
 var ROBUST_PROFILE = {
@@ -8679,7 +8505,7 @@ var AdaptiveNetworkTracker = class {
         this.idleSince = 0;
       }
       const remaining = Math.max(1, options.deadline - now);
-      await sleep5(Math.min(NETWORK_POLL_MS, remaining));
+      await sleep6(Math.min(NETWORK_POLL_MS, remaining));
     }
   }
   handleRequestStarted = (request) => {
@@ -8724,7 +8550,7 @@ var AdaptiveNetworkTracker = class {
     return false;
   }
 };
-async function sleep5(ms) {
+async function sleep6(ms) {
   await new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -10081,30 +9907,20 @@ var Opensteer = class _Opensteer {
     this.pool = new BrowserPool(resolved.browser || {});
     if (cloudSelection.cloud) {
       const cloudConfig = resolved.cloud && typeof resolved.cloud === "object" ? resolved.cloud : void 0;
-      const apiKey = cloudConfig?.apiKey?.trim();
-      const accessToken = cloudConfig?.accessToken?.trim();
-      if (apiKey && accessToken) {
-        throw new Error(
-          "Cloud mode cannot use both cloud.apiKey and cloud.accessToken. Set only one credential."
-        );
-      }
-      let credential = "";
-      let authScheme = cloudConfig?.authScheme ?? "api-key";
-      if (accessToken) {
-        credential = accessToken;
-        authScheme = "bearer";
-      } else if (apiKey) {
-        credential = apiKey;
-      }
+      const credential = selectCloudCredential({
+        apiKey: cloudConfig?.apiKey,
+        accessToken: cloudConfig?.accessToken,
+        authScheme: cloudConfig?.authScheme
+      });
       if (!credential) {
         throw new Error(
           "Cloud mode requires credentials via cloud.apiKey/cloud.accessToken or OPENSTEER_API_KEY/OPENSTEER_ACCESS_TOKEN."
         );
       }
       this.cloud = createCloudRuntimeState(
-        credential,
+        credential.token,
         cloudConfig?.baseUrl,
-        authScheme
+        credential.authScheme
       );
     } else {
       this.cloud = null;
@@ -10425,9 +10241,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;
@@ -10458,6 +10276,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) {
@@ -12490,7 +12334,7 @@ var Opensteer = class _Opensteer {
   }
   resolveStorageKey(description) {
     if (!description) return null;
-    return createHash2("sha256").update(description).digest("hex").slice(0, 16);
+    return createHash("sha256").update(description).digest("hex").slice(0, 16);
   }
   normalizePath(path3) {
     return sanitizeElementPath(path3);
@@ -12562,7 +12406,7 @@ function normalizeExtractSource(source) {
 }
 function computeSchemaHash(schema) {
   const stable = stableStringify(schema);
-  return createHash2("sha256").update(stable).digest("hex");
+  return createHash("sha256").update(stable).digest("hex");
 }
 function buildPathMap(fields) {
   const out = {};
@@ -12822,8 +12666,6 @@ function buildLocalRunId(namespace) {
 }
 
 export {
-  expandHome,
-  loadCookiesFromLocalProfileDir,
   waitForVisualStability,
   createEmptyRegistry,
   LocalSelectorStorage,