matterbridge-lg-thinq-plugin 0.1.0

package/scripts/parse-junit-failures.mjs

@@ -0,0 +1,45 @@
+/* eslint-disable no-console, n/no-process-exit */
+import { existsSync, readFileSync } from 'node:fs';
+
+const REPORT = 'test-report.junit.xml';
+const MSG_MAX = 120;
+
+function decodeXml(value) {
+	return value
+		.replace(/'/g, "'")
+		.replace(/"/g, '"')
+		.replace(/&lt;/g, '<')
+		.replace(/&gt;/g, '>')
+		.replace(/&amp;/g, '&');
+}
+
+if (!existsSync(REPORT)) {
+	console.error('TESTS FAIL: missing test-report.junit.xml');
+	process.exit(1);
+}
+
+const xml = readFileSync(REPORT, 'utf8');
+const failures = [];
+
+for (const block of xml.matchAll(/<testcase[^>]*>[\s\S]*?<\/testcase>/g)) {
+	const testcase = block[0];
+	const failure = testcase.match(/<failure[^>]*message="([^"]*)"/);
+	if (!failure) {
+		continue;
+	}
+
+	const openTag = testcase.match(/^<testcase\s+([^>]+)>/)?.[1] ?? '';
+	const classname = openTag.match(/classname="([^"]*)"/)?.[1] ?? '';
+	const name = decodeXml(openTag.match(/\bname="([^"]*)"/)?.[1] ?? '');
+	const message = decodeXml(failure[1]).split('\n')[0].slice(0, MSG_MAX);
+	failures.push(`${classname} > ${name}: ${message}`);
+}
+
+if (failures.length === 0) {
+	console.log('TESTS PASS');
+	process.exit(0);
+}
+
+console.log(`FAILED ${failures.length}:`);
+console.log(failures.join('\n'));
+process.exit(1);

package/scripts/parse-tsc-failures.mjs

@@ -0,0 +1,48 @@
+/* eslint-disable no-console, n/no-process-exit */
+import { existsSync, readFileSync } from 'node:fs';
+
+const LOG = 'type-check.log';
+const MSG_MAX = 120;
+const MAX_LINES = 25;
+
+if (!existsSync(LOG)) {
+	console.error('TYPE-CHECK FAIL: missing type-check.log');
+	process.exit(1);
+}
+
+const log = readFileSync(LOG, 'utf8');
+const failures = [];
+
+for (const line of log.split('\n')) {
+	const fileMatch = line.match(/^(.+?\(\d+,\d+\)): (error TS\d+: .+)$/);
+	if (fileMatch) {
+		failures.push(`${fileMatch[1]}: ${fileMatch[2].slice(0, MSG_MAX)}`);
+		continue;
+	}
+
+	const bareMatch = line.match(/^(error TS\d+: .+)$/);
+	if (bareMatch) {
+		failures.push(bareMatch[1].slice(0, MSG_MAX));
+	}
+}
+
+if (failures.length === 0) {
+	if (/Found \d+ error/i.test(log) || /\berror TS\d+:/i.test(log)) {
+		const detail = log
+			.split('\n')
+			.map((line) => line.trimEnd())
+			.filter((line) => /error TS\d+:/i.test(line) || /Found \d+ error/i.test(line))
+			.slice(0, MAX_LINES)
+			.join('\n');
+		console.log('TYPE-CHECK FAIL');
+		console.log(detail || 'type-check failed');
+		process.exit(1);
+	}
+
+	console.log('TYPE-CHECK PASS');
+	process.exit(0);
+}
+
+console.log(`FAILED ${failures.length}:`);
+console.log(failures.slice(0, MAX_LINES).join('\n'));
+process.exit(1);

package/scripts/run-build-local-summary.mjs

@@ -0,0 +1,29 @@
+/* eslint-disable no-console, n/no-process-exit */
+import { spawnSync } from 'node:child_process';
+
+const MAX_LINES = 30;
+
+function run(command) {
+	return spawnSync(command, {
+		shell: true,
+		encoding: 'utf8',
+		stdio: ['ignore', 'pipe', 'pipe'],
+	});
+}
+
+const { status, stdout, stderr } = run('npm run build:local');
+
+const code = status ?? 1;
+if (code !== 0) {
+	console.log('BUILD LOCAL FAIL');
+	const detail = `${stderr}\n${stdout}`
+		.trim()
+		.split('\n')
+		.filter((line) => line.trim().length > 0)
+		.slice(-MAX_LINES)
+		.join('\n');
+	console.log(detail || 'build:local failed');
+	process.exit(1);
+}
+
+console.log('BUILD LOCAL PASS');

