@putdotio/rokit 1.3.0 → 1.4.0

package/README.md

@@ -42,6 +42,7 @@ pnpm exec rokit press --delay-ms 250 Right Select
 pnpm exec rokit query /query/active-app
 pnpm exec rokit wait-node videoPlayerScreen visible
 pnpm exec rokit screenshot artifacts/live/player.png
+pnpm exec rokit --json active-app
 ```
 
 App-specific scenario scripts can also import the generic helpers:
@@ -91,6 +92,16 @@ rokit install <zip-path>
 rokit --version
 ```
 
+Global options:
+
+```bash
+rokit --json <command>
+rokit --output json <command>
+```
+
+JSON mode wraps command output as `{ "status": "ok", "command": "...", ... }`
+and reports failures as `{ "status": "failed", "error": { "message": "..." } }`.
+
 - `check` confirms the Roku ECP endpoint responds and the developer installer
   is reachable.
 - `device-info` prints enhanced Roku device metadata as JSON.

package/dist/rokit.mjs

@@ -23,9 +23,9 @@ const requirePassword = (env) => {
 	if (!password) return fail("ROKIT_PASSWORD is not set");
 	return password;
 };
+var RokitCliError = class extends Error {};
 const fail = (message) => {
-	console.error(message);
-	process.exit(1);
+	throw new RokitCliError(message);
 };
 const formatErrorMessage = (error) => {
 	if (error instanceof Error) return error.message;
@@ -42,100 +42,212 @@ const parseTimeout = (value) => {
 //#region src/cli.ts
 const packageJson = createRequire(import.meta.url)("../package.json");
 const main = async (argv = process.argv.slice(2)) => {
-	const firstArg = argv[0];
-	if (!firstArg || firstArg === "--help" || firstArg === "-h") {
-		printHelp();
-		return;
-	}
-	if (firstArg === "--version" || firstArg === "-v") {
-		console.log(packageJson.version);
-		return;
-	}
-	loadLocalEnv();
-	const env = loadEnv();
-	const target = requireTarget(env);
-	const context = {
-		password: env.password,
-		target,
-		timeoutMs: env.timeoutMs,
-		username: env.username
-	};
-	const command = parseCommand(argv);
+	let outputMode = inferOutputMode(argv);
 	try {
-		await runCommand(context, command);
+		const options = parseGlobalOptions(argv);
+		outputMode = options.outputMode;
+		const firstArg = options.args[0];
+		if (!firstArg || firstArg === "--help" || firstArg === "-h") {
+			printHelp();
+			return;
+		}
+		if (firstArg === "--version" || firstArg === "-v") {
+			console.log(packageJson.version);
+			return;
+		}
+		loadLocalEnv();
+		const env = loadEnv();
+		const target = requireTarget(env);
+		const result = await runCommand({
+			password: env.password,
+			target,
+			timeoutMs: env.timeoutMs,
+			username: env.username
+		}, parseCommand(options.args));
+		printResult(options.outputMode, result);
 	} catch (error) {
-		fail(formatErrorMessage(error));
+		printError(outputMode, formatErrorMessage(error));
+		process.exitCode = 1;
 	}
 };
 const runCommand = async (context, command) => {
 	if (command.name === "check") {
 		const summary = await checkDevice(context);
-		console.log(`device: ${summary.name} (${summary.model})`);
-		console.log(`ecp: ${summary.ecp}`);
-		console.log(`developer installer HTTP status: ${summary.installerStatus}`);
-		return;
-	}
-	if (command.name === "device-info") {
-		console.log(JSON.stringify(await getDeviceInfo(context), null, 2));
-		return;
+		return {
+			command: command.name,
+			data: summary,
+			message: [
+				`device: ${summary.name} (${summary.model})`,
+				`ecp: ${summary.ecp}`,
+				`developer installer HTTP status: ${summary.installerStatus}`
+			].join("\n"),
+			status: "ok"
+		};
 	}
+	if (command.name === "device-info") return {
+		command: command.name,
+		data: await getDeviceInfo(context),
+		status: "ok"
+	};
 	if (command.name === "active-app") {
 		const app = await queryActiveApp(context);
-		console.log(`active app: ${app.id} ${app.name} ${app.version}`.trim());
-		return;
+		return {
+			command: command.name,
+			data: app,
+			message: `active app: ${app.id} ${app.name} ${app.version}`.trim(),
+			status: "ok"
+		};
 	}
 	if (command.name === "wait-active") {
 		const app = await waitForActiveApp(context, command.appId, command.timeoutMs);
-		console.log(`active app: ${app.id} ${app.name} ${app.version}`.trim());
-		return;
+		return {
+			command: command.name,
+			data: app,
+			message: `active app: ${app.id} ${app.name} ${app.version}`.trim(),
+			status: "ok"
+		};
 	}
 	if (command.name === "launch") {
 		const app = await launchApp(context, command.args.appId, command.args.params);
-		console.log(`launched: ${app.id} ${app.name} ${app.version}`.trim());
-		return;
+		return {
+			command: command.name,
+			data: app,
+			message: `launched: ${app.id} ${app.name} ${app.version}`.trim(),
+			status: "ok"
+		};
 	}
 	if (command.name === "press") {
+		const pressed = [];
 		for (const [index, key] of command.args.keys.entries()) {
 			if (index > 0 && command.args.delayMs > 0) await sleep(command.args.delayMs);
 			await pressKey(context, key);
-			console.log(`pressed: ${key}`);
+			pressed.push(key);
 		}
-		return;
+		return {
+			command: command.name,
+			data: {
+				delayMs: command.args.delayMs,
+				keys: pressed
+			},
+			message: pressed.map((key) => `pressed: ${key}`).join("\n"),
+			status: "ok"
+		};
 	}
 	if (command.name === "query") {
-		console.log(await queryEcp(context, command.path));
-		return;
+		const body = await queryEcp(context, command.path);
+		return {
+			command: command.name,
+			data: {
+				body,
+				path: command.path
+			},
+			message: body,
+			status: "ok"
+		};
 	}
 	if (command.name === "sgnodes") {
-		console.log(await querySceneGraph(context));
-		return;
+		const body = await querySceneGraph(context);
+		return {
+			command: command.name,
+			data: { body },
+			message: body,
+			status: "ok"
+		};
 	}
 	if (command.name === "assert-node") {
 		await assertSceneGraphNode(context, command.args.nodeName, command.args.expectation);
-		console.log(`asserted node: ${formatNodeCondition(command.args)}`);
-		return;
+		return {
+			command: command.name,
+			data: formatNodeData(command.args),
+			message: `asserted node: ${formatNodeCondition(command.args)}`,
+			status: "ok"
+		};
 	}
 	if (command.name === "wait-node") {
 		await waitForSceneGraphNode(context, command.args.nodeName, command.args.expectation, command.args.timeoutMs);
-		console.log(`matched node: ${formatNodeCondition(command.args)}`);
-		return;
+		return {
+			command: command.name,
+			data: formatNodeData(command.args),
+			message: `matched node: ${formatNodeCondition(command.args)}`,
+			status: "ok"
+		};
 	}
 	if (command.name === "screenshot") {
 		const password = requirePassword(context);
 		mkdirSync(dirname(command.outputPath), { recursive: true });
-		console.log(`screenshot: ${await takeScreenshot({
+		const path = await takeScreenshot({
 			...context,
 			password
-		}, command.outputPath)}`);
-		return;
+		}, command.outputPath);
+		return {
+			command: command.name,
+			data: { path },
+			message: `screenshot: ${path}`,
+			status: "ok"
+		};
 	}
 	if (command.name === "install") {
 		const password = requirePassword(context);
-		console.log(await installPackage({
+		const message = await installPackage({
 			...context,
 			password
-		}, command.zipPath));
+		}, command.zipPath);
+		return {
+			command: command.name,
+			data: { message },
+			message,
+			status: "ok"
+		};
 	}
+	throw new Error(`unsupported command: ${command.name}`);
+};
+const parseGlobalOptions = (argv) => {
+	const args = [];
+	let outputMode = "text";
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (arg === "--json") {
+			outputMode = "json";
+			continue;
+		}
+		if (arg === "--output") {
+			const value = argv[index + 1];
+			if (value !== "json" && value !== "text") fail("usage: rokit [--json|--output json|--output text] <command>");
+			outputMode = value === "json" ? "json" : "text";
+			index += 1;
+			continue;
+		}
+		args.push(arg);
+	}
+	return {
+		args,
+		outputMode
+	};
+};
+const inferOutputMode = (argv) => {
+	if (argv.includes("--json")) return "json";
+	return argv[argv.indexOf("--output") + 1] === "json" ? "json" : "text";
+};
+const printResult = (outputMode, result) => {
+	if (outputMode === "json") {
+		console.log(JSON.stringify(result, null, 2));
+		return;
+	}
+	if (result.message !== void 0) {
+		console.log(result.message);
+		return;
+	}
+	console.log(JSON.stringify(result.data, null, 2));
+};
+const printError = (outputMode, message) => {
+	if (outputMode === "json") {
+		console.error(JSON.stringify({
+			error: { message },
+			status: "failed"
+		}, null, 2));
+		return;
+	}
+	console.error(message);
 };
 const parseCommand = (argv) => {
 	const [name, ...args] = argv;
@@ -265,6 +377,11 @@ const formatNodeCondition = ({ expectation, nodeName }) => {
 	const suffix = expectation.text === void 0 ? "" : ` text=${expectation.text}`;
 	return `${nodeName} ${expectation.state}${suffix}`;
 };
+const formatNodeData = ({ expectation, nodeName, timeoutMs }) => ({
+	expectation,
+	nodeName,
+	timeoutMs
+});
 const sleep = (ms) => new Promise((resolve) => {
 	setTimeout(resolve, ms);
 });
@@ -305,6 +422,10 @@ usage:
   rokit install <zip-path>
   rokit --version
 
+global options:
+  --json
+  --output json | text
+
 environment:
   ROKIT_TARGET=<roku-ip>
   ROKIT_PASSWORD=<developer-mode-password>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putdotio/rokit",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "A tiny CLI companion for Roku device harness work.",
   "keywords": [
     "cli",