@apmantza/greedysearch-pi 1.8.2 → 1.8.3

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## v1.8.3 (2026-04-24)
+
+### Fixes
+- **Perplexity extraction fixed** — The copy button selector was returning the first matching button ("Copy question") instead of the answer copy button. Changed `.find()` to `.filter().pop()` to get the last matching button, which correctly copies the answer text. Fixes `--full` flag returning only the query text instead of the full answer.
+
+### Features
+- **Reddit JSON API support** — Reddit post URLs now use Reddit's public `.json` API instead of HTML scraping. Gets structured post data + top comments with nesting. Falls back to HTTP fetch if API fails.
+
 ## v1.8.2 (2026-04-20)
 
 ### Cross-Platform Testing

package/README.md

@@ -57,11 +57,20 @@ node ~/.pi/agent/git/GreedySearch-pi/bin/launch.mjs --kill
 - Chrome
 - Node.js 20.11.0+ (22+ recommended)
 
+## Source fetching
+
+When using `depth: "standard"` or `depth: "deep"`, source content is fetched and synthesized:
+
+- **Reddit** — Uses Reddit's public `.json` API for posts and comments (no scraping)
+- **GitHub** — Uses GitHub REST API for repos, READMEs, and file trees
+- **General web** — Mozilla Readability extraction with browser fallback for bot-blocked pages
+- **Metadata** — title, author/byline, site name, publish date, language, excerpt
+
 ## Project layout
 
 - `bin/` - runtime CLIs (`search.mjs`, `launch.mjs`, `cdp.mjs`, `coding-task.mjs`)
 - `extractors/` - engine-specific automation
-- `src/` - ranking/fetching/formatting internals
+- `src/` - ranking/fetching/formatting internals (includes `reddit.mjs`, `github.mjs`, `fetcher.mjs`)
 - `skills/` - Pi skill metadata
 
 ## Testing

package/extractors/perplexity.mjs

