pi-ext

import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import path from "node:path";
import type { ExtensionToolContext } from "@earendil-works/pi-coding-agent";
import { afterEach, describe, expect, it, vi } from "vitest";
import {
	createPiSession,
	type PiSession,
} from "../../../test/fixture/create-pi-session.ts";
import extension from "../index.ts";

// Replace the browser runtime so execution only reports the resolved setting.
vi.mock("../mockup-tool.ts", () => ({
	createMockupRuntime: (options: {
		openBrowser: (ctx: ExtensionToolContext) => boolean;
	}) => ({
		remember: () => undefined,
		shutdown: () => Promise.resolve(),
		tool: {
			execute: async (
				_toolCallId: string,
				_params: unknown,
				_signal: AbortSignal | undefined,
				_onUpdate: unknown,
				ctx: ExtensionToolContext,
			) => ({
				content: [],
				details: { open: options.openBrowser(ctx) },
			}),
		},
	}),
}));

type Case = {
	user?: unknown;
	project?: unknown;
	env?: string;
	untrusted?: boolean;
};

describe("mockup.openBrowser resolution", () => {
	let session: PiSession | undefined;
	let root: string | undefined;
	afterEach(async () => {
		await session?.dispose();
		session = undefined;
		vi.restoreAllMocks();
		if (root) rmSync(root, { recursive: true, force: true });
		root = undefined;
	});

	async function start(input: Case) {
		root = mkdtempSync(path.join(tmpdir(), "pi-ext-mockup-settings-"));
		if ("project" in input) {
			const dir = path.join(root, ".pi");
			mkdirSync(dir, { recursive: true });
			writeFileSync(
				path.join(dir, "settings.json"),
				JSON.stringify({ mockup: { openBrowser: input.project } }),
			);
		}
		session = await createPiSession({
			cwd: root,
			extensionFactories: [extension],
			env: { PI_MOCKUP_NO_OPEN: input.env },
			...("user" in input
				? { userSettings: { mockup: { openBrowser: input.user } } }
				: {}),
		});
		if (input.untrusted)
			session.session.settingsManager.setProjectTrusted(false);
		const runner = session.session.extensionRunner;
		const tool = runner.getToolDefinition("mockup");
		if (!tool) throw new Error("mockup tool not registered");
		const ctx = runner.createToolContext("call", undefined);
		const notify = vi.spyOn(ctx.ui, "notify").mockImplementation(() => {});
		const result = await tool.execute(
			"call",
			{
				title: "Settings",
				question: "Open browser?",
				options: [{ id: "one", label: "One", html: "<p>one</p>" }],
			},
			undefined,
			undefined,
			ctx,
		);
		const warnings = notify.mock.calls
			.filter((call) => call[1] === "warning")
			.map((call) => call[0]);
		return { open: (result.details as { open: boolean }).open, warnings };
	}

	it.each([
		["default opens", {}, true],
		["user false", { user: false }, false],
		["project true over user false", { user: false, project: true }, true],
		["project false over user true", { user: true, project: false }, false],
		["env 1 over project true", { project: true, env: "1" }, false],
		["env 0 over user false", { user: false, env: "0" }, true],
		["env false over project false", { project: false, env: "false" }, true],
		[
			"untrusted project ignored",
			{ user: true, project: false, untrusted: true },
			true,
		],
	] satisfies [string, Case, boolean][])(
		"%s",
		async (_name, input, expected) => {
			const { open, warnings } = await start(input);
			expect(open).toBe(expected);
			expect(warnings).toEqual([]);
		},
	);

	it.each([
		[
			"env yes",
			{ user: true, env: "yes" },
			"environment variable PI_MOCKUP_NO_OPEN",
		],
		["string project", { user: true, project: "true" }, "project settings"],
		["numeric user", { user: 1 }, "user settings"],
	] satisfies [string, Case, string][])(
		"rejects %s without falling through",
		async (_name, input, source) => {
			const { open, warnings } = await start(input);
			expect(open).toBe(false);
			expect(warnings.at(-1)).toBe(
				`Invalid mockup.openBrowser from ${source}; browser not opened`,
			);
		},
	);
});