opensteer 0.6.6 → 0.6.8

package/dist/cli/profile.cjs

@@ -425,7 +425,7 @@ __export(profile_exports, {
 });
 module.exports = __toCommonJS(profile_exports);
 var import_node_path4 = __toESM(require("path"), 1);
-var import_promises4 = require("readline/promises");
+var import_promises5 = require("readline/promises");
 
 // src/config.ts
 var import_fs = __toESM(require("fs"), 1);
@@ -1324,11 +1324,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
@@ -1821,18 +1818,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";
@@ -1882,11 +2143,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);
@@ -1894,8 +2157,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);
@@ -1944,10 +2207,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",
@@ -1955,7 +2219,7 @@ var BrowserPool = class {
       this.defaults.headless
     );
     const launchArgs = buildRealBrowserLaunchArgs({
-      userDataDir: tempUserDataDir,
+      userDataDir: persistentProfile.userDataDir,
       profileDirectory,
       debugPort,
       headless
@@ -1975,24 +2239,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;
     }
   }
@@ -2015,8 +2277,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) {
@@ -2028,77 +2289,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();
@@ -2112,19 +2327,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) {
@@ -2204,38 +2411,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");
@@ -7053,7 +7234,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);
 }
@@ -7065,10 +7246,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);
 }
@@ -7819,31 +8000,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) {
@@ -7856,17 +8037,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,
@@ -8735,7 +8916,96 @@ function stripPositionClauses2(path7) {
 }
 
 // src/cloud/contracts.ts
+var cloudActionMethods = [
+  "goto",
+  "snapshot",
+  "screenshot",
+  "state",
+  "click",
+  "dblclick",
+  "rightclick",
+  "hover",
+  "input",
+  "select",
+  "scroll",
+  "tabs",
+  "newTab",
+  "switchTab",
+  "closeTab",
+  "getCookies",
+  "setCookie",
+  "clearCookies",
+  "pressKey",
+  "type",
+  "getElementText",
+  "getElementValue",
+  "getElementAttributes",
+  "getElementBoundingBox",
+  "getHtml",
+  "getTitle",
+  "uploadFile",
+  "exportCookies",
+  "importCookies",
+  "waitForText",
+  "extract",
+  "extractFromPlan",
+  "clearCache"
+];
+var cloudErrorCodes = [
+  "CLOUD_AUTH_FAILED",
+  "CLOUD_SESSION_NOT_FOUND",
+  "CLOUD_SESSION_CLOSED",
+  "CLOUD_UNSUPPORTED_METHOD",
+  "CLOUD_INVALID_REQUEST",
+  "CLOUD_MODEL_NOT_ALLOWED",
+  "CLOUD_ACTION_FAILED",
+  "CLOUD_CAPACITY_EXHAUSTED",
+  "CLOUD_RUNTIME_UNAVAILABLE",
+  "CLOUD_RUNTIME_MISMATCH",
+  "CLOUD_SESSION_STALE",
+  "CLOUD_CONTROL_PLANE_ERROR",
+  "CLOUD_CONTRACT_MISMATCH",
+  "CLOUD_PROXY_UNAVAILABLE",
+  "CLOUD_PROXY_REQUIRED",
+  "CLOUD_BILLING_LIMIT_REACHED",
+  "CLOUD_RATE_LIMITED",
+  "CLOUD_BROWSER_PROFILE_NOT_FOUND",
+  "CLOUD_BROWSER_PROFILE_BUSY",
+  "CLOUD_BROWSER_PROFILE_DISABLED",
+  "CLOUD_BROWSER_PROFILE_PROXY_UNAVAILABLE",
+  "CLOUD_BROWSER_PROFILE_SYNC_FAILED",
+  "CLOUD_INTERNAL"
+];
+var cloudSessionStatuses = [
+  "provisioning",
+  "active",
+  "closing",
+  "closed",
+  "failed"
+];
 var cloudSessionContractVersion = "v3";
+var cloudSessionSourceTypes = [
+  "agent-thread",
+  "agent-run",
+  "project-agent-run",
+  "local-cloud",
+  "manual"
+];
+var cloudActionMethodSet = new Set(cloudActionMethods);
+var cloudErrorCodeSet = new Set(cloudErrorCodes);
+var cloudSessionSourceTypeSet = new Set(
+  cloudSessionSourceTypes
+);
+var cloudSessionStatusSet = new Set(cloudSessionStatuses);
+function isCloudErrorCode(value) {
+  return typeof value === "string" && cloudErrorCodeSet.has(value);
+}
+function isCloudSessionSourceType(value) {
+  return typeof value === "string" && cloudSessionSourceTypeSet.has(value);
+}
+function isCloudSessionStatus(value) {
+  return typeof value === "string" && cloudSessionStatusSet.has(value);
+}
 
 // src/cloud/action-ws-client.ts
 var import_ws2 = __toESM(require("ws"), 1);
@@ -8766,6 +9036,13 @@ function cloudNotLaunchedError() {
   );
 }
 
