@asterxsk/kiln 0.1.0

package/agent/extensions/pi-web-access/test/tool-registration-config.test.mjs

@@ -0,0 +1,182 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { Value } from "typebox/value";
+
+import initializeExtension from "../index.ts";
+
+const indexUrl = new URL("../index.ts", import.meta.url).href;
+const indexSrc = readFileSync(new URL("../index.ts", import.meta.url), "utf8");
+const readmeSrc = readFileSync(new URL("../README.md", import.meta.url), "utf8");
+
+function runRegistration(config) {
+	return runRegistrationWithConfig(JSON.stringify(config) + "\n");
+}
+
+function runRegistrationWithConfig(configText) {
+	const root = mkdtempSync(join(tmpdir(), "pi-web-access-tool-names-"));
+	writeFileSync(join(root, "web-search.json"), configText, "utf8");
+	return spawnSync(process.execPath, ["--input-type=module"], {
+		input: `
+			const { default: initializeExtension } = await import(${JSON.stringify(indexUrl)});
+			const tools = [];
+			const commands = [];
+			initializeExtension({
+				registerTool(tool) { tools.push({ name: tool.name, description: tool.description, promptSnippet: tool.promptSnippet, parameters: tool.parameters }); },
+				registerCommand(name) { commands.push(name); },
+				registerShortcut() {},
+				on() {},
+			});
+			console.log(JSON.stringify({ tools, commands }));
+		`,
+		encoding: "utf8",
+		env: { ...process.env, PI_CODING_AGENT_DIR: root, XDG_CONFIG_HOME: "", HOME: join(root, "home"), USERPROFILE: join(root, "home") },
+	});
+}
+
+function registered(config) {
+	const child = runRegistration(config);
+	assert.equal(child.status, 0, child.stderr);
+	return JSON.parse(child.stdout);
+}
+
+function registeredToolNames(config) {
+	return registered(config).tools.map(tool => tool.name);
+}
+
+function registeredTool(config, name) {
+	return registered(config).tools.find(tool => tool.name === name);
+}
+
+function registeredCommandNames(config) {
+	return registered(config).commands;
+}
+
+function registrationError(config) {
+	const child = runRegistration(config);
+	assert.notEqual(child.status, 0, child.stdout);
+	return child.stderr;
+}
+
+test("malformed config falls back during extension registration", () => {
+	const child = runRegistrationWithConfig("{");
+	assert.equal(child.status, 0, child.stderr);
+	const registered = JSON.parse(child.stdout);
+	assert.deepEqual(registered.tools.map(tool => tool.name), ["web_search", "source_check", "fetch_content", "get_search_content"]);
+});
+
+test("search tools constrain numResults to integer values from 1 through 20", () => {
+	for (const name of ["web_search", "source_check"]) {
+		const schema = registeredTool({}, name).parameters.properties.numResults;
+		assert.equal(schema.type, "integer");
+		assert.equal(schema.minimum, 1);
+		assert.equal(schema.maximum, 20);
+		for (const value of [0, -1, 1.5, 21, Number.NaN, Number.POSITIVE_INFINITY]) {
+			assert.equal(Value.Check(schema, value), false, `${name} accepts ${value}`);
+		}
+		for (const value of [1, 5, 20]) {
+			assert.equal(Value.Check(schema, value), true, `${name} rejects ${value}`);
+		}
+	}
+});
+
+test("tool registration gates support legacy and per-tool config", () => {
+	assert.deepEqual(registeredToolNames({ webSearch: { enabled: false } }), ["fetch_content", "get_search_content"]);
+	assert.deepEqual(registeredToolNames({
+		webSearch: { enabled: false },
+		tools: { webSearch: { enabled: true }, sourceCheck: { enabled: true }, fetchContent: { enabled: false } },
+	}), ["web_search", "source_check", "get_search_content"]);
+	assert.deepEqual(registeredToolNames({
+		tools: { sourceCheck: { enabled: false }, getSearchContent: { enabled: false } },
+	}), ["web_search", "fetch_content"]);
+});
+
+test("command registration gates default to enabled", () => {
+	assert.deepEqual(registeredCommandNames({}), ["google-account", "search"]);
+	assert.deepEqual(registeredCommandNames({
+		commands: { websearch: { enabled: false }, search: { enabled: false } },
+	}), ["google-account"]);
+});
+
+test("fetch_content schema exposes auth profile opt-in", () => {
+	const schema = registeredTool({}, "fetch_content").parameters.properties.auth;
+	assert.ok(schema);
+	assert.deepEqual(schema.anyOf.map(option => option.type), ["string", "boolean"]);
+});
+
+test("registered tools do not advertise disabled get_search_content", () => {
+	const fetchTool = registeredTool({ tools: { getSearchContent: { enabled: false } } }, "fetch_content");
+	assert.ok(fetchTool);
+	assert.doesNotMatch(fetchTool.description, /get_search_content/);
+	assert.match(fetchTool.description, /retrieval tool is not registered/);
+});
+
+test("web activity shortcut renders through the supported string-array API", async () => {
+	const shortcuts = [];
+	initializeExtension({
+		registerTool() {},
+		registerCommand() {},
+		registerShortcut(name, shortcut) { shortcuts.push({ name, shortcut }); },
+		on() {},
+	});
+
+	const activityShortcut = shortcuts.find(({ shortcut }) => shortcut.description === "Toggle web search activity");
+	assert.ok(activityShortcut, "activity shortcut was not registered");
+	const widgets = [];
+	const ctx = {
+		ui: {
+			theme: { fg: (_color, text) => text },
+			setWidget(key, content) { widgets.push({ key, content }); },
+		},
+	};
+
+	await activityShortcut.shortcut.handler(ctx);
+	assert.equal(widgets[0].key, "web-activity");
+	assert.ok(Array.isArray(widgets[0].content), "activity widget content must be a string array");
+	assert.ok(widgets[0].content.length > 0);
+
+	await activityShortcut.shortcut.handler(ctx);
+});
+
+test("tool names can be configured without changing defaults", () => {
+	assert.deepEqual(registeredToolNames({}), ["web_search", "source_check", "fetch_content", "get_search_content"]);
+	assert.deepEqual(registeredToolNames({
+		toolNames: {
+			webSearch: "research_web",
+			sourceCheck: "verify_sources",
+			fetchContent: "grab_content",
+			getSearchContent: "open_content",
+		},
+	}), ["research_web", "verify_sources", "grab_content", "open_content"]);
+});
+
+test("tool name config rejects invalid and duplicate registered names", () => {
+	assert.match(registrationError({ toolNames: { webSearch: "1bad" } }), /toolNames\.webSearch/);
+	assert.match(registrationError({ toolNames: { webSearch: "same_name", fetchContent: "same_name" } }), /duplicates/);
+});
+
+test("webSearch.enabled false registers only fetch tools and ignores disabled-name duplicates", () => {
+	assert.deepEqual(registeredToolNames({
+		webSearch: { enabled: false },
+		toolNames: {
+			webSearch: "content_only",
+			sourceCheck: "content_only",
+			fetchContent: "grab_content",
+			getSearchContent: "open_content",
+		},
+	}), ["grab_content", "open_content"]);
+	assert.match(registrationError({
+		webSearch: { enabled: false },
+		toolNames: { fetchContent: "same_name", getSearchContent: "same_name" },
+	}), /duplicates/);
+});
+
+test("README documents registration gates and toolNames", () => {
+	assert.match(readmeSrc, /"tools": \{/);
+	assert.match(readmeSrc, /"commands": \{/);
+	assert.match(readmeSrc, /Pi restart is required for tool and command registration changes/);
+	assert.match(readmeSrc, /`toolNames` can opt into alternate public tool names/);
+});

package/agent/extensions/pi-web-access/test/web-search-answer-render.test.mjs

@@ -0,0 +1,66 @@
+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 indexUrl = new URL("../index.ts", import.meta.url).href;
+
+function runChild(script, env) {
+	const childEnv = { ...process.env };
+	for (const key of [
+		"PI_CODING_AGENT_DIR",
+		"XDG_CONFIG_HOME",
+		"EXA_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("web_search preserves Exa answers even when no sources are returned", async () => {
+	const home = await mkdtemp(join(tmpdir(), "pi-web-access-exa-answer-"));
+	const child = runChild(`
+		globalThis.fetch = async () => new Response(JSON.stringify({
+			answer: "Direct answer without citations.",
+			citations: [],
+		}), { status: 200, headers: { "content-type": "application/json" } });
+
+		const { default: initializeExtension } = await import(${JSON.stringify(indexUrl)});
+		const tools = [];
+		initializeExtension({
+			registerTool(tool) { tools.push(tool); },
+			registerCommand() {},
+			registerShortcut() {},
+			on() {},
+			appendEntry() {},
+			sendMessage() {},
+			exec() { return { code: 0 }; },
+		});
+		const webSearch = tools.find((tool) => tool.name === "web_search");
+		const result = await webSearch.execute("call", {
+			query: "answer only",
+		});
+		console.log(JSON.stringify({ text: result.content[0].text, details: result.details }));
+	`, {
+		HOME: home,
+		USERPROFILE: home,
+		PI_CODING_AGENT_DIR: home,
+		EXA_API_KEY: "exa-test-key",
+	});
+
+	assert.equal(child.status, 0, child.stderr);
+	const output = JSON.parse(child.stdout.trim());
+	assert.match(output.text, /Direct answer without citations\./);
+	assert.match(output.text, /No sources returned\./);
+	assert.doesNotMatch(output.text, /No results found/);
+	assert.equal(output.details.successfulQueries, 1);
+	assert.equal(output.details.totalResults, 0);
+});

package/agent/extensions/pi-web-access/test/youtube-extract-errors.test.mjs

@@ -0,0 +1,64 @@
+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 extractorUrl = new URL("../extract.ts", import.meta.url).href;
+
+test("YouTube extraction surfaces Gemini API errors", async () => {
+	const home = await mkdtemp(join(tmpdir(), "pi-web-access-youtube-errors-"));
+	const env = {
+		...process.env,
+		HOME: home,
+		USERPROFILE: home,
+		GEMINI_API_KEY: "test-gemini-key",
+		PERPLEXITY_API_KEY: "",
+	};
+	delete env.PI_ALLOW_BROWSER_COOKIES;
+	delete env.FEYNMAN_ALLOW_BROWSER_COOKIES;
+
+	const child = spawnSync(process.execPath, ["--input-type=module"], {
+		input: buildChildScript(extractorUrl),
+		encoding: "utf8",
+		env,
+	});
+
+	assert.equal(child.status, 0, child.stderr || child.stdout);
+	const result = JSON.parse(child.stdout);
+	assert.match(result.error, /Gemini API error 503/);
+	assert.doesNotMatch(result.error, /Sign into Google in a supported Chromium browser/);
+});
+
+function buildChildScript(moduleUrl) {
+	return `
+		process.on("uncaughtException", (error) => {
+			console.error(error?.stack || error);
+			process.exit(1);
+		});
+		process.on("unhandledRejection", (error) => {
+			console.error(error?.stack || error);
+			process.exit(1);
+		});
+
+		globalThis.fetch = async (input) => {
+			const url = String(input);
+			if (url.startsWith("https://generativelanguage.googleapis.com/")) {
+				return new Response(JSON.stringify({ error: { message: "model overloaded" } }), {
+					status: 503,
+					statusText: "Service Unavailable",
+					headers: { "content-type": "application/json" },
+				});
+			}
+			throw new Error("Unexpected fetch: " + url);
+		};
+
+		const { extractContent } = await import(${JSON.stringify(moduleUrl)});
+		// Inject DNS so SSRF validation never depends on real resolution (which a
+		// local fake-IP/TUN proxy would map into a blocked reserved range).
+		const lookup = async () => [{ address: "93.184.216.34", family: 4 }];
+		const result = await extractContent("https://www.youtube.com/watch?v=dQw4w9WgXcQ", undefined, { lookup });
+		console.log(JSON.stringify(result));
+	`;
+}

package/agent/extensions/pi-web-access/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "allowImportingTsExtensions": true,
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "noEmit": true,
+    "skipLibCheck": true,
+    "target": "ES2022"
+  },
+  "include": ["*.ts"]
+}