lobster-cli 0.1.0 → 0.3.0

package/dist/browser/index.js

@@ -1,6 +1,214 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/browser/pdf.ts
+var pdf_exports = {};
+__export(pdf_exports, {
+  extractPdf: () => extractPdf,
+  isPdfResponse: () => isPdfResponse,
+  isPdfUrl: () => isPdfUrl,
+  tryExtractPdf: () => tryExtractPdf
+});
+import { readFileSync as readFileSync3 } from "fs";
+async function getPdfParser() {
+  if (!pdfParseFn) {
+    const mod = await import("pdf-parse");
+    const PDFParseClass = mod.PDFParse;
+    if (PDFParseClass && typeof PDFParseClass === "function") {
+      pdfParseFn = async (buffer) => {
+        const parser = new PDFParseClass(buffer);
+        return parser.parse ? await parser.parse() : parser;
+      };
+    } else {
+      pdfParseFn = mod.default || mod;
+    }
+  }
+  return pdfParseFn;
+}
+function isPdfUrl(urlOrPath) {
+  const lower = urlOrPath.toLowerCase();
+  if (lower.endsWith(".pdf")) return true;
+  if (/\/pdf\//.test(lower)) return true;
+  if (/arxiv\.org\/pdf\//.test(lower)) return true;
+  if (/[?&]format=pdf/i.test(lower)) return true;
+  if (/[?&]type=pdf/i.test(lower)) return true;
+  return false;
+}
+function isPdfResponse(contentType) {
+  return contentType.includes("application/pdf");
+}
+async function downloadPdf(url) {
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+      "Accept": "application/pdf,*/*"
+    },
+    redirect: "follow"
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to download PDF: ${response.status} ${response.statusText}`);
+  }
+  const contentType = response.headers.get("content-type") || "";
+  if (!contentType.includes("pdf") && !isPdfUrl(url)) {
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  return Buffer.from(arrayBuffer);
+}
+function readLocalPdf(filePath) {
+  return readFileSync3(filePath);
+}
+function textToMarkdown(text, metadata) {
+  const lines = text.split("\n");
+  const mdLines = [];
+  if (metadata.title && metadata.title !== "untitled") {
+    mdLines.push(`# ${metadata.title}`);
+    mdLines.push("");
+    if (metadata.author) {
+      mdLines.push(`**Authors:** ${metadata.author}`);
+      mdLines.push("");
+    }
+    mdLines.push("---");
+    mdLines.push("");
+  }
+  let inReferences = false;
+  let prevWasBlank = false;
+  let paragraphBuffer = [];
+  function flushParagraph() {
+    if (paragraphBuffer.length > 0) {
+      mdLines.push(paragraphBuffer.join(" "));
+      mdLines.push("");
+      paragraphBuffer = [];
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line) {
+      if (!prevWasBlank) {
+        flushParagraph();
+      }
+      prevWasBlank = true;
+      continue;
+    }
+    prevWasBlank = false;
+    const numberedHeading = line.match(/^(\d+\.?\d*\.?\d*)\s+([A-Z][A-Za-z\s:&-]+)$/);
+    if (numberedHeading && line.length < 80) {
+      flushParagraph();
+      const depth = numberedHeading[1].split(".").filter(Boolean).length;
+      const prefix = depth <= 1 ? "##" : depth === 2 ? "###" : "####";
+      mdLines.push(`${prefix} ${line}`);
+      mdLines.push("");
+      continue;
+    }
+    if (line === line.toUpperCase() && line.length > 3 && line.length < 60 && /^[A-Z\s:&-]+$/.test(line)) {
+      flushParagraph();
+      mdLines.push(`## ${line.charAt(0) + line.slice(1).toLowerCase()}`);
+      mdLines.push("");
+      continue;
+    }
+    const knownHeadings = /^(Abstract|Introduction|Conclusion|Discussion|Results|Methods|Methodology|Background|Related Work|Acknowledgments|Acknowledgements|References|Bibliography|Appendix)/i;
+    if (knownHeadings.test(line) && line.length < 40) {
+      flushParagraph();
+      if (/^(References|Bibliography)/i.test(line)) {
+        inReferences = true;
+      }
+      mdLines.push(`## ${line}`);
+      mdLines.push("");
+      continue;
+    }
+    if (/^[-•∙◦▪]/.test(line)) {
+      flushParagraph();
+      mdLines.push(`- ${line.replace(/^[-•∙◦▪]\s*/, "")}`);
+      continue;
+    }
+    if (/^\(\d+\)|^[a-z]\)/.test(line)) {
+      flushParagraph();
+      mdLines.push(`- ${line}`);
+      continue;
+    }
+    if (inReferences && /^\[?\d+\]?\.?\s/.test(line)) {
+      flushParagraph();
+      mdLines.push(`- ${line}`);
+      continue;
+    }
+    if (line.endsWith("-") && i + 1 < lines.length) {
+      paragraphBuffer.push(line.slice(0, -1));
+    } else {
+      paragraphBuffer.push(line);
+    }
+  }
+  flushParagraph();
+  return mdLines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+async function extractFromBuffer(buffer) {
+  const parse = await getPdfParser();
+  const result = await parse(buffer);
+  const info = result.info || {};
+  const metadata = {
+    title: info.Title || "untitled",
+    author: info.Author || "",
+    pages: result.numpages,
+    creator: info.Creator || "",
+    producer: info.Producer || "",
+    creationDate: info.CreationDate || ""
+  };
+  const text = result.text || "";
+  const pageTexts = text.split(/\f/).filter(Boolean);
+  const pages = pageTexts.length === result.numpages ? pageTexts : [text];
+  const markdown = textToMarkdown(text, metadata);
+  const words = text.split(/\s+/).filter(Boolean);
+  return {
+    metadata,
+    text,
+    markdown,
+    pages: pages.map((p) => p.trim()),
+    wordCount: words.length,
+    charCount: text.length
+  };
+}
+async function extractPdf(urlOrPath) {
+  let buffer;
+  if (urlOrPath.startsWith("http://") || urlOrPath.startsWith("https://")) {
+    buffer = await downloadPdf(urlOrPath);
+  } else {
+    buffer = readLocalPdf(urlOrPath);
+  }
+  if (buffer[0] !== 37 || buffer[1] !== 80 || buffer[2] !== 68 || buffer[3] !== 70) {
+    throw new Error("Not a valid PDF file (invalid magic bytes)");
+  }
+  return extractFromBuffer(buffer);
+}
+async function tryExtractPdf(url) {
+  if (isPdfUrl(url)) {
+    return extractPdf(url);
+  }
+  try {
+    const head = await fetch(url, { method: "HEAD", redirect: "follow" });
+    const contentType = head.headers.get("content-type") || "";
+    if (isPdfResponse(contentType)) {
+      return extractPdf(url);
+    }
+  } catch {
+  }
+  return null;
+}
+var pdfParseFn;
+var init_pdf = __esm({
+  "src/browser/pdf.ts"() {
+    "use strict";
+    pdfParseFn = null;
+  }
+});
+
 // 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";
