unbrowse 3.8.0 → 4.0.0

package/dist/cli.js

@@ -31,7 +31,7 @@ var __promiseAll = (args) => Promise.all(args);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../src/build-info.generated.ts
-var BUILD_RELEASE_VERSION = "3.8.0", BUILD_GIT_SHA = "81ae16d04a8c", BUILD_CODE_HASH = "5d9ebf619c61", BUILD_RELEASE_MANIFEST_BASE64 = "eyJzY2hlbWFfdmVyc2lvbiI6MSwicmVsZWFzZV92ZXJzaW9uIjoiMy44LjAiLCJnaXRfc2hhIjoiODFhZTE2ZDA0YThjIiwiY29kZV9oYXNoIjoiNWQ5ZWJmNjE5YzYxIiwidHJhY2VfdmVyc2lvbiI6IjVkOWViZjYxOWM2MUA4MWFlMTZkMDRhOGMiLCJpc3N1ZWRfYXQiOiIyMDI2LTA0LTI1VDAxOjAyOjAwLjEwNloifQ", BUILD_RELEASE_MANIFEST_SIGNATURE = "rPotXSdWbu75TR3RgjPFf-9Gdc9qwUidjazsSGRYR8Y", BUILD_DEFAULT_BACKEND_URL = "https://beta-api.unbrowse.ai";
+var BUILD_RELEASE_VERSION = "4.0.0", BUILD_GIT_SHA = "d08d50cd0432", BUILD_CODE_HASH = "5d9ebf619c61", BUILD_RELEASE_MANIFEST_BASE64 = "eyJzY2hlbWFfdmVyc2lvbiI6MSwicmVsZWFzZV92ZXJzaW9uIjoiNC4wLjAiLCJnaXRfc2hhIjoiZDA4ZDUwY2QwNDMyIiwiY29kZV9oYXNoIjoiNWQ5ZWJmNjE5YzYxIiwidHJhY2VfdmVyc2lvbiI6IjVkOWViZjYxOWM2MUBkMDhkNTBjZDA0MzIiLCJpc3N1ZWRfYXQiOiIyMDI2LTA0LTI1VDAyOjM5OjQxLjc4OVoifQ", BUILD_RELEASE_MANIFEST_SIGNATURE = "ICQ4NQIuyX0CMPhz1VoclQwk4PHMivS0ddVrr1ZTFgc", BUILD_DEFAULT_BACKEND_URL = "https://beta-api.unbrowse.ai";
 
 // ../../src/version.ts
 import { createHash } from "crypto";
@@ -530,11 +530,6 @@ function getRegistrableDomain(hostname2) {
   }
   return parts.slice(-2).join(".");
 }