+// src/cloud/ws-url.ts
+function withTokenQuery(wsUrl, token) {
+  const url = new URL(wsUrl);
+  url.searchParams.set("token", token);
+  return url.toString();
+}
+
 // src/cloud/action-ws-client.ts
 var ActionWsClient = class _ActionWsClient {
   ws;
@@ -8894,11 +9171,6 @@ function rawDataToUtf8(raw) {
   if (Array.isArray(raw)) return Buffer.concat(raw).toString("utf8");
   return raw.toString("utf8");
 }
-function withTokenQuery(wsUrl, token) {
-  const url = new URL(wsUrl);
-  url.searchParams.set("token", token);
-  return url.toString();
-}
 
 // src/cloud/local-cache-sync.ts
 var import_fs4 = __toESM(require("fs"), 1);
@@ -9038,7 +9310,7 @@ function dedupeNewest(entries) {
 var import_playwright2 = require("playwright");
 var CloudCdpClient = class {
   async connect(args) {
-    const endpoint = withTokenQuery2(args.wsUrl, args.token);
+    const endpoint = withTokenQuery(args.wsUrl, args.token);
     let browser;
     try {
       browser = await import_playwright2.chromium.connectOverCDP(endpoint);
@@ -9067,7 +9339,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 };
       }
@@ -9078,7 +9350,7 @@ function selectPreferredContextPage(browser, contexts) {
   }
   return aboutBlankCandidate;
 }
-function safePageUrl(page) {
+function safePageUrl2(page) {
   try {
     return page.url();
   } catch {
@@ -9090,11 +9362,6 @@ function isInternalOrEmptyUrl(url) {
   if (url === "about:blank") return true;
   return url.startsWith("chrome://") || url.startsWith("devtools://") || url.startsWith("edge://");
 }
-function withTokenQuery2(wsUrl, token) {
-  const url = new URL(wsUrl);
-  url.searchParams.set("token", token);
-  return url.toString();
-}
 
 // src/utils/strip-trailing-slashes.ts
 function stripTrailingSlashes(value) {
@@ -9131,10 +9398,7 @@ async function parseCloudHttpError(response) {
   return new OpensteerCloudError(code, message, response.status, body?.details);
 }
 function toCloudErrorCode(code) {
-  if (code === "CLOUD_AUTH_FAILED" || code === "CLOUD_SESSION_NOT_FOUND" || code === "CLOUD_SESSION_CLOSED" || code === "CLOUD_UNSUPPORTED_METHOD" || code === "CLOUD_INVALID_REQUEST" || code === "CLOUD_MODEL_NOT_ALLOWED" || code === "CLOUD_ACTION_FAILED" || code === "CLOUD_INTERNAL" || code === "CLOUD_CAPACITY_EXHAUSTED" || code === "CLOUD_RUNTIME_UNAVAILABLE" || code === "CLOUD_RUNTIME_MISMATCH" || code === "CLOUD_SESSION_STALE" || code === "CLOUD_CONTRACT_MISMATCH" || code === "CLOUD_CONTROL_PLANE_ERROR" || code === "CLOUD_PROXY_UNAVAILABLE" || code === "CLOUD_PROXY_REQUIRED" || code === "CLOUD_BILLING_LIMIT_REACHED" || code === "CLOUD_RATE_LIMITED" || code === "CLOUD_BROWSER_PROFILE_NOT_FOUND" || code === "CLOUD_BROWSER_PROFILE_BUSY" || code === "CLOUD_BROWSER_PROFILE_DISABLED" || code === "CLOUD_BROWSER_PROFILE_PROXY_UNAVAILABLE" || code === "CLOUD_BROWSER_PROFILE_SYNC_FAILED") {
-    return code;
-  }
-  return "CLOUD_TRANSPORT_ERROR";
+  return isCloudErrorCode(code) ? code : "CLOUD_TRANSPORT_ERROR";
 }
 
 // src/cloud/session-client.ts
@@ -9241,7 +9505,12 @@ function parseCreateResponse(body, status) {
       status,
       "cloudSession"
     ),
-    state: requireString(cloudSessionRoot, "state", status, "cloudSession"),
+    state: requireSessionStatus(
+      cloudSessionRoot,
+      "state",
+      status,
+      "cloudSession"
+    ),
     createdAt: requireNumber(cloudSessionRoot, "createdAt", status, "cloudSession"),
     sourceType: requireSourceType(cloudSessionRoot, "sourceType", status, "cloudSession"),
     sourceRef: optionalString(cloudSessionRoot, "sourceRef", status, "cloudSession"),
@@ -9329,7 +9598,7 @@ function optionalNumber(source, field, status, parent) {
 }
 function requireSourceType(source, field, status, parent) {
   const value = source[field];
-  if (value === "agent-thread" || value === "agent-run" || value === "local-cloud" || value === "manual") {
+  if (isCloudSessionSourceType(value)) {
     return value;
   }
   throw new OpensteerCloudError(
@@ -9337,13 +9606,30 @@ function requireSourceType(source, field, status, parent) {
     `Invalid cloud session create response: ${formatFieldPath(
       field,
       parent
-    )} must be one of "agent-thread", "agent-run", "local-cloud", or "manual".`,
+    )} must be one of ${formatAllowedValues(cloudSessionSourceTypes)}.`,
+    status
+  );
+}
+function requireSessionStatus(source, field, status, parent) {
+  const value = source[field];
+  if (isCloudSessionStatus(value)) {
+    return value;
+  }
+  throw new OpensteerCloudError(
+    "CLOUD_CONTRACT_MISMATCH",
+    `Invalid cloud session create response: ${formatFieldPath(
+      field,
+      parent
+    )} must be one of ${formatAllowedValues(cloudSessionStatuses)}.`,
     status
   );
 }
 function formatFieldPath(field, parent) {
   return parent ? `"${parent}.${field}"` : `"${field}"`;
 }
+function formatAllowedValues(values) {
+  return values.map((value) => `"${value}"`).join(", ");
+}
 function zeroImportResponse() {
   return {
     imported: 0,
@@ -14498,8 +14784,8 @@ function buildLocalRunId(namespace) {
 // src/browser/chromium-profile.ts
 var import_node_util = require("util");
 var import_node_child_process3 = require("child_process");
-var import_node_crypto = require("crypto");
-var import_promises3 = require("fs/promises");
+var import_node_crypto2 = require("crypto");
+var import_promises4 = require("fs/promises");
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
 var import_node_os2 = require("os");
@@ -14724,7 +15010,7 @@ function resolveCookieDbPath(profileDir) {
   return null;
 }
 async function selectProfileDirFromUserDataDir(userDataDir) {
-  const entries = await (0, import_promises3.readdir)(userDataDir, {
+  const entries = await (0, import_promises4.readdir)(userDataDir, {
     withFileTypes: true
   }).catch(() => []);
   const candidates = entries.filter((entry) => entry.isDirectory()).map((entry) => (0, import_node_path2.join)(userDataDir, entry.name)).filter((entryPath) => resolveCookieDbPath(entryPath));
@@ -14811,20 +15097,20 @@ function detectChromiumBrand(location) {
   return DEFAULT_CHROMIUM_BRAND;
 }
 async function createSqliteSnapshot(dbPath) {
-  const snapshotDir = await (0, import_promises3.mkdtemp)((0, import_node_path2.join)((0, import_node_os2.tmpdir)(), "opensteer-cookie-db-"));
+  const snapshotDir = await (0, import_promises4.mkdtemp)((0, import_node_path2.join)((0, import_node_os2.tmpdir)(), "opensteer-cookie-db-"));
   const snapshotPath = (0, import_node_path2.join)(snapshotDir, "Cookies");
-  await (0, import_promises3.copyFile)(dbPath, snapshotPath);
+  await (0, import_promises4.copyFile)(dbPath, snapshotPath);
   for (const suffix of ["-wal", "-shm", "-journal"]) {
     const source = `${dbPath}${suffix}`;
     if (!(0, import_node_fs2.existsSync)(source)) {
       continue;
     }
-    await (0, import_promises3.copyFile)(source, `${snapshotPath}${suffix}`);
+    await (0, import_promises4.copyFile)(source, `${snapshotPath}${suffix}`);
   }
   return {
     snapshotPath,
     cleanup: async () => {
-      await (0, import_promises3.rm)(snapshotDir, { recursive: true, force: true });
+      await (0, import_promises4.rm)(snapshotDir, { recursive: true, force: true });
     }
   };
 }
@@ -14870,7 +15156,7 @@ function stripDomainHashPrefix(buffer, hostKey) {
   if (buffer.length < 32) {
     return buffer;
   }
-  const domainHash = (0, import_node_crypto.createHash)("sha256").update(hostKey, "utf8").digest();
+  const domainHash = (0, import_node_crypto2.createHash)("sha256").update(hostKey, "utf8").digest();
   if (buffer.subarray(0, 32).equals(domainHash)) {
     return buffer.subarray(32);
   }
@@ -14879,7 +15165,7 @@ function stripDomainHashPrefix(buffer, hostKey) {
 function decryptChromiumAes128CbcValue(encryptedValue, key, hostKey) {
   const ciphertext = encryptedValue.length > 3 && encryptedValue[0] === 118 && encryptedValue[1] === 49 && (encryptedValue[2] === 48 || encryptedValue[2] === 49) ? encryptedValue.subarray(3) : encryptedValue;
   const iv = Buffer.alloc(AES_BLOCK_BYTES, " ");
-  const decipher = (0, import_node_crypto.createDecipheriv)("aes-128-cbc", key, iv);
+  const decipher = (0, import_node_crypto2.createDecipheriv)("aes-128-cbc", key, iv);
   const plaintext = Buffer.concat([
     decipher.update(ciphertext),
     decipher.final()
@@ -14892,7 +15178,7 @@ function decryptChromiumAes256GcmValue(encryptedValue, key) {
   const nonce = encryptedValue.subarray(3, 15);
   const ciphertext = encryptedValue.subarray(15, encryptedValue.length - 16);
   const authTag = encryptedValue.subarray(encryptedValue.length - 16);
-  const decipher = (0, import_node_crypto.createDecipheriv)("aes-256-gcm", key, nonce);
+  const decipher = (0, import_node_crypto2.createDecipheriv)("aes-256-gcm", key, nonce);
   decipher.setAuthTag(authTag);
   return Buffer.concat([
     decipher.update(ciphertext),
@@ -14929,7 +15215,7 @@ async function buildChromiumDecryptor(location) {
         `Unable to read ${brand.macService} from macOS Keychain.`
       );
     }
-    const key = (0, import_node_crypto.pbkdf2Sync)(password, KEY_SALT, MAC_KEY_ITERATIONS, KEY_LENGTH, "sha1");
+    const key = (0, import_node_crypto2.pbkdf2Sync)(password, KEY_SALT, MAC_KEY_ITERATIONS, KEY_LENGTH, "sha1");
     return async (row) => decryptChromiumAes128CbcValue(
       Buffer.from(row.encrypted_value || "", "hex"),
       key,
@@ -14940,7 +15226,7 @@ async function buildChromiumDecryptor(location) {
     const brand = detectChromiumBrand(location);
     const keychainStore = createKeychainStore();
     const password = keychainStore?.get(brand.macService, brand.macAccount) ?? brand.linuxApplications.map((application) => keychainStore?.get(application, application) ?? null).find(Boolean) ?? null;
-    const key = (0, import_node_crypto.pbkdf2Sync)(
+    const key = (0, import_node_crypto2.pbkdf2Sync)(
       password || "peanuts",
       KEY_SALT,
       LINUX_KEY_ITERATIONS,
@@ -14960,7 +15246,7 @@ async function buildChromiumDecryptor(location) {
       );
     }
     const localState = JSON.parse(
-      await (0, import_promises3.readFile)(location.localStatePath, "utf8")
+      await (0, import_promises4.readFile)(location.localStatePath, "utf8")
     );
     const encryptedKeyBase64 = localState.os_crypt?.encrypted_key;
     if (!encryptedKeyBase64) {
@@ -15054,18 +15340,18 @@ async function loadCookiesFromSqlite(location) {
   }
 }
 async function loadCookiesFromBrowserSnapshot(location, options) {
-  const snapshotRootDir = await (0, import_promises3.mkdtemp)((0, import_node_path2.join)((0, import_node_os2.tmpdir)(), "opensteer-profile-"));
+  const snapshotRootDir = await (0, import_promises4.mkdtemp)((0, import_node_path2.join)((0, import_node_os2.tmpdir)(), "opensteer-profile-"));
   const snapshotProfileDir = (0, import_node_path2.join)(
     snapshotRootDir,
     (0, import_node_path2.basename)(location.profileDir)
   );
   let context = null;
   try {
-    await (0, import_promises3.cp)(location.profileDir, snapshotProfileDir, {
+    await (0, import_promises4.cp)(location.profileDir, snapshotProfileDir, {
       recursive: true
     });
     if (location.localStatePath) {
-      await (0, import_promises3.copyFile)(location.localStatePath, (0, import_node_path2.join)(snapshotRootDir, "Local State"));
+      await (0, import_promises4.copyFile)(location.localStatePath, (0, import_node_path2.join)(snapshotRootDir, "Local State"));
     }
     const brand = detectChromiumBrand(location);
     const args = [`--profile-directory=${(0, import_node_path2.basename)(snapshotProfileDir)}`];
@@ -15078,7 +15364,7 @@ async function loadCookiesFromBrowserSnapshot(location, options) {
     return await context.cookies();
   } finally {
     await context?.close().catch(() => void 0);
-    await (0, import_promises3.rm)(snapshotRootDir, { recursive: true, force: true });
+    await (0, import_promises4.rm)(snapshotRootDir, { recursive: true, force: true });
   }
 }
 function isMissingSqliteBinary(error) {
@@ -15321,7 +15607,7 @@ function toResolvedCloudCredential(source, credential) {
 }
 
 // src/auth/machine-credential-store.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 var import_node_fs3 = __toESM(require("fs"), 1);
 var import_node_os3 = __toESM(require("os"), 1);
 var import_node_path3 = __toESM(require("path"), 1);
@@ -15469,7 +15755,7 @@ function createMachineCredentialStore(options = {}) {
 }
 function resolveCredentialSlot(authDir, target) {
   const normalizedBaseUrl = normalizeCredentialUrl(target.baseUrl);
-  const storageKey = (0, import_node_crypto2.createHash)("sha256").update(normalizedBaseUrl).digest("hex").slice(0, 24);
+  const storageKey = (0, import_node_crypto3.createHash)("sha256").update(normalizedBaseUrl).digest("hex").slice(0, 24);
   return {
     keychainAccount: `${KEYCHAIN_ACCOUNT_PREFIX}${storageKey}`,
     metadataPath: import_node_path3.default.join(authDir, `cli-login.${storageKey}.json`),
@@ -16394,7 +16680,7 @@ function createDefaultDeps() {
     loadLocalProfileCookies: (profileDir, options) => loadCookiesFromLocalProfileDir(profileDir, options),
     isInteractive: () => Boolean(process.stdin.isTTY && process.stdout.isTTY),
     confirm: async (message) => {
-      const rl = (0, import_promises4.createInterface)({
+      const rl = (0, import_promises5.createInterface)({
         input: process.stdin,
         output: process.stderr
       });