@narumitw/pi-chrome-devtools 0.13.0 → 0.14.0

package/src/render.ts

@@ -0,0 +1,111 @@
+import type {
+	AgentToolResult,
+	ToolRenderResultOptions,
+} from "@earendil-works/pi-coding-agent";
+
+const STATUS_KEY = "chrome-devtools";
+interface StatusContext {
+	ui: { setStatus: (key: string, value: string | undefined) => void };
+}
+interface RenderTheme {
+	bold(text: string): string;
+	fg(color: string, text: string): string;
+}
+interface RenderComponent {
+	invalidate(): void;
+	render(width: number): string[];
+}
+
+export function renderToolCall(action: string) {
+	return () => new PiTextComponent(`Chrome DevTools: ${action}`);
+}
+
+export function renderTextResult(
+	result: AgentToolResult<unknown>,
+	options: ToolRenderResultOptions,
+	theme: RenderTheme,
+) {
+	const output = formatCollapsibleOutput(textContent(result), options);
+	return new PiTextComponent(output.text, theme, output.color);
+}
+
+export function renderScreenshotResult(
+	result: AgentToolResult<unknown>,
+	options: ToolRenderResultOptions,
+	theme: RenderTheme,
+): RenderComponent {
+	const output = formatCollapsibleOutput(screenshotTextContent(result), options);
+	return new PiTextComponent(output.text, theme, output.color);
+}
+
+function textContent(result: AgentToolResult<unknown>) {
+	return result.content
+		.flatMap((content) => (content.type === "text" ? [content.text] : []))
+		.join("\n");
+}
+
+function screenshotTextContent(result: AgentToolResult<unknown>) {
+	const text = textContent(result);
+	if (text.trim()) return text;
+
+	const details = result.details as { savedPath?: unknown; bytes?: unknown } | undefined;
+	if (typeof details?.savedPath !== "string") return text;
+	const bytes = typeof details.bytes === "number" ? ` (${details.bytes} bytes)` : "";
+	return `Saved screenshot to ${details.savedPath}${bytes}`;
+}
+
+function formatCollapsibleOutput(
+	text: string,
+	options: ToolRenderResultOptions,
+): { text: string; color?: string } {
+	if (options.isPartial) return { text: "Running...", color: "warning" };
+	if (options.expanded) return { text, color: "toolOutput" };
+
+	return { text: "" };
+}
+
+class PiTextComponent implements RenderComponent {
+	private text: string;
+	private readonly theme?: RenderTheme;
+	private readonly color?: string;
+
+	constructor(text = "", theme?: RenderTheme, color?: string) {
+		this.text = text;
+		this.theme = theme;
+		this.color = color;
+	}
+
+	setText(text: string) {
+		this.text = text;
+	}
+
+	invalidate() {
+		// Stateless renderer: no cached layout to invalidate.
+	}
+
+	render(width: number) {
+		if (!this.text.trim()) return [];
+		return this.text
+			.replace(/\t/g, "   ")
+			.split(/\r?\n/)
+			.map((line) => {
+				const truncatedLine = truncateLine(line, Math.max(1, width));
+				return this.theme && this.color
+					? this.theme.fg(this.color, truncatedLine)
+					: truncatedLine;
+			});
+	}
+}
+
+function truncateLine(line: string, maxWidth: number) {
+	return Array.from(line).slice(0, maxWidth).join("");
+}
+
+export async function withStatus<T>(ctx: StatusContext, status: string, callback: () => Promise<T>) {
+	ctx.ui.setStatus(STATUS_KEY, status);
+	try {
+		return await callback();
+	} finally {
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+	}
+}

package/src/runtime.ts

