mcp-scraper 0.2.20 → 0.2.21

package/dist/bin/browser-agent-stdio-server.cjs

@@ -2,16 +2,589 @@
 "use strict";
 
 // bin/browser-agent-stdio-server.ts
-var import_node_fs2 = require("fs");
-var import_node_os3 = require("os");
-var import_node_path3 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_os5 = require("os");
+var import_node_path6 = require("path");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 
 // src/mcp/browser-agent-mcp-server.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_node_fs3 = require("fs");
+var import_node_os4 = require("os");
+var import_node_path5 = require("path");
+
+// src/lib/chrome-profiles.ts
+var import_promises = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path = require("path");
+function defaultChromeUserDataDir() {
+  if (process.platform === "darwin") return (0, import_node_path.join)((0, import_node_os.homedir)(), "Library", "Application Support", "Google", "Chrome");
+  if (process.platform === "win32") {
+    return (0, import_node_path.join)(process.env.LOCALAPPDATA ?? (0, import_node_path.join)((0, import_node_os.homedir)(), "AppData", "Local"), "Google", "Chrome", "User Data");
+  }
+  return (0, import_node_path.join)(process.env.XDG_CONFIG_HOME ?? (0, import_node_path.join)((0, import_node_os.homedir)(), ".config"), "google-chrome");
+}
+function recommendedKernelProfileName(value) {
+  return value.trim().toLowerCase().replace(/@/g, "-").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "browser-profile";
+}
+async function listLocalChromeProfiles(userDataDir = defaultChromeUserDataDir(), emailFilter) {
+  const raw = await (0, import_promises.readFile)((0, import_node_path.join)(userDataDir, "Local State"), "utf8");
+  const localState = JSON.parse(raw);
+  const wanted = emailFilter?.trim().toLowerCase();
+  return Object.entries(localState.profile?.info_cache ?? {}).map(([directory, info]) => {
+    const email = (info.user_name ?? "").trim();
+    const displayName = (info.name ?? info.shortcut_name ?? "").trim();
+    const labelSource = email || displayName || directory;
+    return {
+      email,
+      displayName,
+      chromeProfileDirectory: directory,
+      chromeProfilePath: (0, import_node_path.join)(userDataDir, directory),
+      recommendedKernelProfileName: recommendedKernelProfileName(labelSource)
+    };
+  }).filter((row) => !wanted || row.email.toLowerCase() === wanted || row.displayName.toLowerCase().includes(wanted));
+}
+
+// src/lib/browser-service-env.ts
+function browserServiceProfileName() {
+  const value = (process.env.BROWSER_AGENT_PROFILE_NAME ?? process.env.BROWSER_SERVICE_PROFILE_NAME ?? process.env.KERNEL_BROWSER_PROFILE_NAME ?? process.env.KERNEL_PROFILE_NAME)?.trim();
+  return value || void 0;
+}
+function browserServiceProfileSaveChanges() {
+  const value = (process.env.BROWSER_AGENT_PROFILE_SAVE_CHANGES ?? process.env.BROWSER_SERVICE_PROFILE_SAVE_CHANGES ?? process.env.KERNEL_BROWSER_PROFILE_SAVE_CHANGES ?? process.env.KERNEL_PROFILE_SAVE_CHANGES)?.trim().toLowerCase();
+  if (!value) return void 0;
+  if (["1", "true", "yes", "on"].includes(value)) return true;
+  if (["0", "false", "no", "off"].includes(value)) return false;
+  return void 0;
+}
+
+// src/lib/local-browser-profiles.ts
 var import_node_fs = require("fs");
+var import_promises2 = require("fs/promises");
 var import_node_os2 = require("os");
 var import_node_path2 = require("path");
