real-browser-plus 1.1.0

package/dist/index.mjs

@@ -0,0 +1,645 @@
+// src/index.ts
+import puppeteerExtra from "puppeteer-extra";
+import StealthPlugin from "puppeteer-extra-plugin-stealth";
+
+// src/stealth/evasions.ts
+async function applyStealthEvasions(page) {
+  await page.evaluateOnNewDocument(() => {
+    Object.defineProperty(Navigator.prototype, "webdriver", { get: () => void 0, configurable: true });
+    const w = window;
+    if (!w.chrome) {
+      w.chrome = {
+        runtime: {},
+        loadTimes: function() {
+        },
+        csi: function() {
+        },
+        app: { isInstalled: false }
+      };
+    }
+    const originalQuery = window.navigator.permissions.query;
+    window.navigator.permissions.query = (parameters) => parameters.name === "notifications" ? Promise.resolve({ state: Notification.permission }) : originalQuery(parameters);
+    Object.defineProperty(navigator, "plugins", {
+      get: () => [
+        { name: "PDF Viewer", filename: "internal-pdf-viewer" },
+        { name: "Chrome PDF Viewer", filename: "internal-pdf-viewer" },
+        { name: "Chromium PDF Viewer", filename: "internal-pdf-viewer" },
+        { name: "Native Client", filename: "internal-nacl-plugin" }
+      ]
+    });
+    try {
+      const proto = HTMLIFrameElement.prototype;
+      const oIFCW = proto.__lookupGetter__?.call(HTMLIFrameElement.prototype, "contentWindow");
+      if (oIFCW) {
+        Object.defineProperty(HTMLIFrameElement.prototype, "contentWindow", {
+          get: function() {
+            return oIFCW.call(this);
+          }
+        });
+      }
+    } catch {
+    }
+    const doc = document;
+    delete doc.$cdc_asdjflasutopfhvcZLmcfl_;
+    const win = window;
+    delete win.cdc_adoQpoasnfa76pfcZLmcfl_Array;
+    window.Function.prototype.toString = new Proxy(window.Function.prototype.toString, {
+      apply(target, thisArg, args) {
+        if (thisArg === window.navigator.permissions.query) return "function query() { [native code] }";
+        return Reflect.apply(target, thisArg, args);
+      }
+    });
+    try {
+      Object.defineProperty(Notification, "permission", { get: () => "default" });
+    } catch {
+    }
+  });
+}
+
+// src/stealth/index.ts
+var STEALTH_LAUNCH_ARGS = [
+  "--disable-blink-features=AutomationControlled",
+  "--disable-features=IsolateOrigins,site-per-process",
+  "--no-first-run",
+  "--no-default-browser-check",
+  "--disable-infobars",
+  "--window-position=0,0",
+  "--disable-dev-shm-usage"
+];
+async function applyAllStealth(page) {
+  await applyStealthEvasions(page);
+}
+
+// src/fingerprint/generator.ts
+var CHROME_VERSIONS = ["128.0.6613.120", "129.0.6668.90", "130.0.6723.92", "131.0.6778.86", "132.0.6834.83"];
+var WINDOWS_UA_TEMPLATE = (v) => `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${v} Safari/537.36`;
+var MAC_UA_TEMPLATE = (v) => `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${v} Safari/537.36`;
+var RESOLUTIONS = [
+  { screen: { width: 1920, height: 1080 }, viewport: { width: 1920, height: 1040 } },
+  { screen: { width: 1536, height: 864 }, viewport: { width: 1536, height: 824 } },
+  { screen: { width: 1440, height: 900 }, viewport: { width: 1440, height: 860 } },
+  { screen: { width: 1366, height: 768 }, viewport: { width: 1366, height: 728 } },
+  { screen: { width: 1280, height: 800 }, viewport: { width: 1280, height: 760 } }
+];
+var GPU_PROFILES = [
+  { vendor: "Google Inc. (NVIDIA)", renderer: "ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0, D3D11)" },
+  { vendor: "Google Inc. (Intel)", renderer: "ANGLE (Intel, Intel(R) UHD Graphics 620 Direct3D11 vs_5_0 ps_5_0, D3D11)" },
+  { vendor: "Google Inc. (AMD)", renderer: "ANGLE (AMD, AMD Radeon RX 6600 Direct3D11 vs_5_0 ps_5_0, D3D11)" },
+  { vendor: "Apple Inc.", renderer: "Apple M1" },
+  { vendor: "Apple Inc.", renderer: "Apple M2" }
+];
+var TIMEZONES = ["Asia/Jakarta", "Asia/Singapore", "America/New_York", "Europe/London", "Asia/Tokyo"];
+var LOCALES = ["en-US", "en-GB", "id-ID"];
+function pick(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function generateFingerprint(overrides = {}) {
+  const isMac = Math.random() < 0.3;
+  const chromeVersion = pick(CHROME_VERSIONS);
+  const chromeMajorVersion = chromeVersion.split(".")[0];
+  const gpu = pick(GPU_PROFILES.filter((g) => isMac ? g.vendor === "Apple Inc." : g.vendor !== "Apple Inc."));
+  const resolution = pick(RESOLUTIONS);
+  const profile = {
+    userAgent: isMac ? MAC_UA_TEMPLATE(chromeVersion) : WINDOWS_UA_TEMPLATE(chromeVersion),
+    chromeVersion,
+    chromeMajorVersion,
+    platform: isMac ? "MacIntel" : "Win32",
+    viewport: { ...resolution.viewport, deviceScaleFactor: pick([1, 1.25, 1.5]) },
+    screen: resolution.screen,
+    hardwareConcurrency: pick([4, 8, 12, 16]),
+    deviceMemory: pick([4, 8, 16]),
+    timezone: pick(TIMEZONES),
+    locale: pick(LOCALES),
+    webglVendor: gpu.vendor,
+    webglRenderer: gpu.renderer,
+    languages: ["en-US", "en"],
+    ...overrides
+  };
+  return profile;
+}
+
+// src/fingerprint/index.ts
+async function applyFingerprint(page, profile) {
+  await page.setUserAgent(profile.userAgent);
+  await page.setViewport(profile.viewport);
+  const client = await page.target().createCDPSession();
+  await client.send("Emulation.setTimezoneOverride", { timezoneId: profile.timezone });
+  await client.send("Emulation.setLocaleOverride", { locale: profile.locale });
+  await client.send("Network.setUserAgentOverride", {
+    userAgent: profile.userAgent,
+    acceptLanguage: profile.languages.join(","),
+    platform: profile.platform,
+    userAgentMetadata: {
+      brands: [
+        { brand: "Not/A)Brand", version: "99" },
+        { brand: "Google Chrome", version: profile.chromeMajorVersion },
+        { brand: "Chromium", version: profile.chromeMajorVersion }
+      ],
+      fullVersionList: [
+        { brand: "Not/A)Brand", version: "99.0.0.0" },
+        { brand: "Google Chrome", version: profile.chromeVersion },
+        { brand: "Chromium", version: profile.chromeVersion }
+      ],
+      fullVersion: profile.chromeVersion,
+      platform: profile.platform === "MacIntel" ? "macOS" : "Windows",
+      platformVersion: profile.platform === "MacIntel" ? "13.0.0" : "10.0.0",
+      architecture: "x86",
+      model: "",
+      mobile: false
+    }
+  });
+  await page.setExtraHTTPHeaders({
+    "Accept-Language": `${profile.languages[0]};q=0.9,${profile.languages.slice(1).join(";q=0.8,")}`.replace(/;q=0\.8,$/, "")
+  });
+  await page.evaluateOnNewDocument((p) => {
+    Object.defineProperty(navigator, "platform", { get: () => p.platform });
+    Object.defineProperty(navigator, "hardwareConcurrency", { get: () => p.hardwareConcurrency });
+    Object.defineProperty(navigator, "deviceMemory", { get: () => p.deviceMemory });
+    Object.defineProperty(navigator, "languages", { get: () => p.languages });
+    Object.defineProperty(screen, "width", { get: () => p.screen.width });
+    Object.defineProperty(screen, "height", { get: () => p.screen.height });
+    Object.defineProperty(screen, "availWidth", { get: () => p.screen.width });
+    Object.defineProperty(screen, "availHeight", { get: () => p.screen.height - 40 });
+    Object.defineProperty(window, "outerWidth", { get: () => p.screen.width });
+    Object.defineProperty(window, "outerHeight", { get: () => p.screen.height });
+    Object.defineProperty(window, "devicePixelRatio", { get: () => p.viewport.deviceScaleFactor });
+    const patchGetParameter = (proto) => {
+      const original = proto.getParameter;
+      proto.getParameter = function(parameter) {
+        const UNMASKED_VENDOR_WEBGL = 37445;
+        const UNMASKED_RENDERER_WEBGL = 37446;
+        if (parameter === UNMASKED_VENDOR_WEBGL) return p.webglVendor;
+        if (parameter === UNMASKED_RENDERER_WEBGL) return p.webglRenderer;
+        return original.call(this, parameter);
+      };
+    };
+    patchGetParameter(WebGLRenderingContext.prototype);
+    if (typeof WebGL2RenderingContext !== "undefined") {
+      patchGetParameter(WebGL2RenderingContext.prototype);
+    }
+    const toDataURLProto = HTMLCanvasElement.prototype.toDataURL;
+    HTMLCanvasElement.prototype.toDataURL = function(...args) {
+      const ctx = this.getContext("2d");
+      if (ctx) {
+        const imageData = ctx.getImageData(0, 0, this.width, this.height);
+        for (let i = 0; i < imageData.data.length; i += 4) {
+          imageData.data[i] = imageData.data[i] ^ 1;
+        }
+        ctx.putImageData(imageData, 0, 0);
+      }
+      return toDataURLProto.apply(this, args);
+    };
+    const origCreateAnalyser = AudioContext.prototype.createAnalyser;
+    AudioContext.prototype.createAnalyser = function() {
+      const analyser = origCreateAnalyser.call(this);
+      const origGetFloatFrequencyData = analyser.getFloatFrequencyData.bind(analyser);
+      analyser.getFloatFrequencyData = ((array) => {
+        origGetFloatFrequencyData(array);
+        const typedArray = array;
+        for (let i = 0; i < typedArray.length; i++) typedArray[i] += Math.random() * 1e-4;
+      });
+      return analyser;
+    };
+    const nav = navigator;
+    if (nav.getBattery) {
+      nav.getBattery = () => Promise.resolve({
+        charging: true,
+        chargingTime: 0,
+        dischargingTime: Infinity,
+        level: 1,
+        addEventListener: () => {
+        },
+        removeEventListener: () => {
+        }
+      });
+    }
+    const navConn = navigator;
+    if (navConn.connection) {
+      Object.defineProperty(navConn, "connection", {
+        get: () => ({
+          effectiveType: "4g",
+          rtt: 50,
+          downlink: 10,
+          saveData: false,
+          addEventListener: () => {
+          },
+          removeEventListener: () => {
+          }
+        })
+      });
+    }
+  }, profile);
+}
+
+// src/cursor/ghostCursor.ts
+function bezierPath(start, end, steps) {
+  const c1 = {
+    x: start.x + (end.x - start.x) * (0.3 + Math.random() * 0.2) + (Math.random() - 0.5) * 100,
+    y: start.y + (end.y - start.y) * (0.1 + Math.random() * 0.3) + (Math.random() - 0.5) * 100
+  };
+  const c2 = {
+    x: start.x + (end.x - start.x) * (0.6 + Math.random() * 0.2) + (Math.random() - 0.5) * 100,
+    y: start.y + (end.y - start.y) * (0.7 + Math.random() * 0.2) + (Math.random() - 0.5) * 100
+  };
+  const points = [];
+  for (let i = 0; i <= steps; i++) {
+    const t = i / steps;
+    const x = Math.pow(1 - t, 3) * start.x + 3 * Math.pow(1 - t, 2) * t * c1.x + 3 * (1 - t) * Math.pow(t, 2) * c2.x + Math.pow(t, 3) * end.x;
+    const y = Math.pow(1 - t, 3) * start.y + 3 * Math.pow(1 - t, 2) * t * c1.y + 3 * (1 - t) * Math.pow(t, 2) * c2.y + Math.pow(t, 3) * end.y;
+    points.push({ x, y });
+  }
+  return points;
+}
+function easeInOutQuad(t) {
+  return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+}
+var lastPosition = { x: 100, y: 100 };
+async function moveMouseHuman(page, target) {
+  const steps = 20 + Math.floor(Math.random() * 15);
+  const path = bezierPath(lastPosition, target, steps);
+  for (let i = 0; i < path.length; i++) {
+    const eased = easeInOutQuad(i / path.length);
+    const idx = Math.min(path.length - 1, Math.floor(eased * path.length));
+    const p = path[idx];
+    await page.mouse.move(p.x, p.y);
+    await new Promise((r) => setTimeout(r, 3 + Math.random() * 10));
+  }
+  lastPosition = target;
+}
+async function ghostClick(page, selector) {
+  const handle = await page.waitForSelector(selector, { timeout: 15e3 });
+  if (!handle) throw new Error(`real-browser-plus: element not found for selector "${selector}"`);
+  const box = await handle.boundingBox();
+  if (!box) throw new Error(`real-browser-plus: element "${selector}" has no bounding box (is it visible?)`);
+  const target = {
+    x: box.x + box.width * (0.3 + Math.random() * 0.4),
+    y: box.y + box.height * (0.3 + Math.random() * 0.4)
+  };
+  await moveMouseHuman(page, target);
+  await new Promise((r) => setTimeout(r, 50 + Math.random() * 150));
+  await page.mouse.down();
+  await new Promise((r) => setTimeout(r, 30 + Math.random() * 90));
+  await page.mouse.up();
+}
+
+// src/humanize/typing.ts
+var NEARBY_KEYS = {
+  a: ["s", "q", "z"],
+  s: ["a", "d", "w"],
+  e: ["w", "r", "d"],
+  i: ["u", "o", "k"],
+  o: ["i", "p", "l"],
+  n: ["b", "m", "h"]
+};
+function randomDelay(min, max) {
+  return min + Math.random() * (max - min);
+}
+async function humanType(page, selector, text) {
+  await ghostClick(page, selector);
+  await new Promise((r) => setTimeout(r, randomDelay(200, 600)));
+  for (const char of text) {
+    const lower = char.toLowerCase();
+    const nearby = NEARBY_KEYS[lower];
+    const shouldTypo = Math.random() < 0.04 && nearby;
+    if (shouldTypo) {
+      const wrongChar = nearby[Math.floor(Math.random() * nearby.length)];
+      await page.keyboard.type(wrongChar, { delay: randomDelay(60, 180) });
+      await new Promise((r) => setTimeout(r, randomDelay(150, 350)));
+      await page.keyboard.press("Backspace");
+      await new Promise((r) => setTimeout(r, randomDelay(80, 200)));
+    }
+    await page.keyboard.type(char, { delay: randomDelay(60, 180) });
+    if (Math.random() < 0.06) {
+      await new Promise((r) => setTimeout(r, randomDelay(300, 900)));
+    }
+  }
+}
+
+// src/humanize/scroll.ts
+async function humanScroll(page, distance) {
+  const direction = distance > 0 ? 1 : -1;
+  let remaining = Math.abs(distance);
+  while (remaining > 0) {
+    const step = Math.min(remaining, 60 + Math.random() * 120);
+    await page.mouse.wheel({ deltaY: direction * step });
+    remaining -= step;
+    const delay = Math.random() < 0.15 ? 400 + Math.random() * 800 : 30 + Math.random() * 90;
+    await new Promise((r) => setTimeout(r, delay));
+  }
+}
+
+// src/captcha/turnstile.ts
+var TURNSTILE_IFRAME_SELECTOR = 'iframe[src*="challenges.cloudflare.com"]';
+var TURNSTILE_TIMEOUT_MS = 2e4;
+async function solveTurnstile(page) {
+  let frameHandle;
+  try {
+    frameHandle = await page.waitForSelector(TURNSTILE_IFRAME_SELECTOR, { timeout: 4e3 });
+  } catch {
+    return false;
+  }
+  if (!frameHandle) return false;
+  const frame = await frameHandle.contentFrame();
+  if (!frame) return false;
+  const checkbox = await frame.waitForSelector('input[type="checkbox"], #challenge-stage', { timeout: TURNSTILE_TIMEOUT_MS }).catch(() => null);
+  if (!checkbox) return false;
+  const box = await checkbox.boundingBox();
+  if (!box) return false;
+  const frameElement = frameHandle.asElement();
+  const parentFrameBox = frameElement ? await frameElement.boundingBox() : null;
+  const offsetX = parentFrameBox?.x ?? 0;
+  const offsetY = parentFrameBox?.y ?? 0;
+  await moveMouseHuman(page, {
+    x: offsetX + box.x + box.width / 2,
+    y: offsetY + box.y + box.height / 2
+  });
+  await new Promise((r) => setTimeout(r, 150 + Math.random() * 250));
+  await page.mouse.down();
+  await new Promise((r) => setTimeout(r, 40 + Math.random() * 80));
+  await page.mouse.up();
+  await page.waitForSelector(TURNSTILE_IFRAME_SELECTOR, { hidden: true, timeout: TURNSTILE_TIMEOUT_MS }).catch(() => null);
+  return true;
+}
+function watchForTurnstile(page) {
+  page.on("framenavigated", async () => {
+    try {
+      await solveTurnstile(page);
+    } catch {
+    }
+  });
+}
+
+// src/proxy/index.ts
+function resolveProxy(proxy) {
+  if (!proxy) return void 0;
+  if (Array.isArray(proxy)) return proxy[Math.floor(Math.random() * proxy.length)];
+  return proxy;
+}
+function proxyLaunchArg(proxy) {
+  const server = proxy.server.startsWith("http") ? proxy.server : `http://${proxy.server}`;
+  return `--proxy-server=${server}`;
+}
+async function applyProxyAuth(page, proxy) {
+  if (!proxy.username || !proxy.password) return;
+  await page.authenticate({ username: proxy.username, password: proxy.password });
+}
+
+// src/webrtc/index.ts
+async function blockWebRTCLeak(page) {
+  await page.evaluateOnNewDocument(() => {
+    const OriginalRTCPeerConnection = window.RTCPeerConnection;
+    if (!OriginalRTCPeerConnection) return;
+    class PatchedRTCPeerConnection extends OriginalRTCPeerConnection {
+      constructor(config) {
+        const sanitizedConfig = { ...config, iceServers: [] };
+        super(sanitizedConfig);
+      }
+    }
+    Object.defineProperty(window, "RTCPeerConnection", {
+      value: PatchedRTCPeerConnection,
+      writable: false,
+      configurable: true
+    });
+    Object.defineProperty(window, "webkitRTCPeerConnection", {
+      value: PatchedRTCPeerConnection,
+      writable: false,
+      configurable: true
+    });
+  });
+}
+
+// src/session/index.ts
+async function saveSession(page) {
+  const cookies = await page.cookies();
+  const storageSnapshot = await page.evaluate(() => {
+    const local = {};
+    const session = {};
+    for (let i = 0; i < window.localStorage.length; i++) {
+      const key = window.localStorage.key(i);
+      if (key !== null) local[key] = window.localStorage.getItem(key) ?? "";
+    }
+    for (let i = 0; i < window.sessionStorage.length; i++) {
+      const key = window.sessionStorage.key(i);
+      if (key !== null) session[key] = window.sessionStorage.getItem(key) ?? "";
+    }
+    return { local, session, origin: window.location.origin };
+  });
+  return {
+    cookies,
+    localStorage: storageSnapshot.local,
+    sessionStorage: storageSnapshot.session,
+    origin: storageSnapshot.origin
+  };
+}
+async function restoreSession(page, session) {
+  if (session.cookies.length > 0) {
+    await page.setCookie(...session.cookies);
+  }
+  if (session.origin) {
+    await page.evaluateOnNewDocument(
+      (data) => {
+        for (const [key, value] of Object.entries(data.localStorage)) {
+          window.localStorage.setItem(key, value);
+        }
+        for (const [key, value] of Object.entries(data.sessionStorage)) {
+          window.sessionStorage.setItem(key, value);
+        }
+      },
+      { localStorage: session.localStorage, sessionStorage: session.sessionStorage }
+    );
+  }
+}
+
+// src/retry/index.ts
+async function withRetry(fn, options = {}) {
+  const { retries = 3, minDelayMs = 300, maxDelayMs = 3e3, onRetry } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === retries) break;
+      onRetry?.(attempt + 1, error);
+      const exponential = Math.min(maxDelayMs, minDelayMs * Math.pow(2, attempt));
+      const jitter = exponential * (0.5 + Math.random() * 0.5);
+      await new Promise((r) => setTimeout(r, jitter));
+    }
+  }
+  throw lastError;
+}
+
+// src/logger/index.ts
+var LEVEL_WEIGHT = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4
+};
+var Logger = class {
+  constructor(level = "warn") {
+    this.level = level;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  shouldLog(target) {
+    return LEVEL_WEIGHT[this.level] >= LEVEL_WEIGHT[target];
+  }
+  error(...args) {
+    if (this.shouldLog("error")) console.error("[real-browser-plus]", ...args);
+  }
+  warn(...args) {
+    if (this.shouldLog("warn")) console.warn("[real-browser-plus]", ...args);
+  }
+  info(...args) {
+    if (this.shouldLog("info")) console.info("[real-browser-plus]", ...args);
+  }
+  debug(...args) {
+    if (this.shouldLog("debug")) console.debug("[real-browser-plus]", ...args);
+  }
+};
+var logger = new Logger();
+
+// src/plugins/index.ts
+var PluginManager = class {
+  constructor() {
+    this.plugins = [];
+  }
+  register(plugin) {
+    this.plugins.push(plugin);
+  }
+  async runBrowserLaunched(browser) {
+    for (const plugin of this.plugins) {
+      await plugin.onBrowserLaunched?.(browser);
+    }
+  }
+  async runPageCreated(page) {
+    for (const plugin of this.plugins) {
+      await plugin.onPageCreated?.(page);
+    }
+  }
+  async runBeforeClose(browser) {
+    for (const plugin of this.plugins) {
+      await plugin.onBeforeClose?.(browser);
+    }
+  }
+};
+
+// src/index.ts
+puppeteerExtra.use(StealthPlugin());
+async function connect(options = {}) {
+  const {
+    headless = false,
+    args = [],
+    executablePath,
+    proxy,
+    turnstile = true,
+    fingerprint: fingerprintOverrides,
+    disableFingerprinting = false,
+    ghostCursor = true,
+    blockWebRTCLeak: shouldBlockWebRTC = true,
+    connectToExisting,
+    customConfig = {},
+    ignoreAllFlags = false,
+    plugins = [],
+    logLevel = "warn",
+    session
+  } = options;
+  logger.setLevel(logLevel);
+  const pluginManager = new PluginManager();
+  for (const plugin of plugins) pluginManager.register(plugin);
+  const chosenProxy = resolveProxy(proxy);
+  const launchArgs = ignoreAllFlags ? args : [...STEALTH_LAUNCH_ARGS, ...args, ...chosenProxy ? [proxyLaunchArg(chosenProxy)] : []];
+  let browser;
+  if (connectToExisting) {
+    browser = await puppeteerExtra.connect(connectToExisting);
+    logger.info("Attached to existing browser instance");
+  } else {
+    browser = await puppeteerExtra.launch({
+      headless,
+      args: launchArgs,
+      executablePath,
+      defaultViewport: null,
+      ignoreDefaultArgs: ["--enable-automation"],
+      ...customConfig
+    });
+    logger.info("Launched new browser instance", { headless, proxy: Boolean(chosenProxy) });
+  }
+  await pluginManager.runBrowserLaunched(browser);
+  const page = await browser.newPage();
+  if (chosenProxy) {
+    await applyProxyAuth(page, chosenProxy);
+    logger.debug("Proxy authentication applied");
+  }
+  if (!ignoreAllFlags) {
+    await applyAllStealth(page);
+  }
+  if (shouldBlockWebRTC && !ignoreAllFlags) {
+    await blockWebRTCLeak(page);
+  }
+  const fingerprint = generateFingerprint(fingerprintOverrides);
+  if (!disableFingerprinting && !ignoreAllFlags) {
+    await applyFingerprint(page, fingerprint);
+    logger.debug("Fingerprint applied", fingerprint);
+  }
+  if (session) {
+    await restoreSession(page, session);
+    logger.debug("Session restored", { origin: session.origin });
+  }
+  if (turnstile) {
+    watchForTurnstile(page);
+    solveTurnstile(page).catch((error) => logger.debug("Initial turnstile check skipped", error));
+  }
+  await pluginManager.runPageCreated(page);
+  const humanClick = async (targetPage, selector) => {
+    if (ghostCursor) {
+      await ghostClick(targetPage, selector);
+    } else {
+      await targetPage.click(selector);
+    }
+  };
+  const use = async (plugin) => {
+    pluginManager.register(plugin);
+    await plugin.onPageCreated?.(page);
+  };
+  browser.on("disconnected", () => {
+    logger.info("Browser disconnected");
+  });
+  const originalClose = browser.close.bind(browser);
+  browser.close = (async () => {
+    await pluginManager.runBeforeClose(browser);
+    return originalClose();
+  });
+  return {
+    browser,
+    page,
+    fingerprint,
+    humanClick,
+    humanType,
+    humanScroll,
+    solveTurnstile,
+    saveSession,
+    restoreSession,
+    withRetry,
+    use
+  };
+}
+var index_default = { connect };
+export {
+  Logger,
+  blockWebRTCLeak,
+  connect,
+  index_default as default,
+  generateFingerprint,
+  ghostClick,
+  humanScroll,
+  humanType,
+  logger,
+  moveMouseHuman,
+  restoreSession,
+  saveSession,
+  solveTurnstile,
+  withRetry
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "real-browser-plus",
+  "version": "1.1.0",
+  "description": "A modernized, more powerful successor to puppeteer-real-browser — stealth browser automation with fingerprint spoofing, ghost cursor, human-like typing, auto Turnstile handling, and proxy rotation.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+ "exports": {
+  ".": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.mjs",
+    "require": "./dist/index.js"
+  }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "node test/basic.test.js",
+    "prepublishOnly": "npm run typecheck && npm run build && npm test"
+  },
+  "keywords": [
+    "puppeteer",
+    "stealth",
+    "anti-detect",
+    "cloudflare-bypass",
+    "turnstile",
+    "fingerprint",
+    "ghost-cursor",
+    "browser-automation",
+    "scraping"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fidzzcodex-me/real-browser-plus.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fidzzcodex-me/real-browser-plus/issues"
+  },
+  "homepage": "https://github.com/fidzzcodex-me/real-browser-plus#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "puppeteer": "^23.9.0",
+    "puppeteer-extra": "^3.3.6",
+    "puppeteer-extra-plugin-stealth": "^2.11.2"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "tsup": "^8.3.5",
+    "@types/node": "^22.9.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}