@@ -0,0 +1,85 @@
+import type { ChildProcess } from "node:child_process";
+
+export const DEFAULT_HOST = "127.0.0.1";
+export const DEFAULT_PORT = 9222;
+export const DEFAULT_TIMEOUT_MS = 10_000;
+export const DEFAULT_HTTP_TIMEOUT_MS = 1_000;
+export const DEFAULT_ENDPOINT_WAIT_MS = 5_000;
+export const DEFAULT_ENDPOINT_RETRY_MS = 250;
+export const MANAGED_BROWSER_PROFILE_PREFIX = "pi-chrome-devtools-profile-";
+export const DEVTOOLS_ACTIVE_PORT_FILE = "DevToolsActivePort";
+export const BROWSER_SHUTDOWN_WAIT_MS = 1_500;
+
+export interface DevToolsPage {
+	id: string;
+	type: string;
+	title: string;
+	url: string;
+	webSocketDebuggerUrl?: string;
+}
+
+export interface ChromeDevToolsState {
+	host: string;
+	port: number;
+	configuredPort: number;
+	hostConfigured: boolean;
+	portConfigured: boolean;
+	autoLaunchEnabled: boolean;
+	browserExecutable?: string;
+	activePageId?: string;
+	managedBrowser?: ManagedBrowser;
+	launchPromise?: Promise<void>;
+	lastLaunchAttempt?: BrowserLaunchAttempt;
+	shuttingDown: boolean;
+	settingsNotice?: string;
+}
+
+export interface ManagedBrowser {
+	process: ChildProcess;
+	userDataDir: string;
+	port?: number;
+	exited: boolean;
+	ready: boolean;
+}
+
+export interface BrowserLaunchAttempt {
+	candidateLabels: string[];
+	mode: "dynamic-port" | "explicit-port";
+	selectedCandidate?: string;
+	userDataDir?: string;
+	lastError?: string;
+}
+
+export interface BrowserCandidateDefinition {
+	label: string;
+	executable: string;
+	source: "env" | "path" | "wellKnownPath";
+}
+
+export interface BrowserCandidate extends BrowserCandidateDefinition {
+	resolvedExecutable: string;
+}
+
+export function parseConfiguredPort(value: string | undefined) {
+	if (value === undefined) return undefined;
+	const trimmedValue = value.trim();
+	if (!/^\d+$/.test(trimmedValue)) return undefined;
+	const port = Number(trimmedValue);
+	if (!Number.isInteger(port) || port < 1 || port > 65_535) return undefined;
+	return port;
+}
+
+const configuredHost = process.env.PI_CHROME_DEVTOOLS_HOST ?? DEFAULT_HOST;
+const configuredPortOverride = parseConfiguredPort(process.env.PI_CHROME_DEVTOOLS_PORT);
+const configuredPort = configuredPortOverride ?? DEFAULT_PORT;
+
+export const state: ChromeDevToolsState = {
+	host: configuredHost,
+	port: configuredPort,
+	configuredPort,
+	hostConfigured: process.env.PI_CHROME_DEVTOOLS_HOST !== undefined,
+	portConfigured: configuredPortOverride !== undefined,
+	autoLaunchEnabled: process.env.PI_CHROME_DEVTOOLS_AUTO_LAUNCH !== "0",
+	browserExecutable: process.env.PI_CHROME_DEVTOOLS_BROWSER,
+	shuttingDown: false,
+};

package/src/screenshot.ts

