webcrawl 1.4.2 → 1.4.4

package/dist/core/engine/chrome.js

@@ -0,0 +1,208 @@
+/**
+ * Local Chrome renderer (JS pages the native fetch ladder cannot hydrate).
+ *
+ * Primary driver is Chrome DevTools Protocol:
+ * launch headless Chrome, navigate, wait until the DOM is content-ready
+ * (load + 200ms mutation-idle), then read `documentElement.outerHTML`.
+ *
+ * dump-dom is a last-resort fallback: Chrome 156 hangs on dump-dom with a
+ * fresh profile, which used to look like a successful scrape of the
+ * unrendered nav shell. Every attempt has a hard timeout and a process-group
+ * kill. Playwright's chrome-headless-shell is discovered automatically when
+ * present.
+ */
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { renderUrlViaCdp } from "./chrome-cdp.js";
+import { DEFAULT_TIMEOUT_MS, DUMP_MAX_BYTES, chromeDumpDomArgs, discoverChromeBinaries, killProcessGroup, } from "./chrome-launch.js";
+export { DEFAULT_TIMEOUT_MS, VIRTUAL_TIME_MS, discoverChromeBinaries, findPlaywrightHeadlessShell, installedChromePath, isLocalChromeAvailable, parseDevToolsActivePort, chromeCdpArgs, chromeDumpDomArgs, killProcessGroup, } from "./chrome-launch.js";
+function attemptPlan(binary) {
+    const isShell = /headless[-_]?shell/i.test(binary);
+    if (isShell) {
+        return [
+            { driver: "cdp", headless: "shell" },
+            { driver: "dump-dom", headless: "shell" },
+        ];
+    }
+    return [
+        { driver: "cdp", headless: "new" },
+        { driver: "cdp", headless: "old" },
+        { driver: "dump-dom", headless: "old" },
+        { driver: "dump-dom", headless: "new" },
+    ];
+}
+function methodName(binary, kind) {
+    const base = binary.split(/[/\\]/).pop() || binary;
+    return `${kind.driver}/${kind.headless} (${base})`;
+}
+/**
+ * Render `url` in local Chrome and return the hydrated HTML, or null when
+ * Chrome is missing, times out, or produces nothing.
+ */
+export async function renderViaLocalChrome(url, opts = {}) {
+    const result = await renderViaLocalChromeDetailed(url, opts);
+    return result.html;
+}
+/**
+ * Same as `renderViaLocalChrome` but with the attempt log and an actionable
+ * error when every driver fails. Callers that need to report honest JS-render
+ * failures should use this.
+ */
+export async function renderViaLocalChromeDetailed(url, opts = {}) {
+    const binaries = discoverChromeBinaries();
+    if (binaries.length === 0) {
+        return {
+            html: null,
+            error: "No local Chrome/Chromium binary found. Install Chrome, set WEBCRAWL_CHROME_PATH, " +
+                "or run `npx playwright install chromium-headless-shell`. See `webcrawl doctor`.",
+            attempts: [],
+        };
+    }
+    const budgetMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const started = Date.now();
+    const attempts = [];
+    let lastError = "local Chrome produced no content";
+    for (const binary of binaries) {
+        for (const kind of attemptPlan(binary)) {
+            const remaining = budgetMs - (Date.now() - started);
+            if (remaining < 1_200)
+                break;
+            const method = methodName(binary, kind);
+            const attemptBudget = kind.driver === "cdp"
+                ? Math.min(remaining, kind.headless === "new" ? 12_000 : 8_000)
+                : Math.min(remaining, 6_000);
+            const t0 = Date.now();
+            try {
+                const html = kind.driver === "cdp"
+                    ? (await renderUrlViaCdp(binary, url, {
+                        timeoutMs: attemptBudget,
+                        headless: kind.headless,
+                    })).html
+                    : await dumpDom(binary, url, kind.headless, attemptBudget);
+                const ms = Date.now() - t0;
+                if (html && html.length > 100) {
+                    attempts.push({ ok: true, method, ms });
+                    return { html, method, attempts };
+                }
+                lastError = `${method} returned empty HTML`;
+                attempts.push({ ok: false, method, ms, error: lastError });
+            }
+            catch (err) {
+                const ms = Date.now() - t0;
+                lastError = `${method}: ${err instanceof Error ? err.message : String(err)}`;
+                attempts.push({ ok: false, method, ms, error: lastError });
+            }
+        }
+    }
+    return {
+        html: null,
+        error: `JavaScript rendering failed (${lastError}). ` +
+            "Chrome hung, timed out, or produced no content. Install Chrome, point WEBCRAWL_CHROME_PATH " +
+            "at chrome-headless-shell (`npx playwright install chromium-headless-shell`), " +
+            "run `webcrawl login` and retry with `--mode cloud`, or set WEBCRAWL_RENDER_URL.",
+        attempts,
+    };
+}
+async function dumpDom(chrome, url, headless, timeoutMs) {
+    let profile = "";
+    try {
+        profile = mkdtempSync(join(tmpdir(), "wc-chrome-"));
+    }
+    catch {
+        throw new Error("could not create Chrome profile directory");
+    }
+    const args = chromeDumpDomArgs({
+        profile,
+        headless,
+        url,
+        timeoutMs,
+        binaryPath: chrome,
+    });
+    try {
+        return await new Promise((resolve, reject) => {
+            let settled = false;
+            const done = (err, value) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (err)
+                    reject(err);
+                else
+                    resolve(value ?? "");
+            };
+            let child;
+            try {
+                child = spawn(chrome, args, {
+                    stdio: ["ignore", "pipe", "pipe"],
+                    detached: true,
+                });
+            }
+            catch (err) {
+                done(err instanceof Error ? err : new Error(String(err)));
+                return;
+            }
+            const chunks = [];
+            let bytes = 0;
+            let idle = null;
+            const finish = (err) => {
+                clearTimeout(timer);
+                if (idle)
+                    clearTimeout(idle);
+                killProcessGroup(child.pid, child);
+                if (err) {
+                    done(err);
+                    return;
+                }
+                const text = Buffer.concat(chunks).toString("utf8");
+                done(null, text.trim());
+            };
+            const timer = setTimeout(() => {
+                if (bytes > 100)
+                    finish(null);
+                else
+                    finish(new Error(`dump-dom timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            child.stdout?.on("data", (c) => {
+                if (bytes >= DUMP_MAX_BYTES)
+                    return;
+                const take = c.subarray(0, DUMP_MAX_BYTES - bytes);
+                chunks.push(take);
+                bytes += take.length;
+                // Chrome 156 often prints the DOM then never exits (`--dump-dom` hang).
+                if (idle)
+                    clearTimeout(idle);
+                idle = setTimeout(() => {
+                    if (bytes > 40)
+                        finish(null);
+                }, 400);
+            });
+            child.on("error", (err) => {
+                clearTimeout(timer);
+                if (idle)
+                    clearTimeout(idle);
+                done(err);
+            });
+            child.on("close", () => {
+                clearTimeout(timer);
+                if (idle)
+                    clearTimeout(idle);
+                if (bytes === 0) {
+                    done(new Error("dump-dom produced no stdout"));
+                    return;
+                }
+                const text = Buffer.concat(chunks).toString("utf8");
+                done(null, text.trim().length > 0 ? text : "");
+            });
+        });
+    }
+    finally {
+        try {
+            rmSync(profile, { recursive: true, force: true });
+        }
+        catch {
+            /* leftover profile is in /tmp */
+        }
+    }
+}

package/dist/core/engine/crawler.d.ts

@@ -66,8 +66,9 @@ export declare function checkUrlsStatusBatch(urls: string[], timeoutMs?: number)
     ok: boolean;
 }>>;
 /**
- * Extracts structured `{ app_name, product_features }` (or custom JSON schema) from a URL.
- * Replaces `firecrawl.asyncExtract` in `website-extract.ts`.
+ * Extracts structured JSON from a URL.
+ * Honours `prompt` / `schema` when provided; otherwise falls back to
+ * `{ app_name, product_features }` from title and headings.
  */
 export declare function extractWebsiteData(url: string, options?: {
     prompt?: string;
@@ -76,9 +77,9 @@ export declare function extractWebsiteData(url: string, options?: {
     bypassCache?: boolean;
     /** Already-extracted content (e.g. a parsed PDF); skips the HTML fetch and cache. */
     markdown?: string;
-}): Promise<{
-    app_name: string;
-    product_features: string[];
+    /** Source HTML when the caller already fetched the page (quote cards, JSON-LD). */
+    html?: string;
+}): Promise<Record<string, unknown> & {
     cached?: boolean;
     cacheLayer?: "memory" | "disk" | "postgres" | "miss";
 }>;

package/dist/core/engine/crawler.js

@@ -5,6 +5,7 @@ import { escalateToSandboxOrBrowser } from "../sandbox.js";
 import { getCachedMapAsync, getCachedPageAsync, setCachedMap, setCachedPage, sha256, } from "./cache.js";
 import { fetchWithTlsImpersonation, getBrowserHeaders, isAntiBotChallenge, } from "./fetcher.js";
 import { decodeHtmlEntities, extractLinksFromHtml, fastHtmlToMarkdown, } from "./markdown.js";
+import { extractByPromptAndSchema, hasCustomExtractRequest, } from "../extract/structured.js";
 export async function mapWebsiteUrls(targetUrl, options = {}) {
     const start = performance.now();
     const limit = Math.max(1, options.limit ?? 5000);
@@ -490,11 +491,13 @@ export async function checkUrlsStatusBatch(urls, timeoutMs = 8000) {
     }));
 }
 /**
- * Extracts structured `{ app_name, product_features }` (or custom JSON schema) from a URL.
- * Replaces `firecrawl.asyncExtract` in `website-extract.ts`.
+ * Extracts structured JSON from a URL.
+ * Honours `prompt` / `schema` when provided; otherwise falls back to
+ * `{ app_name, product_features }` from title and headings.
  */
 export async function extractWebsiteData(url, options = {}) {
-    if (!options.bypassCache && !options.markdown) {
+    const custom = hasCustomExtractRequest(options.prompt, options.schema);
+    if (!custom && !options.bypassCache && !options.markdown) {
         const cachedPage = await getCachedPageAsync(url, "all");
         if (cachedPage?.structuredData &&
             typeof cachedPage.structuredData.app_name === "string" &&
@@ -509,6 +512,7 @@ export async function extractWebsiteData(url, options = {}) {
     }
     let title = "";
     let markdown = "";
+    let html = options.html ?? "";
     let links = [];
     const existingPage = !options.bypassCache && !options.markdown
         ? await getCachedPageAsync(url, "all")
@@ -532,16 +536,25 @@ export async function extractWebsiteData(url, options = {}) {
             headers: { location: r.headers.get("location") ?? "" },
             text: () => r.text(),
         })));
-        const html = await res.text();
+        html = await res.text();
         const parsed = fastHtmlToMarkdown(html, url);
         title = parsed.title;
         markdown = parsed.markdown;
         links = parsed.links;
     }
+    const cacheMeta = () => ({
+        cached: Boolean(existingPage),
+        cacheLayer: existingPage?.cacheLayer || "miss",
+    });
     // If OPENAI_API_KEY is available, use gpt-4o-mini for structured JSON extraction
     const apiKey = options.openaiApiKey || process.env.OPENAI_API_KEY;
     if (apiKey) {
         try {
+            const schemaHint = options.schema
+                ? `Return a JSON object matching this JSON Schema:\n${JSON.stringify(options.schema)}`
+                : options.prompt
+                    ? `Return JSON that satisfies this request: ${options.prompt}`
+                    : 'Extract the application/website name and a list of key product features as JSON: {"app_name": string, "product_features": string[]}.';
             const llmRes = await fetch("https://api.openai.com/v1/chat/completions", {
                 method: "POST",
                 headers: {
@@ -554,11 +567,11 @@ export async function extractWebsiteData(url, options = {}) {
                     messages: [
                         {
                             role: "system",
-                            content: 'Extract the application/website name and a list of key product features as JSON: {"app_name": string, "product_features": string[]}.',
+                            content: schemaHint,
                         },
                         {
                             role: "user",
-                            content: `URL: ${url}\nTitle: ${title}\n\nContent:\n${markdown.slice(0, 12000)}`,
+                            content: `${options.prompt ? `${options.prompt}\n\n` : ""}URL: ${url}\nTitle: ${title}\n\nContent:\n${markdown.slice(0, 12000)}`,
                         },
                     ],
                     temperature: 0,
@@ -570,11 +583,16 @@ export async function extractWebsiteData(url, options = {}) {
                 const content = json.choices?.[0]?.message?.content;
                 if (content) {
                     const parsed = JSON.parse(content);
-                    if (parsed.app_name && Array.isArray(parsed.product_features)) {
-                        const structuredResult = {
-                            app_name: String(parsed.app_name),
-                            product_features: parsed.product_features.map(String),
-                        };
+                    const usable = custom
+                        ? parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                        : Boolean(parsed.app_name && Array.isArray(parsed.product_features));
+                    if (usable) {
+                        const structuredResult = custom
+                            ? parsed
+                            : {
+                                app_name: String(parsed.app_name),
+                                product_features: parsed.product_features.map(String),
+                            };
                         setCachedPage(url, "all", {
                             title,
                             markdown,
@@ -583,11 +601,7 @@ export async function extractWebsiteData(url, options = {}) {
                             statusCode: 200,
                             contentHash: sha256(markdown),
                         });
-                        return {
-                            ...structuredResult,
-                            cached: Boolean(existingPage),
-                            cacheLayer: existingPage?.cacheLayer || "miss",
-                        };
+                        return { ...structuredResult, ...cacheMeta() };
                     }
                 }
             }
@@ -596,6 +610,23 @@ export async function extractWebsiteData(url, options = {}) {
             // Fall through to deterministic heuristic extraction
         }
     }
+    if (custom) {
+        const shaped = extractByPromptAndSchema(html, markdown, options.prompt, options.schema);
+        if (shaped) {
+            setCachedPage(url, "all", {
+                title,
+                markdown,
+                links,
+                structuredData: shaped,
+                statusCode: 200,
+                contentHash: sha256(markdown),
+            });
+            return { ...shaped, ...cacheMeta() };
+        }
+        // Honour the caller's schema/prompt: never substitute the generic
+        // `{ app_name, product_features }` object when they asked for something else.
+        return { ...cacheMeta() };
+    }
     // Deterministic fast extraction from Title, Meta Description, and H2/H3/List headings (<5ms)
     const cleanAppName = title.split(/\s+[-|\u2014–:]\s+/)[0]?.trim() ||
         new URL(url).hostname.replace(/^www\./, "").split(".")[0];
@@ -640,8 +671,7 @@ export async function extractWebsiteData(url, options = {}) {
     });
     return {
         ...structuredResult,
-        cached: Boolean(existingPage),
-        cacheLayer: existingPage?.cacheLayer || "miss",
+        ...cacheMeta(),
     };
 }
 /**
@@ -694,6 +724,9 @@ export async function crawlWebsitePages(targetUrl, options = {}) {
 }
 /** True for markdown converted from a bot-check page (old cache entries). */
 export function isChallengeMarkdown(title, markdown) {
+    if (/blocked by network security/i.test(`${title}\n${markdown}`)) {
+        return true;
+    }
     const t = `${title}\n${markdown.slice(0, 600)}`.toLowerCase();
     return (t.includes("vercel security checkpoint") ||
         t.includes("we're verifying your browser") ||

package/dist/core/engine/fetcher.js

@@ -95,7 +95,13 @@ export function isAntiBotChallenge(html, status) {
     if (status === 403 || status === 429 || status === 503) {
         return true;
     }
-    const lower = html.slice(0, 6000).toLowerCase();
+    const raw = String(html ?? "");
+    // Reddit (and similar) hide this copy after tens of KB of CSS + a data-URI PNG.
+    if (/blocked by network security/i.test(raw)) {
+        return true;
+    }
+    // Head slice catches title/meta markers on ordinary challenge interstitials.
+    const lower = raw.slice(0, 8000).toLowerCase();
     if (lower.includes("cf-browser-verification") ||
         lower.includes("challenge-platform") ||
         lower.includes("just a moment...") ||
@@ -457,18 +463,31 @@ export function needsBrowserEscalation(status, html, markdown) {
     if (isAntiBotChallenge(html, status)) {
         return true;
     }
-    const lower = html.slice(0, 6000).toLowerCase();
+    const text = markdown.trim();
+    const lower = html.slice(0, 8000).toLowerCase();
+    // Empty or near-empty body: nothing to return until a renderer hydrates it.
+    if (text.length === 0) {
+        return true;
+    }
     // Empty SPA shell check (<div id="root"></div> or <div id="app"></div> with almost no text)
-    if (markdown.length < 120 &&
+    if (text.length < 200 &&
         (lower.includes('id="root"') ||
             lower.includes('id="app"') ||
-            lower.includes('id="__next"'))) {
+            lower.includes('id="__next"') ||
+            lower.includes('id="__nuxt"'))) {
+        return true;
+    }
+    // Header-only JS pages (quotes.toscrape.com/js): real content lives in a
+    // <script> as JSON + document.write / innerHTML, so markdown is just the chrome.
+    if (text.length < 200 &&
+        /<script[\s>]/i.test(html) &&
+        /document\.write|innerHTML\s*=/i.test(html)) {
         return true;
     }
     // Big-HTML/no-content SPA shell: a very large page (JS bundles / inline
     // state, e.g. StubHub category pages ~3MB) that yields almost no
     // extractable text is serving its real content client-side.
-    if (html.length > 250_000 && markdown.length < 500) {
+    if (html.length > 250_000 && text.length < 500) {
         return true;
     }
     return false;

package/dist/core/engine/index.d.ts

@@ -3,4 +3,5 @@ export * from "./markdown.js";
 export * from "./session.js";
 export * from "./fetcher.js";
 export * from "./render.js";
+export * from "./chrome.js";
 export * from "./crawler.js";

package/dist/core/engine/index.js

@@ -3,4 +3,5 @@ export * from "./markdown.js";
 export * from "./session.js";
 export * from "./fetcher.js";
 export * from "./render.js";
+export * from "./chrome.js";
 export * from "./crawler.js";

package/dist/core/extract/index.d.ts

@@ -6,3 +6,4 @@ export { dedupeHotelListings, extractHotelListingFromSerpResult, extractHotelLis
 export { dedupeBusinessListings, extractBusinessListingFromSerpResult, extractBusinessListingsFromHtml, type BusinessListing, } from "./business.js";
 export { cvss3BaseScore, cveSeverityLabel, extractCveIdsFromText, extractGhsaIdsFromText, looksLikeVulnId, mergeCveRecords, normalizeCveId, nvdUrl, parseNvdCve, parseNvdResponse, parseOsvVuln, severityFromScore, sortCveRecords, type CveAffected, type CveRecord, type CveSeverity, } from "./cve.js";
 export { extractBusinessListingsWithScaleDown, extractFlightOffersWithScaleDown, extractHotelListingsWithScaleDown, extractPropertyListingsWithScaleDown, } from "./scaledown.js";
+export { coerceExtractSchema, extractByPromptAndSchema, extractQuoteAuthorPairs, hasCustomExtractRequest, isEmptyExtractResult, isJsTemplateJunk, nestedQuoteAuthorFields, normalizeExtractSchema, shapeQuoteAuthors, stripNonContentHtml, wantsQuoteAuthorExtract, type QuoteAuthor, } from "./structured.js";

package/dist/core/extract/index.js

@@ -6,3 +6,4 @@ export { dedupeHotelListings, extractHotelListingFromSerpResult, extractHotelLis
 export { dedupeBusinessListings, extractBusinessListingFromSerpResult, extractBusinessListingsFromHtml, } from "./business.js";
 export { cvss3BaseScore, cveSeverityLabel, extractCveIdsFromText, extractGhsaIdsFromText, looksLikeVulnId, mergeCveRecords, normalizeCveId, nvdUrl, parseNvdCve, parseNvdResponse, parseOsvVuln, severityFromScore, sortCveRecords, } from "./cve.js";
 export { extractBusinessListingsWithScaleDown, extractFlightOffersWithScaleDown, extractHotelListingsWithScaleDown, extractPropertyListingsWithScaleDown, } from "./scaledown.js";
+export { coerceExtractSchema, extractByPromptAndSchema, extractQuoteAuthorPairs, hasCustomExtractRequest, isEmptyExtractResult, isJsTemplateJunk, nestedQuoteAuthorFields, normalizeExtractSchema, shapeQuoteAuthors, stripNonContentHtml, wantsQuoteAuthorExtract, } from "./structured.js";

package/dist/core/extract/structured.d.ts

@@ -0,0 +1,33 @@
+export interface QuoteAuthor {
+    text: string;
+    author: string;
+}
+/** A bare property map or shorthand array becomes a JSON Schema. */
+export declare function coerceExtractSchema(node: unknown): Record<string, unknown>;
+/**
+ * Root-array wrap: a top-level array becomes
+ * `{ type: object, properties: { items: <array> } }`.
+ */
+export declare function normalizeExtractSchema(schema?: Record<string, unknown>): Record<string, unknown> | undefined;
+export declare function schemaProperties(schema?: Record<string, unknown>): Record<string, unknown>;
+export declare function hasCustomExtractRequest(prompt?: string, schema?: Record<string, unknown>): boolean;
+/** Nested object/array field names that look like quote+author records. */
+export declare function nestedQuoteAuthorFields(schema?: Record<string, unknown>): {
+    arrayPath: string[];
+    textKey: string;
+    authorKey: string;
+} | null;
+export declare function wantsQuoteAuthorExtract(prompt?: string, schema?: Record<string, unknown>): boolean;
+/** Strip script/style/template (including unclosed tags) before reading visible DOM. */
+export declare function stripNonContentHtml(html: string): string;
+/** Inline `document.write("... " + d['text'] + ...)` leftovers, not real quotes. */
+export declare function isJsTemplateJunk(text: string): boolean;
+export declare function isEmptyExtractResult(data: Record<string, unknown> | null | undefined): boolean;
+/** Pull quote/author pairs from HTML (cards, microdata, `var data = [...]`) and markdown. */
+export declare function extractQuoteAuthorPairs(html: string, markdown?: string): QuoteAuthor[];
+export declare function shapeQuoteAuthors(pairs: QuoteAuthor[], schema?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Deterministic extract when the caller passed a prompt and/or JSON schema.
+ * Returns null when this page/request has nothing this extractor can fill.
+ */
+export declare function extractByPromptAndSchema(html: string, markdown: string, prompt?: string, schema?: Record<string, unknown>): Record<string, unknown> | null;