31214747864

Committed 07 Aug 2026 08:11PM UTC coverage: 64.351% (+4.5%) from 59.875%

Build # 31214747864

Build Type

push

github

Committed by

web-flow

Commit Message

Roku Cloud Emulator support (#861)

Coverage Stats

3360 of 5629 branches covered (59.69%)

Branch coverage included in aggregate %.

1160 of 1375 new or added lines in 27 files covered. (84.36%)

3 existing lines in 3 files now uncovered.

5025 of 7401 relevant lines covered (67.9%)

47.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

25.4

/src/SceneGraphDebugCommands.ts

import * as vscode from 'vscode';
import type { SceneGraphCommandResponse } from 'roku-debug';
import { SceneGraphDebugCommandController } from 'roku-debug';
import type { DeviceTargetManager } from './managers/DeviceTargetManager';

export class SceneGraphDebugCommands {
    private outputChannel: vscode.OutputChannel;
    private deviceTargetManager: DeviceTargetManager;

    public registerCommands(context: vscode.ExtensionContext, outputChannel: vscode.OutputChannel, deviceTargetManager: DeviceTargetManager) {
        this.outputChannel = outputChannel;
        this.deviceTargetManager = deviceTargetManager;
        let subscriptions = context.subscriptions;

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.bsprofPause', async () => {
            await this.logCommandOutput(async (commandController) => commandController.bsprof('pause'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.bsprofResume', async () => {
            await this.logCommandOutput(async (commandController) => commandController.bsprof('resume'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.bsprofStatus', async () => {
            await this.logCommandOutput(async (commandController) => commandController.bsprof('status'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.chanperf', async () => {
            await this.logCommandOutput(async (commandController) => commandController.chanperf());
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.chanperfChangeInterval', async () => {
            let interval = parseInt(await vscode.window.showInputBox({ placeHolder: 'seconds' }));
            if (!isNaN(interval)) {
                await this.logCommandOutput(async (commandController) => commandController.chanperf({ interval: interval }));
            }
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.clearLaunchCaches', async () => {
            await this.logCommandOutput(async (commandController) => commandController.clearLaunchCaches());
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.fpsDisplay', async () => {
            let option = await vscode.window.showQuickPick(['toggle', 'on', 'off'], { placeHolder: 'Please select an option' });
            if (option) {
                await this.logCommandOutput(async (commandController) => commandController.fpsDisplay(option as 'toggle' | 'on' | 'off'));
            }
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.free', async () => {
            await this.logCommandOutput(async (commandController) => commandController.free());
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.genkey', async () => {
            await this.logCommandOutput(async (commandController) => commandController.genkey());
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.loadedTextures', async () => {
            await this.logCommandOutput(async (commandController) => commandController.loadedTextures());
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.logrendezvous', async () => {
            let option = await vscode.window.showQuickPick(['status', 'on', 'off'], { placeHolder: 'Please select an option' });
            if (option) {
                await this.logCommandOutput(async (commandController) => commandController.logrendezvous(option as 'status' | 'on' | 'off'));
            }
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.plugins', async () => {
            await this.logCommandOutput(async (commandController) => commandController.plugins());
        }));

        // TODO: press? likely needs to go in the old area.
        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.press', async () => {
            let keys = (await vscode.window.showInputBox({ placeHolder: 'comma separated list of keys' })).split(',');
            if (keys.length > 1) {
                await this.logCommandOutput(async (commandController) => commandController.press(keys));
            }
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.r2d2bitmaps', async () => {
            await this.logCommandOutput(async (commandController) => commandController.r2d2Bitmaps());
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.removePlugin', async () => {
            let pluginId = await vscode.window.showInputBox({ placeHolder: 'plugin_id' });

            if (pluginId) {
                await this.logCommandOutput(async (commandController) => commandController.removePlugin(pluginId));
            }
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgnodesAll', async () => {
            await this.logCommandOutput(async (commandController) => commandController.sgnodes('all'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgnodesRoots', async () => {
            await this.logCommandOutput(async (commandController) => commandController.sgnodes('roots'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgnodesNodeId', async () => {
            let nodeId = await vscode.window.showInputBox({ placeHolder: 'node_id' });
            if (nodeId) {
                await this.logCommandOutput(async (commandController) => commandController.sgnodes(nodeId));
            }
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfStart', async () => {
            await this.logCommandOutput(async (commandController) => commandController.sgperf('start'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfStop', async () => {
            await this.logCommandOutput(async (commandController) => commandController.sgperf('stop'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfClear', async () => {
            await this.logCommandOutput(async (commandController) => commandController.sgperf('clear'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfReport', async () => {
            await this.logCommandOutput(async (commandController) => commandController.sgperf('report'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.showkey', async () => {
            await this.logCommandOutput(async (commandController) => commandController.showkey());
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.brightscriptWarnings', async () => {
            let limit = parseInt(await vscode.window.showInputBox({ placeHolder: '100', validateInput: (value: string) => {
                if (isNaN(parseInt(value))) {
                    return 'Input must be a numeric value';
                }
            } }));

            if (!isNaN(limit)) {
                await this.logCommandOutput((commandController) => commandController.brightscriptWarnings(limit));
            }
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.custom8080Command', async () => {
            let command = await vscode.window.showInputBox({ placeHolder: 'custom command' });
            if (command) {
                await this.logCommandOutput(async (commandController) => commandController.exec(command));
            }
        }));
    }

    private async logCommandOutput(callback: (controller: SceneGraphDebugCommandController) => Promise<SceneGraphCommandResponse>) {
        //active device first (LAN or Roku Cloud Emulator - the controller accepts either device
        //config), then the legacy host fallbacks / device picker
        const target = await this.deviceTargetManager.resolveActiveTargetDevice();
        if (!target) {
            return;
        }
        let response = await callback(new SceneGraphDebugCommandController(target.device));

        this.outputChannel.show();

        // The output channel seems to have a limit to the amount of output that can be displayed in a single log.
        // For this reason we split the output into groups of 20 lines and send each group. If we don't do this a lot of
        // the middle of the string gets cut out.
        let lines = (response?.error?.message ?? response.result.rawResponse).split('\n');
        let lineGroups = this.chunkArray(lines);

        // Log the command statement
        this.outputChannel.append(`>${response.command}\n`);

        // Log each group of 20 lines
        for (let lineGroup of lineGroups) {
            this.outputChannel.append(lineGroup.join('\n') + '\n');
        }
    }

    private chunkArray(arr: Array<any>, chunkSize = 20) {
        if (chunkSize <= 0) {
            return arr;
        }

        let chunks = [];
        for (let i = 0, len = arr.length; i < len; i += 20) {
            chunks.push(arr.slice(i, i + chunkSize));

        }

        return chunks;
    }

}

export const sceneGraphDebugCommands = new SceneGraphDebugCommands();

1	import * as vscode from 'vscode';	1✔
2	import type { SceneGraphCommandResponse } from 'roku-debug';
3	import { SceneGraphDebugCommandController } from 'roku-debug';	1✔
4	import type { DeviceTargetManager } from './managers/DeviceTargetManager';
5
6	export class SceneGraphDebugCommands {	1✔
7	private outputChannel: vscode.OutputChannel;
8	private deviceTargetManager: DeviceTargetManager;
9
10	public registerCommands(context: vscode.ExtensionContext, outputChannel: vscode.OutputChannel, deviceTargetManager: DeviceTargetManager) {
11	this.outputChannel = outputChannel;	12✔
12	this.deviceTargetManager = deviceTargetManager;	12✔
13	let subscriptions = context.subscriptions;	12✔
14
15	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.bsprofPause', async () => {	12✔
16	await this.logCommandOutput(async (commandController) => commandController.bsprof('pause'));	×
17	}));
18
19	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.bsprofResume', async () => {	12✔
20	await this.logCommandOutput(async (commandController) => commandController.bsprof('resume'));	×
21	}));
22
23	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.bsprofStatus', async () => {	12✔
24	await this.logCommandOutput(async (commandController) => commandController.bsprof('status'));	×
25	}));
26
27	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.chanperf', async () => {	12✔
28	await this.logCommandOutput(async (commandController) => commandController.chanperf());	×
29	}));
30
31	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.chanperfChangeInterval', async () => {	12✔
32	let interval = parseInt(await vscode.window.showInputBox({ placeHolder: 'seconds' }));	×
33	if (!isNaN(interval)) {	×
34	await this.logCommandOutput(async (commandController) => commandController.chanperf({ interval: interval }));	×
35	}
36	}));
37
38	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.clearLaunchCaches', async () => {	12✔
39	await this.logCommandOutput(async (commandController) => commandController.clearLaunchCaches());	×
40	}));
41
42	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.fpsDisplay', async () => {	12✔
43	let option = await vscode.window.showQuickPick(['toggle', 'on', 'off'], { placeHolder: 'Please select an option' });	×
44	if (option) {	×
45	await this.logCommandOutput(async (commandController) => commandController.fpsDisplay(option as 'toggle' \| 'on' \| 'off'));	×
46	}
47	}));
48
49	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.free', async () => {	12✔
50	await this.logCommandOutput(async (commandController) => commandController.free());	×
51	}));
52
53	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.genkey', async () => {	12✔
54	await this.logCommandOutput(async (commandController) => commandController.genkey());	×
55	}));
56
57	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.loadedTextures', async () => {	12✔
58	await this.logCommandOutput(async (commandController) => commandController.loadedTextures());	×
59	}));
60
61	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.logrendezvous', async () => {	12✔
62	let option = await vscode.window.showQuickPick(['status', 'on', 'off'], { placeHolder: 'Please select an option' });	×
63	if (option) {	×
64	await this.logCommandOutput(async (commandController) => commandController.logrendezvous(option as 'status' \| 'on' \| 'off'));	×
65	}
66	}));
67
68	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.plugins', async () => {	12✔
69	await this.logCommandOutput(async (commandController) => commandController.plugins());	×
70	}));
71
72	// TODO: press? likely needs to go in the old area.
73	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.press', async () => {	12✔
74	let keys = (await vscode.window.showInputBox({ placeHolder: 'comma separated list of keys' })).split(',');	×
75	if (keys.length > 1) {	×
76	await this.logCommandOutput(async (commandController) => commandController.press(keys));	×
77	}
78	}));
79
80	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.r2d2bitmaps', async () => {	12✔
81	await this.logCommandOutput(async (commandController) => commandController.r2d2Bitmaps());	×
82	}));
83
84	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.removePlugin', async () => {	12✔
85	let pluginId = await vscode.window.showInputBox({ placeHolder: 'plugin_id' });	×
86
87	if (pluginId) {	×
88	await this.logCommandOutput(async (commandController) => commandController.removePlugin(pluginId));	×
89	}
90	}));
91
92	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgnodesAll', async () => {	12✔
93	await this.logCommandOutput(async (commandController) => commandController.sgnodes('all'));	×
94	}));
95
96	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgnodesRoots', async () => {	12✔
97	await this.logCommandOutput(async (commandController) => commandController.sgnodes('roots'));	×
98	}));
99
100	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgnodesNodeId', async () => {	12✔
101	let nodeId = await vscode.window.showInputBox({ placeHolder: 'node_id' });	×
102	if (nodeId) {	×
103	await this.logCommandOutput(async (commandController) => commandController.sgnodes(nodeId));	×
104	}
105	}));
106
107	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfStart', async () => {	12✔
108	await this.logCommandOutput(async (commandController) => commandController.sgperf('start'));	×
109	}));
110
111	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfStop', async () => {	12✔
112	await this.logCommandOutput(async (commandController) => commandController.sgperf('stop'));	×
113	}));
114
115	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfClear', async () => {	12✔
116	await this.logCommandOutput(async (commandController) => commandController.sgperf('clear'));	×
117	}));
118
119	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfReport', async () => {	12✔
120	await this.logCommandOutput(async (commandController) => commandController.sgperf('report'));	×
121	}));
122
123	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.showkey', async () => {	12✔
124	await this.logCommandOutput(async (commandController) => commandController.showkey());	×
125	}));
126
127	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.brightscriptWarnings', async () => {	12✔
128	let limit = parseInt(await vscode.window.showInputBox({ placeHolder: '100', validateInput: (value: string) => {	×
129	if (isNaN(parseInt(value))) {	×
130	return 'Input must be a numeric value';	×
131	}
132	} }));
133
134	if (!isNaN(limit)) {	×
135	await this.logCommandOutput((commandController) => commandController.brightscriptWarnings(limit));	×
136	}
137	}));
138
139	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.custom8080Command', async () => {	12✔
140	let command = await vscode.window.showInputBox({ placeHolder: 'custom command' });	×
141	if (command) {	×
142	await this.logCommandOutput(async (commandController) => commandController.exec(command));	×
143	}
144	}));
145	}
146
147	private async logCommandOutput(callback: (controller: SceneGraphDebugCommandController) => Promise<SceneGraphCommandResponse>) {
148	//active device first (LAN or Roku Cloud Emulator - the controller accepts either device
149	//config), then the legacy host fallbacks / device picker
NEW 150	const target = await this.deviceTargetManager.resolveActiveTargetDevice();	×
NEW 151	if (!target) {	×
NEW 152	return;	×
153	}
NEW 154	let response = await callback(new SceneGraphDebugCommandController(target.device));	×
155
156	this.outputChannel.show();	×
157
158	// The output channel seems to have a limit to the amount of output that can be displayed in a single log.
159	// For this reason we split the output into groups of 20 lines and send each group. If we don't do this a lot of
160	// the middle of the string gets cut out.
161	let lines = (response?.error?.message ?? response.result.rawResponse).split('\n');	×
162	let lineGroups = this.chunkArray(lines);	×
163
164	// Log the command statement
165	this.outputChannel.append(`>${response.command}\n`);	×
166
167	// Log each group of 20 lines
168	for (let lineGroup of lineGroups) {	×
169	this.outputChannel.append(lineGroup.join('\n') + '\n');	×
170	}
171	}
172
173	private chunkArray(arr: Array<any>, chunkSize = 20) {	×
174	if (chunkSize <= 0) {	×
175	return arr;	×
176	}
177
178	let chunks = [];	×
179	for (let i = 0, len = arr.length; i < len; i += 20) {	×
180	chunks.push(arr.slice(i, i + chunkSize));	×
181
182	}
183
184	return chunks;	×
185	}
186
187	}
188
189	export const sceneGraphDebugCommands = new SceneGraphDebugCommands();	1✔

rokucommunity / vscode-brightscript-language / 31214747864

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous