lobster-cli 0.1.0 → 0.2.0

package/dist/lib.js

@@ -432,7 +432,7 @@ function extractJsonFromString(str) {
 
 // src/browser/manager.ts
 import puppeteer from "puppeteer-core";
-import { existsSync } from "fs";
+import { existsSync as existsSync3 } from "fs";
 
 // src/utils/logger.ts
 import chalk from "chalk";
@@ -448,20 +448,591 @@ var log = {
   dim: (msg) => console.log(chalk.dim(msg))
 };
 
+// src/browser/profiles.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, readdirSync, rmSync, statSync } from "fs";
+import { join as join2 } from "path";
+
+// src/config/index.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import yaml from "js-yaml";
+
+// src/config/schema.ts
+import { z } from "zod";
+var LLM_PROVIDERS = {
+  openai: {
+    name: "OpenAI",
+    baseURL: "https://api.openai.com/v1",
+    defaultModel: "gpt-4o",
+    keyPrefix: "sk-",
+    keyEnvHint: "https://platform.openai.com/api-keys",
+    models: ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "o1", "o1-mini", "o3-mini"]
+  },
+  anthropic: {
+    name: "Anthropic",
+    baseURL: "https://api.anthropic.com/v1",
+    defaultModel: "claude-sonnet-4-20250514",
+    keyPrefix: "sk-ant-",
+    keyEnvHint: "https://console.anthropic.com/settings/keys",
+    models: ["claude-opus-4-20250514", "claude-sonnet-4-20250514", "claude-haiku-4-5-20251001"]
+  },
+  gemini: {
+    name: "Google Gemini",
+    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai",
+    defaultModel: "gemini-2.5-flash",
+    keyPrefix: "AI",
+    keyEnvHint: "https://aistudio.google.com/apikey",
+    models: ["gemini-2.5-flash", "gemini-2.5-flash-lite", "gemini-2.5-pro", "gemini-3-flash-preview"]
+  },
+  ollama: {
+    name: "Ollama (local, free)",
+    baseURL: "http://localhost:11434/v1",
+    defaultModel: "llama3.1",
+    keyPrefix: "",
+    keyEnvHint: "No API key needed \u2014 install from https://ollama.ai",
+    models: ["llama3.1", "llama3.2", "mistral", "codestral", "qwen2.5", "deepseek-r1"]
+  }
+};
+var configSchema = z.object({
+  llm: z.object({
+    provider: z.enum(["openai", "anthropic", "gemini", "ollama"]).default("openai"),
+    baseURL: z.string().default("https://api.openai.com/v1"),
+    model: z.string().default("gpt-4o"),
+    apiKey: z.string().default(""),
+    temperature: z.number().min(0).max(2).default(0.1),
+    maxRetries: z.number().int().min(0).default(3)
+  }).default({}),
+  browser: z.object({
+    executablePath: z.string().default(""),
+    headless: z.boolean().default(true),
+    connectTimeout: z.number().default(30),
+    commandTimeout: z.number().default(60),
+    cdpEndpoint: z.string().default(""),
+    profile: z.string().default(""),
+    stealth: z.boolean().default(false)
+  }).default({}),
+  agent: z.object({
+    maxSteps: z.number().int().default(40),
+    stepDelay: z.number().default(0.4)
+  }).default({}),
+  domains: z.object({
+    allow: z.array(z.string()).default([]),
+    block: z.array(z.string()).default([]),
+    blockMessage: z.string().default("")
+  }).default({}),
+  output: z.object({
+    defaultFormat: z.enum(["table", "json", "yaml", "markdown", "csv"]).default("table"),
+    color: z.boolean().default(true)
+  }).default({})
+});
+
+// src/config/index.ts
+var CONFIG_DIR = join(homedir(), ".lobster");
+var CONFIG_FILE = join(CONFIG_DIR, "config.yaml");
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  ensureConfigDir();
+  let fileConfig = {};
+  if (existsSync(CONFIG_FILE)) {
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    fileConfig = yaml.load(raw) || {};
+  }
+  const envOverrides = {};
+  if (process.env.LOBSTER_API_KEY) {
+    envOverrides.llm = { ...fileConfig.llm || {}, apiKey: process.env.LOBSTER_API_KEY };
+  }
+  if (process.env.LOBSTER_MODEL) {
+    envOverrides.llm = { ...envOverrides.llm || fileConfig.llm || {}, model: process.env.LOBSTER_MODEL };
+  }
+  if (process.env.LOBSTER_BASE_URL) {
+    envOverrides.llm = { ...envOverrides.llm || fileConfig.llm || {}, baseURL: process.env.LOBSTER_BASE_URL };
+  }
+  if (process.env.LOBSTER_CDP_ENDPOINT) {
+    envOverrides.browser = { ...fileConfig.browser || {}, cdpEndpoint: process.env.LOBSTER_CDP_ENDPOINT };
+  }
+  if (process.env.LOBSTER_BROWSER_PATH) {
+    envOverrides.browser = { ...envOverrides.browser || fileConfig.browser || {}, executablePath: process.env.LOBSTER_BROWSER_PATH };
+  }
+  const merged = { ...fileConfig, ...envOverrides };
+  return configSchema.parse(merged);
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const existing = loadConfig();
+  const merged = deepMerge(existing, config);
+  writeFileSync(CONFIG_FILE, yaml.dump(merged, { indent: 2 }), "utf-8");
+}
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key]) && target[key] && typeof target[key] === "object" && !Array.isArray(target[key])) {
+      result[key] = deepMerge(target[key], source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+// src/browser/profiles.ts
+var PROFILES_DIR = () => join2(getConfigDir(), "profiles");
+var META_FILE = ".lobster-meta.json";
+var VALID_NAME = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
+var RESERVED_NAMES = /* @__PURE__ */ new Set([
+  "default",
+  "system",
+  "con",
+  "prn",
+  "aux",
+  "nul",
+  "com1",
+  "com2",
+  "com3",
+  "com4",
+  "com5",
+  "com6",
+  "com7",
+  "com8",
+  "com9",
+  "lpt1",
+  "lpt2",
+  "lpt3",
+  "lpt4",
+  "lpt5",
+  "lpt6",
+  "lpt7",
+  "lpt8",
+  "lpt9"
+]);
+var CACHE_DIRS = [
+  "Cache",
+  "Code Cache",
+  "GPUCache",
+  "GrShaderCache",
+  "ShaderCache",
+  "Service Worker",
+  "Sessions",
+  "Session Storage",
+  "blob_storage"
+];
+function ensureProfilesDir() {
+  const dir = PROFILES_DIR();
+  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+}
+function validateName(name) {
+  if (!VALID_NAME.test(name)) {
+    throw new Error(`Invalid profile name "${name}". Use only letters, numbers, hyphens, underscores (max 64 chars).`);
+  }
+  if (RESERVED_NAMES.has(name.toLowerCase())) {
+    throw new Error(`"${name}" is a reserved name. Choose a different profile name.`);
+  }
+}
+function getProfileDir(name) {
+  return join2(PROFILES_DIR(), name);
+}
+function readMeta(profileDir) {
+  const metaPath = join2(profileDir, META_FILE);
+  if (!existsSync2(metaPath)) return null;
+  try {
+    return JSON.parse(readFileSync2(metaPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeMeta(profileDir, meta) {
+  writeFileSync2(join2(profileDir, META_FILE), JSON.stringify(meta, null, 2));
+}
+function getDirSizeMB(dirPath) {
+  let total = 0;
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join2(dirPath, entry.name);
+      if (entry.isFile()) {
+        total += statSync(fullPath).size;
+      } else if (entry.isDirectory() && entry.name !== ".lobster-meta.json") {
+        total += getDirSizeMB(fullPath) * 1024 * 1024;
+      }
+    }
+  } catch {
+  }
+  return Math.round(total / (1024 * 1024) * 10) / 10;
+}
+function createProfile(name) {
+  validateName(name);
+  ensureProfilesDir();
+  const dir = getProfileDir(name);
+  if (existsSync2(dir)) {
+    throw new Error(`Profile "${name}" already exists.`);
+  }
+  mkdirSync2(dir, { recursive: true });
+  const meta = {
+    name,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUsed: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeMeta(dir, meta);
+  log.success(`Profile "${name}" created at ${dir}`);
+  return meta;
+}
+function listProfiles() {
+  ensureProfilesDir();
+  const dir = PROFILES_DIR();
+  const profiles = [];
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const profileDir = join2(dir, entry.name);
+      const meta = readMeta(profileDir);
+      if (meta) {
+        meta.sizeMB = getDirSizeMB(profileDir);
+        profiles.push(meta);
+      } else {
+        profiles.push({
+          name: entry.name,
+          createdAt: "unknown",
+          lastUsed: "unknown",
+          sizeMB: getDirSizeMB(profileDir)
+        });
+      }
+    }
+  } catch {
+  }
+  return profiles.sort((a, b) => a.name.localeCompare(b.name));
+}
+function removeProfile(name) {
+  const dir = getProfileDir(name);
+  if (!existsSync2(dir)) {
+    throw new Error(`Profile "${name}" does not exist.`);
+  }
+  rmSync(dir, { recursive: true, force: true });
+  log.success(`Profile "${name}" deleted.`);
+}
+function getProfileDataDir(name) {
+  validateName(name);
+  const dir = getProfileDir(name);
+  if (!existsSync2(dir)) {
+    createProfile(name);
+  } else {
+    const meta = readMeta(dir) || { name, createdAt: "unknown", lastUsed: "" };
+    meta.lastUsed = (/* @__PURE__ */ new Date()).toISOString();
+    writeMeta(dir, meta);
+  }
+  return dir;
+}
+function resetProfileCache(name) {
+  const dir = getProfileDir(name);
+  if (!existsSync2(dir)) {
+    throw new Error(`Profile "${name}" does not exist.`);
+  }
+  let cleaned = 0;
+  for (const cacheDir of CACHE_DIRS) {
+    for (const base of [dir, join2(dir, "Default")]) {
+      const target = join2(base, cacheDir);
+      if (existsSync2(target)) {
+        rmSync(target, { recursive: true, force: true });
+        cleaned++;
+      }
+    }
+  }
+  log.success(`Profile "${name}" cache reset (${cleaned} directories cleaned).`);
+}
+
+// src/browser/chrome-attach.ts
+import http from "http";
+var DEFAULT_PORTS = [9222, 9229, 9333, 9515];
+var PROBE_TIMEOUT = 1500;
+function probePort(port) {
+  return new Promise((resolve) => {
+    const req = http.get(`http://127.0.0.1:${port}/json/version`, {
+      timeout: PROBE_TIMEOUT
+    }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          const info = JSON.parse(data);
+          if (info.webSocketDebuggerUrl) {
+            resolve({
+              wsEndpoint: info.webSocketDebuggerUrl,
+              port,
+              version: info["Protocol-Version"] || "",
+              browser: info.Browser || ""
+            });
+          } else {
+            resolve(null);
+          }
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+    req.on("error", () => resolve(null));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
+}
+async function discoverChrome(ports) {
+  const portsToCheck = ports || DEFAULT_PORTS;
+  log.debug(`Scanning ports for Chrome: ${portsToCheck.join(", ")}`);
+  const results = await Promise.all(portsToCheck.map(probePort));
+  const found = results.find(Boolean) || null;
+  if (found) {
+    log.info(`Found Chrome on port ${found.port}: ${found.browser}`);
+  } else {
+    log.debug("No running Chrome instance found on debug ports.");
+  }
+  return found;
+}
+async function getWebSocketDebuggerUrl(port) {
+  const result = await probePort(port);
+  return result?.wsEndpoint || null;
+}
+async function resolveAttachTarget(target) {
+  if (target === true || target === "true") {
+    const result = await discoverChrome();
+    if (!result) {
+      throw new Error(
+        "No running Chrome found. Start Chrome with:\n  google-chrome --remote-debugging-port=9222\n  # or on Mac:\n  /Applications/Google\\ Chrome.app/Contents/MacOS/Google\\ Chrome --remote-debugging-port=9222"
+      );
+    }
+    return result.wsEndpoint;
+  }
+  if (typeof target === "string") {
+    if (target.startsWith("ws://") || target.startsWith("wss://")) {
+      return target;
+    }
+    const port = parseInt(target, 10);
+    if (!isNaN(port) && port > 0 && port < 65536) {
+      const url = await getWebSocketDebuggerUrl(port);
+      if (!url) {
+        throw new Error(`No Chrome found on port ${port}. Make sure Chrome is running with --remote-debugging-port=${port}`);
+      }
+      return url;
+    }
+    throw new Error(`Invalid attach target: "${target}". Use "true" for auto-discover, a port number, or a ws:// URL.`);
+  }
+  throw new Error("Invalid attach target.");
+}
+
+// src/browser/stealth.ts
+var STEALTH_SCRIPT = `
+(() => {
+  // \u2500\u2500 1. navigator.webdriver removal \u2500\u2500
+  // Most important: this is the #1 detection vector
+  Object.defineProperty(navigator, 'webdriver', {
+    get: () => undefined,
+    configurable: true,
+  });
+
+  // Also delete from prototype
+  delete Object.getPrototypeOf(navigator).webdriver;
+
+  // \u2500\u2500 2. CDP marker removal \u2500\u2500
+  // Chrome DevTools Protocol injects cdc_* properties on window
+  for (const key of Object.keys(window)) {
+    if (/^cdc_|^__webdriver|^__selenium|^__driver/.test(key)) {
+      try { delete window[key]; } catch {}
+    }
+  }
+
+  // \u2500\u2500 3. Chrome runtime spoofing \u2500\u2500
+  // Real Chrome has window.chrome with runtime, loadTimes, csi
+  if (!window.chrome) {
+    window.chrome = {};
+  }
+  if (!window.chrome.runtime) {
+    window.chrome.runtime = {
+      connect: function() {},
+      sendMessage: function() {},
+      onMessage: { addListener: function() {} },
+      id: undefined,
+    };
+  }
+  if (!window.chrome.loadTimes) {
+    window.chrome.loadTimes = function() {
+      return {
+        commitLoadTime: Date.now() / 1000 - 0.5,
+        connectionInfo: 'h2',
+        finishDocumentLoadTime: Date.now() / 1000 - 0.1,
+        finishLoadTime: Date.now() / 1000 - 0.05,
+        firstPaintAfterLoadTime: 0,
+        firstPaintTime: Date.now() / 1000 - 0.3,
+        navigationType: 'Other',
+        npnNegotiatedProtocol: 'h2',
+        requestTime: Date.now() / 1000 - 1,
+        startLoadTime: Date.now() / 1000 - 0.8,
+        wasAlternateProtocolAvailable: false,
+        wasFetchedViaSpdy: true,
+        wasNpnNegotiated: true,
+      };
+    };
+  }
+  if (!window.chrome.csi) {
+    window.chrome.csi = function() {
+      return {
+        onloadT: Date.now(),
+        startE: Date.now() - 500,
+        pageT: 500,
+        tran: 15,
+      };
+    };
+  }
+
+  // \u2500\u2500 4. Plugin array spoofing \u2500\u2500
+  // Headless Chrome reports empty plugins; real Chrome has at least 2
+  const fakePlugins = [
+    { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format', length: 1 },
+    { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai', description: '', length: 1 },
+    { name: 'Native Client', filename: 'internal-nacl-plugin', description: '', length: 2 },
+  ];
+
+  Object.defineProperty(navigator, 'plugins', {
+    get: () => {
+      const arr = fakePlugins.map(p => {
+        const plugin = { ...p, item: (i) => plugin, namedItem: (n) => plugin };
+        return plugin;
+      });
+      arr.item = (i) => arr[i];
+      arr.namedItem = (n) => arr.find(p => p.name === n);
+      arr.refresh = () => {};
+      return arr;
+    },
+  });
+
+  // \u2500\u2500 5. Languages \u2500\u2500
+  Object.defineProperty(navigator, 'languages', {
+    get: () => ['en-US', 'en'],
+  });
+  Object.defineProperty(navigator, 'language', {
+    get: () => 'en-US',
+  });
+
+  // \u2500\u2500 6. Platform consistency \u2500\u2500
+  // Ensure platform matches user agent
+  const platform = navigator.userAgent.includes('Mac') ? 'MacIntel' :
+                   navigator.userAgent.includes('Win') ? 'Win32' :
+                   navigator.userAgent.includes('Linux') ? 'Linux x86_64' : navigator.platform;
+  Object.defineProperty(navigator, 'platform', { get: () => platform });
+
+  // \u2500\u2500 7. Hardware concurrency & device memory \u2500\u2500
+  // Headless often reports unusual values
+  if (navigator.hardwareConcurrency < 2) {
+    Object.defineProperty(navigator, 'hardwareConcurrency', { get: () => 8 });
+  }
+  if (!navigator.deviceMemory || navigator.deviceMemory < 2) {
+    Object.defineProperty(navigator, 'deviceMemory', { get: () => 8 });
+  }
+
+  // \u2500\u2500 8. WebGL vendor/renderer spoofing \u2500\u2500
+  // Headless reports "Google SwiftShader" which is a dead giveaway
+  const origGetParameter = WebGLRenderingContext.prototype.getParameter;
+  WebGLRenderingContext.prototype.getParameter = function(param) {
+    // UNMASKED_VENDOR_WEBGL
+    if (param === 0x9245) return 'Intel Inc.';
+    // UNMASKED_RENDERER_WEBGL
+    if (param === 0x9246) return 'Intel Iris OpenGL Engine';
+    return origGetParameter.call(this, param);
+  };
+
+  // Also for WebGL2
+  if (typeof WebGL2RenderingContext !== 'undefined') {
+    const origGetParameter2 = WebGL2RenderingContext.prototype.getParameter;
+    WebGL2RenderingContext.prototype.getParameter = function(param) {
+      if (param === 0x9245) return 'Intel Inc.';
+      if (param === 0x9246) return 'Intel Iris OpenGL Engine';
+      return origGetParameter2.call(this, param);
+    };
+  }
+
+  // \u2500\u2500 9. Canvas fingerprint noise \u2500\u2500
+  // Adds subtle deterministic noise to canvas output based on domain
+  const seed = location.hostname.split('').reduce((a, c) => a + c.charCodeAt(0), 0);
+  const origToDataURL = HTMLCanvasElement.prototype.toDataURL;
+  HTMLCanvasElement.prototype.toDataURL = function(type) {
+    const ctx = this.getContext('2d');
+    if (ctx && this.width > 0 && this.height > 0) {
+      try {
+        const imageData = ctx.getImageData(0, 0, 1, 1);
+        // Flip a single pixel with seeded noise
+        imageData.data[0] = (imageData.data[0] + seed) % 256;
+        ctx.putImageData(imageData, 0, 0);
+      } catch {}
+    }
+    return origToDataURL.apply(this, arguments);
+  };
+
+  // \u2500\u2500 10. Permissions API \u2500\u2500
+  // Headless returns 'denied' for notifications; real Chrome returns 'prompt'
+  const origQuery = navigator.permissions?.query?.bind(navigator.permissions);
+  if (origQuery) {
+    navigator.permissions.query = function(descriptor) {
+      if (descriptor.name === 'notifications') {
+        return Promise.resolve({ state: Notification.permission || 'prompt', onchange: null });
+      }
+      return origQuery(descriptor);
+    };
+  }
+
+  // \u2500\u2500 11. Notification constructor \u2500\u2500
+  if (!window.Notification) {
+    window.Notification = function() {};
+    window.Notification.permission = 'default';
+    window.Notification.requestPermission = () => Promise.resolve('default');
+  }
+
+  // \u2500\u2500 12. Connection type \u2500\u2500
+  if (navigator.connection) {
+    Object.defineProperty(navigator.connection, 'rtt', { get: () => 50 });
+  }
+})()
+`;
+async function injectStealth(page) {
+  await page.evaluateOnNewDocument(STEALTH_SCRIPT);
+}
+var STEALTH_ARGS = [
+  "--disable-blink-features=AutomationControlled",
+  "--disable-features=IsolateOrigins,site-per-process",
+  "--disable-infobars",
+  "--window-size=1920,1080"
+];
+
 // src/browser/manager.ts
 var BrowserManager = class {
   browser = null;
   config;
+  isAttached = false;
   constructor(config = {}) {
     this.config = config;
   }
   async connect() {
     if (this.browser?.connected) return this.browser;
+    if (this.config.attach) {
+      const wsEndpoint = await resolveAttachTarget(this.config.attach);
+      log.info(`Attaching to Chrome: ${wsEndpoint}`);
+      this.browser = await puppeteer.connect({ browserWSEndpoint: wsEndpoint });
+      this.isAttached = true;
+      return this.browser;
+    }
     if (this.config.cdpEndpoint) {
       log.debug(`Connecting to CDP endpoint: ${this.config.cdpEndpoint}`);
       this.browser = await puppeteer.connect({
         browserWSEndpoint: this.config.cdpEndpoint
       });
+      this.isAttached = true;
       return this.browser;
     }
     const executablePath = this.config.executablePath || findChrome();
@@ -470,27 +1041,48 @@ var BrowserManager = class {
         "Chrome/Chromium not found. Set LOBSTER_BROWSER_PATH or config browser.executablePath"
       );
     }
+    const args = [
+      "--no-sandbox",
+      "--disable-setuid-sandbox",
+      "--disable-dev-shm-usage",
+      "--disable-gpu"
+    ];
+    if (this.config.stealth) {
+      args.push(...STEALTH_ARGS);
+    }
+    let userDataDir;
+    if (this.config.profile) {
+      userDataDir = getProfileDataDir(this.config.profile);
+      log.info(`Using profile "${this.config.profile}" \u2192 ${userDataDir}`);
+    }
     log.debug(`Launching Chrome: ${executablePath}`);
     this.browser = await puppeteer.launch({
       executablePath,
       headless: this.config.headless ?? true,
-      args: [
-        "--no-sandbox",
-        "--disable-setuid-sandbox",
-        "--disable-dev-shm-usage",
-        "--disable-gpu"
-      ]
+      userDataDir,
+      args
     });
+    this.isAttached = false;
     return this.browser;
   }
   async newPage() {
     const browser = await this.connect();
-    return browser.newPage();
+    const page = await browser.newPage();
+    if (this.config.stealth) {
+      await injectStealth(page);
+      log.debug("Stealth mode enabled");
+    }
+    return page;
   }
   async close() {
     if (this.browser) {
-      await this.browser.close().catch(() => {
-      });
+      if (this.isAttached) {
+        this.browser.disconnect();
+        log.debug("Disconnected from Chrome (attached mode)");
+      } else {
+        await this.browser.close().catch(() => {
+        });
+      }
       this.browser = null;
     }
   }
@@ -510,7 +1102,7 @@ function findChrome() {
     "/usr/bin/chromium",
     "/snap/bin/chromium"
   ];
-  return paths.find((p) => existsSync(p));
+  return paths.find((p) => existsSync3(p));
 }
 
 // src/browser/dom/flat-tree.ts
@@ -1016,6 +1608,164 @@ var SNAPSHOT_SCRIPT = `
 })()
 `;
 
+// src/browser/dom/compact-snapshot.ts
+var COMPACT_SNAPSHOT_SCRIPT = `
+(() => {
+  const TOKEN_BUDGET = 800;
+  const CHARS_PER_TOKEN = 4;
+
+  const INTERACTIVE_TAGS = new Set([
+    'a','button','input','select','textarea','details','summary','label',
+  ]);
+  const INTERACTIVE_ROLES = new Set([
+    'button','link','textbox','checkbox','radio','combobox','listbox',
+    'menu','menuitem','tab','switch','slider','searchbox','spinbutton',
+    'option','menuitemcheckbox','menuitemradio','treeitem',
+  ]);
+  const LANDMARK_TAGS = new Map([
+    ['nav', 'Navigation'],
+    ['main', 'Main Content'],
+    ['header', 'Header'],
+    ['footer', 'Footer'],
+    ['aside', 'Sidebar'],
+    ['form', 'Form'],
+  ]);
+  const LANDMARK_ROLES = new Map([
+    ['navigation', 'Navigation'],
+    ['main', 'Main Content'],
+    ['banner', 'Header'],
+    ['contentinfo', 'Footer'],
+    ['complementary', 'Sidebar'],
+    ['search', 'Search'],
+    ['dialog', 'Dialog'],
+  ]);
+
+  function isVisible(el) {
+    if (el.offsetWidth === 0 && el.offsetHeight === 0 && el.tagName !== 'INPUT') return false;
+    const s = getComputedStyle(el);
+    return s.display !== 'none' && s.visibility !== 'hidden' && s.opacity !== '0';
+  }
+
+  function isInteractive(el) {
+    const tag = el.tagName.toLowerCase();
+    if (INTERACTIVE_TAGS.has(tag)) {
+      if (el.disabled) return false;
+      if (tag === 'input' && el.type === 'hidden') return false;
+      return true;
+    }
+    const role = el.getAttribute('role');
+    if (role && INTERACTIVE_ROLES.has(role)) return true;
+    if (el.contentEditable === 'true') return true;
+    if (el.tabIndex >= 0 && el.getAttribute('tabindex') !== null) return true;
+    return false;
+  }
+
+  function getRole(el) {
+    const role = el.getAttribute('role');
+    if (role) return role;
+    const tag = el.tagName.toLowerCase();
+    if (tag === 'a') return 'link';
+    if (tag === 'button' || tag === 'summary') return 'button';
+    if (tag === 'input') return el.type || 'text';
+    if (tag === 'select') return 'select';
+    if (tag === 'textarea') return 'textarea';
+    if (tag === 'label') return 'label';
+    return tag;
+  }
+
+  function getName(el) {
+    return (
+      el.getAttribute('aria-label') ||
+      el.getAttribute('alt') ||
+      el.getAttribute('title') ||
+      el.getAttribute('placeholder') ||
+      (el.tagName === 'INPUT' && (el.type === 'submit' || el.type === 'button') ? el.value : '') ||
+      (el.id ? document.querySelector('label[for="' + el.id + '"]')?.textContent?.trim() : '') ||
+      (el.children.length <= 2 ? el.textContent?.trim() : '') ||
+      ''
+    ).slice(0, 60);
+  }
+
+  function getValue(el) {
+    const tag = el.tagName.toLowerCase();
+    if (tag === 'input') {
+      const type = el.type || 'text';
+      if (type === 'checkbox' || type === 'radio') return el.checked ? 'checked' : 'unchecked';
+      if (type === 'password') return el.value ? '****' : '';
+      return el.value ? el.value.slice(0, 30) : '';
+    }
+    if (tag === 'textarea') return el.value ? el.value.slice(0, 30) : '';
+    if (tag === 'select' && el.selectedOptions?.length) return el.selectedOptions[0].text.slice(0, 30);
+    return '';
+  }
+
+  // Collect elements
+  let idx = 0;
+  let charsUsed = 0;
+  const lines = [];
+  let lastLandmark = '';
+
+  // Page header
+  const scrollY = window.scrollY;
+  const scrollMax = document.documentElement.scrollHeight - window.innerHeight;
+  const scrollPct = scrollMax > 0 ? Math.round((scrollY / scrollMax) * 100) : 0;
+  const header = 'url: ' + location.href + ' | scroll: ' + scrollPct + '%';
+  lines.push(header);
+  charsUsed += header.length;
+
+  // Walk DOM
+  const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT);
+  let node;
+  while ((node = walker.nextNode())) {
+    if (!isVisible(node)) continue;
+
+    const tag = node.tagName.toLowerCase();
+    if (['script','style','noscript','svg','path','meta','link','head','template'].includes(tag)) continue;
+
+    // Check for landmark
+    const role = node.getAttribute('role');
+    const landmark = LANDMARK_TAGS.get(tag) || (role ? LANDMARK_ROLES.get(role) : null);
+    if (landmark && landmark !== lastLandmark) {
+      const sectionLine = '--- ' + landmark + ' ---';
+      if (charsUsed + sectionLine.length > TOKEN_BUDGET * CHARS_PER_TOKEN) break;
+      lines.push(sectionLine);
+      charsUsed += sectionLine.length;
+      lastLandmark = landmark;
+    }
+
+    // Only emit interactive elements
+    if (!isInteractive(node)) continue;
+
+    const elRole = getRole(node);
+    const name = getName(node);
+    const value = getValue(node);
+
+    // Build compact line
+    let line = '[' + idx + '] ' + elRole;
+    if (name) line += ' "' + name.replace(/"/g, "'") + '"';
+    if (value) line += ' val="' + value.replace(/"/g, "'") + '"';
+
+    // Check token budget
+    if (charsUsed + line.length > TOKEN_BUDGET * CHARS_PER_TOKEN) {
+      lines.push('... (' + (document.querySelectorAll('a,button,input,select,textarea,[role]').length - idx) + ' more elements)');
+      break;
+    }
+
+    // Annotate element with ref for clicking
+    try { node.dataset.ref = String(idx); } catch {}
+
+    lines.push(line);
+    charsUsed += line.length;
+    idx++;
+  }
+
+  return lines.join('\\n');
+})()
+`;
+function buildCompactSnapshotScript(tokenBudget = 800) {
+  return COMPACT_SNAPSHOT_SCRIPT.replace("const TOKEN_BUDGET = 800;", `const TOKEN_BUDGET = ${tokenBudget};`);
+}
+
 // src/browser/dom/semantic-tree.ts
 var SEMANTIC_TREE_SCRIPT = `
 (() => {
@@ -1526,18 +2276,76 @@ var FORM_STATE_SCRIPT = `
     });
   }
 
-  // Collect orphan fields (not in a <form>)
-  const allInputs = document.querySelectorAll(
-    'input, textarea, select, [contenteditable="true"]'
-  );
-  for (const el of allInputs) {
-    if (!el.form) {
-      const field = extractField(el);
-      if (field) result.orphanFields.push(field);
-    }
-  }
-
-  return result;
+  // Collect orphan fields (not in a <form>)
+  const allInputs = document.querySelectorAll(
+    'input, textarea, select, [contenteditable="true"]'
+  );
+  for (const el of allInputs) {
+    if (!el.form) {
+      const field = extractField(el);
+      if (field) result.orphanFields.push(field);
+    }
+  }
+
+  return result;
+})()
+`;
+
+// src/browser/dom/interactive.ts
+var INTERACTIVE_ELEMENTS_SCRIPT = `
+(() => {
+  const results = [];
+
+  function classify(el) {
+    const tag = el.tagName.toLowerCase();
+    const role = el.getAttribute('role');
+    const types = [];
+
+    // Native interactive
+    if (['a', 'button', 'input', 'select', 'textarea', 'details', 'summary'].includes(tag)) {
+      types.push('native');
+    }
+
+    // ARIA role interactive
+    if (role && ['button', 'link', 'textbox', 'checkbox', 'radio', 'combobox', 'tab', 'switch', 'menuitem', 'slider'].includes(role)) {
+      types.push('aria');
+    }
+
+    // Contenteditable
+    if (el.contentEditable === 'true') types.push('contenteditable');
+
+    // Focusable
+    if (el.tabIndex >= 0 && el.getAttribute('tabindex') !== null) types.push('focusable');
+
+    // Has click listener (approximate)
+    if (el.onclick) types.push('listener');
+
+    return types;
+  }
+
+  let idx = 0;
+  const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT);
+  let node;
+  while (node = walker.nextNode()) {
+    const types = classify(node);
+    if (types.length === 0) continue;
+
+    const style = getComputedStyle(node);
+    if (style.display === 'none' || style.visibility === 'hidden') continue;
+
+    const rect = node.getBoundingClientRect();
+    results.push({
+      index: idx++,
+      tag: node.tagName.toLowerCase(),
+      role: node.getAttribute('role') || '',
+      text: (node.textContent || '').trim().slice(0, 100),
+      types,
+      ariaLabel: node.getAttribute('aria-label') || '',
+      rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
+    });
+  }
+
+  return results;
 })()
 `;
 
@@ -1597,6 +2405,155 @@ var GET_INTERCEPTED_SCRIPT = `
 })()
 `;
 
+// src/browser/semantic-find.ts
+var SYNONYMS = {
+  btn: ["button"],
+  button: ["btn", "submit", "click"],
+  submit: ["go", "send", "ok", "confirm", "done", "button"],
+  search: ["find", "lookup", "query", "filter"],
+  login: ["signin", "sign-in", "log-in", "authenticate"],
+  signup: ["register", "create-account", "sign-up", "join"],
+  logout: ["signout", "sign-out", "log-out"],
+  close: ["dismiss", "x", "cancel", "exit"],
+  menu: ["nav", "navigation", "hamburger", "sidebar"],
+  nav: ["navigation", "menu", "navbar"],
+  input: ["field", "textbox", "text", "entry"],
+  email: ["mail", "e-mail"],
+  password: ["pass", "pwd", "secret"],
+  next: ["continue", "forward", "proceed"],
+  back: ["previous", "return", "go-back"],
+  save: ["store", "keep", "persist"],
+  delete: ["remove", "trash", "discard", "destroy"],
+  edit: ["modify", "change", "update"],
+  add: ["create", "new", "plus", "insert"],
+  settings: ["preferences", "config", "options", "gear"],
+  profile: ["account", "user", "avatar"],
+  home: ["main", "dashboard", "start"],
+  link: ["anchor", "href", "url"],
+  select: ["dropdown", "combo", "picker", "choose"],
+  checkbox: ["check", "toggle", "tick"],
+  upload: ["attach", "file", "browse"],
+  download: ["save", "export"]
+};
+var ROLE_KEYWORDS = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "input",
+  "textbox",
+  "checkbox",
+  "radio",
+  "select",
+  "dropdown",
+  "tab",
+  "menu",
+  "menuitem",
+  "switch",
+  "slider",
+  "combobox",
+  "searchbox",
+  "option"
+]);
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/[\s-]+/).filter((t) => t.length > 0);
+}
+function expandSynonyms(tokens) {
+  const expanded = new Set(tokens);
+  for (const token of tokens) {
+    const syns = SYNONYMS[token];
+    if (syns) {
+      for (const syn of syns) expanded.add(syn);
+    }
+  }
+  return expanded;
+}
+function freqMap(tokens) {
+  const map = /* @__PURE__ */ new Map();
+  for (const t of tokens) {
+    map.set(t, (map.get(t) || 0) + 1);
+  }
+  return map;
+}
+function jaccardScore(queryTokens, descTokens) {
+  const qFreq = freqMap(queryTokens);
+  const dFreq = freqMap(descTokens);
+  let intersection = 0;
+  let union = 0;
+  const allTokens = /* @__PURE__ */ new Set([...qFreq.keys(), ...dFreq.keys()]);
+  for (const token of allTokens) {
+    const qCount = qFreq.get(token) || 0;
+    const dCount = dFreq.get(token) || 0;
+    intersection += Math.min(qCount, dCount);
+    union += Math.max(qCount, dCount);
+  }
+  return union === 0 ? 0 : intersection / union;
+}
+function prefixScore(queryTokens, descTokens) {
+  if (queryTokens.length === 0 || descTokens.length === 0) return 0;
+  let matches = 0;
+  for (const qt of queryTokens) {
+    if (qt.length < 3) continue;
+    for (const dt of descTokens) {
+      if (dt.startsWith(qt) || qt.startsWith(dt)) {
+        matches += 0.5;
+        break;
+      }
+    }
+  }
+  return Math.min(matches / queryTokens.length, 0.3);
+}
+function roleBoost(queryTokens, elementRole) {
+  const roleLower = elementRole.toLowerCase();
+  for (const qt of queryTokens) {
+    if (ROLE_KEYWORDS.has(qt) && roleLower.includes(qt)) {
+      return 0.2;
+    }
+  }
+  return 0;
+}
+function scoreElement(queryTokens, queryExpanded, element) {
+  const descParts = [
+    element.text,
+    element.role,
+    element.tag,
+    element.ariaLabel
+  ].filter(Boolean);
+  const descText = descParts.join(" ");
+  const descTokens = tokenize(descText);
+  if (descTokens.length === 0) return 0;
+  const descExpanded = expandSynonyms(descTokens);
+  const expandedQueryTokens = [...queryExpanded];
+  const expandedDescTokens = [...descExpanded];
+  const jaccard = jaccardScore(expandedQueryTokens, expandedDescTokens);
+  const prefix = prefixScore(queryTokens, descTokens);
+  const role = roleBoost(queryTokens, element.role || element.tag);
+  const queryStr = queryTokens.join(" ");
+  const descStr = descTokens.join(" ");
+  const exactBonus = descStr.includes(queryStr) ? 0.3 : 0;
+  return Math.min(jaccard + prefix + role + exactBonus, 1);
+}
+function semanticFind(elements, query, options) {
+  const maxResults = options?.maxResults ?? 5;
+  const minScore = options?.minScore ?? 0.3;
+  const queryTokens = tokenize(query);
+  if (queryTokens.length === 0) return [];
+  const queryExpanded = expandSynonyms(queryTokens);
+  const scored = [];
+  for (const el of elements) {
+    const score = scoreElement(queryTokens, queryExpanded, el);
+    if (score >= minScore) {
+      scored.push({
+        ref: el.index,
+        score: Math.round(score * 100) / 100,
+        text: (el.text || el.ariaLabel || "").slice(0, 60),
+        role: el.role || el.tag,
+        tag: el.tag
+      });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, maxResults);
+}
+
 // src/browser/page-adapter.ts
 var PuppeteerPage = class {
   page;
@@ -1624,7 +2581,10 @@ var PuppeteerPage = class {
   async evaluate(js) {
     return this.page.evaluate(js);
   }
-  async snapshot(_opts) {
+  async snapshot(opts) {
+    if (opts?.compact) {
+      return this.page.evaluate(COMPACT_SNAPSHOT_SCRIPT);
+    }
     return this.page.evaluate(SNAPSHOT_SCRIPT);
   }
   async semanticTree(_opts) {
@@ -1896,69 +2856,15 @@ var PuppeteerPage = class {
       active: p === this.page
     }));
   }
+  async find(query, options) {
+    const elements = await this.page.evaluate(INTERACTIVE_ELEMENTS_SCRIPT);
+    return semanticFind(elements, query, options);
+  }
   async close() {
     await this.page.close();
   }
 };
 
-// src/browser/dom/interactive.ts
-var INTERACTIVE_ELEMENTS_SCRIPT = `
-(() => {
-  const results = [];
-
-  function classify(el) {
-    const tag = el.tagName.toLowerCase();
-    const role = el.getAttribute('role');
-    const types = [];
-
-    // Native interactive
-    if (['a', 'button', 'input', 'select', 'textarea', 'details', 'summary'].includes(tag)) {
-      types.push('native');
-    }
-
-    // ARIA role interactive
-    if (role && ['button', 'link', 'textbox', 'checkbox', 'radio', 'combobox', 'tab', 'switch', 'menuitem', 'slider'].includes(role)) {
-      types.push('aria');
-    }
-
-    // Contenteditable
-    if (el.contentEditable === 'true') types.push('contenteditable');
-
-    // Focusable
-    if (el.tabIndex >= 0 && el.getAttribute('tabindex') !== null) types.push('focusable');
-
-    // Has click listener (approximate)
-    if (el.onclick) types.push('listener');
-
-    return types;
-  }
-
-  let idx = 0;
-  const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT);
-  let node;
-  while (node = walker.nextNode()) {
-    const types = classify(node);
-    if (types.length === 0) continue;
-
-    const style = getComputedStyle(node);
-    if (style.display === 'none' || style.visibility === 'hidden') continue;
-
-    const rect = node.getBoundingClientRect();
-    results.push({
-      index: idx++,
-      tag: node.tagName.toLowerCase(),
-      role: node.getAttribute('role') || '',
-      text: (node.textContent || '').trim().slice(0, 100),
-      types,
-      ariaLabel: node.getAttribute('aria-label') || '',
-      rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
-    });
-  }
-
-  return results;
-})()
-`;
-
 // src/browser/lightpanda.ts
 var SELF_CLOSING = /* @__PURE__ */ new Set([
   "area",
@@ -2672,8 +3578,8 @@ function getAllSites() {
 }
 
 // src/discover/explore.ts
-import { writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
-import { join } from "path";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
+import { join as join3 } from "path";
 var SITE_ALIASES = {
   "x.com": "twitter",
   "twitter.com": "twitter",
@@ -2921,8 +3827,8 @@ async function recoverMissingBodies(page, endpoints) {
   }
 }
 function writeArtifacts(dir, result) {
-  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "manifest.json"), JSON.stringify({
+  if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
+  writeFileSync3(join3(dir, "manifest.json"), JSON.stringify({
     site: result.site,
     domain: result.domain,
     framework: result.framework,
@@ -2931,7 +3837,7 @@ function writeArtifacts(dir, result) {
     endpointCount: result.endpoints.length,
     exploredAt: (/* @__PURE__ */ new Date()).toISOString()
   }, null, 2));
-  writeFileSync(join(dir, "endpoints.json"), JSON.stringify(
+  writeFileSync3(join3(dir, "endpoints.json"), JSON.stringify(
     result.endpoints.map((ep) => ({
       url: ep.url,
       pattern: ep.pattern,
@@ -2948,7 +3854,7 @@ function writeArtifacts(dir, result) {
     null,
     2
   ));
-  writeFileSync(join(dir, "capabilities.json"), JSON.stringify(
+  writeFileSync3(join3(dir, "capabilities.json"), JSON.stringify(
     result.capabilities.map((cap) => {
       const matchingEndpoints = result.endpoints.filter((ep) => {
         const path = ep.url.toLowerCase();
@@ -2976,9 +3882,9 @@ function writeArtifacts(dir, result) {
       authSummary[ind].push(ep.pattern);
     }
   }
-  writeFileSync(join(dir, "auth.json"), JSON.stringify(authSummary, null, 2));
+  writeFileSync3(join3(dir, "auth.json"), JSON.stringify(authSummary, null, 2));
   if (result.stores && result.stores.length > 0) {
-    writeFileSync(join(dir, "stores.json"), JSON.stringify(result.stores, null, 2));
+    writeFileSync3(join3(dir, "stores.json"), JSON.stringify(result.stores, null, 2));
   }
   log.success(`Artifacts written to ${dir}/`);
 }
@@ -3115,14 +4021,14 @@ async function exploreSite(page, url, options) {
     stores: stores.length > 0 ? stores : void 0,
     capabilities
   };
-  const outputDir = options?.outputDir || join(process.cwd(), ".lobster", "explore", site);
+  const outputDir = options?.outputDir || join3(process.cwd(), ".lobster", "explore", site);
   writeArtifacts(outputDir, result);
   result.artifactDir = outputDir;
   return result;
 }
 
 // src/discover/synthesize.ts
-import yaml from "js-yaml";
+import yaml2 from "js-yaml";
 function synthesizeAdapter(result, goal) {
   const topEndpoints = result.endpoints.filter((e) => e.score > 0).slice(0, 3);
   if (topEndpoints.length === 0) {
@@ -3193,7 +4099,7 @@ function synthesizeAdapter(result, goal) {
     pipeline,
     columns: columns.length > 0 ? columns : void 0
   };
-  return yaml.dump(adapter, { indent: 2, lineWidth: 120 });
+  return yaml2.dump(adapter, { indent: 2, lineWidth: 120 });
 }
 
 // src/cascade/index.ts
@@ -3362,17 +4268,17 @@ function makeRoutingDecision(request) {
 }
 
 // src/agent/core.ts
-import { readFileSync } from "fs";
-import { join as join2, dirname } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join4, dirname } from "path";
 import { fileURLToPath } from "url";
 
 // src/agent/tools/click.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 function createClickTool(page) {
   return {
     description: "Click on an interactive element by its index number from the page content.",
-    inputSchema: z.object({
-      index: z.number().describe("The index of the element to click")
+    inputSchema: z2.object({
+      index: z2.number().describe("The index of the element to click")
     }),
     execute: async (args) => {
       await page.click(args.index);
@@ -3382,13 +4288,13 @@ function createClickTool(page) {
 }
 
 // src/agent/tools/type.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 function createTypeTool(page) {
   return {
     description: "Type text into an input field identified by its index number.",
-    inputSchema: z2.object({
-      index: z2.number().describe("The index of the input element"),
-      text: z2.string().describe("The text to type")
+    inputSchema: z3.object({
+      index: z3.number().describe("The index of the input element"),
+      text: z3.string().describe("The text to type")
     }),
     execute: async (args) => {
       await page.typeText(args.index, args.text);
@@ -3398,13 +4304,13 @@ function createTypeTool(page) {
 }
 
 // src/agent/tools/scroll.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 function createScrollTool(page) {
   return {
     description: "Scroll the page in a given direction. Use to reveal more content.",
-    inputSchema: z3.object({
-      direction: z3.enum(["up", "down", "left", "right"]).describe("Scroll direction"),
-      amount: z3.number().optional().describe("Pixels to scroll (default 500)")
+    inputSchema: z4.object({
+      direction: z4.enum(["up", "down", "left", "right"]).describe("Scroll direction"),
+      amount: z4.number().optional().describe("Pixels to scroll (default 500)")
     }),
     execute: async (args) => {
       await page.scroll(args.direction, args.amount);
@@ -3414,13 +4320,13 @@ function createScrollTool(page) {
 }
 
 // src/agent/tools/select.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 function createSelectTool(page) {
   return {
     description: "Select an option from a dropdown/select element by its index.",
-    inputSchema: z4.object({
-      index: z4.number().describe("The index of the select element"),
-      value: z4.string().describe("The option text or value to select")
+    inputSchema: z5.object({
+      index: z5.number().describe("The index of the select element"),
+      value: z5.string().describe("The option text or value to select")
     }),
     execute: async (args) => {
       await page.selectOption(args.index, args.value);
@@ -3430,12 +4336,12 @@ function createSelectTool(page) {
 }
 
 // src/agent/tools/wait.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 function createWaitTool() {
   return {
     description: "Wait for a specified number of seconds before continuing.",
-    inputSchema: z5.object({
-      seconds: z5.number().min(0.1).max(30).describe("Seconds to wait")
+    inputSchema: z6.object({
+      seconds: z6.number().min(0.1).max(30).describe("Seconds to wait")
     }),
     execute: async (args) => {
       await new Promise((r) => setTimeout(r, args.seconds * 1e3));
@@ -3445,13 +4351,13 @@ function createWaitTool() {
 }
 
 // src/agent/tools/done.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function createDoneTool() {
   return {
     description: "Signal that the task is complete. Call this when you have finished the task or cannot proceed further.",
-    inputSchema: z6.object({
-      success: z6.boolean().describe("Whether the task was completed successfully"),
-      text: z6.string().describe("Summary of the result or explanation of failure")
+    inputSchema: z7.object({
+      success: z7.boolean().describe("Whether the task was completed successfully"),
+      text: z7.string().describe("Summary of the result or explanation of failure")
     }),
     execute: async (args) => {
       return JSON.stringify({ done: true, success: args.success, text: args.text });
@@ -3460,13 +4366,13 @@ function createDoneTool() {
 }
 
 // src/agent/tools/ask-user.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 import { createInterface } from "readline";
 function createAskUserTool() {
   return {
     description: "Ask the user a question when you need clarification or input to proceed.",
-    inputSchema: z7.object({
-      question: z7.string().describe("The question to ask the user")
+    inputSchema: z8.object({
+      question: z8.string().describe("The question to ask the user")
     }),
     execute: async (args) => {
       const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -3483,12 +4389,12 @@ function createAskUserTool() {
 }
 
 // src/agent/tools/execute-js.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function createExecuteJsTool(page) {
   return {
     description: "Execute JavaScript code on the current page. Returns the result.",
-    inputSchema: z8.object({
-      code: z8.string().describe("JavaScript code to execute on the page")
+    inputSchema: z9.object({
+      code: z9.string().describe("JavaScript code to execute on the page")
     }),
     execute: async (args) => {
       const result = await page.evaluate(args.code);
@@ -3512,7 +4418,7 @@ function createDefaultTools(page) {
 }
 
 // src/agent/macro-tool.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/agent/auto-fixer.ts
 function normalizeResponse(raw, toolName, availableActions, toolSchemas) {
@@ -3659,14 +4565,14 @@ function packMacroTool(tools) {
   for (const [name, tool] of Object.entries(tools)) {
     toolNames.push(name);
     actionSchemas.push(
-      z9.object({ [name]: tool.inputSchema }).describe(tool.description)
+      z10.object({ [name]: tool.inputSchema }).describe(tool.description)
     );
   }
-  const actionSchema = actionSchemas.length === 1 ? actionSchemas[0] : z9.union(actionSchemas);
-  const macroSchema = z9.object({
-    evaluation_previous_goal: z9.string().optional().describe("Evaluate whether the previous goal was achieved"),
-    memory: z9.string().optional().describe("Important information to remember for future steps"),
-    next_goal: z9.string().optional().describe("The next immediate goal to achieve"),
+  const actionSchema = actionSchemas.length === 1 ? actionSchemas[0] : z10.union(actionSchemas);
+  const macroSchema = z10.object({
+    evaluation_previous_goal: z10.string().optional().describe("Evaluate whether the previous goal was achieved"),
+    memory: z10.string().optional().describe("Important information to remember for future steps"),
+    next_goal: z10.string().optional().describe("The next immediate goal to achieve"),
     action: actionSchema.describe("The action to take")
   });
   return {
@@ -3755,7 +4661,7 @@ var AgentCore = class {
     const macroTool = packMacroTool(tools);
     let systemPrompt;
     try {
-      systemPrompt = readFileSync(join2(__dirname, "prompts", "system.md"), "utf-8");
+      systemPrompt = readFileSync3(join4(__dirname, "prompts", "system.md"), "utf-8");
     } catch {
       systemPrompt = "You are an AI web agent that navigates web pages to complete tasks.";
     }
@@ -3944,128 +4850,104 @@ ${pageContent}
   return prompt;
 }
 
-// src/config/index.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
-import { homedir } from "os";
-import yaml2 from "js-yaml";
-
-// src/config/schema.ts
-import { z as z10 } from "zod";
-var LLM_PROVIDERS = {
-  openai: {
-    name: "OpenAI",
-    baseURL: "https://api.openai.com/v1",
-    defaultModel: "gpt-4o",
-    keyPrefix: "sk-",
-    keyEnvHint: "https://platform.openai.com/api-keys",
-    models: ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "o1", "o1-mini", "o3-mini"]
-  },
-  anthropic: {
-    name: "Anthropic",
-    baseURL: "https://api.anthropic.com/v1",
-    defaultModel: "claude-sonnet-4-20250514",
-    keyPrefix: "sk-ant-",
-    keyEnvHint: "https://console.anthropic.com/settings/keys",
-    models: ["claude-opus-4-20250514", "claude-sonnet-4-20250514", "claude-haiku-4-5-20251001"]
-  },
-  gemini: {
-    name: "Google Gemini",
-    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai",
-    defaultModel: "gemini-2.5-flash",
-    keyPrefix: "AI",
-    keyEnvHint: "https://aistudio.google.com/apikey",
-    models: ["gemini-2.5-flash", "gemini-2.5-flash-lite", "gemini-2.5-pro", "gemini-3-flash-preview"]
-  },
-  ollama: {
-    name: "Ollama (local, free)",
-    baseURL: "http://localhost:11434/v1",
-    defaultModel: "llama3.1",
-    keyPrefix: "",
-    keyEnvHint: "No API key needed \u2014 install from https://ollama.ai",
-    models: ["llama3.1", "llama3.2", "mistral", "codestral", "qwen2.5", "deepseek-r1"]
+// src/domain-guard.ts
+var DEFAULT_BLOCK_MESSAGE = "This domain is not allowed by the current configuration.";
+var DomainGuard = class {
+  allow;
+  block;
+  message;
+  matchSubs;
+  constructor(config = {}) {
+    this.allow = (config.allowDomains || []).map((d) => d.toLowerCase().replace(/^www\./, ""));
+    this.block = (config.blockDomains || []).map((d) => d.toLowerCase().replace(/^www\./, ""));
+    this.message = config.blockMessage || DEFAULT_BLOCK_MESSAGE;
+    this.matchSubs = config.matchSubdomains ?? true;
   }
-};
-var configSchema = z10.object({
-  llm: z10.object({
-    provider: z10.enum(["openai", "anthropic", "gemini", "ollama"]).default("openai"),
-    baseURL: z10.string().default("https://api.openai.com/v1"),
-    model: z10.string().default("gpt-4o"),
-    apiKey: z10.string().default(""),
-    temperature: z10.number().min(0).max(2).default(0.1),
-    maxRetries: z10.number().int().min(0).default(3)
-  }).default({}),
-  browser: z10.object({
-    executablePath: z10.string().default(""),
-    headless: z10.boolean().default(true),
-    connectTimeout: z10.number().default(30),
-    commandTimeout: z10.number().default(60),
-    cdpEndpoint: z10.string().default("")
-  }).default({}),
-  agent: z10.object({
-    maxSteps: z10.number().int().default(40),
-    stepDelay: z10.number().default(0.4)
-  }).default({}),
-  output: z10.object({
-    defaultFormat: z10.enum(["table", "json", "yaml", "markdown", "csv"]).default("table"),
-    color: z10.boolean().default(true)
-  }).default({})
-});
-
-// src/config/index.ts
-var CONFIG_DIR = join3(homedir(), ".lobster");
-var CONFIG_FILE = join3(CONFIG_DIR, "config.yaml");
-function ensureConfigDir() {
-  if (!existsSync3(CONFIG_DIR)) {
-    mkdirSync2(CONFIG_DIR, { recursive: true });
+  /**
+   * Check if a URL is allowed. Returns true if allowed, throws if blocked.
+   */
+  check(url) {
+    if (this.allow.length === 0 && this.block.length === 0) return true;
+    const domain = this.extractDomain(url);
+    if (!domain) return true;
+    if (this.allow.length > 0) {
+      if (!this.matches(domain, this.allow)) {
+        throw new DomainBlockedError(domain, this.message);
+      }
+      return true;
+    }
+    if (this.block.length > 0) {
+      if (this.matches(domain, this.block)) {
+        throw new DomainBlockedError(domain, this.message);
+      }
+      return true;
+    }
+    return true;
   }
-}
-function loadConfig() {
-  ensureConfigDir();
-  let fileConfig = {};
-  if (existsSync3(CONFIG_FILE)) {
-    const raw = readFileSync2(CONFIG_FILE, "utf-8");
-    fileConfig = yaml2.load(raw) || {};
+  /**
+   * Check without throwing — returns { allowed, domain, message }.
+   */
+  test(url) {
+    const domain = this.extractDomain(url);
+    if (!domain) return { allowed: true, domain: "" };
+    try {
+      this.check(url);
+      return { allowed: true, domain };
+    } catch (err) {
+      if (err instanceof DomainBlockedError) {
+        return { allowed: false, domain, message: err.message };
+      }
+      return { allowed: true, domain };
+    }
   }
-  const envOverrides = {};
-  if (process.env.LOBSTER_API_KEY) {
-    envOverrides.llm = { ...fileConfig.llm || {}, apiKey: process.env.LOBSTER_API_KEY };
+  /**
+   * Check if domain matches any pattern in the list.
+   */
+  matches(domain, patterns) {
+    for (const pattern of patterns) {
+      if (domain === pattern) return true;
+      if (this.matchSubs && domain.endsWith("." + pattern)) return true;
+    }
+    return false;
   }
-  if (process.env.LOBSTER_MODEL) {
-    envOverrides.llm = { ...envOverrides.llm || fileConfig.llm || {}, model: process.env.LOBSTER_MODEL };
+  /**
+   * Extract domain from URL, stripping www. prefix.
+   */
+  extractDomain(url) {
+    try {
+      const parsed = new URL(url.startsWith("http") ? url : "https://" + url);
+      return parsed.hostname.toLowerCase().replace(/^www\./, "");
+    } catch {
+      return "";
+    }
   }
-  if (process.env.LOBSTER_BASE_URL) {
-    envOverrides.llm = { ...envOverrides.llm || fileConfig.llm || {}, baseURL: process.env.LOBSTER_BASE_URL };
+  /**
+   * Whether any restrictions are active.
+   */
+  get isRestricted() {
+    return this.allow.length > 0 || this.block.length > 0;
   }
-  if (process.env.LOBSTER_CDP_ENDPOINT) {
-    envOverrides.browser = { ...fileConfig.browser || {}, cdpEndpoint: process.env.LOBSTER_CDP_ENDPOINT };
+  /**
+   * Get list of allowed domains (empty = all allowed).
+   */
+  get allowedDomains() {
+    return [...this.allow];
   }
-  if (process.env.LOBSTER_BROWSER_PATH) {
-    envOverrides.browser = { ...envOverrides.browser || fileConfig.browser || {}, executablePath: process.env.LOBSTER_BROWSER_PATH };
+  /**
+   * Get list of blocked domains.
+   */
+  get blockedDomains() {
+    return [...this.block];
   }
-  const merged = { ...fileConfig, ...envOverrides };
-  return configSchema.parse(merged);
-}
-function saveConfig(config) {
-  ensureConfigDir();
-  const existing = loadConfig();
-  const merged = deepMerge(existing, config);
-  writeFileSync2(CONFIG_FILE, yaml2.dump(merged, { indent: 2 }), "utf-8");
-}
-function getConfigDir() {
-  return CONFIG_DIR;
-}
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key]) && target[key] && typeof target[key] === "object" && !Array.isArray(target[key])) {
-      result[key] = deepMerge(target[key], source[key]);
-    } else {
-      result[key] = source[key];
-    }
+};
+var DomainBlockedError = class extends Error {
+  domain;
+  constructor(domain, message) {
+    super(message);
+    this.name = "DomainBlockedError";
+    this.domain = domain;
   }
-  return result;
-}
+};
 
 // src/output/table.ts
 import Table from "cli-table3";
@@ -4159,6 +5041,9 @@ function render(data, format, columns) {
 export {
   AgentCore,
   BrowserManager,
+  COMPACT_SNAPSHOT_SCRIPT,
+  DomainBlockedError,
+  DomainGuard,
   FLAT_TREE_SCRIPT,
   FORM_STATE_SCRIPT,
   GET_INTERCEPTED_SCRIPT,
@@ -4170,13 +5055,18 @@ export {
   PuppeteerPage,
   SEMANTIC_TREE_SCRIPT,
   SNAPSHOT_SCRIPT,
+  STEALTH_ARGS,
+  STEALTH_SCRIPT,
   Strategy,
+  buildCompactSnapshotScript,
   buildInterceptorScript,
   buildSnapshotScript,
   cascadeProbe,
   classifyIntent,
   cli,
   configSchema,
+  createProfile,
+  discoverChrome,
   executePipeline,
   exploreSite,
   extractLinks,
@@ -4190,17 +5080,24 @@ export {
   getAllAdapters,
   getAllSites,
   getConfigDir,
+  getProfileDataDir,
   getStep,
   getStepNames,
   heuristicClassify,
+  injectStealth,
+  listProfiles,
   loadConfig,
   lobsterFetch,
   makeRoutingDecision,
   parseHtml,
   registerStep,
+  removeProfile,
   render,
   renderTemplate,
+  resetProfileCache,
+  resolveAttachTarget,
   saveConfig,
+  semanticFind,
   synthesizeAdapter
 };
 //# sourceMappingURL=lib.js.map