@questpie/probe 0.1.0

package/dist/http-BZouO1Cj.js

@@ -0,0 +1,187 @@
+import "./duration-DUrbfMLK.js";
+import { ConfigError, loadProbeConfig, resolveBaseUrl } from "./config-BUEMgFYN.js";
+import { error, info, log, success } from "./output-CHUjdVDf.js";
+import { defineCommand } from "citty";
+import { ofetch } from "ofetch";
+
+//#region src/core/http-client.ts
+async function makeRequest(opts, config) {
+	const base = opts.base ?? resolveBaseUrl(config);
+	const url = opts.path.startsWith("http") ? opts.path : `${base}${opts.path}`;
+	const headers = {
+		...config.http?.headers,
+		...opts.headers
+	};
+	if (opts.token) headers["Authorization"] = `Bearer ${opts.token}`;
+	let body;
+	if (opts.data) {
+		body = JSON.parse(opts.data);
+		if (!headers["Content-Type"]) headers["Content-Type"] = "application/json";
+	}
+	const start = performance.now();
+	const response = await ofetch.raw(url, {
+		method: opts.method,
+		headers,
+		body,
+		ignoreResponseError: true
+	});
+	const duration = Math.round(performance.now() - start);
+	const responseHeaders = {};
+	response.headers.forEach((value, key) => {
+		responseHeaders[key] = value;
+	});
+	return {
+		status: response.status,
+		statusText: response.statusText,
+		headers: responseHeaders,
+		body: response._data,
+		duration
+	};
+}
+
+//#endregion
+//#region src/commands/http.ts
+const command = defineCommand({
+	meta: {
+		name: "http",
+		description: "Send HTTP requests against a running server"
+	},
+	args: {
+		method: {
+			type: "positional",
+			description: "HTTP method (GET, POST, PUT, DELETE, PATCH)",
+			required: true
+		},
+		path: {
+			type: "positional",
+			description: "URL path (e.g. /api/users)",
+			required: true
+		},
+		data: {
+			type: "string",
+			alias: "d",
+			description: "Request body (JSON)"
+		},
+		header: {
+			type: "string",
+			alias: "H",
+			description: "Header as key:value"
+		},
+		token: {
+			type: "string",
+			description: "Bearer token"
+		},
+		status: {
+			type: "string",
+			description: "Assert expected status code"
+		},
+		jq: {
+			type: "string",
+			description: "JQ-style filter on response"
+		},
+		raw: {
+			type: "boolean",
+			description: "Raw output (no pretty-print)",
+			default: false
+		},
+		verbose: {
+			type: "boolean",
+			alias: "v",
+			description: "Show request and response headers",
+			default: false
+		},
+		base: {
+			type: "string",
+			description: "Base URL override"
+		},
+		timing: {
+			type: "boolean",
+			description: "Show request timing breakdown",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const config = await loadProbeConfig();
+		const headers = {};
+		if (args.header) {
+			const parts = args.header.split(",");
+			for (const part of parts) {
+				const idx = part.indexOf(":");
+				if (idx > 0) headers[part.slice(0, idx).trim()] = part.slice(idx + 1).trim();
+			}
+		}
+		try {
+			if (args.verbose) {
+				const base = args.base ?? config.http?.baseUrl ?? "http://localhost:3000";
+				const url = args.path.startsWith("http") ? args.path : `${base}${args.path}`;
+				log(`\u2192 ${args.method} ${url}`);
+				for (const [k, v] of Object.entries(headers)) log(`\u2192 ${k}: ${v}`);
+				if (args.data) log(`\u2192 Body: ${args.data}`);
+			}
+			const result = await makeRequest({
+				method: args.method,
+				path: args.path,
+				base: args.base,
+				data: args.data,
+				headers: Object.keys(headers).length > 0 ? headers : void 0,
+				token: args.token,
+				verbose: args.verbose,
+				raw: args.raw
+			}, config);
+			if (args.verbose) {
+				log(`\u2190 ${result.status} ${result.statusText} (${result.duration}ms)`);
+				for (const [k, v] of Object.entries(result.headers)) log(`\u2190 ${k}: ${v}`);
+			}
+			if (args.timing) info(`Total: ${result.duration}ms`);
+			if (args.status) {
+				const expected = Number(args.status);
+				if (result.status !== expected) {
+					error(`Expected ${expected}, got ${result.status} ${result.statusText} (${result.duration}ms)`);
+					if (result.body) {
+						info("Response body:");
+						log(args.raw ? String(result.body) : JSON.stringify(result.body, null, 2));
+					}
+					process.exit(1);
+				}
+				success(`${result.status} ${result.statusText} (${result.duration}ms)`);
+				return;
+			}
+			if (!args.verbose) info(`${result.status} ${result.statusText} (${result.duration}ms)`);
+			if (result.body !== void 0 && result.body !== null) {
+				let output = result.body;
+				if (args.jq) output = applyJqFilter(result.body, args.jq);
+				if (args.raw) log(typeof output === "string" ? output : JSON.stringify(output));
+				else log(JSON.stringify(output, null, 2));
+			}
+		} catch (err) {
+			error(err instanceof Error ? err.message : String(err));
+			process.exit(err instanceof ConfigError ? 4 : 1);
+		}
+	}
+});
+var http_default = command;
+function applyJqFilter(data, expr) {
+	const parts = expr.split(".").filter(Boolean);
+	let current = data;
+	for (const part of parts) {
+		const arrayMatch = part.match(/^\[(\d+)]$/);
+		if (arrayMatch && Array.isArray(current)) current = current[Number(arrayMatch[1])];
+		else if (current && typeof current === "object" && !Array.isArray(current)) {
+			const bracketMatch = part.match(/^(.+?)\[(\d+)]$/);
+			if (bracketMatch) {
+				const obj = current;
+				const arr = obj[bracketMatch[1]];
+				if (Array.isArray(arr)) current = arr[Number(bracketMatch[2])];
+				else current = void 0;
+			} else current = current[part];
+		} else if (Array.isArray(current)) current = current.map((item) => {
+			if (item && typeof item === "object") return item[part];
+			return void 0;
+		});
+		else current = void 0;
+	}
+	return current;
+}
+
+//#endregion
+export { http_default as default };

package/dist/index.d.ts

@@ -0,0 +1,119 @@
+//#region src/core/config.d.ts
+interface ServiceConfig {
+  cmd: string;
+  ready?: string;
+  port?: number;
+  health?: string;
+  depends?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+  stop?: string;
+  timeout?: number;
+}
+interface BrowserConfig {
+  driver?: "agent-browser" | "playwright";
+  baseUrl?: string;
+  headless?: boolean;
+  session?: string;
+}
+interface HttpConfig {
+  baseUrl?: string;
+  headers?: Record<string, string>;
+}
+interface ProbeConfig {
+  services?: Record<string, ServiceConfig>;
+  browser?: BrowserConfig;
+  http?: HttpConfig;
+  logs?: {
+    dir?: string;
+    maxSize?: string;
+    browserConsole?: boolean;
+  };
+  tests?: {
+    dir?: string;
+    timeout?: number;
+  };
+}
+declare function defineConfig(config: ProbeConfig): ProbeConfig; //#endregion
+//#region src/browser/types.d.ts
+interface SnapshotOpts {
+  interactive?: boolean;
+  compact?: boolean;
+  depth?: number;
+  selector?: string;
+  diff?: boolean;
+}
+interface ScreenshotOpts {
+  path?: string;
+  annotate?: boolean;
+  full?: boolean;
+  selector?: string;
+}
+interface ConsoleEntry {
+  level: "log" | "warn" | "error" | "info";
+  text: string;
+  timestamp?: string;
+  source?: string;
+}
+interface ErrorEntry {
+  message: string;
+  stack?: string;
+  timestamp?: string;
+}
+interface NetworkEntry {
+  method: string;
+  url: string;
+  status: number;
+  duration: number;
+  timestamp?: string;
+}
+interface ConsoleOpts {
+  level?: "log" | "warn" | "error" | "info";
+  clear?: boolean;
+  json?: boolean;
+}
+interface NetworkOpts {
+  failed?: boolean;
+  method?: string;
+  grep?: string;
+  json?: boolean;
+}
+interface WaitOpts {
+  ref?: string;
+  selector?: string;
+  url?: string;
+  text?: string;
+  network?: "idle";
+  hidden?: boolean;
+  timeout?: number;
+}
+interface BrowserDriver {
+  open(url: string): Promise<void>;
+  back(): Promise<void>;
+  forward(): Promise<void>;
+  reload(): Promise<void>;
+  url(): Promise<string>;
+  title(): Promise<string>;
+  close(): Promise<void>;
+  snapshot(opts?: SnapshotOpts): Promise<string>;
+  click(ref: string): Promise<void>;
+  dblclick(ref: string): Promise<void>;
+  fill(ref: string, value: string): Promise<void>;
+  select(ref: string, value: string): Promise<void>;
+  check(ref: string): Promise<void>;
+  uncheck(ref: string): Promise<void>;
+  press(key: string): Promise<void>;
+  type(text: string): Promise<void>;
+  hover(ref: string): Promise<void>;
+  focus(ref: string): Promise<void>;
+  scroll(direction: string, px?: number): Promise<void>;
+  upload(ref: string, file: string): Promise<void>;
+  screenshot(opts?: ScreenshotOpts): Promise<string>;
+  eval(js: string): Promise<string>;
+  text(selector?: string): Promise<string>;
+  console(opts?: ConsoleOpts): Promise<ConsoleEntry[]>;
+  errors(): Promise<ErrorEntry[]>;
+  network(opts?: NetworkOpts): Promise<NetworkEntry[]>;
+  wait(opts: WaitOpts): Promise<void>;
+} //#endregion
+export { BrowserConfig, BrowserDriver, ConsoleEntry, HttpConfig, NetworkEntry, ProbeConfig, ServiceConfig, SnapshotOpts, defineConfig };

package/dist/index.js

@@ -0,0 +1,4 @@
+import "./duration-DUrbfMLK.js";
+import { defineConfig } from "./config-BUEMgFYN.js";
+
+export { defineConfig };

package/dist/init-BjTfn_-A.js

@@ -0,0 +1,92 @@
+import { error, info, success } from "./output-CHUjdVDf.js";
+import { defineCommand } from "citty";
+import { access, mkdir, writeFile } from "node:fs/promises";
+
+//#region src/commands/init.ts
+const CONFIG_TEMPLATE = `import { defineConfig } from '@questpie/probe'
+
+export default defineConfig({
+  services: {
+    // db: {
+    //   cmd: 'docker compose up postgres',
+    //   ready: 'ready to accept connections',
+    //   health: 'http://localhost:5432',
+    //   stop: 'docker compose down postgres',
+    // },
+    // server: {
+    //   cmd: 'bun dev',
+    //   ready: 'ready on http://localhost:3000',
+    //   port: 3000,
+    //   health: '/api/health',
+    //   depends: ['db'],
+    //   env: {
+    //     DATABASE_URL: 'postgresql://postgres:postgres@localhost:5432/dev',
+    //   },
+    // },
+  },
+
+  browser: {
+    driver: 'agent-browser',
+    baseUrl: 'http://localhost:3000',
+    headless: true,
+    session: 'qprobe',
+  },
+
+  http: {
+    baseUrl: 'http://localhost:3000',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  },
+
+  logs: {
+    dir: 'tmp/qprobe/logs',
+    maxSize: '10mb',
+    browserConsole: true,
+  },
+
+  tests: {
+    dir: 'tests/qprobe',
+    timeout: 30_000,
+  },
+})
+`;
+const GITIGNORE_ADDITION = "\n# QUESTPIE Probe\ntmp/qprobe/\n";
+const command = defineCommand({
+	meta: {
+		name: "init",
+		description: "Initialize QUESTPIE Probe config in current project"
+	},
+	args: { force: {
+		type: "boolean",
+		description: "Overwrite existing config",
+		default: false
+	} },
+	async run({ args }) {
+		const configPath = "qprobe.config.ts";
+		if (!args.force) try {
+			await access(configPath);
+			error(`${configPath} already exists. Use --force to overwrite.`);
+			process.exit(1);
+		} catch {}
+		await writeFile(configPath, CONFIG_TEMPLATE, "utf-8");
+		success(`Created ${configPath}`);
+		await mkdir("tmp/qprobe/logs", { recursive: true });
+		await mkdir("tmp/qprobe/pids", { recursive: true });
+		await mkdir("tests/qprobe/recordings", { recursive: true });
+		info("Created tmp/qprobe/ and tests/qprobe/ directories");
+		try {
+			const { readFile: readFile$1 } = await import("node:fs/promises");
+			const gitignore = await readFile$1(".gitignore", "utf-8");
+			if (!gitignore.includes("tmp/qprobe")) {
+				await writeFile(".gitignore", gitignore + GITIGNORE_ADDITION, "utf-8");
+				info("Added tmp/qprobe/ to .gitignore");
+			}
+		} catch {}
+		info("Run \"qprobe compose up\" to start your stack");
+	}
+});
+var init_default = command;
+
+//#endregion
+export { init_default as default };

package/dist/logs-BCgur07G.js

@@ -0,0 +1,191 @@
+import { parseDuration } from "./duration-DUrbfMLK.js";
+import { error, info, json, log } from "./output-CHUjdVDf.js";
+import { getLogPath, listProcessNames } from "./state-DRTSIt_r.js";
+import { defineCommand } from "citty";
+import { readFile, stat } from "node:fs/promises";
+import { consola } from "consola";
+import { watch } from "chokidar";
+
+//#region src/core/log-reader.ts
+function parseLine(line, source) {
+	const match = line.match(/^(\d{4}-\d{2}-\d{2}T[\d:.]+Z)\s+(INFO|ERROR|WARN|DEBUG)\s+(.*)$/);
+	if (!match) return null;
+	return {
+		timestamp: match[1],
+		level: match[2],
+		message: match[3],
+		source
+	};
+}
+function matchesFilter(entry, filter) {
+	if (filter.level && entry.level.toLowerCase() !== filter.level.toLowerCase()) return false;
+	if (filter.grep) {
+		const regex = new RegExp(filter.grep, "i");
+		if (!regex.test(entry.message)) return false;
+	}
+	if (filter.since) {
+		const entryTime = new Date(entry.timestamp).getTime();
+		const cutoff = Date.now() - filter.since;
+		if (entryTime < cutoff) return false;
+	}
+	return true;
+}
+async function readLogs(name, filter = {}) {
+	const logPath = getLogPath(name);
+	let content;
+	try {
+		content = await readFile(logPath, "utf-8");
+	} catch {
+		return [];
+	}
+	const lines = content.trim().split("\n");
+	const entries = [];
+	for (const line of lines) {
+		const entry = parseLine(line, name);
+		if (entry && matchesFilter(entry, filter)) entries.push(entry);
+	}
+	const limit = filter.lines ?? 50;
+	return entries.slice(-limit);
+}
+async function readAllLogs(filter = {}) {
+	const names = await listProcessNames();
+	const allEntries = [];
+	for (const name of names) {
+		const entries = await readLogs(name, {
+			...filter,
+			lines: void 0
+		});
+		allEntries.push(...entries);
+	}
+	allEntries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+	const limit = filter.lines ?? 50;
+	return allEntries.slice(-limit);
+}
+async function followLogs(name, filter, signal) {
+	const logPath = getLogPath(name);
+	let fileSize = 0;
+	try {
+		const s = await stat(logPath);
+		fileSize = s.size;
+	} catch {}
+	const existing = await readLogs(name, filter);
+	for (const entry of existing) printEntry(entry);
+	const watcher = watch(logPath, { persistent: true });
+	const onChange = async () => {
+		try {
+			const content = await readFile(logPath, "utf-8");
+			const newContent = content.slice(fileSize);
+			fileSize = content.length;
+			const lines = newContent.trim().split("\n");
+			for (const line of lines) {
+				const entry = parseLine(line, name);
+				if (entry && matchesFilter(entry, filter)) printEntry(entry);
+			}
+		} catch {}
+	};
+	watcher.on("change", onChange);
+	watcher.on("add", onChange);
+	signal.addEventListener("abort", () => {
+		watcher.close();
+	});
+}
+function printEntry(entry) {
+	const prefix = entry.source ? `[${entry.source}] ` : "";
+	const levelColor = entry.level === "ERROR" ? "\x1B[31m" : entry.level === "WARN" ? "\x1B[33m" : "\x1B[0m";
+	consola.log(`${prefix}${entry.timestamp} ${levelColor}${entry.level}\x1b[0m ${entry.message}`);
+}
+
+//#endregion
+//#region src/commands/logs.ts
+const command = defineCommand({
+	meta: {
+		name: "logs",
+		description: "Read process logs with filtering"
+	},
+	args: {
+		name: {
+			type: "positional",
+			description: "Process name",
+			required: false
+		},
+		follow: {
+			type: "boolean",
+			alias: "f",
+			description: "Follow mode (tail -f)",
+			default: false
+		},
+		lines: {
+			type: "string",
+			alias: "n",
+			description: "Number of lines",
+			default: "50"
+		},
+		grep: {
+			type: "string",
+			description: "Filter pattern (regex)"
+		},
+		level: {
+			type: "string",
+			description: "Log level filter (error, warn, info, debug)"
+		},
+		since: {
+			type: "string",
+			description: "Time filter (e.g. 5m, 1h)"
+		},
+		all: {
+			type: "boolean",
+			description: "All processes merged",
+			default: false
+		},
+		unified: {
+			type: "boolean",
+			description: "All processes + browser unified",
+			default: false
+		},
+		json: {
+			type: "boolean",
+			description: "JSON output",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const filter = {
+			grep: args.grep,
+			level: args.level,
+			lines: Number(args.lines),
+			since: args.since ? parseDuration(args.since) : void 0,
+			json: args.json
+		};
+		if (args.all || args.unified) {
+			const entries$1 = await readAllLogs(filter);
+			if (entries$1.length === 0) {
+				info("No log entries found");
+				return;
+			}
+			if (args.json) json(entries$1);
+			else for (const entry of entries$1) log(`[${entry.source}] ${entry.timestamp} ${entry.level} ${entry.message}`);
+			return;
+		}
+		if (!args.name) {
+			error("Provide a process name, or use --all");
+			process.exit(1);
+		}
+		if (args.follow) {
+			const ac = new AbortController();
+			process.on("SIGINT", () => ac.abort());
+			await followLogs(args.name, filter, ac.signal);
+			return;
+		}
+		const entries = await readLogs(args.name, filter);
+		if (entries.length === 0) {
+			info(`No log entries for "${args.name}"`);
+			return;
+		}
+		if (args.json) json(entries);
+		else for (const entry of entries) log(`${entry.timestamp} ${entry.level} ${entry.message}`);
+	}
+});
+var logs_default = command;
+
+//#endregion
+export { logs_default as default };

package/dist/output-CHUjdVDf.js

@@ -0,0 +1,38 @@
+import { consola } from "consola";
+
+//#region src/utils/output.ts
+function success(msg) {
+	consola.success(msg);
+}
+function error(msg) {
+	consola.error(msg);
+}
+function warn(msg) {
+	consola.warn(msg);
+}
+function info(msg) {
+	consola.info(msg);
+}
+function log(msg) {
+	consola.log(msg);
+}
+function table(rows) {
+	if (rows.length === 0) return;
+	const keys = Object.keys(rows[0]);
+	const widths = keys.map((k) => {
+		const vals = rows.map((r) => String(r[k] ?? ""));
+		return Math.max(k.length, ...vals.map((v) => v.length));
+	});
+	const header = keys.map((k, i) => k.toUpperCase().padEnd(widths[i])).join("  ");
+	consola.log(header);
+	for (const row of rows) {
+		const line = keys.map((k, i) => String(row[k] ?? "").padEnd(widths[i])).join("  ");
+		consola.log(line);
+	}
+}
+function json(data) {
+	consola.log(JSON.stringify(data, null, 2));
+}
+
+//#endregion
+export { error, info, json, log, success, table, warn };