@questpie/probe 0.1.0

package/dist/process-manager-CzexpFO4.js

@@ -0,0 +1,229 @@
+import { ensureLogsDir, getLogPath, listProcessNames, readPid, readState, removePid, removeState, savePid, saveState } from "./state-DRTSIt_r.js";
+import { appendFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { openSync } from "node:fs";
+
+//#region src/core/log-writer.ts
+function timestamp() {
+	return new Date().toISOString();
+}
+function detectLevel(line) {
+	const lower = line.toLowerCase();
+	if (lower.includes("error") || lower.includes("err ")) return "ERROR";
+	if (lower.includes("warn")) return "WARN";
+	if (lower.includes("debug")) return "DEBUG";
+	return "INFO";
+}
+async function writeLog(name, data, level) {
+	await ensureLogsDir();
+	const logPath = getLogPath(name);
+	const lines = data.split("\n").filter((l) => l.length > 0);
+	const formatted = lines.map((line) => {
+		const lvl = level ?? detectLevel(line);
+		return `${timestamp()} ${lvl.padEnd(5)} ${line}`;
+	}).join("\n");
+	if (formatted.length > 0) await appendFile(logPath, `${formatted}\n`, "utf-8");
+}
+function createLogWriter(name) {
+	return {
+		stdout(chunk) {
+			const text = typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+			writeLog(name, text);
+		},
+		stderr(chunk) {
+			const text = typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+			writeLog(name, text, "ERROR");
+		}
+	};
+}
+
+//#endregion
+//#region src/core/process-manager.ts
+function isProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function startProcess(opts) {
+	const existingPid = await readPid(opts.name);
+	if (existingPid && isProcessAlive(existingPid)) throw new Error(`Process "${opts.name}" is already running (PID ${existingPid})`);
+	await ensureLogsDir();
+	const [command, ...args] = opts.cmd.split(/\s+/);
+	if (!command) throw new Error("Empty command");
+	if (opts.ready) {
+		const logWriter = createLogWriter(opts.name);
+		const child$1 = spawn(command, args, {
+			cwd: opts.cwd ?? process.cwd(),
+			env: {
+				...process.env,
+				...opts.env
+			},
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			detached: true
+		});
+		const pid$1 = child$1.pid;
+		if (!pid$1) throw new Error("Failed to spawn process");
+		child$1.stdout?.on("data", logWriter.stdout);
+		child$1.stderr?.on("data", logWriter.stderr);
+		await savePid(opts.name, pid$1);
+		await saveState(opts.name, makeState(opts, pid$1));
+		const timeoutMs = opts.timeout ?? 6e4;
+		await waitForReady(child$1, opts.ready, timeoutMs);
+		child$1.stdout?.removeAllListeners();
+		child$1.stderr?.removeAllListeners();
+		child$1.stdout?.destroy();
+		child$1.stderr?.destroy();
+		child$1.unref();
+		return { pid: pid$1 };
+	}
+	const logPath = getLogPath(opts.name);
+	const logFd = openSync(logPath, "a");
+	const child = spawn(command, args, {
+		cwd: opts.cwd ?? process.cwd(),
+		env: {
+			...process.env,
+			...opts.env
+		},
+		stdio: [
+			"ignore",
+			logFd,
+			logFd
+		],
+		detached: true
+	});
+	const pid = child.pid;
+	if (!pid) throw new Error("Failed to spawn process");
+	child.unref();
+	await savePid(opts.name, pid);
+	await saveState(opts.name, makeState(opts, pid));
+	return { pid };
+}
+function makeState(opts, pid) {
+	return {
+		name: opts.name,
+		cmd: opts.cmd,
+		pid,
+		port: opts.port,
+		ready: opts.ready,
+		cwd: opts.cwd,
+		env: opts.env,
+		timeout: opts.timeout,
+		startedAt: new Date().toISOString()
+	};
+}
+function waitForReady(child, pattern, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		const regex = new RegExp(pattern);
+		let resolved = false;
+		const timer = setTimeout(() => {
+			if (!resolved) {
+				resolved = true;
+				reject(new Error(`Timeout waiting for ready pattern "${pattern}" after ${timeoutMs}ms`));
+			}
+		}, timeoutMs);
+		const onData = (chunk) => {
+			if (resolved) return;
+			const text = chunk.toString("utf-8");
+			if (regex.test(text)) {
+				resolved = true;
+				clearTimeout(timer);
+				child.stdout?.off("data", onData);
+				child.stderr?.off("data", onStderrData);
+				resolve();
+			}
+		};
+		const onStderrData = (chunk) => {
+			if (resolved) return;
+			const text = chunk.toString("utf-8");
+			if (regex.test(text)) {
+				resolved = true;
+				clearTimeout(timer);
+				child.stdout?.off("data", onData);
+				child.stderr?.off("data", onStderrData);
+				resolve();
+			}
+		};
+		child.stdout?.on("data", onData);
+		child.stderr?.on("data", onStderrData);
+		child.on("exit", (code) => {
+			if (!resolved) {
+				resolved = true;
+				clearTimeout(timer);
+				reject(new Error(`Process exited with code ${code} before ready`));
+			}
+		});
+	});
+}
+async function stopProcess(name) {
+	const pid = await readPid(name);
+	if (!pid) throw new Error(`No PID file for "${name}"`);
+	if (!isProcessAlive(pid)) {
+		await removePid(name);
+		await removeState(name);
+		return;
+	}
+	try {
+		process.kill(-pid, "SIGTERM");
+	} catch {
+		try {
+			process.kill(pid, "SIGTERM");
+		} catch {}
+	}
+	const deadline = Date.now() + 5e3;
+	while (Date.now() < deadline) {
+		if (!isProcessAlive(pid)) break;
+		await new Promise((r) => setTimeout(r, 100));
+	}
+	if (isProcessAlive(pid)) try {
+		process.kill(-pid, "SIGKILL");
+	} catch {
+		try {
+			process.kill(pid, "SIGKILL");
+		} catch {}
+	}
+	await removePid(name);
+	await removeState(name);
+}
+async function stopAll() {
+	const names = await listProcessNames();
+	for (const name of names) await stopProcess(name);
+	return names;
+}
+async function listProcesses() {
+	const names = await listProcessNames();
+	const result = [];
+	for (const name of names) {
+		const state = await readState(name);
+		const pid = await readPid(name);
+		if (!state || !pid) continue;
+		const alive = isProcessAlive(pid);
+		if (!alive) {
+			await removePid(name);
+			await removeState(name);
+			continue;
+		}
+		const uptimeMs = Date.now() - new Date(state.startedAt).getTime();
+		const { formatDuration } = await import("./duration-D1ya1zLn.js");
+		result.push({
+			name: state.name,
+			pid,
+			port: state.port,
+			status: "running",
+			uptime: formatDuration(uptimeMs)
+		});
+	}
+	return result;
+}
+async function getProcessState(name) {
+	return readState(name);
+}
+
+//#endregion
+export { getProcessState, listProcesses, startProcess, stopAll, stopProcess };

