# In your project directory (or globally with -g)
npm install playwright@1.60.0 camoufox-js
 
# First run auto-fetches the camoufox Firefox binary into node_modules

# Idempotent — safe to re-run. Patches both occurrences (browser context + page).
python3 - <<'PY'
import re, pathlib
p = pathlib.Path("node_modules/playwright-core/lib/coreBundle.js")
src = p.read_text()
old = """            location: {
              url: pageError.location.url,
              line: pageError.location.lineNumber,
              column: pageError.location.columnNumber
            }"""
new = """            location: pageError.location ? {
              url: pageError.location.url,
              line: pageError.location.lineNumber,
              column: pageError.location.columnNumber
            } : { url: "", line: 0, column: 0 }"""
n = src.count(old)
if n != 2:
    raise SystemExit(f"expected 2 occurrences, found {n} — playwright version may have changed")
p.write_text(src.replace(old, new))
print(f"patched {n} occurrences OK")
PY

grep -c "pageError.location ?" node_modules/playwright-core/lib/coreBundle.js   # must print 2

# Use --break-system-packages on Debian/Ubuntu, or a venv
python3 -m pip install "camoufox[geoip]" playwright==1.60.0
 
# Fetch the camoufox browser binary (~700 MB) + uBlock Origin addon
python3 -m camoufox fetch

echo "DISPLAY=$DISPLAY"
xdpyinfo -display "${DISPLAY:-:0}" 2>&1 | head -3
# Expect: "name of display: :0" + a vendor string
# If "xdpyinfo: unable to open display" → no X server, install xvfb or use headless.

// CommonJS
const { Camoufox } = require('camoufox-js');
(async () => {
  const browser = await Camoufox({
    headless: false,     // false for visible window
    humanize: true,      // human-like mouse movement
    geoip: true,         // match timezone/locale to exit IP
    locale: 'id-ID',     // match target site
    os: 'linux',         // pin to keep fingerprint stable across runs
  });
  const page = await browser.newPage();   // Firefox Browser exposes newPage directly
  await page.goto('https://example.com', { waitUntil: 'domcontentloaded', timeout: 30000 });
  console.log(await page.title());
  await browser.close();
})();

const browser = await Camoufox({ headless: false, humanize: true, geoip: true });
const page = await browser.newPage();
await page.goto('https://example.com', { waitUntil: 'domcontentloaded', timeout: 30000 });
// Keep window open until user closes it
await new Promise(r => browser.on('disconnected', r));

# Headless server: provide a virtual display
xvfb-run node your_script.js

import asyncio
from camoufox import AsyncCamoufox
async def browse(url: str):
    async with AsyncCamoufox(
        headless=True,             # set False for a visible window
        humanize=True,             # human-like mouse movement
        geoip=True,                # match timezone/locale to exit IP
    ) as browser:
        page = await browser.new_page()
        await page.goto(url, wait_until="domcontentloaded", timeout=30000)
        return await page.title()
print(asyncio.run(browse("https://example.com")))

import asyncio
from camoufox import AsyncCamoufox
async def browse_headed(url: str):
    async with AsyncCamoufox(
        headless=False,            # visible window
        humanize=True,
        geoip=True,
    ) as browser:
        page = await browser.new_page()
        await page.goto(url, wait_until="domcontentloaded", timeout=30000)
        input("Press Enter to close…")   # keep the window open
asyncio.run(browse_headed("https://example.com"))

# Headless server: provide a virtual display
xvfb-run python your_script.py

// Node
const content = await page.content();           // raw HTML
const text    = await page.innerText('body');   // visible text
const title   = await page.title();
await page.screenshot({ path: '/tmp/shot.png', fullPage: true });

# Python
content = await page.content()
text    = await page.inner_text("body")
title   = await page.title()
await page.screenshot(path="/tmp/shot.png", full_page=True)

// Node
await page.fill('input[name="email"]', 'user@example.com');
await page.fill('input[name="password"]', '...');
await page.click('button[type="submit"]');
await page.waitForLoadState('networkidle');

# Python
await page.fill('input[name="email"]', "user@example.com")
await page.fill('input[name="password"]', "...")
await page.click('button[type="submit"]')
await page.wait_for_load_state("networkidle")

fields = {
    'input[name="first"]': "Ada",
    'input[name="last"]':  "Lovelace",
    'input[name="email"]': "ada@example.com",
}
for selector, value in fields.items():
    await page.fill(selector, value)
await page.click('button[type="submit"]')
await page.wait_for_load_state("networkidle")

async def navigate_and_read(page, url):
    await page.goto(url, wait_until="domcontentloaded", timeout=30000)
    await page.wait_for_load_state("networkidle")
    return await page.inner_text("body")

async def scroll_to_bottom(page, steps=10, pause=0.5):
    for _ in range(steps):
        await page.mouse.wheel(0, 2000)
        await page.wait_for_timeout(int(pause * 1000))
    return await page.content()   # now includes lazy-loaded items

selectors = ["#accept", "button.load-more", "a.next"]
for sel in selectors:
    el = await page.query_selector(sel)
    if el:
        await el.click()
        await page.wait_for_load_state("networkidle")

// Node — camoufox-js returns a Browser; use its default context, not browser.contexts()[0]
const fs = require('fs');
const browser = await Camoufox({ headless: false });
const context = browser.contexts()[0];           // or `await browser.newContext()` for a fresh one
const page = await context.newPage();
// ... do stuff ...
const state = await context.storageState();
fs.writeFileSync('/path/to/state.json', JSON.stringify(state));
await browser.close();

# Python
async with AsyncCamoufox(headless=True) as browser:
    context = await browser.new_context(storage_state="/path/to/state.json")
    # ...
    state = await context.storage_state()  # save for next run

// Node
const browser = await Camoufox({
  headless: true,
  proxy: { server: 'http://resi.example.com:8000', username: 'u', password: '***' },
});

# Python
async with AsyncCamoufox(
    headless=True,
    proxy={"server": "http://resi.example.com:8000", "username": "u", "password": "***"},
) as browser:
    ...

// Node — minimum-viable wrapper. Apply the Playwright patch FIRST.
const { Camoufox } = require('camoufox-js');
// Belt + suspenders: the patch above stops the dispatcher crash, but
// page-level `pageerror` events still fire on every bad page. Suppress them
// so they don't show up as console noise during the run.
process.on('uncaughtException', e => {
  if (String(e?.message).includes("undefined (reading 'url')")) {
    // dispatcher crash — already handled by the patch, this is a leftover
    return;
  }
  console.error('UNCAUGHT', e);
});
(async () => {
  const browser = await Camoufox({ headless: false, humanize: true, geoip: true });
  browser.on('pageerror', () => {});  // silence page-error events
  const page = await browser.newPage();
  page.setDefaultNavigationTimeout(60000);
  page.setDefaultTimeout(25000);
  for (const [slug, url] of STEPS) {
    try {
      await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 60000 });
      await page.waitForTimeout(3000);                       // let JS render
      await page.screenshot({ path: `${slug}.png` });
      // ... extract data ...
    } catch (e) {
      console.error('  ✗', slug, e.message.split('\n')[0]);
      // continue to next URL — do not throw
    }
  }
  await browser.close();
})();