@@ -16,20 +224,509 @@ 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 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 getConfigDir() {
+  return CONFIG_DIR;
+}
+
+// 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();
@@ -38,27 +735,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;
     }
   }
@@ -78,7 +796,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
@@ -584,6 +1302,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 = `
 (() => {
@@ -1109,6 +1985,64 @@ var FORM_STATE_SCRIPT = `
 })()
 `;
 
+// 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/interceptor.ts
 function buildInterceptorScript(pattern) {
   return `
@@ -1165,6 +2099,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;
@@ -1192,7 +2275,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) {
@@ -1464,69 +2550,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/wait.ts
 async function waitForCondition(page, condition, timeout = 3e4) {
   switch (condition) {
@@ -1958,6 +2990,43 @@ async function lobsterFetch(url, options) {
   const timeout = options?.timeout || 3e4;
   const dump = options?.dump || "markdown";
   const start = Date.now();
+  const { isPdfUrl: isPdfUrl2, isPdfResponse: isPdfResponse2, extractPdf: extractPdf2 } = await Promise.resolve().then(() => (init_pdf(), pdf_exports));
+  if (isPdfUrl2(url)) {
+    const pdfResult = await extractPdf2(url);
+    const duration2 = Date.now() - start;
+    let content2;
+    switch (dump) {
+      case "markdown":
+        content2 = pdfResult.markdown;
+        break;
+      case "text":
+        content2 = pdfResult.text;
+        break;
+      case "html":
+        content2 = `<pre>${pdfResult.text}</pre>`;
+        break;
+      case "snapshot":
+        content2 = `[PDF] ${pdfResult.metadata.title} (${pdfResult.metadata.pages} pages, ${pdfResult.wordCount} words)
+
+${pdfResult.text.slice(0, 5e3)}`;
+        break;
+      case "links":
+        content2 = "";
+        break;
+      default:
+        content2 = pdfResult.markdown;
+    }
+    return {
+      url,
+      finalUrl: url,
+      title: pdfResult.metadata.title,
+      content: content2,
+      links: [],
+      engine: "pdf",
+      duration: duration2,
+      statusCode: 200
+    };
+  }
   const resp = await fetch(url, {
     headers: {
       "User-Agent": "LobsterCLI/0.1 (+https://github.com/iexcalibur/lobster-cli)",
@@ -1971,6 +3040,48 @@ async function lobsterFetch(url, options) {
   if (!resp.ok) {
     throw new Error(`HTTP ${resp.status} ${resp.statusText}`);
   }
+  const contentType = resp.headers.get("content-type") || "";
+  if (isPdfResponse2(contentType)) {
+    const arrayBuffer = await resp.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    const pdfMod = await import("pdf-parse");
+    const pdfParseFn2 = pdfMod.PDFParse || pdfMod.default || pdfMod;
+    const pdfResult = await pdfParseFn2(buffer);
+    const info = pdfResult.info || {};
+    const metadata = {
+      title: info.Title || "untitled",
+      author: info.Author || "",
+      pages: pdfResult.numpages
+    };
+    const duration2 = Date.now() - start;
+    const text = pdfResult.text || "";
+    let content2;
+    switch (dump) {
+      case "text":
+        content2 = text;
+        break;
+      case "html":
+        content2 = `<pre>${text}</pre>`;
+        break;
+      case "snapshot":
+        content2 = `[PDF] ${metadata.title} (${metadata.pages} pages)
+
+${text.slice(0, 5e3)}`;
+        break;
+      default:
+        content2 = text;
+    }
+    return {
+      url,
+      finalUrl: resp.url || url,
+      title: metadata.title,
+      content: content2,
+      links: [],
+      engine: "pdf",
+      duration: duration2,
+      statusCode: 200
+    };
+  }
   const html = await resp.text();
   const duration = Date.now() - start;
   const finalUrl = resp.url || url;
@@ -2010,8 +3121,12 @@ async function lobsterFetch(url, options) {
   }
   return { url, finalUrl, status: resp.status, title, content, links, duration };
 }
+
+// src/browser/index.ts
+init_pdf();
 export {
   BrowserManager,
+  COMPACT_SNAPSHOT_SCRIPT,
   FLAT_TREE_SCRIPT,
   FORM_STATE_SCRIPT,
   GET_INTERCEPTED_SCRIPT,
@@ -2020,15 +3135,31 @@ export {
   PuppeteerPage,
   SEMANTIC_TREE_SCRIPT,
   SNAPSHOT_SCRIPT,
+  STEALTH_ARGS,
+  STEALTH_SCRIPT,
+  buildCompactSnapshotScript,
   buildInterceptorScript,
   buildSnapshotScript,
+  createProfile,
+  discoverChrome,
   extractLinks,
   extractMarkdown,
+  extractPdf,
   extractSnapshot,
   extractText,
   flatTreeToString,
+  getProfileDataDir,
+  injectStealth,
+  isPdfResponse,
+  isPdfUrl,
+  listProfiles,
   lobsterFetch,
   parseHtml,
+  removeProfile,
+  resetProfileCache,
+  resolveAttachTarget,
+  semanticFind,
+  tryExtractPdf,
   waitForCondition
 };
 //# sourceMappingURL=index.js.map