package/dist/process-manager-zzltWvZ0.js

@@ -0,0 +1,4 @@
+import "./state-DRTSIt_r.js";
+import { getProcessState, listProcesses, startProcess, stopAll, stopProcess } from "./process-manager-CzexpFO4.js";
+
+export { startProcess, stopProcess };

package/dist/ps-DuHF7vmE.js

@@ -0,0 +1,39 @@
+import { info, json, table } from "./output-CHUjdVDf.js";
+import "./state-DRTSIt_r.js";
+import { listProcesses } from "./process-manager-CzexpFO4.js";
+import { defineCommand } from "citty";
+
+//#region src/commands/ps.ts
+const command = defineCommand({
+	meta: {
+		name: "ps",
+		description: "List running processes"
+	},
+	args: { json: {
+		type: "boolean",
+		description: "JSON output",
+		default: false
+	} },
+	async run({ args }) {
+		const processes = await listProcesses();
+		if (processes.length === 0) {
+			info("No processes running");
+			return;
+		}
+		if (args.json) {
+			json(processes);
+			return;
+		}
+		table(processes.map((p) => ({
+			name: p.name,
+			pid: p.pid,
+			port: p.port ?? "—",
+			status: p.status,
+			uptime: p.uptime
+		})));
+	}
+});
+var ps_default = command;
+
+//#endregion
+export { ps_default as default };

package/dist/record-C4SmoPsT.js

