@questpie/probe 0.1.0

package/dist/check-Cny-3lkZ.js

@@ -0,0 +1,41 @@
+import "./duration-DUrbfMLK.js";
+import { loadProbeConfig, resolveBaseUrl } from "./config-BUEMgFYN.js";
+import { error, info, success, warn } from "./output-CHUjdVDf.js";
+import "./state-DRTSIt_r.js";
+import { listProcesses } from "./process-manager-CzexpFO4.js";
+import { defineCommand } from "citty";
+import { ofetch } from "ofetch";
+
+//#region src/commands/check.ts
+const command = defineCommand({
+	meta: {
+		name: "check",
+		description: "Quick health check of a running application"
+	},
+	args: { url: {
+		type: "positional",
+		description: "URL to check (defaults to baseUrl from config)",
+		required: false
+	} },
+	async run({ args }) {
+		const config = await loadProbeConfig();
+		const url = args.url ?? resolveBaseUrl(config);
+		info(`Checking ${url}...`);
+		try {
+			const start = performance.now();
+			const response = await ofetch.raw(url, { ignoreResponseError: true });
+			const duration = Math.round(performance.now() - start);
+			if (response.status >= 200 && response.status < 400) success(`HTTP ${response.status} ${response.statusText} (${duration}ms)`);
+			else error(`HTTP ${response.status} ${response.statusText} (${duration}ms)`);
+		} catch (err) {
+			error(`Connection failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		const processes = await listProcesses();
+		if (processes.length > 0) info(`${processes.length} service(s) running (${processes.map((p) => p.name).join(", ")})`);
+		else warn("No managed services running");
+	}
+});
+var check_default = command;
+
+//#endregion
+export { check_default as default };

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/cli.js

@@ -0,0 +1,30 @@
+import { defineCommand, runMain } from "citty";
+
+//#region src/cli.ts
+const main = defineCommand({
+	meta: {
+		name: "qprobe",
+		version: "0.1.0",
+		description: "Dev testing CLI for AI coding agents"
+	},
+	subCommands: {
+		start: () => import("./start-BClY6oJq.js").then((m) => m.default),
+		stop: () => import("./stop-QAP6gbDe.js").then((m) => m.default),
+		restart: () => import("./restart-By3Edj5X.js").then((m) => m.default),
+		ps: () => import("./ps-DuHF7vmE.js").then((m) => m.default),
+		health: () => import("./health-B36ufFzJ.js").then((m) => m.default),
+		compose: () => import("./compose-D5a8qHkg.js").then((m) => m.default),
+		logs: () => import("./logs-BCgur07G.js").then((m) => m.default),
+		http: () => import("./http-BZouO1Cj.js").then((m) => m.default),
+		check: () => import("./check-Cny-3lkZ.js").then((m) => m.default),
+		browser: () => import("./browser-DoCXU5Bs.js").then((m) => m.default),
+		record: () => import("./record-C4SmoPsT.js").then((m) => m.default),
+		replay: () => import("./replay-Dg9PHNrg.js").then((m) => m.default),
+		recordings: () => import("./recordings-Cb31alos.js").then((m) => m.default),
+		assert: () => import("./assert-BLP5_JwC.js").then((m) => m.default),
+		init: () => import("./init-BjTfn_-A.js").then((m) => m.default)
+	}
+});
+runMain(main);
+
+//#endregion

package/dist/codegen-BH3cUNuf.js

@@ -0,0 +1,61 @@
+//#region src/testing/codegen.ts
+function generatePlaywrightTest(recording) {
+	const lines = [];
+	lines.push("import { test, expect } from '@playwright/test'");
+	lines.push("");
+	lines.push(`test('${escapeString(recording.name)}', async ({ page }) => {`);
+	for (const action of recording.actions) {
+		const code = actionToPlaywright(action.command, action.args);
+		if (code) lines.push(`  ${code}`);
+	}
+	lines.push("})");
+	lines.push("");
+	return lines.join("\n");
+}
+function actionToPlaywright(command, args) {
+	switch (command) {
+		case "browser open": return `await page.goto('${escapeString(args[0] ?? "")}')`;
+		case "browser click": return `await page.locator('${escapeSelector(args[0] ?? "")}').click()`;
+		case "browser dblclick": return `await page.locator('${escapeSelector(args[0] ?? "")}').dblclick()`;
+		case "browser fill": return `await page.locator('${escapeSelector(args[0] ?? "")}').fill('${escapeString(args[1] ?? "")}')`;
+		case "browser select": return `await page.locator('${escapeSelector(args[0] ?? "")}').selectOption('${escapeString(args[1] ?? "")}')`;
+		case "browser check": return `await page.locator('${escapeSelector(args[0] ?? "")}').check()`;
+		case "browser uncheck": return `await page.locator('${escapeSelector(args[0] ?? "")}').uncheck()`;
+		case "browser press": return `await page.keyboard.press('${escapeString(args[0] ?? "")}')`;
+		case "browser type": return `await page.keyboard.type('${escapeString(args[0] ?? "")}')`;
+		case "browser hover": return `await page.locator('${escapeSelector(args[0] ?? "")}').hover()`;
+		case "browser screenshot": return `await page.screenshot({ path: '${escapeString(args[0] ?? "screenshot.png")}' })`;
+		case "browser wait":
+			if (args[0]) return `await page.locator('${escapeSelector(args[0])}').waitFor()`;
+			return `await page.waitForLoadState('networkidle')`;
+		case "browser eval": return `await page.evaluate(() => { ${args[0] ?? ""} })`;
+		case "browser back": return "await page.goBack()";
+		case "browser forward": return "await page.goForward()";
+		case "browser reload": return "await page.reload()";
+		case "http GET":
+		case "http POST":
+		case "http PUT":
+		case "http DELETE":
+		case "http PATCH": {
+			const method = command.split(" ")[1];
+			const url = args[0] ?? "/";
+			return `await page.request.${method.toLowerCase()}('${escapeString(url)}')`;
+		}
+		case "assert text": return `await expect(page.locator('body')).toContainText('${escapeString(args[0] ?? "")}')`;
+		case "assert no-text": return `await expect(page.locator('body')).not.toContainText('${escapeString(args[0] ?? "")}')`;
+		case "assert element": return `await expect(page.locator('${escapeSelector(args[0] ?? "")}')).toBeVisible()`;
+		case "assert url": return `await expect(page).toHaveURL(/${escapeString(args[0] ?? "")}/)`;
+		case "assert title": return `await expect(page).toHaveTitle(/${escapeString(args[0] ?? "")}/)`;
+		default: return `// ${command} ${args.join(" ")}`;
+	}
+}
+function escapeString(s) {
+	return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function escapeSelector(s) {
+	if (s.startsWith("@e")) return s;
+	return escapeString(s);
+}
+
+//#endregion
+export { generatePlaywrightTest };

package/dist/compose-D5a8qHkg.js

@@ -0,0 +1,233 @@
+import "./duration-DUrbfMLK.js";
+import { loadProbeConfig } from "./config-BUEMgFYN.js";
+import { error, info, json, success, table } from "./output-CHUjdVDf.js";
+import "./state-DRTSIt_r.js";
+import { listProcesses, startProcess, stopProcess } from "./process-manager-CzexpFO4.js";
+import { defineCommand } from "citty";
+import { ofetch } from "ofetch";
+
+//#region src/core/compose-engine.ts
+function resolveDependencyOrder(services, only, skip) {
+	const filtered = new Set();
+	if (only && only.length > 0) {
+		const queue = [...only];
+		while (queue.length > 0) {
+			const name = queue.pop();
+			if (filtered.has(name)) continue;
+			const svc = services[name];
+			if (!svc) throw new Error(`Unknown service: "${name}"`);
+			filtered.add(name);
+			if (svc.depends) for (const dep of svc.depends) queue.push(dep);
+		}
+	} else for (const name of Object.keys(services)) filtered.add(name);
+	if (skip) for (const name of skip) filtered.delete(name);
+	const sorted = [];
+	const visited = new Set();
+	const visiting = new Set();
+	function visit(name) {
+		if (visited.has(name)) return;
+		if (visiting.has(name)) throw new Error(`Circular dependency detected: ${name}`);
+		if (!filtered.has(name)) return;
+		visiting.add(name);
+		const svc = services[name];
+		if (svc?.depends) for (const dep of svc.depends) visit(dep);
+		visiting.delete(name);
+		visited.add(name);
+		sorted.push(name);
+	}
+	for (const name of filtered) visit(name);
+	return sorted;
+}
+async function composeUp(services, opts) {
+	const order = resolveDependencyOrder(services, opts.only, opts.skip);
+	const started = [];
+	for (const name of order) {
+		const svc = services[name];
+		await startProcess({
+			name,
+			cmd: svc.cmd,
+			ready: svc.ready,
+			timeout: svc.timeout ? svc.timeout : 6e4,
+			port: svc.port,
+			env: svc.env,
+			cwd: svc.cwd
+		});
+		started.push(name);
+		if (!opts.noHealth && svc.health) {
+			const healthUrl = svc.health.startsWith("http") ? svc.health : `http://localhost:${svc.port ?? 3e3}${svc.health}`;
+			await waitForHealth(healthUrl, svc.timeout ?? 3e4);
+		}
+	}
+	return started;
+}
+async function composeDown(services) {
+	const order = resolveDependencyOrder(services);
+	const reversed = [...order].reverse();
+	const stopped = [];
+	for (const name of reversed) try {
+		await stopProcess(name);
+		stopped.push(name);
+	} catch {}
+	return stopped;
+}
+async function waitForHealth(url, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		try {
+			const response = await ofetch.raw(url, { ignoreResponseError: true });
+			if (response.status >= 200 && response.status < 400) return;
+		} catch {}
+		await new Promise((r) => setTimeout(r, 1e3));
+	}
+	throw new Error(`Health check failed for ${url} after ${timeoutMs}ms`);
+}
+
+//#endregion
+//#region src/commands/compose.ts
+const up = defineCommand({
+	meta: {
+		name: "up",
+		description: "Start all services from config"
+	},
+	args: {
+		only: {
+			type: "string",
+			description: "Only start these services (comma-separated)"
+		},
+		skip: {
+			type: "string",
+			description: "Skip these services (comma-separated)"
+		},
+		"no-health": {
+			type: "boolean",
+			description: "Skip health checks",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const config = await loadProbeConfig();
+		if (!config.services || Object.keys(config.services).length === 0) {
+			error("No services defined in config");
+			process.exit(4);
+		}
+		try {
+			const started = await composeUp(config.services, {
+				only: args.only ? args.only.split(",") : void 0,
+				skip: args.skip ? args.skip.split(",") : void 0,
+				noHealth: args["no-health"]
+			});
+			success(`Started ${started.length} service(s): ${started.join(", ")}`);
+		} catch (err) {
+			error(err instanceof Error ? err.message : String(err));
+			process.exit(1);
+		}
+	}
+});
+const down = defineCommand({
+	meta: {
+		name: "down",
+		description: "Stop all services"
+	},
+	args: {},
+	async run() {
+		const config = await loadProbeConfig();
+		if (!config.services) {
+			info("No services defined");
+			return;
+		}
+		const stopped = await composeDown(config.services);
+		if (stopped.length === 0) info("No services were running");
+		else success(`Stopped ${stopped.length} service(s): ${stopped.join(", ")}`);
+	}
+});
+const restart = defineCommand({
+	meta: {
+		name: "restart",
+		description: "Restart a service or all services"
+	},
+	args: { name: {
+		type: "positional",
+		description: "Service name (optional)",
+		required: false
+	} },
+	async run({ args }) {
+		const config = await loadProbeConfig();
+		if (!config.services) {
+			error("No services defined");
+			process.exit(4);
+		}
+		try {
+			if (args.name) {
+				const svc = config.services[args.name];
+				if (!svc) {
+					error(`Unknown service: "${args.name}"`);
+					process.exit(1);
+				}
+				const { stopProcess: stopProcess$1, startProcess: startProcess$1 } = await import("./process-manager-zzltWvZ0.js");
+				try {
+					await stopProcess$1(args.name);
+				} catch {}
+				await startProcess$1({
+					name: args.name,
+					cmd: svc.cmd,
+					ready: svc.ready,
+					port: svc.port,
+					env: svc.env,
+					cwd: svc.cwd
+				});
+				success(`Restarted "${args.name}"`);
+			} else {
+				await composeDown(config.services);
+				const started = await composeUp(config.services, {});
+				success(`Restarted ${started.length} service(s)`);
+			}
+		} catch (err) {
+			error(err instanceof Error ? err.message : String(err));
+			process.exit(1);
+		}
+	}
+});
+const status = defineCommand({
+	meta: {
+		name: "status",
+		description: "Show status of all services"
+	},
+	args: { json: {
+		type: "boolean",
+		default: false
+	} },
+	async run({ args }) {
+		const processes = await listProcesses();
+		if (args.json) {
+			json(processes);
+			return;
+		}
+		if (processes.length === 0) {
+			info("No services running");
+			return;
+		}
+		table(processes.map((p) => ({
+			name: p.name,
+			pid: p.pid,
+			port: p.port ?? "—",
+			status: p.status,
+			uptime: p.uptime
+		})));
+	}
+});
+const command = defineCommand({
+	meta: {
+		name: "compose",
+		description: "Manage service stack from config"
+	},
+	subCommands: {
+		up,
+		down,
+		restart,
+		status
+	}
+});
+var compose_default = command;
+
+//#endregion
+export { compose_default as default };

package/dist/config-BUEMgFYN.js

@@ -0,0 +1,89 @@
+import { parseDuration } from "./duration-DUrbfMLK.js";
+import { loadConfig } from "c12";
+import { defu } from "defu";
+
+//#region src/core/config.ts
+const defaults = {
+	browser: {
+		driver: "agent-browser",
+		headless: true,
+		session: "qprobe"
+	},
+	logs: {
+		dir: "tmp/qprobe/logs",
+		maxSize: "10mb",
+		browserConsole: true
+	},
+	tests: {
+		dir: "tests/qprobe",
+		timeout: 3e4
+	}
+};
+function defineConfig(config) {
+	return config;
+}
+let _config = null;
+async function loadProbeConfig() {
+	if (_config) return _config;
+	try {
+		const configFile = process.env.QPROBE_CONFIG;
+		const { config } = await loadConfig({
+			name: "qprobe",
+			defaults,
+			...configFile ? { configFile } : {}
+		});
+		_config = defu(config ?? {}, defaults);
+		applyEnvOverrides(_config);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		throw new ConfigError(msg);
+	}
+	return _config;
+}
+var ConfigError = class extends Error {
+	name = "ConfigError";
+	constructor(message) {
+		super(message);
+	}
+};
+function applyEnvOverrides(config) {
+	const baseUrl = process.env.QPROBE_BASE_URL;
+	if (baseUrl) {
+		config.http = config.http ?? {};
+		config.http.baseUrl = baseUrl;
+		config.browser = config.browser ?? {};
+		config.browser.baseUrl = baseUrl;
+	}
+	const browserDriver = process.env.QPROBE_BROWSER_DRIVER;
+	if (browserDriver === "agent-browser" || browserDriver === "playwright") {
+		config.browser = config.browser ?? {};
+		config.browser.driver = browserDriver;
+	}
+	const logDir = process.env.QPROBE_LOG_DIR;
+	if (logDir) {
+		config.logs = config.logs ?? {};
+		config.logs.dir = logDir;
+	}
+	const headless = process.env.QPROBE_HEADLESS;
+	if (headless === "true" || headless === "false") {
+		config.browser = config.browser ?? {};
+		config.browser.headless = headless === "true";
+	}
+	const timeout = process.env.QPROBE_TIMEOUT;
+	if (timeout) {
+		config.tests = config.tests ?? {};
+		config.tests.timeout = parseDuration(timeout);
+	}
+}
+function resolveBaseUrl(config) {
+	const envBaseUrl = process.env.QPROBE_BASE_URL;
+	if (envBaseUrl) return envBaseUrl;
+	if (config.http?.baseUrl) return config.http.baseUrl;
+	if (config.browser?.baseUrl) return config.browser.baseUrl;
+	const firstServiceWithPort = Object.values(config.services ?? {}).find((s) => s.port);
+	if (firstServiceWithPort?.port) return `http://localhost:${firstServiceWithPort.port}`;
+	return "http://localhost:3000";
+}
+
+//#endregion
+export { ConfigError, defineConfig, loadProbeConfig, resolveBaseUrl };

package/dist/duration-D1ya1zLn.js

@@ -0,0 +1,3 @@
+import { formatDuration, parseDuration } from "./duration-DUrbfMLK.js";
+
+export { formatDuration };

package/dist/duration-DUrbfMLK.js

@@ -0,0 +1,30 @@
+//#region src/utils/duration.ts
+const UNITS = {
+	ms: 1,
+	s: 1e3,
+	m: 6e4,
+	h: 36e5,
+	d: 864e5
+};
+function parseDuration(input) {
+	const match = input.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/);
+	if (!match) throw new Error(`Invalid duration: "${input}"`);
+	const value = Number(match[1]);
+	const unit = UNITS[match[2]];
+	return Math.round(value * unit);
+}
+function formatDuration(ms) {
+	if (ms < 1e3) return `${ms}ms`;
+	if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+	if (ms < 36e5) {
+		const m$1 = Math.floor(ms / 6e4);
+		const s = Math.floor(ms % 6e4 / 1e3);
+		return s > 0 ? `${m$1}m ${s}s` : `${m$1}m`;
+	}
+	const h = Math.floor(ms / 36e5);
+	const m = Math.floor(ms % 36e5 / 6e4);
+	return m > 0 ? `${h}h ${m}m` : `${h}h`;
+}
+
+//#endregion
+export { formatDuration, parseDuration };

package/dist/health-B36ufFzJ.js

@@ -0,0 +1,62 @@
+import { parseDuration } from "./duration-DUrbfMLK.js";
+import { error, success } from "./output-CHUjdVDf.js";
+import { defineCommand } from "citty";
+import { ofetch } from "ofetch";
+
+//#region src/commands/health.ts
+const command = defineCommand({
+	meta: {
+		name: "health",
+		description: "Poll a URL until it responds with expected status"
+	},
+	args: {
+		url: {
+			type: "positional",
+			description: "URL to check",
+			required: true
+		},
+		interval: {
+			type: "string",
+			description: "Interval between attempts",
+			default: "1s"
+		},
+		timeout: {
+			type: "string",
+			description: "Max total wait time",
+			default: "30s"
+		},
+		status: {
+			type: "string",
+			description: "Expected status code",
+			default: "200"
+		}
+	},
+	async run({ args }) {
+		const intervalMs = parseDuration(args.interval);
+		const timeoutMs = parseDuration(args.timeout);
+		const expectedStatus = Number(args.status);
+		const startTime = Date.now();
+		const deadline = startTime + timeoutMs;
+		while (Date.now() < deadline) {
+			try {
+				const reqStart = performance.now();
+				const response = await ofetch.raw(args.url, { ignoreResponseError: true });
+				const duration = Math.round(performance.now() - reqStart);
+				if (response.status === expectedStatus) {
+					const elapsed$1 = ((Date.now() - startTime) / 1e3).toFixed(1);
+					success(`${args.url} responding (${response.status} ${response.statusText}, ${duration}ms) after ${elapsed$1}s`);
+					return;
+				}
+			} catch {}
+			if (Date.now() + intervalMs > deadline) break;
+			await new Promise((r) => setTimeout(r, intervalMs));
+		}
+		const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+		error(`${args.url} did not respond with ${expectedStatus} within ${elapsed}s`);
+		process.exit(3);
+	}
+});
+var health_default = command;
+
+//#endregion
+export { health_default as default };