package/scripts/run-format-summary.mjs

@@ -0,0 +1,36 @@
+/* eslint-disable no-console, n/no-process-exit */
+import { spawnSync } from 'node:child_process';
+
+const GLOB = '**/*.{js,jsx,ts,tsx,json,css,md}';
+const MAX_FILES = 30;
+
+const { status, stdout, stderr } = spawnSync(`npx prettier --write "${GLOB}"`, {
+	shell: true,
+	encoding: 'utf8',
+	stdio: ['ignore', 'pipe', 'pipe'],
+});
+
+const code = status ?? 1;
+if (code !== 0) {
+	console.log('FORMAT FAIL');
+	const detail = `${stderr}\n${stdout}`.trim().split('\n').slice(0, 10).join('\n');
+	console.log(detail || 'prettier failed');
+	process.exit(1);
+}
+
+const reformatted = `${stdout}`
+	.split('\n')
+	.map((line) => line.trim())
+	.filter((line) => line.length > 0 && !line.includes('(unchanged)'))
+	.map((line) => line.replace(/\s+\d+ms$/, ''));
+
+if (reformatted.length === 0) {
+	console.log('FORMAT PASS');
+	process.exit(0);
+}
+
+const shown = reformatted.slice(0, MAX_FILES);
+const suffix = reformatted.length > MAX_FILES ? `\n... +${reformatted.length - MAX_FILES} more` : '';
+
+console.log(`FORMAT: ${reformatted.length} file(s)`);
+console.log(shown.join('\n') + suffix);

package/scripts/run-lint-fix-summary.mjs

@@ -0,0 +1,38 @@
+/* eslint-disable no-console, n/no-process-exit */
+import { spawnSync } from 'node:child_process';
+
+const MAX_LINES = 25;
+
+function run(command) {
+	return spawnSync(command, {
+		shell: true,
+		encoding: 'utf8',
+		stdio: ['ignore', 'pipe', 'pipe'],
+	});
+}
+
+function compactLintErrors(output) {
+	const lines = output.split('\n').map((line) => line.trimEnd());
+	const matched = lines.filter((line) => /\berror\b/i.test(line) || /✖/.test(line) || /ESLint/.test(line));
+	return [...new Set(matched)].slice(0, MAX_LINES).join('\n');
+}
+
+const fix = run('npx eslint --fix --max-warnings=0 .');
+const fixCode = fix.status ?? 1;
+if (fixCode !== 0) {
+	console.log('LINT FIX FAIL');
+	const detail = compactLintErrors(`${fix.stdout ?? ''}\n${fix.stderr ?? ''}`);
+	console.log(detail || 'eslint --fix failed');
+	process.exit(1);
+}
+
+const verify = run('npm run lint');
+const verifyCode = verify.status ?? 1;
+if (verifyCode !== 0) {
+	console.log('LINT FIX FAIL');
+	const detail = compactLintErrors(`${verify.stdout ?? ''}\n${verify.stderr ?? ''}`);
+	console.log(detail || 'eslint verify failed after --fix');
+	process.exit(1);
+}
+
+console.log('LINT FIX PASS');

package/scripts/run-precommit-summary.mjs

@@ -0,0 +1,94 @@
+/* eslint-disable no-console, n/no-process-exit */
+import { spawnSync } from 'node:child_process';
+
+const MAX_LINES = 25;
+
+const STEPS = [
+	{ name: 'lint', command: 'npm run lint' },
+	{ name: 'type-check', command: 'npm run type-check:ci' },
+	{ name: 'dup-check', command: 'npm run dup-check' },
+	{ name: 'format:check', command: 'npm run format:check' },
+	{ name: 'test', command: 'npm run test:ci' },
+];
+
+function runStep(command) {
+	return spawnSync(command, {
+		shell: true,
+		encoding: 'utf8',
+		stdio: ['ignore', 'pipe', 'pipe'],
+	});
+}
+
+function compactLines(output, patterns) {
+	const lines = output.split('\n').map((line) => line.trimEnd());
+	const matched = lines.filter((line) => patterns.some((re) => re.test(line)));
+	const unique = [...new Set(matched)];
+	return unique.slice(0, MAX_LINES);
+}
+
+function summarize(name, stdout, stderr, code) {
+	if (code === 0) {
+		const passLine = stdout.trim().split('\n').filter(Boolean).pop();
+		return { pass: true, detail: passLine && name === 'test' ? passLine : 'PASS' };
+	}
+
+	const output = `${stdout}\n${stderr}`;
+
+	switch (name) {
+		case 'lint':
+			return {
+				pass: false,
+				detail: compactLines(output, [/\berror\b/i, /✖/, /ESLint/]).join('\n') || 'lint failed',
+			};
+		case 'type-check':
+			return {
+				pass: false,
+				detail:
+					compactLines(output, [/TYPE-CHECK FAIL/, /FAILED \d+:/, /error TS\d+/, /Found \d+ error/]).join('\n') ||
+					'type-check failed',
+			};
+		case 'dup-check':
+			return {
+				pass: false,
+				detail: compactLines(output, [/Clone found/i, /duplication/i, /ERROR/i]).join('\n') || 'dup-check failed',
+			};
+		case 'format:check':
+			return {
+				pass: false,
+				detail:
+					compactLines(output, [/^\[warn\]/i, /Code style issue/, /\.(ts|tsx|js|md|json)/]).join('\n') ||
+					'format:check failed',
+			};
+		case 'test':
+			return {
+				pass: false,
+				detail: compactLines(output, [/TESTS FAIL/, /FAILED \d+:/, /^FAILED /, / > /]).join('\n') || 'test failed',
+			};
+		default:
+			return { pass: false, detail: output.split('\n').slice(0, MAX_LINES).join('\n') };
+	}
+}
+
+const results = [];
+let failed = false;
+
+for (const step of STEPS) {
+	const { status, stdout, stderr } = runStep(step.command);
+	const code = status ?? 1;
+	const summary = summarize(step.name, stdout ?? '', stderr ?? '', code);
+	results.push({ name: step.name, ...summary });
+	if (!summary.pass) {
+		failed = true;
+		break;
+	}
+}
+
+console.log(failed ? 'PRECOMMIT FAIL' : 'PRECOMMIT PASS');
+for (const result of results) {
+	console.log(`${result.name}: ${result.pass ? result.detail : 'FAIL'}`);
+	if (!result.pass) {
+		console.log(result.detail);
+	}
+}
+
+process.exit(failed ? 1 : 0);

package/src/cli/commands/devices.ts

@@ -0,0 +1,67 @@
+import { AnsiLogger } from 'matterbridge/logger';
+
+import { toThinqDevice } from '../../core/domain/entities/ThinqDevice.js';
+import { ThinqSession } from '../../services/thinq/session.js';
+import { ThinqApiClient } from '../../services/thinq/thinqApiClient.js';
+import type { CliSession } from '../types.js';
+
+export async function cmdDevices(
+	session: CliSession,
+	logger: AnsiLogger,
+	dumpSnapshotDeviceId?: string,
+	probeFilterDeviceId?: string,
+): Promise<void> {
+	const { userData, country, language } = session;
+
+	const thinqSession = new ThinqSession(userData.accessToken, userData.refreshToken, userData.expiresAtEpochSeconds);
+	const apiClient = new ThinqApiClient(thinqSession, country, language, logger);
+	if (userData.userNumber) {
+		apiClient.setUserNumber(userData.userNumber);
+	}
+
+	if (probeFilterDeviceId) {
+		const response = await apiClient.sendCommandAndGetResponse(probeFilterDeviceId, {
+			ctrlKey: 'filterMngStateCtrl',
+			command: 'Get',
+			dataGetList: [
+				'airState.filterMngState.useTime',
+				'airState.filterMngState.remainTime',
+				'airState.filterMngState.maxTime',
+				'airState.filterMngState.changeDate',
+				'airState.filterMngState.type',
+			],
+		});
+		console.log(JSON.stringify(response, null, 2));
+		return;
+	}
+
+	const rawDevices = await apiClient.getListDevices();
+	const devices = rawDevices.map(toThinqDevice);
+
+	if (devices.length === 0) {
+		console.log('No devices found.');
+		return;
+	}
+
+	if (dumpSnapshotDeviceId) {
+		const device = devices.find((d) => d.id === dumpSnapshotDeviceId);
+		if (!device) {
+			console.error(`Device not found: ${dumpSnapshotDeviceId}`);
+			process.exitCode = 1;
+			return;
+		}
+		console.log(JSON.stringify(device.snapshot.raw, null, 2));
+		return;
+	}
+
+	console.log(`Found ${devices.length} device(s):\n`);
+	devices.forEach((device, index) => {
+		console.log(`${index + 1}. ${device.name}`);
+		console.log(`   Device ID:     ${device.id}`);
+		console.log(`   Type:          ${device.type}`);
+		console.log(`   Platform Type: ${device.platformType ?? 'unknown'}`);
+		console.log(`   Model Name:    ${device.modelName}`);
+		console.log(`   Online:        ${device.online}`);
+		console.log('');
+	});
+}