@@ -0,0 +1,140 @@
+import "./duration-DUrbfMLK.js";
+import { loadProbeConfig } from "./config-BUEMgFYN.js";
+import { error, info, success } from "./output-CHUjdVDf.js";
+import { generatePlaywrightTest } from "./codegen-BH3cUNuf.js";
+import { defineCommand } from "citty";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+//#region src/testing/recorder.ts
+const STATE_FILE = "tmp/qprobe/state/recording.json";
+let activeRecording = null;
+async function startRecording(name) {
+	if (activeRecording) throw new Error(`Already recording "${activeRecording.name}". Stop it first.`);
+	const config = await loadProbeConfig();
+	activeRecording = {
+		name,
+		startedAt: new Date().toISOString(),
+		baseUrl: config.http?.baseUrl ?? config.browser?.baseUrl,
+		actions: []
+	};
+	await mkdir("tmp/qprobe/state", { recursive: true });
+	await writeFile(STATE_FILE, JSON.stringify(activeRecording, null, 2), "utf-8");
+}
+async function stopRecording() {
+	const recording = activeRecording ?? await loadActiveRecording();
+	if (!recording) throw new Error("No active recording");
+	recording.finishedAt = new Date().toISOString();
+	const config = await loadProbeConfig();
+	const testsDir = config.tests?.dir ?? "tests/qprobe";
+	const recordingsDir = join(testsDir, "recordings");
+	await mkdir(recordingsDir, { recursive: true });
+	const jsonPath = join(recordingsDir, `${recording.name}.json`);
+	await writeFile(jsonPath, JSON.stringify(recording, null, 2), "utf-8");
+	activeRecording = null;
+	try {
+		const { rm: rm$1 } = await import("node:fs/promises");
+		await rm$1(STATE_FILE);
+	} catch {}
+	return recording;
+}
+async function cancelRecording() {
+	activeRecording = null;
+	try {
+		const { rm: rm$1 } = await import("node:fs/promises");
+		await rm$1(STATE_FILE);
+	} catch {}
+}
+async function loadActiveRecording() {
+	try {
+		const content = await readFile(STATE_FILE, "utf-8");
+		activeRecording = JSON.parse(content);
+		return activeRecording;
+	} catch {
+		return null;
+	}
+}
+async function getActiveRecording() {
+	if (activeRecording) return activeRecording;
+	return loadActiveRecording();
+}
+
+//#endregion
+//#region src/commands/record.ts
+const start = defineCommand({
+	meta: {
+		name: "start",
+		description: "Start recording browser actions"
+	},
+	args: { name: {
+		type: "positional",
+		description: "Recording name",
+		required: true
+	} },
+	async run({ args }) {
+		try {
+			await startRecording(args.name);
+			success(`Recording "${args.name}" started`);
+			info("Browser and HTTP commands will be recorded. Run \"qprobe record stop\" when done.");
+		} catch (err) {
+			error(err instanceof Error ? err.message : String(err));
+			process.exit(1);
+		}
+	}
+});
+const stop = defineCommand({
+	meta: {
+		name: "stop",
+		description: "Stop recording and generate Playwright test"
+	},
+	args: {},
+	async run() {
+		try {
+			const recording = await stopRecording();
+			const specCode = generatePlaywrightTest(recording);
+			const config = await loadProbeConfig();
+			const testsDir = config.tests?.dir ?? "tests/qprobe";
+			const recordingsDir = join(testsDir, "recordings");
+			await mkdir(recordingsDir, { recursive: true });
+			const specPath = join(recordingsDir, `${recording.name}.spec.ts`);
+			await writeFile(specPath, specCode, "utf-8");
+			success(`Recording "${recording.name}" saved (${recording.actions.length} actions)`);
+			info(`JSON: ${join(recordingsDir, `${recording.name}.json`)}`);
+			info(`Spec: ${specPath}`);
+		} catch (err) {
+			error(err instanceof Error ? err.message : String(err));
+			process.exit(1);
+		}
+	}
+});
+const cancel = defineCommand({
+	meta: {
+		name: "cancel",
+		description: "Cancel recording without saving"
+	},
+	args: {},
+	async run() {
+		const active = await getActiveRecording();
+		if (!active) {
+			info("No active recording");
+			return;
+		}
+		await cancelRecording();
+		success(`Recording "${active.name}" cancelled`);
+	}
+});
+const command = defineCommand({
+	meta: {
+		name: "record",
+		description: "Record browser actions for replay"
+	},
+	subCommands: {
+		start,
+		stop,
+		cancel
+	}
+});
+var record_default = command;
+
+//#endregion
+export { record_default as default };

package/dist/recordings-Cb31alos.js

