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

package/src/core/tools/task/types.ts

@@ -4,20 +4,34 @@ import { type Static, Type } from "@sinclair/typebox";
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";
 
+function getEnv(name: string, defaultValue: number): number {
+	const value = process.env[name];
+	if (value === undefined) {
+		return defaultValue;
+	}
+	try {
+		const number = Number.parseInt(value, 10);
+		if (!Number.isNaN(number) && number > 0) {
+			return number;
+		}
+	} catch {}
+	return defaultValue;
+}
+
 /** Maximum tasks per call */
-export const MAX_PARALLEL_TASKS = 32;
+export const MAX_PARALLEL_TASKS = getEnv("OMP_TASK_MAX_PARALLEL", 32);
 
 /** Maximum concurrent workers */
-export const MAX_CONCURRENCY = 16;
+export const MAX_CONCURRENCY = getEnv("OMP_TASK_MAX_CONCURRENCY", 16);
 
 /** Maximum output bytes per agent */
-export const MAX_OUTPUT_BYTES = 500_000;
+export const MAX_OUTPUT_BYTES = getEnv("OMP_TASK_MAX_OUTPUT_BYTES", 500_000);
 
 /** Maximum output lines per agent */
-export const MAX_OUTPUT_LINES = 5000;
+export const MAX_OUTPUT_LINES = getEnv("OMP_TASK_MAX_OUTPUT_LINES", 5000);
 
 /** Maximum agents to show in description */
-export const MAX_AGENTS_IN_DESCRIPTION = 10;
+export const MAX_AGENTS_IN_DESCRIPTION = getEnv("OMP_TASK_MAX_AGENTS_IN_DESCRIPTION", 10);
 
 /** EventBus channel for raw subagent events */
 export const TASK_SUBAGENT_EVENT_CHANNEL = "task:subagent:event";

package/src/core/tools/task/worker.ts

