@asterxsk/kiln 0.3.0 → 0.4.0

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

@@ -1,182 +0,0 @@
-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.bak.20260905-190020/extensions/pi-web-access/test/web-search-answer-render.test.mjs

@@ -1,66 +0,0 @@
-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.bak.20260905-190020/extensions/pi-web-access/test/youtube-extract-errors.test.mjs

@@ -1,64 +0,0 @@
-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.bak.20260905-190020/extensions/pi-web-access/tsconfig.json

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