@@ -0,0 +1,158 @@
+import "./duration-DUrbfMLK.js";
+import { loadProbeConfig } from "./config-BUEMgFYN.js";
+import { error, info, json, log, success } from "./output-CHUjdVDf.js";
+import { generatePlaywrightTest } from "./codegen-BH3cUNuf.js";
+import { formatRecordingsList } from "./reporter-CqWc26OP.js";
+import { defineCommand } from "citty";
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+//#region src/commands/recordings.ts
+async function getRecordingsDir() {
+	const config = await loadProbeConfig();
+	return join(config.tests?.dir ?? "tests/qprobe", "recordings");
+}
+async function loadRecording(name) {
+	const dir = await getRecordingsDir();
+	const content = await readFile(join(dir, `${name}.json`), "utf-8");
+	return JSON.parse(content);
+}
+const list = defineCommand({
+	meta: {
+		name: "list",
+		description: "List all recordings"
+	},
+	args: { json: {
+		type: "boolean",
+		description: "JSON output",
+		default: false
+	} },
+	async run({ args }) {
+		const dir = await getRecordingsDir();
+		let files;
+		try {
+			files = (await readdir(dir)).filter((f) => f.endsWith(".json"));
+		} catch {
+			info("No recordings found");
+			return;
+		}
+		const recordings = [];
+		for (const file of files) try {
+			const content = await readFile(join(dir, file), "utf-8");
+			const rec = JSON.parse(content);
+			recordings.push({
+				name: rec.name,
+				actions: rec.actions.length,
+				date: rec.startedAt.split("T")[0] ?? ""
+			});
+		} catch {}
+		if (args.json) json(recordings);
+		else log(formatRecordingsList(recordings));
+	}
+});
+const show = defineCommand({
+	meta: {
+		name: "show",
+		description: "Show recording details"
+	},
+	args: {
+		name: {
+			type: "positional",
+			description: "Recording name",
+			required: true
+		},
+		json: {
+			type: "boolean",
+			default: false
+		}
+	},
+	async run({ args }) {
+		try {
+			const rec = await loadRecording(args.name);
+			if (args.json) json(rec);
+			else {
+				info(`Recording: ${rec.name}`);
+				info(`Started: ${rec.startedAt}`);
+				if (rec.finishedAt) info(`Finished: ${rec.finishedAt}`);
+				info(`Actions: ${rec.actions.length}`);
+				log("");
+				for (const action of rec.actions) log(`  ${action.command} ${action.args.join(" ")}`);
+			}
+		} catch {
+			error(`Recording "${args.name}" not found`);
+			process.exit(1);
+		}
+	}
+});
+const deleteCmd = defineCommand({
+	meta: {
+		name: "delete",
+		description: "Delete a recording"
+	},
+	args: { name: {
+		type: "positional",
+		description: "Recording name",
+		required: true
+	} },
+	async run({ args }) {
+		const dir = await getRecordingsDir();
+		try {
+			await rm(join(dir, `${args.name}.json`));
+		} catch {}
+		try {
+			await rm(join(dir, `${args.name}.spec.ts`));
+		} catch {}
+		success(`Deleted recording "${args.name}"`);
+	}
+});
+const exportCmd = defineCommand({
+	meta: {
+		name: "export",
+		description: "Export as standalone Playwright project"
+	},
+	args: { name: {
+		type: "positional",
+		description: "Recording name",
+		required: true
+	} },
+	async run({ args }) {
+		try {
+			const rec = await loadRecording(args.name);
+			const specCode = generatePlaywrightTest(rec);
+			const exportDir = `${args.name}-playwright`;
+			await mkdir(exportDir, { recursive: true });
+			await writeFile(join(exportDir, `${args.name}.spec.ts`), specCode, "utf-8");
+			await writeFile(join(exportDir, "package.json"), JSON.stringify({
+				name: `${args.name}-tests`,
+				scripts: { test: "playwright test" },
+				devDependencies: { "@playwright/test": ">=1.45.0" }
+			}, null, 2), "utf-8");
+			await writeFile(join(exportDir, "playwright.config.ts"), `import { defineConfig } from '@playwright/test'
+export default defineConfig({
+  use: { baseURL: '${rec.baseUrl ?? "http://localhost:3000"}' },
+})
+`, "utf-8");
+			success(`Exported to ./${exportDir}/`);
+			info("Run: cd " + exportDir + " && bun install && bunx playwright test");
+		} catch {
+			error(`Recording "${args.name}" not found`);
+			process.exit(1);
+		}
+	}
+});
+const command = defineCommand({
+	meta: {
+		name: "recordings",
+		description: "Manage test recordings"
+	},
+	subCommands: {
+		list,
+		show,
+		delete: deleteCmd,
+		export: exportCmd
+	}
+});
+var recordings_default = command;
+
+//#endregion
+export { recordings_default as default };