@@ -24,7 +24,11 @@ import type { SubagentWorkerRequest, SubagentWorkerResponse, SubagentWorkerStart
 type PostMessageFn = (message: SubagentWorkerResponse) => void;
 
 const postMessageSafe: PostMessageFn = (message) => {
-	(globalThis as typeof globalThis & { postMessage: PostMessageFn }).postMessage(message);
+	try {
+		(globalThis as typeof globalThis & { postMessage: PostMessageFn }).postMessage(message);
+	} catch {
+		// Parent may have terminated worker, nothing we can do
+	}
 };
 
 interface WorkerMessageEvent<T> {
@@ -51,7 +55,9 @@ const isAgentEvent = (event: AgentSessionEvent): event is AgentEvent => {
 
 let running = false;
 let abortRequested = false;
+let doneSent = false;
 let activeSession: { abort: () => Promise<void>; dispose: () => Promise<void> } | null = null;
+let unsubscribe: (() => void) | null = null;
 
 /**
  * Resolve model string to Model object with optional thinking level.
@@ -145,6 +151,17 @@ async function runTask(payload: SubagentWorkerStartPayload): Promise<void> {
 
 		activeSession = session;
 
+		if (abortRequested) {
+			aborted = true;
+			exitCode = 1;
+			try {
+				await session.abort();
+			} catch {
+				// Ignore abort errors
+			}
+			return;
+		}
+
 		// Initialize extensions (equivalent to CLI's extension initialization)
 		// Note: Does not support --extension CLI flag or extension CLI flags
 		const extensionRunner = session.extensionRunner;
@@ -174,7 +191,7 @@ async function runTask(payload: SubagentWorkerStartPayload): Promise<void> {
 		let completeCalled = false;
 
 		// Subscribe to events and forward to parent (equivalent to --mode json output)
-		session.subscribe((event: AgentSessionEvent) => {
+		unsubscribe = session.subscribe((event: AgentSessionEvent) => {
 			if (isAgentEvent(event)) {
 				postMessageSafe({ type: "event", event });
 				// Track when complete tool is called
@@ -222,24 +239,39 @@ Call complete now.`;
 			if (exitCode === 0) exitCode = 1;
 		}
 
-		// Cleanup session
+		if (unsubscribe) {
+			try {
+				unsubscribe();
+			} catch {
+				// Ignore unsubscribe errors
+			}
+			unsubscribe = null;
+		}
+
+		// Cleanup session with timeout to prevent hanging
 		if (activeSession) {
+			const session = activeSession;
+			activeSession = null;
 			try {
-				await activeSession.dispose();
+				await Promise.race([session.dispose(), new Promise<void>((resolve) => setTimeout(resolve, 5000))]);
 			} catch {
 				// Ignore cleanup errors
 			}
-			activeSession = null;
 		}
 
-		// Send completion message to parent
-		postMessageSafe({
-			type: "done",
-			exitCode,
-			durationMs: Date.now() - startTime,
-			error,
-			aborted,
-		});
+		running = false;
+
+		// Send completion message to parent (only once)
+		if (!doneSent) {
+			doneSent = true;
+			postMessageSafe({
+				type: "done",
+				exitCode,
+				durationMs: Date.now() - startTime,
+				error,
+				aborted,
+			});
+		}
 	}
 }
 
@@ -251,6 +283,64 @@ function handleAbort(): void {
 	}
 }
 
+// Global error handlers to ensure we always send a done message
+// Using self instead of globalThis for proper worker scope typing
+declare const self: {
+	addEventListener(type: "error", listener: (event: ErrorEvent) => void): void;
+	addEventListener(type: "unhandledrejection", listener: (event: { reason: unknown }) => void): void;
+	addEventListener(type: "messageerror", listener: (event: MessageEvent) => void): void;
+};
+
+self.addEventListener("error", (event) => {
+	if (!running || doneSent) return;
+	doneSent = true;
+	abortRequested = true;
+	if (activeSession) {
+		void activeSession.abort();
+	}
+	postMessageSafe({
+		type: "done",
+		exitCode: 1,
+		durationMs: 0,
+		error: `Uncaught error: ${event.message || "Unknown error"}`,
+		aborted: false,
+	});
+});
+
+self.addEventListener("unhandledrejection", (event) => {
+	if (!running || doneSent) return;
+	doneSent = true;
+	abortRequested = true;
+	if (activeSession) {
+		void activeSession.abort();
+	}
+	const reason = event.reason;
+	const message = reason instanceof Error ? reason.stack || reason.message : String(reason);
+	postMessageSafe({
+		type: "done",
+		exitCode: 1,
+		durationMs: 0,
+		error: `Unhandled rejection: ${message}`,
+		aborted: false,
+	});
+});
+
+self.addEventListener("messageerror", () => {
+	if (doneSent) return;
+	doneSent = true;
+	abortRequested = true;
+	if (activeSession) {
+		void activeSession.abort();
+	}
+	postMessageSafe({
+		type: "done",
+		exitCode: 1,
+		durationMs: 0,
+		error: "Failed to deserialize parent message",
+		aborted: false,
+	});
+});
+
 // Message handler - receives start/abort commands from parent
 globalThis.addEventListener("message", (event: WorkerMessageEvent<SubagentWorkerRequest>) => {
 	const message = event.data;

package/src/core/tools/web-fetch-handlers/academic.test.ts

@@ -0,0 +1,239 @@
+import { describe, expect, it } from "bun:test";
+import { handleArxiv } from "./arxiv";
+import { handleIacr } from "./iacr";
+import { handlePubMed } from "./pubmed";
+import { handleSemanticScholar } from "./semantic-scholar";
+
+const SKIP = !process.env.WEB_FETCH_INTEGRATION;
+
+describe.skipIf(SKIP)("handleSemanticScholar", () => {
+	it("returns null for non-S2 URLs", async () => {
+		const result = await handleSemanticScholar("https://example.com", 10);
+		expect(result).toBeNull();
+	});
+
+	it("fetches a known paper", async () => {
+		// "Attention Is All You Need" paper
+		const result = await handleSemanticScholar(
+			"https://www.semanticscholar.org/paper/Attention-is-All-you-Need-Vaswani-Shazeer/204e3073870fae3d05bcbc2f6a8e263d9b72e776",
+			20,
+		);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("semantic-scholar");
+		// API may be rate-limited or fail, verify handler structure
+		if (
+			!result?.content.includes("Too Many Requests") &&
+			!result?.content.includes("Failed to fetch") &&
+			!result?.content.includes("Failed to parse")
+		) {
+			expect(result?.content).toContain("Attention");
+			expect(result?.contentType).toBe("text/markdown");
+		}
+		expect(result?.truncated).toBe(false);
+	});
+
+	it("handles invalid paper ID format", async () => {
+		const result = await handleSemanticScholar("https://www.semanticscholar.org/paper/invalid", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("semantic-scholar");
+		expect(result?.content).toContain("Failed to extract paper ID");
+		expect(result?.notes).toContain("Invalid URL format");
+	});
+
+	it("extracts paper ID from various URL formats", async () => {
+		const paperId = "204e3073870fae3d05bcbc2f6a8e263d9b72e776";
+		const urls = [
+			`https://www.semanticscholar.org/paper/Attention-is-All-you-Need-Vaswani-Shazeer/${paperId}`,
+			`https://www.semanticscholar.org/paper/${paperId}`,
+		];
+
+		for (const url of urls) {
+			const result = await handleSemanticScholar(url, 20);
+			expect(result).not.toBeNull();
+			expect(result?.method).toBe("semantic-scholar");
+			// API may be rate-limited or fail
+			if (
+				!result?.content.includes("Too Many Requests") &&
+				!result?.content.includes("Failed to fetch") &&
+				!result?.content.includes("Failed to parse")
+			) {
+				expect(result?.content).toContain("Attention");
+			}
+		}
+	});
+
+	it("includes metadata in formatted output", async () => {
+		const result = await handleSemanticScholar(
+			"https://www.semanticscholar.org/paper/Attention-is-All-you-Need-Vaswani-Shazeer/204e3073870fae3d05bcbc2f6a8e263d9b72e776",
+			20,
+		);
+		expect(result).not.toBeNull();
+		// Only check metadata if API call succeeded (not rate-limited)
+		if (!result?.content.includes("Too Many Requests") && !result?.content.includes("Failed to fetch")) {
+			expect(result?.content).toMatch(/Year:/);
+			expect(result?.content).toMatch(/Citations:/);
+			expect(result?.content).toMatch(/Authors:/);
+			expect(result?.content).toContain("Vaswani");
+		}
+	});
+});
+
+describe.skipIf(SKIP)("handlePubMed", () => {
+	it("returns null for non-PubMed URLs", async () => {
+		const result = await handlePubMed("https://example.com", 10);
+		expect(result).toBeNull();
+	});
+
+	it("fetches a known article from pubmed.ncbi.nlm.nih.gov", async () => {
+		// PMID 33782455 - COVID-19 vaccine paper
+		const result = await handlePubMed("https://pubmed.ncbi.nlm.nih.gov/33782455/", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("pubmed");
+		expect(result?.contentType).toBe("text/markdown");
+		expect(result?.truncated).toBe(false);
+	});
+
+	it("fetches from ncbi.nlm.nih.gov/pubmed format", async () => {
+		const result = await handlePubMed("https://ncbi.nlm.nih.gov/pubmed/33782455", 20);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("pubmed");
+	});
+
+	it("includes PMID in output", async () => {
+		const result = await handlePubMed("https://pubmed.ncbi.nlm.nih.gov/33782455/", 20);
+		expect(result).not.toBeNull();
+		expect(result?.content).toContain("PMID:");
+		expect(result?.content).toContain("33782455");
+	});
+
+	it("includes abstract section", async () => {
+		const result = await handlePubMed("https://pubmed.ncbi.nlm.nih.gov/33782455/", 20);
+		expect(result).not.toBeNull();
+		expect(result?.content).toContain("## Abstract");
+	});
+
+	it("includes metadata fields", async () => {
+		const result = await handlePubMed("https://pubmed.ncbi.nlm.nih.gov/33782455/", 20);
+		expect(result).not.toBeNull();
+		expect(result?.content).toMatch(/Authors:/);
+		expect(result?.content).toMatch(/Journal:/);
+	});
+
+	it("returns null for invalid PMID format", async () => {
+		const result = await handlePubMed("https://pubmed.ncbi.nlm.nih.gov/invalid/", 20);
+		expect(result).toBeNull();
+	});
+
+	it("handles non-existent PMID gracefully", async () => {
+		const result = await handlePubMed("https://pubmed.ncbi.nlm.nih.gov/99999999999/", 20);
+		// NCBI API returns a response even for non-existent PMIDs with minimal data
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("pubmed");
+	});
+});
+
+describe.skipIf(SKIP)("handleArxiv", () => {
+	it("returns null for non-arXiv URLs", async () => {
+		const result = await handleArxiv("https://example.com", 10000);
+		expect(result).toBeNull();
+	});
+
+	it("fetches a known paper", async () => {
+		// "Attention Is All You Need" paper
+		const result = await handleArxiv("https://arxiv.org/abs/1706.03762", 30000);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("arxiv");
+		expect(result?.contentType).toBe("text/markdown");
+		// API may be rate-limited or fail
+		if (!result?.content.includes("Too Many Requests") && !result?.content.includes("Failed to fetch")) {
+			expect(result?.content).toContain("Attention");
+			expect(result?.content).toContain("arXiv:");
+			expect(result?.content).toContain("1706.03762");
+		}
+		expect(result?.truncated).toBe(false);
+	});
+
+	it("handles /pdf/ URLs", async () => {
+		const result = await handleArxiv("https://arxiv.org/pdf/1706.03762", 30000);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("arxiv");
+		if (!result?.content.includes("Too Many Requests") && !result?.content.includes("Failed to fetch")) {
+			expect(result?.content).toContain("Attention");
+			expect(result?.notes?.some((n) => n.includes("PDF"))).toBe(true);
+		}
+	});
+
+	it("handles arxiv.org/abs/ format", async () => {
+		const result = await handleArxiv("https://arxiv.org/abs/1706.03762", 30000);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("arxiv");
+		if (!result?.content.includes("Too Many Requests") && !result?.content.includes("Failed to fetch")) {
+			expect(result?.content).toContain("1706.03762");
+		}
+	});
+
+	it("includes paper metadata", async () => {
+		const result = await handleArxiv("https://arxiv.org/abs/1706.03762", 30000);
+		expect(result).not.toBeNull();
+		if (!result?.content.includes("Too Many Requests") && !result?.content.includes("Failed to fetch")) {
+			expect(result?.content).toMatch(/Authors:/);
+			expect(result?.content).toContain("Vaswani");
+			expect(result?.content).toMatch(/Abstract/);
+			expect(result?.content).toMatch(/Published:/);
+		}
+	});
+
+	it("handles rate limiting gracefully", async () => {
+		const result = await handleArxiv("https://arxiv.org/abs/1706.03762", 5000);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("arxiv");
+		// Should return something, even if rate limited
+		expect(result?.content).toBeTruthy();
+	});
+});
+
+describe.skipIf(SKIP)("handleIacr", () => {
+	it("returns null for non-IACR URLs", async () => {
+		const result = await handleIacr("https://example.com", 10000);
+		expect(result).toBeNull();
+	});
+
+	it("fetches a known ePrint", async () => {
+		// Using a well-known paper
+		const result = await handleIacr("https://eprint.iacr.org/2023/123", 30000);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("iacr");
+		expect(result?.contentType).toBe("text/markdown");
+		if (!result?.content.includes("Too Many Requests") && !result?.content.includes("Failed to fetch")) {
+			expect(result?.content).toContain("ePrint:");
+			expect(result?.content).toContain("2023/123");
+		}
+		expect(result?.truncated).toBe(false);
+	});
+
+	it("includes paper metadata", async () => {
+		const result = await handleIacr("https://eprint.iacr.org/2023/123", 30000);
+		expect(result).not.toBeNull();
+		if (!result?.content.includes("Too Many Requests") && !result?.content.includes("Failed to fetch")) {
+			expect(result?.content).toMatch(/Authors:/);
+			expect(result?.content).toMatch(/Abstract/);
+		}
+	});
+
+	it("handles rate limiting gracefully", async () => {
+		const result = await handleIacr("https://eprint.iacr.org/2023/123", 5000);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("iacr");
+		// Should return something, even if rate limited
+		expect(result?.content).toBeTruthy();
+	});
+
+	it("handles PDF URLs", async () => {
+		const result = await handleIacr("https://eprint.iacr.org/2023/123.pdf", 30000);
+		expect(result).not.toBeNull();
+		expect(result?.method).toBe("iacr");
+		if (!result?.content.includes("Too Many Requests") && !result?.content.includes("Failed to fetch")) {
+			expect(result?.notes?.some((n) => n.includes("PDF"))).toBe(true);
+		}
+	});
+});

package/src/core/tools/web-fetch-handlers/artifacthub.ts

@@ -0,0 +1,210 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, formatCount, loadPage } from "./types";
+
+interface ArtifactHubMaintainer {
+	name: string;
+	email?: string;
+}
+
+interface ArtifactHubLink {
+	name: string;
+	url: string;
+}
+
+interface ArtifactHubRepository {
+	name: string;
+	display_name?: string;
+	url: string;
+	organization_name?: string;
+	organization_display_name?: string;
+}
+
+interface ArtifactHubPackage {
+	package_id: string;
+	name: string;
+	normalized_name: string;
+	display_name?: string;
+	description?: string;
+	version: string;
+	app_version?: string;
+	license?: string;
+	home_url?: string;
+	readme?: string;
+	install?: string;
+	keywords?: string[];
+	maintainers?: ArtifactHubMaintainer[];
+	links?: ArtifactHubLink[];
+	repository: ArtifactHubRepository;
+	ts: number;
+	created_at: number;
+	stars?: number;
+	official?: boolean;
+	signed?: boolean;
+	security_report_summary?: {
+		low?: number;
+		medium?: number;
+		high?: number;
+		critical?: number;
+	};
+	available_versions?: Array<{ version: string; ts: number }>;
+}
+
+/**
+ * Handle Artifact Hub URLs via API
+ * Supports Helm charts, OLM operators, Falco rules, OPA policies, etc.
+ */
+export const handleArtifactHub: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "artifacthub.io" && parsed.hostname !== "www.artifacthub.io") return null;
+
+		// Extract kind, repo, and package name from /packages/{kind}/{repo}/{name}
+		const match = parsed.pathname.match(/^\/packages\/([^/]+)\/([^/]+)\/([^/]+)/);
+		if (!match) return null;
+
+		const [, kind, repo, name] = match;
+		const fetchedAt = new Date().toISOString();
+
+		// Fetch from Artifact Hub API
+		const apiUrl = `https://artifacthub.io/api/v1/packages/${kind}/${repo}/${name}`;
+		const result = await loadPage(apiUrl, {
+			timeout,
+			headers: { Accept: "application/json" },
+		});
+
+		if (!result.ok) return null;
+
+		let pkg: ArtifactHubPackage;
+		try {
+			pkg = JSON.parse(result.content);
+		} catch {
+			return null;
+		}
+
+		const displayName = pkg.display_name || pkg.name;
+		const kindLabel = formatKindLabel(kind);
+
+		let md = `# ${displayName}\n\n`;
+		if (pkg.description) md += `${pkg.description}\n\n`;
+
+		// Basic info line
+		md += `**Type:** ${kindLabel}`;
+		md += ` · **Version:** ${pkg.version}`;
+		if (pkg.app_version) md += ` · **App Version:** ${pkg.app_version}`;
+		if (pkg.license) md += ` · **License:** ${pkg.license}`;
+		md += "\n";
+
+		// Stats and badges
+		const badges: string[] = [];
+		if (pkg.official) badges.push("Official");
+		if (pkg.signed) badges.push("Signed");
+		if (pkg.stars) badges.push(`${formatCount(pkg.stars)} stars`);
+		if (badges.length > 0) md += `**${badges.join(" · ")}**\n`;
+		md += "\n";
+
+		// Repository info
+		const repoDisplay =
+			pkg.repository.organization_display_name || pkg.repository.display_name || pkg.repository.name;
+		md += `**Repository:** ${repoDisplay}`;
+		if (pkg.repository.url) md += ` ([${pkg.repository.url}](${pkg.repository.url}))`;
+		md += "\n";
+
+		if (pkg.home_url) md += `**Homepage:** ${pkg.home_url}\n`;
+		if (pkg.keywords?.length) md += `**Keywords:** ${pkg.keywords.join(", ")}\n`;
+
+		// Maintainers
+		if (pkg.maintainers?.length) {
+			const maintainerNames = pkg.maintainers.map((m) => m.name).join(", ");
+			md += `**Maintainers:** ${maintainerNames}\n`;
+		}
+
+		// Security report summary
+		if (pkg.security_report_summary) {
+			const sec = pkg.security_report_summary;
+			const parts: string[] = [];
+			if (sec.critical) parts.push(`${sec.critical} critical`);
+			if (sec.high) parts.push(`${sec.high} high`);
+			if (sec.medium) parts.push(`${sec.medium} medium`);
+			if (sec.low) parts.push(`${sec.low} low`);
+			if (parts.length > 0) {
+				md += `**Security:** ${parts.join(", ")}\n`;
+			}
+		}
+
+		// Links
+		if (pkg.links?.length) {
+			md += `\n## Links\n\n`;
+			for (const link of pkg.links) {
+				md += `- [${link.name}](${link.url})\n`;
+			}
+		}
+
+		// Install instructions
+		if (pkg.install) {
+			md += `\n## Installation\n\n\`\`\`bash\n${pkg.install.trim()}\n\`\`\`\n`;
+		}
+
+		// Recent versions
+		if (pkg.available_versions?.length) {
+			md += `\n## Recent Versions\n\n`;
+			for (const ver of pkg.available_versions.slice(0, 5)) {
+				const date = new Date(ver.ts * 1000).toISOString().split("T")[0];
+				md += `- **${ver.version}** (${date})\n`;
+			}
+		}
+
+		// README
+		if (pkg.readme) {
+			md += `\n---\n\n## README\n\n${pkg.readme}\n`;
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "artifacthub",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: [`Fetched via Artifact Hub API (${kindLabel})`],
+		};
+	} catch {}
+
+	return null;
+};
+
+/**
+ * Convert kind slug to display label
+ */
+function formatKindLabel(kind: string): string {
+	const labels: Record<string, string> = {
+		helm: "Helm Chart",
+		"helm-plugin": "Helm Plugin",
+		falco: "Falco Rules",
+		opa: "OPA Policy",
+		olm: "OLM Operator",
+		tbaction: "Tinkerbell Action",
+		krew: "Krew Plugin",
+		tekton: "Tekton Task",
+		"tekton-pipeline": "Tekton Pipeline",
+		keda: "KEDA Scaler",
+		coredns: "CoreDNS Plugin",
+		keptn: "Keptn Integration",
+		container: "Container Image",
+		kubewarden: "Kubewarden Policy",
+		gatekeeper: "Gatekeeper Policy",
+		kyverno: "Kyverno Policy",
+		"knative-client": "Knative Client Plugin",
+		backstage: "Backstage Plugin",
+		argo: "Argo Template",
+		kubearmor: "KubeArmor Policy",
+		kcl: "KCL Module",
+		headlamp: "Headlamp Plugin",
+		inspektor: "Inspektor Gadget",
+		"meshery-design": "Meshery Design",
+		"opencost-plugin": "OpenCost Plugin",
+		radius: "Radius Recipe",
+	};
+	return labels[kind] || kind.charAt(0).toUpperCase() + kind.slice(1);
+}