@@ -36,7 +36,9 @@ const GLOBAL_VAR = "__pplxClipboard";
 function findCopyButtonJsExpression() {
 	// Perplexity uses SVG icons via <use xlink:href="#pplx-icon-copy">
 	// This works across all locales since it doesn't depend on aria-label text
-	return `Array.from(document.querySelectorAll('button')).find(b => b.innerHTML.includes('#pplx-icon-copy'))`;
+	// Use .pop() to get the last matching button (the answer copy button),
+	// not the first one which is the question copy button
+	return `Array.from(document.querySelectorAll('button')).filter(b => b.innerHTML.includes('#pplx-icon-copy')).pop()`;
 }
 
 // ============================================================================

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@apmantza/greedysearch-pi",
-	"version": "1.8.2",
+	"version": "1.8.3",
 	"description": "Pi extension: multi-engine AI search (Perplexity, Bing Copilot, Google AI) via browser automation -- NO API KEYS needed. Extracts answers with sources, optional Gemini synthesis. Grounded AI answers from real browser interactions.",
 	"type": "module",
 	"keywords": [

package/src/reddit.mjs

@@ -0,0 +1,210 @@
+// src/reddit.mjs - Reddit content fetching via public JSON API
+// Reddit exposes structured data by appending .json to any URL
+
+const REDDIT_HEADERS = {
+	"user-agent": "GreedySearch/1.0 (Research Bot)",
+	accept: "application/json",
+};
+
+/**
+ * Parse a Reddit URL to check if it's a post, comment, or user profile
+ * @param {string} url
+ * @returns {{type: 'post'|'user'|'other', cleanUrl: string} | null}
+ */
+export function parseRedditUrl(url) {
+	try {
+		const parsed = new URL(url);
+		const hostname = parsed.hostname.toLowerCase();
+
+		// Support reddit.com, old.reddit.com, www.reddit.com
+		if (!hostname.endsWith("reddit.com")) {
+			return null;
+		}
+
+		const pathname = parsed.pathname;
+
+		// User profile: /u/username or /user/username
+		if (pathname.match(/^\/(u|user)\/[^/]+\/?$/i)) {
+			return { type: "user", cleanUrl: normalizeRedditUrl(url) };
+		}
+
+		// Post: /r/subreddit/comments/xxxx/...
+		if (pathname.match(/^\/r\/[^/]+\/comments\/[^/]+/i)) {
+			return { type: "post", cleanUrl: normalizeRedditUrl(url) };
+		}
+
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Normalize Reddit URL (remove query params, fragments)
+ * @param {string} url
+ * @returns {string}
+ */
+function normalizeRedditUrl(url) {
+	try {
+		const parsed = new URL(url);
+		// Reconstruct without query/fragment
+		return `${parsed.protocol}//${parsed.hostname}${parsed.pathname}`;
+	} catch {
+		return url;
+	}
+}
+
+/**
+ * Fetch Reddit content via the .json API
+ * @param {string} url - Reddit URL (will have .json appended)
+ * @param {number} maxChars - Max characters for content
+ * @returns {Promise<FetchResult>}
+ */
+export async function fetchRedditContent(url, maxChars = 8000) {
+	const start = Date.now();
+
+	try {
+		// Append .json to get API response
+		const jsonUrl = url.replace(/\/?$/, ".json");
+
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 15000);
+
+		const response = await fetch(jsonUrl, {
+			headers: REDDIT_HEADERS,
+			signal: controller.signal,
+		});
+
+		clearTimeout(timeoutId);
+
+		if (!response.ok) {
+			throw new Error(`Reddit API ${response.status}`);
+		}
+
+		const data = await response.json();
+
+		// data[0] = post listing, data[1] = comments listing
+		if (!Array.isArray(data) || data.length < 1) {
+			throw new Error("Invalid Reddit API response structure");
+		}
+
+		const postListing = data[0];
+		const commentsListing = data[1];
+
+		// Extract post data
+		const post = postListing?.data?.children?.[0]?.data;
+		if (!post) {
+			throw new Error("No post data in Reddit response");
+		}
+
+		// Format as markdown
+		const markdown = formatRedditPost(post, commentsListing, maxChars);
+
+		return {
+			ok: true,
+			url,
+			finalUrl: url,
+			status: 200,
+			contentType: "text/markdown",
+			lastModified: "",
+			title: post.title || "Reddit Post",
+			byline: `u/${post.author}`,
+			siteName: `r/${post.subreddit}`,
+			lang: "en",
+			publishedTime: new Date(post.created_utc * 1000).toISOString(),
+			excerpt: post.selftext?.slice(0, 300).replace(/\n/g, " ") || "",
+			markdown,
+			contentLength: markdown.length,
+			needsBrowser: false,
+			duration: Date.now() - start,
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			url,
+			finalUrl: url,
+			status: 0,
+			error: `Reddit fetch failed: ${error.message}`,
+			needsBrowser: false,
+			duration: Date.now() - start,
+		};
+	}
+}
+
+/**
+ * Format Reddit post and comments as clean markdown
+ * @param {object} post - Reddit post data
+ * @param {object|null} commentsListing - Comments listing data
+ * @param {number} maxChars - Max characters
+ * @returns {string}
+ */
+function formatRedditPost(post, commentsListing, maxChars) {
+	let md = "";
+
+	// Post header
+	md += `# ${post.title}\n\n`;
+	md += `**Subreddit:** r/${post.subreddit} | **Author:** u/${post.author} | **Score:** ${post.score}\n\n`;
+
+	// Post body (selftext) or link
+	if (post.selftext) {
+		md += post.selftext;
+		md += "\n\n";
+	} else if (post.url && !post.url.includes("reddit.com")) {
+		// External link post
+		md += `**Link:** ${post.url}\n\n`;
+	}
+
+	// Comments section
+	if (commentsListing?.data?.children?.length > 0) {
+		md += "---\n\n## Comments\n\n";
+		const comments = commentsListing.data.children
+			.filter((c) => c.kind === "t1") // t1 = comment
+			.slice(0, 10); // Top 10 comments
+
+		for (const comment of comments) {
+			md += formatComment(comment.data, 0);
+			md += "\n";
+		}
+	}
+
+	// Trim to maxChars while keeping structure
+	if (md.length > maxChars) {
+		md = md.slice(0, maxChars).trim() + "\n\n... (truncated)";
+	}
+
+	return md;
+}
+
+/**
+ * Format a single comment with nesting
+ * @param {object} comment - Reddit comment data
+ * @param {number} depth - Nesting depth
+ * @returns {string}
+ */
+function formatComment(comment, depth) {
+	if (
+		!comment ||
+		comment.body === "[deleted]" ||
+		comment.body === "[removed]"
+	) {
+		return "";
+	}
+
+	const indent = "> ".repeat(depth);
+	let md = "";
+
+	md += `${indent}**u/${comment.author}** (${comment.score} pts)\n`;
+	md += `${indent}${comment.body.replace(/\n/g, "\n" + indent)}\n`;
+
+	// Handle nested replies (limit depth to 3)
+	if (depth < 3 && comment.replies?.data?.children) {
+		const replies = comment.replies.data.children.filter(
+			(r) => r.kind === "t1",
+		);
+		for (const reply of replies.slice(0, 5)) {
+			md += "\n" + formatComment(reply.data, depth + 1);
+		}
+	}
+
+	return md;
+}

package/src/search/fetch-source.mjs

@@ -1,230 +1,262 @@
-// src/search/fetch-source.mjs — HTTP and browser-based source content fetching
-//
-// Extracted from search.mjs. Uses fetchSourceHttp from src/fetcher.mjs
-// with browser fallback via CDP, plus GitHub content fetching.
-
-import { spawn } from "node:child_process";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { fetchSourceHttp, shouldUseBrowser } from "../fetcher.mjs";
-import { fetchGitHubContent, parseGitHubUrl } from "../github.mjs";
-import { trimContentHeadTail } from "../utils/content.mjs";
-import { cdp } from "./chrome.mjs";
-import { openNewTab, closeTab, closeTabs } from "./chrome.mjs";
-import { SOURCE_FETCH_CONCURRENCY } from "./constants.mjs";
-import { trimText } from "./sources.mjs";
-
-export async function fetchSourceContent(url, maxChars = 8000) {
-	const start = Date.now();
-
-	// Check if it's a GitHub URL
-	if (parseGitHubUrl(url)) {
-		const parsed = parseGitHubUrl(url);
-		if (
-			parsed &&
-			(parsed.type === "root" ||
-				parsed.type === "tree" ||
-				(parsed.type === "blob" && !parsed.path?.includes(".")))
-		) {
-			const ghResult = await fetchGitHubContent(url);
-			if (ghResult.ok) {
-				const content = trimContentHeadTail(ghResult.content, maxChars);
-				return {
-					url,
-					finalUrl: url,
-					status: 200,
-					contentType: "text/markdown",
-					lastModified: "",
-					title: ghResult.title,
-					snippet: content.slice(0, 320),
-					content,
-					contentChars: content.length,
-					source: "github-api",
-					...(ghResult.tree && { tree: ghResult.tree }),
-					duration: Date.now() - start,
-				};
-			}
-			process.stderr.write(
-				`[greedysearch] GitHub API fetch failed, trying HTTP: ${ghResult.error}\n`,
-			);
-		}
-	}
-
-	// Try HTTP first
-	const httpResult = await fetchSourceHttp(url, { timeoutMs: 15000 });
-
-	if (httpResult.ok) {
-		const content = trimContentHeadTail(httpResult.markdown, maxChars);
-		return {
-			url,
-			finalUrl: httpResult.finalUrl,
-			status: httpResult.status,
-			contentType: "text/markdown",
-			lastModified: httpResult.lastModified || "",
-			publishedTime: httpResult.publishedTime || "",
-			byline: httpResult.byline || "",
-			siteName: httpResult.siteName || "",
-			lang: httpResult.lang || "",
-			title: httpResult.title,
-			snippet: httpResult.excerpt,
-			content,
-			contentChars: content.length,
-			source: "http",
-			duration: Date.now() - start,
-		};
-	}
-
-	// HTTP failed — fall back to browser
-	process.stderr.write(
-		`[greedysearch] HTTP failed for ${url.slice(0, 60)}, trying browser...\n`,
-	);
-	return await fetchSourceContentBrowser(url, maxChars);
-}
-
-async function fetchSourceContentBrowser(url, maxChars = 8000) {
-	const start = Date.now();
-	const tab = await openNewTab();
-
-	try {
-		await cdp(["nav", tab, url], 30000);
-		await new Promise((r) => setTimeout(r, 1500));
-
-		const content = await cdp([
-			"eval",
-			tab,
-			`
-			(function(){
-				var el = document.querySelector('article, [role="main"], main, .post-content, .article-body, #content, .content');
-				var text = (el || document.body).innerText;
-				return JSON.stringify({
-					title: document.title,
-					content: text.replace(/\\s+/g, ' ').trim(),
-					url: location.href
-				});
-			})()
-		`,
-		]);
-
-		const parsed = JSON.parse(content);
-		const finalContent = trimContentHeadTail(parsed.content, maxChars);
-
-		return {
-			url,
-			finalUrl: parsed.url || url,
-			status: 200,
-			contentType: "text/plain",
-			lastModified: "",
-			title: parsed.title,
-			snippet: trimText(finalContent, 320),
-			content: finalContent,
-			contentChars: finalContent.length,
-			source: "browser",
-			duration: Date.now() - start,
-		};
-	} catch (error) {
-		return {
-			url,
-			title: "",
-			content: null,
-			snippet: "",
-			contentChars: 0,
-			error: error.message,
-			source: "browser",
-			duration: Date.now() - start,
-		};
-	} finally {
-		await closeTab(tab);
-	}
-}
-
-export async function fetchMultipleSources(
-	sources,
-	maxSources = 5,
-	maxChars = 8000,
-	concurrency = SOURCE_FETCH_CONCURRENCY,
-) {
-	const toFetch = sources.slice(0, maxSources);
-	if (toFetch.length === 0) return [];
-
-	const workerCount = Math.min(
-		toFetch.length,
-		Math.max(1, parseInt(String(concurrency), 10) || SOURCE_FETCH_CONCURRENCY),
-	);
-
-	process.stderr.write(
-		`[greedysearch] Fetching content from ${toFetch.length} sources via HTTP (concurrency ${workerCount})...\n`,
-	);
-
-	const fetched = new Array(toFetch.length);
-	let nextIndex = 0;
-	let completed = 0;
-
-	async function worker() {
-		while (true) {
-			const index = nextIndex++;
-			if (index >= toFetch.length) return;
-
-			const s = toFetch[index];
-			const url = s.canonicalUrl || s.url;
-			process.stderr.write(
-				`[greedysearch] [${index + 1}/${toFetch.length}] Fetching: ${url.slice(0, 60)}...\n`,
-			);
-
-			const result = await fetchSourceContent(url, maxChars);
-			fetched[index] = {
-				id: s.id,
-				...result,
-			};
-
-			if (result.content && result.content.length > 100) {
-				process.stderr.write(
-					`[greedysearch] ✓ ${result.source}: ${result.content.length} chars\n`,
-				);
-			} else if (result.error) {
-				process.stderr.write(`[greedysearch] ✗ ${result.error.slice(0, 80)}\n`);
-			}
-
-			completed += 1;
-			process.stderr.write(`PROGRESS:fetch:${completed}/${toFetch.length}\n`);
-		}
-	}
-
-	await Promise.all(Array.from({ length: workerCount }, () => worker()));
-
-	// Log summary
-	const successful = fetched.filter((f) => f.content && f.content.length > 100);
-	const httpCount = fetched.filter((f) => f.source === "http").length;
-	const browserCount = fetched.filter((f) => f.source === "browser").length;
-
-	process.stderr.write(
-		`[greedysearch] Fetched ${successful.length}/${fetched.length} sources ` +
-			`(HTTP: ${httpCount}, Browser: ${browserCount})\n`,
-	);
-
-	return fetched;
-}
-
-export async function fetchTopSource(url) {
-	const tab = await openNewTab();
-	await cdp(["list"]); // refresh cache
-	try {
-		await cdp(["nav", tab, url], 30000);
-		await new Promise((r) => setTimeout(r, 1500));
-		const content = await cdp([
-			"eval",
-			tab,
-			`
-      (function(){
-        var el = document.querySelector('article, [role="main"], main, .post-content, .article-body, #content, .content');
-        var text = (el || document.body).innerText;
-        return text.replace(/\\s+/g, ' ').trim();
-      })()
-    `,
-		]);
-		return { url, content };
-	} catch (e) {
-		return { url, content: null, error: e.message };
-	} finally {
-		await closeTab(tab);
-	}
-}
+// src/search/fetch-source.mjs — HTTP and browser-based source content fetching
+//
+// Extracted from search.mjs. Uses fetchSourceHttp from src/fetcher.mjs
+// with browser fallback via CDP, plus GitHub content fetching.
+
+import { spawn } from "node:child_process";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fetchSourceHttp, shouldUseBrowser } from "../fetcher.mjs";
+import { fetchGitHubContent, parseGitHubUrl } from "../github.mjs";
+import { fetchRedditContent, parseRedditUrl } from "../reddit.mjs";
+import { trimContentHeadTail } from "../utils/content.mjs";
+import { cdp, closeTab, closeTabs, openNewTab } from "./chrome.mjs";
+import { SOURCE_FETCH_CONCURRENCY } from "./constants.mjs";
+import { trimText } from "./sources.mjs";
+
+export async function fetchSourceContent(url, maxChars = 8000) {
+	const start = Date.now();
+
+	// Check if it's a GitHub URL
+	if (parseGitHubUrl(url)) {
+		const parsed = parseGitHubUrl(url);
+		if (
+			parsed &&
+			(parsed.type === "root" ||
+				parsed.type === "tree" ||
+				(parsed.type === "blob" && !parsed.path?.includes(".")))
+		) {
+			const ghResult = await fetchGitHubContent(url);
+			if (ghResult.ok) {
+				const content = trimContentHeadTail(ghResult.content, maxChars);
+				return {
+					url,
+					finalUrl: url,
+					status: 200,
+					contentType: "text/markdown",
+					lastModified: "",
+					title: ghResult.title,
+					snippet: content.slice(0, 320),
+					content,
+					contentChars: content.length,
+					source: "github-api",
+					...(ghResult.tree && { tree: ghResult.tree }),
+					duration: Date.now() - start,
+				};
+			}
+			process.stderr.write(
+				`[greedysearch] GitHub API fetch failed, trying HTTP: ${ghResult.error}\n`,
+			);
+		}
+	}
+
+	// Check if it's a Reddit URL (posts and comments)
+	const redditInfo = parseRedditUrl(url);
+	if (redditInfo?.type === "post") {
+		process.stderr.write(
+			`[greedysearch] Using Reddit JSON API for: ${url.slice(0, 60)}...\n`,
+		);
+		const redditResult = await fetchRedditContent(url, maxChars);
+		if (redditResult.ok) {
+			const content = trimContentHeadTail(redditResult.markdown, maxChars);
+			return {
+				url,
+				finalUrl: redditResult.finalUrl,
+				status: redditResult.status,
+				contentType: "text/markdown",
+				lastModified: redditResult.lastModified || "",
+				publishedTime: redditResult.publishedTime || "",
+				byline: redditResult.byline || "",
+				siteName: redditResult.siteName || "",
+				lang: redditResult.lang || "",
+				title: redditResult.title,
+				snippet: redditResult.excerpt,
+				content,
+				contentChars: content.length,
+				source: "reddit-api",
+				duration: Date.now() - start,
+			};
+		}
+		process.stderr.write(
+			`[greedysearch] Reddit API fetch failed, falling back to HTTP: ${redditResult.error}\n`,
+		);
+	}
+
+	// Try HTTP first
+	const httpResult = await fetchSourceHttp(url, { timeoutMs: 15000 });
+
+	if (httpResult.ok) {
+		const content = trimContentHeadTail(httpResult.markdown, maxChars);
+		return {
+			url,
+			finalUrl: httpResult.finalUrl,
+			status: httpResult.status,
+			contentType: "text/markdown",
+			lastModified: httpResult.lastModified || "",
+			publishedTime: httpResult.publishedTime || "",
+			byline: httpResult.byline || "",
+			siteName: httpResult.siteName || "",
+			lang: httpResult.lang || "",
+			title: httpResult.title,
+			snippet: httpResult.excerpt,
+			content,
+			contentChars: content.length,
+			source: "http",
+			duration: Date.now() - start,
+		};
+	}
+
+	// HTTP failed — fall back to browser
+	process.stderr.write(
+		`[greedysearch] HTTP failed for ${url.slice(0, 60)}, trying browser...\n`,
+	);
+	return await fetchSourceContentBrowser(url, maxChars);
+}
+
+async function fetchSourceContentBrowser(url, maxChars = 8000) {
+	const start = Date.now();
+	const tab = await openNewTab();
+
+	try {
+		await cdp(["nav", tab, url], 30000);
+		await new Promise((r) => setTimeout(r, 1500));
+
+		const content = await cdp([
+			"eval",
+			tab,
+			`
+			(function(){
+				var el = document.querySelector('article, [role="main"], main, .post-content, .article-body, #content, .content');
+				var text = (el || document.body).innerText;
+				return JSON.stringify({
+					title: document.title,
+					content: text.replace(/\\s+/g, ' ').trim(),
+					url: location.href
+				});
+			})()
+		`,
+		]);
+
+		const parsed = JSON.parse(content);
+		const finalContent = trimContentHeadTail(parsed.content, maxChars);
+
+		return {
+			url,
+			finalUrl: parsed.url || url,
+			status: 200,
+			contentType: "text/plain",
+			lastModified: "",
+			title: parsed.title,
+			snippet: trimText(finalContent, 320),
+			content: finalContent,
+			contentChars: finalContent.length,
+			source: "browser",
+			duration: Date.now() - start,
+		};
+	} catch (error) {
+		return {
+			url,
+			title: "",
+			content: null,
+			snippet: "",
+			contentChars: 0,
+			error: error.message,
+			source: "browser",
+			duration: Date.now() - start,
+		};
+	} finally {
+		await closeTab(tab);
+	}
+}
+
+export async function fetchMultipleSources(
+	sources,
+	maxSources = 5,
+	maxChars = 8000,
+	concurrency = SOURCE_FETCH_CONCURRENCY,
+) {
+	const toFetch = sources.slice(0, maxSources);
+	if (toFetch.length === 0) return [];
+
+	const workerCount = Math.min(
+		toFetch.length,
+		Math.max(1, parseInt(String(concurrency), 10) || SOURCE_FETCH_CONCURRENCY),
+	);
+
+	process.stderr.write(
+		`[greedysearch] Fetching content from ${toFetch.length} sources via HTTP (concurrency ${workerCount})...\n`,
+	);
+
+	const fetched = new Array(toFetch.length);
+	let nextIndex = 0;
+	let completed = 0;
+
+	async function worker() {
+		while (true) {
+			const index = nextIndex++;
+			if (index >= toFetch.length) return;
+
+			const s = toFetch[index];
+			const url = s.canonicalUrl || s.url;
+			process.stderr.write(
+				`[greedysearch] [${index + 1}/${toFetch.length}] Fetching: ${url.slice(0, 60)}...\n`,
+			);
+
+			const result = await fetchSourceContent(url, maxChars);
+			fetched[index] = {
+				id: s.id,
+				...result,
+			};
+
+			if (result.content && result.content.length > 100) {
+				process.stderr.write(
+					`[greedysearch] ✓ ${result.source}: ${result.content.length} chars\n`,
+				);
+			} else if (result.error) {
+				process.stderr.write(`[greedysearch] ✗ ${result.error.slice(0, 80)}\n`);
+			}
+
+			completed += 1;
+			process.stderr.write(`PROGRESS:fetch:${completed}/${toFetch.length}\n`);
+		}
+	}
+
+	await Promise.all(Array.from({ length: workerCount }, () => worker()));
+
+	// Log summary
+	const successful = fetched.filter((f) => f.content && f.content.length > 100);
+	const httpCount = fetched.filter((f) => f.source === "http").length;
+	const browserCount = fetched.filter((f) => f.source === "browser").length;
+
+	process.stderr.write(
+		`[greedysearch] Fetched ${successful.length}/${fetched.length} sources ` +
+			`(HTTP: ${httpCount}, Browser: ${browserCount})\n`,
+	);
+
+	return fetched;
+}
+
+export async function fetchTopSource(url) {
+	const tab = await openNewTab();
+	await cdp(["list"]); // refresh cache
+	try {
+		await cdp(["nav", tab, url], 30000);
+		await new Promise((r) => setTimeout(r, 1500));
+		const content = await cdp([
+			"eval",
+			tab,
+			`
+      (function(){
+        var el = document.querySelector('article, [role="main"], main, .post-content, .article-body, #content, .content');
+        var text = (el || document.body).innerText;
+        return text.replace(/\\s+/g, ' ').trim();
+      })()
+    `,
+		]);
+		return { url, content };
+	} catch (e) {
+		return { url, content: null, error: e.message };
+	} finally {
+		await closeTab(tab);
+	}
+}