@oh-my-pi/pi-coding-agent 3.30.0 → 3.31.0

package/src/core/tools/web-scrapers/firefox-addons.ts

@@ -0,0 +1,214 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, formatCount, htmlToBasicMarkdown, loadPage } from "./types";
+
+type LocalizedText = string | Record<string, string | null | undefined> | null | undefined;
+
+type AddonFile = {
+	permissions?: string[];
+	host_permissions?: string[];
+	optional_permissions?: string[];
+	optional_host_permissions?: string[];
+};
+
+type AddonLicense = {
+	name?: LocalizedText;
+	slug?: string;
+	url?: string;
+};
+
+type AddonVersion = {
+	version?: string;
+	license?: AddonLicense;
+	file?: AddonFile;
+};
+
+type AddonHomepage = {
+	url?: LocalizedText;
+	outgoing?: LocalizedText;
+};
+
+type AddonData = {
+	name?: LocalizedText;
+	summary?: LocalizedText;
+	description?: LocalizedText;
+	default_locale?: string;
+	authors?: Array<{ name?: string | null }>;
+	average_daily_users?: number;
+	weekly_downloads?: number;
+	ratings?: { average?: number; count?: number };
+	current_version?: AddonVersion;
+	categories?: string[] | Record<string, string[]>;
+	homepage?: AddonHomepage;
+	url?: string;
+};
+
+function getLocalizedText(value: LocalizedText, defaultLocale?: string): string | undefined {
+	if (!value) return undefined;
+	if (typeof value === "string") return value;
+
+	const localized = value as Record<string, string | null | undefined>;
+	if (defaultLocale && localized[defaultLocale]) return localized[defaultLocale] ?? undefined;
+	if (localized["en-US"]) return localized["en-US"] ?? undefined;
+
+	for (const entry of Object.values(localized)) {
+		if (entry) return entry;
+	}
+
+	return undefined;
+}
+
+function normalizeCategories(categories?: string[] | Record<string, string[]>): string[] {
+	if (!categories) return [];
+	if (Array.isArray(categories)) return categories.filter(Boolean);
+
+	const values: string[] = [];
+	for (const list of Object.values(categories)) {
+		if (Array.isArray(list)) {
+			for (const item of list) {
+				if (item) values.push(item);
+			}
+		}
+	}
+
+	const seen = new Set<string>();
+	return values.filter((item) => {
+		if (seen.has(item)) return false;
+		seen.add(item);
+		return true;
+	});
+}
+
+function collectPermissions(file?: AddonFile): string[] {
+	if (!file) return [];
+	const permissions: string[] = [];
+	const seen = new Set<string>();
+
+	const add = (items?: string[]) => {
+		for (const item of items ?? []) {
+			if (!item || seen.has(item)) continue;
+			seen.add(item);
+			permissions.push(item);
+		}
+	};
+
+	add(file.permissions);
+	add(file.host_permissions);
+	add(file.optional_permissions);
+	add(file.optional_host_permissions);
+
+	return permissions;
+}
+
+export const handleFirefoxAddons: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "addons.mozilla.org") return null;
+
+		const segments = parsed.pathname.split("/").filter(Boolean);
+		const addonIndex = segments.indexOf("addon");
+		if (addonIndex === -1) return null;
+
+		const slug = segments[addonIndex + 1] ? decodeURIComponent(segments[addonIndex + 1]) : "";
+		if (!slug) return null;
+
+		const apiUrl = `https://addons.mozilla.org/api/v5/addons/addon/${encodeURIComponent(slug)}/`;
+		const result = await loadPage(apiUrl, { timeout, headers: { Accept: "application/json" }, signal });
+		if (!result.ok) return null;
+
+		let data: AddonData;
+		try {
+			data = JSON.parse(result.content) as AddonData;
+		} catch {
+			return null;
+		}
+
+		const fetchedAt = new Date().toISOString();
+		const defaultLocale = data.default_locale || "en-US";
+
+		const name = getLocalizedText(data.name, defaultLocale) ?? slug;
+		const summary = getLocalizedText(data.summary, defaultLocale);
+		const descriptionRaw = getLocalizedText(data.description, defaultLocale);
+		const description = descriptionRaw ? htmlToBasicMarkdown(descriptionRaw) : undefined;
+
+		const authors = (data.authors ?? [])
+			.map((author) => author.name ?? "")
+			.map((author) => author.trim())
+			.filter(Boolean);
+
+		const ratingAverage = data.ratings?.average;
+		const ratingCount = data.ratings?.count;
+		const users = data.average_daily_users ?? data.weekly_downloads;
+		const version = data.current_version?.version;
+		const categories = normalizeCategories(data.categories);
+
+		const licenseName =
+			getLocalizedText(data.current_version?.license?.name, defaultLocale) ?? data.current_version?.license?.slug;
+		const licenseUrl = data.current_version?.license?.url;
+
+		const homepage =
+			getLocalizedText(data.homepage?.url, defaultLocale) ??
+			getLocalizedText(data.homepage?.outgoing, defaultLocale);
+
+		const permissions = collectPermissions(data.current_version?.file);
+
+		let md = `# ${name}\n\n`;
+		if (summary) md += `${summary}\n\n`;
+
+		if (authors.length > 0) {
+			md += `**Author${authors.length > 1 ? "s" : ""}:** ${authors.join(", ")}\n`;
+		}
+
+		if (ratingAverage !== undefined) {
+			md += `**Rating:** ${ratingAverage.toFixed(2)}`;
+			if (ratingCount !== undefined) md += ` (${formatCount(ratingCount)} reviews)`;
+			md += "\n";
+		}
+
+		if (users !== undefined) md += `**Users:** ${formatCount(users)}\n`;
+		if (version) md += `**Version:** ${version}\n`;
+		if (categories.length > 0) md += `**Categories:** ${categories.join(", ")}\n`;
+
+		if (licenseName && licenseUrl) {
+			md += `**License:** [${licenseName}](${licenseUrl})\n`;
+		} else if (licenseName) {
+			md += `**License:** ${licenseName}\n`;
+		} else if (licenseUrl) {
+			md += `**License:** ${licenseUrl}\n`;
+		}
+
+		if (homepage) md += `**Homepage:** ${homepage}\n`;
+
+		if (description) {
+			md += `\n## Description\n\n${description}\n`;
+		}
+
+		if (permissions.length > 0) {
+			const preview = permissions.slice(0, 40);
+			md += `\n## Permissions (${permissions.length})\n\n`;
+			for (const permission of preview) {
+				md += `- ${permission}\n`;
+			}
+			if (permissions.length > preview.length) {
+				md += `\n*...and ${permissions.length - preview.length} more*\n`;
+			}
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: data.url ?? result.finalUrl ?? url,
+			contentType: "text/markdown",
+			method: "firefox-addons",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via Firefox Add-ons API"],
+		};
+	} catch {}
+
+	return null;
+};

