@asterxsk/kiln 0.4.0 → 0.4.2

package/agent/extensions/pi-web-access/test/inline-content-config.test.mjs

@@ -1,99 +1,99 @@
-import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
-import { mkdtemp, writeFile } 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;
-const storageUrl = new URL("../storage.ts", import.meta.url).href;
-
-async function runScenario(maxInlineContentChars) {
-	const agentDir = await mkdtemp(join(tmpdir(), "pi-web-access-inline-content-"));
-	if (maxInlineContentChars !== undefined) {
-		await writeFile(join(agentDir, "web-search.json"), JSON.stringify({ maxInlineContentChars }) + "\n", "utf8");
-	}
-	const child = spawnSync(process.execPath, ["--input-type=module"], {
-		input: `
-			import initializeExtension from ${JSON.stringify(indexUrl)};
-			import { clearResults } from ${JSON.stringify(storageUrl)};
-			clearResults();
-			globalThis.fetch = async () => new Response("A".repeat(40000) + "TAIL", {
-				status: 200,
-				headers: { "content-type": "text/plain" },
-			});
-			const tools = [];
-			initializeExtension({ registerTool(tool) { tools.push(tool); }, registerCommand() {}, registerShortcut() {}, on() {}, appendEntry() {} });
-			const fetchTool = tools.find(tool => tool.name === "fetch_content");
-			const contentTool = tools.find(tool => tool.name === "get_search_content");
-			const fetched = await fetchTool.execute("call", { url: "https://93.184.216.34/page" });
-			const retrieved = await contentTool.execute("call", { responseId: fetched.details.responseId, urlIndex: 0 });
-			const tail = await contentTool.execute("call", { responseId: fetched.details.responseId, urlIndex: 0, offset: 40000, limit: 4 });
-			const rejected = await contentTool.execute("call", { responseId: fetched.details.responseId, urlIndex: 0, limit: ${maxInlineContentChars === undefined ? 30_001 : maxInlineContentChars + 1} });
-			console.log(JSON.stringify({
-				schemaMax: contentTool.parameters.properties.limit.maximum,
-				fetchTruncated: fetched.details.truncated,
-				fetchEndOffset: fetched.content.find(item => item.type === "text").text.indexOf("\\n\\n---"),
-				retrievedChars: retrieved.details.returnedChars,
-				retrievedNextOffset: retrieved.details.nextOffset,
-				tail: tail.content[0].text.includes("TAIL"),
-				rejectedMax: rejected.details.maxLimit,
-			}));
-		`,
-		encoding: "utf8",
-		env: { ...process.env, PI_CODING_AGENT_DIR: agentDir, XDG_CONFIG_HOME: undefined },
-	});
-	assert.equal(child.status, 0, child.stderr);
-	return JSON.parse(child.stdout);
-}
-
-test("inline content defaults to 30,000 characters", async () => {
-	const result = await runScenario();
-	assert.deepEqual(result, {
-		schemaMax: 30_000,
-		fetchTruncated: true,
-		fetchEndOffset: 30_000,
-		retrievedChars: 30_000,
-		retrievedNextOffset: 30_000,
-		tail: true,
-		rejectedMax: 30_000,
-	});
-});
-
-test("maxInlineContentChars applies to direct and stored content slices", async () => {
-	const result = await runScenario(40_000);
-	assert.deepEqual(result, {
-		schemaMax: 40_000,
-		fetchTruncated: true,
-		fetchEndOffset: 40_000,
-		retrievedChars: 40_000,
-		retrievedNextOffset: 40_000,
-		tail: true,
-		rejectedMax: 40_000,
-	});
-});
-
-test("stored content schema and execution keep one registered limit", async () => {
-	const agentDir = await mkdtemp(join(tmpdir(), "pi-web-access-inline-content-"));
-	await writeFile(join(agentDir, "web-search.json"), JSON.stringify({ maxInlineContentChars: 40_000 }) + "\n", "utf8");
-	const child = spawnSync(process.execPath, ["--input-type=module"], {
-		input: `
-			import initializeExtension from ${JSON.stringify(indexUrl)};
-			import { storeResult, clearResults } from ${JSON.stringify(storageUrl)};
-			import { writeFile } from "node:fs/promises";
-			import { join } from "node:path";
-			clearResults();
-			const tools = [];
-			initializeExtension({ registerTool(tool) { tools.push(tool); }, registerCommand() {}, registerShortcut() {}, on() {}, appendEntry() {} });
-			await writeFile(join(process.env.PI_CODING_AGENT_DIR, "web-search.json"), JSON.stringify({ maxInlineContentChars: 20_000 }) + "\\n", "utf8");
-			storeResult("stored", { id: "stored", type: "fetch", timestamp: Date.now(), urls: [{ url: "https://example.test", title: "Stored", content: "A".repeat(50_000), error: null }] });
-			const contentTool = tools.find(tool => tool.name === "get_search_content");
-			const rejected = await contentTool.execute("call", { responseId: "stored", urlIndex: 0, limit: 40_001 });
-			console.log(JSON.stringify({ schemaMax: contentTool.parameters.properties.limit.maximum, rejectedMax: rejected.details.maxLimit }));
-		`,
-		encoding: "utf8",
-		env: { ...process.env, PI_CODING_AGENT_DIR: agentDir, XDG_CONFIG_HOME: undefined },
-	});
-	assert.equal(child.status, 0, child.stderr);
-	assert.deepEqual(JSON.parse(child.stdout), { schemaMax: 40_000, rejectedMax: 40_000 });
-});
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtemp, writeFile } 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;
+const storageUrl = new URL("../storage.ts", import.meta.url).href;
+
+async function runScenario(maxInlineContentChars) {
+	const agentDir = await mkdtemp(join(tmpdir(), "pi-web-access-inline-content-"));
+	if (maxInlineContentChars !== undefined) {
+		await writeFile(join(agentDir, "web-search.json"), JSON.stringify({ maxInlineContentChars }) + "\n", "utf8");
+	}
+	const child = spawnSync(process.execPath, ["--input-type=module"], {
+		input: `
+			import initializeExtension from ${JSON.stringify(indexUrl)};
+			import { clearResults } from ${JSON.stringify(storageUrl)};
+			clearResults();
+			globalThis.fetch = async () => new Response("A".repeat(40000) + "TAIL", {
+				status: 200,
+				headers: { "content-type": "text/plain" },
+			});
+			const tools = [];
+			initializeExtension({ registerTool(tool) { tools.push(tool); }, registerCommand() {}, registerShortcut() {}, on() {}, appendEntry() {} });
+			const fetchTool = tools.find(tool => tool.name === "fetch_content");
+			const contentTool = tools.find(tool => tool.name === "get_search_content");
+			const fetched = await fetchTool.execute("call", { url: "https://93.184.216.34/page" });
+			const retrieved = await contentTool.execute("call", { responseId: fetched.details.responseId, urlIndex: 0 });
+			const tail = await contentTool.execute("call", { responseId: fetched.details.responseId, urlIndex: 0, offset: 40000, limit: 4 });
+			const rejected = await contentTool.execute("call", { responseId: fetched.details.responseId, urlIndex: 0, limit: ${maxInlineContentChars === undefined ? 30_001 : maxInlineContentChars + 1} });
+			console.log(JSON.stringify({
+				schemaMax: contentTool.parameters.properties.limit.maximum,
+				fetchTruncated: fetched.details.truncated,
+				fetchEndOffset: fetched.content.find(item => item.type === "text").text.indexOf("\\n\\n---"),
+				retrievedChars: retrieved.details.returnedChars,
+				retrievedNextOffset: retrieved.details.nextOffset,
+				tail: tail.content[0].text.includes("TAIL"),
+				rejectedMax: rejected.details.maxLimit,
+			}));
+		`,
+		encoding: "utf8",
+		env: { ...process.env, PI_CODING_AGENT_DIR: agentDir, XDG_CONFIG_HOME: undefined },
+	});
+	assert.equal(child.status, 0, child.stderr);
+	return JSON.parse(child.stdout);
+}
+
+test("inline content defaults to 30,000 characters", async () => {
+	const result = await runScenario();
+	assert.deepEqual(result, {
+		schemaMax: 30_000,
+		fetchTruncated: true,
+		fetchEndOffset: 30_000,
+		retrievedChars: 30_000,
+		retrievedNextOffset: 30_000,
+		tail: true,
+		rejectedMax: 30_000,
+	});
+});
+
+test("maxInlineContentChars applies to direct and stored content slices", async () => {
+	const result = await runScenario(40_000);
+	assert.deepEqual(result, {
+		schemaMax: 40_000,
+		fetchTruncated: true,
+		fetchEndOffset: 40_000,
+		retrievedChars: 40_000,
+		retrievedNextOffset: 40_000,
+		tail: true,
+		rejectedMax: 40_000,
+	});
+});
+
+test("stored content schema and execution keep one registered limit", async () => {
+	const agentDir = await mkdtemp(join(tmpdir(), "pi-web-access-inline-content-"));
+	await writeFile(join(agentDir, "web-search.json"), JSON.stringify({ maxInlineContentChars: 40_000 }) + "\n", "utf8");
+	const child = spawnSync(process.execPath, ["--input-type=module"], {
+		input: `
+			import initializeExtension from ${JSON.stringify(indexUrl)};
+			import { storeResult, clearResults } from ${JSON.stringify(storageUrl)};
+			import { writeFile } from "node:fs/promises";
+			import { join } from "node:path";
+			clearResults();
+			const tools = [];
+			initializeExtension({ registerTool(tool) { tools.push(tool); }, registerCommand() {}, registerShortcut() {}, on() {}, appendEntry() {} });
+			await writeFile(join(process.env.PI_CODING_AGENT_DIR, "web-search.json"), JSON.stringify({ maxInlineContentChars: 20_000 }) + "\\n", "utf8");
+			storeResult("stored", { id: "stored", type: "fetch", timestamp: Date.now(), urls: [{ url: "https://example.test", title: "Stored", content: "A".repeat(50_000), error: null }] });
+			const contentTool = tools.find(tool => tool.name === "get_search_content");
+			const rejected = await contentTool.execute("call", { responseId: "stored", urlIndex: 0, limit: 40_001 });
+			console.log(JSON.stringify({ schemaMax: contentTool.parameters.properties.limit.maximum, rejectedMax: rejected.details.maxLimit }));
+		`,
+		encoding: "utf8",
+		env: { ...process.env, PI_CODING_AGENT_DIR: agentDir, XDG_CONFIG_HOME: undefined },
+	});
+	assert.equal(child.status, 0, child.stderr);
+	assert.deepEqual(JSON.parse(child.stdout), { schemaMax: 40_000, rejectedMax: 40_000 });
+});

