@luxonis/depthai-viewer-common 2.5.2 → 2.5.3

package/benchmark-cli.mjs

@@ -0,0 +1,1071 @@
+#!/usr/bin/env node
+
+import * as prompts from '@clack/prompts';
+import { spawn } from 'node:child_process';
+import { existsSync, statSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import process from 'node:process';
+import { clearLine, cursorTo } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const repoRoot = join(dirname(__filename), '..', '..');
+
+const benchmarkCatalog = [
+	{ id: 'bgr888i-stream', label: 'BGR888i Stream' },
+	{ id: 'encoded-stream', label: 'H.264 Stream' },
+	{ id: 'nv12-stream', label: 'NV12 Stream' },
+	{ id: 'pointcloud', label: 'Point Cloud' },
+];
+const backValue = '__back__';
+const customResolutionValue = '__custom_resolution__';
+const sourceResolutionValue = '__source_resolution__';
+const defaultResolution = process.env.BENCHMARK_RESOLUTION ?? '1920x1080';
+const progressEventPrefix = '__BENCHMARK_PROGRESS__|';
+
+const benchmarkById = new Map(benchmarkCatalog.map((benchmark) => [benchmark.id, benchmark]));
+const rootRunCommand = ['bash', './packages/common/benchmark-root.sh', '--'];
+const rootBenchmarkScript = ['npm', 'run', '-w=@luxonis/depthai-viewer-common', 'benchmark:raw', '--'];
+const signalExitCodes = {
+	SIGINT: 130,
+	SIGTERM: 143,
+};
+
+function printHelp() {
+	process.stdout.write(`DepthAI benchmark CLI
+
+Usage:
+  node ./packages/common/benchmark-cli.mjs [command] [options]
+
+Commands:
+  run               Run the full benchmark flow with visualizer startup.
+  download          Download benchmark assets only.
+  list              Show available benchmarks.
+
+Options:
+  --benchmark ID              Select a single benchmark. Can be repeated.
+  --benchmarks ID1,ID2        Select a comma-separated list of benchmarks.
+  --resolution WIDTHxHEIGHT   Resolution used by the run command.
+  --interactive               Force interactive benchmark selection.
+  --no-interactive            Disable interactive prompts.
+  -h, --help                  Show this help message.
+
+Examples:
+  npm run benchmark
+  npm run benchmark -- download
+  npm run benchmark -- run --benchmark encoded-stream
+  npm run benchmark -- list
+`);
+}
+
+function parseArgs(argv) {
+	const args = [...argv];
+	let command = null;
+
+	const options = {
+		benchmarkIds: [],
+		resolution: defaultResolution,
+		hasResolutionFlag: false,
+		interactive: null,
+		help: false,
+	};
+
+	while (args.length > 0) {
+		const current = args.shift();
+
+		switch (current) {
+			case '--benchmark': {
+				const value = args.shift();
+				if (!value) {
+					throw new Error('Missing value for --benchmark');
+				}
+				options.benchmarkIds.push(value);
+				break;
+			}
+			case '--benchmarks': {
+				const value = args.shift();
+				if (!value) {
+					throw new Error('Missing value for --benchmarks');
+				}
+				for (const benchmarkId of value.split(',')) {
+					const trimmed = benchmarkId.trim();
+					if (trimmed) {
+						options.benchmarkIds.push(trimmed);
+					}
+				}
+				break;
+			}
+			case '--resolution': {
+				const value = args.shift();
+				if (!value) {
+					throw new Error('Missing value for --resolution');
+				}
+				options.resolution = value;
+				options.hasResolutionFlag = true;
+				break;
+			}
+			case '--interactive':
+				options.interactive = true;
+				break;
+			case '--no-interactive':
+				options.interactive = false;
+				break;
+			case '-h':
+			case '--help':
+			case 'help':
+				options.help = true;
+				break;
+			case 'run':
+			case 'download':
+			case 'list':
+				if (command !== null) {
+					throw new Error(`Unexpected command: ${current}`);
+				}
+				command = current;
+				break;
+			default:
+				if (!current.startsWith('-') && command === null) {
+					command = current;
+					break;
+				}
+				throw new Error(`Unknown argument: ${current}`);
+		}
+	}
+
+	options.benchmarkIds = [...new Set(options.benchmarkIds)];
+	return { command, options };
+}
+
+function validateBenchmarkIds(benchmarkIds) {
+	for (const benchmarkId of benchmarkIds) {
+		if (!benchmarkById.has(benchmarkId)) {
+			throw new Error(`Unknown benchmark: ${benchmarkId}`);
+		}
+	}
+}
+
+function validateResolution(resolution) {
+	if (!/^[0-9]+x[0-9]+$/.test(resolution)) {
+		throw new Error('Resolution must be in WIDTHxHEIGHT format');
+	}
+
+	const [widthText, heightText] = resolution.split('x');
+	const width = Number(widthText);
+	const height = Number(heightText);
+
+	if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
+		throw new Error('Resolution width and height must be positive integers');
+	}
+
+	if (width % 2 !== 0 || height % 2 !== 0) {
+		throw new Error('Resolution width and height must be even');
+	}
+}
+
+function shouldPromptForAction(options, command) {
+	if (options.interactive === false || command !== null) {
+		return false;
+	}
+
+	return process.stdin.isTTY && process.stdout.isTTY;
+}
+
+function shouldPromptForBenchmarks(options) {
+	if (options.interactive === false || options.benchmarkIds.length > 0) {
+		return false;
+	}
+
+	return process.stdin.isTTY && process.stdout.isTTY;
+}
+
+function shouldPromptForResolution(options, command) {
+	if (command !== 'run') {
+		return false;
+	}
+
+	if (options.interactive === false || options.hasResolutionFlag) {
+		return false;
+	}
+
+	return process.stdin.isTTY && process.stdout.isTTY;
+}
+
+function toSelectionArgs(benchmarkIds) {
+	const args = [];
+
+	for (const benchmarkId of benchmarkIds) {
+		args.push('--benchmark', benchmarkId);
+	}
+
+	return args;
+}
+
+async function promptForAction() {
+	const action = await prompts.select({
+		message: 'What do you want to do?',
+		options: [
+			{
+				value: 'run',
+				label: 'Run benchmarks',
+				hint: 'if benchmarks are not downloaded yet, they will be downloaded first',
+			},
+			{
+				value: 'download',
+				label: 'Download benchmarks',
+				hint: 'only download benchmarks without running them',
+			},
+		],
+	});
+
+	return prompts.isCancel(action) ? null : action;
+}
+
+async function promptForBenchmarks() {
+	const selectionMode = await prompts.select({
+		message: 'Which benchmarks do you want to use?',
+		options: [
+			{ value: 'all', label: 'All benchmarks' },
+			{ value: 'single', label: 'Choose one benchmark' },
+			{ value: 'multiple', label: 'Choose multiple benchmarks' },
+			{ value: backValue, label: 'Back to main menu' },
+		],
+	});
+
+	if (prompts.isCancel(selectionMode)) {
+		return null;
+	}
+
+	if (selectionMode === backValue) {
+		return backValue;
+	}
+
+	if (selectionMode === 'all') {
+		return benchmarkCatalog.map((benchmark) => benchmark.id);
+	}
+
+	if (selectionMode === 'single') {
+		const benchmarkId = await prompts.select({
+			message: 'Pick a benchmark',
+			options: benchmarkCatalog
+				.map((benchmark) => ({
+					value: benchmark.id,
+					label: benchmark.label,
+					hint: benchmark.id,
+				}))
+				.concat([{ value: backValue, label: 'Back to benchmark mode' }]),
+		});
+
+		if (prompts.isCancel(benchmarkId)) {
+			return null;
+		}
+
+		return benchmarkId === backValue ? backValue : [benchmarkId];
+	}
+
+	const benchmarkIds = await prompts.multiselect({
+		message: 'Select one or more benchmarks',
+		required: true,
+		options: benchmarkCatalog.map((benchmark) => ({
+			value: benchmark.id,
+			label: benchmark.label,
+			hint: benchmark.id,
+		})),
+	});
+
+	return prompts.isCancel(benchmarkIds) ? null : benchmarkIds;
+}
+
+async function promptForResolution(currentResolution, benchmarkIds) {
+	for (;;) {
+		const selectedResolution = await prompts.select({
+			message: 'Which resolution should the benchmarks use?',
+			options: [
+				{
+					value: '1920x1080',
+					label: '1920x1080',
+					hint: currentResolution === '1920x1080' ? 'current default' : 'Full HD',
+				},
+				{
+					value: '1200x800',
+					label: '1200x800',
+					hint: 'HD',
+				},
+				{
+					value: '3840x2160',
+					label: '3840x2160',
+					hint: '4K',
+				},
+				{
+					value: sourceResolutionValue,
+					label: 'Recorded source resolution',
+					hint: 'run without resizing',
+				},
+				{
+					value: customResolutionValue,
+					label: 'Custom resolution',
+					hint: 'enter WIDTHxHEIGHT',
+				},
+				{
+					value: backValue,
+					label: 'Back to benchmark selection',
+				},
+			],
+		});
+
+		if (prompts.isCancel(selectedResolution)) {
+			return null;
+		}
+
+		if (selectedResolution === backValue) {
+			return backValue;
+		}
+
+		if (selectedResolution === sourceResolutionValue) {
+			return sourceResolutionValue;
+		}
+
+		if (selectedResolution === customResolutionValue) {
+			const customResolution = await prompts.text({
+				message: 'Enter a resolution in WIDTHxHEIGHT format',
+				placeholder: currentResolution,
+				validate: (value) => {
+					try {
+						validateResolution(value);
+						return;
+					} catch (error) {
+						return error instanceof Error ? error.message : String(error);
+					}
+				},
+			});
+
+			if (prompts.isCancel(customResolution)) {
+				return null;
+			}
+
+			return customResolution;
+		}
+
+		return selectedResolution;
+	}
+}
+
+function attachSignalForwarding(child, onSignal) {
+	const signals = ['SIGINT', 'SIGTERM'];
+	let forwardedSignal = null;
+	const handlers = new Map();
+
+	for (const signal of signals) {
+		const handler = () => {
+			if (forwardedSignal !== null) {
+				return;
+			}
+
+			forwardedSignal = signal;
+			onSignal?.(signal);
+			if (!child.killed) {
+				child.kill(signal);
+			}
+		};
+
+		handlers.set(signal, handler);
+		process.on(signal, handler);
+	}
+
+	return {
+		get forwardedSignal() {
+			return forwardedSignal;
+		},
+		cleanup() {
+			for (const [signal, handler] of handlers) {
+				process.off(signal, handler);
+			}
+		},
+	};
+}
+
+async function runCommand(command, args, { cwd = repoRoot, env = process.env } = {}) {
+	await new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			cwd,
+			env,
+			stdio: 'inherit',
+		});
+		const signalForwarding = attachSignalForwarding(child);
+
+		child.on('error', (error) => {
+			signalForwarding.cleanup();
+			reject(error);
+		});
+
+		child.on('close', (code, signal) => {
+			const forwardedSignal = signalForwarding.forwardedSignal ?? signal;
+			signalForwarding.cleanup();
+
+			if (forwardedSignal) {
+				process.exit(signalExitCodes[forwardedSignal] ?? 1);
+			}
+
+			if (code === 0) {
+				resolve();
+				return;
+			}
+
+			reject(new Error(`${command} exited with code ${code ?? 1}`));
+		});
+	});
+}
+
+async function runTaskWithSpinner(message, command, args, { cwd = repoRoot, env = process.env } = {}) {
+	const taskSpinner = prompts.spinner();
+	taskSpinner.start(message);
+
+	await new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			cwd,
+			env,
+			stdio: ['inherit', 'pipe', 'pipe'],
+		});
+		let stdout = '';
+		let stderr = '';
+		const signalForwarding = attachSignalForwarding(child, () => {
+			taskSpinner.stop(`${message} canceled`);
+		});
+
+		child.stdout.on('data', (chunk) => {
+			stdout += chunk.toString();
+		});
+
+		child.stderr.on('data', (chunk) => {
+			stderr += chunk.toString();
+		});
+
+		child.on('error', (error) => {
+			signalForwarding.cleanup();
+			taskSpinner.stop(`${message} failed`);
+			reject(error);
+		});
+
+		child.on('close', (code, signal) => {
+			const forwardedSignal = signalForwarding.forwardedSignal ?? signal;
+			signalForwarding.cleanup();
+
+			if (forwardedSignal) {
+				process.exit(signalExitCodes[forwardedSignal] ?? 1);
+			}
+
+			if (code === 0) {
+				taskSpinner.stop(message);
+				resolve();
+				return;
+			}
+
+			taskSpinner.stop(`${message} failed`);
+			if (stdout) {
+				process.stdout.write(stdout);
+			}
+			if (stderr) {
+				process.stderr.write(stderr);
+			}
+			reject(new Error(`${command} exited with code ${code ?? 1}`));
+		});
+	});
+}
+
+function formatDownloadStatus(line) {
+	const normalizedLine = line.startsWith('[benchmark] ') ? line.slice(12) : line;
+
+	if (normalizedLine.startsWith('Installing Python dependencies from ')) {
+		return 'Installing Python dependencies';
+	}
+
+	if (normalizedLine.startsWith('Downloading ')) {
+		return normalizedLine;
+	}
+
+	if (normalizedLine.startsWith('Resuming ')) {
+		return normalizedLine;
+	}
+
+	if (normalizedLine.startsWith('Using existing asset ')) {
+		return normalizedLine;
+	}
+
+	if (normalizedLine.startsWith('Recovered completed asset ')) {
+		return normalizedLine;
+	}
+
+	if (normalizedLine.startsWith('Download completed: ')) {
+		return normalizedLine;
+	}
+
+	if (normalizedLine.startsWith('Retrying ')) {
+		return normalizedLine;
+	}
+
+	return normalizedLine;
+}
+
+function formatBytes(bytes) {
+	if (!Number.isFinite(bytes) || bytes < 0) {
+		return '0 B';
+	}
+
+	if (bytes < 1024) {
+		return `${bytes} B`;
+	}
+
+	const units = ['KB', 'MB', 'GB', 'TB'];
+	let value = bytes;
+	let unitIndex = -1;
+
+	while (value >= 1024 && unitIndex < units.length - 1) {
+		value /= 1024;
+		unitIndex += 1;
+	}
+
+	return `${value.toFixed(value >= 10 ? 1 : 2)} ${units[unitIndex]}`;
+}
+
+function fitToTerminalWidth(text) {
+	const columns = process.stdout.columns ?? 120;
+	const maxWidth = Math.max(20, columns - 1);
+
+	if (text.length <= maxWidth) {
+		return text;
+	}
+
+	if (maxWidth <= 3) {
+		return text.slice(0, maxWidth);
+	}
+
+	return `${text.slice(0, maxWidth - 3)}...`;
+}
+
+function formatProgressLabel(progressState) {
+	const baseLabel = `${progressState.mode === 'resume' ? 'Resuming' : 'Downloading'} ${progressState.fileName} for ${progressState.benchmarkId}`;
+
+	if (!progressState.expectedSize || progressState.expectedSize <= 0) {
+		return baseLabel;
+	}
+
+	const percent = Math.max(
+		0,
+		Math.min(100, Math.floor((progressState.currentSize / progressState.expectedSize) * 100)),
+	);
+	const downloadedSize = Math.min(progressState.currentSize, progressState.expectedSize);
+	const remainingSize = Math.max(0, progressState.expectedSize - downloadedSize);
+	return `${baseLabel} (${percent}%) • ${formatBytes(downloadedSize)} / ${formatBytes(progressState.expectedSize)} • ${formatBytes(remainingSize)} left`;
+}
+
+function createDownloadStatusHandler(taskSpinner) {
+	let progressTimer = null;
+	let progressState = null;
+
+	const clearProgressTimer = () => {
+		if (progressTimer !== null) {
+			clearInterval(progressTimer);
+			progressTimer = null;
+		}
+	};
+
+	const updateProgressMessage = () => {
+		if (progressState === null) {
+			return;
+		}
+
+		if (existsSync(progressState.filePath)) {
+			try {
+				progressState.currentSize = statSync(progressState.filePath).size;
+			} catch {
+				return;
+			}
+		}
+
+		taskSpinner.message(formatProgressLabel(progressState));
+	};
+
+	return {
+		cleanup() {
+			clearProgressTimer();
+		},
+		handleLine(line) {
+			if (line.startsWith(progressEventPrefix)) {
+				const [, action, benchmarkId, fileName, filePath, expectedSizeText, mode] =
+					line.split('|');
+
+				if (action === 'start') {
+					clearProgressTimer();
+					progressState = {
+						benchmarkId,
+						fileName,
+						filePath,
+						expectedSize: Number(expectedSizeText) || 0,
+						currentSize: 0,
+						mode,
+					};
+					updateProgressMessage();
+
+					if (progressState.expectedSize > 0) {
+						progressTimer = setInterval(updateProgressMessage, 200);
+					}
+
+					return { hidden: true };
+				}
+
+				if (action === 'finish') {
+					clearProgressTimer();
+					progressState = null;
+					return { hidden: true };
+				}
+			}
+
+			return {
+				hidden: false,
+				message: formatDownloadStatus(line),
+			};
+		},
+	};
+}
+
+async function runStreamingCommandWithSpinner(
+	message,
+	command,
+	args,
+	{ cwd = repoRoot, env = process.env, createLineHandler, successMessage } = {},
+) {
+	if (!process.stdout.isTTY) {
+		const taskSpinner = prompts.spinner();
+		taskSpinner.start(message);
+
+		await new Promise((resolve, reject) => {
+			const child = spawn(command, args, {
+				cwd,
+				env,
+				stdio: ['inherit', 'pipe', 'pipe'],
+			});
+			const signalForwarding = attachSignalForwarding(child, () => {
+				taskSpinner.stop(`${message} canceled`);
+			});
+			let stdoutBuffer = '';
+			let stderrBuffer = '';
+			let stdoutOutput = '';
+			let stderrOutput = '';
+			const lineHandler = createLineHandler?.({
+				message() {},
+			});
+
+			const flushLines = (buffer, appendOutput) => {
+				const normalized = buffer.replaceAll('\r', '\n');
+				const parts = normalized.split('\n');
+				const remainder = parts.pop() ?? '';
+
+				for (const part of parts) {
+					const line = part.trim();
+					if (!line) {
+						continue;
+					}
+
+					const result = lineHandler?.handleLine(part);
+					if (!result?.hidden) {
+						appendOutput(`${part}\n`);
+					}
+				}
+
+				return remainder;
+			};
+
+			child.stdout.on('data', (chunk) => {
+				stdoutBuffer += chunk.toString();
+				stdoutBuffer = flushLines(stdoutBuffer, (value) => {
+					stdoutOutput += value;
+				});
+			});
+
+			child.stderr.on('data', (chunk) => {
+				stderrBuffer += chunk.toString();
+				stderrBuffer = flushLines(stderrBuffer, (value) => {
+					stderrOutput += value;
+				});
+			});
+
+			child.on('error', (error) => {
+				lineHandler?.cleanup?.();
+				signalForwarding.cleanup();
+				taskSpinner.stop(`${message} failed`);
+				reject(error);
+			});
+
+			child.on('close', (code, signal) => {
+				lineHandler?.cleanup?.();
+				const forwardedSignal = signalForwarding.forwardedSignal ?? signal;
+				signalForwarding.cleanup();
+				const remainingStdout = stdoutBuffer.trim();
+				const remainingStderr = stderrBuffer.trim();
+				if (remainingStdout) {
+					const result = lineHandler?.handleLine(remainingStdout);
+					if (!result?.hidden) {
+						stdoutOutput += `${remainingStdout}\n`;
+					}
+				}
+				if (remainingStderr) {
+					const result = lineHandler?.handleLine(remainingStderr);
+					if (!result?.hidden) {
+						stderrOutput += `${remainingStderr}\n`;
+					}
+				}
+
+				if (forwardedSignal) {
+					process.exit(signalExitCodes[forwardedSignal] ?? 1);
+				}
+
+				if (code === 0) {
+					taskSpinner.stop(successMessage ?? message);
+					resolve();
+					return;
+				}
+
+				taskSpinner.stop(`${message} failed`);
+				if (stdoutOutput) {
+					process.stdout.write(stdoutOutput);
+				}
+				if (stderrOutput) {
+					process.stderr.write(stderrOutput);
+				}
+				reject(new Error(`${command} exited with code ${code ?? 1}`));
+			});
+		});
+		return;
+	}
+
+	const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+	let spinnerIndex = 0;
+	let activeMessage = message;
+	let renderTimer = null;
+
+	const renderLine = () => {
+		const frame = spinnerFrames[spinnerIndex];
+		const text = fitToTerminalWidth(`${frame}  ${activeMessage}`);
+		cursorTo(process.stdout, 0);
+		clearLine(process.stdout, 0);
+		process.stdout.write(text);
+		spinnerIndex = (spinnerIndex + 1) % spinnerFrames.length;
+	};
+
+	const stopLine = (finalMessage) => {
+		if (renderTimer !== null) {
+			clearInterval(renderTimer);
+			renderTimer = null;
+		}
+
+		const text = fitToTerminalWidth(`◆  ${finalMessage}`);
+		cursorTo(process.stdout, 0);
+		clearLine(process.stdout, 0);
+		process.stdout.write(`${text}\n`);
+	};
+
+	renderLine();
+	renderTimer = setInterval(renderLine, 80);
+
+	await new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			cwd,
+			env,
+			stdio: ['inherit', 'pipe', 'pipe'],
+		});
+		const signalForwarding = attachSignalForwarding(child, () => {
+			stopLine(`${message} canceled`);
+		});
+		let stdoutBuffer = '';
+		let stderrBuffer = '';
+		let stdoutOutput = '';
+		let stderrOutput = '';
+		const inlineSpinnerHandle = {
+			message(nextMessage) {
+				activeMessage = nextMessage;
+				renderLine();
+			},
+		};
+		const inlineLineHandler = createLineHandler?.(inlineSpinnerHandle);
+
+		const flushLines = (buffer, appendOutput) => {
+			const normalized = buffer.replaceAll('\r', '\n');
+			const parts = normalized.split('\n');
+			const remainder = parts.pop() ?? '';
+
+			for (const part of parts) {
+				const line = part.trim();
+				if (!line) {
+					continue;
+				}
+
+				const result = inlineLineHandler?.handleLine(part);
+				if (!result?.hidden) {
+					appendOutput(`${part}\n`);
+				}
+			}
+
+			return remainder;
+		};
+
+		child.stdout.on('data', (chunk) => {
+			stdoutBuffer += chunk.toString();
+			stdoutBuffer = flushLines(
+				stdoutBuffer,
+				(value) => {
+					stdoutOutput += value;
+				},
+			);
+		});
+
+		child.stderr.on('data', (chunk) => {
+			stderrBuffer += chunk.toString();
+			stderrBuffer = flushLines(
+				stderrBuffer,
+				(value) => {
+					stderrOutput += value;
+				},
+			);
+		});
+
+		child.on('error', (error) => {
+			inlineLineHandler?.cleanup?.();
+			signalForwarding.cleanup();
+			stopLine(`${message} failed`);
+			reject(error);
+		});
+
+		child.on('close', (code, signal) => {
+			inlineLineHandler?.cleanup?.();
+			const forwardedSignal = signalForwarding.forwardedSignal ?? signal;
+			signalForwarding.cleanup();
+			const remainingStdout = stdoutBuffer.trim();
+			const remainingStderr = stderrBuffer.trim();
+			if (remainingStdout) {
+				const result = inlineLineHandler?.handleLine(remainingStdout);
+				if (!result?.hidden) {
+					stdoutOutput += `${remainingStdout}\n`;
+				}
+			}
+			if (remainingStderr) {
+				const result = inlineLineHandler?.handleLine(remainingStderr);
+				if (!result?.hidden) {
+					stderrOutput += `${remainingStderr}\n`;
+				}
+			}
+
+			if (forwardedSignal) {
+				process.exit(signalExitCodes[forwardedSignal] ?? 1);
+			}
+
+			if (code === 0) {
+				stopLine(successMessage ?? message);
+				resolve();
+				return;
+			}
+
+			stopLine(`${message} failed`);
+			if (stdoutOutput) {
+				process.stdout.write(stdoutOutput);
+			}
+			if (stderrOutput) {
+				process.stderr.write(stderrOutput);
+			}
+			reject(new Error(`${command} exited with code ${code ?? 1}`));
+		});
+	});
+}
+
+async function resolveBenchmarkIds(options) {
+	validateBenchmarkIds(options.benchmarkIds);
+
+	if (!shouldPromptForBenchmarks(options)) {
+		return options.benchmarkIds;
+	}
+
+	const selectedBenchmarkIds = await promptForBenchmarks();
+	if (selectedBenchmarkIds === null) {
+		prompts.cancel('Benchmark selection cancelled');
+		process.exit(1);
+	}
+
+	return selectedBenchmarkIds;
+}
+
+async function resolveRunResolution(options, command, benchmarkIds) {
+	if (!shouldPromptForResolution(options, command)) {
+		return options.resolution;
+	}
+
+	const selectedResolution = await promptForResolution(options.resolution, benchmarkIds);
+	if (selectedResolution === null) {
+		prompts.cancel('Resolution selection cancelled');
+		process.exit(1);
+	}
+
+	return selectedResolution;
+}
+
+function formatResolutionDisplay(resolution, benchmarkIds) {
+	return resolution === null ? 'recorded source resolution' : resolution;
+}
+
+function printBenchmarkList() {
+	process.stdout.write('Available benchmarks:\n');
+	for (const benchmark of benchmarkCatalog) {
+		process.stdout.write(`  ${benchmark.id} (${benchmark.label})\n`);
+	}
+}
+
+function formatPreparationMessage(command, selectedDisplay, resolutionDisplay) {
+	if (command === 'run') {
+		return `Preparing to run ${selectedDisplay}${resolutionDisplay}`;
+	}
+
+	return `Preparing to download ${selectedDisplay}`;
+}
+
+async function ensureBenchmarkAssets(selectionArgs, successMessage = 'Benchmark assets are ready') {
+	await runStreamingCommandWithSpinner(
+		'Preparing benchmark downloads',
+		'npm',
+		['run', '-w=@luxonis/depthai-viewer-common', 'benchmark:download:raw', '--', ...selectionArgs],
+		{
+			env: {
+				...process.env,
+				BENCHMARK_CURL_PROGRESS: '0',
+			},
+			createLineHandler: createDownloadStatusHandler,
+			successMessage,
+		},
+	);
+}
+
+async function main() {
+	const { command: parsedCommand, options } = parseArgs(process.argv.slice(2));
+	const returnToMainMenuAfterDownload = shouldPromptForAction(options, parsedCommand);
+	let command = parsedCommand;
+
+	if (options.help) {
+		printHelp();
+		return;
+	}
+
+	if (options.hasResolutionFlag) {
+		validateResolution(options.resolution);
+	}
+
+	for (;;) {
+		if (shouldPromptForAction(options, command)) {
+			command = await promptForAction();
+			if (command === null) {
+				prompts.cancel('Benchmark action cancelled');
+				process.exit(1);
+			}
+		}
+
+		if (command === null) {
+			command = 'run';
+		}
+
+		if (command === 'list') {
+			printBenchmarkList();
+			return;
+		}
+
+		if (!['run', 'download'].includes(command)) {
+			throw new Error(`Unknown command: ${command}`);
+		}
+
+		let benchmarkIds;
+		let resolvedResolution = options.resolution;
+		for (;;) {
+			benchmarkIds = await resolveBenchmarkIds(options);
+			if (benchmarkIds !== backValue) {
+				if (command !== 'run') {
+					break;
+				}
+
+				const nextResolution = await resolveRunResolution(options, command, benchmarkIds);
+				if (nextResolution === backValue) {
+					continue;
+				}
+
+				if (nextResolution === sourceResolutionValue) {
+					resolvedResolution = null;
+					break;
+				}
+
+				resolvedResolution = nextResolution;
+				if (resolvedResolution !== null) {
+					validateResolution(resolvedResolution);
+				}
+				break;
+			}
+
+			const nextCommand = await promptForAction();
+			if (nextCommand === null) {
+				prompts.cancel('Benchmark action cancelled');
+				process.exit(1);
+			}
+
+			command = nextCommand;
+		}
+
+		const selectionArgs = toSelectionArgs(benchmarkIds);
+		const resolutionArgs =
+			command === 'run' && resolvedResolution !== null
+				? ['--resolution', resolvedResolution]
+				: [];
+		const selectedDisplay =
+			benchmarkIds.length > 0 ? benchmarkIds.join(', ') : 'all benchmarks';
+		const resolutionDisplay =
+			command === 'run' ? ` • ${formatResolutionDisplay(resolvedResolution, benchmarkIds)}` : '';
+
+		prompts.intro(
+			`DepthAI Benchmark CLI\n${formatPreparationMessage(command, selectedDisplay, resolutionDisplay)}`,
+		);
+
+		if (command === 'run') {
+			await ensureBenchmarkAssets(selectionArgs, 'Benchmark assets are ready');
+			await runTaskWithSpinner(
+				'Building common package',
+				'npm',
+				['run', '-w=@luxonis/depthai-viewer-common', 'build'],
+				{},
+			);
+			await runTaskWithSpinner(
+				'Building visualizer',
+				'npm',
+				['run', '-w=@luxonis/visualizer', 'build'],
+				{},
+			);
+
+			prompts.outro('Starting benchmark flow');
+			await runCommand(
+				rootRunCommand[0],
+				[...rootRunCommand.slice(1), ...rootBenchmarkScript, ...selectionArgs, ...resolutionArgs],
+				{
+					env: {
+						...process.env,
+						BENCHMARK_SKIP_DOWNLOAD: '1',
+					},
+				},
+			);
+			return;
+		}
+
+		prompts.outro('Starting benchmark asset download');
+		await ensureBenchmarkAssets(selectionArgs);
+
+		if (!returnToMainMenuAfterDownload) {
+			return;
+		}
+
+		command = null;
+	}
+}
+
+main().catch((error) => {
+	prompts.cancel(error instanceof Error ? error.message : String(error));
+	process.exit(1);
+});