package/src/core/tools/web-scrapers/flathub.ts

@@ -0,0 +1,239 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, formatCount, htmlToBasicMarkdown, loadPage } from "./types";
+
+interface FlathubScreenshotSize {
+	src?: string;
+	width?: string;
+	height?: string;
+	scale?: string;
+}
+
+interface FlathubScreenshot {
+	caption?: string | null;
+	sizes?: FlathubScreenshotSize[];
+}
+
+interface FlathubRelease {
+	version?: string;
+	timestamp?: string;
+	description?: string | null;
+	url?: string | null;
+	type?: string | null;
+}
+
+interface FlathubAppStream {
+	id?: string;
+	name?: string;
+	summary?: string;
+	description?: string;
+	developer_name?: string;
+	categories?: string[];
+	screenshots?: FlathubScreenshot[];
+	releases?: FlathubRelease[];
+	metadata?: Record<string, unknown>;
+	installs?: number | string;
+	permissions?: unknown;
+}
+
+function extractAppId(pathname: string): string | null {
+	const detailsMatch = pathname.match(/^\/apps\/details\/([^/]+)\/?$/);
+	if (detailsMatch) return decodeURIComponent(detailsMatch[1]);
+
+	const appMatch = pathname.match(/^\/apps\/([^/]+)\/?$/);
+	if (appMatch) return decodeURIComponent(appMatch[1]);
+
+	return null;
+}
+
+function parseNumber(value: unknown): number | null {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string") {
+		const cleaned = value.replace(/[^0-9.]/g, "");
+		if (!cleaned) return null;
+		const parsed = Number(cleaned);
+		if (!Number.isNaN(parsed)) return parsed;
+	}
+	return null;
+}
+
+function normalizeStringList(value: unknown): string[] {
+	if (Array.isArray(value)) {
+		return value.filter((item): item is string => typeof item === "string" && item.trim().length > 0);
+	}
+	if (typeof value === "string") {
+		return value
+			.split(/[,;\n]+/)
+			.map((item) => item.trim())
+			.filter(Boolean);
+	}
+	return [];
+}
+
+function extractInstalls(app: FlathubAppStream): number | null {
+	const direct = parseNumber(app.installs);
+	if (direct !== null) return direct;
+
+	if (!app.metadata) return null;
+	for (const [key, value] of Object.entries(app.metadata)) {
+		if (!key.toLowerCase().includes("install")) continue;
+		const parsed = parseNumber(value);
+		if (parsed !== null) return parsed;
+	}
+
+	return null;
+}
+
+function extractPermissions(app: FlathubAppStream): string[] {
+	const permissions: string[] = [];
+	permissions.push(...normalizeStringList(app.permissions));
+
+	if (app.metadata) {
+		for (const [key, value] of Object.entries(app.metadata)) {
+			if (!key.toLowerCase().includes("permission")) continue;
+			const list = normalizeStringList(value);
+			if (list.length) {
+				permissions.push(...list);
+				continue;
+			}
+			if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+				permissions.push(`${key}: ${String(value)}`);
+			}
+		}
+	}
+
+	return Array.from(new Set(permissions));
+}
+
+function screenshotArea(size?: FlathubScreenshotSize): number {
+	if (!size) return 0;
+	const width = Number(size.width);
+	const height = Number(size.height);
+	if (!Number.isFinite(width) || !Number.isFinite(height)) return 0;
+	return width * height;
+}
+
+function bestScreenshotUrl(sizes?: FlathubScreenshotSize[]): string | null {
+	if (!sizes || sizes.length === 0) return null;
+
+	let best = sizes[0];
+	let bestArea = screenshotArea(best);
+
+	for (const size of sizes) {
+		const area = screenshotArea(size);
+		if (area > bestArea) {
+			best = size;
+			bestArea = area;
+		}
+	}
+
+	return best.src ?? sizes[0].src ?? null;
+}
+
+function formatReleaseDate(timestamp?: string | null): string | null {
+	if (!timestamp) return null;
+	const seconds = Number(timestamp);
+	if (!Number.isFinite(seconds)) return null;
+	const date = new Date(seconds * 1000);
+	if (Number.isNaN(date.getTime())) return null;
+	return date.toISOString().split("T")[0] ?? null;
+}
+
+export const handleFlathub: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "flathub.org" && parsed.hostname !== "www.flathub.org") return null;
+
+		const appId = extractAppId(parsed.pathname);
+		if (!appId) return null;
+
+		const apiUrl = `https://flathub.org/api/v2/appstream/${encodeURIComponent(appId)}`;
+		const result = await loadPage(apiUrl, { timeout, signal, headers: { Accept: "application/json" } });
+		if (!result.ok) return null;
+
+		let app: FlathubAppStream;
+		try {
+			app = JSON.parse(result.content) as FlathubAppStream;
+		} catch {
+			return null;
+		}
+
+		const fetchedAt = new Date().toISOString();
+		const name = app.name ?? app.id ?? appId;
+
+		let md = `# ${name}\n\n`;
+		if (app.summary) md += `${app.summary}\n\n`;
+
+		md += "## Metadata\n\n";
+		md += `**App ID:** ${app.id ?? appId}\n`;
+		if (app.developer_name) md += `**Developer:** ${app.developer_name}\n`;
+
+		const installs = extractInstalls(app);
+		if (installs !== null) md += `**Installs:** ${formatCount(installs)}\n`;
+
+		if (app.categories?.length) {
+			md += "\n## Categories\n\n";
+			for (const category of app.categories) {
+				md += `- ${category}\n`;
+			}
+		}
+
+		if (app.description) {
+			const description = htmlToBasicMarkdown(app.description);
+			if (description) md += `\n## Description\n\n${description}\n`;
+		}
+
+		const permissions = extractPermissions(app);
+		if (permissions.length) {
+			md += "\n## Permissions\n\n";
+			for (const permission of permissions) {
+				md += `- ${permission}\n`;
+			}
+		}
+
+		if (app.screenshots?.length) {
+			md += "\n## Screenshots\n\n";
+			for (const screenshot of app.screenshots.slice(0, 5)) {
+				const screenshotUrl = bestScreenshotUrl(screenshot.sizes);
+				if (!screenshotUrl) continue;
+				const caption = screenshot.caption ? ` - ${screenshot.caption}` : "";
+				md += `- ${screenshotUrl}${caption}\n`;
+			}
+		}
+
+		if (app.releases?.length) {
+			md += "\n## Releases\n\n";
+			for (const release of app.releases.slice(0, 5)) {
+				const version = release.version ?? "unknown";
+				let line = `- **${version}**`;
+				const date = formatReleaseDate(release.timestamp);
+				if (date) line += ` (${date})`;
+				if (release.type) line += ` · ${release.type}`;
+				if (release.url) line += ` · ${release.url}`;
+				md += `${line}\n`;
+
+				if (release.description) {
+					const releaseDesc = htmlToBasicMarkdown(release.description).replace(/\n+/g, " ").trim();
+					if (releaseDesc) md += `  - ${releaseDesc}\n`;
+				}
+			}
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: result.finalUrl,
+			contentType: "text/markdown",
+			method: "flathub-appstream",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via Flathub Appstream API"],
+		};
+	} catch {}
+
+	return null;
+};

