@nklisch/pi-enhanced 0.1.0

package/node_modules/pi-web-access/test/pdf-extract.test.mjs

@@ -0,0 +1,95 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { test } from "node:test";
+
+const extractorUrl = new URL("../pdf-extract.ts", import.meta.url).href;
+
+test("extractPDFToMarkdown works on Node 22 without native Promise.try", () => {
+  const child = spawnSync(process.execPath, ["--input-type=module"], {
+    input: buildChildScript(extractorUrl),
+    encoding: "utf8",
+    maxBuffer: 2 * 1024 * 1024,
+  });
+
+  assert.equal(
+    child.status,
+    0,
+    "PDF extraction failed in a child process. stderr summary:\n" + errorSummary(child.stderr),
+  );
+
+  assert.match(child.stdout, /Hello PDF/);
+});
+
+function buildChildScript(moduleUrl) {
+  return `
+    import { mkdtemp, readFile } from "node:fs/promises";
+    import { tmpdir } from "node:os";
+    import { join } from "node:path";
+
+    process.on("uncaughtException", (error) => {
+      console.error(error?.stack || error);
+      process.exit(1);
+    });
+    process.on("unhandledRejection", (error) => {
+      console.error(error?.stack || error);
+      process.exit(1);
+    });
+
+    Reflect.deleteProperty(Promise, "try");
+    if (typeof Promise.try !== "undefined") {
+      throw new Error("Expected Promise.try to be unavailable before PDF extraction");
+    }
+
+    const { extractPDFToMarkdown } = await import(${JSON.stringify(moduleUrl)});
+
+    const outputDir = await mkdtemp(join(tmpdir(), "pi-web-access-pdf-"));
+    const result = await extractPDFToMarkdown(
+      makePdf("Hello PDF"),
+      "https://example.test/hello.pdf",
+      { outputDir },
+    );
+
+    console.log(await readFile(result.outputPath, "utf8"));
+
+    function makePdf(text) {
+      const content = "BT /F1 24 Tf 72 720 Td (" + text + ") Tj ET";
+      const objects = [
+        "<< /Type /Catalog /Pages 2 0 R >>",
+        "<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+        "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R >>",
+        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
+        "<< /Length " + Buffer.byteLength(content, "ascii") + " >>\\nstream\\n" + content + "\\nendstream",
+      ];
+      let body = "%PDF-1.4\\n";
+      const offsets = [0];
+
+      for (let index = 0; index < objects.length; index += 1) {
+        offsets.push(Buffer.byteLength(body, "ascii"));
+        body += String(index + 1) + " 0 obj\\n" + objects[index] + "\\nendobj\\n";
+      }
+
+      const xrefOffset = Buffer.byteLength(body, "ascii");
+      body += "xref\\n0 " + String(objects.length + 1) + "\\n";
+      body += "0000000000 65535 f \\n";
+
+      for (const offset of offsets.slice(1)) {
+        body += String(offset).padStart(10, "0") + " 00000 n \\n";
+      }
+
+      body += "trailer\\n<< /Size " + String(objects.length + 1) + " /Root 1 0 R >>\\n";
+      body += "startxref\\n" + String(xrefOffset) + "\\n%%EOF\\n";
+
+      return new TextEncoder().encode(body).buffer;
+    }
+  `;
+}
+
+function errorSummary(value, size = 1200) {
+  const marker = "TypeError: Promise.try is not a function";
+  const index = value.indexOf(marker);
+  if (index >= 0) {
+    return value.slice(index, index + size);
+  }
+
+  return value.length > size ? value.slice(-size) : value;
+}

package/node_modules/pi-web-access/test/search-error-render.test.mjs