package/agent/extensions/pi-web-access/test/lazy-extract-load.test.mjs

@@ -1,118 +1,118 @@
-import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
-import { test } from "node:test";
-
-const indexUrl = new URL("../index.ts", import.meta.url).href;
-
-test("registers eagerly and loads content extraction on first use", () => {
-	const child = spawnSync(process.execPath, ["--input-type=module"], {
-		input: buildChildScript(indexUrl),
-		encoding: "utf8",
-		maxBuffer: 2 * 1024 * 1024,
-		timeout: 30_000,
-	});
-
-	assert.equal(
-		child.status,
-		0,
-		"Lazy extraction regression child failed:\n" + errorSummary(child.stderr),
-	);
-});
-
-function buildChildScript(moduleUrl) {
-	return `
-		import assert from "node:assert/strict";
-		import { existsSync } from "node:fs";
-		import { mkdtemp, writeFile } from "node:fs/promises";
-		import { createServer } from "node:http";
-		import { register } from "node:module";
-		import { tmpdir } from "node:os";
-		import { join } from "node:path";
-
-		const tempDir = await mkdtemp(join(tmpdir(), "pi-web-access-lazy-"));
-		const markerPath = join(tempDir, "extract-loaded");
-		process.env.PI_CODING_AGENT_DIR = tempDir;
-		await writeFile(
-			join(tempDir, "web-search.json"),
-			JSON.stringify({ ssrf: { allowRanges: ["127.0.0.0/8"] } }),
-		);
-
-		const hookSource = \`
-			import { appendFileSync } from "node:fs";
-			let markerPath;
-			export function initialize(data) { markerPath = data.markerPath; }
-			export async function load(url, context, nextLoad) {
-				if (new URL(url).pathname.endsWith("/extract.ts")) {
-					appendFileSync(markerPath, url + "\\\\n");
-				}
-				return nextLoad(url, context);
-			}
-		\`;
-		register("data:text/javascript," + encodeURIComponent(hookSource), {
-			parentURL: import.meta.url,
-			data: { markerPath },
-		});
-
-		const { default: initializeExtension } = await import(${JSON.stringify(moduleUrl)});
-		assert.equal(existsSync(markerPath), false, "extract.ts loaded during extension import");
-
-		const tools = [];
-		const commands = [];
-		const shortcuts = [];
-		const events = [];
-		const pi = new Proxy({}, {
-			get(_target, property) {
-				if (property === "registerTool") return (tool) => tools.push(tool);
-				if (property === "registerCommand") return (name) => commands.push(name);
-				if (property === "registerShortcut") return (name) => shortcuts.push(name);
-				if (property === "on") return (name) => events.push(name);
-				return () => {};
-			},
-		});
-
-		initializeExtension(pi);
-		assert.deepEqual(
-			tools.map((tool) => tool.name),
-			["web_search", "source_check", "fetch_content", "get_search_content"],
-		);
-		assert.ok(commands.includes("google-account"), "google-account command was not registered");
-		assert.ok(shortcuts.length > 0, "shortcuts were not registered");
-		assert.ok(events.includes("session_start"), "session handlers were not registered");
-		assert.equal(existsSync(markerPath), false, "extract.ts loaded during registration");
-
-		const articleText = "Lazy loading keeps extension startup responsive while preserving first-use extraction. ";
-		const html = \`<!doctype html><html><head><title>Lazy extraction</title></head><body>
-			<article><h1>Lazy extraction works</h1><p>\${articleText.repeat(20)}</p></article>
-		</body></html>\`;
-		const server = createServer((_request, response) => {
-			response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
-			response.end(html);
-		});
-		await new Promise((resolve, reject) => {
-			server.once("error", reject);
-			server.listen(0, "127.0.0.1", resolve);
-		});
-
-		try {
-			const address = server.address();
-			assert.ok(address && typeof address === "object");
-			const fetchTool = tools.find((tool) => tool.name === "fetch_content");
-			const result = await fetchTool.execute(
-				"lazy-load-regression",
-				{ url: \`http://127.0.0.1:\${address.port}/article\` },
-				undefined,
-				() => {},
-			);
-
-			assert.equal(existsSync(markerPath), true, "extract.ts did not load on first use");
-			assert.equal(result.details.successful, 1);
-			assert.match(result.content.at(-1).text, /preserving first-use extraction/);
-		} finally {
-			await new Promise((resolve) => server.close(resolve));
-		}
-	`;
-}
-
-function errorSummary(value, size = 2000) {
-	return value.length > size ? value.slice(-size) : value;
-}
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { test } from "node:test";
+
+const indexUrl = new URL("../index.ts", import.meta.url).href;
+
+test("registers eagerly and loads content extraction on first use", () => {
+	const child = spawnSync(process.execPath, ["--input-type=module"], {
+		input: buildChildScript(indexUrl),
+		encoding: "utf8",
+		maxBuffer: 2 * 1024 * 1024,
+		timeout: 30_000,
+	});
+
+	assert.equal(
+		child.status,
+		0,
+		"Lazy extraction regression child failed:\n" + errorSummary(child.stderr),
+	);
+});
+
+function buildChildScript(moduleUrl) {
+	return `
+		import assert from "node:assert/strict";
+		import { existsSync } from "node:fs";
+		import { mkdtemp, writeFile } from "node:fs/promises";
+		import { createServer } from "node:http";
+		import { register } from "node:module";
+		import { tmpdir } from "node:os";
+		import { join } from "node:path";
+
+		const tempDir = await mkdtemp(join(tmpdir(), "pi-web-access-lazy-"));
+		const markerPath = join(tempDir, "extract-loaded");
+		process.env.PI_CODING_AGENT_DIR = tempDir;
+		await writeFile(
+			join(tempDir, "web-search.json"),
+			JSON.stringify({ ssrf: { allowRanges: ["127.0.0.0/8"] } }),
+		);
+
+		const hookSource = \`
+			import { appendFileSync } from "node:fs";
+			let markerPath;
+			export function initialize(data) { markerPath = data.markerPath; }
+			export async function load(url, context, nextLoad) {
+				if (new URL(url).pathname.endsWith("/extract.ts")) {
+					appendFileSync(markerPath, url + "\\\\n");
+				}
+				return nextLoad(url, context);
+			}
+		\`;
+		register("data:text/javascript," + encodeURIComponent(hookSource), {
+			parentURL: import.meta.url,
+			data: { markerPath },
+		});
+
+		const { default: initializeExtension } = await import(${JSON.stringify(moduleUrl)});
+		assert.equal(existsSync(markerPath), false, "extract.ts loaded during extension import");
+
+		const tools = [];
+		const commands = [];
+		const shortcuts = [];
+		const events = [];
+		const pi = new Proxy({}, {
+			get(_target, property) {
+				if (property === "registerTool") return (tool) => tools.push(tool);
+				if (property === "registerCommand") return (name) => commands.push(name);
+				if (property === "registerShortcut") return (name) => shortcuts.push(name);
+				if (property === "on") return (name) => events.push(name);
+				return () => {};
+			},
+		});
+
+		initializeExtension(pi);
+		assert.deepEqual(
+			tools.map((tool) => tool.name),
+			["web_search", "source_check", "fetch_content", "get_search_content"],
+		);
+		assert.ok(commands.includes("google-account"), "google-account command was not registered");
+		assert.ok(shortcuts.length > 0, "shortcuts were not registered");
+		assert.ok(events.includes("session_start"), "session handlers were not registered");
+		assert.equal(existsSync(markerPath), false, "extract.ts loaded during registration");
+
+		const articleText = "Lazy loading keeps extension startup responsive while preserving first-use extraction. ";
+		const html = \`<!doctype html><html><head><title>Lazy extraction</title></head><body>
+			<article><h1>Lazy extraction works</h1><p>\${articleText.repeat(20)}</p></article>
+		</body></html>\`;
+		const server = createServer((_request, response) => {
+			response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+			response.end(html);
+		});
+		await new Promise((resolve, reject) => {
+			server.once("error", reject);
+			server.listen(0, "127.0.0.1", resolve);
+		});
+
+		try {
+			const address = server.address();
+			assert.ok(address && typeof address === "object");
+			const fetchTool = tools.find((tool) => tool.name === "fetch_content");
+			const result = await fetchTool.execute(
+				"lazy-load-regression",
+				{ url: \`http://127.0.0.1:\${address.port}/article\` },
+				undefined,
+				() => {},
+			);
+
+			assert.equal(existsSync(markerPath), true, "extract.ts did not load on first use");
+			assert.equal(result.details.successful, 1);
+			assert.match(result.content.at(-1).text, /preserving first-use extraction/);
+		} finally {
+			await new Promise((resolve) => server.close(resolve));
+		}
+	`;
+}
+
+function errorSummary(value, size = 2000) {
+	return value.length > size ? value.slice(-size) : value;
+}