package/src/cli/commands/energy.ts

@@ -0,0 +1,160 @@
+import { AnsiLogger } from 'matterbridge/logger';
+
+import { isAirConditionerDevice, type ThinqDevice, toThinqDevice } from '../../core/domain/entities/ThinqDevice.js';
+import { ThinqSession } from '../../services/thinq/session.js';
+import { ThinqApiClient } from '../../services/thinq/thinqApiClient.js';
+import type { CliSession } from '../types.js';
+
+const ENERGY_KEY = 'airState.energy.onCurrent';
+const OPERATION_KEY = 'airState.operation';
+const KEEP_ALIVE_WAIT_MS = 2000;
+
+export interface EnergyOptions {
+	readonly deviceId: string | undefined;
+	readonly samples: number;
+	readonly intervalSeconds: number;
+	readonly keepAlive: boolean;
+}
+
+function parsePositiveNumber(name: string, raw: string | undefined, fallback: number, integer: boolean): number {
+	if (raw === undefined) {
+		return fallback;
+	}
+	const value = Number(raw);
+	if (!Number.isFinite(value) || value <= 0 || (integer && !Number.isInteger(value))) {
+		throw new Error(`Invalid --${name} value "${raw}": expected a positive ${integer ? 'integer' : 'number'}.`);
+	}
+	return value;
+}
+
+/** Builds `EnergyOptions` from the flat `parseArgs` record. Throws on invalid numeric values. */
+export function parseEnergyOptions(args: Record<string, string>): EnergyOptions {
+	const deviceArg = args['device'];
+	return {
+		deviceId: deviceArg && deviceArg !== 'true' ? deviceArg : undefined,
+		samples: parsePositiveNumber('samples', args['samples'], 1, true),
+		intervalSeconds: parsePositiveNumber('interval', args['interval'], 5, false),
+		keepAlive: args['keep-alive'] === 'true',
+	};
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function describe(value: unknown): string {
+	return `${JSON.stringify(value)} (typeof ${typeof value})`;
+}
+
+function listDeviceIds(devices: ThinqDevice[]): void {
+	if (devices.length === 0) {
+		console.log('  (no devices discovered)');
+		return;
+	}
+	for (const device of devices) {
+		console.log(`  ${device.id}  type=${device.type}  name=${device.name}`);
+	}
+}
+
+function printSample(device: ThinqDevice, index: number, total: number): void {
+	const { snapshot } = device;
+	const raw = snapshot.raw;
+
+	console.log(`--- Sample ${index}/${total} @ ${new Date().toISOString()} ---`);
+	console.log(`online (device):        ${device.online}`);
+	console.log(`online (snapshot):      ${describe(raw['online'])}`);
+	console.log(`${OPERATION_KEY}: ${describe(raw[OPERATION_KEY])}  -> isPowerOn=${snapshot.isPowerOn}`);
+
+	const keys = Object.keys(raw)
+		.filter((key) => {
+			const lower = key.toLowerCase();
+			return lower.startsWith('airstate.energy.') || lower.includes('energy') || lower.includes('power');
+		})
+		.sort();
+
+	console.log('Energy/power related keys:');
+	if (keys.length === 0) {
+		console.log('  (none found)');
+	}
+	for (const key of keys) {
+		console.log(`  ${key} = ${describe(raw[key])}`);
+	}
+
+	console.log(`${ENERGY_KEY}:`);
+	if (!(ENERGY_KEY in raw)) {
+		console.log('  key is ABSENT from this snapshot');
+	} else {
+		console.log(`  raw value:                 ${describe(raw[ENERGY_KEY])}`);
+	}
+
+	const watts = snapshot.powerConsumptionWatts;
+	if (watts === undefined) {
+		console.log('  powerConsumptionWatts:     undefined (plugin would NOT write activePower)');
+	} else {
+		console.log(`  powerConsumptionWatts:     ${watts} W`);
+		console.log(`  activePower the plugin writes: ${Math.round(watts * 1000)} mW`);
+	}
+	console.log('');
+}
+
+export async function cmdEnergy(session: CliSession, options: EnergyOptions, logger: AnsiLogger): Promise<void> {
+	const { userData, country, language } = session;
+
+	const thinqSession = new ThinqSession(userData.accessToken, userData.refreshToken, userData.expiresAtEpochSeconds);
+	const apiClient = new ThinqApiClient(thinqSession, country, language, logger);
+	if (userData.userNumber) {
+		apiClient.setUserNumber(userData.userNumber);
+	}
+
+	const fetchDevices = async (): Promise<ThinqDevice[]> => (await apiClient.getListDevices()).map(toThinqDevice);
+
+	let devices = await fetchDevices();
+
+	const target = options.deviceId
+		? devices.find((device) => device.id === options.deviceId)
+		: devices.find(isAirConditionerDevice);
+
+	if (!target) {
+		console.error(
+			options.deviceId
+				? `Device "${options.deviceId}" was not found. Discovered device ids:`
+				: 'No AC device found. Discovered device ids:',
+		);
+		listDeviceIds(devices);
+		process.exitCode = 1;
+		return;
+	}
+
+	if (!isAirConditionerDevice(target)) {
+		console.warn(`Warning: device ${target.id} is type ${target.type}, not AC; continuing anyway.`);
+	}
+
+	console.log(`Device: ${target.name} (${target.id}) type=${target.type} model=${target.modelName || 'unknown'}`);
+	console.log(
+		`Samples: ${options.samples}, interval: ${options.intervalSeconds}s, keep-alive: ${options.keepAlive ? 'yes' : 'no'}\n`,
+	);
+
+	if (options.keepAlive) {
+		await apiClient.sendKeepAlive(target.id);
+		console.log(
+			`Keep-alive sent (allEventEnable, airState.mon.timeout=70). Waiting ${KEEP_ALIVE_WAIT_MS / 1000}s...\n`,
+		);
+		await sleep(KEEP_ALIVE_WAIT_MS);
+		devices = await fetchDevices();
+	}
+
+	for (let i = 1; i <= options.samples; i++) {
+		if (i > 1) {
+			await sleep(options.intervalSeconds * 1000);
+			devices = await fetchDevices();
+		}
+
+		const current = devices.find((device) => device.id === target.id);
+		if (!current) {
+			console.error(`Sample ${i}/${options.samples}: device ${target.id} is missing from the device list.`);
+			process.exitCode = 1;
+			continue;
+		}
+		printSample(current, i, options.samples);
+	}
+}

package/src/cli/commands/login.ts

@@ -0,0 +1,74 @@
+import { AnsiLogger } from 'matterbridge/logger';
+
+import { AccountAuthStrategy } from '../../services/authentication/AccountAuthStrategy.js';
+import type { ThinqAuthContext } from '../../services/authentication/AuthContext.js';
+import { AuthenticationCoordinator } from '../../services/authentication/AuthenticationCoordinator.js';
+import { TokenAuthStrategy } from '../../services/authentication/TokenAuthStrategy.js';
+import { ThinqSession } from '../../services/thinq/session.js';
+import { ThinqApiClient } from '../../services/thinq/thinqApiClient.js';
+import { saveSession } from '../session.js';
+import { maskSecret } from '../utils.js';
+import { prompt } from '../utils.js';
+
+export type CliLoginType = 'account' | 'token';
+
+async function buildAuthContext(type: CliLoginType, country: string, language: string): Promise<ThinqAuthContext> {
+	if (type === 'token') {
+		const refreshToken = await prompt('Refresh token: ');
+		return {
+			refreshToken,
+			country,
+			language,
+		};
+	}
+
+	// type === 'account'
+	const username = await prompt('Username (email): ');
+	const password = await prompt('Password: ');
+	return {
+		username,
+		password,
+		country,
+		language,
+	};
+}
+
+export async function cmdLogin(
+	type: CliLoginType,
+	country: string,
+	language: string,
+	logger: AnsiLogger,
+): Promise<void> {
+	const context = await buildAuthContext(type, country, language);
+
+	const apiClient = new ThinqApiClient(new ThinqSession('', '', 0), country, language, logger);
+	const accountStrategy = new AccountAuthStrategy(apiClient, logger);
+	const tokenStrategy = new TokenAuthStrategy(apiClient, logger);
+	const coordinator = new AuthenticationCoordinator(accountStrategy, tokenStrategy, apiClient, logger);
+
+	const userData = await coordinator.authenticate(type, context);
+
+	if (!userData) {
+		console.error('Login did not complete: no session data was returned (a manual process may be required).');
+		process.exitCode = 1;
+		return;
+	}
+
+	const session = {
+		loginType: type,
+		country,
+		language,
+		userData,
+	};
+
+	saveSession(session);
+
+	console.log('Login successful. Session saved to .cli-session.json');
+	console.log('Session Summary:');
+	console.log(`  Login Type: ${session.loginType}`);
+	console.log(`  Country: ${session.country}`);
+	console.log(`  Language: ${session.language}`);
+	console.log(`  Access Token: ${maskSecret(session.userData.accessToken)}`);
+	console.log(`  Refresh Token: ${maskSecret(session.userData.refreshToken)}`);
+	console.log(`  Expires At: ${new Date(session.userData.expiresAtEpochSeconds * 1000).toISOString()}`);
+}

package/src/cli/help.ts

@@ -0,0 +1,53 @@
+const b = '\x1b[1m'; // bold
+const c = '\x1b[36m'; // cyan
+const y = '\x1b[33m'; // yellow
+const g = '\x1b[32m'; // green
+const d = '\x1b[2m'; // dim
+const r = '\x1b[0m'; // reset
+
+const NAME_WIDTH = 12;
+
+function row(name: string, args: string, desc: string): string {
+	const paddedName = name.padEnd(NAME_WIDTH);
+	const paddedArgs = args.padEnd(40);
+	return `  ${g}${paddedName}${r}${d}${paddedArgs}${r}${desc}`;
+}
+
+export const HELP_TEXT = `
+${b}Usage:${r}
+  npm run cli -- --command ${c}<command>${r} [options]
+
+${b}Options:${r}
+  ${y}--type${r}         account|token (default: account)
+  ${y}--country${r}      Country code (default: US)
+  ${y}--language${r}     Language code (default: en-US)
+  ${y}--help${r}         Show this help message
+  ${y}--debug${r}        Enable debug logging
+
+${b}Devices options:${r}
+  ${y}--dump-snapshot${r} Device id; prints its full raw ThinQ snapshot JSON instead of the device list
+  ${y}--probe-filter${r}  Device id; sends a filterMngStateCtrl Get probe and prints the raw response JSON
+
+${b}Energy options:${r}
+  ${y}--device${r}       Device id (default: first AC device)
+  ${y}--samples${r}      Number of snapshots to fetch (default: 1)
+  ${y}--interval${r}     Seconds between samples (default: 5)
+  ${y}--keep-alive${r}   Send the plugin's keep-alive first, wait 2s, then sample
+
+${b}Commands:${r}
+${row('login', '', 'Authenticate with LG ThinQ')}
+${row('devices', '', 'List all discovered ThinQ devices (requires a prior login)')}
+${row('energy', '[energy options]', 'Print raw AC power/energy snapshot fields (requires a prior login)')}
+${row('help', '', 'Show this help message')}
+
+${b}Examples:${r}
+  npm run cli -- ${y}--help${r}
+  npm run cli -- --command ${g}login${r}
+  npm run cli -- --command ${g}login${r} --type account --country US --language en-US
+  npm run cli -- --command ${g}login${r} --type token
+  npm run cli -- --command ${g}devices${r}
+  npm run cli -- --command ${g}devices${r} --dump-snapshot <deviceId>
+  npm run cli -- --command ${g}devices${r} --probe-filter <deviceId>
+  npm run cli -- --command ${g}energy${r}
+  npm run cli -- --command ${g}energy${r} --samples 5 --interval 10 --keep-alive
+`;