@apmantza/greedysearch-pi 1.8.9 → 1.9.0

package/extractors/bing-copilot.mjs

@@ -10,6 +10,7 @@
 // Errors go to stderr only — stdout is always clean JSON for piping.
 
 import {
+	buildEnvelope,
 	cdp,
 	formatAnswer,
 	getOrOpenTab,
@@ -36,22 +37,39 @@ const GLOBAL_VAR = "__bingClipboard";
 // Bing Copilot-specific helpers
 // ============================================================================
 
-async function extractAnswer(tab) {
+async function extractAnswer(tab, env) {
+	// In headless mode: snap the accessibility tree before spending ~18s on
+	// clipboard polls. Copilot loads its input fine in headless but renders
+	// responses behind a Cloudflare-protected iframe — detecting that here
+	// fast-fails to the visible retry instead of burning all the poll time.
+	if (process.env.GREEDY_SEARCH_HEADLESS === "1") {
+		const snap = await cdp(["snap", tab]).catch(() => "");
+		if (/cloudflare|challenge|security check/i.test(snap)) {
+			console.error("[bing] Cloudflare challenge in snap — fast-failing to visible retry");
+			env.blockedBy = "cloudflare";
+			throw new Error("Cloudflare challenge detected — headless blocked");
+		}
+	}
+
 	// Wait for the assistant copy button to exist. On fresh Copilot
 	// sessions the answer text can render before the button handler is
 	// fully hydrated.  Wait for the button + a small hydration delay.
-	await waitForCopyButton(tab, S.copyButton, { timeout: 5000 }).catch(
+	// 2s is enough — the CF snap check above ensures we only reach here
+	// on a clean response, where the button appears within ~1s.
+	await waitForCopyButton(tab, S.copyButton, { timeout: 2000 }).catch(
 		() => null,
 	);
 	// Give React time to hydrate the click handler on the button
 	await new Promise((r) => setTimeout(r, 800));
 
 	let answer = await clickCopyAndPollClipboard(tab, 5000);
+	let clipboardEmpty = !answer;
 
 	// Retry once if clipboard is empty (Copilot might be slow to wire the handler)
 	if (!answer) {
 		console.error("[bing] Clipboard empty, retrying copy/poll...");
 		answer = await clickCopyAndPollClipboard(tab, 8000);
+		clipboardEmpty = !answer;
 	}
 
 	// DOM fallback: visible Copilot can render a valid response while the copy
@@ -59,17 +77,21 @@ async function extractAnswer(tab) {
 	// answer from page text before treating this as a headless/iframe block.
 	if (!answer) {
 		answer = await extractFromVisibleDom(tab);
+		if (answer) env.fallbackUsed = "visibleDom";
 	}
 
 	// DOM fallback: if clipboard still empty, extract text directly from response DOM.
 	// This handles headless mode where Copilot renders the AI reply inside nested
 	// iframes (copilot.microsoft.com → copilot.fun → blob:…) and hides the copy button.
 	if (!answer) {
-		answer = await extractFromIframes(tab);
+		const iframeResult = await extractFromIframes(tab, env);
+		answer = iframeResult.answer;
+		if (answer) env.fallbackUsed = "iframeDom";
 	}
 
 	if (!answer) throw new Error("Clipboard interceptor returned empty text");
 
+	env.clipboardEmpty = clipboardEmpty;
 	const sources = parseSourcesFromMarkdown(answer);
 	return { answer: answer.trim(), sources };
 }
@@ -136,7 +158,7 @@ async function extractFromVisibleDom(tab) {
  * Returns the extracted text or empty string on failure (caller falls through to error
  * which triggers the visible Chrome auto-retry in search.mjs).
  */
-async function extractFromIframes(mainTab) {
+async function extractFromIframes(mainTab, env) {
 	try {
 		// Check if the AI copy button exists — if it does, we're in visible mode
 		// and clipboard should have worked. This is a different issue.
@@ -145,7 +167,7 @@ async function extractFromIframes(mainTab) {
 			mainTab,
 			`!!document.querySelector('${S.copyButton}')`,
 		]).catch(() => "false");
-		if (hasCopyBtn === "true") return ""; // not a headless/iframe issue
+		if (hasCopyBtn === "true") return { answer: "" }; // not a headless/iframe issue
 
 		// Check for Cloudflare challenge in the accessibility tree.
 		// If present, Copilot content is blocked entirely — no DOM extraction possible.
@@ -154,7 +176,8 @@ async function extractFromIframes(mainTab) {
 			console.error(
 				"[bing] Cloudflare challenge detected — content blocked in headless",
 			);
-			return ""; // Let caller throw → triggers visible auto-retry
+			env.blockedBy = "cloudflare";
+			return { answer: "" }; // Let caller throw → triggers visible auto-retry
 		}
 
 		console.error(
@@ -175,7 +198,7 @@ async function extractFromIframes(mainTab) {
 		);
 		if (!funFrame) {
 			console.error("[bing] No copilot.fun iframe target found");
-			return "";
+			return { answer: "" };
 		}
 
 		// Try to extract from the nested blob iframe (rarely succeeds due to Cloudflare)
@@ -190,7 +213,7 @@ async function extractFromIframes(mainTab) {
 			console.error(
 				`[bing] DOM extraction succeeded (${innerText.length} chars)`,
 			);
-			return innerText;
+			return { answer: innerText };
 		}
 
 		console.error(
@@ -199,7 +222,7 @@ async function extractFromIframes(mainTab) {
 	} catch (e) {
 		console.error(`[bing] DOM extraction failed: ${e.message}`);
 	}
-	return "";
+	return { answer: "" };
 }
 
 // ============================================================================
@@ -214,6 +237,20 @@ async function main() {
 	validateQuery(args, USAGE);
 
 	const { query, tabPrefix, short } = parseArgs(args);
+	const startTime = Date.now();
+	const mode =
+		process.env.GREEDY_SEARCH_VISIBLE === "1" ? "visible" : "headless";
+
+	// Lightweight envelope — no extra CDP calls, just tracks what we already know
+	const env = {
+		engine: "bing",
+		mode,
+		clipboardEmpty: null,
+		fallbackUsed: null,
+		blockedBy: null,
+		verificationResult: null,
+		inputReady: null,
+	};
 
 	try {
 		// Only refresh page list when creating a fresh tab (no prefix provided)
@@ -240,6 +277,7 @@ async function main() {
 
 		// Handle verification challenges (Cloudflare Turnstile, Microsoft auth, etc.)
 		const verifyResult = await handleVerification(tab, cdp, 10000);
+		env.verificationResult = verifyResult;
 		if (verifyResult === "needs-human") {
 			throw new Error(
 				"Copilot verification required — please solve it manually in the browser window",
@@ -272,6 +310,7 @@ async function main() {
 
 		// Wait for React app to mount input (up to 15s, longer after verification)
 		const inputReady = await waitForSelector(tab, S.input, 15000, 500);
+		env.inputReady = inputReady;
 		await new Promise((r) => setTimeout(r, jitter(300)));
 
 		if (!inputReady) {
@@ -293,24 +332,42 @@ async function main() {
 			`document.querySelector('${S.input}')?.dispatchEvent(new KeyboardEvent('keydown',{key:'Enter',bubbles:true,keyCode:13})), 'ok'`,
 		]);
 
+		// Post-submit: Bing's antibot sometimes appears AFTER the query is sent.
+		// Fire-and-forget verification check — runs in parallel with stream wait.
+		// Zero added latency to the critical path; if it finds and clicks the
+		// challenge, the stream unblocks instead of timing out at 60s.
+		setTimeout(() => {
+			handleVerification(tab, cdp, 10000)
+				.then((v) => {
+					if (v === "clicked") {
+						console.error("[bing] Post-submit verification clicked");
+						env.verificationResult = "post-submit-clicked";
+					}
+				})
+				.catch(() => {});
+		}, 2000);
+
 		// Wait for Bing Copilot's response to finish streaming before extracting.
 		await waitForStreamComplete(tab, { timeout: 60000, minLength: 50 });
 
-		const { answer, sources } = await extractAnswer(tab);
+		const { answer, sources } = await extractAnswer(tab, env);
 		if (!answer)
 			throw new Error("No answer extracted — Copilot may not have responded");
 
 		const finalUrl = await cdp(["eval", tab, "document.location.href"]).catch(
 			() => "",
 		);
+		env.durationMs = Date.now() - startTime;
 		outputJson({
 			query,
 			url: finalUrl,
 			answer: formatAnswer(answer, short),
 			sources,
+			_envelope: buildEnvelope(env),
 		});
 	} catch (e) {
-		handleError(e);
+		env.durationMs = Date.now() - startTime;
+		handleError(e, buildEnvelope(env));
 	}
 }
 

package/extractors/common.mjs

@@ -552,10 +552,45 @@ export function outputJson(data) {
 }
 
 /**
- * Handle and output error, then exit
+ * Build a lightweight result envelope from data already collected during extraction.
+ * Zero additional CDP calls — everything here is already known.
+ * @param {object} fields
+ * @returns {object}
+ */
+export function buildEnvelope({
+	engine,
+	mode = "headless",
+	clipboardEmpty = null,
+	fallbackUsed = null,
+	blockedBy = null,
+	verificationResult = null,
+	inputReady = null,
+	durationMs = null,
+} = {}) {
+	return {
+		engine,
+		mode,
+		clipboardEmpty,
+		fallbackUsed,
+		blockedBy,
+		verificationResult,
+		inputReady,
+		durationMs,
+	};
+}
+
+/**
+ * Handle and output error, then exit.
+ * If an envelope is provided, writes it to stdout as JSON so the runner
+ * can parse structured diagnostics even on failure.
  * @param {Error} error - Error to handle
+ * @param {object} [envelope] - Optional envelope object
  */
-export function handleError(error) {
+export function handleError(error, envelope = null) {
+	if (envelope) {
+		const out = JSON.stringify({ _envelope: envelope, error: error.message });
+		process.stdout.write(`${out}\n`);
+	}
 	process.stderr.write(`Error: ${error.message}\n`);
 	process.exit(1);
 }