-function isDomainMatch(cookieDomain, targetDomain) {
-  const c = cookieDomain.replace(/^\./, "").toLowerCase();
-  const t = targetDomain.replace(/^\./, "").toLowerCase();
-  return t === c || t.endsWith("." + c);
-}
 var CC_TLDS, GEO_TLD_SUFFIXES;
 var init_domain = __esm(() => {
   CC_TLDS = new Set([
@@ -640,7 +635,6 @@ var init_logger = __esm(() => {
 // ../../src/kuri/client.ts
 import { execFileSync as execFileSync2, spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync9 } from "node:fs";
-import net from "node:net";
 import path5 from "node:path";
 function createBrokerState(port = KURI_DEFAULT_PORT) {
   return {
@@ -653,39 +647,6 @@ function createBrokerState(port = KURI_DEFAULT_PORT) {
     requestedPort: port
   };
 }
-function brokerCacheKey(port) {
-  return port === undefined ? "default" : `port:${port}`;
-}
-function rememberBrokerClient(client, state) {
-  brokerClients.set(brokerCacheKey(state.requestedPort), client);
-  brokerClients.set(brokerCacheKey(state.port), client);
-}
-function forgetBrokerClient(state) {
-  brokerClients.delete(brokerCacheKey(state.requestedPort));
-  brokerClients.delete(brokerCacheKey(state.port));
-}
-function envFlag(value) {
-  return value === "1" || value?.toLowerCase() === "true";
-}
-function falseyEnv(value) {
-  if (!value)
-    return false;
-  const normalized = value.trim().toLowerCase();
-  return normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off";
-}
-function resolveKuriLaunchConfig(env = process.env) {
-  const explicitHeadless = env.KURI_HEADLESS ?? env.HEADLESS;
-  const headless = explicitHeadless !== undefined ? envFlag(explicitHeadless) : process.platform === "linux" && !env.DISPLAY;
-  const cleanRoom = envFlag(env.UNBROWSE_LOCAL_ONLY) || envFlag(env.KURI_CLEAN_ROOM);
-  const browserCookieOptOut = falseyEnv(env.UNBROWSE_IMPORT_BROWSER_COOKIES);
-  const explicitAttach = envFlag(env.KURI_ATTACH_EXISTING_CHROME ?? env.UNBROWSE_ATTACH_EXISTING_CHROME);
-  const disableCdpAttach = envFlag(env.KURI_DISABLE_CDP_ATTACH);
-  const canAttachToExistingChrome = !headless && !disableCdpAttach && !cleanRoom;
-  return {
-    headless,
-    attachToExistingChrome: canAttachToExistingChrome && (explicitAttach || browserCookieOptOut)
-  };
-}
 function kuriBinaryName() {
   return process.platform === "win32" ? "kuri.exe" : "kuri";
 }
@@ -744,679 +705,13 @@ function getKuriBinaryCandidates() {
   addCandidate(candidates, resolveBinaryOnPath("kuri"));
   return candidates;
 }
-async function discoverCdpPort(state) {
-  const portsToTry = [9222, 9223, 9224, 9225];
-  for (const port of portsToTry) {
-    try {
-      const res = await fetch(`http://127.0.0.1:${port}/json/version`, {
-        signal: AbortSignal.timeout(500)
-      });
-      if (res.ok) {
-        state.cdpPort = port;
-        kuriCdpPort = port;
-        log("kuri", `found Chrome CDP on port ${port}`);
-        return;
-      }
-    } catch {}
-  }
-  log("kuri", "could not discover CDP port — tab discovery may fail");
-}
-async function findFreeCdpPort() {
-  for (let port = 9222;port < 9230; port++) {
-    try {
-      await fetch(`http://127.0.0.1:${port}/json/version`, {
-        signal: AbortSignal.timeout(300)
-      });
-    } catch {
-      return port;
-    }
-  }
-  return 9222;
-}
-async function isKuriHealthyOnPort(port) {
-  try {
-    const health = await fetch(`http://127.0.0.1:${port}/health`, {
-      signal: AbortSignal.timeout(1000)
-    });
-    return health.ok;
-  } catch {
-    return false;
-  }
-}
-async function isChromeCdpAvailable(port) {
-  try {
-    const res = await fetch(`http://127.0.0.1:${port}/json/version`, {
-      signal: AbortSignal.timeout(1000)
-    });
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
-async function listRegisteredTabs(state) {
-  try {
-    const tabs = await kuriGet(state, "/tabs");
-    if (!Array.isArray(tabs))
-      return [];
-    return tabs.filter((tab) => typeof tab?.id === "string").map((tab) => ({ id: tab.id, url: tab.url ?? "", title: tab.title }));
-  } catch {
-    return [];
-  }
-}
-async function waitForChromeCdpReady(state, timeoutMs = KURI_CDP_READY_TIMEOUT_MS) {
-  if (typeof state.cdpPort !== "number")
-    return false;
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (await isChromeCdpAvailable(state.cdpPort))
-      return true;
-    await new Promise((resolve) => setTimeout(resolve, KURI_CDP_POLL_INTERVAL_MS));
-  }
-  return false;
-}
-function shouldReuseManagedChrome(launchConfig, state, managedChromeAvailable) {
-  return !launchConfig.attachToExistingChrome && state.managedChrome === true && typeof state.cdpPort === "number" && managedChromeAvailable;
-}
-async function isTcpPortOpen(port, timeoutMs = 400) {
-  return await new Promise((resolve) => {
-    const socket = net.createConnection({ host: "127.0.0.1", port });
-    const finish = (open) => {
-      socket.removeAllListeners();
-      socket.destroy();
-      resolve(open);
-    };
-    socket.setTimeout(timeoutMs);
-    socket.once("connect", () => finish(true));
-    socket.once("timeout", () => finish(false));
-    socket.once("error", () => finish(false));
-  });
-}
-async function resolveKuriPort(preferredPort, deps = {}) {
-  const isHealthyPort = deps.isHealthyPort ?? isKuriHealthyOnPort;
-  const isPortOpen = deps.isPortOpen ?? isTcpPortOpen;
-  const searchLimit = deps.searchLimit ?? KURI_PORT_SEARCH_LIMIT;
-  if (await isHealthyPort(preferredPort))
-    return preferredPort;
-  if (!await isPortOpen(preferredPort))
-    return preferredPort;
-  for (let candidate = preferredPort + 1;candidate <= preferredPort + searchLimit; candidate++) {
-    if (await isHealthyPort(candidate))
-      return candidate;
-    if (!await isPortOpen(candidate))
-      return candidate;
-  }
-  return preferredPort;
-}
-async function ensureUserChromeRunning(state) {
-  for (const port2 of [9222, 9223, 9224, 9225]) {
-    try {
-      const res = await fetch(`http://127.0.0.1:${port2}/json/version`, { signal: AbortSignal.timeout(500) });
-      if (res.ok) {
-        state.cdpPort = port2;
-        return;
-      }
-    } catch {}
-  }
-  const chromePaths = {
-    darwin: "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
-    linux: "google-chrome",
-    win32: "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe"
-  };
-  const chromeBin = chromePaths[process.platform];
-  if (!chromeBin)
-    return;
-  const port = await findFreeCdpPort();
-  state.cdpPort = port;
-  log("kuri", `launching user Chrome with CDP on port ${port}`);
-  try {
-    const child = spawn2(chromeBin, [
-      `--remote-debugging-port=${port}`,
-      "--no-first-run",
-      "--no-default-browser-check"
-    ], {
-      stdio: "ignore",
-      detached: true
-    });
-    child.unref();
-    const deadline = Date.now() + 8000;
-    while (Date.now() < deadline) {
-      try {
-        const res = await fetch(`http://127.0.0.1:${port}/json/version`, { signal: AbortSignal.timeout(500) });
-        if (res.ok) {
-          log("kuri", `user Chrome ready with CDP on port ${port}`);
-          return;
-        }
-      } catch {}
-      await new Promise((r) => setTimeout(r, 300));
-    }
-    log("kuri", "user Chrome launched but CDP not responding — Kuri will launch managed Chrome");
-    state.cdpPort = null;
-  } catch (err) {
-    log("kuri", `failed to launch user Chrome: ${err instanceof Error ? err.message : err}`);
-    state.cdpPort = null;
-  }
-}
-async function terminateBrokerOnPort(port) {
-  try {
-    const output = execFileSync2("lsof", ["-tiTCP:" + String(port), "-sTCP:LISTEN"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    const pids = output.split(/\r?\n/).map((line) => Number(line.trim())).filter((pid) => Number.isInteger(pid) && pid > 0);
-    for (const pid of pids) {
-      try {
-        process.kill(pid, "SIGTERM");
-      } catch {}
-    }
-    if (pids.length > 0) {
-      await new Promise((resolve) => setTimeout(resolve, 500));
-    }
-  } catch {}
-}
-async function reuseHealthyBrokerIfPossible(state, launchConfig, deps = {}) {
-  const isHealthyPort = deps.isHealthyPort ?? isKuriHealthyOnPort;
-  if (!await isHealthyPort(state.port))
-    return false;
-  log("kuri", `already running on port ${state.port}`);
-  state.ready = true;
-  const cdpAvailable = deps.isChromeCdpAvailable ?? isChromeCdpAvailable;
-  const discover = deps.discoverCdpPort ?? discoverCdpPort;
-  await discover(state);
-  if (!state.cdpPort && launchConfig.attachToExistingChrome) {
-    const ensureChrome = deps.ensureUserChromeRunning ?? ensureUserChromeRunning;
-    await ensureChrome(state);
-  }
-  if (typeof state.cdpPort === "number" && !await cdpAvailable(state.cdpPort)) {
-    state.cdpPort = null;
-  }
-  const syncTabs = deps.ensureTabsDiscovered ?? ensureTabsDiscovered;
-  await syncTabs(state).catch(() => {});
-  const tabs = await (deps.listTabs ?? listRegisteredTabs)(state).catch(() => []);
-  if (state.cdpPort) {
-    return true;
-  }
-  if (tabs.length > 0) {
-    log("kuri", `healthy broker on port ${state.port} has stale registered tabs but no CDP; recycling startup path`);
-  } else {
-    log("kuri", `healthy broker on port ${state.port} has no CDP or tabs; recycling startup path`);
-  }
-  state.ready = false;
-  if (state.process) {
-    state.process.kill("SIGTERM");
-    await waitForChildExit(state.process);
-    state.process = null;
-  } else {
-    const terminate = deps.terminateBrokerOnPort ?? terminateBrokerOnPort;
-    await terminate(state.port);
-  }
-  return false;
-}
-function kuriUrl(state, path6, params) {
-  const base = `http://127.0.0.1:${state.port}${path6}`;
-  if (!params || Object.keys(params).length === 0)
-    return base;
-  const parts = Object.entries(params).map(([k, v]) => `${k}=${v.replace(/#/g, "%23").replace(/&/g, "%26").replace(/\+/g, "%2B")}`);
-  return `${base}?${parts.join("&")}`;
-}
-function shouldRetryKuriTransportError(error) {
-  const message = error instanceof Error ? error.message : String(error ?? "");
-  return /fetch failed|econnrefused|connection refused|socket hang up|other side closed|transport closed/i.test(message);
-}
-async function kuriGet(state, path6, params, retryOnTransportFailure = true) {
-  const url = kuriUrl(state, path6, params);
-  const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), KURI_REQUEST_TIMEOUT_MS);
-  try {
-    const res = await fetch(url, { signal: controller.signal });
-    const text = await res.text();
-    try {
-      return JSON.parse(text);
-    } catch {
-      return text;
-    }
-  } catch (error) {
-    if (retryOnTransportFailure && path6 !== "/health" && shouldRetryKuriTransportError(error)) {
-      log("kuri", `transport failed for ${path6}; restarting Kuri and retrying once on port ${state.port}`);
-      await stopOn(state);
-      await startOn(state, state.requestedPort || state.port);
-      return await kuriGet(state, path6, params, false);
-    }
-    throw error;
-  } finally {
-    clearTimeout(timeout);
-  }
-}
 function findKuriBinary() {
   if (process.env.KURI_BIN)
     return process.env.KURI_BIN;
   const candidates = getKuriBinaryCandidates();
   return candidates.find((candidate) => existsSync9(candidate)) ?? candidates[0] ?? kuriBinaryName();
 }
-async function waitForChildExit(child, timeoutMs = 2000) {
-  if (!child)
-    return;
-  if (child.exitCode !== null || child.killed)
-    return;
-  await new Promise((resolve) => {
-    const timer = setTimeout(resolve, timeoutMs);
-    child.once("exit", () => {
-      clearTimeout(timer);
-      resolve();
-    });
-  });
-}
-async function startOn(state, port) {
-  const requestedPort = port ?? Number(process.env.KURI_PORT || KURI_DEFAULT_PORT);
-  const externalPort = process.env.KURI_EXTERNAL_PORT;
-  if (externalPort && !state.ready) {
-    const ep = Number(externalPort);
-    if (await isKuriHealthyOnPort(ep)) {
-      state.port = ep;
-      state.requestedPort = ep;
-      state.ready = true;
-      state.managedChrome = false;
-      const cdpUrl = process.env.CDP_URL;
-      if (cdpUrl) {
-        const m = cdpUrl.match(/:(\d+)/);
-        if (m)
-          state.cdpPort = Number(m[1]);
-      }
-      log("kuri", `using external Kuri broker on port ${ep}${state.cdpPort ? ` (CDP port ${state.cdpPort})` : ""}`);
-      return;
-    }
-    log("kuri", `external Kuri on port ${ep} not healthy — falling through to normal start`);
-  }
-  if (state.ready) {
-    const activePort = state.port || requestedPort;
-    if (await isKuriHealthyOnPort(activePort))
-      return;
-    log("kuri", `cached ready state stale on port ${activePort}; restarting`);
-    state.ready = false;
-    state.process = null;
-    state.startPromise = null;
-  }
-  if (state.startPromise)
-    return state.startPromise;
-  const startPromise = (async () => {
-    const launchConfig = resolveKuriLaunchConfig();
-    state.requestedPort = requestedPort;
-    state.port = await resolveKuriPort(requestedPort);
-    const existingClient = brokerClients.get(brokerCacheKey(requestedPort));
-    if (existingClient)
-      rememberBrokerClient(existingClient, state);
-    if (state.port !== requestedPort) {
-      log("kuri", `preferred port ${requestedPort} is occupied but unhealthy; falling back to ${state.port}`);
-    }
-    if (await reuseHealthyBrokerIfPossible(state, launchConfig))
-      return;
-    const binary = findKuriBinary();
-    log("kuri", `starting: ${binary} on port ${state.port}`);
-    if (!existsSync9(binary)) {
-      throw new Error(`Kuri binary not found at ${binary}`);
-    }
-    const reusableManagedChrome = shouldReuseManagedChrome(launchConfig, state, typeof state.cdpPort === "number" && await isChromeCdpAvailable(state.cdpPort));
-    if (launchConfig.attachToExistingChrome) {
-      await discoverCdpPort(state);
-      state.managedChrome = false;
-    } else if (reusableManagedChrome) {
-      log("kuri", `reconnecting to surviving managed Chrome on port ${state.cdpPort}`);
-    } else {
-      state.cdpPort = null;
-      state.managedChrome = false;
-    }
-    const env = {
-      ...process.env,
-      PORT: String(state.port),
-      HOST: "127.0.0.1",
-      HEADLESS: launchConfig.headless ? "true" : "false"
-    };
-    if (state.cdpPort && (launchConfig.attachToExistingChrome || reusableManagedChrome)) {
-      env.CDP_URL = `ws://127.0.0.1:${state.cdpPort}`;
-      log("kuri", reusableManagedChrome ? `connecting to surviving managed Chrome on port ${state.cdpPort}` : `connecting to existing Chrome on port ${state.cdpPort}`);
-    } else if (launchConfig.headless) {
-      log("kuri", "starting in headless mode with managed Chrome");
-    } else {
-      log("kuri", "no existing Chrome found — Kuri will launch managed Chrome");
-    }
-    const maxAttempts = KURI_SPAWN_RETRIES + 1;
-    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
-      if (attempt > 1) {
-        log("kuri", `spawn retry ${attempt}/${maxAttempts} after ${KURI_SPAWN_RETRY_DELAY_MS}ms`);
-        await new Promise((r) => setTimeout(r, KURI_SPAWN_RETRY_DELAY_MS));
-      }
-      let exitedBeforeReady = false;
-      state.process = spawn2(binary, [], {
-        env,
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-      const childPid = state.process.pid;
-      log("kuri", `spawned pid ${childPid ?? "unknown"} on broker port ${state.port}`);
-      state.process.stderr?.on("data", (chunk) => {
-        const line = chunk.toString().trim();
-        if (line)
-          log("kuri", `[stderr] ${line}`);
-        const cdpMatch = line.match(/CDP port:\s*(\d+)/);
-        if (cdpMatch) {
-          state.cdpPort = parseInt(cdpMatch[1], 10);
-          kuriCdpPort = state.cdpPort;
-          log("kuri", `discovered CDP port: ${state.cdpPort}`);
-        }
-        if (/launched Chrome \(pid=\d+\) on CDP port/i.test(line) || /launching managed Chrome instance/i.test(line)) {
-          state.managedChrome = true;
-        }
-      });
-      state.process.on("exit", (code, signal) => {
-        if (!state.ready)
-          exitedBeforeReady = true;
-        log("kuri", `process exited pid=${childPid ?? "unknown"} code=${code === null ? "null" : code} signal=${signal ?? "none"} broker_port=${state.port} cdp_port=${state.cdpPort ?? "unknown"}`);
-        state.ready = false;
-        state.process = null;
-        forgetBrokerClient(state);
-      });
-      const deadline = Date.now() + KURI_STARTUP_TIMEOUT_MS;
-      while (Date.now() < deadline) {
-        if (exitedBeforeReady)
-          break;
-        try {
-          const res = await fetch(`http://127.0.0.1:${state.port}/health`, {
-            signal: AbortSignal.timeout(500)
-          });
-          if (res.ok) {
-            state.ready = true;
-            log("kuri", `ready on port ${state.port}`);
-            await new Promise((r) => setTimeout(r, 300));
-            if (!state.cdpPort)
-              await discoverCdpPort(state);
-            await waitForChromeCdpReady(state).catch(() => false);
-            await ensureTabsDiscovered(state);
-            return;
-          }
-        } catch {}
-        await new Promise((r) => setTimeout(r, 200));
-      }
-      if (state.ready)
-        return;
-      if (state.process) {
-        state.process.kill();
-        await waitForChildExit(state.process);
-      }
-      try {
-        execFileSync2("pkill", ["-f", `remote-debugging-port=${state.cdpPort ?? 9222}`], { stdio: "ignore" });
-        await new Promise((r) => setTimeout(r, 1000));
-      } catch {}
-    }
-    throw new Error(`Kuri failed to start after ${maxAttempts} attempts`);
-  })();
-  state.startPromise = startPromise.finally(() => {
-    if (state.startPromise === startPromise) {
-      state.startPromise = null;
-    }
-  });
-  return state.startPromise;
-}
-async function stopOn(state) {
-  if (state.startPromise) {
-    await state.startPromise.catch(() => {});
-  }
-  if (state.process) {
-    state.process.kill("SIGTERM");
-    state.process = null;
-  }
-  state.ready = false;
-  state.cdpPort = null;
-  kuriCdpPort = null;
-  state.managedChrome = false;
-  state.startPromise = null;
-  forgetBrokerClient(state);
-}
-async function getDefaultTabOn(state) {
-  await ensureTabsDiscovered(state);
-  try {
-    const tabs = await kuriGet(state, "/tabs");
-    if (Array.isArray(tabs) && tabs.length > 0)
-      return tabs[0].id;
-  } catch {}
-  const cdpTabId = await createTabViaChromeCdp("about:blank", state);
-  if (cdpTabId)
-    return cdpTabId;
-  throw new Error("No tabs available and failed to create one");
-}
-async function start(port, state = defaultBrokerState) {
-  return startOn(state, port);
-}
-async function stop(state = defaultBrokerState) {
-  return stopOn(state);
-}
-async function getDefaultTab(state = defaultBrokerState) {
-  return getDefaultTabOn(state);
-}
-async function ensureTabsDiscovered(state) {
-  try {
-    if (state.cdpPort)
-      await waitForChromeCdpReady(state).catch(() => false);
-    const params = {};
-    if (state.cdpPort)
-      params.cdp_url = `ws://127.0.0.1:${state.cdpPort}`;
-    await kuriGet(state, "/discover", params);
-  } catch {}
-}
-async function waitForTabRegistration(state, tabId, timeoutMs = 2000) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    await ensureTabsDiscovered(state);
-    try {
-      const tabs = await kuriGet(state, "/tabs");
-      if (Array.isArray(tabs) && tabs.some((tab) => tab?.id === tabId))
-        return;
-    } catch {}
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-}
-async function createTabViaChromeCdp(url = "about:blank", state = defaultBrokerState) {
-  if (!state.cdpPort)
-    return "";
-  for (let attempt = 0;attempt < KURI_TAB_CREATE_RETRIES; attempt += 1) {
-    await waitForChromeCdpReady(state).catch(() => false);
-    try {
-      const res = await fetch(`http://127.0.0.1:${state.cdpPort}/json/new?${url}`, {
-        method: "PUT",
-        signal: AbortSignal.timeout(5000)
-      });
-      const target = await res.json();
-      const tabId = target?.id ?? target?.targetId ?? "";
-      if (tabId) {
-        log("kuri", `created new Chrome tab: ${tabId}`);
-        await new Promise((resolve) => setTimeout(resolve, 300));
-        await ensureTabsDiscovered(state).catch(() => {});
-        await waitForTabRegistration(state, tabId).catch(() => {});
-        return tabId;
-      }
-    } catch (err) {
-      if (attempt === KURI_TAB_CREATE_RETRIES - 1) {
-        log("kuri", `Chrome tab creation failed: ${err instanceof Error ? err.message : err}`);
-        return "";
-      }
-    }
-    await new Promise((resolve) => setTimeout(resolve, KURI_CDP_POLL_INTERVAL_MS));
-  }
-  return "";
-}
-async function navigate(tabId, url, state = defaultBrokerState) {
-  await kuriGet(state, "/navigate", { tab_id: tabId, url });
-}
-async function evaluate(tabId, expression, state = defaultBrokerState) {
-  let raw;
-  if (expression.length > 2000) {
-    const url = kuriUrl(state, "/evaluate", { tab_id: tabId, expression });
-    const controller = new AbortController;
-    const timeout = setTimeout(() => controller.abort(), KURI_REQUEST_TIMEOUT_MS);
-    try {
-      const res = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "text/plain" },
-        body: expression,
-        signal: controller.signal
-      });
-      const text = await res.text();
-      try {
-        raw = JSON.parse(text);
-      } catch {
-        raw = text;
-      }
-    } finally {
-      clearTimeout(timeout);
-    }
-  } else {
-    raw = await kuriGet(state, "/evaluate", { tab_id: tabId, expression });
-  }
-  const inner = raw?.result?.result;
-  if (!inner)
-    return raw;
-  if (inner.type === "undefined")
-    return;
-  if ("value" in inner)
-    return inner.value;
-  return inner.description ?? raw;
-}
-async function getCookies(tabId, state = defaultBrokerState) {
-  const raw = await kuriGet(state, "/cookies", { tab_id: tabId });
-  return raw?.result?.cookies ?? [];
-}
-async function setCookieViaCDP(wsUrl, cookie) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => {
-      resolve(false);
-    }, 3000);
-    try {
-      const ws = new (__require("ws"))(wsUrl);
-      ws.on("open", () => {
-        ws.send(JSON.stringify({
-          id: 1,
-          method: "Network.setCookie",
-          params: {
-            ...cookie,
-            url: `https://${cookie.domain.replace(/^\./, "")}/`
-          }
-        }));
-      });
-      ws.on("message", (data) => {
-        clearTimeout(timer);
-        try {
-          const msg = JSON.parse(data.toString());
-          if (msg.id === 1) {
-            ws.close();
-            resolve(msg.result?.success ?? false);
-          }
-        } catch {
-          ws.close();
-          resolve(false);
-        }
-      });
-      ws.on("error", () => {
-        clearTimeout(timer);
-        resolve(false);
-      });
-    } catch {
-      clearTimeout(timer);
-      resolve(false);
-    }
-  });
-}
-async function resolveCdpDebuggerUrlForTab(tabId) {
-  const portsToTry = Array.from(new Set([kuriCdpPort, 9222, 9223, 9224, 9225].filter((port) => typeof port === "number")));
-  for (const port of portsToTry) {
-    try {
-      const res = await fetch(`http://127.0.0.1:${port}/json`, { signal: AbortSignal.timeout(1000) });
-      if (!res.ok)
-        continue;
-      const pages = await res.json();
-      const page = pages.find((candidate) => candidate.id === tabId);
-      if (page?.webSocketDebuggerUrl) {
-        if (kuriCdpPort !== port) {
-          kuriCdpPort = port;
-          log("kuri", `updated CDP port from tab discovery: ${port}`);
-        }
-        return page.webSocketDebuggerUrl;
-      }
-    } catch {}
-  }
-  return null;
-}
-async function setCookie(tabId, cookie, state = defaultBrokerState) {
-  const value = cookie.value.replace(/^"|"$/g, "");
-  if (cookie.secure || cookie.httpOnly) {
-    try {
-      const debuggerUrl = await resolveCdpDebuggerUrlForTab(tabId);
-      if (debuggerUrl) {
-        const success = await setCookieViaCDP(debuggerUrl, {
-          name: cookie.name,
-          value,
-          domain: cookie.domain,
-          path: cookie.path || "/",
-          secure: cookie.secure ?? false,
-          httpOnly: cookie.httpOnly ?? false,
-          sameSite: cookie.sameSite || "Lax",
-          ...cookie.expires && cookie.expires > 0 ? { expires: cookie.expires } : {}
-        });
-        if (success)
-          return;
-        log("kuri", `CDP cookie set failed for ${cookie.name} on ${cookie.domain}; falling back to /cookies`);
-      } else {
-        log("kuri", `no CDP websocket for tab ${tabId}; falling back to /cookies for secure cookie ${cookie.name}`);
-      }
-    } catch {}
-  }
-  await kuriGet(state, "/cookies", {
-    tab_id: tabId,
-    name: cookie.name,
-    value,
-    domain: cookie.domain,
-    ...cookie.path ? { path: cookie.path } : {}
-  });
-}
-async function networkEnable(tabId, state = defaultBrokerState) {
-  await kuriGet(state, "/network", { tab_id: tabId, mode: "enable" });
-}
-async function getCurrentUrl(tabId, state = defaultBrokerState) {
-  const result = await evaluate(tabId, "window.location.href", state);
-  return typeof result === "string" ? result : "";
-}
-async function action(tabId, actionType, ref, value, state = defaultBrokerState) {
-  const params = { tab_id: tabId, action: actionType, ref };
-  if (value !== undefined)
-    params.value = value;
-  return kuriGet(state, "/action", params);
-}
-async function click(tabId, ref, state = defaultBrokerState) {
-  await scrollIntoView(tabId, ref, state);
-  return action(tabId, "click", ref, undefined, state);
-}
-async function fill(tabId, ref, value, state = defaultBrokerState) {
-  await click(tabId, ref, state);
-  const result = await action(tabId, "fill", ref, value, state);
-  const currentValue = await evaluate(tabId, `(() => {
-    const active = document.activeElement;
-    return active && "value" in active ? active.value : undefined;
-  })()`, state);
-  if (currentValue !== value) {
-    return evaluate(tabId, `(function() {
-      const active = document.activeElement;
-      if (!active || !("value" in active)) return false;
-      active.value = ${JSON.stringify(value)};
-      active.dispatchEvent(new Event("input", { bubbles: true }));
-      active.dispatchEvent(new Event("change", { bubbles: true }));
-      return active.value;
-    })()`, state);
-  }
-  return result;
-}
-async function scrollIntoView(tabId, ref, state = defaultBrokerState) {
-  return kuriGet(state, "/scrollintoview", { tab_id: tabId, ref });
-}
-async function authProfileSave(tabId, name, state = defaultBrokerState) {
-  return kuriGet(state, "/auth/profile/save", { tab_id: tabId, name });
-}
-var KURI_DEFAULT_PORT = 7700, KURI_STARTUP_TIMEOUT_MS = 60000, KURI_REQUEST_TIMEOUT_MS = 30000, KURI_SPAWN_RETRIES = 3, KURI_SPAWN_RETRY_DELAY_MS = 1000, KURI_PORT_SEARCH_LIMIT = 10, KURI_CDP_READY_TIMEOUT_MS = 5000, KURI_CDP_POLL_INTERVAL_MS = 200, KURI_TAB_CREATE_RETRIES = 5, kuriCdpPort = null, defaultBrokerState, brokerClients;
+var KURI_DEFAULT_PORT = 7700, defaultBrokerState, brokerClients;
 var init_client2 = __esm(() => {
   init_logger();
   init_paths();
@@ -1721,210 +1016,6 @@ var init_token_resolver = __esm(() => {
   init_token_sources();
 });
 
-// ../../src/auth/agent-mail.ts
-var exports_agent_mail = {};
-__export(exports_agent_mail, {
-  waitForVerificationEmail: () => waitForVerificationEmail,
-  tryAgentMailAuth: () => tryAgentMailAuth,
-  isAgentMailAvailable: () => isAgentMailAvailable,
-  getOrCreateSiteInbox: () => getOrCreateSiteInbox,
-  extractVerificationLink: () => extractVerificationLink,
-  extractOtpFromEmail: () => extractOtpFromEmail,
-  autonomousEmailLogin: () => autonomousEmailLogin
-});
-import { AgentMailClient } from "agentmail";
-function getClient() {
-  if (_client)
-    return _client;
-  const apiKey = process.env.AGENTMAIL_API_KEY;
-  if (!apiKey)
-    throw new Error("AGENTMAIL_API_KEY not set — cannot use agent mail");
-  _client = new AgentMailClient({ apiKey });
-  return _client;
-}
-async function getStoredInbox(domain) {
-  const key = `${VAULT_PREFIX}${getRegistrableDomain(domain)}`;
-  const raw = await getCredential(key);
-  if (!raw)
-    return null;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-async function storeInbox(domain, inbox) {
-  const key = `${VAULT_PREFIX}${getRegistrableDomain(domain)}`;
-  await storeCredential(key, JSON.stringify(inbox));
-  log("agent-mail", `stored inbox ${inbox.email} for ${domain}`);
-}
-async function getOrCreateSiteInbox(domain) {
-  const stored = await getStoredInbox(domain);
-  if (stored) {
-    log("agent-mail", `reusing stored inbox ${stored.email} for ${domain}`);
-    return { inboxId: stored.inboxId, email: stored.email };
-  }
-  const client = getClient();
-  const safeDomain = getRegistrableDomain(domain).replace(/[^a-z0-9-]/gi, "-").toLowerCase();
-  const username = `unbrowse-${safeDomain}`;
-  const clientId = `unbrowse-login-${safeDomain}`;
-  try {
-    const inbox = await client.inboxes.create({
-      username,
-      domain: "agentmail.to",
-      displayName: `Unbrowse Agent - ${domain}`,
-      clientId
-    });
-    const result = { inboxId: inbox.inboxId, email: inbox.email };
-    await storeInbox(domain, { ...result, domain, createdAt: new Date().toISOString() });
-    log("agent-mail", `created inbox ${inbox.email} for ${domain}`);
-    return result;
-  } catch (err) {
-    log("agent-mail", `create failed (likely exists), listing to find match: ${err instanceof Error ? err.message : err}`);
-    try {
-      const list = await client.inboxes.list({ limit: 100 });
-      const match = list.inboxes.find((i) => i.clientId === clientId || i.email === `${username}@agentmail.to`);
-      if (match) {
-        const result = { inboxId: match.inboxId, email: match.email };
-        await storeInbox(domain, { ...result, domain, createdAt: new Date().toISOString() });
-        return result;
-      }
-    } catch {}
-    throw new Error(`Failed to create or find AgentMail inbox for ${domain}`);
-  }
-}
-async function waitForVerificationEmail(inboxId, fromDomain, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  const client = getClient();
-  const start2 = Date.now();
-  const normalizedDomain = fromDomain.toLowerCase();
-  log("agent-mail", `polling inbox ${inboxId} for email from *@${normalizedDomain} (timeout: ${timeoutMs}ms)`);
-  while (Date.now() - start2 < timeoutMs) {
-    try {
-      const response = await client.inboxes.messages.list(inboxId, {
-        limit: 10,
-        labels: ["received"]
-      });
-      for (const item of response.messages ?? []) {
-        const msg = await client.inboxes.messages.get(inboxId, item.messageId);
-        const from = typeof msg.from === "string" ? msg.from : (msg.from ?? []).join(", ");
-        if (from.toLowerCase().includes(normalizedDomain)) {
-          log("agent-mail", `found verification email from ${from}: "${msg.subject}"`);
-          return {
-            messageId: msg.messageId,
-            threadId: msg.threadId,
-            subject: msg.subject ?? "",
-            from,
-            text: msg.extractedText ?? msg.text ?? "",
-            html: msg.extractedHtml ?? msg.html ?? "",
-            receivedAt: msg.createdAt
-          };
-        }
-      }
-    } catch (err) {
-      log("agent-mail", `poll error: ${err instanceof Error ? err.message : err}`);
-    }
-    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
-  }
-  log("agent-mail", `timeout waiting for email from ${normalizedDomain}`);
-  return null;
-}
-function extractOtpFromEmail(text) {
-  const codePhrase = text.match(/(?:verification|confirm|security|login|one[- ]time|otp)\s*(?:code|pin|number)[:\s]+(\w{4,8})/i);
-  if (codePhrase)
-    return codePhrase[1];
-  const codeIs = text.match(/(?:code|otp|pin)[:\s]+(\w{4,8})/i);
-  if (codeIs)
-    return codeIs[1];
-  const six = text.match(/\b(\d{6})\b/);
-  if (six)
-    return six[1];
-  const four = text.match(/\b(\d{4})\b/);
-  if (four)
-    return four[1];
-  return null;
-}
-function extractVerificationLink(text, html) {
-  const htmlLink = html.match(/href="(https?:\/\/[^"]*(?:verify|confirm|activate|magic|token|auth|callback|validate|approve|email)[^"]*)"/i);
-  if (htmlLink)
-    return htmlLink[1];
-  const textLink = text.match(/(https?:\/\/\S*(?:verify|confirm|activate|magic|token|auth|callback|validate|approve|email)\S*)/i);
-  if (textLink)
-    return textLink[1];
-  const anyHtmlLink = html.match(/href="(https?:\/\/[^"]+)"/);
-  if (anyHtmlLink)
-    return anyHtmlLink[1];
-  const anyTextLink = text.match(/(https?:\/\/\S+)/);
-  if (anyTextLink)
-    return anyTextLink[1];
-  return null;
-}
-async function autonomousEmailLogin(domain) {
-  const inbox = await getOrCreateSiteInbox(domain);
-  const client = getClient();
-  log("agent-mail", `session ready for ${domain} — email: ${inbox.email}`);
-  return {
-    email: inbox.email,
-    inboxId: inbox.inboxId,
-    domain,
-    waitForOtp: async (timeoutMs = DEFAULT_TIMEOUT_MS) => {
-      const email = await waitForVerificationEmail(inbox.inboxId, domain, timeoutMs);
-      if (!email)
-        return null;
-      const otp = extractOtpFromEmail(email.text);
-      if (otp)
-        log("agent-mail", `extracted OTP: ${otp} from ${email.subject}`);
-      return otp;
-    },
-    waitForLink: async (timeoutMs = DEFAULT_TIMEOUT_MS) => {
-      const email = await waitForVerificationEmail(inbox.inboxId, domain, timeoutMs);
-      if (!email)
-        return null;
-      const link = extractVerificationLink(email.text, email.html);
-      if (link)
-        log("agent-mail", `extracted verification link from ${email.subject}`);
-      return link;
-    },
-    waitForEmail: (timeoutMs = DEFAULT_TIMEOUT_MS) => waitForVerificationEmail(inbox.inboxId, domain, timeoutMs),
-    sendEmail: async (to, subject, body) => {
-      const result = await client.inboxes.messages.send(inbox.inboxId, {
-        to: [to],
-        subject,
-        text: body
-      });
-      log("agent-mail", `sent email to ${to}: "${subject}" (${result.messageId})`);
-      return { messageId: result.messageId, threadId: result.threadId };
-    },
-    replyTo: async (messageId, body) => {
-      const result = await client.inboxes.messages.reply(inbox.inboxId, messageId, {
-        text: body
-      });
-      log("agent-mail", `replied to ${messageId} (${result.messageId})`);
-      return { messageId: result.messageId, threadId: result.threadId };
-    }
-  };
-}
-function isAgentMailAvailable() {
-  return Boolean(process.env.AGENTMAIL_API_KEY);
-}
-async function tryAgentMailAuth(domain) {
-  if (!isAgentMailAvailable()) {
-    log("agent-mail", `skipping — AGENTMAIL_API_KEY not set`);
-    return null;
-  }
-  try {
-    return await autonomousEmailLogin(domain);
-  } catch (err) {
-    log("agent-mail", `auth failed for ${domain}: ${err instanceof Error ? err.message : err}`);
-    return null;
-  }
-}
-var POLL_INTERVAL_MS = 3000, DEFAULT_TIMEOUT_MS = 90000, _client = null, VAULT_PREFIX = "agentmail:";
-var init_agent_mail = __esm(async () => {
-  init_logger();
-  init_domain();
-  await init_vault();
-});
-
 // ../../src/auth/browser-cookies.ts
 var exports_browser_cookies = {};
 __export(exports_browser_cookies, {
@@ -2292,74 +1383,6 @@ var init_browser_cookies = __esm(() => {
 });
 
 // ../../src/auth/index.ts
-function formatAuthError(error) {
-  if (error instanceof Error && error.message)
-    return error.message;
-  if (typeof error === "string")
-    return error;
-  try {
-    return JSON.stringify(error);
-  } catch {
-    return String(error);
-  }
-}
-function normalizeAuthDomain(domain) {
-  return domain.toLowerCase().replace(/^www\./, "");
-}
-function shouldImportBrowserCookies() {
-  const raw = process.env.UNBROWSE_IMPORT_BROWSER_COOKIES?.trim();
-  if (!raw)
-    return true;
-  return !DISABLE_BROWSER_COOKIE_IMPORT.test(raw);
-}
-function isLikelyAuthenticatedCookie(targetDomain, cookie) {
-  const cookieName = cookie.name.toLowerCase();
-  const registrableDomain = getRegistrableDomain(normalizeAuthDomain(targetDomain));
-  const requiredCookieNames = DOMAIN_AUTH_COOKIE_NAMES[registrableDomain];
-  if (requiredCookieNames)
-    return requiredCookieNames.includes(cookieName);
-  return GENERIC_AUTH_COOKIE_NAMES.test(cookieName);
-}
-function getAuthenticatedCookiesForDomain(targetDomain, cookies) {
-  return cookies.filter((cookie) => isDomainMatch(cookie.domain, targetDomain) && isLikelyAuthenticatedCookie(targetDomain, cookie));
-}
-async function importBrowserCookiesIntoTab(tabId, domain) {
-  if (!shouldImportBrowserCookies())
-    return 0;
-  try {
-    const { extractBrowserCookies: extractBrowserCookies2, findBestBrowserSession: findBestBrowserSession2 } = await Promise.resolve().then(() => (init_browser_cookies(), exports_browser_cookies));
-    const bestSession = findBestBrowserSession2(domain);
-    const cookies = bestSession ? bestSession.cookies : extractBrowserCookies2(domain).cookies;
-    let imported = 0;
-    for (const cookie of cookies) {
-      try {
-        await setCookie(tabId, cookie);
-        imported += 1;
-      } catch (error) {
-        log("auth", `browser_cookie_import_failed domain=${normalizeAuthDomain(domain)} tab_id=${tabId} cookie=${cookie.name} error=${formatAuthError(error)}`);
-      }
-    }
-    if (imported > 0) {
-      log("auth", `browser_cookie_imported domain=${normalizeAuthDomain(domain)} tab_id=${tabId} count=${imported}`);
-    }
-    return imported;
-  } catch (error) {
-    log("auth", `browser_cookie_extract_failed domain=${normalizeAuthDomain(domain)} tab_id=${tabId} error=${formatAuthError(error)}`);
-    return 0;
-  }
-}
-async function saveAuthProfileBestEffort(tabId, domain, context = "auth") {
-  const profileName = normalizeAuthDomain(domain);
-  if (!profileName || profileName === "unknown")
-    return false;
-  try {
-    await authProfileSave(tabId, profileName);
-    return true;
-  } catch (error) {
-    log("auth", `${context} auth_profile_failed op=save domain=${profileName} tab_id=${tabId} error=${formatAuthError(error)}`);
-    return false;
-  }
-}
 async function extractBrowserAuth(domain, opts) {
   const { extractBrowserCookies: extractBrowserCookies2 } = await Promise.resolve().then(() => (init_browser_cookies(), exports_browser_cookies));
   const result = extractBrowserCookies2(domain, opts);
@@ -2446,301 +1469,12 @@ async function getAuthCookies(domain) {
   }
   return null;
 }
-var DISABLE_BROWSER_COOKIE_IMPORT, GENERIC_AUTH_COOKIE_NAMES, DOMAIN_AUTH_COOKIE_NAMES;
 var init_auth = __esm(async () => {
   init_client2();
   init_domain();
   init_logger();
   init_supervisor();
-  await __promiseAll([
-    init_vault(),
-    init_agent_mail()
-  ]);
-  DISABLE_BROWSER_COOKIE_IMPORT = /^(0|false|no|off)$/i;
-  GENERIC_AUTH_COOKIE_NAMES = /(^|[_\-.])(sess(?:ion)?(?:id)?|auth|token|csrf|xsrf|jwt|sid|sso|remember|logged[_-]?in|connect\.sid)([_\-.]|$)/i;
-  DOMAIN_AUTH_COOKIE_NAMES = {
-    "linkedin.com": ["li_at"]
-  };
-});
-
-// ../../src/auth/email-provider.ts
-class AgentMailProvider {
-  name = "agentmail";
-  get configured() {
-    return Boolean(process.env.AGENTMAIL_API_KEY);
-  }
-  async getAddress(domain) {
-    const { getOrCreateSiteInbox: getOrCreateSiteInbox2 } = await init_agent_mail().then(() => exports_agent_mail);
-    const inbox = await getOrCreateSiteInbox2(domain);
-    return inbox.email;
-  }
-  async send(to, subject, body) {
-    const { autonomousEmailLogin: autonomousEmailLogin2 } = await init_agent_mail().then(() => exports_agent_mail);
-    const session = await autonomousEmailLogin2("general");
-    const result = await session.sendEmail(to, subject, body);
-    return { messageId: result.messageId };
-  }
-  async waitForMessage(fromDomain, timeoutMs = 90000) {
-    const { autonomousEmailLogin: autonomousEmailLogin2, waitForVerificationEmail: waitForVerificationEmail2 } = await init_agent_mail().then(() => exports_agent_mail);
-    const session = await autonomousEmailLogin2(fromDomain);
-    const email = await waitForVerificationEmail2(session.inboxId, fromDomain, timeoutMs);
-    return email;
-  }
-}
-
-class GmailProvider {
-  name = "gmail";
-  get configured() {
-    try {
-      const { existsSync: existsSync12 } = __require("fs");
-      const { homedir: homedir7 } = __require("os");
-      const { join: join9 } = __require("path");
-      return existsSync12(join9(homedir7(), ".config", "gcloud", "application_default_credentials.json"));
-    } catch {
-      return false;
-    }
-  }
-  async getAddress(_domain) {
-    const { execSync: execSync3 } = __require("child_process");
-    try {
-      const email = execSync3("gcloud config get-value account 2>/dev/null", { encoding: "utf-8" }).trim();
-      if (email && email.includes("@"))
-        return email;
-    } catch {}
-    throw new Error("Gmail not configured — run: gcloud auth login");
-  }
-  async send(_to, _subject, _body) {
-    throw new Error("Gmail send not yet wired — use AgentMail or the gws-gmail-send skill directly");
-  }
-  async waitForMessage(_fromDomain, _timeoutMs = 90000) {
-    throw new Error("Gmail inbox polling not yet wired — use AgentMail or the gws-gmail skill directly");
-  }
-}
-function getEmailProvider(purpose = "general") {
-  if (purpose === "register") {
-    const agentmail = providers.find((p) => p.name === "agentmail" && p.configured);
-    if (agentmail)
-      return agentmail;
-  }
-  if (purpose === "login") {
-    const gmail = providers.find((p) => p.name === "gmail" && p.configured);
-    if (gmail)
-      return gmail;
-  }
-  return providers.find((p) => p.configured) ?? null;
-}
-var providers;
-var init_email_provider = __esm(() => {
-  providers = [
-    new GmailProvider,
-    new AgentMailProvider
-  ];
-});
-
-// ../../src/auth/autonomous-login.ts
-async function detectEmailInput(tabId) {
-  const ref = await evaluate(tabId, `(() => {
-    // Priority order: type=email, name/id containing email, placeholder containing email
-    const byType = document.querySelector('input[type="email"]');
-    if (byType) return byType.getAttribute("data-ref") || "input[type=email]";
-
-    const byName = document.querySelector('input[name*="email" i], input[id*="email" i]');
-    if (byName) return byName.getAttribute("data-ref") || 'input[name*="email" i]';
-
-    const byPlaceholder = document.querySelector('input[placeholder*="email" i]');
-    if (byPlaceholder) return byPlaceholder.getAttribute("data-ref") || 'input[placeholder*="email" i]';
-
-    // Generic text input on a login page (single input + submit button pattern)
-    const inputs = document.querySelectorAll('input[type="text"], input:not([type])');
-    const submit = document.querySelector('button[type="submit"], input[type="submit"], button:not([type])');
-    if (inputs.length === 1 && submit) {
-      return inputs[0].getAttribute("data-ref") || 'input[type="text"]';
-    }
-
-    return null;
-  })()`);
-  return typeof ref === "string" ? ref : null;
-}
-async function detectOtpInput(tabId) {
-  const ref = await evaluate(tabId, `(() => {
-    // OTP-specific inputs
-    const byAutocomplete = document.querySelector('input[autocomplete="one-time-code"]');
-    if (byAutocomplete) return byAutocomplete.getAttribute("data-ref") || 'input[autocomplete="one-time-code"]';
-
-    // Name/id/placeholder containing otp, code, verification, pin
-    const byName = document.querySelector(
-      'input[name*="otp" i], input[name*="code" i], input[name*="verification" i], input[name*="pin" i], ' +
-      'input[id*="otp" i], input[id*="code" i], input[id*="verification" i], ' +
-      'input[placeholder*="code" i], input[placeholder*="verification" i], input[placeholder*="otp" i]'
-    );
-    if (byName) return byName.getAttribute("data-ref") || 'input[name*="code" i]';
-
-    // Numeric input with maxlength 4-8 (common OTP pattern)
-    const numericInputs = document.querySelectorAll('input[type="number"], input[type="tel"], input[inputmode="numeric"]');
-    for (const el of numericInputs) {
-      const ml = parseInt(el.getAttribute("maxlength") || "0");
-      if (ml >= 4 && ml <= 8) return el.getAttribute("data-ref") || 'input[inputmode="numeric"]';
-    }
-
-    // Single short text input that appeared after email submit
-    const textInputs = document.querySelectorAll('input[type="text"], input:not([type])');
-    for (const el of textInputs) {
-      const ml = parseInt(el.getAttribute("maxlength") || "0");
-      if (ml >= 4 && ml <= 8) return el.getAttribute("data-ref") || 'input[type="text"]';
-    }
-
-    return null;
-  })()`);
-  return typeof ref === "string" ? ref : null;
-}
-async function detectSubmitButton(tabId) {
-  const ref = await evaluate(tabId, `(() => {
-    const submit = document.querySelector(
-      'button[type="submit"], input[type="submit"], ' +
-      'button:not([type]):not([aria-label*="close" i]):not([aria-label*="cancel" i])'
-    );
-    if (submit) return submit.getAttribute("data-ref") || 'button[type="submit"]';
-
-    // Look for buttons with login/register/continue/verify text
-    const buttons = document.querySelectorAll('button, a[role="button"]');
-    for (const btn of buttons) {
-      const text = btn.textContent?.toLowerCase() || "";
-      if (/logs*in|signs*in|register|signs*up|continue|submit|verify|next/i.test(text)) {
-        return btn.getAttribute("data-ref") || null;
-      }
-    }
-    return null;
-  })()`);
-  return typeof ref === "string" ? ref : null;
-}
-async function checkLoginSuccess(tabId, domain) {
-  const cookies = await getCookies(tabId);
-  const domainCookies = cookies.filter((c) => isDomainMatch(c.domain, domain));
-  const authCookies = getAuthenticatedCookiesForDomain(domain, domainCookies);
-  return authCookies.length > 0;
-}
-async function autonomousLogin(loginUrl, domain) {
-  const start2 = Date.now();
-  const targetDomain = domain ?? (() => {
-    try {
-      return new URL(loginUrl).hostname.replace(/^www\./, "");
-    } catch {
-      return loginUrl;
-    }
-  })();
-  const elapsed = () => Date.now() - start2;
-  const emailProvider = getEmailProvider("register");
-  if (!emailProvider) {
-    return { success: false, method: "failed", domain: targetDomain, cookies_stored: 0, error: "No email provider configured (set AGENTMAIL_API_KEY or configure Gmail via gcloud)", duration_ms: elapsed() };
-  }
-  log("autonomous-login", `starting for ${targetDomain} — url: ${loginUrl}`);
-  let tabId;
-  try {
-    await start();
-    tabId = await getDefaultTab();
-    await networkEnable(tabId);
-  } catch (err) {
-    return { success: false, method: "failed", domain: targetDomain, cookies_stored: 0, error: `Kuri start failed: ${err}`, duration_ms: elapsed() };
-  }
-  try {
-    await navigate(tabId, loginUrl);
-    await new Promise((r) => setTimeout(r, 2000));
-    let emailRef = await detectEmailInput(tabId);
-    if (!emailRef) {
-      const regUrl = loginUrl.replace(/login|signin|sign-in/i, "register").replace(/register/i, "signup");
-      if (regUrl !== loginUrl) {
-        await navigate(tabId, regUrl);
-        await new Promise((r) => setTimeout(r, 2000));
-        emailRef = await detectEmailInput(tabId);
-      }
-    }
-    if (!emailRef) {
-      log("autonomous-login", `no email input found on ${loginUrl}`);
-      return { success: false, method: "failed", domain: targetDomain, cookies_stored: 0, error: "no email input field detected", duration_ms: elapsed() };
-    }
-    let agentEmail;
-    try {
-      agentEmail = await emailProvider.getAddress(targetDomain);
-    } catch (err) {
-      return { success: false, method: "failed", domain: targetDomain, cookies_stored: 0, error: `Email provider (${emailProvider.name}) failed: ${err}`, duration_ms: elapsed() };
-    }
-    log("autonomous-login", `filling email: ${agentEmail} (via ${emailProvider.name}) into ${emailRef}`);
-    await fill(tabId, emailRef, agentEmail);
-    const submitRef = await detectSubmitButton(tabId);
-    if (submitRef) {
-      await click(tabId, submitRef);
-    } else {
-      await evaluate(tabId, `document.querySelector('${emailRef}')?.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }))`);
-    }
-    await new Promise((r) => setTimeout(r, POST_SUBMIT_SETTLE_MS));
-    const otpRef = await detectOtpInput(tabId);
-    if (otpRef) {
-      log("autonomous-login", `OTP input detected (${otpRef}), waiting for verification email via ${emailProvider.name}...`);
-      const verificationEmail = await emailProvider.waitForMessage(targetDomain, OTP_FILL_TIMEOUT_MS);
-      const otp = verificationEmail ? extractOtpFromEmail(verificationEmail.text) : null;
-      if (!otp) {
-        return { success: false, method: "failed", domain: targetDomain, email: agentEmail, cookies_stored: 0, error: "OTP email not received within timeout", duration_ms: elapsed() };
-      }
-      log("autonomous-login", `filling OTP: ${otp}`);
-      await fill(tabId, otpRef, otp);
-      const otpSubmitRef = await detectSubmitButton(tabId);
-      if (otpSubmitRef) {
-        await click(tabId, otpSubmitRef);
-      }
-      await new Promise((r) => setTimeout(r, POST_SUBMIT_SETTLE_MS));
-    } else {
-      log("autonomous-login", `no OTP input, trying magic link flow via ${emailProvider.name}...`);
-      const verificationEmail = await emailProvider.waitForMessage(targetDomain, OTP_FILL_TIMEOUT_MS);
-      const link = verificationEmail ? extractVerificationLink(verificationEmail.text, verificationEmail.html) : null;
-      if (link) {
-        log("autonomous-login", `navigating to magic link`);
-        await navigate(tabId, link);
-        await new Promise((r) => setTimeout(r, POST_SUBMIT_SETTLE_MS));
-      } else {
-        log("autonomous-login", `no magic link received, checking if already authenticated...`);
-      }
-    }
-    const success = await checkLoginSuccess(tabId, targetDomain);
-    if (success) {
-      const cookies = await getCookies(tabId);
-      const domainCookies = cookies.filter((c) => isDomainMatch(c.domain, targetDomain));
-      const storableCookies = domainCookies.map((c) => ({
-        name: c.name,
-        value: c.value,
-        domain: c.domain,
-        path: c.path,
-        secure: c.secure,
-        httpOnly: c.httpOnly,
-        sameSite: c.sameSite,
-        expires: c.expires
-      }));
-      const vaultKey = `auth:${getRegistrableDomain(targetDomain)}`;
-      await storeCredential(vaultKey, JSON.stringify({ cookies: storableCookies }));
-      await saveAuthProfileBestEffort(tabId, targetDomain, "autonomous_login");
-      log("autonomous-login", `login succeeded for ${targetDomain} — stored ${storableCookies.length} cookies (${elapsed()}ms)`);
-      return {
-        success: true,
-        method: otpRef ? "agent-mail-otp" : "agent-mail-link",
-        domain: targetDomain,
-        email: agentEmail,
-        cookies_stored: storableCookies.length,
-        duration_ms: elapsed()
-      };
-    }
-    return { success: false, method: "failed", domain: targetDomain, email: agentEmail, cookies_stored: 0, error: "login flow completed but no auth cookies detected", duration_ms: elapsed() };
-  } finally {}
-}
-var OTP_FILL_TIMEOUT_MS = 120000, POST_SUBMIT_SETTLE_MS = 3000;
-var init_autonomous_login = __esm(async () => {
-  init_client2();
-  init_logger();
-  init_email_provider();
-  init_domain();
-  await __promiseAll([
-    init_agent_mail(),
-    init_auth(),
-    init_vault()
-  ]);
+  await init_vault();
 });
 
 // ../../src/auth/runtime.ts
@@ -2802,18 +1536,6 @@ class LocalAuthRuntime {
         return true;
       }
     } catch {}
-    const url = loginUrl ?? `https://${domain}/login`;
-    try {
-      const result = await autonomousLogin(url, domain);
-      if (result.success) {
-        this.setSession(domain, "autonomous-login", 3600000);
-        log("auth-runtime", `loginIfNeeded resolved via autonomous login for ${domain} (${result.method}, ${result.duration_ms}ms)`);
-        return true;
-      }
-      log("auth-runtime", `autonomous login failed for ${domain}: ${result.error}`);
-    } catch (err) {
-      log("auth-runtime", `autonomous login error for ${domain}: ${err instanceof Error ? err.message : err}`);
-    }
     return false;
   }
   setSession(domain, token, ttlMs = 3600000) {
@@ -2823,10 +1545,7 @@ class LocalAuthRuntime {
 var authRuntime;
 var init_runtime = __esm(async () => {
   init_logger();
-  await __promiseAll([
-    init_auth(),
-    init_autonomous_login()
-  ]);
+  await init_auth();
   authRuntime = new LocalAuthRuntime;
 });
 
@@ -3032,7 +1751,6 @@ var init_execution = __esm(async () => {
     init_vault(),
     init_auth(),
     init_runtime(),
-    init_autonomous_login(),
     init_indexer(),
     init_orchestrator()
   ]);
@@ -3358,186 +2076,6 @@ function checkWalletConfigured2() {
 }
 var init_wallet2 = () => {};
 
-// ../../src/auth/bootstrap-agentmail.ts
-var exports_bootstrap_agentmail = {};
-__export(exports_bootstrap_agentmail, {
-  bootstrapAgentMailKey: () => bootstrapAgentMailKey
-});
-import os6 from "node:os";
-import fs2 from "node:fs";
-import path9 from "node:path";
-async function bootstrapAgentMailKey() {
-  log("bootstrap-agentmail", "starting — opening console.agentmail.to");
-  try {
-    await start();
-    const tabId = await getDefaultTab();
-    await networkEnable(tabId);
-    await importBrowserCookiesIntoTab(tabId, "agentmail.to");
-    await importBrowserCookiesIntoTab(tabId, "clerk.agentmail.to");
-    await importBrowserCookiesIntoTab(tabId, "github.com");
-    await navigate(tabId, CONSOLE_URL);
-    await new Promise((r) => setTimeout(r, SETTLE_MS));
-    let currentUrl = await getCurrentUrl(tabId);
-    let onDashboard = typeof currentUrl === "string" && currentUrl.includes("/dashboard");
-    if (!onDashboard) {
-      log("bootstrap-agentmail", "not logged in — looking for social OAuth");
-      const clickResult = await evaluate(tabId, `(() => {
-        // Clerk's social button class pattern
-        const socialBtns = document.querySelectorAll('.cl-socialButtonsBlockButton, [data-provider]');
-        for (const btn of socialBtns) {
-          const text = (btn.textContent || '').toLowerCase();
-          const provider = btn.getAttribute('data-provider') || '';
-          // Match any social provider — Google, GitHub, etc.
-          if (text || provider) {
-            btn.click();
-            return 'clicked:' + (provider || text.slice(0, 20));
-          }
-        }
-        // Fallback: look for any button with a known OAuth provider name
-        const btns = document.querySelectorAll('button, a');
-        for (const btn of btns) {
-          const text = (btn.textContent || '').toLowerCase();
-          if (text.includes('google') || text.includes('github') || text.includes('continue with')) {
-            btn.click();
-            return 'clicked:' + text.slice(0, 30);
-          }
-        }
-        return 'not_found';
-      })()`);
-      const clickStr = typeof clickResult === "string" ? clickResult : String(clickResult);
-      log("bootstrap-agentmail", `social button result: ${clickStr}`);
-      if (clickStr.startsWith("clicked")) {
-        log("bootstrap-agentmail", "clicked social OAuth — waiting for redirect");
-        const start2 = Date.now();
-        while (Date.now() - start2 < AUTH_TIMEOUT_MS) {
-          await new Promise((r) => setTimeout(r, 2000));
-          currentUrl = await getCurrentUrl(tabId);
-          if (typeof currentUrl === "string" && currentUrl.includes("/dashboard")) {
-            onDashboard = true;
-            log("bootstrap-agentmail", "OAuth completed — on dashboard");
-            break;
-          }
-        }
-      }
-      if (!onDashboard) {
-        log("bootstrap-agentmail", "could not auto-login — manual setup needed");
-        const pageInfo = await evaluate(tabId, `JSON.stringify({
-          url: window.location.href,
-          title: document.title,
-          visible_buttons: Array.from(document.querySelectorAll('button,a'))
-            .map(e => (e.textContent || '').trim().slice(0, 30))
-            .filter(t => t)
-            .slice(0, 10),
-        })`).catch(() => "{}");
-        return {
-          success: false,
-          method: "manual",
-          error: `Could not auto-login to AgentMail console. Page state: ${pageInfo}. Sign up at https://console.agentmail.to and create an API key manually, then: export AGENTMAIL_API_KEY=<key>`
-        };
-      }
-    }
-    log("bootstrap-agentmail", "on dashboard — navigating to API keys");
-    await navigate(tabId, `${DASHBOARD_URL}/api-keys`);
-    await new Promise((r) => setTimeout(r, SETTLE_MS));
-    const createResult = await evaluate(tabId, `(() => {
-      const btns = document.querySelectorAll('button, a');
-      for (const btn of btns) {
-        const text = (btn.textContent || '').toLowerCase();
-        if (text.includes('create') && (text.includes('key') || text.includes('api'))) {
-          btn.click();
-          return 'clicked';
-        }
-      }
-      return 'not_found';
-    })()`);
-    if (createResult === "clicked") {
-      await new Promise((r) => setTimeout(r, 2000));
-      await evaluate(tabId, `(() => {
-        const input = document.querySelector('input[placeholder*="name" i], input[name*="name" i], input[type="text"]');
-        if (input) {
-          input.value = 'unbrowse-agent';
-          input.dispatchEvent(new Event('input', { bubbles: true }));
-          input.dispatchEvent(new Event('change', { bubbles: true }));
-        }
-      })()`);
-      await evaluate(tabId, `(() => {
-        const btns = document.querySelectorAll('button');
-        for (const btn of btns) {
-          const text = (btn.textContent || '').toLowerCase();
-          if (text.includes('create') || text.includes('confirm') || text.includes('generate')) {
-            btn.click();
-            return 'clicked';
-          }
-        }
-      })()`);
-      await new Promise((r) => setTimeout(r, 2000));
-    }
-    const apiKey = await evaluate(tabId, `(() => {
-      // Look for the key in common patterns
-      // 1. Input/textarea with the key value
-      const inputs = document.querySelectorAll('input[readonly], input[type="text"], textarea, code, pre');
-      for (const el of inputs) {
-        const val = el.value || el.textContent || '';
-        // AgentMail keys typically start with 'am_' or are long alphanumeric strings
-        if (/^(am_|sk_|key_)/.test(val) || (val.length > 30 && /^[a-zA-Z0-9_-]+$/.test(val))) {
-          return val.trim();
-        }
-      }
-      // 2. Look in the page text for key patterns
-      const text = document.body.innerText;
-      const match = text.match(/(am_[a-zA-Z0-9_-]{20,}|sk_[a-zA-Z0-9_-]{20,})/);
-      if (match) return match[1];
-      return null;
-    })()`);
-    if (apiKey && typeof apiKey === "string" && apiKey.length > 10) {
-      log("bootstrap-agentmail", `extracted API key: ${apiKey.substring(0, 8)}...`);
-      await storeCredential("agentmail:api_key", apiKey);
-      persistApiKeyToShell(apiKey);
-      process.env.AGENTMAIL_API_KEY = apiKey;
-      return {
-        success: true,
-        api_key: apiKey,
-        method: onDashboard ? "existing-session" : "github-oauth"
-      };
-    }
-    return {
-      success: false,
-      error: "Reached dashboard but could not extract API key. Create one manually at https://console.agentmail.to/dashboard/api-keys"
-    };
-  } finally {
-    try {
-      await stop();
-    } catch {}
-  }
-}
-function persistApiKeyToShell(apiKey) {
-  const shell = process.env.SHELL ?? "/bin/zsh";
-  const rcFile = shell.includes("zsh") ? path9.join(os6.homedir(), ".zshrc") : path9.join(os6.homedir(), ".bashrc");
-  try {
-    const content = fs2.existsSync(rcFile) ? fs2.readFileSync(rcFile, "utf-8") : "";
-    if (content.includes("AGENTMAIL_API_KEY")) {
-      log("bootstrap-agentmail", `${rcFile} already has AGENTMAIL_API_KEY — not overwriting`);
-      return;
-    }
-    fs2.appendFileSync(rcFile, `
-# AgentMail API key (added by unbrowse setup)
-export AGENTMAIL_API_KEY="${apiKey}"
-`);
-    log("bootstrap-agentmail", `wrote AGENTMAIL_API_KEY to ${rcFile}`);
-  } catch (err) {
-    log("bootstrap-agentmail", `failed to write to ${rcFile}: ${err}`);
-  }
-}
-var CONSOLE_URL = "https://console.agentmail.to", DASHBOARD_URL = "https://console.agentmail.to/dashboard", SETTLE_MS = 3000, AUTH_TIMEOUT_MS = 120000;
-var init_bootstrap_agentmail = __esm(async () => {
-  init_client2();
-  init_logger();
-  await __promiseAll([
-    init_vault(),
-    init_auth()
-  ]);
-});
-
 // ../../src/version.ts
 var exports_version = {};
 __export(exports_version, {
@@ -3663,210 +2201,6 @@ var init_version2 = __esm(() => {
   RELEASE_MANIFEST_SIGNATURE2 = BUILD_RELEASE_MANIFEST_SIGNATURE?.trim() || "";
 });
 
-// ../../src/auth/agent-mail.ts
-var exports_agent_mail2 = {};
-__export(exports_agent_mail2, {
-  waitForVerificationEmail: () => waitForVerificationEmail2,
-  tryAgentMailAuth: () => tryAgentMailAuth2,
-  isAgentMailAvailable: () => isAgentMailAvailable2,
-  getOrCreateSiteInbox: () => getOrCreateSiteInbox2,
-  extractVerificationLink: () => extractVerificationLink2,
-  extractOtpFromEmail: () => extractOtpFromEmail2,
-  autonomousEmailLogin: () => autonomousEmailLogin2
-});
-import { AgentMailClient as AgentMailClient2 } from "agentmail";
-function getClient2() {
-  if (_client2)
-    return _client2;
-  const apiKey = process.env.AGENTMAIL_API_KEY;
-  if (!apiKey)
-    throw new Error("AGENTMAIL_API_KEY not set — cannot use agent mail");
-  _client2 = new AgentMailClient2({ apiKey });
-  return _client2;
-}
-async function getStoredInbox2(domain) {
-  const key = `${VAULT_PREFIX2}${getRegistrableDomain(domain)}`;
-  const raw = await getCredential(key);
-  if (!raw)
-    return null;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-async function storeInbox2(domain, inbox) {
-  const key = `${VAULT_PREFIX2}${getRegistrableDomain(domain)}`;
-  await storeCredential(key, JSON.stringify(inbox));
-  log("agent-mail", `stored inbox ${inbox.email} for ${domain}`);
-}
-async function getOrCreateSiteInbox2(domain) {
-  const stored = await getStoredInbox2(domain);
-  if (stored) {
-    log("agent-mail", `reusing stored inbox ${stored.email} for ${domain}`);
-    return { inboxId: stored.inboxId, email: stored.email };
-  }
-  const client = getClient2();
-  const safeDomain = getRegistrableDomain(domain).replace(/[^a-z0-9-]/gi, "-").toLowerCase();
-  const username = `unbrowse-${safeDomain}`;
-  const clientId = `unbrowse-login-${safeDomain}`;
-  try {
-    const inbox = await client.inboxes.create({
-      username,
-      domain: "agentmail.to",
-      displayName: `Unbrowse Agent - ${domain}`,
-      clientId
-    });
-    const result = { inboxId: inbox.inboxId, email: inbox.email };
-    await storeInbox2(domain, { ...result, domain, createdAt: new Date().toISOString() });
-    log("agent-mail", `created inbox ${inbox.email} for ${domain}`);
-    return result;
-  } catch (err) {
-    log("agent-mail", `create failed (likely exists), listing to find match: ${err instanceof Error ? err.message : err}`);
-    try {
-      const list = await client.inboxes.list({ limit: 100 });
-      const match = list.inboxes.find((i) => i.clientId === clientId || i.email === `${username}@agentmail.to`);
-      if (match) {
-        const result = { inboxId: match.inboxId, email: match.email };
-        await storeInbox2(domain, { ...result, domain, createdAt: new Date().toISOString() });
-        return result;
-      }
-    } catch {}
-    throw new Error(`Failed to create or find AgentMail inbox for ${domain}`);
-  }
-}
-async function waitForVerificationEmail2(inboxId, fromDomain, timeoutMs = DEFAULT_TIMEOUT_MS2) {
-  const client = getClient2();
-  const start2 = Date.now();
-  const normalizedDomain = fromDomain.toLowerCase();
-  log("agent-mail", `polling inbox ${inboxId} for email from *@${normalizedDomain} (timeout: ${timeoutMs}ms)`);
-  while (Date.now() - start2 < timeoutMs) {
-    try {
-      const response = await client.inboxes.messages.list(inboxId, {
-        limit: 10,
-        labels: ["received"]
-      });
-      for (const item of response.messages ?? []) {
-        const msg = await client.inboxes.messages.get(inboxId, item.messageId);
-        const from = typeof msg.from === "string" ? msg.from : (msg.from ?? []).join(", ");
-        if (from.toLowerCase().includes(normalizedDomain)) {
-          log("agent-mail", `found verification email from ${from}: "${msg.subject}"`);
-          return {
-            messageId: msg.messageId,
-            threadId: msg.threadId,
-            subject: msg.subject ?? "",
-            from,
-            text: msg.extractedText ?? msg.text ?? "",
-            html: msg.extractedHtml ?? msg.html ?? "",
-            receivedAt: msg.createdAt
-          };
-        }
-      }
-    } catch (err) {
-      log("agent-mail", `poll error: ${err instanceof Error ? err.message : err}`);
-    }
-    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS2));
-  }
-  log("agent-mail", `timeout waiting for email from ${normalizedDomain}`);
-  return null;
-}
-function extractOtpFromEmail2(text) {
-  const codePhrase = text.match(/(?:verification|confirm|security|login|one[- ]time|otp)\s*(?:code|pin|number)[:\s]+(\w{4,8})/i);
-  if (codePhrase)
-    return codePhrase[1];
-  const codeIs = text.match(/(?:code|otp|pin)[:\s]+(\w{4,8})/i);
-  if (codeIs)
-    return codeIs[1];
-  const six = text.match(/\b(\d{6})\b/);
-  if (six)
-    return six[1];
-  const four = text.match(/\b(\d{4})\b/);
-  if (four)
-    return four[1];
-  return null;
-}
-function extractVerificationLink2(text, html) {
-  const htmlLink = html.match(/href="(https?:\/\/[^"]*(?:verify|confirm|activate|magic|token|auth|callback|validate|approve|email)[^"]*)"/i);
-  if (htmlLink)
-    return htmlLink[1];
-  const textLink = text.match(/(https?:\/\/\S*(?:verify|confirm|activate|magic|token|auth|callback|validate|approve|email)\S*)/i);
-  if (textLink)
-    return textLink[1];
-  const anyHtmlLink = html.match(/href="(https?:\/\/[^"]+)"/);
-  if (anyHtmlLink)
-    return anyHtmlLink[1];
-  const anyTextLink = text.match(/(https?:\/\/\S+)/);
-  if (anyTextLink)
-    return anyTextLink[1];
-  return null;
-}
-async function autonomousEmailLogin2(domain) {
-  const inbox = await getOrCreateSiteInbox2(domain);
-  const client = getClient2();
-  log("agent-mail", `session ready for ${domain} — email: ${inbox.email}`);
-  return {
-    email: inbox.email,
-    inboxId: inbox.inboxId,
-    domain,
-    waitForOtp: async (timeoutMs = DEFAULT_TIMEOUT_MS2) => {
-      const email = await waitForVerificationEmail2(inbox.inboxId, domain, timeoutMs);
-      if (!email)
-        return null;
-      const otp = extractOtpFromEmail2(email.text);
-      if (otp)
-        log("agent-mail", `extracted OTP: ${otp} from ${email.subject}`);
-      return otp;
-    },
-    waitForLink: async (timeoutMs = DEFAULT_TIMEOUT_MS2) => {
-      const email = await waitForVerificationEmail2(inbox.inboxId, domain, timeoutMs);
-      if (!email)
-        return null;
-      const link = extractVerificationLink2(email.text, email.html);
-      if (link)
-        log("agent-mail", `extracted verification link from ${email.subject}`);
-      return link;
-    },
-    waitForEmail: (timeoutMs = DEFAULT_TIMEOUT_MS2) => waitForVerificationEmail2(inbox.inboxId, domain, timeoutMs),
-    sendEmail: async (to, subject, body) => {
-      const result = await client.inboxes.messages.send(inbox.inboxId, {
-        to: [to],
-        subject,
-        text: body
-      });
-      log("agent-mail", `sent email to ${to}: "${subject}" (${result.messageId})`);
-      return { messageId: result.messageId, threadId: result.threadId };
-    },
-    replyTo: async (messageId, body) => {
-      const result = await client.inboxes.messages.reply(inbox.inboxId, messageId, {
-        text: body
-      });
-      log("agent-mail", `replied to ${messageId} (${result.messageId})`);
-      return { messageId: result.messageId, threadId: result.threadId };
-    }
-  };
-}
-function isAgentMailAvailable2() {
-  return Boolean(process.env.AGENTMAIL_API_KEY);
-}
-async function tryAgentMailAuth2(domain) {
-  if (!isAgentMailAvailable2()) {
-    log("agent-mail", `skipping — AGENTMAIL_API_KEY not set`);
-    return null;
-  }
-  try {
-    return await autonomousEmailLogin2(domain);
-  } catch (err) {
-    log("agent-mail", `auth failed for ${domain}: ${err instanceof Error ? err.message : err}`);
-    return null;
-  }
-}
-var POLL_INTERVAL_MS2 = 3000, DEFAULT_TIMEOUT_MS2 = 90000, _client2 = null, VAULT_PREFIX2 = "agentmail:";
-var init_agent_mail2 = __esm(async () => {
-  init_logger();
-  init_domain();
-  await init_vault();
-});
-
 // ../../src/auth/browser-cookies.ts
 var exports_browser_cookies2 = {};
 __export(exports_browser_cookies2, {
@@ -5907,11 +4241,7 @@ async function runSetup(options) {
     browser_engine: browser,
     opencode: writeOpenCodeCommand(options?.opencode ?? "auto", cwd),
     update_hints: configureUpdateHintHooks(import.meta.url, installSource),
-    wallet,
-    agent_mail: {
-      configured: Boolean(process.env.AGENTMAIL_API_KEY),
-      message: process.env.AGENTMAIL_API_KEY ? "AgentMail configured — autonomous email login enabled." : "AgentMail not configured. Set AGENTMAIL_API_KEY to enable autonomous email login/registration. Get a key at https://agentmail.to"
-    }
+    wallet
   };
 }
 
@@ -6115,8 +4445,8 @@ function parseArgs(argv) {
   }
   return { command, args: positional, flags };
 }
-async function api2(method, path10, body) {
-  let target = `${BASE_URL}${path10}`;
+async function api2(method, path9, body) {
+  let target = `${BASE_URL}${path9}`;
   let requestBody = body;
   if (method === "GET" && body && typeof body === "object") {
     const params = new URLSearchParams;
@@ -6446,8 +4776,8 @@ async function cmdResolve(flags) {
     throw error;
   }
 }
-function drillPath(data, path10) {
-  const segments = path10.split(/\./).flatMap((s) => {
+function drillPath(data, path9) {
+  const segments = path9.split(/\./).flatMap((s) => {
     const m = s.match(/^(.+)\[\]$/);
     return m ? [m[1], "[]"] : [s];
   });
@@ -6474,9 +4804,9 @@ function drillPath(data, path10) {
   }
   return values;
 }
-function resolveDotPath(obj, path10) {
+function resolveDotPath(obj, path9) {
   let cur = obj;
-  for (const key of path10.split(".")) {
+  for (const key of path9.split(".")) {
     if (cur == null || typeof cur !== "object")
       return;
     cur = cur[key];
@@ -6493,8 +4823,8 @@ function applyExtract(items, extractSpec) {
   return items.map((item) => {
     const row = {};
     let hasValue = false;
-    for (const { alias, path: path10 } of fields) {
-      const val = resolveDotPath(item, path10);
+    for (const { alias, path: path9 } of fields) {
+      const val = resolveDotPath(item, path9);
       row[alias] = val ?? null;
       if (val != null)
         hasValue = true;
@@ -6856,21 +5186,6 @@ async function cmdSetup(flags) {
     info("Set up a wallet to start earning:");
     info("  npx @crossmint/lobster-cli setup");
   }
-  if (!report.agent_mail.configured) {
-    info("AgentMail not configured \u2014 attempting to bootstrap via console.agentmail.to...");
-    try {
-      const { bootstrapAgentMailKey: bootstrapAgentMailKey2 } = await init_bootstrap_agentmail().then(() => exports_bootstrap_agentmail);
-      const result = await bootstrapAgentMailKey2();
-      if (result.success) {
-        info(`AgentMail API key obtained (${result.method}) \u2014 autonomous email login enabled`);
-        report.agent_mail.configured = true;
-      } else {
-        info(`AgentMail bootstrap: ${result.error}`);
-      }
-    } catch (err) {
-      info(`AgentMail bootstrap failed: ${err instanceof Error ? err.message : err}`);
-    }
-  }
   const hasGcloud = (() => {
     try {
       const { existsSync: existsSync19 } = __require("fs");
@@ -6881,16 +5196,8 @@ async function cmdSetup(flags) {
       return false;
     }
   })();
-  const emailProviders = [];
-  if (hasGcloud)
-    emailProviders.push("Gmail (via GWS)");
-  if (report.agent_mail.configured)
-    emailProviders.push("AgentMail");
-  if (emailProviders.length > 0) {
-    info(`Email providers: ${emailProviders.join(", ")} \u2014 autonomous login enabled`);
-  } else {
-    info("No email provider configured \u2014 agents can't auto-register on gated sites.");
-    info("Options: export AGENTMAIL_API_KEY=<key> (https://agentmail.to) or gcloud auth login (Gmail)");
+  if (hasGcloud) {
+    info("Email provider: Gmail (via GWS) \u2014 autonomous login enabled");
   }
   await recordInstallTelemetryEvent("setup", {
     hostType,
@@ -7627,77 +5934,6 @@ async function cmdSync(flags) {
 async function cmdClose(flags) {
   output(await api2("POST", "/v1/browse/close", typeof flags.session === "string" ? { session_id: flags.session } : undefined), false);
 }
-async function cmdLoginAuto(args, flags) {
-  const urlOrDomain = args[0] ?? flags.url ?? flags.domain;
-  if (!urlOrDomain)
-    return die("usage: unbrowse login-auto <domain-or-url> [--wait-otp | --wait-link | --send-to <email>]");
-  const domain = (() => {
-    try {
-      return new URL(urlOrDomain.startsWith("http") ? urlOrDomain : `https://${urlOrDomain}`).hostname.replace(/^www\./, "");
-    } catch {
-      return urlOrDomain;
-    }
-  })();
-  const { autonomousEmailLogin: autonomousEmailLogin3, isAgentMailAvailable: isAgentMailAvailable3 } = await init_agent_mail2().then(() => exports_agent_mail2);
-  if (!isAgentMailAvailable3()) {
-    info(`[login-auto] AGENTMAIL_API_KEY not set \u2014 attempting auto-bootstrap via console.agentmail.to`);
-    try {
-      const { bootstrapAgentMailKey: bootstrapAgentMailKey2 } = await init_bootstrap_agentmail().then(() => exports_bootstrap_agentmail);
-      const bootstrap = await bootstrapAgentMailKey2();
-      if (bootstrap.success && bootstrap.api_key) {
-        process.env.AGENTMAIL_API_KEY = bootstrap.api_key;
-        info(`[login-auto] bootstrapped AgentMail key via ${bootstrap.method ?? "browser"}`);
-      } else {
-        return die(`AGENTMAIL_API_KEY not set and bootstrap failed: ${bootstrap.error ?? "unknown"}. Get a key at https://agentmail.to and run: export AGENTMAIL_API_KEY=<key>`);
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return die(`AGENTMAIL_API_KEY not set and bootstrap errored: ${msg}. Get a key at https://agentmail.to and run: export AGENTMAIL_API_KEY=<key>`);
-    }
-  }
-  info(`[login-auto] creating agent email for ${domain}...`);
-  const session = await autonomousEmailLogin3(domain);
-  info(`[login-auto] email: ${session.email}`);
-  const sendTo = flags["send-to"];
-  if (sendTo) {
-    const subject = flags.subject ?? `Verify ${domain}`;
-    const body = flags.body ?? `This is an automated verification email from Unbrowse agent for ${domain}.`;
-    info(`[login-auto] sending email to ${sendTo}...`);
-    const result = await session.sendEmail(sendTo, subject, body);
-    output({ email: session.email, sent_to: sendTo, message_id: result.messageId, domain });
-    return;
-  }
-  if (flags["wait-otp"]) {
-    const timeout = Number(flags.timeout) || 90000;
-    info(`[login-auto] waiting for OTP from ${domain} (${Math.round(timeout / 1000)}s timeout)...`);
-    const otp = await session.waitForOtp(timeout);
-    if (otp) {
-      info(`[login-auto] OTP: ${otp}`);
-      output({ email: session.email, otp, domain });
-    } else {
-      info(`[login-auto] no OTP received`);
-      output({ email: session.email, otp: null, domain, error: "timeout" });
-    }
-    return;
-  }
-  if (flags["wait-link"]) {
-    const timeout = Number(flags.timeout) || 90000;
-    info(`[login-auto] waiting for verification link from ${domain} (${Math.round(timeout / 1000)}s timeout)...`);
-    const link = await session.waitForLink(timeout);
-    if (link) {
-      info(`[login-auto] link: ${link}`);
-      output({ email: session.email, link, domain });
-    } else {
-      info(`[login-auto] no verification link received`);
-      output({ email: session.email, link: null, domain, error: "timeout" });
-    }
-    return;
-  }
-  info(`[login-auto] use this email to register/login on ${domain}`);
-  info(`[login-auto] then: unbrowse login-auto ${domain} --wait-otp`);
-  info(`[login-auto]   or: unbrowse login-auto ${domain} --wait-link`);
-  output({ email: session.email, inbox_id: session.inboxId, domain });
-}
 async function cmdSessionsScan(flags) {
   const domain = flags.domain;
   const { scanAllBrowserSessions: scanAllBrowserSessions3, findBestBrowserSession: findBestBrowserSession3 } = await Promise.resolve().then(() => (init_browser_cookies2(), exports_browser_cookies2));
@@ -7997,8 +6233,6 @@ async function main() {
     return cmdEarnings(flags);
   if (command === "sessions-scan")
     return cmdSessionsScan(flags);
-  if (command === "login-auto")
-    return cmdLoginAuto(args, flags);
   const KNOWN_COMMANDS = new Set([
     "health",
     "mcp",
@@ -8050,8 +6284,7 @@ async function main() {
     "corpus-test",
     "corpus-run",
     "sessions-scan",
-    "cache-clear",
-    "login-auto"
+    "cache-clear"
   ]);
   if (!KNOWN_COMMANDS.has(command)) {
     const pack = findSitePack(command);
@@ -8161,8 +6394,6 @@ async function main() {
       return cmdCorpusRun(flags);
     case "sessions-scan":
       return cmdSessionsScan(flags);
-    case "login-auto":
-      return cmdLoginAuto(args, flags);
     default:
       info(`Unknown command: ${command}`);
       printHelp();