@oomfware/cbr 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1366 @@
+#!/usr/bin/env node
+import { argument, choice, command, constant, flag, formatDocPage, formatMessage, getDocPage, group, integer, message, object, option, or, parse, passThrough, string } from "@optique/core";
+import { run } from "@optique/run";
+import { spawn } from "node:child_process";
+import { basename, join } from "node:path";
+import { optional, withDefault } from "@optique/core/modifiers";
+import { chromium } from "playwright";
+import yoctoSpinner from "yocto-spinner";
+import { chmod, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import * as v from "valibot";
+import { createServer } from "node:net";
+
+//#region package.json
+var version = "0.1.0";
+
+//#endregion
+//#region src/lib/commands/_types.ts
+/** intentional, user-facing error thrown by command handlers */
+var CommandError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CommandError";
+	}
+};
+
+//#endregion
+//#region src/lib/commands/back.ts
+const schema$28 = object({ command: constant("back") });
+const handler$28 = async (state) => {
+	const start = performance.now();
+	await state.page.goBack({ waitUntil: "domcontentloaded" });
+	const elapsed = ((performance.now() - start) / 1e3).toFixed(1);
+	return `navigated back to ${state.page.url()} (${elapsed}s)`;
+};
+
+//#endregion
+//#region src/lib/snapshot.ts
+/** roles that represent interactive elements — always get refs */
+const INTERACTIVE_ROLES = new Set([
+	"button",
+	"link",
+	"textbox",
+	"checkbox",
+	"radio",
+	"combobox",
+	"listbox",
+	"menuitem",
+	"menuitemcheckbox",
+	"menuitemradio",
+	"option",
+	"searchbox",
+	"slider",
+	"spinbutton",
+	"switch",
+	"tab",
+	"treeitem"
+]);
+/** content roles — get refs only when they have a name */
+const CONTENT_ROLES = new Set([
+	"heading",
+	"cell",
+	"gridcell",
+	"columnheader",
+	"rowheader",
+	"listitem",
+	"article",
+	"region",
+	"main",
+	"navigation"
+]);
+/** structural roles — stripped in compact mode when unnamed */
+const STRUCTURAL_ROLES = new Set([
+	"generic",
+	"group",
+	"list",
+	"table",
+	"row",
+	"rowgroup",
+	"grid",
+	"treegrid",
+	"menu",
+	"menubar",
+	"toolbar",
+	"tablist",
+	"tree",
+	"directory",
+	"document",
+	"application",
+	"presentation",
+	"none"
+]);
+const makeKey = (role, name) => `${role}:${name ?? ""}`;
+const createRoleNameTracker = () => {
+	const counts = /* @__PURE__ */ new Map();
+	const refsByKey = /* @__PURE__ */ new Map();
+	return {
+		getNextIndex(role, name) {
+			const key = makeKey(role, name);
+			const index = counts.get(key) ?? 0;
+			counts.set(key, index + 1);
+			return index;
+		},
+		trackRef(role, name, ref) {
+			const key = makeKey(role, name);
+			const existing = refsByKey.get(key);
+			if (existing) existing.push(ref);
+			else refsByKey.set(key, [ref]);
+		},
+		getDuplicateKeys() {
+			const dupes = /* @__PURE__ */ new Set();
+			for (const [key, refs] of refsByKey) if (refs.length > 1) dupes.add(key);
+			return dupes;
+		}
+	};
+};
+const LINE_RE = /^(\s*-\s*)(\w+)(?:\s+"([^"]*)")?(.*)$/;
+/**
+* takes a snapshot of the page's accessibility tree and assigns element refs.
+* @param page the Playwright page
+* @param options snapshot options
+* @returns object with the formatted snapshot text and the ref map
+*/
+const takeSnapshot = async (page, options = {}) => {
+	const ariaTree = await (options.selector ? page.locator(options.selector) : page.locator("body")).ariaSnapshot();
+	const refs = {};
+	let refCounter = 0;
+	const tracker = createRoleNameTracker();
+	const nextRef = () => `e${++refCounter}`;
+	const lines = ariaTree.split("\n");
+	const output = [];
+	for (const line of lines) {
+		const match = line.match(LINE_RE);
+		if (!match) {
+			if (!options.interactive) {
+				const depth = Math.floor((line.search(/\S/) || 0) / 2);
+				output.push({
+					text: line,
+					depth,
+					hasRef: false,
+					hasContent: line.trim().length > 0
+				});
+			}
+			continue;
+		}
+		const [, prefix, role, name, suffix] = match;
+		const roleLower = role.toLowerCase();
+		const depth = Math.floor((prefix.search(/\S/) === -1 ? prefix.length : prefix.search(/\S/)) / 2);
+		if (options.depth !== void 0 && depth > options.depth) continue;
+		const isInteractive = INTERACTIVE_ROLES.has(roleLower);
+		const isContent = CONTENT_ROLES.has(roleLower);
+		const isStructural = STRUCTURAL_ROLES.has(roleLower);
+		if (options.interactive && !isInteractive) continue;
+		if (options.compact && isStructural && !name) continue;
+		const shouldHaveRef = isInteractive || isContent && !!name;
+		let refTag = "";
+		if (shouldHaveRef) {
+			const ref = nextRef();
+			const nth = tracker.getNextIndex(roleLower, name);
+			tracker.trackRef(roleLower, name, ref);
+			refs[ref] = {
+				role: roleLower,
+				name,
+				nth
+			};
+			refTag = ` [ref=${ref}]`;
+		}
+		const nthTag = shouldHaveRef && refs[`e${refCounter}`]?.nth ? ` [nth=${refs[`e${refCounter}`].nth}]` : "";
+		const reconstructed = name ? `${prefix}${role} "${name}"${refTag}${nthTag}${suffix}` : `${prefix}${role}${refTag}${suffix}`;
+		const hasInlineContent = !!suffix && suffix.includes(":") && !suffix.endsWith(":");
+		output.push({
+			text: reconstructed,
+			depth,
+			hasRef: shouldHaveRef,
+			hasContent: hasInlineContent || !!name
+		});
+	}
+	{
+		const dupes = tracker.getDuplicateKeys();
+		for (const [ref, entry] of Object.entries(refs)) {
+			const key = makeKey(entry.role, entry.name);
+			if (!dupes.has(key)) {
+				entry.nth = void 0;
+				const idx = output.findIndex((l) => l.text.includes(`[ref=${ref}]`));
+				if (idx !== -1) output[idx].text = output[idx].text.replace(/\s*\[nth=\d+\]/, "");
+			}
+		}
+	}
+	if (options.compact) return {
+		text: compactTree(output).map((l) => l.text).join("\n"),
+		refs
+	};
+	return {
+		text: output.map((l) => l.text).join("\n"),
+		refs
+	};
+};
+/**
+* prunes branches from the tree that contain no refs.
+* keeps: lines with refs, lines with inline content, and structural ancestors of ref-bearing lines.
+*/
+const compactTree = (lines) => {
+	const keep = Array.from({ length: lines.length }, () => false);
+	for (let i = 0; i < lines.length; i++) if (lines[i].hasRef || lines[i].hasContent) keep[i] = true;
+	for (let i = 0; i < lines.length; i++) {
+		if (!keep[i]) continue;
+		const targetDepth = lines[i].depth;
+		for (let j = i - 1; j >= 0 && lines[j].depth < targetDepth; j--) if (!keep[j]) keep[j] = true;
+	}
+	return lines.filter((_, i) => keep[i]);
+};
+/**
+* parses a ref string (e.g. "@e1", "ref=e1", "e1") into the bare ref id.
+* @param input the ref string
+* @returns the bare ref id or null if not a valid ref format
+*/
+const parseRef = (input) => {
+	if (input.startsWith("@")) return input.slice(1);
+	if (input.startsWith("ref=")) return input.slice(4);
+	if (/^e\d+$/.test(input)) return input;
+	return null;
+};
+/**
+* resolves a ref or CSS selector to a Playwright locator.
+* @param page the Playwright page
+* @param selectorOrRef a ref string (e.g. "@e1") or CSS selector
+* @param refs the current ref map
+* @returns the resolved Playwright locator
+* @throws if a ref is provided but not found in the ref map
+*/
+const resolveLocator = (page, selectorOrRef, refs) => {
+	const ref = parseRef(selectorOrRef);
+	if (ref) {
+		const entry = refs[ref];
+		if (!entry) throw new Error(`ref ${selectorOrRef} not found — run snapshot to refresh refs`);
+		let locator;
+		if (entry.name) locator = page.getByRole(entry.role, {
+			name: entry.name,
+			exact: true
+		});
+		else locator = page.getByRole(entry.role);
+		if (entry.nth !== void 0) locator = locator.nth(entry.nth);
+		return locator;
+	}
+	return page.locator(selectorOrRef);
+};
+
+//#endregion
+//#region src/lib/commands/_utils.ts
+/** resolves a ref or CSS selector to a Playwright locator */
+const getLocator = (state, selectorOrRef) => {
+	return resolveLocator(state.page, selectorOrRef, state.refs);
+};
+/** formats a byte count into a human-readable string */
+const formatBytes = (bytes) => {
+	if (bytes === 0) return "0 B";
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB"
+	];
+	const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
+	const value = bytes / 1024 ** i;
+	return `${i === 0 ? value : value.toFixed(1)} ${units[i]}`;
+};
+/** extracts a filename from a URL, falling back to a generic name */
+const filenameFromUrl = (url) => {
+	try {
+		const pathname = new URL(url).pathname;
+		const base = basename(pathname);
+		if (base && base !== "/" && !base.startsWith(".")) return base.split("?")[0];
+	} catch {}
+	return "download";
+};
+
+//#endregion
+//#region src/lib/commands/check.ts
+const schema$27 = object({
+	command: constant("check"),
+	selector: argument(string({ metavar: "SELECTOR" }))
+});
+const handler$27 = async (state, args) => {
+	await getLocator(state, args.selector).check();
+	return "checked";
+};
+
+//#endregion
+//#region src/lib/commands/click.ts
+const schema$26 = object({
+	command: constant("click"),
+	selector: argument(string({ metavar: "SELECTOR" }))
+});
+const handler$26 = async (state, args) => {
+	await getLocator(state, args.selector).click();
+	return "clicked";
+};
+
+//#endregion
+//#region src/lib/commands/close.ts
+const schema$25 = object({ command: constant("close") });
+const handler$25 = async (state) => {
+	await state.page.close();
+	const pages = state.context.pages();
+	if (pages.length > 0) {
+		state.page = pages[0];
+		return "tab closed, switched to remaining tab";
+	}
+	return "browser closed";
+};
+
+//#endregion
+//#region src/lib/commands/dblclick.ts
+const schema$24 = object({
+	command: constant("dblclick"),
+	selector: argument(string({ metavar: "SELECTOR" }))
+});
+const handler$24 = async (state, args) => {
+	await getLocator(state, args.selector).dblclick();
+	return "double-clicked";
+};
+
+//#endregion
+//#region src/lib/commands/download.ts
+const schema$23 = object({
+	command: constant("download"),
+	url: argument(string({ metavar: "URL" }), { description: message`URL of the resource to download` }),
+	filename: optional(argument(string({ metavar: "FILENAME" }), { description: message`save as this filename` }))
+});
+const handler$23 = async (state, args) => {
+	const filename = args.filename ?? filenameFromUrl(args.url);
+	const start = performance.now();
+	const response = await state.page.request.get(args.url);
+	if (!response.ok()) throw new CommandError(`download failed: ${response.status()} ${response.statusText()}`);
+	const buffer = await response.body();
+	await writeFile(join(state.assetsDir, filename), buffer);
+	return `saved assets/${filename} (${formatBytes(buffer.length)}, ${((performance.now() - start) / 1e3).toFixed(1)}s)`;
+};
+
+//#endregion
+//#region src/lib/commands/eval.ts
+const schema$22 = object({
+	command: constant("eval"),
+	code: passThrough({
+		format: "greedy",
+		description: message`JavaScript code to evaluate`
+	})
+});
+const handler$22 = async (state, args) => {
+	const code = args.code.join(" ");
+	if (!code) throw new CommandError("missing code to evaluate");
+	const result = await state.page.evaluate(code);
+	if (result === void 0 || result === null) return;
+	return typeof result === "string" ? result : JSON.stringify(result, null, 2);
+};
+
+//#endregion
+//#region src/lib/commands/fill.ts
+const schema$21 = object({
+	command: constant("fill"),
+	selector: argument(string({ metavar: "SELECTOR" }), { description: message`input element to fill` }),
+	text: argument(string({ metavar: "TEXT" }), { description: message`text to fill in` })
+});
+const handler$21 = async (state, args) => {
+	await getLocator(state, args.selector).fill(args.text);
+	return "filled";
+};
+
+//#endregion
+//#region src/lib/commands/forward.ts
+const schema$20 = object({ command: constant("forward") });
+const handler$20 = async (state) => {
+	const start = performance.now();
+	await state.page.goForward({ waitUntil: "domcontentloaded" });
+	const elapsed = ((performance.now() - start) / 1e3).toFixed(1);
+	return `navigated forward to ${state.page.url()} (${elapsed}s)`;
+};
+
+//#endregion
+//#region src/lib/commands/frame.ts
+const schema$19 = object({
+	command: constant("frame"),
+	subcommand: or(command("list", object({ kind: constant("list") }), { description: message`list all frames with IDs, URLs, and parent info` }), command("main", object({ kind: constant("main") }), { description: message`switch to the main frame` }), object({
+		kind: constant("switch"),
+		id: argument(string({ metavar: "FRAME_ID" }), { description: message`frame ref to switch to` })
+	}))
+});
+/**
+* collects child frames from the page, assigns IDs (`f1`, `f2`, ...), and
+* stores them in `state.frameRefs`. the main frame is excluded since
+* `frame main` handles switching back to it.
+*/
+const refreshFrameRefs = (state) => {
+	const mainPage = state.context.pages()[0];
+	const mainFrame = mainPage.mainFrame();
+	const childFrames = mainPage.frames().filter((f) => f !== mainFrame);
+	const map = {};
+	for (let i = 0; i < childFrames.length; i++) map[`f${i + 1}`] = childFrames[i];
+	state.frameRefs = map;
+	return map;
+};
+const formatFrameList = (refs, currentPage) => {
+	const mainFrame = currentPage.mainFrame();
+	const currentFrame = currentPage;
+	const lines = [];
+	{
+		const marker = currentFrame === mainFrame ? "* " : "  ";
+		lines.push(`${marker}main: ${mainFrame.url()}`);
+	}
+	for (const [id, frame] of Object.entries(refs)) {
+		const marker = frame === currentFrame ? "* " : "  ";
+		const name = frame.name() ? ` name="${frame.name()}"` : "";
+		let parentTag = "";
+		{
+			const parent = frame.parentFrame();
+			if (parent === mainFrame) parentTag = " (parent: main)";
+			else if (parent) {
+				const parentId = Object.entries(refs).find(([, f]) => f === parent)?.[0];
+				if (parentId) parentTag = ` (parent: ${parentId})`;
+			}
+		}
+		lines.push(`${marker}${id}: ${frame.url()}${name}${parentTag}`);
+	}
+	return lines.join("\n");
+};
+const handler$19 = async (state, args) => {
+	const sub = args.subcommand;
+	switch (sub.kind) {
+		case "list": return formatFrameList(refreshFrameRefs(state), state.page);
+		case "main":
+			state.page = state.context.pages()[0];
+			return "switched to main frame";
+		case "switch": {
+			const frame = state.frameRefs[sub.id];
+			if (!frame) throw new CommandError(`frame ${sub.id} not found — run \`browser frame list\` to list frames and get IDs`);
+			state.page = frame;
+			return `switched to frame ${sub.id}: ${frame.url()}`;
+		}
+	}
+};
+
+//#endregion
+//#region src/lib/commands/get.ts
+const schema$18 = object({
+	command: constant("get"),
+	subcommand: or(command("text", object({
+		kind: constant("text"),
+		selector: argument(string({ metavar: "SELECTOR" }))
+	}), { description: message`get inner text of an element` }), command("url", object({ kind: constant("url") }), { description: message`get the current page URL` }), command("title", object({ kind: constant("title") }), { description: message`get the current page title` }), command("html", object({
+		kind: constant("html"),
+		selector: argument(string({ metavar: "SELECTOR" }))
+	}), { description: message`get inner HTML of an element` }), command("value", object({
+		kind: constant("value"),
+		selector: argument(string({ metavar: "SELECTOR" }))
+	}), { description: message`get the value of an input field` }), command("attr", object({
+		kind: constant("attr"),
+		selector: argument(string({ metavar: "SELECTOR" })),
+		attribute: argument(string({ metavar: "ATTR" }))
+	}), { description: message`get an attribute of an element` }), command("count", object({
+		kind: constant("count"),
+		selector: argument(string({ metavar: "SELECTOR" }))
+	}), { description: message`count matching elements` }))
+});
+const handler$18 = async (state, args) => {
+	switch (args.subcommand.kind) {
+		case "text": return await getLocator(state, args.subcommand.selector).innerText();
+		case "url": return state.page.url();
+		case "title": return await state.page.title();
+		case "html": return await getLocator(state, args.subcommand.selector).innerHTML();
+		case "value": return await getLocator(state, args.subcommand.selector).inputValue();
+		case "attr": return await getLocator(state, args.subcommand.selector).getAttribute(args.subcommand.attribute) ?? "";
+		case "count": {
+			const count = await getLocator(state, args.subcommand.selector).count();
+			return String(count);
+		}
+	}
+};
+
+//#endregion
+//#region src/lib/commands/hover.ts
+const schema$17 = object({
+	command: constant("hover"),
+	selector: argument(string({ metavar: "SELECTOR" }))
+});
+const handler$17 = async (state, args) => {
+	await getLocator(state, args.selector).hover();
+	return "hovered";
+};
+
+//#endregion
+//#region src/lib/commands/is.ts
+const schema$16 = object({
+	command: constant("is"),
+	subcommand: or(command("visible", object({
+		kind: constant("visible"),
+		selector: argument(string({ metavar: "SELECTOR" }))
+	}), { description: message`check if an element is visible` }), command("enabled", object({
+		kind: constant("enabled"),
+		selector: argument(string({ metavar: "SELECTOR" }))
+	}), { description: message`check if an element is enabled` }), command("checked", object({
+		kind: constant("checked"),
+		selector: argument(string({ metavar: "SELECTOR" }))
+	}), { description: message`check if a checkbox is checked` }))
+});
+const handler$16 = async (state, args) => {
+	switch (args.subcommand.kind) {
+		case "visible": {
+			const visible = await getLocator(state, args.subcommand.selector).isVisible();
+			return String(visible);
+		}
+		case "enabled": {
+			const enabled = await getLocator(state, args.subcommand.selector).isEnabled();
+			return String(enabled);
+		}
+		case "checked": {
+			const checked = await getLocator(state, args.subcommand.selector).isChecked();
+			return String(checked);
+		}
+	}
+};
+
+//#endregion
+//#region src/lib/commands/open.ts
+const schema$15 = object({
+	command: constant("open"),
+	url: argument(string({ metavar: "URL" }))
+});
+const handler$15 = async (state, args) => {
+	const start = performance.now();
+	await state.page.goto(args.url, { waitUntil: "domcontentloaded" });
+	const elapsed = ((performance.now() - start) / 1e3).toFixed(1);
+	return `navigated to ${state.page.url()} (${elapsed}s)`;
+};
+
+//#endregion
+//#region src/lib/commands/press.ts
+const schema$14 = object({
+	command: constant("press"),
+	key: argument(string({ metavar: "KEY" }))
+});
+const handler$14 = async (state, args) => {
+	await state.page.keyboard.press(args.key);
+	return `pressed ${args.key}`;
+};
+
+//#endregion
+//#region src/lib/commands/reload.ts
+const schema$13 = object({ command: constant("reload") });
+const handler$13 = async (state) => {
+	const start = performance.now();
+	await state.page.reload({ waitUntil: "domcontentloaded" });
+	const elapsed = ((performance.now() - start) / 1e3).toFixed(1);
+	return `reloaded ${state.page.url()} (${elapsed}s)`;
+};
+
+//#endregion
+//#region src/lib/commands/resources.ts
+const schema$12 = object({
+	command: constant("resources"),
+	typeFilter: optional(argument(string({ metavar: "TYPE" }), { description: message`filter by resource type (e.g. script, img)` }))
+});
+const handler$12 = async (state, args) => {
+	const entries = await state.page.evaluate(() => performance.getEntriesByType("resource").map((e) => {
+		const r = e;
+		return {
+			name: r.name,
+			type: r.initiatorType,
+			size: r.transferSize
+		};
+	}));
+	const filtered = args.typeFilter ? entries.filter((e) => e.type === args.typeFilter) : entries;
+	if (filtered.length === 0) return args.typeFilter ? `no resources of type "${args.typeFilter}"` : "no resources recorded";
+	return filtered.map((e) => {
+		const size = e.size > 0 ? ` (${formatBytes(e.size)})` : "";
+		return `[${e.type}] ${e.name}${size}`;
+	}).join("\n");
+};
+
+//#endregion
+//#region src/lib/commands/screenshot.ts
+const schema$11 = object({
+	command: constant("screenshot"),
+	name: optional(argument(string({ metavar: "NAME" }), { description: message`filename for the screenshot` })),
+	full: withDefault(option("--full", { description: message`capture the full scrollable page` }), false)
+});
+const handler$11 = async (state, args) => {
+	state.screenshotCounter++;
+	const name = args.name ?? `screenshot-${state.screenshotCounter}`;
+	const filename = name.endsWith(".png") ? name : `${name}.png`;
+	const filepath = join(state.screenshotDir, filename);
+	await state.page.screenshot({
+		path: filepath,
+		fullPage: args.full
+	});
+	return `screenshot saved to screenshots/${filename}`;
+};
+
+//#endregion
+//#region src/lib/commands/scroll.ts
+const schema$10 = object({
+	command: constant("scroll"),
+	direction: argument(choice(["up", "down"]), { description: message`scroll direction` }),
+	selector: optional(argument(string({ metavar: "SELECTOR" }), { description: message`element to scroll instead of the page` }))
+});
+const handler$10 = async (state, args) => {
+	const delta = args.direction === "down" ? 500 : -500;
+	if (args.selector) await getLocator(state, args.selector).evaluate((el, d) => el.scrollBy(0, d), delta);
+	else await state.page.mouse.wheel(0, delta);
+	return `scrolled ${args.direction}`;
+};
+
+//#endregion
+//#region src/lib/commands/select.ts
+const schema$9 = object({
+	command: constant("select"),
+	selector: argument(string({ metavar: "SELECTOR" }), { description: message`select element to target` }),
+	value: argument(string({ metavar: "VALUE" }), { description: message`option value to select` })
+});
+const handler$9 = async (state, args) => {
+	await getLocator(state, args.selector).selectOption(args.value);
+	return `selected ${args.value}`;
+};
+
+//#endregion
+//#region src/lib/commands/snapshot.ts
+const schema$8 = object({
+	command: constant("snapshot"),
+	interactive: withDefault(option("--interactive", { description: message`only show interactive elements` }), false),
+	compact: withDefault(option("--compact", { description: message`remove empty lines from output` }), false),
+	depth: optional(option("--depth", integer({ min: 0 }), { description: message`maximum tree depth` })),
+	selector: optional(option("--selector", string(), { description: message`scope to a subtree` }))
+});
+const handler$8 = async (state, args) => {
+	const result = await takeSnapshot(state.page, {
+		interactive: args.interactive || void 0,
+		compact: args.compact || void 0,
+		depth: args.depth ?? void 0,
+		selector: args.selector ?? void 0
+	});
+	state.refs = result.refs;
+	return result.text;
+};
+
+//#endregion
+//#region src/lib/commands/source.ts
+const schema$7 = object({
+	command: constant("source"),
+	selector: optional(argument(string({ metavar: "SELECTOR" }), { description: message`element to get HTML for, or full page if omitted` }))
+});
+const handler$7 = async (state, args) => {
+	if (args.selector) return await getLocator(state, args.selector).evaluate((el) => el.outerHTML);
+	return await state.page.content();
+};
+
+//#endregion
+//#region src/lib/commands/styles.ts
+const schema$6 = object({
+	command: constant("styles"),
+	selector: argument(string({ metavar: "SELECTOR" }), { description: message`element to inspect` }),
+	property: optional(argument(string({ metavar: "PROPERTY" }), { description: message`specific CSS property, or all if omitted` }))
+});
+const handler$6 = async (state, args) => {
+	if (args.property) return await getLocator(state, args.selector).evaluate((el, prop) => getComputedStyle(el).getPropertyValue(prop), args.property) || "(empty)";
+	const styles = await getLocator(state, args.selector).evaluate((el) => {
+		const cs = getComputedStyle(el);
+		const props = [
+			"color",
+			"background-color",
+			"font-family",
+			"font-size",
+			"font-weight",
+			"line-height",
+			"display",
+			"position",
+			"width",
+			"height",
+			"margin",
+			"padding",
+			"border",
+			"opacity",
+			"z-index"
+		];
+		const result = {};
+		for (const p of props) {
+			const v = cs.getPropertyValue(p);
+			if (v) result[p] = v;
+		}
+		return result;
+	});
+	return Object.entries(styles).map(([k, v]) => `${k}: ${v}`).join("\n");
+};
+
+//#endregion
+//#region src/lib/commands/tab.ts
+const schema$5 = object({
+	command: constant("tab"),
+	subcommand: or(command("list", object({ kind: constant("list") }), { description: message`list open tabs` }), command("new", object({
+		kind: constant("new"),
+		url: optional(argument(string({ metavar: "URL" }), { description: message`URL to open in the new tab` }))
+	}), { description: message`open a new tab and switch to it` }), command("close", object({
+		kind: constant("close"),
+		index: optional(argument(integer({ min: 0 }), { description: message`tab index to close` }))
+	}), { description: message`close a tab` }), object({
+		kind: constant("switch"),
+		index: argument(integer({ min: 0 }), { description: message`tab index to switch to` })
+	}))
+});
+const handler$5 = async (state, args) => {
+	const sub = args.subcommand;
+	switch (sub.kind) {
+		case "list": return state.context.pages().map((p, i) => {
+			return `${p === state.page ? "* " : "  "}${i}: ${p.url()}`;
+		}).join("\n");
+		case "new": {
+			const newPage = await state.context.newPage();
+			if (sub.url) await newPage.goto(sub.url, { waitUntil: "domcontentloaded" });
+			state.page = newPage;
+			return `opened new tab${sub.url ? ` at ${sub.url}` : ""}`;
+		}
+		case "close": {
+			const pages = state.context.pages();
+			if (sub.index !== void 0) {
+				if (sub.index >= pages.length) throw new CommandError(`invalid tab index: ${sub.index}`);
+				await pages[sub.index].close();
+				if (!state.context.pages().includes(state.page)) state.page = state.context.pages()[0];
+			} else {
+				await state.page.close();
+				state.page = state.context.pages()[0];
+			}
+			return "tab closed";
+		}
+		case "switch": {
+			const pages = state.context.pages();
+			if (sub.index < 0 || sub.index >= pages.length) throw new CommandError(`tab index out of range: ${sub.index} (${pages.length} tabs open)`);
+			state.page = pages[sub.index];
+			await state.page.bringToFront();
+			return `switched to tab ${sub.index}: ${state.page.url()}`;
+		}
+	}
+};
+
+//#endregion
+//#region src/lib/commands/type-text.ts
+const schema$4 = object({
+	command: constant("type"),
+	selector: argument(string({ metavar: "SELECTOR" }), { description: message`element to type into` }),
+	text: argument(string({ metavar: "TEXT" }), { description: message`text to type` })
+});
+const handler$4 = async (state, args) => {
+	await getLocator(state, args.selector).pressSequentially(args.text);
+	return "typed";
+};
+
+//#endregion
+//#region src/lib/commands/uncheck.ts
+const schema$3 = object({
+	command: constant("uncheck"),
+	selector: argument(string({ metavar: "SELECTOR" }))
+});
+const handler$3 = async (state, args) => {
+	await getLocator(state, args.selector).uncheck();
+	return "unchecked";
+};
+
+//#endregion
+//#region src/lib/commands/wait.ts
+const schema$2 = object({
+	command: constant("wait"),
+	subcommand: or(command("for", object({
+		kind: constant("for"),
+		selector: argument(string({ metavar: "SELECTOR" })),
+		timeout: withDefault(option("--timeout", integer({ min: 0 }), { description: message`milliseconds to wait` }), 5e3),
+		hidden: withDefault(option("--hidden", { description: message`wait for the element to disappear` }), false)
+	}), { description: message`wait for an element to appear` }), command("for-text", object({
+		kind: constant("for-text"),
+		text: argument(string({ metavar: "TEXT" })),
+		timeout: withDefault(option("--timeout", integer({ min: 0 }), { description: message`milliseconds to wait` }), 5e3),
+		hidden: withDefault(option("--hidden", { description: message`wait for the text to disappear` }), false)
+	}), { description: message`wait for text content to appear` }), command("for-url", object({
+		kind: constant("for-url"),
+		pattern: argument(string({ metavar: "URL_PATTERN" })),
+		timeout: withDefault(option("--timeout", integer({ min: 0 }), { description: message`milliseconds to wait` }), 5e3)
+	}), { description: message`wait for the URL to match a pattern` }))
+});
+const handler$2 = async (state, args) => {
+	const start = performance.now();
+	const sub = args.subcommand;
+	switch (sub.kind) {
+		case "for": {
+			const waitState = sub.hidden ? "hidden" : "visible";
+			await getLocator(state, sub.selector).waitFor({
+				state: waitState,
+				timeout: sub.timeout
+			});
+			const elapsed = ((performance.now() - start) / 1e3).toFixed(1);
+			return `element ${sub.selector} is ${waitState} (${elapsed}s)`;
+		}
+		case "for-text": {
+			const waitState = sub.hidden ? "hidden" : "visible";
+			await state.page.getByText(sub.text).waitFor({
+				state: waitState,
+				timeout: sub.timeout
+			});
+			const elapsed = ((performance.now() - start) / 1e3).toFixed(1);
+			return `text "${sub.text}" is ${waitState} (${elapsed}s)`;
+		}
+		case "for-url": {
+			await state.page.waitForURL(sub.pattern, { timeout: sub.timeout });
+			const elapsed = ((performance.now() - start) / 1e3).toFixed(1);
+			return `url matched ${sub.pattern} (${elapsed}s)`;
+		}
+	}
+};
+
+//#endregion
+//#region src/lib/commands.ts
+const navigation = group("navigation", or(command("open", schema$15, { description: message`navigate to a URL` }), command("back", schema$28, { description: message`go back in history` }), command("forward", schema$20, { description: message`go forward in history` }), command("reload", schema$13, { description: message`reload the current page` }), command("click", schema$26, { description: message`click an element` }), command("dblclick", schema$24, { description: message`double-click an element` }), command("fill", schema$21, { description: message`clear and fill an input field` }), command("type", schema$4, { description: message`type text character by character` }), command("press", schema$14, { description: message`press a keyboard key` })));
+const querying = group("querying", or(command("hover", schema$17, { description: message`hover over an element` }), command("select", schema$9, { description: message`select a dropdown option` }), command("check", schema$27, { description: message`check a checkbox` }), command("uncheck", schema$3, { description: message`uncheck a checkbox` }), command("get", schema$18, { description: message`get page or element data` }), command("is", schema$16, { description: message`check element state` }), command("snapshot", schema$8, { description: message`get the accessibility tree` }), command("screenshot", schema$11, { description: message`take a screenshot` }), command("wait", schema$2, { description: message`wait for an element, text, or URL` })));
+const inspection = group("inspection", or(command("scroll", schema$10, { description: message`scroll the page or a container` }), command("frame", schema$19, { description: message`list or switch frames` }), command("tab", schema$5, { description: message`list, open, switch, or close tabs` }), command("eval", schema$22, { description: message`evaluate JavaScript in the page` }), command("source", schema$7, { description: message`get page or element HTML source` }), command("resources", schema$12, { description: message`list loaded resources` }), command("styles", schema$6, { description: message`get computed styles for an element` }), command("download", schema$23, { description: message`download a resource to assets/` }), command("close", schema$25, { description: message`close the current tab` })));
+const parser = or(navigation, querying, inspection);
+/**
+* creates a command handler that parses args and dispatches to the matching command.
+* @param state mutable browser state shared across commands
+* @returns a command handler compatible with the server
+*/
+const createCommandHandler = (state) => async (args) => {
+	if (args[0] === "help" || args[0] === "--help") {
+		const page = getDocPage(parser, args.slice(1));
+		if (page) return {
+			ok: true,
+			data: formatDocPage("browser", page)
+		};
+		return {
+			ok: false,
+			error: `no help available`
+		};
+	}
+	if (state.spinner.isSpinning) state.spinner.text = ["browser", ...args].join(" ").replace(/\s+/g, " ");
+	const parsed = parse(parser, args);
+	if (!parsed.success) return {
+		ok: false,
+		error: formatMessage(parsed.error)
+	};
+	try {
+		let data;
+		switch (parsed.value.command) {
+			case "open":
+				data = await handler$15(state, parsed.value);
+				break;
+			case "back":
+				data = await handler$28(state);
+				break;
+			case "forward":
+				data = await handler$20(state);
+				break;
+			case "reload":
+				data = await handler$13(state);
+				break;
+			case "click":
+				data = await handler$26(state, parsed.value);
+				break;
+			case "dblclick":
+				data = await handler$24(state, parsed.value);
+				break;
+			case "fill":
+				data = await handler$21(state, parsed.value);
+				break;
+			case "type":
+				data = await handler$4(state, parsed.value);
+				break;
+			case "press":
+				data = await handler$14(state, parsed.value);
+				break;
+			case "hover":
+				data = await handler$17(state, parsed.value);
+				break;
+			case "select":
+				data = await handler$9(state, parsed.value);
+				break;
+			case "check":
+				data = await handler$27(state, parsed.value);
+				break;
+			case "uncheck":
+				data = await handler$3(state, parsed.value);
+				break;
+			case "get":
+				data = await handler$18(state, parsed.value);
+				break;
+			case "is":
+				data = await handler$16(state, parsed.value);
+				break;
+			case "snapshot":
+				data = await handler$8(state, parsed.value);
+				break;
+			case "screenshot":
+				data = await handler$11(state, parsed.value);
+				break;
+			case "wait":
+				data = await handler$2(state, parsed.value);
+				break;
+			case "scroll":
+				data = await handler$10(state, parsed.value);
+				break;
+			case "frame":
+				data = await handler$19(state, parsed.value);
+				break;
+			case "tab":
+				data = await handler$5(state, parsed.value);
+				break;
+			case "eval":
+				data = await handler$22(state, parsed.value);
+				break;
+			case "source":
+				data = await handler$7(state, parsed.value);
+				break;
+			case "resources":
+				data = await handler$12(state, parsed.value);
+				break;
+			case "styles":
+				data = await handler$6(state, parsed.value);
+				break;
+			case "download":
+				data = await handler$23(state, parsed.value);
+				break;
+			case "close":
+				data = await handler$25(state);
+				break;
+		}
+		return {
+			ok: true,
+			data
+		};
+	} catch (e) {
+		if (e instanceof CommandError) return {
+			ok: false,
+			error: e.message
+		};
+		return {
+			ok: false,
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
+};
+
+//#endregion
+//#region src/lib/paths.ts
+/**
+* returns the cache directory for cbr.
+* uses `$XDG_CACHE_HOME/cbr` if set, otherwise falls back to:
+* - `~/.cache/cbr` on linux
+* - `~/Library/Caches/cbr` on macos
+* @returns the cache directory path
+*/
+const getCacheDir = () => {
+	const xdgCache = process.env["XDG_CACHE_HOME"];
+	if (xdgCache) return join(xdgCache, "cbr");
+	const home = homedir();
+	if (process.platform === "darwin") return join(home, "Library", "Caches", "cbr");
+	return join(home, ".cache", "cbr");
+};
+/**
+* returns the sessions directory within the cache.
+* @returns the sessions directory path
+*/
+const getSessionsDir = () => join(getCacheDir(), "sessions");
+const PID_FILE = ".pid";
+const PidSchema = v.pipe(v.string(), v.trim(), v.toNumber(), v.integer(), v.minValue(1));
+/**
+* creates a new session directory with a random UUID, PID lockfile, and subdirectories.
+* @returns the path to the created session directory
+*/
+const createSessionDir = async () => {
+	const sessionPath = join(getSessionsDir(), randomUUID());
+	await mkdir(sessionPath, { recursive: true });
+	await writeFile(join(sessionPath, PID_FILE), process.pid.toString());
+	await Promise.all([
+		mkdir(join(sessionPath, ".claude"), { recursive: true }),
+		mkdir(join(sessionPath, "bin"), { recursive: true }),
+		mkdir(join(sessionPath, "assets"), { recursive: true }),
+		mkdir(join(sessionPath, "screenshots"), { recursive: true }),
+		mkdir(join(sessionPath, "scratch"), { recursive: true })
+	]);
+	return sessionPath;
+};
+/**
+* removes a session directory.
+* @param sessionPath the session directory path
+*/
+const cleanupSessionDir = async (sessionPath) => {
+	await rm(sessionPath, {
+		recursive: true,
+		force: true
+	});
+};
+/**
+* checks if a process with the given PID is running.
+* @param pid the process ID to check
+* @returns true if the process is running
+*/
+const isProcessRunning = (pid) => {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+};
+/**
+* garbage collects orphaned session directories.
+* a session is orphaned if its PID file is missing or the process is no longer running.
+* this function is meant to be called fire-and-forget (errors are silently ignored).
+*/
+const gcSessions = async () => {
+	const sessionsDir = getSessionsDir();
+	let entries;
+	try {
+		entries = await readdir(sessionsDir, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const sessionPath = join(sessionsDir, entry.name);
+		const pidPath = join(sessionPath, PID_FILE);
+		try {
+			const pidContent = await readFile(pidPath, "utf-8");
+			const result = v.safeParse(PidSchema, pidContent);
+			if (!result.success || !isProcessRunning(result.output)) await rm(sessionPath, {
+				recursive: true,
+				force: true
+			});
+		} catch {
+			await rm(sessionPath, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+		}
+	}
+};
+
+//#endregion
+//#region src/lib/debug.ts
+const debugEnabled = process.env.DEBUG === "1" || process.env.CBR_DEBUG === "1";
+/**
+* logs a debug message to stderr if DEBUG=1 or CBR_DEBUG=1.
+* @param message the message to log
+*/
+const debug = (message) => {
+	if (debugEnabled) console.error(`[debug] ${message}`);
+};
+
+//#endregion
+//#region src/lib/server.ts
+const RequestSchema = v.object({
+	id: v.string(),
+	args: v.array(v.string())
+});
+/**
+* starts a JSON-over-Unix-socket server.
+* each connection handles a single newline-delimited JSON request,
+* dispatches to the handler, writes the response, and closes.
+* @param socketPath path to the Unix domain socket
+* @param handler function that processes commands and returns responses
+* @returns promise that resolves with the server instance once listening
+*/
+const startServer = (socketPath, handler) => {
+	return new Promise((resolve, reject) => {
+		const server = createServer((socket) => {
+			let data = "";
+			socket.on("data", (chunk) => {
+				data += chunk.toString();
+				const newlineIndex = data.indexOf("\n");
+				if (newlineIndex === -1) return;
+				const line = data.slice(0, newlineIndex).trim();
+				data = "";
+				handleRequest(line, socket, handler);
+			});
+			socket.on("error", (err) => {
+				debug(`socket error: ${err.message}`);
+			});
+		});
+		server.on("error", reject);
+		server.listen(socketPath, () => {
+			debug(`server listening on ${socketPath}`);
+			resolve(server);
+		});
+	});
+};
+const handleRequest = async (line, socket, handler) => {
+	let parsed;
+	try {
+		parsed = JSON.parse(line);
+	} catch {
+		debug(`ignoring malformed JSON: ${line}`);
+		socket.end();
+		return;
+	}
+	const result = v.safeParse(RequestSchema, parsed);
+	if (!result.success) {
+		debug(`ignoring invalid request: ${line}`);
+		socket.end();
+		return;
+	}
+	const { id, args } = result.output;
+	try {
+		debug(`request: ${line}`);
+		const result = await handler(args);
+		const response = JSON.stringify({
+			id,
+			...result
+		});
+		debug(`response: ${response}`);
+		socket.end(response + "\n");
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		const response = JSON.stringify({
+			id,
+			ok: false,
+			error: message
+		});
+		debug(`handler error: ${message}`);
+		socket.end(response + "\n");
+	}
+};
+
+//#endregion
+//#region src/lib/session.ts
+/**
+* writes the per-session `.claude/settings.json` with permissions and hooks.
+* paths are baked in at generation time so the settings work regardless of cwd.
+* @param sessionPath the session directory path
+*/
+const writeSessionSettings = async (sessionPath) => {
+	const settings = {
+		permissions: {
+			allow: [
+				"Read(assets/*)",
+				"Read(screenshots/*)",
+				"Read(scratch/*)",
+				"Write(scratch/*)",
+				"Glob(assets/*)",
+				"Glob(screenshots/*)",
+				"Glob(scratch/*)",
+				"Grep(assets/*)",
+				"Grep(screenshots/*)",
+				"Grep(scratch/*)",
+				"Bash(browser:*)",
+				"Bash(ls:*)",
+				"Bash(cat:*)",
+				"Bash(head:*)",
+				"Bash(tail:*)",
+				"Bash(wc:*)",
+				"Bash(file:*)",
+				"Bash(find:*)",
+				"Bash(tree:*)",
+				"Bash(stat:*)",
+				"Bash(du:*)",
+				"Bash(mkdir:*)",
+				"Bash(basename:*)",
+				"Bash(dirname:*)",
+				"Bash(realpath:*)",
+				"Bash(awk:*)",
+				"Bash(cut:*)",
+				"Bash(diff:*)",
+				"Bash(grep:*)",
+				"Bash(jq:*)",
+				"Bash(sed:*)",
+				"Bash(sort:*)",
+				"Bash(tr:*)",
+				"Bash(uniq:*)",
+				"Bash(xargs:*)",
+				"Bash(paste:*)",
+				"Bash(tee:*)",
+				"Bash(column:*)",
+				"WebSearch",
+				"WebFetch"
+			],
+			deny: ["*"]
+		},
+		hooks: { SessionStart: [{
+			matcher: "",
+			hooks: [{
+				type: "command",
+				command: `sh -c 'echo "export PATH=\\"${sessionPath}/bin:\\$PATH\\"" >> "$CLAUDE_ENV_FILE"'`
+			}]
+		}] }
+	};
+	await writeFile(join(sessionPath, ".claude", "settings.json"), JSON.stringify(settings, null, "	") + "\n");
+};
+/**
+* writes the `bin/browser` shim script that delegates to the bundled client.
+* @param sessionPath the session directory path
+* @param clientScriptPath absolute path to the bundled `dist/browser.mjs`
+* @param socketPath absolute path to the Unix domain socket
+*/
+const writeBrowserShim = async (sessionPath, clientScriptPath, socketPath) => {
+	const shimPath = join(sessionPath, "bin", "browser");
+	await writeFile(shimPath, `#!/bin/sh\nexec node ${clientScriptPath} --socket ${socketPath} "$@"\n`);
+	await chmod(shimPath, 493);
+};
+
+//#endregion
+//#region src/commands/ask.ts
+const systemPromptPath = join(join(import.meta.dirname, "assets"), "system-prompt.md");
+const clientScriptPath = join(import.meta.dirname, "client.mjs");
+const schema$1 = object({
+	command: constant("ask"),
+	model: withDefault(option("-m", "--model", choice([
+		"opus",
+		"sonnet",
+		"haiku"
+	]), { description: message`model to use` }), "sonnet"),
+	headful: withDefault(flag("--headful", { description: message`show browser window (default: headless)` }), false),
+	url: optional(option("--url", string(), { description: message`starting URL to navigate to` })),
+	task: argument(string({ metavar: "TASK" }), { description: message`what to accomplish in the browser` })
+});
+/**
+* spawns Claude Code as a child process.
+* @param cwd working directory
+* @param args command arguments
+* @param contextPrompt additional context to append to the system prompt
+* @returns the child process
+*/
+const spawnClaude = (cwd, args, contextPrompt) => {
+	return spawn("claude", [
+		"-p",
+		args.task,
+		"--no-session-persistence",
+		"--model",
+		args.model,
+		"--system-prompt-file",
+		systemPromptPath,
+		"--append-system-prompt",
+		contextPrompt
+	], {
+		cwd,
+		stdio: [
+			"ignore",
+			"pipe",
+			"inherit"
+		],
+		env: {
+			...process.env,
+			CLAUDECODE: ""
+		}
+	});
+};
+/**
+* waits for a child process to exit, collecting its stdout.
+* @param child the child process
+* @returns promise that resolves with exit code and collected stdout
+*/
+const waitForExit = (child) => {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		child.stdout?.on("data", (chunk) => {
+			chunks.push(chunk);
+		});
+		child.on("close", (code) => resolve({
+			code: code ?? 0,
+			stdout: Buffer.concat(chunks).toString()
+		}));
+		child.on("error", (err) => reject(/* @__PURE__ */ new Error(`failed to summon claude: ${err}`)));
+	});
+};
+/**
+* handles the ask command.
+* launches a browser, starts the IPC server, and spawns Claude Code.
+* @param args parsed command arguments
+*/
+const handler$1 = async (args) => {
+	gcSessions();
+	const sessionPath = await createSessionDir();
+	const socketPath = join(sessionPath, ".sock");
+	let exitCode = 1;
+	let claudeOutput = "";
+	let browser;
+	let claude;
+	const onSignal = () => {
+		if (claude) claude.kill("SIGTERM");
+		spin.stop("interrupted");
+		if (browser) browser.close().catch(() => {});
+		cleanupSessionDir(sessionPath).finally(() => {
+			process.exit(130);
+		});
+	};
+	process.on("SIGINT", onSignal);
+	process.on("SIGTERM", onSignal);
+	const spin = yoctoSpinner({ text: args.headful ? "launching browser (headful)" : "launching browser" }).start();
+	try {
+		browser = await chromium.launch({ headless: !args.headful });
+		const context = await browser.newContext();
+		const page = await context.newPage();
+		if (args.url) {
+			spin.text = `navigating to ${args.url}`;
+			await page.goto(args.url, { waitUntil: "domcontentloaded" });
+		}
+		const state = {
+			context,
+			page,
+			refs: {},
+			frameRefs: {},
+			assetsDir: join(sessionPath, "assets"),
+			screenshotDir: join(sessionPath, "screenshots"),
+			screenshotCounter: 0,
+			spinner: spin
+		};
+		spin.text = "starting session";
+		const server = await startServer(socketPath, createCommandHandler(state));
+		await writeBrowserShim(sessionPath, clientScriptPath, socketPath);
+		await writeSessionSettings(sessionPath);
+		const contextParts = [];
+		if (args.url) contextParts.push(`The browser is already open at: ${args.url}`);
+		const contextPrompt = contextParts.length > 0 ? contextParts.join("\n") : "";
+		spin.text = "summoning claude";
+		claude = spawnClaude(sessionPath, args, contextPrompt);
+		const result = await waitForExit(claude);
+		exitCode = result.code;
+		claudeOutput = result.stdout;
+		server.close();
+	} finally {
+		process.off("SIGINT", onSignal);
+		process.off("SIGTERM", onSignal);
+		spin.stop();
+		if (browser) await browser.close().catch(() => {});
+		await cleanupSessionDir(sessionPath);
+	}
+	if (claudeOutput) process.stdout.write(claudeOutput);
+	process.exit(exitCode);
+};
+
+//#endregion
+//#region src/commands/clean.ts
+const schema = object({ command: constant("clean") });
+/**
+* handles the clean command.
+* garbage collects orphaned session directories.
+* @param _args parsed command arguments
+*/
+const handler = async (_args) => {
+	await gcSessions();
+};
+
+//#endregion
+//#region src/index.ts
+const result = run(or(command("ask", schema$1, { description: message`ask a question by browsing the web with Claude Code` }), command("clean", schema, { description: message`remove cached session data` })), {
+	programName: "cbr",
+	help: "both",
+	version: {
+		value: version,
+		mode: "both"
+	},
+	brief: message`ask questions by browsing the web using Claude Code`
+});
+switch (result.command) {
+	case "ask":
+		await handler$1(result);
+		break;
+	case "clean":
+		await handler(result);
+		break;
+}
+
+//#endregion
+export {  };