@@ -0,0 +1,155 @@
+// Repro + guard for the web_search Ctrl+O error-path dead-end (ronin fix).
+//
+// BEFORE the fix, web_search renderResult early-returned a SINGLE line on the
+// error/cancel path (before the collapsed/expanded branch), so Ctrl+O flipped
+// `expanded` with zero visible effect and discarded the partial results. This
+// test pins the new behavior: the error/cancel path produces a rich, EXPANDABLE
+// plan (>1 line, with diagnostics + a "ctrl+o to expand" hint), routed through
+// the dep-free buildSearchErrorPlan() that index.ts.renderResult delegates to.
+//
+// Runner: node --test (matches the package's existing .test.mjs convention).
+// Node >= 22.6 imports the .ts source directly (no build step).
+
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { test } from "node:test";
+
+import { buildSearchErrorPlan } from "../render-search-error.ts";
+
+// --- fixture: a stale cancel with partial results, mirroring the user's report
+// ("Search curation cancelled (stale)" with 2/3 queries done, one errored,
+//  browser never connected). ---
+const staleCancel = {
+	error: "Search curation cancelled (stale).",
+	cancelled: true,
+	cancelReason: "stale",
+	browserConnected: false,
+	lastHeartbeatAgeMs: 31200,
+	queryCount: 3,
+	cancelledQueries: [
+		{ query: "z.ai API usage endpoint coding plan credits", provider: "perplexity", error: null, resultCount: 5 },
+		{ query: "z.ai GLM coding plan API key usage limits", provider: "perplexity", error: "Connection error", resultCount: 0 },
+	],
+};
+
+test("cancel/error path is NOT a dead-end single line: expanded plan has >1 line", () => {
+	const plan = buildSearchErrorPlan(staleCancel);
+	assert.notEqual(plan, null, "a cancelled result must produce a plan, not null");
+	const expanded = plan.expanded.join("\n");
+	// The dead-end was exactly ONE line. Pin that the expanded view is rich.
+	assert.ok(plan.expanded.length > 1, `expanded must be >1 line, got ${plan.expanded.length}`);
+	assert.match(expanded, /Search curation cancelled \(stale\)/);
+});
+
+test("expanded plan surfaces the diagnostics that were previously discarded", () => {
+	const plan = buildSearchErrorPlan(staleCancel);
+	const expanded = plan.expanded.join("\n");
+	// cancel reason
+	assert.match(expanded, /cancel reason\s*:\s*stale/);
+	// browser state — the #1 stale cause, previously invisible
+	assert.match(expanded, /browser\s*:\s*never connected/);
+	// query progress (2 of 3 done)
+	assert.match(expanded, /queries started\s*:\s*3/);
+	assert.match(expanded, /queries done\s*:\s*2/);
+	// per-query results: the completed one (with source count) AND the errored one
+	assert.match(expanded, /z\.ai API usage endpoint/);
+	assert.match(expanded, /5 sources/);
+	assert.match(expanded, /\[err\]/);
+	assert.match(expanded, /Connection error/);
+});
+
+test("collapsed view is a short summary WITH a ctrl+o expand hint (Ctrl+O now does something)", () => {
+	const plan = buildSearchErrorPlan(staleCancel);
+	// collapsed preview summarizes progress + browser state
+	const collapsed = plan.collapsed.join("\n");
+	assert.match(collapsed, /2\/3 queries completed/);
+	assert.match(collapsed, /browser never connected/);
+	// THE fix signal: an expand hint exists (the old single-line return had none,
+	// so Ctrl+O did nothing). Mutation: dropping the hint fails here.
+	assert.equal(typeof plan.expandHint, "string");
+	assert.match(plan.expandHint, /ctrl\+o to expand/i, "expand hint must mention ctrl+o");
+	// and the hint correctly counts the hidden lines
+	assert.match(plan.expandHint, /\d+ more lines/);
+});
+
+test("plain (non-cancel) error stays a clean single line — no diagnostic noise", () => {
+	// A bare argument error has nothing to diagnose; it must NOT sprout fake
+	// "browser: unknown" diagnostics. Guards the gating logic in the module.
+	const plan = buildSearchErrorPlan({ error: "No query provided" });
+	assert.notEqual(plan, null);
+	assert.equal(plan.expanded.length, 1, "plain error must be a single line");
+	assert.equal(plan.collapsed.length, 0);
+	assert.equal(plan.expandHint, null, "plain error must have no expand hint");
+});
+
+// --- other tools (fetch_content / get_search_content): the same
+// dead-end exists in their renderResults; they now reuse buildSearchErrorPlan via
+// extraLines. These pin that non-cancel errors with detail become expandable
+// WITHOUT the curator/browser diagnostics (which are web_search-only). ---
+
+test("fetch_content-style error (extras, no cancel) is expandable without browser diagnostics", () => {
+	const plan = buildSearchErrorPlan({
+		error: "Failed to fetch: https://example.com/x (404)",
+		extraLines: ["urls: 1/2 succeeded", "response id: resp_abc", "  \u25b8 https://example.com/x"],
+	});
+	assert.notEqual(plan, null);
+	const expanded = plan.expanded.join("\n");
+	assert.ok(plan.expanded.length > 1);
+	assert.match(expanded, /urls: 1\/2 succeeded/);
+	assert.match(expanded, /resp_abc/);
+	// MUST NOT show curator/browser diagnostics for a non-cancel error.
+	assert.doesNotMatch(expanded, /browser|cancel reason|queries started/);
+	assert.equal(typeof plan.expandHint, "string");
+	assert.match(plan.expandHint, /ctrl\+o to expand/i);
+});
+
+test("non-search error with extras shows detail without browser diagnostics", () => {
+	const plan = buildSearchErrorPlan({
+		error: "Exa search failed: connection reset",
+		extraLines: ["query: how to use p-limit concurrency"],
+	});
+	assert.notEqual(plan, null);
+	assert.match(plan.expanded.join("\n"), /query: how to use p-limit concurrency/);
+	assert.doesNotMatch(plan.expanded.join("\n"), /browser/);
+	assert.equal(typeof plan.expandHint, "string");
+});
+
+test("error with NO extras and NO cancel stays single-line", () => {
+	// e.g. fetch_content with no url — nothing to diagnose.
+	const plan = buildSearchErrorPlan({ error: "Some transient error" });
+	assert.notEqual(plan, null);
+	assert.equal(plan.expanded.length, 1);
+	assert.equal(plan.expandHint, null);
+});
+
+test("non-error result yields null so the caller falls through to the success renderer", () => {
+	assert.equal(buildSearchErrorPlan({ queryCount: 3, totalResults: 9 }), null);
+	assert.equal(buildSearchErrorPlan(undefined), null);
+	assert.equal(buildSearchErrorPlan(null), null);
+});
+
+// --- source-contract guard: index.ts web_search renderResult must DELEGATE to
+// buildSearchErrorPlan on the error path (mutation-proof against reverting the
+// integration back to the dead-end single-line return). ---
+const indexPath = fileURLToPath(new URL("../index.ts", import.meta.url));
+const indexSrc = readFileSync(indexPath, "utf8");
+
+test("index.ts imports buildSearchErrorPlan and wires it into the web_search error path", () => {
+	assert.match(indexSrc, /import \{ buildSearchErrorPlan, type SearchErrorDetails, type SearchErrorPlan \} from "\.\/render-search-error\.ts";/);
+	// The web_search renderResult error branch must call buildSearchErrorPlan.
+	// (Mutation: reverting renderResult to `return new Text(error...)` drops this.)
+	assert.match(indexSrc, /buildSearchErrorPlan\(details as SearchErrorDetails\)/);
+	// buildCurationCancelledReturn must now carry partial diagnostics into details
+	// (mutation: dropping the partial arg reverts to the discarded-results bug).
+	assert.match(indexSrc, /buildCurationCancelledReturn\(reason, \{/);
+	assert.match(indexSrc, /cancelledQueries/);
+	// the 2 other tools must also delegate to buildSearchErrorPlan (mutation-proof:
+	// reverting any of them to the bare single-line drops its buildSearchErrorPlan call).
+	// Count call sites: web_search + fetch_content + get_search_content = 3.
+	const callSiteCount = (indexSrc.match(/const plan = buildSearchErrorPlan\(/g) || []).length;
+	assert.equal(callSiteCount, 3, `expected 3 buildSearchErrorPlan call sites, got ${callSiteCount}`);
+	// renderSearchErrorPlan shared renderer is used by all 3.
+	const renderCount = (indexSrc.match(/return renderSearchErrorPlan\(plan, expanded, theme\)/g) || []).length;
+	assert.equal(renderCount, 3, `expected 3 renderSearchErrorPlan returns, got ${renderCount}`);
+});

package/node_modules/pi-web-access/test/search-providers.test.mjs

@@ -0,0 +1,285 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+const braveModuleUrl = new URL("../brave.ts", import.meta.url).href;
+const exaModuleUrl = new URL("../exa.ts", import.meta.url).href;
+const openaiModuleUrl = new URL("../openai-search.ts", import.meta.url).href;
+const tavilyModuleUrl = new URL("../tavily.ts", import.meta.url).href;
+const searchModuleUrl = new URL("../gemini-search.ts", import.meta.url).href;
+
+function runChild(script, env) {
+	const childEnv = { ...process.env };
+	for (const key of [
+		"PI_CODING_AGENT_DIR",
+		"XDG_CONFIG_HOME",
+		"OPENAI_API_KEY",
+		"BRAVE_API_KEY",
+		"PARALLEL_API_KEY",
+		"TAVILY_API_KEY",
+		"EXA_API_KEY",
+		"PERPLEXITY_API_KEY",
+		"GEMINI_API_KEY",
+	]) {
+		delete childEnv[key];
+	}
+	Object.assign(childEnv, env);
+	return spawnSync(process.execPath, ["--input-type=module"], {
+		input: script,
+		encoding: "utf8",
+		env: childEnv,
+		maxBuffer: 2 * 1024 * 1024,
+	});
+}
+
+test("Brave search applies domain filters in the query and returned results", async () => {
+	const home = await mkdtemp(join(tmpdir(), "pi-web-access-brave-"));
+	const child = runChild(`
+		let capturedUrl = "";
+		let capturedHeaders = null;
+		globalThis.fetch = async (url, init) => {
+			capturedUrl = String(url);
+			capturedHeaders = init.headers;
+			return new Response(JSON.stringify({
+				web: { results: [
+					{ title: "GitHub", url: "https://github.com/nicobailon/pi-web-access", description: "repo" },
+					{ title: "Gist", url: "https://gist.github.com/nicobailon/abc", description: "gist" },
+					{ title: "Example", url: "https://example.com/nope", description: "example" },
+				] },
+			}), { status: 200, headers: { "content-type": "application/json" } });
+		};
+
+		const { searchWithBrave } = await import(${JSON.stringify(braveModuleUrl)});
+		const result = await searchWithBrave("sdk docs", {
+			domainFilter: ["github.com", "-gist.github.com"],
+			numResults: 2,
+		});
+		const parsedUrl = new URL(capturedUrl);
+		console.log(JSON.stringify({
+			q: parsedUrl.searchParams.get("q"),
+			count: parsedUrl.searchParams.get("count"),
+			token: capturedHeaders["X-Subscription-Token"],
+			results: result.results,
+		}));
+	`, {
+		HOME: home,
+		USERPROFILE: home,
+		BRAVE_API_KEY: "brave-test-key",
+	});
+
+	assert.equal(child.status, 0, child.stderr);
+	const output = JSON.parse(child.stdout.trim());
+	assert.match(output.q, /site:github\.com/);
+	assert.match(output.q, /NOT site:gist\.github\.com/);
+	assert.equal(output.count, "20");
+	assert.equal(output.token, "brave-test-key");
+	assert.deepEqual(output.results.map((result) => result.url), ["https://github.com/nicobailon/pi-web-access"]);
+});
+
+test("Tavily search uses bearer auth and maps filters/content", async () => {
+	const home = await mkdtemp(join(tmpdir(), "pi-web-access-tavily-"));
+	const child = runChild(`
+		let capturedUrl = "";
+		let capturedHeaders = null;
+		let capturedBody = null;
+		globalThis.fetch = async (url, init) => {
+			capturedUrl = String(url);
+			capturedHeaders = init.headers;
+			capturedBody = JSON.parse(init.body);
+			return new Response(JSON.stringify({
+				answer: "Tavily answer",
+				results: [{
+					title: "Tavily Docs",
+					url: "https://docs.tavily.com/search",
+					content: "Search docs snippet",
+					raw_content: "# Tavily Docs\\nFull content",
+				}],
+			}), { status: 200, headers: { "content-type": "application/json" } });
+		};
+
+		const { searchWithTavily } = await import(${JSON.stringify(tavilyModuleUrl)});
+		const result = await searchWithTavily("tavily search docs", {
+			domainFilter: ["https://docs.tavily.com/search", "-reddit.com"],
+			recencyFilter: "week",
+			numResults: 4,
+			includeContent: true,
+		});
+		console.log(JSON.stringify({ capturedUrl, capturedHeaders, capturedBody, result }));
+	`, {
+		HOME: home,
+		USERPROFILE: home,
+		TAVILY_API_KEY: "tvly-test-key",
+	});
+
+	assert.equal(child.status, 0, child.stderr);
+	const output = JSON.parse(child.stdout.trim());
+	assert.equal(output.capturedUrl, "https://api.tavily.com/search");
+	assert.equal(output.capturedHeaders.Authorization, "Bearer tvly-test-key");
+	assert.deepEqual(output.capturedBody, {
+		query: "tavily search docs",
+		search_depth: "basic",
+		max_results: 4,
+		include_answer: "basic",
+		include_raw_content: "markdown",
+		time_range: "week",
+		include_domains: ["docs.tavily.com"],
+		exclude_domains: ["reddit.com"],
+	});
+	assert.equal(output.result.answer, "Tavily answer");
+	assert.deepEqual(output.result.results, [{ title: "Tavily Docs", url: "https://docs.tavily.com/search", snippet: "Search docs snippet" }]);
+	assert.deepEqual(output.result.inlineContent, [{ url: "https://docs.tavily.com/search", title: "Tavily Docs", content: "# Tavily Docs\nFull content", error: null }]);
+});
+
+test("auto provider falls through to Tavily after unavailable earlier providers", async () => {
+	const home = await mkdtemp(join(tmpdir(), "pi-web-access-tavily-auto-"));
+	const child = runChild(`
+		const calls = [];
+		globalThis.fetch = async (url, init = {}) => {
+			const urlText = String(url);
+			calls.push(urlText);
+			if (urlText === "https://mcp.exa.ai/mcp") {
+				return new Response("Exa unavailable", { status: 503 });
+			}
+			if (urlText === "https://api.tavily.com/search") {
+				return new Response(JSON.stringify({
+					answer: "Auto Tavily answer",
+					results: [{ title: "Tavily Auto", url: "https://docs.tavily.com/auto", content: "auto snippet" }],
+				}), { status: 200, headers: { "content-type": "application/json" } });
+			}
+			throw new Error("Unexpected fetch " + urlText);
+		};
+
+		const { search } = await import(${JSON.stringify(searchModuleUrl)});
+		const result = await search("auto tavily docs", { provider: "auto" });
+		console.log(JSON.stringify({ calls, result }));
+	`, {
+		HOME: home,
+		USERPROFILE: home,
+		TAVILY_API_KEY: "tvly-test-key",
+	});
+
+	assert.equal(child.status, 0, child.stderr);
+	const output = JSON.parse(child.stdout.trim());
+	assert.ok(output.calls.includes("https://mcp.exa.ai/mcp"));
+	assert.ok(output.calls.includes("https://api.tavily.com/search"));
+	assert.equal(output.result.provider, "tavily");
+	assert.equal(output.result.answer, "Auto Tavily answer");
+});
+
+test("Exa direct API key ignores full legacy usage counter", async () => {
+	const home = await mkdtemp(join(tmpdir(), "pi-web-access-exa-paid-"));
+	const child = runChild(`
+		const dir = ${JSON.stringify(home)};
+		const { readFileSync, writeFileSync } = await import("node:fs");
+		writeFileSync(dir + "/web-search.json", JSON.stringify({ exaApiKey: "exa-paid-key" }));
+		writeFileSync(dir + "/exa-usage.json", JSON.stringify({ month: new Date().toISOString().slice(0, 7), count: 1000 }));
+
+		let capturedUrl = "";
+		let capturedHeaders = null;
+		globalThis.fetch = async (url, init) => {
+			capturedUrl = String(url);
+			capturedHeaders = init.headers;
+			return new Response(JSON.stringify({
+				answer: "Paid Exa answer",
+				citations: [{ title: "Exa Docs", url: "https://exa.ai/docs" }],
+			}), { status: 200, headers: { "content-type": "application/json" } });
+		};
+
+		const { isExaAvailable, searchWithExa } = await import(${JSON.stringify(exaModuleUrl)});
+		const available = isExaAvailable();
+		const result = await searchWithExa("paid exa query");
+		const usage = JSON.parse(readFileSync(dir + "/exa-usage.json", "utf8"));
+		console.log(JSON.stringify({
+			available,
+			capturedUrl,
+			apiKey: capturedHeaders["x-api-key"],
+			result,
+			usage,
+		}));
+	`, {
+		HOME: home,
+		USERPROFILE: home,
+		PI_CODING_AGENT_DIR: home,
+	});
+
+	assert.equal(child.status, 0, child.stderr);
+	const output = JSON.parse(child.stdout.trim());
+	assert.equal(output.available, true);
+	assert.equal(output.capturedUrl, "https://api.exa.ai/answer");
+	assert.equal(output.apiKey, "exa-paid-key");
+	assert.equal(output.result.answer, "Paid Exa answer");
+	assert.deepEqual(output.result.results, [{ title: "Exa Docs", url: "https://exa.ai/docs", snippet: "" }]);
+	assert.equal(output.usage.count, 1000);
+});
+
+test("OpenAI search requires web_search and maps domain filters", async () => {
+	const home = await mkdtemp(join(tmpdir(), "pi-web-access-openai-"));
+	const child = runChild(`
+		let capturedUrl = "";
+		let capturedHeaders = null;
+		let capturedBody = null;
+		globalThis.fetch = async (url, init) => {
+			capturedUrl = String(url);
+			capturedHeaders = init.headers;
+			capturedBody = JSON.parse(init.body);
+			return new Response(JSON.stringify({
+				output: [
+					{
+						type: "web_search_call",
+						action: { sources: [{ title: "OpenAI Blog", url: "https://openai.com/blog?utm_source=openai" }] },
+					},
+					{
+						type: "message",
+						content: [{
+							type: "output_text",
+							text: "Answer from the web",
+							annotations: [{
+								type: "url_citation",
+								start_index: 0,
+								end_index: 6,
+								url: "https://openai.com/docs?utm_source=openai",
+								title: "OpenAI Docs",
+							}],
+						}],
+					},
+				],
+			}), { status: 200, headers: { "content-type": "application/json" } });
+		};
+
+		const { searchWithOpenAI } = await import(${JSON.stringify(openaiModuleUrl)});
+		const result = await searchWithOpenAI("latest docs", {
+			domainFilter: ["https://openai.com/docs", "-reddit.com"],
+			numResults: 3,
+		});
+		console.log(JSON.stringify({
+			url: capturedUrl,
+			authorization: capturedHeaders.Authorization,
+			body: capturedBody,
+			results: result.results,
+			answer: result.answer,
+		}));
+	`, {
+		HOME: home,
+		USERPROFILE: home,
+		OPENAI_API_KEY: "sk-test-key",
+	});
+
+	assert.equal(child.status, 0, child.stderr);
+	const output = JSON.parse(child.stdout.trim());
+	assert.equal(output.url, "https://api.openai.com/v1/responses");
+	assert.equal(output.authorization, "Bearer sk-test-key");
+	assert.equal(output.body.tool_choice, "required");
+	assert.deepEqual(output.body.include, ["web_search_call.action.sources"]);
+	assert.deepEqual(output.body.tools[0].filters, {
+		allowed_domains: ["openai.com"],
+		blocked_domains: ["reddit.com"],
+	});
+	assert.equal(output.answer, "Answer from the web");
+	assert.deepEqual(output.results.map((result) => result.url), [
+		"https://openai.com/docs",
+		"https://openai.com/blog",
+	]);
+});

package/node_modules/pi-web-access/test/ssrf-allow-ranges-config.test.mjs

@@ -0,0 +1,111 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+const extractUrl = new URL("../extract.ts", import.meta.url).href;
+
+// `loadSsrfAllowRanges` reads the config path captured at module load, so each
+// case runs in a child process with PI_CODING_AGENT_DIR pointed at a temp dir.
+function runLoad(env) {
+	const childEnv = { ...process.env };
+	delete childEnv.PI_CODING_AGENT_DIR;
+	delete childEnv.XDG_CONFIG_HOME;
+	for (const [key, value] of Object.entries(env)) {
+		if (value === undefined) delete childEnv[key];
+		else childEnv[key] = value;
+	}
+	const script = `
+		const { loadSsrfAllowRanges } = await import(${JSON.stringify(extractUrl)});
+		try {
+			console.log(JSON.stringify({ ok: true, ranges: loadSsrfAllowRanges() }));
+		} catch (err) {
+			console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+		}
+	`;
+	const child = spawnSync(process.execPath, ["--input-type=module"], {
+		input: script,
+		encoding: "utf8",
+		env: childEnv,
+	});
+	assert.equal(child.status, 0, child.stderr);
+	return JSON.parse(child.stdout);
+}
+
+async function makeConfigDir(prefix) {
+	const root = await mkdtemp(join(tmpdir(), prefix));
+	const agentDir = join(root, "agent-dir");
+	await mkdir(agentDir, { recursive: true });
+	return { root, agentDir, configPath: join(agentDir, "web-search.json") };
+}
+
+function envFor(root, agentDir) {
+	return {
+		PI_CODING_AGENT_DIR: agentDir,
+		HOME: join(root, "home"),
+		USERPROFILE: join(root, "home"),
+	};
+}
+
+test("loadSsrfAllowRanges throws when ssrf.allowRanges is not an array", async () => {
+	// Regression: a mistyped non-array value (bare string, object, number) must
+	// fail loudly instead of being silently ignored as "no exemptions".
+	for (const allowRanges of ["198.18.0.0/15", { "198.18.0.0/15": true }, 42]) {
+		const { root, agentDir, configPath } = await makeConfigDir("pi-ssrf-nonarray-");
+		await writeFile(configPath, JSON.stringify({ ssrf: { allowRanges } }), "utf8");
+
+		const result = runLoad(envFor(root, agentDir));
+		assert.equal(result.ok, false, `expected throw for ${JSON.stringify(allowRanges)}`);
+		assert.match(result.error, /ssrf\.allowRanges in .* must be an array of CIDR strings/);
+	}
+});
+
+test("loadSsrfAllowRanges throws when an ssrf.allowRanges entry is not a string", async () => {
+	const { root, agentDir, configPath } = await makeConfigDir("pi-ssrf-entry-type-");
+	await writeFile(configPath, JSON.stringify({ ssrf: { allowRanges: ["198.18.0.0/15", 123] } }), "utf8");
+
+	const result = runLoad(envFor(root, agentDir));
+	assert.equal(result.ok, false);
+	assert.match(result.error, /ssrf\.allowRanges in .* must contain only CIDR strings; entry 2 is number/);
+});
+
+test("loadSsrfAllowRanges returns trimmed, non-empty CIDR strings for a valid array", async () => {
+	const { root, agentDir, configPath } = await makeConfigDir("pi-ssrf-valid-");
+	await writeFile(
+		configPath,
+		JSON.stringify({ ssrf: { allowRanges: ["198.18.0.0/15", "  fd00::/8  ", "", "   "] } }),
+		"utf8",
+	);
+
+	const result = runLoad(envFor(root, agentDir));
+	assert.equal(result.ok, true, result.error);
+	assert.deepEqual(result.ranges, ["198.18.0.0/15", "fd00::/8"]);
+});
+
+test("loadSsrfAllowRanges returns [] when the config file is missing", async () => {
+	const { root, agentDir } = await makeConfigDir("pi-ssrf-missing-");
+	// Intentionally do not write web-search.json.
+	const result = runLoad(envFor(root, agentDir));
+	assert.equal(result.ok, true, result.error);
+	assert.deepEqual(result.ranges, []);
+});
+
+test("loadSsrfAllowRanges returns [] when ssrf.allowRanges is unset", async () => {
+	const { root, agentDir, configPath } = await makeConfigDir("pi-ssrf-unset-");
+	await writeFile(configPath, JSON.stringify({ perplexityApiKey: "pplx-x" }), "utf8");
+
+	const result = runLoad(envFor(root, agentDir));
+	assert.equal(result.ok, true, result.error);
+	assert.deepEqual(result.ranges, []);
+});
+
+test("loadSsrfAllowRanges fails safe with [] when the config JSON is invalid", async () => {
+	const { root, agentDir, configPath } = await makeConfigDir("pi-ssrf-badjson-");
+	await writeFile(configPath, "{ not valid json", "utf8");
+
+	const result = runLoad(envFor(root, agentDir));
+	assert.equal(result.ok, true, result.error);
+	assert.deepEqual(result.ranges, []);
+});