@@ -0,0 +1,252 @@
+import { randomUUID } from "node:crypto";
+import { link, lstat, mkdir, mkdtemp, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import type { DevToolsPage } from "./runtime.js";
+
+function unique<T>(values: T[]) {
+	return Array.from(new Set(values));
+}
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+	return error instanceof Error && "code" in error;
+}
+
+export interface ResolvedScreenshotPath {
+	path: string;
+	allowedRoots: string[];
+	isDefault: boolean;
+}
+export interface ScreenshotSaveResult {
+	savedPath: string;
+	bytes: number;
+	isDefaultPath: boolean;
+}
+
+export async function saveScreenshot(
+	base64Png: string,
+	savePath: string | undefined,
+	cwd: string,
+	signal: AbortSignal | undefined,
+): Promise<ScreenshotSaveResult> {
+	const resolvedPath = resolveScreenshotPath(savePath, cwd);
+	const pngBytes = Buffer.from(base64Png, "base64");
+
+	await withFileMutationQueue(resolvedPath.path, async () => {
+		throwIfAborted(signal);
+		await ensureSafeScreenshotParent(resolvedPath);
+		await assertSafeScreenshotTargetPath(resolvedPath);
+		await writeScreenshotFileSafely(resolvedPath, pngBytes, signal);
+	});
+
+	return {
+		savedPath: resolvedPath.path,
+		bytes: pngBytes.byteLength,
+		isDefaultPath: resolvedPath.isDefault,
+	};
+}
+
+export function resolveScreenshotPath(savePath: string | undefined, cwd: string): ResolvedScreenshotPath {
+	const cwdRoot = resolve(cwd);
+	const tempRoot = resolve(tmpdir());
+
+	if (savePath === undefined) {
+		return {
+			path: join(tempRoot, `pi-chrome-devtools-screenshot-${randomUUID()}.png`),
+			allowedRoots: [tempRoot],
+			isDefault: true,
+		};
+	}
+
+	const normalizedPath = stripLeadingAtPath(savePath);
+	if (!normalizedPath.trim()) {
+		throw new Error("Screenshot savePath must not be empty.");
+	}
+	if (normalizedPath.includes("\0")) {
+		throw new Error("Screenshot savePath must not contain NUL bytes.");
+	}
+	if (hasParentPathSegment(normalizedPath)) {
+		throw new Error("Screenshot savePath must not contain '..' path segments.");
+	}
+
+	const isAbsolutePath = isAbsolute(normalizedPath);
+	const path = isAbsolutePath ? resolve(normalizedPath) : resolve(cwdRoot, normalizedPath);
+	const allowedRoots = isAbsolutePath ? unique([cwdRoot, tempRoot]) : [cwdRoot];
+	if (!allowedRoots.some((root) => isPathInsideRoot(path, root))) {
+		throw new Error(
+			"Screenshot savePath must be relative to the current working directory, or an absolute path inside the current working directory or OS temp directory.",
+		);
+	}
+
+	return { path, allowedRoots, isDefault: false };
+}
+
+function stripLeadingAtPath(path: string) {
+	return path.startsWith("@") ? path.slice(1) : path;
+}
+
+export function hasParentPathSegment(path: string) {
+	return path.split(/[\\/]+/).some((part) => part === "..");
+}
+
+async function ensureSafeScreenshotParent(resolvedPath: ResolvedScreenshotPath) {
+	const parentPath = dirname(resolvedPath.path);
+	const rootPath = selectAllowedRoot(parentPath, resolvedPath.allowedRoots);
+	if (!rootPath) {
+		throw new Error(
+			"Screenshot savePath parent must stay inside the current working directory or OS temp directory.",
+		);
+	}
+
+	const realRootPath = await realpath(rootPath);
+	let currentPath = rootPath;
+	const parentSegments = relative(rootPath, parentPath)
+		.split(/[\\/]+/)
+		.filter((part) => part.length > 0);
+
+	for (const segment of parentSegments) {
+		currentPath = join(currentPath, segment);
+		await ensureSafeDirectorySegment(currentPath, realRootPath);
+	}
+}
+
+export function selectAllowedRoot(path: string, roots: readonly string[]) {
+	const matchingRoots = roots.filter((root) => isPathInsideRoot(path, root));
+	matchingRoots.sort(
+		(left, right) =>
+			normalizePathForComparison(resolve(right)).length -
+			normalizePathForComparison(resolve(left)).length,
+	);
+	return matchingRoots[0];
+}
+
+async function ensureSafeDirectorySegment(path: string, realRootPath: string) {
+	const existingDirectory = await lstat(path).catch(async (error: unknown) => {
+		if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+		await mkdir(path).catch((mkdirError: unknown) => {
+			if (!isNodeError(mkdirError) || mkdirError.code !== "EEXIST") throw mkdirError;
+		});
+		return lstat(path);
+	});
+
+	if (existingDirectory.isSymbolicLink()) {
+		throw new Error("Screenshot savePath parent directories must not contain symbolic links.");
+	}
+	if (!existingDirectory.isDirectory()) {
+		throw new Error("Screenshot savePath parent must be a directory.");
+	}
+	await assertPathWithinRealRoot(path, realRootPath);
+}
+
+async function assertSafeScreenshotTargetPath(resolvedPath: ResolvedScreenshotPath) {
+	const existingTarget = await lstat(resolvedPath.path).catch((error: unknown) => {
+		if (isNodeError(error) && error.code === "ENOENT") return undefined;
+		throw error;
+	});
+	if (existingTarget?.isSymbolicLink()) {
+		throw new Error("Screenshot savePath must not point to a symbolic link.");
+	}
+	if (existingTarget?.isDirectory()) {
+		throw new Error("Screenshot savePath must point to a file, not a directory.");
+	}
+	if (existingTarget && !existingTarget.isFile()) {
+		throw new Error("Screenshot savePath may only replace regular files.");
+	}
+
+	const realAllowedRoots = await Promise.all(resolvedPath.allowedRoots.map(realpathOrResolvedPath));
+	const realParent = await realpath(dirname(resolvedPath.path));
+	const realTargetPath = join(realParent, basename(resolvedPath.path));
+	if (!realAllowedRoots.some((root) => isPathInsideRoot(realTargetPath, root))) {
+		throw new Error(
+			"Screenshot savePath resolves outside the current working directory or OS temp directory.",
+		);
+	}
+}
+
+async function assertPathWithinRealRoot(path: string, realRootPath: string) {
+	const realPath = await realpath(path);
+	if (!isPathInsideRoot(realPath, realRootPath)) {
+		throw new Error(
+			"Screenshot savePath parent resolves outside the current working directory or OS temp directory.",
+		);
+	}
+}
+
+async function writeScreenshotFileSafely(
+	resolvedPath: ResolvedScreenshotPath,
+	pngBytes: Buffer,
+	signal: AbortSignal | undefined,
+) {
+	const tempFile = join(
+		dirname(resolvedPath.path),
+		`.${basename(resolvedPath.path)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`,
+	);
+	try {
+		await writeFile(tempFile, pngBytes, { flag: "wx", signal });
+		throwIfAborted(signal);
+		await replaceScreenshotFile(resolvedPath, tempFile, signal);
+	} catch (error) {
+		await rm(tempFile, { force: true }).catch(() => undefined);
+		throw error;
+	}
+}
+
+async function replaceScreenshotFile(
+	resolvedPath: ResolvedScreenshotPath,
+	tempFile: string,
+	signal: AbortSignal | undefined,
+) {
+	try {
+		await rename(tempFile, resolvedPath.path);
+		return;
+	} catch (error) {
+		if (!shouldRetryRenameAfterRemovingDestination(error)) throw error;
+	}
+
+	// Some Windows filesystems reject renaming over an existing file. Revalidate before
+	// removing the destination so the fallback still refuses directories and symlinks.
+	await assertSafeScreenshotTargetPath(resolvedPath);
+	throwIfAborted(signal);
+	await rm(resolvedPath.path, { force: true });
+	await rename(tempFile, resolvedPath.path);
+}
+
+function shouldRetryRenameAfterRemovingDestination(error: unknown) {
+	return (
+		process.platform === "win32" &&
+		isNodeError(error) &&
+		["EACCES", "EEXIST", "EPERM"].includes(error.code ?? "")
+	);
+}
+
+async function realpathOrResolvedPath(path: string) {
+	return realpath(path).catch(() => resolve(path));
+}
+
+export function isPathInsideRoot(path: string, root: string) {
+	const normalizedPath = normalizePathForComparison(resolve(path));
+	const normalizedRoot = normalizePathForComparison(resolve(root));
+	if (normalizedPath === normalizedRoot) return true;
+	const rootWithSeparator = normalizedRoot.endsWith(sep) ? normalizedRoot : `${normalizedRoot}${sep}`;
+	return normalizedPath.startsWith(rootWithSeparator);
+}
+
+function normalizePathForComparison(path: string) {
+	return process.platform === "win32" ? path.toLowerCase() : path;
+}
+
+export function throwIfAborted(signal: AbortSignal | undefined) {
+	if (!signal?.aborted) return;
+	throw signal.reason instanceof Error ? signal.reason : new Error("Screenshot capture cancelled.");
+}
+
+export function formatScreenshotText(page: DevToolsPage, screenshot: ScreenshotSaveResult) {
+	const pathLabel = screenshot.isDefaultPath ? "Saved to temp file" : "Saved to";
+	return [
+		`Captured PNG screenshot from ${page.title || page.url || page.id}.`,
+		`${pathLabel}: ${screenshot.savedPath}`,
+		`Bytes: ${screenshot.bytes}`,
+		`Use read({ path: ${JSON.stringify(screenshot.savedPath)} }) to inspect the saved screenshot if inline image content is not available.`,
+	].join("\n");
+}