package/src/core/tools/{web-fetch-handlers → web-scrapers}/github-gist.ts

@@ -5,7 +5,11 @@ import { finalizeOutput } from "./types";
 /**
  * Handle GitHub Gist URLs via GitHub API
  */
-export const handleGitHubGist: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleGitHubGist: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		if (parsed.hostname !== "gist.github.com") return null;
@@ -21,7 +25,7 @@ export const handleGitHubGist: SpecialHandler = async (url: string, timeout: num
 		const fetchedAt = new Date().toISOString();
 
 		// Fetch via GitHub API
-		const result = await fetchGitHubApi(`/gists/${gistId}`, timeout);
+		const result = await fetchGitHubApi(`/gists/${gistId}`, timeout, signal);
 		if (!result.ok || !result.data) return null;
 
 		const gist = result.data as {

package/src/core/tools/{web-fetch-handlers → web-scrapers}/github.ts

@@ -1,5 +1,5 @@
 import type { RenderResult, SpecialHandler } from "./types";
-import { finalizeOutput, loadPage } from "./types";
+import { createRequestSignal, finalizeOutput, loadPage } from "./types";
 
 interface GitHubUrl {
 	type: "blob" | "tree" | "repo" | "issue" | "issues" | "pull" | "pulls" | "discussion" | "discussions" | "other";
@@ -64,16 +64,19 @@ function parseGitHubUrl(url: string): GitHubUrl | null {
  * Convert GitHub blob URL to raw URL
  */
 function toRawGitHubUrl(gh: GitHubUrl): string {
-	return `https://raw.githubusercontent.com/${gh.owner}/${gh.repo}/refs/heads/${gh.ref}/${gh.path}`;
+	return `https://raw.githubusercontent.com/${gh.owner}/${gh.repo}/${gh.ref}/${gh.path}`;
 }
 
 /**
  * Fetch from GitHub API
  */
-export async function fetchGitHubApi(endpoint: string, timeout: number): Promise<{ data: unknown; ok: boolean }> {
+export async function fetchGitHubApi(
+	endpoint: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<{ data: unknown; ok: boolean }> {
 	try {
-		const controller = new AbortController();
-		const timeoutId = setTimeout(() => controller.abort(), timeout * 1000);
+		const { signal: requestSignal, cleanup } = createRequestSignal(timeout * 1000, signal);
 
 		const headers: Record<string, string> = {
 			Accept: "application/vnd.github.v3+json",
@@ -86,18 +89,20 @@ export async function fetchGitHubApi(endpoint: string, timeout: number): Promise
 			headers.Authorization = `Bearer ${token}`;
 		}
 
-		const response = await fetch(`https://api.github.com${endpoint}`, {
-			signal: controller.signal,
-			headers,
-		});
+		try {
+			const response = await fetch(`https://api.github.com${endpoint}`, {
+				signal: requestSignal,
+				headers,
+			});
 
-		clearTimeout(timeoutId);
+			if (!response.ok) {
+				return { data: null, ok: false };
+			}
 
-		if (!response.ok) {
-			return { data: null, ok: false };
+			return { data: await response.json(), ok: true };
+		} finally {
+			cleanup();
 		}
-
-		return { data: await response.json(), ok: true };
 	} catch {
 		return { data: null, ok: false };
 	}
@@ -106,13 +111,17 @@ export async function fetchGitHubApi(endpoint: string, timeout: number): Promise
 /**
  * Render GitHub issue/PR to markdown
  */
-async function renderGitHubIssue(gh: GitHubUrl, timeout: number): Promise<{ content: string; ok: boolean }> {
+async function renderGitHubIssue(
+	gh: GitHubUrl,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<{ content: string; ok: boolean }> {
 	const endpoint =
 		gh.type === "pull"
 			? `/repos/${gh.owner}/${gh.repo}/pulls/${gh.number}`
 			: `/repos/${gh.owner}/${gh.repo}/issues/${gh.number}`;
 
-	const result = await fetchGitHubApi(endpoint, timeout);
+	const result = await fetchGitHubApi(endpoint, timeout, signal);
 	if (!result.ok || !result.data) return { content: "", ok: false };
 
 	const issue = result.data as {
@@ -143,6 +152,7 @@ async function renderGitHubIssue(gh: GitHubUrl, timeout: number): Promise<{ cont
 		const commentsResult = await fetchGitHubApi(
 			`/repos/${gh.owner}/${gh.repo}/issues/${gh.number}/comments?per_page=50`,
 			timeout,
+			signal,
 		);
 		if (commentsResult.ok && Array.isArray(commentsResult.data)) {
 			md += `## Comments (${issue.comments})\n\n`;
@@ -163,8 +173,12 @@ async function renderGitHubIssue(gh: GitHubUrl, timeout: number): Promise<{ cont
 /**
  * Render GitHub issues list to markdown
  */
-async function renderGitHubIssuesList(gh: GitHubUrl, timeout: number): Promise<{ content: string; ok: boolean }> {
-	const result = await fetchGitHubApi(`/repos/${gh.owner}/${gh.repo}/issues?state=open&per_page=30`, timeout);
+async function renderGitHubIssuesList(
+	gh: GitHubUrl,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<{ content: string; ok: boolean }> {
+	const result = await fetchGitHubApi(`/repos/${gh.owner}/${gh.repo}/issues?state=open&per_page=30`, timeout, signal);
 	if (!result.ok || !Array.isArray(result.data)) return { content: "", ok: false };
 
 	const issues = result.data as Array<{
@@ -193,9 +207,13 @@ async function renderGitHubIssuesList(gh: GitHubUrl, timeout: number): Promise<{
 /**
  * Render GitHub tree (directory) to markdown
  */
-async function renderGitHubTree(gh: GitHubUrl, timeout: number): Promise<{ content: string; ok: boolean }> {
+async function renderGitHubTree(
+	gh: GitHubUrl,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<{ content: string; ok: boolean }> {
 	// Fetch repo info first to get default branch if ref not specified
-	const repoResult = await fetchGitHubApi(`/repos/${gh.owner}/${gh.repo}`, timeout);
+	const repoResult = await fetchGitHubApi(`/repos/${gh.owner}/${gh.repo}`, timeout, signal);
 	if (!repoResult.ok) return { content: "", ok: false };
 
 	const repo = repoResult.data as {
@@ -210,7 +228,11 @@ async function renderGitHubTree(gh: GitHubUrl, timeout: number): Promise<{ conte
 	md += `**Branch:** ${ref}\n\n`;
 
 	// Fetch directory contents
-	const contentsResult = await fetchGitHubApi(`/repos/${gh.owner}/${gh.repo}/contents/${dirPath}?ref=${ref}`, timeout);
+	const contentsResult = await fetchGitHubApi(
+		`/repos/${gh.owner}/${gh.repo}/contents/${dirPath}?ref=${ref}`,
+		timeout,
+		signal,
+	);
 
 	if (contentsResult.ok && Array.isArray(contentsResult.data)) {
 		const items = contentsResult.data as Array<{
@@ -240,8 +262,8 @@ async function renderGitHubTree(gh: GitHubUrl, timeout: number): Promise<{ conte
 		const readmeFile = items.find((item) => item.type === "file" && /^readme\.md$/i.test(item.name));
 		if (readmeFile) {
 			const readmePath = dirPath ? `${dirPath}/${readmeFile.name}` : readmeFile.name;
-			const rawUrl = `https://raw.githubusercontent.com/${gh.owner}/${gh.repo}/refs/heads/${ref}/${readmePath}`;
-			const readmeResult = await loadPage(rawUrl, { timeout });
+			const rawUrl = `https://raw.githubusercontent.com/${gh.owner}/${gh.repo}/${ref}/${readmePath}`;
+			const readmeResult = await loadPage(rawUrl, { timeout, signal });
 			if (readmeResult.ok) {
 				md += `---\n\n## README\n\n${readmeResult.content}`;
 			}
@@ -254,9 +276,13 @@ async function renderGitHubTree(gh: GitHubUrl, timeout: number): Promise<{ conte
 /**
  * Render GitHub repo to markdown (file list + README)
  */
-async function renderGitHubRepo(gh: GitHubUrl, timeout: number): Promise<{ content: string; ok: boolean }> {
+async function renderGitHubRepo(
+	gh: GitHubUrl,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<{ content: string; ok: boolean }> {
 	// Fetch repo info
-	const repoResult = await fetchGitHubApi(`/repos/${gh.owner}/${gh.repo}`, timeout);
+	const repoResult = await fetchGitHubApi(`/repos/${gh.owner}/${gh.repo}`, timeout, signal);
 	if (!repoResult.ok) return { content: "", ok: false };
 
 	const repo = repoResult.data as {
@@ -281,6 +307,7 @@ async function renderGitHubRepo(gh: GitHubUrl, timeout: number): Promise<{ conte
 	const treeResult = await fetchGitHubApi(
 		`/repos/${gh.owner}/${gh.repo}/git/trees/${repo.default_branch}?recursive=1`,
 		timeout,
+		signal,
 	);
 	if (treeResult.ok && treeResult.data) {
 		const tree = (treeResult.data as { tree: Array<{ path: string; type: string }> }).tree;
@@ -297,7 +324,7 @@ async function renderGitHubRepo(gh: GitHubUrl, timeout: number): Promise<{ conte
 	}
 
 	// Fetch README
-	const readmeResult = await fetchGitHubApi(`/repos/${gh.owner}/${gh.repo}/readme`, timeout);
+	const readmeResult = await fetchGitHubApi(`/repos/${gh.owner}/${gh.repo}/readme`, timeout, signal);
 	if (readmeResult.ok && readmeResult.data) {
 		const readme = readmeResult.data as { content: string; encoding: string };
 		if (readme.encoding === "base64") {
@@ -312,7 +339,11 @@ async function renderGitHubRepo(gh: GitHubUrl, timeout: number): Promise<{ conte
 /**
  * Handle GitHub URLs specially
  */
-export const handleGitHub: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleGitHub: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	const gh = parseGitHubUrl(url);
 	if (!gh) return null;
 
@@ -324,7 +355,7 @@ export const handleGitHub: SpecialHandler = async (url: string, timeout: number)
 			// Convert to raw URL and fetch
 			const rawUrl = toRawGitHubUrl(gh);
 			notes.push(`Fetched raw: ${rawUrl}`);
-			const result = await loadPage(rawUrl, { timeout });
+			const result = await loadPage(rawUrl, { timeout, signal });
 			if (result.ok) {
 				const output = finalizeOutput(result.content);
 				return {
@@ -343,7 +374,7 @@ export const handleGitHub: SpecialHandler = async (url: string, timeout: number)
 
 		case "tree": {
 			notes.push(`Fetched via GitHub API`);
-			const result = await renderGitHubTree(gh, timeout);
+			const result = await renderGitHubTree(gh, timeout, signal);
 			if (result.ok) {
 				const output = finalizeOutput(result.content);
 				return {
@@ -363,7 +394,7 @@ export const handleGitHub: SpecialHandler = async (url: string, timeout: number)
 		case "issue":
 		case "pull": {
 			notes.push(`Fetched via GitHub API`);
-			const result = await renderGitHubIssue(gh, timeout);
+			const result = await renderGitHubIssue(gh, timeout, signal);
 			if (result.ok) {
 				const output = finalizeOutput(result.content);
 				return {
@@ -382,7 +413,7 @@ export const handleGitHub: SpecialHandler = async (url: string, timeout: number)
 
 		case "issues": {
 			notes.push(`Fetched via GitHub API`);
-			const result = await renderGitHubIssuesList(gh, timeout);
+			const result = await renderGitHubIssuesList(gh, timeout, signal);
 			if (result.ok) {
 				const output = finalizeOutput(result.content);
 				return {
@@ -401,7 +432,7 @@ export const handleGitHub: SpecialHandler = async (url: string, timeout: number)
 
 		case "repo": {
 			notes.push(`Fetched via GitHub API`);
-			const result = await renderGitHubRepo(gh, timeout);
+			const result = await renderGitHubRepo(gh, timeout, signal);
 			if (result.ok) {
 				const output = finalizeOutput(result.content);
 				return {