+var EXCLUDED_PROFILE_NAMES = [
+  "Cache",
+  "Code Cache",
+  "Crashpad",
+  "DawnCache",
+  "DawnGraphiteCache",
+  "DawnWebGPUCache",
+  "GPUCache",
+  "GrShaderCache",
+  "ShaderCache",
+  "Shared Dictionary"
+];
+function defaultImportedBrowserProfilesDir() {
+  return process.env.MCP_SCRAPER_BROWSER_PROFILE_BASE_DIR?.trim() || (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".mcp-scraper", "browser-profiles");
+}
+function defaultChromeExecutablePath() {
+  const envPath = process.env.MCP_SCRAPER_BROWSER_EXECUTABLE?.trim() || process.env.CHROME_PATH?.trim();
+  if (envPath) return envPath;
+  const candidates = process.platform === "darwin" ? ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"] : process.platform === "win32" ? [
+    (0, import_node_path2.join)(process.env.PROGRAMFILES ?? "C:\\Program Files", "Google", "Chrome", "Application", "chrome.exe"),
+    (0, import_node_path2.join)(process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)", "Google", "Chrome", "Application", "chrome.exe")
+  ] : ["/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/chromium-browser", "/usr/bin/chromium"];
+  return candidates.find((candidate) => (0, import_node_fs.existsSync)(candidate));
+}
+function localBrowserModeEnabled() {
+  return process.env.MCP_SCRAPER_BROWSER_MODE?.trim().toLowerCase() === "local";
+}
+function importedProfileName(value) {
+  return recommendedKernelProfileName(value);
+}
+function importedProfileRoot(name, outputDir = defaultImportedBrowserProfilesDir()) {
+  return (0, import_node_path2.join)(outputDir, importedProfileName(name));
+}
+function importedProfileManifestPath(name, outputDir = defaultImportedBrowserProfilesDir()) {
+  return (0, import_node_path2.join)(importedProfileRoot(name, outputDir), "manifest.json");
+}
+function importedProfileUserDataDir(name, outputDir = defaultImportedBrowserProfilesDir()) {
+  return (0, import_node_path2.join)(importedProfileRoot(name, outputDir), "user-data");
+}
+async function readExistingManifest(path) {
+  try {
+    return JSON.parse(await (0, import_promises2.readFile)(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function isExcludedProfilePath(sourceRoot, sourcePath) {
+  const rel = (0, import_node_path2.relative)(sourceRoot, sourcePath);
+  if (!rel) return false;
+  const parts = rel.split(import_node_path2.sep).filter(Boolean);
+  const last = parts[parts.length - 1] ?? "";
+  if (last.startsWith("Singleton")) return true;
+  if (last === "LOCK" || last.endsWith(".lock")) return true;
+  if (parts.some((part) => EXCLUDED_PROFILE_NAMES.includes(part))) return true;
+  if (parts.includes("Service Worker") && parts.includes("CacheStorage")) return true;
+  return false;
+}
+async function copyProfileTree(sourceProfilePath, destinationProfilePath) {
+  await (0, import_promises2.cp)(sourceProfilePath, destinationProfilePath, {
+    recursive: true,
+    force: true,
+    errorOnExist: false,
+    dereference: false,
+    filter: (source) => !isExcludedProfilePath(sourceProfilePath, source)
+  });
+}
+function selectProfile(profiles, options) {
+  const requestedDirectory = options.chromeProfileDirectory?.trim();
+  const requestedEmail = options.email?.trim().toLowerCase();
+  const exactDirectory = requestedDirectory ? profiles.find((profile) => profile.chromeProfileDirectory === requestedDirectory) : void 0;
+  if (exactDirectory) return exactDirectory;
+  const exactEmail = requestedEmail ? profiles.find((profile) => profile.email.toLowerCase() === requestedEmail) : void 0;
+  if (exactEmail) return exactEmail;
+  const first = profiles[0];
+  if (first) return first;
+  const hint = requestedDirectory ? `Chrome profile directory "${requestedDirectory}"` : requestedEmail ? `Chrome account "${requestedEmail}"` : "Chrome profile";
+  throw new Error(`${hint} was not found in ${options.sourceUserDataDir ?? defaultChromeUserDataDir()}`);
+}
+async function ensureProfilePathExists(profile) {
+  const details = await (0, import_promises2.stat)(profile.chromeProfilePath).catch(() => null);
+  if (!details?.isDirectory()) {
+    throw new Error(`Chrome profile path does not exist or is not a directory: ${profile.chromeProfilePath}`);
+  }
+}
+async function writeNormalizedLocalState(sourceLocalStatePath, destinationLocalStatePath, sourceProfileDirectory) {
+  const raw = await (0, import_promises2.readFile)(sourceLocalStatePath, "utf8");
+  const localState = JSON.parse(raw);
+  const selectedInfo = localState.profile?.info_cache?.[sourceProfileDirectory] ?? localState.profile?.info_cache?.Default ?? {};
+  localState.profile = {
+    ...localState.profile ?? {},
+    info_cache: { Default: selectedInfo },
+    last_used: "Default",
+    last_active_profiles: ["Default"]
+  };
+  await (0, import_promises2.writeFile)(destinationLocalStatePath, `${JSON.stringify(localState, null, 2)}
+`);
+}
+async function importChromeProfile(options = {}) {
+  const sourceUserDataDir = options.sourceUserDataDir?.trim() || defaultChromeUserDataDir();
+  const profiles = await listLocalChromeProfiles(sourceUserDataDir, options.email);
+  const sourceProfile = selectProfile(profiles, { ...options, sourceUserDataDir });
+  await ensureProfilePathExists(sourceProfile);
+  const name = importedProfileName(options.name?.trim() || sourceProfile.recommendedKernelProfileName);
+  const outputDir = options.outputDir?.trim() || defaultImportedBrowserProfilesDir();
+  const profileRoot = importedProfileRoot(name, outputDir);
+  const manifestPath = importedProfileManifestPath(name, outputDir);
+  const userDataDir = importedProfileUserDataDir(name, outputDir);
+  const existingManifest = await readExistingManifest(manifestPath);
+  const existing = (0, import_node_fs.existsSync)(profileRoot);
+  if (existing && !options.overwrite) {
+    throw new Error(`Imported browser profile "${name}" already exists at ${profileRoot}. Re-run with --overwrite to refresh it.`);
+  }
+  if (existing) await (0, import_promises2.rm)(profileRoot, { recursive: true, force: true });
+  await (0, import_promises2.mkdir)((0, import_node_path2.join)(userDataDir, "Default"), { recursive: true });
+  await writeNormalizedLocalState(
+    (0, import_node_path2.join)(sourceUserDataDir, "Local State"),
+    (0, import_node_path2.join)(userDataDir, "Local State"),
+    sourceProfile.chromeProfileDirectory
+  );
+  await copyProfileTree(sourceProfile.chromeProfilePath, (0, import_node_path2.join)(userDataDir, "Default"));
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const manifest = {
+    layoutVersion: 1,
+    name,
+    profileRoot,
+    userDataDir,
+    browserExecutablePath: options.browserExecutablePath?.trim() || defaultChromeExecutablePath() || null,
+    sourceUserDataDir,
+    sourceProfileDirectory: sourceProfile.chromeProfileDirectory,
+    sourceProfilePath: sourceProfile.chromeProfilePath,
+    email: sourceProfile.email,
+    displayName: sourceProfile.displayName,
+    createdAt: existingManifest?.createdAt ?? now,
+    updatedAt: now,
+    copyMode: "chrome-profile-clone"
+  };
+  await (0, import_promises2.writeFile)(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+  return {
+    profile: manifest,
+    sourceProfile,
+    excludedNames: EXCLUDED_PROFILE_NAMES
+  };
+}
+async function loadImportedBrowserProfile(name = process.env.MCP_SCRAPER_BROWSER_PROFILE?.trim() || "default", outputDir = defaultImportedBrowserProfilesDir()) {
+  const profileName = importedProfileName(name);
+  const manifestPath = importedProfileManifestPath(profileName, outputDir);
+  const manifest = await readExistingManifest(manifestPath);
+  if (!manifest) {
+    throw new Error(
+      `Imported browser profile "${profileName}" was not found. Run: mcp-scraper-cli browser import-chrome --name ${profileName}`
+    );
+  }
+  return manifest;
+}
+async function syncImportedChromeProfile(name, options = {}) {
+  const outputDir = options.outputDir?.trim() || defaultImportedBrowserProfilesDir();
+  const manifest = await loadImportedBrowserProfile(name, outputDir);
+  return importChromeProfile({
+    name: manifest.name,
+    sourceUserDataDir: manifest.sourceUserDataDir,
+    chromeProfileDirectory: manifest.sourceProfileDirectory,
+    outputDir,
+    overwrite: true,
+    browserExecutablePath: options.browserExecutablePath ?? manifest.browserExecutablePath ?? void 0
+  });
+}
+
+// src/services/browser-agent/local-browser-agent-service.ts
+var import_node_crypto = require("crypto");
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+var import_playwright = require("playwright");
+function directProfileDir() {
+  return process.env.MCP_SCRAPER_BROWSER_PROFILE_DIR?.trim() || void 0;
+}
+function configuredProfileName(profile) {
+  return profile?.trim() || process.env.MCP_SCRAPER_BROWSER_PROFILE?.trim() || (directProfileDir() ? (0, import_node_path3.basename)(directProfileDir()) : "default");
+}
+function launchExecutablePath(profile) {
+  const configured = process.env.MCP_SCRAPER_BROWSER_EXECUTABLE?.trim() || profile.browserExecutablePath || defaultChromeExecutablePath();
+  return configured && (0, import_node_fs2.existsSync)(configured) ? configured : void 0;
+}
+function ignoreDefaultArgsFor(executablePath) {
+  if (!executablePath) return void 0;
+  if (process.platform !== "darwin") return void 0;
+  if (!/Google Chrome\.app\/Contents\/MacOS\/Google Chrome$/.test(executablePath)) return void 0;
+  return ["--password-store=basic", "--use-mock-keychain"];
+}
+function normalizeKeyCombo(value) {
+  return value.split("+").map((part) => {
+    const trimmed = part.trim();
+    const lower = trimmed.toLowerCase();
+    if (lower === "ctrl" || lower === "control") return "Control";
+    if (lower === "cmd" || lower === "command" || lower === "meta") return "Meta";
+    if (lower === "option" || lower === "alt") return "Alt";
+    if (lower === "return") return "Enter";
+    if (lower === "esc") return "Escape";
+    if (trimmed.length === 1) return trimmed.toUpperCase();
+    return trimmed;
+  }).join("+");
+}
+function sessionSummary(session) {
+  return {
+    session_id: session.sessionId,
+    status: session.status,
+    label: session.label,
+    profile: session.profileName,
+    user_data_dir: session.userDataDir,
+    created_at: session.createdAt,
+    last_action_at: session.lastActionAt,
+    closed_at: session.closedAt,
+    watch_url: `local://browser-session/${session.sessionId}`,
+    url: session.status === "open" ? session.page.url() : null
+  };
+}
+var LocalBrowserAgentService = class {
+  contexts = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  async open(input) {
+    const profile = await this.resolveProfile(input.profile);
+    const contextState = await this.ensureContext(profile);
+    const pages = contextState.context.pages();
+    const page = pages.length === 1 && !this.hasOpenSessionForContext(contextState.key) ? pages[0] : await contextState.context.newPage();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sessionId = `lbs_${(0, import_node_crypto.randomUUID)().replace(/-/g, "").slice(0, 20)}`;
+    const session = {
+      sessionId,
+      label: input.label ?? null,
+      page,
+      contextKey: contextState.key,
+      profileName: profile.name,
+      userDataDir: profile.userDataDir,
+      createdAt: now,
+      lastActionAt: now,
+      closedAt: null,
+      status: "open"
+    };
+    const timeoutSeconds = input.timeout_seconds ?? 600;
+    if (timeoutSeconds > 0) {
+      session.timeout = setTimeout(() => {
+        void this.close(sessionId);
+      }, timeoutSeconds * 1e3);
+      session.timeout.unref();
+    }
+    this.sessions.set(sessionId, session);
+    if (input.url) await this.goto(sessionId, input.url);
+    return {
+      session_id: sessionId,
+      watch_url: `local://browser-session/${sessionId}`,
+      live_view_url: null,
+      profile: profile.name,
+      user_data_dir: profile.userDataDir,
+      url: input.url ?? null,
+      mode: "local"
+    };
+  }
+  async screenshot(sessionId) {
+    const session = this.requireOpenSession(sessionId);
+    await this.waitForPage(session.page);
+    const image = await session.page.screenshot({ type: "png", fullPage: false });
+    const page = await this.read(sessionId);
+    return {
+      ...page,
+      image_base64: image.toString("base64"),
+      mime_type: "image/png"
+    };
+  }
+  async read(sessionId) {
+    const session = this.requireOpenSession(sessionId);
+    await this.waitForPage(session.page);
+    this.touch(session);
+    const title = await session.page.title().catch(() => "");
+    const snapshot = await session.page.evaluate(() => {
+      const cssEscape = (value) => {
+        const escapeFn = globalThis.CSS?.escape;
+        return escapeFn ? escapeFn(value) : value.replace(/["\\#.:>+~[\]()]/g, "\\$&");
+      };
+      const textFor = (element) => {
+        const html = element;
+        return (element.getAttribute("aria-label") || element.getAttribute("title") || html.placeholder || html.value || html.innerText || element.textContent || "").replace(/\s+/g, " ").trim();
+      };
+      const selectorFor = (element) => {
+        const id = element.id;
+        if (id) return `#${cssEscape(id)}`;
+        const name = element.getAttribute("name");
+        const tag = element.tagName.toLowerCase();
+        if (name) return `${tag}[name="${name.replace(/"/g, '\\"')}"]`;
+        const parts = [];
+        let current = element;
+        while (current && current !== document.body && parts.length < 4) {
+          const currentTag = current.tagName.toLowerCase();
+          const parent = current.parentElement;
+          if (!parent) {
+            parts.unshift(currentTag);
+            break;
+          }
+          const children = Array.from(parent.children);
+          const siblings = children.filter((child) => child.tagName === current.tagName);
+          const index = siblings.indexOf(current) + 1;
+          parts.unshift(siblings.length > 1 ? `${currentTag}:nth-of-type(${index})` : currentTag);
+          current = parent;
+        }
+        return parts.join(" > ") || tag;
+      };
+      const candidates = Array.from(document.querySelectorAll(
+        'a, button, input, textarea, select, summary, [role], [contenteditable="true"], [tabindex]:not([tabindex="-1"])'
+      ));
+      const elements = candidates.map((element, index) => {
+        const rect = element.getBoundingClientRect();
+        const style = window.getComputedStyle(element);
+        const visible = rect.width > 0 && rect.height > 0 && style.display !== "none" && style.visibility !== "hidden" && Number(style.opacity || "1") > 0;
+        if (!visible) return null;
+        const label = textFor(element);
+        return {
+          index,
+          tag: element.tagName.toLowerCase(),
+          role: element.getAttribute("role") || null,
+          text: label.slice(0, 180),
+          selector: selectorFor(element),
+          x: Math.round(rect.left + rect.width / 2),
+          y: Math.round(rect.top + rect.height / 2),
+          left: Math.round(rect.left),
+          top: Math.round(rect.top),
+          width: Math.round(rect.width),
+          height: Math.round(rect.height)
+        };
+      }).filter(Boolean).slice(0, 120);
+      return {
+        text: (document.body?.innerText || "").replace(/\n{3,}/g, "\n\n").slice(0, 3e4),
+        elements,
+        viewport: {
+          width: window.innerWidth,
+          height: window.innerHeight,
+          devicePixelRatio: window.devicePixelRatio,
+          scrollX: window.scrollX,
+          scrollY: window.scrollY
+        }
+      };
+    });
+    return {
+      url: session.page.url(),
+      title,
+      text: snapshot.text,
+      elements: snapshot.elements,
+      viewport: snapshot.viewport
+    };
+  }
+  async locate(sessionId, targets) {
+    const session = this.requireOpenSession(sessionId);
+    this.touch(session);
+    const located = [];
+    for (const target of targets) {
+      try {
+        const locator = target.selector ? session.page.locator(target.selector) : session.page.getByText(target.text ?? "", { exact: target.match === "exact" });
+        const selected = locator.nth(target.index ?? 0);
+        await selected.waitFor({ state: "visible", timeout: 3e3 }).catch(() => void 0);
+        const box = await selected.boundingBox();
+        const text = await selected.textContent({ timeout: 1e3 }).catch(() => null);
+        located.push({
+          input: target,
+          found: Boolean(box),
+          element: box ? {
+            left: Math.round(box.x),
+            top: Math.round(box.y),
+            width: Math.round(box.width),
+            height: Math.round(box.height),
+            x: Math.round(box.x + box.width / 2),
+            y: Math.round(box.y + box.height / 2),
+            text: (text ?? "").replace(/\s+/g, " ").trim().slice(0, 220)
+          } : null
+        });
+      } catch (err) {
+        located.push({
+          input: target,
+          found: false,
+          element: null,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    const read = await this.read(sessionId);
+    return {
+      url: read.url,
+      title: read.title,
+      viewport: read.viewport,
+      replay: null,
+      targets: located
+    };
+  }
+  async goto(sessionId, url) {
+    const session = this.requireOpenSession(sessionId);
+    this.touch(session);
+    const response = await session.page.goto(url, { waitUntil: "domcontentloaded", timeout: 45e3 }).catch((err) => {
+      throw new Error(err instanceof Error ? err.message : String(err));
+    });
+    await this.waitForPage(session.page);
+    return {
+      ok: true,
+      url: session.page.url(),
+      status: response?.status() ?? null,
+      mode: "local"
+    };
+  }
+  async click(sessionId, input) {
+    const session = this.requireOpenSession(sessionId);
+    this.touch(session);
+    await session.page.mouse.click(input.x, input.y, {
+      button: input.button ?? "left",
+      clickCount: input.num_clicks ?? 1
+    });
+    await this.waitForPage(session.page);
+    return { ok: true, mode: "local", url: session.page.url() };
+  }
+  async type(sessionId, input) {
+    const session = this.requireOpenSession(sessionId);
+    this.touch(session);
+    await session.page.keyboard.type(input.text, { delay: input.delay });
+    return { ok: true, mode: "local", url: session.page.url() };
+  }
+  async scroll(sessionId, input) {
+    const session = this.requireOpenSession(sessionId);
+    this.touch(session);
+    if (typeof input.x === "number" && typeof input.y === "number") {
+      await session.page.mouse.move(input.x, input.y);
+    }
+    await session.page.mouse.wheel((input.delta_x ?? 0) * 120, (input.delta_y ?? 5) * 120);
+    await session.page.waitForTimeout(150).catch(() => void 0);
+    return { ok: true, mode: "local", url: session.page.url() };
+  }
+  async press(sessionId, input) {
+    const session = this.requireOpenSession(sessionId);
+    this.touch(session);
+    for (const key of input.keys) {
+      await session.page.keyboard.press(normalizeKeyCombo(key));
+    }
+    await this.waitForPage(session.page);
+    return { ok: true, mode: "local", url: session.page.url() };
+  }
+  async close(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session || session.status === "closed") {
+      return { ok: true, closed: true, already_closed: true, mode: "local" };
+    }
+    if (session.timeout) clearTimeout(session.timeout);
+    session.status = "closed";
+    session.closedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await session.page.close().catch(() => void 0);
+    await this.closeContextIfUnused(session.contextKey);
+    return { ok: true, closed: true, mode: "local" };
+  }
+  list(includeClosed = false) {
+    return Array.from(this.sessions.values()).filter((session) => includeClosed || session.status === "open").map(sessionSummary);
+  }
+  async resolveProfile(profile) {
+    const directDir = directProfileDir();
+    const requestedName = configuredProfileName(profile);
+    if (directDir && (!profile || requestedName === process.env.MCP_SCRAPER_BROWSER_PROFILE?.trim())) {
+      return {
+        name: requestedName,
+        userDataDir: directDir,
+        browserExecutablePath: process.env.MCP_SCRAPER_BROWSER_EXECUTABLE?.trim() || defaultChromeExecutablePath() || null,
+        manifest: null
+      };
+    }
+    const manifest = await loadImportedBrowserProfile(requestedName);
+    return {
+      name: manifest.name,
+      userDataDir: manifest.userDataDir,
+      browserExecutablePath: manifest.browserExecutablePath,
+      manifest
+    };
+  }
+  async ensureContext(profile) {
+    const existing = this.contexts.get(profile.userDataDir);
+    if (existing) return existing;
+    const executablePath = launchExecutablePath(profile);
+    const context = await import_playwright.chromium.launchPersistentContext(profile.userDataDir, {
+      headless: false,
+      viewport: { width: 1440, height: 900 },
+      acceptDownloads: true,
+      ...executablePath ? { executablePath } : {},
+      ...ignoreDefaultArgsFor(executablePath) ? { ignoreDefaultArgs: ignoreDefaultArgsFor(executablePath) } : {}
+    });
+    const state = { key: profile.userDataDir, context, profile };
+    context.on("close", () => {
+      this.contexts.delete(profile.userDataDir);
+      const closedAt = (/* @__PURE__ */ new Date()).toISOString();
+      for (const session of this.sessions.values()) {
+        if (session.contextKey === profile.userDataDir && session.status === "open") {
+          session.status = "closed";
+          session.closedAt = closedAt;
+          if (session.timeout) clearTimeout(session.timeout);
+        }
+      }
+    });
+    this.contexts.set(profile.userDataDir, state);
+    return state;
+  }
+  requireOpenSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session || session.status !== "open") throw new Error(`Local browser session not found or closed: ${sessionId}`);
+    return session;
+  }
+  touch(session) {
+    session.lastActionAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  hasOpenSessionForContext(contextKey) {
+    return Array.from(this.sessions.values()).some((session) => session.contextKey === contextKey && session.status === "open");
+  }
+  async closeContextIfUnused(contextKey) {
+    if (this.hasOpenSessionForContext(contextKey)) return;
+    const state = this.contexts.get(contextKey);
+    if (!state) return;
+    this.contexts.delete(contextKey);
+    await state.context.close().catch(() => void 0);
+  }
+  async waitForPage(page) {
+    await page.waitForLoadState("domcontentloaded", { timeout: 5e3 }).catch(() => void 0);
+    await page.waitForTimeout(200).catch(() => void 0);
+  }
+};
 
 // src/version.ts
 var PACKAGE_VERSION = "0.2.20";
@@ -34,8 +607,35 @@ var BrowserOpenInputSchema = {
   label: import_zod.z.string().optional().describe("Optional human label for this session, shown in the watch console."),
   url: import_zod.z.string().url().optional().describe("Optional URL to navigate to immediately after opening."),
   profile: import_zod.z.string().optional().describe("Optional saved profile name to load a logged-in session for a site."),
+  save_profile_changes: import_zod.z.boolean().optional().describe("Persist cookies and local storage back to the named profile when the session is closed. Use this for profile setup or intentional auth refreshes; avoid parallel sessions writing to the same profile."),
   timeout_seconds: import_zod.z.number().int().min(60).max(259200).optional().describe("How long the session may live before auto-termination. Defaults to 600. The browser idles into a zero-cost standby between actions, so a longer timeout is cheap.")
 };
+var BrowserProfileListInputSchema = {
+  email: import_zod.z.string().optional().describe("Optional Chrome account email or displayed profile name to filter for, for example seo@example.com."),
+  user_data_dir: import_zod.z.string().optional().describe("Optional Chrome user data directory. Defaults to the current OS Chrome profile root.")
+};
+var BrowserProfileOnboardInputSchema = {
+  email: import_zod.z.string().optional().describe("Optional local Chrome account email to find and convert into a suggested Kernel profile name."),
+  profile: import_zod.z.string().optional().describe("Optional Kernel browser profile name to create/load. If omitted, email is used to derive one."),
+  user_data_dir: import_zod.z.string().optional().describe("Optional Chrome user data directory for email lookup. Defaults to the current OS Chrome profile root."),
+  url: import_zod.z.string().url().optional().describe("Setup URL to open after creating the browser. Defaults to https://accounts.google.com/."),
+  label: import_zod.z.string().optional().describe("Optional human label for this setup session."),
+  timeout_seconds: import_zod.z.number().int().min(60).max(259200).optional().describe("How long the setup session may live before auto-termination. Defaults to 600.")
+};
+var BrowserProfileImportInputSchema = {
+  email: import_zod.z.string().optional().describe("Optional Chrome account email or displayed profile name to select from Chrome Local State."),
+  name: import_zod.z.string().optional().describe("Name for the managed MCP Scraper browser profile. Defaults to a slug derived from the selected Chrome account."),
+  chrome_profile_directory: import_zod.z.string().optional().describe("Optional Chrome profile directory to import, for example Default or Profile 1."),
+  user_data_dir: import_zod.z.string().optional().describe("Optional source Chrome user data directory. Defaults to the current OS Chrome profile root."),
+  output_dir: import_zod.z.string().optional().describe("Optional managed profile base directory. Defaults to ~/.mcp-scraper/browser-profiles."),
+  browser_executable_path: import_zod.z.string().optional().describe("Optional Chrome executable path for local browser launches. Defaults to the installed Google Chrome path when found."),
+  overwrite: import_zod.z.boolean().default(false).describe("Overwrite an existing managed profile clone with the same name.")
+};
+var BrowserProfileSyncInputSchema = {
+  name: import_zod.z.string().describe("Managed MCP Scraper browser profile name to refresh from its recorded source Chrome profile."),
+  output_dir: import_zod.z.string().optional().describe("Optional managed profile base directory. Defaults to ~/.mcp-scraper/browser-profiles."),
+  browser_executable_path: import_zod.z.string().optional().describe("Optional Chrome executable path to store in the refreshed profile manifest.")
+};
 var BrowserSessionInputSchema = {
   session_id: import_zod.z.string().describe("The session id returned by browser_open or browser_list_sessions. Use only a returned session_id; do not construct one yourself.")
 };
@@ -140,6 +740,43 @@ var BrowserOpenOutputSchema = {
   hint: import_zod.z.string(),
   raw: BrowserRawObject.optional()
 };
+var BrowserProfileListOutputSchema = {
+  ok: import_zod.z.boolean(),
+  tool: import_zod.z.literal("browser_profile_list"),
+  session_id: import_zod.z.null(),
+  profiles: import_zod.z.array(BrowserRawObject),
+  count: import_zod.z.number().int().min(0),
+  hint: import_zod.z.string()
+};
+var BrowserProfileOnboardOutputSchema = {
+  ok: import_zod.z.boolean(),
+  tool: import_zod.z.literal("browser_profile_onboard"),
+  session_id: import_zod.z.string(),
+  watch_url: import_zod.z.string(),
+  live_view_url: NullableString,
+  profile: import_zod.z.string(),
+  setup_url: import_zod.z.string(),
+  chrome_profile: BrowserRawObject.nullable(),
+  next_steps: import_zod.z.array(import_zod.z.string()),
+  raw: BrowserRawObject.optional()
+};
+var BrowserProfileImportOutputSchema = {
+  ok: import_zod.z.boolean(),
+  tool: import_zod.z.literal("browser_profile_import"),
+  session_id: import_zod.z.null(),
+  profile: BrowserRawObject,
+  source_profile: BrowserRawObject,
+  next_steps: import_zod.z.array(import_zod.z.string()),
+  hint: import_zod.z.string()
+};
+var BrowserProfileSyncOutputSchema = {
+  ok: import_zod.z.boolean(),
+  tool: import_zod.z.literal("browser_profile_sync"),
+  session_id: import_zod.z.null(),
+  profile: BrowserRawObject,
+  source_profile: BrowserRawObject,
+  hint: import_zod.z.string()
+};
 var BrowserScreenshotOutputSchema = {
   ...BrowserBaseOutput,
   tool: import_zod.z.literal("browser_screenshot"),
@@ -240,9 +877,9 @@ var BrowserListSessionsOutputSchema = {
 
 // src/mcp/replay-annotator.ts
 var import_node_child_process = require("child_process");
-var import_promises = require("fs/promises");
-var import_node_os = require("os");
-var import_node_path = require("path");
+var import_promises3 = require("fs/promises");
+var import_node_os3 = require("os");
+var import_node_path4 = require("path");
 var import_node_util = require("util");
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
 function finiteNumber(value) {
@@ -465,10 +1102,10 @@ function ffmpegFilterPath(path) {
 async function annotateReplayVideo(inputFilePath, outputFilePath, options) {
   if (!options.annotations.length) throw new Error("annotations must include at least one item");
   const size = await videoSize(inputFilePath);
-  const tmp = await (0, import_promises.mkdtemp)((0, import_node_path.join)((0, import_node_os.tmpdir)(), "mcp-scraper-ass-"));
-  const assPath = (0, import_node_path.join)(tmp, "annotations.ass");
+  const tmp = await (0, import_promises3.mkdtemp)((0, import_node_path4.join)((0, import_node_os3.tmpdir)(), "mcp-scraper-ass-"));
+  const assPath = (0, import_node_path4.join)(tmp, "annotations.ass");
   try {
-    await (0, import_promises.writeFile)(assPath, buildAssSubtitle(options, size), "utf8");
+    await (0, import_promises3.writeFile)(assPath, buildAssSubtitle(options, size), "utf8");
     await execFileAsync("ffmpeg", [
       "-y",
       "-i",
@@ -485,7 +1122,7 @@ async function annotateReplayVideo(inputFilePath, outputFilePath, options) {
       "copy",
       outputFilePath
     ], { maxBuffer: 1024 * 1024 * 20 });
-    const out = await (0, import_promises.stat)(outputFilePath);
+    const out = await (0, import_promises3.stat)(outputFilePath);
     return {
       filePath: outputFilePath,
       bytes: out.size,
@@ -494,7 +1131,7 @@ async function annotateReplayVideo(inputFilePath, outputFilePath, options) {
       annotationCount: options.annotations.length
     };
   } finally {
-    await (0, import_promises.rm)(tmp, { recursive: true, force: true });
+    await (0, import_promises3.rm)(tmp, { recursive: true, force: true });
   }
 }
 
@@ -535,7 +1172,7 @@ function actionResult(tool, sessionId, ok, data, nextRecommendedTool = "browser_
   });
 }
 function outputBaseDir() {
-  return process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || (0, import_node_path2.join)((0, import_node_os2.homedir)(), "Downloads", "mcp-scraper");
+  return process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || (0, import_node_path5.join)((0, import_node_os4.homedir)(), "Downloads", "mcp-scraper");
 }
 function safeFilePart(value) {
   return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 120) || "replay";
@@ -544,7 +1181,7 @@ function replayFilePath(sessionId, replayId, filename) {
   const requested = filename?.trim();
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const name = requested ? safeFilePart(requested).replace(/\.mp4$/i, "") : `${stamp}-${safeFilePart(sessionId)}-${safeFilePart(replayId)}`;
-  return (0, import_node_path2.join)(outputBaseDir(), "browser-replays", `${name}.mp4`);
+  return (0, import_node_path5.join)(outputBaseDir(), "browser-replays", `${name}.mp4`);
 }
 function annotatedReplayFilePath(sessionId, replayId, filename) {
   const requested = filename?.trim();
@@ -580,6 +1217,7 @@ function registerBrowserAgentMcpTools(server2, opts) {
   const baseUrl2 = opts.baseUrl.replace(/\/$/, "");
   const consoleBase = (opts.consoleBaseUrl ?? opts.baseUrl).replace(/\/$/, "");
   const timeoutMs = opts.timeoutMs ?? 9e4;
+  const localBrowser = new LocalBrowserAgentService();
   async function req(method, path, body) {
     try {
       const res = await fetch(`${baseUrl2}${path}`, {
@@ -608,8 +1246,8 @@ function registerBrowserAgentMcpTools(server2, opts) {
       }
       const bytes = Buffer.from(await res.arrayBuffer());
       const filePath = replayFilePath(sessionId, replayId, filename);
-      (0, import_node_fs.mkdirSync)((0, import_node_path2.join)(outputBaseDir(), "browser-replays"), { recursive: true });
-      (0, import_node_fs.writeFileSync)(filePath, bytes);
+      (0, import_node_fs3.mkdirSync)((0, import_node_path5.join)(outputBaseDir(), "browser-replays"), { recursive: true });
+      (0, import_node_fs3.writeFileSync)(filePath, bytes);
       return {
         ok: true,
         data: {
@@ -631,19 +1269,195 @@ function registerBrowserAgentMcpTools(server2, opts) {
     idempotentHint: false,
     openWorldHint: true
   });
+  function selectChromeProfile(matches, email) {
+    const wanted = email?.trim().toLowerCase();
+    if (!wanted) return matches[0] ?? null;
+    return matches.find((profile) => profile.email.toLowerCase() === wanted) ?? matches[0] ?? null;
+  }
+  function localReplayUnsupported(tool, sessionId = null, replayId = null) {
+    return errorResult(tool, {
+      error: "Local browser mode does not support replay recording yet. Use hosted mode for browser_replay_* tools.",
+      mode: "local"
+    }, sessionId, replayId);
+  }
+  server2.registerTool(
+    "browser_profile_list",
+    {
+      title: "List Local Chrome Profiles",
+      description: "List local Chrome profile metadata visible to this MCP server: account email, Chrome profile directory, local path, and a suggested managed browser profile name. This reads Chrome Local State only; it does not read cookies, passwords, browsing history, or copy local browser state. Use browser_profile_import when the user wants MCP Scraper to clone a local Chrome profile for local browser mode.",
+      inputSchema: BrowserProfileListInputSchema,
+      outputSchema: BrowserProfileListOutputSchema,
+      annotations: annotations("List Local Chrome Profiles", true)
+    },
+    async (input) => {
+      try {
+        const profiles = await listLocalChromeProfiles(input.user_data_dir, input.email);
+        return structuredResult({
+          ok: true,
+          tool: "browser_profile_list",
+          session_id: null,
+          profiles,
+          count: profiles.length,
+          hint: "Use browser_profile_import to clone one profile for local mode. Use browser_profile_onboard only for hosted Kernel profile setup."
+        });
+      } catch (err) {
+        return errorResult("browser_profile_list", { error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+  );
+  server2.registerTool(
+    "browser_profile_import",
+    {
+      title: "Import Local Chrome Profile",
+      description: "Clone one local Chrome profile into MCP Scraper managed storage for local browser mode. This copies browser state files such as cookies, history, local storage, session storage, and password database metadata into ~/.mcp-scraper/browser-profiles by default; it skips cache and lock files and never prints cookie or password values. Use this when the user wants browser_open to run locally with their existing logged-in Chrome state.",
+      inputSchema: BrowserProfileImportInputSchema,
+      outputSchema: BrowserProfileImportOutputSchema,
+      annotations: { title: "Import Local Chrome Profile", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
+    },
+    async (input) => {
+      try {
+        const result = await importChromeProfile({
+          email: input.email,
+          name: input.name,
+          chromeProfileDirectory: input.chrome_profile_directory,
+          sourceUserDataDir: input.user_data_dir,
+          outputDir: input.output_dir,
+          overwrite: input.overwrite,
+          browserExecutablePath: input.browser_executable_path
+        });
+        return structuredResult({
+          ok: true,
+          tool: "browser_profile_import",
+          session_id: null,
+          profile: result.profile,
+          source_profile: result.sourceProfile,
+          next_steps: [
+            `Set MCP_SCRAPER_BROWSER_MODE=local in the MCP server config.`,
+            `Set MCP_SCRAPER_BROWSER_PROFILE=${result.profile.name}.`,
+            "Restart the MCP client so it starts the local browser mode process.",
+            "Call browser_open with the same MCP server; it will open a local Chrome window using the cloned profile."
+          ],
+          hint: "The clone is local to this machine. Re-run browser_profile_sync after logging into new sites in normal Chrome."
+        });
+      } catch (err) {
+        return errorResult("browser_profile_import", { error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+  );
+  server2.registerTool(
+    "browser_profile_sync",
+    {
+      title: "Sync Local Chrome Profile",
+      description: "Refresh an existing MCP Scraper managed local browser profile from the source Chrome profile recorded in its manifest. This overwrites the managed clone, copies browser state files again, skips cache and lock files, and never prints cookie or password values.",
+      inputSchema: BrowserProfileSyncInputSchema,
+      outputSchema: BrowserProfileSyncOutputSchema,
+      annotations: { title: "Sync Local Chrome Profile", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
+    },
+    async (input) => {
+      try {
+        const result = await syncImportedChromeProfile(input.name, {
+          outputDir: input.output_dir,
+          browserExecutablePath: input.browser_executable_path
+        });
+        return structuredResult({
+          ok: true,
+          tool: "browser_profile_sync",
+          session_id: null,
+          profile: result.profile,
+          source_profile: result.sourceProfile,
+          hint: `Refreshed ${result.profile.name}. Restart local browser sessions that were using this profile.`
+        });
+      } catch (err) {
+        return errorResult("browser_profile_sync", { error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+  );
+  server2.registerTool(
+    "browser_profile_onboard",
+    {
+      title: "Onboard Hosted Browser Profile",
+      description: "Create or load a saved hosted Kernel browser profile and open a live setup browser with profile saving enabled. Use this only for hosted browser mode. If email is provided, the tool reads local Chrome profile metadata only to suggest the Kernel profile name; it does not import local cookies. For local browser mode with real Chrome state, use browser_profile_import instead.",
+      inputSchema: BrowserProfileOnboardInputSchema,
+      outputSchema: BrowserProfileOnboardOutputSchema,
+      annotations: annotations("Onboard Hosted Browser Profile")
+    },
+    async (input) => {
+      let chromeProfile = null;
+      if (input.email) {
+        try {
+          chromeProfile = selectChromeProfile(await listLocalChromeProfiles(input.user_data_dir, input.email), input.email);
+        } catch (err) {
+          return errorResult("browser_profile_onboard", { error: err instanceof Error ? err.message : String(err) });
+        }
+      }
+      const profile = input.profile?.trim() || chromeProfile?.recommendedKernelProfileName || browserServiceProfileName();
+      if (!profile) {
+        return errorResult("browser_profile_onboard", {
+          error: "profile is required when no email match or BROWSER_AGENT_PROFILE_NAME is available"
+        });
+      }
+      const setupUrl = input.url ?? "https://accounts.google.com/";
+      const open = await req("POST", "/agent/sessions", {
+        label: input.label ?? `Profile setup: ${profile}`,
+        profile,
+        save_profile_changes: true,
+        timeout_seconds: input.timeout_seconds
+      });
+      if (!open.ok) return errorResult("browser_profile_onboard", open.data);
+      const session = open.data;
+      const goto = await req("POST", `/agent/sessions/${session.session_id}/goto`, { url: setupUrl });
+      if (!goto.ok) return errorResult("browser_profile_onboard", goto.data, session.session_id);
+      return structuredResult({
+        ok: true,
+        tool: "browser_profile_onboard",
+        session_id: session.session_id,
+        watch_url: `${consoleBase}/console/${session.session_id}`,
+        live_view_url: session.live_view_url ?? null,
+        profile,
+        setup_url: setupUrl,
+        chrome_profile: chromeProfile,
+        next_steps: [
+          "Open the watch_url and complete the login manually.",
+          "After login is complete, call browser_close with this session_id to persist cookies and local storage to the Kernel profile.",
+          "Use BROWSER_AGENT_PROFILE_NAME or browser_open.profile with this profile name for future authenticated sessions."
+        ],
+        raw: session
+      });
+    }
+  );
   server2.registerTool(
     "browser_open",
     {
       title: "Open Browser Session",
-      description: "Open a fresh cloud browser you can drive. Returns a session_id used by all other browser_* tools, and a watch_url where a human can watch live or take over. Anti-bot stealth and automatic CAPTCHA/Cloudflare solving are on by default: if a Cloudflare or CAPTCHA challenge appears, do NOT click it \u2014 wait a few seconds and call browser_screenshot again; it is solved automatically. Billing: metered per second of active browser work at ~4 credits per minute; idle and standby time are free. Call browser_close when done to stop the meter. After opening, call browser_screenshot to see the page.",
+      description: "Open a browser you can drive. By default this creates a hosted cloud browser with a watch_url; when MCP_SCRAPER_BROWSER_MODE=local it opens a local Google Chrome window against an imported MCP Scraper Chrome profile. Returns a session_id used by all other browser_* tools. In hosted mode, anti-bot stealth and automatic CAPTCHA/Cloudflare solving are on by default. Call browser_close when done.",
       inputSchema: BrowserOpenInputSchema,
       outputSchema: BrowserOpenOutputSchema,
       annotations: annotations("Open Browser Session")
     },
     async (input) => {
+      if (localBrowserModeEnabled()) {
+        try {
+          const session2 = await localBrowser.open(input);
+          return structuredResult({
+            ok: true,
+            tool: "browser_open",
+            session_id: session2.session_id,
+            watch_url: session2.watch_url,
+            live_view_url: null,
+            url: input.url ?? null,
+            hint: "Local Chrome is open on this machine. Call browser_screenshot to see the page and click by x,y coordinates.",
+            raw: session2
+          });
+        } catch (err) {
+          return errorResult("browser_open", { error: err instanceof Error ? err.message : String(err), mode: "local" });
+        }
+      }
+      const profile = input.profile ?? browserServiceProfileName();
+      const saveProfileChanges = input.save_profile_changes ?? browserServiceProfileSaveChanges();
       const open = await req("POST", "/agent/sessions", {
         label: input.label,
-        profile: input.profile,
+        ...profile ? { profile } : {},
+        ...profile && typeof saveProfileChanges === "boolean" ? { save_profile_changes: saveProfileChanges } : {},
         timeout_seconds: input.timeout_seconds
       });
       if (!open.ok) return errorResult("browser_open", open.data);
@@ -673,6 +1487,27 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("See Page", true)
     },
     async (input) => {
+      if (localBrowserModeEnabled()) {
+        try {
+          const res2 = await localBrowser.screenshot(input.session_id);
+          const content2 = [];
+          if (res2.image_base64) content2.push({ type: "image", data: res2.image_base64, mimeType: res2.mime_type });
+          const structured2 = {
+            ok: true,
+            tool: "browser_screenshot",
+            session_id: input.session_id,
+            url: res2.url ?? null,
+            title: res2.title ?? null,
+            text: res2.text,
+            elements: res2.elements,
+            screenshot: { mime_type: res2.mime_type, inline: true }
+          };
+          content2.push({ type: "text", text: JSON.stringify(structured2) });
+          return { content: content2, structuredContent: structured2 };
+        } catch (err) {
+          return errorResult("browser_screenshot", { error: err instanceof Error ? err.message : String(err), mode: "local" }, input.session_id);
+        }
+      }
       const res = await req("POST", `/agent/sessions/${input.session_id}/screenshot`);
       if (!res.ok) return errorResult("browser_screenshot", res.data, input.session_id);
       const { image_base64, mime_type, url, title, elements, text } = res.data;
@@ -705,6 +1540,23 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("Read Page", true)
     },
     async (input) => {
+      if (localBrowserModeEnabled()) {
+        try {
+          const res2 = await localBrowser.read(input.session_id);
+          return structuredResult({
+            ok: true,
+            tool: "browser_read",
+            session_id: input.session_id,
+            url: res2.url ?? null,
+            title: res2.title ?? null,
+            text: res2.text,
+            elements: res2.elements,
+            raw: res2
+          });
+        } catch (err) {
+          return errorResult("browser_read", { error: err instanceof Error ? err.message : String(err), mode: "local" }, input.session_id);
+        }
+      }
       const res = await req("POST", `/agent/sessions/${input.session_id}/read`);
       if (!res.ok) return errorResult("browser_read", res.data, input.session_id);
       return structuredResult({
@@ -729,6 +1581,24 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("Locate DOM Targets", true)
     },
     async (input) => {
+      if (localBrowserModeEnabled()) {
+        try {
+          const res2 = await localBrowser.locate(input.session_id, input.targets);
+          return structuredResult({
+            ok: true,
+            tool: "browser_locate",
+            session_id: input.session_id,
+            url: res2.url ?? null,
+            title: res2.title ?? null,
+            viewport: res2.viewport ?? null,
+            replay: null,
+            targets: Array.isArray(res2.targets) ? res2.targets : [],
+            raw: res2
+          });
+        } catch (err) {
+          return errorResult("browser_locate", { error: err instanceof Error ? err.message : String(err), mode: "local" }, input.session_id);
+        }
+      }
       const res = await req("POST", `/agent/sessions/${input.session_id}/locate`, { targets: input.targets });
       if (!res.ok) return errorResult("browser_locate", res.data, input.session_id);
       return structuredResult({
@@ -754,6 +1624,14 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("Navigate To URL")
     },
     async (input) => {
+      if (localBrowserModeEnabled()) {
+        try {
+          const res2 = await localBrowser.goto(input.session_id, input.url);
+          return actionResult("browser_goto", input.session_id, true, res2, "browser_screenshot");
+        } catch (err) {
+          return errorResult("browser_goto", { error: err instanceof Error ? err.message : String(err), mode: "local" }, input.session_id);
+        }
+      }
       const res = await req("POST", `/agent/sessions/${input.session_id}/goto`, { url: input.url });
       return actionResult("browser_goto", input.session_id, res.ok, res.data, "browser_screenshot");
     }
@@ -768,6 +1646,14 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("Click")
     },
     async (input) => {
+      if (localBrowserModeEnabled()) {
+        try {
+          const res2 = await localBrowser.click(input.session_id, input);
+          return actionResult("browser_click", input.session_id, true, res2, "browser_screenshot");
+        } catch (err) {
+          return errorResult("browser_click", { error: err instanceof Error ? err.message : String(err), mode: "local" }, input.session_id);
+        }
+      }
       const res = await req("POST", `/agent/sessions/${input.session_id}/click`, {
         x: input.x,
         y: input.y,
@@ -787,6 +1673,14 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("Type Text")
     },
     async (input) => {
+      if (localBrowserModeEnabled()) {
+        try {
+          const res2 = await localBrowser.type(input.session_id, input);
+          return actionResult("browser_type", input.session_id, true, res2, "browser_screenshot");
+        } catch (err) {
+          return errorResult("browser_type", { error: err instanceof Error ? err.message : String(err), mode: "local" }, input.session_id);
+        }
+      }
       const res = await req("POST", `/agent/sessions/${input.session_id}/type`, { text: input.text, delay: input.delay });
       return actionResult("browser_type", input.session_id, res.ok, res.data, "browser_screenshot");
     }
@@ -801,6 +1695,14 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("Scroll")
     },
     async (input) => {
+      if (localBrowserModeEnabled()) {
+        try {
+          const res2 = await localBrowser.scroll(input.session_id, input);
+          return actionResult("browser_scroll", input.session_id, true, res2, "browser_screenshot");
+        } catch (err) {
+          return errorResult("browser_scroll", { error: err instanceof Error ? err.message : String(err), mode: "local" }, input.session_id);
+        }
+      }
       const res = await req("POST", `/agent/sessions/${input.session_id}/scroll`, {
         delta_y: input.delta_y,
         delta_x: input.delta_x,
@@ -820,6 +1722,14 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("Press Keys")
     },
     async (input) => {
+      if (localBrowserModeEnabled()) {
+        try {
+          const res2 = await localBrowser.press(input.session_id, input);
+          return actionResult("browser_press", input.session_id, true, res2, "browser_screenshot");
+        } catch (err) {
+          return errorResult("browser_press", { error: err instanceof Error ? err.message : String(err), mode: "local" }, input.session_id);
+        }
+      }
       const res = await req("POST", `/agent/sessions/${input.session_id}/press`, { keys: input.keys });
       return actionResult("browser_press", input.session_id, res.ok, res.data, "browser_screenshot");
     }
@@ -834,6 +1744,7 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("Start Recording")
     },
     async (input) => {
+      if (localBrowserModeEnabled()) return localReplayUnsupported("browser_replay_start", input.session_id);
       const res = await req("POST", `/agent/sessions/${input.session_id}/replay/start`);
       if (!res.ok) return errorResult("browser_replay_start", res.data, input.session_id);
       return structuredResult({
@@ -857,6 +1768,7 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("Stop Recording")
     },
     async (input) => {
+      if (localBrowserModeEnabled()) return localReplayUnsupported("browser_replay_stop", input.session_id, input.replay_id);
       const res = await req("POST", `/agent/sessions/${input.session_id}/replay/stop`, { replay_id: input.replay_id });
       if (!res.ok) return errorResult("browser_replay_stop", res.data, input.session_id, input.replay_id);
       return structuredResult({
@@ -880,6 +1792,7 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("List Replay Videos", true)
     },
     async (input) => {
+      if (localBrowserModeEnabled()) return localReplayUnsupported("browser_list_replays", input.session_id);
       const res = await req("GET", `/agent/sessions/${input.session_id}/replays`);
       if (!res.ok) return errorResult("browser_list_replays", res.data, input.session_id);
       const replays = Array.isArray(res.data?.replays) ? res.data.replays : [];
@@ -902,6 +1815,7 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("Download Replay MP4")
     },
     async (input) => {
+      if (localBrowserModeEnabled()) return localReplayUnsupported("browser_replay_download", input.session_id, input.replay_id);
       const res = await downloadReplay(input.session_id, input.replay_id, input.filename);
       if (!res.ok) return errorResult("browser_replay_download", res.data, input.session_id, input.replay_id);
       return structuredResult({
@@ -926,6 +1840,7 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("Mark Replay Annotation", true)
     },
     async (input) => {
+      if (localBrowserModeEnabled()) return localReplayUnsupported("browser_replay_mark", input.session_id);
       const res = await req("POST", `/agent/sessions/${input.session_id}/locate`, { targets: [input.target] });
       if (!res.ok) return errorResult("browser_replay_mark", res.data, input.session_id);
       const target = res.data?.targets?.[0];
@@ -976,13 +1891,14 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("Annotate Replay MP4")
     },
     async (input) => {
+      if (localBrowserModeEnabled()) return localReplayUnsupported("browser_replay_annotate", input.session_id, input.replay_id);
       const sourceName = input.filename ? `${input.filename}-source` : void 0;
       const downloaded = await downloadReplay(input.session_id, input.replay_id, sourceName);
       if (!downloaded.ok) return errorResult("browser_replay_annotate", downloaded.data, input.session_id, input.replay_id);
       try {
         const sourcePath = String(downloaded.data.file_path);
         const outputPath = annotatedReplayFilePath(input.session_id, input.replay_id, input.filename);
-        (0, import_node_fs.mkdirSync)((0, import_node_path2.join)(outputBaseDir(), "browser-replays"), { recursive: true });
+        (0, import_node_fs3.mkdirSync)((0, import_node_path5.join)(outputBaseDir(), "browser-replays"), { recursive: true });
         const result = await annotateReplayVideo(sourcePath, outputPath, {
           annotations: input.annotations,
           sourceWidth: input.source_width,
@@ -1018,6 +1934,20 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: { title: "Close Browser Session", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
     },
     async (input) => {
+      if (localBrowserModeEnabled()) {
+        try {
+          const res2 = await localBrowser.close(input.session_id);
+          return structuredResult({
+            ok: true,
+            tool: "browser_close",
+            session_id: input.session_id,
+            closed: true,
+            raw: res2
+          });
+        } catch (err) {
+          return errorResult("browser_close", { error: err instanceof Error ? err.message : String(err), mode: "local" }, input.session_id);
+        }
+      }
       const res = await req("DELETE", `/agent/sessions/${input.session_id}`);
       if (!res.ok) return errorResult("browser_close", res.data, input.session_id);
       return structuredResult({
@@ -1039,6 +1969,16 @@ function registerBrowserAgentMcpTools(server2, opts) {
       annotations: annotations("List Browser Sessions", true)
     },
     async (input) => {
+      if (localBrowserModeEnabled()) {
+        const sessions2 = localBrowser.list(input.include_closed);
+        return structuredResult({
+          ok: true,
+          tool: "browser_list_sessions",
+          session_id: null,
+          sessions: sessions2,
+          count: sessions2.length
+        });
+      }
       const res = await req("GET", `/agent/sessions${input.include_closed ? "?all=1" : ""}`);
       if (!res.ok) return errorResult("browser_list_sessions", res.data);
       const sessions = (res.data.sessions ?? []).map((s) => ({ ...s, watch_url: `${consoleBase}/console/${s.session_id}` }));
@@ -1056,10 +1996,10 @@ function registerBrowserAgentMcpTools(server2, opts) {
 // bin/browser-agent-stdio-server.ts
 function readApiKeyFile() {
   const explicitPath = process.env.MCP_SCRAPER_KEY_PATH?.trim();
-  const paths = [explicitPath, (0, import_node_path3.join)((0, import_node_os3.homedir)(), ".mcp-scraper-key")].filter(Boolean);
+  const paths = [explicitPath, (0, import_node_path6.join)((0, import_node_os5.homedir)(), ".mcp-scraper-key")].filter(Boolean);
   for (const path of paths) {
     try {
-      const value = (0, import_node_fs2.readFileSync)(path, "utf8").trim();
+      const value = (0, import_node_fs4.readFileSync)(path, "utf8").trim();
       if (value) return value;
     } catch {
     }