package/agent/extensions/pi-web-access/test/local-video-oversize.test.mjs

@@ -1,52 +1,52 @@
-import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
-import { mkdtemp, rm, truncate, 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;
-
-async function runOversizeProbe(expression) {
-	const root = await mkdtemp(join(tmpdir(), "pi-web-access-oversize-video-"));
-	const videoPath = join(root, "oversized.mp4");
-	await writeFile(videoPath, "");
-	await truncate(videoPath, 50 * 1024 * 1024 + 1);
-	try {
-		const child = spawnSync(process.execPath, ["--input-type=module"], {
-			input: `
-				process.env.PI_CODING_AGENT_DIR = ${JSON.stringify(root)};
-				const { extractContent } = await import(${JSON.stringify(extractUrl)});
-				const result = await (${expression})(extractContent, ${JSON.stringify(videoPath)});
-				console.log(JSON.stringify({ title: result.title, content: result.content, error: result.error }));
-			`,
-			encoding: "utf8",
-			timeout: 30_000,
-		});
-		assert.equal(child.status, 0, child.stderr);
-		return JSON.parse(child.stdout);
-	} finally {
-		await rm(root, { recursive: true, force: true });
-	}
-}
-
-test("oversized local videos are still recognized for frame extraction", async () => {
-	const result = await runOversizeProbe(`(extractContent, videoPath) => extractContent(videoPath, undefined, { frames: 1 })`);
-
-	assert.notEqual(result.error, "Frame extraction only works with YouTube and local video files");
-	assert.match(result.error, /ffprobe|Cannot determine video duration|failed|not installed/i);
-});
-
-test("oversized local videos are still recognized for timestamp extraction", async () => {
-	const result = await runOversizeProbe(`(extractContent, videoPath) => extractContent(videoPath, undefined, { timestamp: "1" })`);
-
-	assert.notEqual(result.error, "Timestamp extraction only works with YouTube and local video files");
-	assert.match(result.error, /ffmpeg|failed|not installed/i);
-});
-
-test("oversized local video analysis reports the upload size limit", async () => {
-	const result = await runOversizeProbe(`(extractContent, videoPath) => extractContent(videoPath, undefined, { prompt: "summarize" })`);
-
-	assert.match(result.error, /above configured video\.maxSizeMB/);
-	assert.match(result.error, /timestamp\/frames/);
-});
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtemp, rm, truncate, 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;
+
+async function runOversizeProbe(expression) {
+	const root = await mkdtemp(join(tmpdir(), "pi-web-access-oversize-video-"));
+	const videoPath = join(root, "oversized.mp4");
+	await writeFile(videoPath, "");
+	await truncate(videoPath, 50 * 1024 * 1024 + 1);
+	try {
+		const child = spawnSync(process.execPath, ["--input-type=module"], {
+			input: `
+				process.env.PI_CODING_AGENT_DIR = ${JSON.stringify(root)};
+				const { extractContent } = await import(${JSON.stringify(extractUrl)});
+				const result = await (${expression})(extractContent, ${JSON.stringify(videoPath)});
+				console.log(JSON.stringify({ title: result.title, content: result.content, error: result.error }));
+			`,
+			encoding: "utf8",
+			timeout: 30_000,
+		});
+		assert.equal(child.status, 0, child.stderr);
+		return JSON.parse(child.stdout);
+	} finally {
+		await rm(root, { recursive: true, force: true });
+	}
+}
+
+test("oversized local videos are still recognized for frame extraction", async () => {
+	const result = await runOversizeProbe(`(extractContent, videoPath) => extractContent(videoPath, undefined, { frames: 1 })`);
+
+	assert.notEqual(result.error, "Frame extraction only works with YouTube and local video files");
+	assert.match(result.error, /ffprobe|Cannot determine video duration|failed|not installed/i);
+});
+
+test("oversized local videos are still recognized for timestamp extraction", async () => {
+	const result = await runOversizeProbe(`(extractContent, videoPath) => extractContent(videoPath, undefined, { timestamp: "1" })`);
+
+	assert.notEqual(result.error, "Timestamp extraction only works with YouTube and local video files");
+	assert.match(result.error, /ffmpeg|failed|not installed/i);
+});
+
+test("oversized local video analysis reports the upload size limit", async () => {
+	const result = await runOversizeProbe(`(extractContent, videoPath) => extractContent(videoPath, undefined, { prompt: "summarize" })`);
+
+	assert.match(result.error, /above configured video\.maxSizeMB/);
+	assert.match(result.error, /timestamp\/frames/);
+});

package/agent/extensions/pi-web-access/test/package-typebox-dependency.test.mjs

@@ -1,50 +1,50 @@
-import assert from "node:assert/strict";
-import { execFileSync } from "node:child_process";
-import { mkdtemp, rm } from "node:fs/promises";
-import { createRequire } from "node:module";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { test } from "node:test";
-
-// npm ships as a shell script / .cmd wrapper, neither of which is spawnable on
-// Windows (extensionless `npm` does not resolve, `.cmd` is refused without a
-// shell). There, invoke its CLI entry through the current node binary instead.
-const NPM_BIN = process.platform === "win32" ? process.execPath : "npm";
-const NPM_PREFIX = process.platform === "win32"
-	? [join(dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js")]
-	: [];
-
-const repoRoot = fileURLToPath(new URL("..", import.meta.url));
-
-test("packed installs include typebox without peer dependencies", async () => {
-	const tempDir = await mkdtemp(join(tmpdir(), "pi-web-access-pack-install-"));
-	try {
-		const packOutput = execFileSync(NPM_BIN, [...NPM_PREFIX, "pack", "--json", "--pack-destination", tempDir], {
-			cwd: repoRoot,
-			encoding: "utf8",
-			stdio: ["ignore", "pipe", "pipe"],
-		});
-		const [{ filename, files }] = JSON.parse(packOutput);
-		const packedFiles = files.map((file) => file.path);
-		assert.ok(packedFiles.includes("index.ts"));
-		assert.ok(packedFiles.includes("CHANGELOG.md"));
-		assert.ok(packedFiles.includes("SECURITY.md"));
-		assert.ok(!packedFiles.some((path) => path.startsWith("skills/")));
-		assert.ok(!packedFiles.some((path) => path.startsWith("test/")));
-		const tarball = join(tempDir, filename);
-
-		execFileSync(NPM_BIN, [...NPM_PREFIX, "install", "--omit=peer", "--ignore-scripts", "--no-audit", "--no-fund", tarball], {
-			cwd: tempDir,
-			stdio: ["ignore", "pipe", "pipe"],
-		});
-
-		const packageRequire = createRequire(join(tempDir, "node_modules", "pi-web-access", "package.json"));
-		const installedManifest = packageRequire("pi-web-access/package.json");
-		assert.equal(installedManifest.peerDependencies?.typebox, undefined);
-		assert.match(installedManifest.dependencies?.typebox, /^\^1\./);
-		assert.match(packageRequire.resolve("typebox").replaceAll("\\", "/"), /node_modules\/typebox\//);
-	} finally {
-		await rm(tempDir, { recursive: true, force: true });
-	}
-});
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { test } from "node:test";
+
+// npm ships as a shell script / .cmd wrapper, neither of which is spawnable on
+// Windows (extensionless `npm` does not resolve, `.cmd` is refused without a
+// shell). There, invoke its CLI entry through the current node binary instead.
+const NPM_BIN = process.platform === "win32" ? process.execPath : "npm";
+const NPM_PREFIX = process.platform === "win32"
+	? [join(dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js")]
+	: [];
+
+const repoRoot = fileURLToPath(new URL("..", import.meta.url));
+
+test("packed installs include typebox without peer dependencies", async () => {
+	const tempDir = await mkdtemp(join(tmpdir(), "pi-web-access-pack-install-"));
+	try {
+		const packOutput = execFileSync(NPM_BIN, [...NPM_PREFIX, "pack", "--json", "--pack-destination", tempDir], {
+			cwd: repoRoot,
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		const [{ filename, files }] = JSON.parse(packOutput);
+		const packedFiles = files.map((file) => file.path);
+		assert.ok(packedFiles.includes("index.ts"));
+		assert.ok(packedFiles.includes("CHANGELOG.md"));
+		assert.ok(packedFiles.includes("SECURITY.md"));
+		assert.ok(!packedFiles.some((path) => path.startsWith("skills/")));
+		assert.ok(!packedFiles.some((path) => path.startsWith("test/")));
+		const tarball = join(tempDir, filename);
+
+		execFileSync(NPM_BIN, [...NPM_PREFIX, "install", "--omit=peer", "--ignore-scripts", "--no-audit", "--no-fund", tarball], {
+			cwd: tempDir,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+
+		const packageRequire = createRequire(join(tempDir, "node_modules", "pi-web-access", "package.json"));
+		const installedManifest = packageRequire("pi-web-access/package.json");
+		assert.equal(installedManifest.peerDependencies?.typebox, undefined);
+		assert.match(installedManifest.dependencies?.typebox, /^\^1\./);
+		assert.match(packageRequire.resolve("typebox").replaceAll("\\", "/"), /node_modules\/typebox\//);
+	} finally {
+		await rm(tempDir, { recursive: true, force: true });
+	}
+});