@questpie/probe 0.1.0

package/dist/agent-browser-Cxuu-Zz0.js

@@ -0,0 +1,203 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { x } from "tinyexec";
+
+//#region src/browser/agent-browser.ts
+const SNAPSHOTS_DIR = "tmp/qprobe/snapshots";
+const SHOTS_DIR = "tmp/qprobe/shots";
+async function ensureDir(dir) {
+	await mkdir(dir, { recursive: true });
+}
+let shotCounter = 0;
+var AgentBrowserDriver = class {
+	session;
+	headed;
+	baseUrl;
+	constructor(opts = {}) {
+		this.session = opts.session ?? "qprobe";
+		this.headed = opts.headed ?? false;
+		this.baseUrl = opts.baseUrl;
+	}
+	async run(...args) {
+		const cmdArgs = [
+			"--session",
+			this.session,
+			"--json",
+			...args
+		];
+		if (this.headed) cmdArgs.unshift("--headed");
+		const result = await x("agent-browser", cmdArgs, {
+			timeout: 3e4,
+			throwOnError: false
+		});
+		const out = result.stdout.trim();
+		if (!out) {
+			if (result.exitCode !== 0) throw new Error(`agent-browser failed (exit ${result.exitCode}): ${result.stderr}`);
+			return { success: true };
+		}
+		try {
+			return JSON.parse(out);
+		} catch {
+			return {
+				success: true,
+				data: { text: out }
+			};
+		}
+	}
+	async runOrThrow(...args) {
+		const res = await this.run(...args);
+		if (!res.success) throw new Error(res.error ?? "agent-browser command failed");
+		return res.data ?? {};
+	}
+	resolveUrl(url) {
+		if (url.startsWith("http://") || url.startsWith("https://")) return url;
+		if (this.baseUrl) return `${this.baseUrl}${url}`;
+		return url;
+	}
+	async open(url) {
+		await this.runOrThrow("open", this.resolveUrl(url));
+	}
+	async back() {
+		await this.runOrThrow("back");
+	}
+	async forward() {
+		await this.runOrThrow("forward");
+	}
+	async reload() {
+		await this.runOrThrow("reload");
+	}
+	async url() {
+		const data = await this.runOrThrow("get", "url");
+		return String(data["text"] ?? data["url"] ?? "");
+	}
+	async title() {
+		const data = await this.runOrThrow("get", "title");
+		return String(data["text"] ?? data["title"] ?? "");
+	}
+	async close() {
+		await this.runOrThrow("close");
+	}
+	async snapshot(opts) {
+		const args = ["snapshot"];
+		if (opts?.interactive) args.push("-i");
+		if (opts?.compact) args.push("-c");
+		if (opts?.depth !== void 0) args.push("-d", String(opts.depth));
+		if (opts?.selector) args.push("-s", opts.selector);
+		const data = await this.runOrThrow(...args);
+		const snapshotText = String(data["snapshot"] ?? data["text"] ?? "");
+		await ensureDir(SNAPSHOTS_DIR);
+		const currentPath = join(SNAPSHOTS_DIR, "current.yaml");
+		const previousPath = join(SNAPSHOTS_DIR, "previous.yaml");
+		try {
+			const existing = await readFile(currentPath, "utf-8");
+			await writeFile(previousPath, existing, "utf-8");
+		} catch {}
+		await writeFile(currentPath, snapshotText, "utf-8");
+		if (opts?.diff) {
+			const { diffSnapshots } = await import("./snapshot-diff-CqXEVTAZ.js");
+			try {
+				const previous = await readFile(previousPath, "utf-8");
+				return diffSnapshots(previous, snapshotText);
+			} catch {
+				return snapshotText;
+			}
+		}
+		return snapshotText;
+	}
+	async click(ref) {
+		await this.runOrThrow("click", ref);
+	}
+	async dblclick(ref) {
+		await this.runOrThrow("dblclick", ref);
+	}
+	async fill(ref, value) {
+		await this.runOrThrow("fill", ref, value);
+	}
+	async select(ref, value) {
+		await this.runOrThrow("select", ref, value);
+	}
+	async check(ref) {
+		await this.runOrThrow("check", ref);
+	}
+	async uncheck(ref) {
+		await this.runOrThrow("uncheck", ref);
+	}
+	async press(key) {
+		await this.runOrThrow("press", key);
+	}
+	async type(text) {
+		await this.runOrThrow("type", text);
+	}
+	async hover(ref) {
+		await this.runOrThrow("hover", ref);
+	}
+	async focus(ref) {
+		await this.runOrThrow("focus", ref);
+	}
+	async scroll(direction, px) {
+		const args = ["scroll", direction];
+		if (px !== void 0) args.push(String(px));
+		await this.runOrThrow(...args);
+	}
+	async upload(ref, file) {
+		await this.runOrThrow("upload", ref, file);
+	}
+	async screenshot(opts) {
+		await ensureDir(SHOTS_DIR);
+		shotCounter++;
+		const defaultPath = join(SHOTS_DIR, `shot-${String(shotCounter).padStart(3, "0")}.png`);
+		const targetPath = opts?.path ?? defaultPath;
+		const args = ["screenshot", targetPath];
+		if (opts?.annotate) args.push("--annotate");
+		if (opts?.full) args.push("--full");
+		if (opts?.selector) args.push("--selector", opts.selector);
+		const data = await this.runOrThrow(...args);
+		return String(data["path"] ?? targetPath);
+	}
+	async eval(js) {
+		const data = await this.runOrThrow("eval", js);
+		return String(data["text"] ?? data["result"] ?? JSON.stringify(data));
+	}
+	async text(selector) {
+		const args = ["get", "text"];
+		if (selector) args.push(selector);
+		const data = await this.runOrThrow(...args);
+		return String(data["text"] ?? "");
+	}
+	async console(opts) {
+		const args = ["console"];
+		if (opts?.clear) args.push("--clear");
+		const data = await this.runOrThrow(...args);
+		const messages = data["messages"] ?? [];
+		if (opts?.level) return messages.filter((m) => m.level === opts.level);
+		return messages;
+	}
+	async errors() {
+		const data = await this.runOrThrow("errors");
+		return data["errors"] ?? [];
+	}
+	async network(opts) {
+		const args = ["network", "requests"];
+		if (opts?.method) args.push("--method", opts.method);
+		if (opts?.grep) args.push("--filter", opts.grep);
+		const data = await this.runOrThrow(...args);
+		let entries = data["requests"] ?? [];
+		if (opts?.failed) entries = entries.filter((e) => e.status >= 400);
+		return entries;
+	}
+	async wait(opts) {
+		const args = ["wait"];
+		const timeout = opts.timeout ?? 3e4;
+		if (opts.ref) args.push(opts.ref);
+		else if (opts.selector) args.push(opts.selector);
+		else if (opts.url) args.push("--url", opts.url);
+		else if (opts.text) args.push("--text", opts.text);
+		else if (opts.network === "idle") args.push("--network", "idle");
+		if (opts.hidden) args.push("--hidden");
+		args.push("--timeout", String(timeout));
+		await this.runOrThrow(...args);
+	}
+};
+
+//#endregion
+export { AgentBrowserDriver };

