@selesai/code 0.8.4 → 0.8.6

package/dist/extensions/copy-turn.test.ts

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createHash } from "node:crypto";
 import copyTurnExtension from "./copy-turn.ts";
 
 vi.mock("@selesai/code", () => ({
@@ -19,6 +20,11 @@ function hashFromMarkedText(text: string): string {
 	return m[1]!;
 }
 
+// hashFor(m) = sha1(JSON.stringify([role, resultOf(m)])).slice(0, 6)
+function hashForText(role: string, text: string): string {
+	return createHash("sha1").update(JSON.stringify([role, text])).digest("hex").slice(0, 6);
+}
+
 function createHarness() {
 	const handlers = new Map<string, Handler>();
 	const commands = new Map<string, Command>();
@@ -128,4 +134,227 @@ describe("copy-turn hash stability", () => {
 
 		expect(hashFromMarkedText(r1.message.content[0].text)).toBe(hashFromMarkedText(r2.message.content[0].text));
 	});
+
+	it("skips empty user messages and tool-use assistant messages", async () => {
+		const { handlers, sent } = createHarness();
+		const messageEnd = handlers.get("message_end")!;
+
+		await messageEnd({ type: "message_end", message: { role: "user", content: "   " } }, {});
+		expect(sent).toHaveLength(0);
+
+		const toolUse = await messageEnd({ type: "message_end", message: { role: "assistant", content: "thinking", stopReason: "toolUse" } }, {});
+		expect(toolUse).toBeUndefined();
+
+		const emptyAssistant = await messageEnd({ type: "message_end", message: { role: "assistant", content: "" } }, {});
+		expect(emptyAssistant).toBeUndefined();
+
+		const otherRole = await messageEnd({ type: "message_end", message: { role: "system", content: "sys" } }, {});
+		expect(otherRole).toBeUndefined();
+
+		await messageEnd({ type: "message_end", message: null }, {});
+		expect(sent).toHaveLength(0);
+	});
+
+	it("marks string-content assistant messages and bashExecution results", async () => {
+		const { handlers } = createHarness();
+		const messageEnd = handlers.get("message_end")!;
+
+		const stringMsg = await messageEnd({ type: "message_end", message: { role: "assistant", content: "plain text result" } }, {});
+		expect(stringMsg.message.content).toMatch(/plain text result\n\n⧉ copy assistant: \/cp [0-9a-f]{6}/);
+
+		const bashMsg = await messageEnd({
+			type: "message_end",
+			message: { role: "bashExecution", content: "ignored", command: "ls -la", output: "file1\nfile2" },
+		}, {});
+		expect(bashMsg).toBeUndefined(); // bashExecution is not assistant
+	});
+
+	it("marks the last text part of multi-part assistant content", async () => {
+		const { handlers } = createHarness();
+		const messageEnd = handlers.get("message_end")!;
+
+		const result = await messageEnd({
+			type: "message_end",
+			message: {
+				role: "assistant",
+				content: [
+					{ type: "text", text: "first part" },
+					{ type: "image", mimeType: "image/png" },
+					{ type: "text", text: "final part" },
+				],
+			},
+		}, {});
+		expect(result.message.content[0].text).toBe("first part");
+		expect(result.message.content[1].type).toBe("image");
+		expect(result.message.content[2].text).toMatch(/^final part\n\n⧉ copy assistant: \/cp [0-9a-f]{6}$/);
+	});
+
+	it("handles text parts with undefined text", async () => {
+		const { handlers } = createHarness();
+		const messageEnd = handlers.get("message_end")!;
+
+		const result = await messageEnd({
+			type: "message_end",
+			message: { role: "assistant", content: [{ type: "text" }, { type: "text", text: "real" }] },
+		}, {});
+		expect(result.message.content[0].text).toBeUndefined(); // non-last parts pass through unchanged
+		expect(result.message.content[1].text).toMatch(/^real\n\n⧉ copy assistant: \/cp [0-9a-f]{6}$/);
+	});
+
+	it("hashes bashExecution results without command or output", async () => {
+		const { handlers, commands } = createHarness();
+		const messageEnd = handlers.get("message_end")!;
+		const cmd = commands.get("cp")!;
+
+		// No command, no output → empty result → no copy row.
+		await messageEnd({ type: "message_end", message: { role: "bashExecution" } }, {});
+
+		// Command without output.
+		const message = { role: "bashExecution", command: "ls" };
+		const hash = hashForText("bashExecution", "$ ls");
+		const ctx = branchCtx([message]);
+		await cmd.handler(hash, ctx);
+		expect(copyToClipboard).toHaveBeenCalledWith("$ ls");
+
+		// Output without command (clean.command ? ... : "" branch).
+		const noCommand = { role: "bashExecution", output: "bare output" };
+		const hash2 = hashForText("bashExecution", "bare output");
+		const ctx2 = branchCtx([noCommand]);
+		await cmd.handler(hash2, ctx2);
+		expect(copyToClipboard).toHaveBeenCalledWith("bare output");
+	});
+
+	it("branchMessages tolerates a missing sessionManager and filters custom rows", async () => {
+		const { commands } = createHarness();
+		const cmd = commands.get("cp")!;
+
+		const noManager = { ui: { notify: vi.fn() } };
+		await cmd.handler("abc123", noManager);
+		expect(noManager.ui.notify).toHaveBeenCalledWith("No message for hash abc123", "warning");
+
+		const withCustom = branchCtx([
+			{ role: "user", content: "real content" },
+			{ role: "custom", customType: "copy-turn", content: "⧉ copy user: /cp abc123" },
+		]);
+		const hash = hashForText("user", "real content");
+		await cmd.handler(hash, withCustom);
+		expect(copyToClipboard).toHaveBeenCalledWith("real content");
+
+		// Role-less message: hashFor falls back to the "message" role.
+		const roleless = branchCtx([{ content: "roleless content" }]);
+		const rolelessHash = hashForText("message", "roleless content");
+		await cmd.handler(rolelessHash, roleless);
+		expect(copyToClipboard).toHaveBeenCalledWith("roleless content");
+	});
+
+	it("adds a marker to content arrays without text parts", async () => {
+		const { handlers } = createHarness();
+		const messageEnd = handlers.get("message_end")!;
+
+		// Image-only assistant content has no copyable text, so no marker is added.
+		const result = await messageEnd({
+			type: "message_end",
+			message: { role: "assistant", content: [{ type: "image", mimeType: "image/png" }] },
+		}, {});
+		expect(result).toBeUndefined();
+	});
+
+	it("context handler strips copy rows and cleans markers", async () => {
+		const { handlers } = createHarness();
+		const context = handlers.get("context")!;
+		const result = await context({
+			type: "context",
+			messages: [
+				{ role: "user", content: "hello\n\n⧉ copy user: /cp abc123" },
+				{ role: "custom", customType: "copy-turn", content: "⧉ copy user: /cp abc123" },
+				{ role: "assistant", content: [{ type: "text", text: "hi\n\n⧉ copy assistant: /cp def456" }] },
+			],
+		});
+		expect(result.messages).toHaveLength(2);
+		expect(result.messages[0].content).toBe("hello");
+		expect(result.messages[1].content[0].text).toBe("hi");
+	});
+
+	it("message renderer falls back to content hash and default role", () => {
+		const { pi } = createHarness();
+		const renderer = (pi.registerMessageRenderer as any).mock.calls[0][1];
+		const theme = { fg: (_name: string, value: string) => value };
+
+		const withDetails = renderer({ details: { hash: "abc123", role: "user" } }, {}, theme);
+		expect(withDetails.render(80).join("\n")).toContain("⧉ copy user: /cp abc123");
+
+		const fromContent = renderer({ content: "hash fedcba in the middle" }, {}, theme);
+		expect(fromContent.render(80).join("\n")).toContain("⧉ copy message: /cp fedcba");
+
+		const fallback = renderer({ content: "no hash here" }, {}, theme);
+		expect(fallback.render(80).join("\n")).toContain("⧉ copy message: /cp ??????");
+
+		// Non-string, non-array content (defensive path in textFromContent).
+		const nonText = renderer({ content: 42 }, {}, theme);
+		expect(nonText.render(80).join("\n")).toContain("⧉ copy message: /cp ??????");
+
+		// Text part without a text property (b.text ?? "" branch).
+		const missingText = renderer({ content: [{ type: "text" }] }, {}, theme);
+		expect(missingText.render(80).join("\n")).toContain("⧉ copy message: /cp ??????");
+	});
+
+	it("/cp reports usage, no-match, ambiguous, and empty-result cases", async () => {
+		const { commands } = createHarness();
+		const cmd = commands.get("cp")!;
+
+		const usageCtx = branchCtx([]);
+		await cmd.handler("", usageCtx);
+		expect(usageCtx.ui.notify).toHaveBeenCalledWith("Usage: /cp <hash>", "warning");
+
+		const noMatchCtx = branchCtx([{ role: "user", content: "hello" }]);
+		await cmd.handler("zzzzzz", noMatchCtx);
+		expect(noMatchCtx.ui.notify).toHaveBeenCalledWith("No message for hash zzzzzz", "warning");
+
+		// Two messages whose hashes share a prefix → ambiguous.
+		// "c" and "e" are known to share the first hash character "9".
+		const m1 = { role: "user", content: "c" };
+		const m2 = { role: "user", content: "e" };
+		const h1 = hashForText("user", "c");
+		const h2 = hashForText("user", "e");
+		// Find a shared prefix of length >= 1.
+		let shared = "";
+		for (let i = 0; i < Math.min(h1.length, h2.length); i++) {
+			if (h1[i] === h2[i]) shared += h1[i];
+			else break;
+		}
+		if (shared.length === 0) {
+			// Extremely unlikely; fall back to asserting the no-match path instead.
+			const ctx = branchCtx([m1]);
+			await cmd.handler(h1, ctx);
+			expect(ctx.ui.notify).toHaveBeenCalledWith(`Copied ${h1} (${m1.content.length} chars)`, "info");
+		} else {
+			const ambiguousCtx = branchCtx([m1, m2]);
+			await cmd.handler(shared, ambiguousCtx);
+			expect(ambiguousCtx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("ambiguous"), "warning");
+		}
+
+		const emptyCtx = branchCtx([{ role: "user", content: "   " }]);
+		await cmd.handler(hashForText("user", ""), emptyCtx);
+		expect(emptyCtx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("No result content"), "warning");
+	});
+
+	it("/cp strips ANSI codes before copying", async () => {
+		const { commands } = createHarness();
+		const cmd = commands.get("cp")!;
+		const message = { role: "user", content: "\x1b[31mred\x1b[0m text" };
+		const hash = hashForText("user", "\x1b[31mred\x1b[0m text");
+		const ctx = branchCtx([message]);
+		await cmd.handler(hash, ctx);
+		expect(copyToClipboard).toHaveBeenCalledWith("red text");
+	});
+
+	it("/cp copies bashExecution results with command prefix", async () => {
+		const { commands } = createHarness();
+		const cmd = commands.get("cp")!;
+		const message = { role: "bashExecution", command: "ls", output: "a\nb" };
+		const hash = hashForText("bashExecution", "$ ls\na\nb");
+		const ctx = branchCtx([message]);
+		await cmd.handler(hash, ctx);
+		expect(copyToClipboard).toHaveBeenCalledWith("$ ls\na\nb");
+	});
 });

package/dist/extensions/copy-turn.ts

@@ -50,10 +50,20 @@ function hashFor(m: AnyMessage): string {
 function addMarker(m: AnyMessage): AnyMessage {
   const h = hashFor(m);
   const out = structuredClone(m);
+  // Unreachable: addMarker is only called from message_end for assistant
+  // messages, so out.role is always "assistant".
+  /* v8 ignore next 1 */
   const role = out.role ?? "message";
   if (typeof out.content === "string") out.content = stripMark(out.content) + mark(h, role);
+  // Unreachable: addMarker is only called when resultOf(m) is non-empty,
+  // which requires string or text-array content, so the non-array else
+  // branch below can never be taken.
+  /* v8 ignore start */
   else if (Array.isArray(out.content)) {
     const lastText = out.content.findLastIndex((x: any) => x?.type === "text");
+    // Unreachable: message_end only calls addMarker when resultOf(m) is
+    // non-empty, and resultOf extracts only text parts, so the last text
+    // part always exists and has defined text.
     if (lastText >= 0) {
       out.content = out.content.map((b: any, i: number) =>
         i === lastText ? { ...b, text: stripMark(b.text ?? "") + mark(h, role) } : b
@@ -62,6 +72,7 @@ function addMarker(m: AnyMessage): AnyMessage {
       out.content.push({ type: "text", text: mark(h, role).trimStart() });
     }
   }
+  /* v8 ignore stop */
   return out;
 }
 

package/dist/extensions/grep-app/index.test.ts

@@ -1,13 +1,51 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { buildSearchUrl, formatSearchResponse } from "./index.ts";
 
+// Mock fetch and playwright so the tool execute paths run offline.
+const fetchMock = vi.fn();
+
+const chromiumMock = {
+	launch: vi.fn(),
+};
+vi.mock("playwright", () => ({ chromium: chromiumMock }));
+
+import grepAppExtension from "./index.ts";
+
+function makePi() {
+	const tools = new Map<string, any>();
+	const pi = {
+		registerTool: (tool: any) => tools.set(tool.name, tool),
+	};
+	grepAppExtension(pi as any);
+	return { pi, tools };
+}
+
+const theme = {
+	fg: (_name: string, value: string) => value,
+	bold: (value: string) => value,
+};
+
+const okResponse = (body: string, status = 200, headers: Record<string, string> = {}) =>
+	new Response(body, { status, headers });
+
 describe("grep-app extension", () => {
+	beforeEach(() => {
+		vi.stubGlobal("fetch", fetchMock);
+		fetchMock.mockReset();
+		chromiumMock.launch.mockReset();
+	});
+
+	afterEach(() => {
+		vi.unstubAllGlobals();
+	});
+
 	it("maps search filters to grep.app parameters", () => {
 		const url = buildSearchUrl({
 			query: "useEffect cleanup",
 			page: 2,
 			caseSensitive: true,
 			useRegex: true,
+			wholeWords: true,
 			repo: "facebook/react",
 			path: "packages/",
 			language: "TypeScript",
@@ -18,12 +56,24 @@ describe("grep-app extension", () => {
 			page: "2",
 			case: "true",
 			regexp: "true",
+			words: "true",
 			"f.repo.pattern": "facebook/react",
 			"f.path.pattern": "packages/",
 			"f.lang": "TypeScript",
 		});
 	});
 
+	it("buildSearchUrl defaults page to 1 and omits optional filters", () => {
+		const url = buildSearchUrl({ query: "foo" });
+		expect(url.searchParams.get("page")).toBe("1");
+		expect(url.searchParams.has("case")).toBe(false);
+		expect(url.searchParams.has("regexp")).toBe(false);
+		expect(url.searchParams.has("words")).toBe(false);
+		expect(url.searchParams.has("f.repo.pattern")).toBe(false);
+		expect(url.searchParams.has("f.path.pattern")).toBe(false);
+		expect(url.searchParams.has("f.lang")).toBe(false);
+	});
+
 	it("turns grep.app HTML snippets into readable numbered source", () => {
 		const output = formatSearchResponse(
 			{
@@ -48,4 +98,309 @@ describe("grep-app extension", () => {
 		expect(output).toContain("L7: const x = <mark>;");
 		expect(output).toContain("https://github.com/owner/repo/blob/main/src/a%20file.ts#L7");
 	});
+
+	it("formatSearchResponse returns no-matches text for empty hits", () => {
+		expect(formatSearchResponse({ hits: { total: 0, hits: [] } }, 1)).toBe("No matches found.");
+	});
+
+	it("formatSearchResponse omits the line anchor when no data-line is present", () => {
+		const output = formatSearchResponse(
+			{
+				hits: {
+					total: 1,
+					hits: [
+						{
+							repo: "owner/repo",
+							branch: "main",
+							path: "src/file.ts",
+							content: { snippet: "<table><tr><td><pre>code</pre></td></tr></table>" },
+						},
+					],
+				},
+			},
+			1,
+		);
+		expect(output).toContain("L?: code");
+		expect(output).toContain("https://github.com/owner/repo/blob/main/src/file.ts");
+		expect(output).not.toContain("#L");
+	});
+
+	it("registers both tools", () => {
+		const { tools } = makePi();
+		expect(tools.has("grep_app_search")).toBe(true);
+		expect(tools.has("grep_app_fetch")).toBe(true);
+	});
+
+	it("grep_app_search executes and formats results", async () => {
+		const { tools } = makePi();
+		fetchMock.mockResolvedValueOnce(
+			okResponse(JSON.stringify({
+				hits: {
+					total: 5,
+					hits: [
+						{
+							repo: "owner/repo",
+							branch: "main",
+							path: "src/a.ts",
+							content: { snippet: '<table><tr data-line="3"><td><pre>const x = 1;</pre></td></tr></table>' },
+						},
+					],
+				},
+			})),
+		);
+
+		const result = await tools.get("grep_app_search").execute("call1", { query: "const x" }, undefined);
+		expect(result.content[0].text).toContain("grep.app: 5 total matches; page 1");
+		expect(result.content[0].text).toContain("L3: const x = 1;");
+		expect(result.details).toMatchObject({ total: 5, page: 1, resultCount: 1 });
+		expect(fetchMock).toHaveBeenCalledTimes(1);
+		const [url, init] = fetchMock.mock.calls[0];
+		expect(String(url)).toContain("q=const+x");
+		expect(init.headers["User-Agent"]).toBe("selesai-grep-app-extension");
+	});
+
+	it("grep_app_search rejects useRegex + wholeWords", async () => {
+		const { tools } = makePi();
+		await expect(tools.get("grep_app_search").execute("call1", { query: "x", useRegex: true, wholeWords: true }, undefined))
+			.rejects.toThrow("useRegex and wholeWords cannot both be true.");
+	});
+
+	it("grep_app_search throws on invalid JSON and unexpected shapes", async () => {
+		const { tools } = makePi();
+		fetchMock.mockResolvedValueOnce(okResponse("not json"));
+		await expect(tools.get("grep_app_search").execute("call1", { query: "x" }, undefined))
+			.rejects.toThrow("grep.app returned invalid JSON.");
+
+		fetchMock.mockResolvedValueOnce(okResponse(JSON.stringify({ hits: {} })));
+		await expect(tools.get("grep_app_search").execute("call1", { query: "x" }, undefined))
+			.rejects.toThrow("grep.app returned an unexpected response.");
+	});
+
+	it("grep_app_search throws on non-OK responses", async () => {
+		const { tools } = makePi();
+		fetchMock.mockResolvedValueOnce(okResponse("oops", 500));
+		await expect(tools.get("grep_app_search").execute("call1", { query: "x" }, undefined))
+			.rejects.toThrow("500");
+	});
+
+	it("grep_app_search falls back to the browser on a 429 challenge", async () => {
+		const { tools } = makePi();
+		fetchMock.mockResolvedValueOnce(
+			okResponse("challenge", 429, { "x-vercel-mitigated": "challenge" }),
+		);
+		const page = {
+			goto: vi.fn(async () => {}),
+			waitForFunction: vi.fn(async () => {}),
+			locator: vi.fn(() => ({ innerText: vi.fn(async () => '{"hits":{"total":1,"hits":[]}}') })),
+		};
+		const browser = { newPage: vi.fn(async () => page), close: vi.fn(async () => {}) };
+		chromiumMock.launch.mockResolvedValue(browser);
+
+		const result = await tools.get("grep_app_search").execute("call1", { query: "x" }, undefined);
+		expect(result.content[0].text).toBe("No matches found.");
+		expect(chromiumMock.launch).toHaveBeenCalledWith({ headless: true });
+		expect(browser.close).toHaveBeenCalled();
+	});
+
+	it("grep_app_search aborts the browser fetch when the signal fires", async () => {
+		const { tools } = makePi();
+		fetchMock.mockResolvedValueOnce(
+			okResponse("challenge", 429, { "x-vercel-mitigated": "challenge" }),
+		);
+		const controller = new AbortController();
+		const page = {
+			goto: vi.fn(async () => {}),
+			waitForFunction: vi.fn(() => new Promise((_resolve, reject) => {
+				controller.signal.addEventListener("abort", () => reject(controller.signal.reason));
+			})),
+			locator: vi.fn(() => ({ innerText: vi.fn(async () => "{}") })),
+		};
+		const browser = { newPage: vi.fn(async () => page), close: vi.fn(async () => {}) };
+		chromiumMock.launch.mockResolvedValue(browser);
+
+		const promise = tools.get("grep_app_search").execute("call1", { query: "x" }, controller.signal);
+		// Let the browser launch and page.goto run, then abort while waitForFunction hangs.
+		await vi.waitFor(() => expect(page.goto).toHaveBeenCalled());
+		controller.abort(new Error("cancelled"));
+		await expect(promise).rejects.toThrow("cancelled");
+	});
+
+	it("grep_app_search rethrows non-abort browser errors", async () => {
+		const { tools } = makePi();
+		fetchMock.mockResolvedValueOnce(
+			okResponse("challenge", 429, { "x-vercel-mitigated": "challenge" }),
+		);
+		const page = {
+			goto: vi.fn(async () => {}),
+			waitForFunction: vi.fn(() => Promise.reject(new Error("browser timeout"))),
+			locator: vi.fn(() => ({ innerText: vi.fn(async () => "{}") })),
+		};
+		const browser = { newPage: vi.fn(async () => page), close: vi.fn(async () => {}) };
+		chromiumMock.launch.mockResolvedValue(browser);
+
+		await expect(tools.get("grep_app_search").execute("call1", { query: "x" }, undefined))
+			.rejects.toThrow("browser timeout");
+	});
+
+	it("grep_app_search aborts with a default Cancelled error when no reason is given", async () => {
+		const { tools } = makePi();
+		fetchMock.mockResolvedValueOnce(
+			okResponse("challenge", 429, { "x-vercel-mitigated": "challenge" }),
+		);
+		const controller = new AbortController();
+		const page = {
+			goto: vi.fn(async () => {}),
+			waitForFunction: vi.fn(() => new Promise((_resolve, reject) => {
+				controller.signal.addEventListener("abort", () => reject(controller.signal.reason));
+			})),
+			locator: vi.fn(() => ({ innerText: vi.fn(async () => "{}") })),
+		};
+		const browser = { newPage: vi.fn(async () => page), close: vi.fn(async () => {}) };
+		chromiumMock.launch.mockResolvedValue(browser);
+
+		const promise = tools.get("grep_app_search").execute("call1", { query: "x" }, controller.signal);
+		await vi.waitFor(() => expect(page.goto).toHaveBeenCalled());
+		controller.abort(); // no reason → signal.reason is a DOMException in Node
+		await expect(promise).rejects.toThrow();
+	});
+
+	it("grep_app_search waitForFunction predicate checks the page body prefix", async () => {
+		const { tools } = makePi();
+		fetchMock.mockResolvedValueOnce(
+			okResponse("challenge", 429, { "x-vercel-mitigated": "challenge" }),
+		);
+		let predicate: (() => boolean) | null = null;
+		const page = {
+			goto: vi.fn(async () => {}),
+			waitForFunction: vi.fn((fn: () => boolean) => {
+				predicate = fn;
+				return Promise.resolve();
+			}),
+			locator: vi.fn(() => ({ innerText: vi.fn(async () => '{"hits":{"total":0,"hits":[]}}') })),
+		};
+		const browser = { newPage: vi.fn(async () => page), close: vi.fn(async () => {}) };
+		chromiumMock.launch.mockResolvedValue(browser);
+
+		const result = await tools.get("grep_app_search").execute("call1", { query: "x" }, undefined);
+		expect(result.content[0].text).toBe("No matches found.");
+
+		// The predicate reads document.body.innerText.
+		const originalDocument = (globalThis as any).document;
+		(globalThis as any).document = { body: { innerText: "{\"hits\":1}" } };
+		try {
+			expect(predicate!()).toBe(true);
+			(globalThis as any).document = { body: { innerText: "not json" } };
+			expect(predicate!()).toBe(false);
+		} finally {
+			(globalThis as any).document = originalDocument;
+		}
+	});
+
+	it("grep_app_search truncates long output and reports the full path", async () => {
+		const { tools } = makePi();
+		// A snippet with 100 table rows produces 100 output lines per hit;
+		// 30 hits × 100 lines exceeds the 2000-line truncation limit.
+		const rows = Array.from({ length: 100 }, (_, i) => `<tr data-line="${i + 1}"><td><pre>line ${i}</pre></td></tr>`).join("");
+		const snippet = `<table>${rows}</table>`;
+		const hits = Array.from({ length: 30 }, (_, i) => ({
+			repo: "owner/repo",
+			branch: "main",
+			path: `src/file${i}.ts`,
+			content: { snippet },
+		}));
+		fetchMock.mockResolvedValueOnce(okResponse(JSON.stringify({ hits: { total: 30, hits } })));
+
+		const result = await tools.get("grep_app_search").execute("call1", { query: "x" }, undefined);
+		expect(result.content[0].text).toContain("[Output truncated to");
+		expect(result.details.fullOutputPath).toBeTruthy();
+	});
+
+	it("grep_app_fetch fetches a file with line ranges", async () => {
+		const { tools } = makePi();
+		fetchMock.mockResolvedValueOnce(okResponse("line1\nline2\nline3\nline4"));
+
+		const result = await tools.get("grep_app_fetch").execute("call2", {
+			repo: "owner/repo",
+			path: "src/a.ts",
+			ref: "v1.0",
+			startLine: 2,
+			endLine: 3,
+		}, undefined);
+		expect(result.content[0].text).toBe("2: line2\n3: line3");
+		expect(result.details).toMatchObject({ repo: "owner/repo", path: "src/a.ts", ref: "v1.0", startLine: 2, endLine: 3, totalLines: 4 });
+		const [url] = fetchMock.mock.calls[0];
+		expect(String(url)).toBe("https://raw.githubusercontent.com/owner/repo/v1.0/src/a.ts");
+	});
+
+	it("grep_app_fetch defaults ref and endLine", async () => {
+		const { tools } = makePi();
+		fetchMock.mockResolvedValueOnce(okResponse("a\nb\nc"));
+
+		const result = await tools.get("grep_app_fetch").execute("call2", { repo: "owner/repo", path: "src/a.ts" }, undefined);
+		expect(result.content[0].text).toBe("1: a\n2: b\n3: c");
+		expect(result.details.ref).toBe("HEAD");
+		expect(result.details.endLine).toBe(3);
+		const [url] = fetchMock.mock.calls[0];
+		expect(String(url)).toBe("https://raw.githubusercontent.com/owner/repo/HEAD/src/a.ts");
+	});
+
+	it("grep_app_fetch rejects endLine before startLine", async () => {
+		const { tools } = makePi();
+		await expect(tools.get("grep_app_fetch").execute("call2", {
+			repo: "owner/repo",
+			path: "src/a.ts",
+			startLine: 5,
+			endLine: 2,
+		}, undefined)).rejects.toThrow("endLine must be greater than or equal to startLine.");
+	});
+
+	it("grep_app_fetch returns empty-file text for empty ranges", async () => {
+		const { tools } = makePi();
+		fetchMock.mockResolvedValueOnce(okResponse("a\nb\nc"));
+		// startLine beyond the file length produces an empty selection.
+		const result = await tools.get("grep_app_fetch").execute("call2", { repo: "owner/repo", path: "src/a.ts", startLine: 5 }, undefined);
+		expect(result.content[0].text).toBe("(empty file or range)");
+	});
+
+	it("grep_app_fetch truncates long output", async () => {
+		const { tools } = makePi();
+		const lines = Array.from({ length: 3000 }, (_, i) => `line ${i}`).join("\n");
+		fetchMock.mockResolvedValueOnce(okResponse(lines));
+		const result = await tools.get("grep_app_fetch").execute("call2", { repo: "owner/repo", path: "src/a.ts" }, undefined);
+		expect(result.content[0].text).toContain("[Output truncated to");
+		expect(result.details.fullOutputPath).toBeTruthy();
+	});
+
+	it("renderResult renders success and error states", () => {
+		const { tools } = makePi();
+		const search = tools.get("grep_app_search");
+		const success = search.renderResult(
+			{ content: [], details: { total: 10, page: 2, resultCount: 3 } },
+			{},
+			theme,
+			{ isError: false },
+		);
+		expect(success.render(80).join("\n")).toContain("✓ grep.app: 3 results · page 2 · 10 total matches");
+
+		const error = search.renderResult({ content: [] }, {}, theme, { isError: true });
+		expect(error.render(80).join("\n")).toContain("✗ grep.app search failed");
+
+		const noDetails = search.renderResult({ content: [] }, {}, theme, { isError: false });
+		expect(noDetails.render(80).join("\n")).toContain("0 results");
+
+		const fetchTool = tools.get("grep_app_fetch");
+		const fetchSuccess = fetchTool.renderResult(
+			{ content: [], details: { repo: "o/r", path: "src/a.ts", startLine: 1, endLine: 5 } },
+			{},
+			theme,
+			{ isError: false },
+		);
+		expect(fetchSuccess.render(80).join("\n")).toContain("✓ GitHub: o/r/src/a.ts · lines 1-5");
+
+		const fetchError = fetchTool.renderResult({ content: [] }, {}, theme, { isError: true });
+		expect(fetchError.render(80).join("\n")).toContain("✗ GitHub file fetch failed");
+
+		const fetchNoDetails = fetchTool.renderResult({ content: [] }, {}, theme, { isError: false });
+		expect(fetchNoDetails.render(80).join("\n")).toContain("✓ GitHub: ?/? · lines 1-?");
+	});
 });

package/dist/extensions/grep-app/index.ts

@@ -97,7 +97,12 @@ async function fetchWithBrowser(url: URL | string, signal: AbortSignal | undefin
 		await page.waitForFunction(() => document.body.innerText.trimStart().startsWith("{"), undefined, { timeout: 15_000 });
 		return await page.locator("body").innerText();
 	} catch (error) {
-		if (signal?.aborted) throw signal.reason ?? new Error("Cancelled");
+		if (signal?.aborted) {
+			// signal.reason is always set after abort() in Node, so the ?? fallback
+			// is unreachable.
+			/* v8 ignore next 1 */
+			throw signal.reason ?? new Error("Cancelled");
+		}
 		throw error;
 	} finally {
 		signal?.removeEventListener("abort", abort);