package/src/settings.ts

@@ -0,0 +1,196 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { access, link, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import {
+	CHROME_DEVTOOLS_TOOL_NAMES,
+	type ChromeDevToolsToolName,
+} from "./tool-names.js";
+
+const NEW_SETTINGS_FILE_NAME = "pi-chrome-devtools.json";
+const LEGACY_SETTINGS_FILE_NAME = "pi-chrome-devtools-settings.json";
+export interface ChromeDevToolsSettings {
+	tools: ChromeDevToolsToolName[];
+	updatedAt: number;
+}
+
+export type SettingsLoadResult =
+	| { kind: "missing"; notice?: string }
+	| { kind: "invalid"; reason: string; notice?: string }
+	| { kind: "loaded"; settings: ChromeDevToolsSettings; notice?: string };
+
+type SettingsMigrationResult = {
+	kind: "migrated" | "failed";
+	notice: string;
+};
+
+export async function loadSettings(): Promise<SettingsLoadResult> {
+	const newPath = settingsFilePath();
+	const newSettings = await readSettingsFile(newPath);
+	if (newSettings.kind !== "missing") {
+		return withLegacyIgnoredNotice(newSettings);
+	}
+
+	const legacyPath = legacySettingsFilePath();
+	const legacySettings = await readSettingsFile(legacyPath);
+	const concurrentlyCreatedSettings = await readSettingsFile(newPath);
+	if (concurrentlyCreatedSettings.kind !== "missing") {
+		return withLegacyIgnoredNotice(concurrentlyCreatedSettings);
+	}
+	if (legacySettings.kind === "missing") return { kind: "missing" };
+	if (legacySettings.kind === "invalid") return legacySettings;
+
+	const migration = await migrateLegacySettings(legacyPath, legacySettings.settings);
+	if (migration.kind === "failed") {
+		const settingsCreatedDuringMigration = await readSettingsFile(newPath);
+		if (settingsCreatedDuringMigration.kind !== "missing") {
+			return withLegacyIgnoredNotice(settingsCreatedDuringMigration);
+		}
+	}
+
+	return { ...legacySettings, notice: migration.notice };
+}
+
+async function readSettingsFile(filePath: string): Promise<SettingsLoadResult> {
+	let text: string;
+	try {
+		text = await readFile(filePath, "utf8");
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return { kind: "missing" };
+		return { kind: "invalid", reason: `${filePath}: ${formatError(error)}` };
+	}
+
+	try {
+		const parsed = JSON.parse(text) as unknown;
+		const settings = normalizeChromeDevtoolsSettings(parsed);
+		if (settings) return { kind: "loaded", settings };
+		return {
+			kind: "invalid",
+			reason: `${filePath}: expected tools to be an array of Chrome DevTools tool names`,
+		};
+	} catch (error) {
+		return { kind: "invalid", reason: `${filePath}: ${formatError(error)}` };
+	}
+}
+
+async function withLegacyIgnoredNotice(settings: SettingsLoadResult): Promise<SettingsLoadResult> {
+	if (!(await fileExists(legacySettingsFilePath()))) return settings;
+	return {
+		...settings,
+		notice: `Chrome DevTools legacy settings ignored: ${legacySettingsFilePath()} exists, but ${settingsFilePath()} takes precedence. Delete ${LEGACY_SETTINGS_FILE_NAME} after confirming your settings.`,
+	};
+}
+
+export async function installSettingsFileExclusively(filePath: string, contents: string) {
+	await mkdir(dirname(filePath), { recursive: true });
+	const tempFile = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		await writeFile(tempFile, contents, { encoding: "utf8", flag: "wx" });
+		await link(tempFile, filePath);
+	} finally {
+		await rm(tempFile, { force: true }).catch(() => undefined);
+	}
+}
+
+async function migrateLegacySettings(
+	legacyPath: string,
+	settings: ChromeDevToolsSettings,
+): Promise<SettingsMigrationResult> {
+	const newPath = settingsFilePath();
+	try {
+		await installSettingsFileExclusively(
+			newPath,
+			`${JSON.stringify(settings, null, 2)}\n`,
+		);
+	} catch (error) {
+		return {
+			kind: "failed",
+			notice: `Chrome DevTools legacy settings migration failed: could not migrate ${legacyPath} to ${newPath}: ${formatError(error)}. The legacy file was used for this session; future saves will write ${NEW_SETTINGS_FILE_NAME}.`,
+		};
+	}
+
+	try {
+		await rm(legacyPath, { force: true });
+	} catch (error) {
+		return {
+			kind: "migrated",
+			notice: `Chrome DevTools settings migrated from ${legacyPath} to ${newPath}, but the legacy file could not be removed: ${formatError(error)}. Delete ${LEGACY_SETTINGS_FILE_NAME} after confirming your settings.`,
+		};
+	}
+
+	return {
+		kind: "migrated",
+		notice: `Chrome DevTools settings migrated from ${legacyPath} to ${newPath}. ${LEGACY_SETTINGS_FILE_NAME} is deprecated and will be removed in a future major release.`,
+	};
+}
+
+async function fileExists(filePath: string) {
+	try {
+		await access(filePath, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export function normalizeChromeDevtoolsSettings(value: unknown): ChromeDevToolsSettings | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const settings = value as { tools?: unknown; updatedAt?: unknown };
+	if (typeof settings.updatedAt !== "number") return undefined;
+
+	if (settings.tools === "enabled") {
+		return { tools: [...CHROME_DEVTOOLS_TOOL_NAMES], updatedAt: settings.updatedAt };
+	}
+	if (settings.tools === "disabled") return { tools: [], updatedAt: settings.updatedAt };
+
+	if (!Array.isArray(settings.tools)) return undefined;
+	if (!settings.tools.every(isChromeDevtoolsToolName)) return undefined;
+	return { tools: orderedUniqueChromeDevtoolsTools(settings.tools), updatedAt: settings.updatedAt };
+}
+
+function isChromeDevtoolsToolName(value: unknown): value is ChromeDevToolsToolName {
+	return typeof value === "string" && CHROME_DEVTOOLS_TOOL_NAMES.includes(value as never);
+}
+
+function orderedUniqueChromeDevtoolsTools(tools: readonly ChromeDevToolsToolName[]) {
+	const selectedTools = new Set(tools);
+	return CHROME_DEVTOOLS_TOOL_NAMES.filter((toolName) => selectedTools.has(toolName));
+}
+
+export async function saveSettings(settings: ChromeDevToolsSettings) {
+	const filePath = settingsFilePath();
+	await mkdir(dirname(filePath), { recursive: true });
+	const tempFile = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+	try {
+		await writeFile(tempFile, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+		await rename(tempFile, filePath);
+	} catch (error) {
+		await rm(tempFile, { force: true }).catch(() => undefined);
+		throw error;
+	}
+}
+
+export function settingsFilePath() {
+	return join(agentDir(), NEW_SETTINGS_FILE_NAME);
+}
+
+function legacySettingsFilePath() {
+	return join(agentDir(), LEGACY_SETTINGS_FILE_NAME);
+}
+
+function agentDir() {
+	return process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
+}
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+	return error instanceof Error && "code" in error;
+}
+
+function formatError(error: unknown) {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function unique<T>(values: T[]) {
+	return Array.from(new Set(values));
+}

package/src/tool-names.ts

@@ -0,0 +1,9 @@
+export const CHROME_DEVTOOLS_TOOL_NAMES = [
+	"chrome_devtools_list_pages",
+	"chrome_devtools_select_page",
+	"chrome_devtools_navigate",
+	"chrome_devtools_evaluate",
+	"chrome_devtools_screenshot",
+] as const;
+
+export type ChromeDevToolsToolName = (typeof CHROME_DEVTOOLS_TOOL_NAMES)[number];