package/dist/assert-BLP5_JwC.js

@@ -0,0 +1,212 @@
+import "./duration-DUrbfMLK.js";
+import { loadProbeConfig, resolveBaseUrl } from "./config-BUEMgFYN.js";
+import { AgentBrowserDriver } from "./agent-browser-Cxuu-Zz0.js";
+import { error, success } from "./output-CHUjdVDf.js";
+import { defineCommand } from "citty";
+import { ofetch } from "ofetch";
+
+//#region src/commands/assert.ts
+async function getDriver() {
+	const config = await loadProbeConfig();
+	return new AgentBrowserDriver({
+		session: config.browser?.session ?? "qprobe",
+		baseUrl: resolveBaseUrl(config)
+	});
+}
+const textAssert = defineCommand({
+	meta: {
+		name: "text",
+		description: "Assert page contains text"
+	},
+	args: { text: {
+		type: "positional",
+		description: "Expected text",
+		required: true
+	} },
+	async run({ args }) {
+		const driver = await getDriver();
+		const content = await driver.text();
+		if (content.includes(args.text)) success(`Page contains "${args.text}"`);
+		else {
+			error(`Page does not contain "${args.text}"`);
+			process.exit(1);
+		}
+	}
+});
+const noTextAssert = defineCommand({
+	meta: {
+		name: "no-text",
+		description: "Assert page does NOT contain text"
+	},
+	args: { text: {
+		type: "positional",
+		required: true
+	} },
+	async run({ args }) {
+		const driver = await getDriver();
+		const content = await driver.text();
+		if (!content.includes(args.text)) success(`Page does not contain "${args.text}"`);
+		else {
+			error(`Page contains "${args.text}" (unexpected)`);
+			process.exit(1);
+		}
+	}
+});
+const elementAssert = defineCommand({
+	meta: {
+		name: "element",
+		description: "Assert element exists"
+	},
+	args: {
+		selector: {
+			type: "positional",
+			description: "Ref or CSS selector",
+			required: true
+		},
+		text: {
+			type: "string",
+			description: "Assert element has this text"
+		}
+	},
+	async run({ args }) {
+		const driver = await getDriver();
+		const snapshot = await driver.snapshot({
+			interactive: true,
+			compact: true
+		});
+		if (snapshot.includes(args.selector)) success(`Element "${args.selector}" exists`);
+		else {
+			error(`Element "${args.selector}" not found`);
+			process.exit(1);
+		}
+	}
+});
+const urlAssert = defineCommand({
+	meta: {
+		name: "url",
+		description: "Assert URL matches pattern"
+	},
+	args: { pattern: {
+		type: "positional",
+		description: "URL pattern",
+		required: true
+	} },
+	async run({ args }) {
+		const driver = await getDriver();
+		const currentUrl = await driver.url();
+		const regex = new RegExp(args.pattern);
+		if (regex.test(currentUrl)) success(`URL matches "${args.pattern}" (${currentUrl})`);
+		else {
+			error(`URL "${currentUrl}" does not match "${args.pattern}"`);
+			process.exit(1);
+		}
+	}
+});
+const titleAssert = defineCommand({
+	meta: {
+		name: "title",
+		description: "Assert page title contains text"
+	},
+	args: { text: {
+		type: "positional",
+		required: true
+	} },
+	async run({ args }) {
+		const driver = await getDriver();
+		const pageTitle = await driver.title();
+		if (pageTitle.includes(args.text)) success(`Title contains "${args.text}" (${pageTitle})`);
+		else {
+			error(`Title "${pageTitle}" does not contain "${args.text}"`);
+			process.exit(1);
+		}
+	}
+});
+const statusAssert = defineCommand({
+	meta: {
+		name: "status",
+		description: "Assert HTTP endpoint returns status"
+	},
+	args: {
+		code: {
+			type: "positional",
+			description: "Expected status code",
+			required: true
+		},
+		path: {
+			type: "positional",
+			description: "URL path",
+			required: true
+		}
+	},
+	async run({ args }) {
+		const config = await loadProbeConfig();
+		const base = resolveBaseUrl(config);
+		const url = args.path.startsWith("http") ? args.path : `${base}${args.path}`;
+		const expected = Number(args.code);
+		try {
+			const response = await ofetch.raw(url, { ignoreResponseError: true });
+			if (response.status === expected) success(`${url} returned ${expected}`);
+			else {
+				error(`${url} returned ${response.status}, expected ${expected}`);
+				process.exit(1);
+			}
+		} catch (err) {
+			error(`Failed to reach ${url}: ${err instanceof Error ? err.message : String(err)}`);
+			process.exit(1);
+		}
+	}
+});
+const noErrorsAssert = defineCommand({
+	meta: {
+		name: "no-errors",
+		description: "Assert no JS console errors"
+	},
+	args: {},
+	async run() {
+		const driver = await getDriver();
+		const errs = await driver.errors();
+		if (errs.length === 0) success("No JS errors");
+		else {
+			error(`Found ${errs.length} JS error(s):`);
+			for (const e of errs) error(`  ${e.message}`);
+			process.exit(1);
+		}
+	}
+});
+const noNetworkErrorsAssert = defineCommand({
+	meta: {
+		name: "no-network-errors",
+		description: "Assert no 4xx/5xx network errors"
+	},
+	args: {},
+	async run() {
+		const driver = await getDriver();
+		const entries = await driver.network({ failed: true });
+		if (entries.length === 0) success("No network errors");
+		else {
+			error(`Found ${entries.length} network error(s):`);
+			for (const e of entries) error(`  ${e.method} ${e.status} ${e.url}`);
+			process.exit(1);
+		}
+	}
+});
+const command = defineCommand({
+	meta: {
+		name: "assert",
+		description: "Run assertions against browser/server state"
+	},
+	subCommands: {
+		text: textAssert,
+		"no-text": noTextAssert,
+		element: elementAssert,
+		url: urlAssert,
+		title: titleAssert,
+		status: statusAssert,
+		"no-errors": noErrorsAssert,
+		"no-network-errors": noNetworkErrorsAssert
+	}
+});
+var assert_default = command;
+
+//#endregion
+export { assert_default as default };