roku-debug 0.20.5 → 0.20.7

package/dist/debugProtocol/ProtocolUtil.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protocolUtil = exports.ProtocolUtil = void 0;
+const smart_buffer_1 = require("smart-buffer");
+const util_1 = require("../util");
+const Constants_1 = require("./Constants");
+class ProtocolUtil {
+    /**
+     * Load json data onto an event, and mark it as successful
+     */
+    loadJson(event, data) {
+        event.data = {
+            ...event.data,
+            ...(data !== null && data !== void 0 ? data : {})
+        };
+        event.success = true;
+    }
+    /**
+     * Helper function for buffer loading.
+     * Handles things like try/catch, setting buffer read offset, etc
+     */
+    bufferLoaderHelper(event, buffer, minByteLength, processor) {
+        var _a, _b;
+        // Required size of this processor
+        try {
+            if (buffer.byteLength >= minByteLength) {
+                let smartBuffer = smart_buffer_1.SmartBuffer.fromBuffer(buffer);
+                //have the processor consume the requred bytes.
+                event.success = ((_a = processor(smartBuffer)) !== null && _a !== void 0 ? _a : true);
+                //if the event has a packet length, use THAT as the read offset. Otherwise, set the offset to the end of the read position of the buffer
+                if (event.success) {
+                    if (!event.readOffset) {
+                        event.readOffset = (_b = event.data.packetLength) !== null && _b !== void 0 ? _b : smartBuffer.readOffset;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Could not parse
+            event.readOffset = 0;
+            event.success = false;
+        }
+        return event;
+    }
+    /**
+     * Load the common DebuggerRequest fields
+     */
+    loadCommonRequestFields(request, smartBuffer) {
+        request.data.packetLength = smartBuffer.readUInt32LE(); // packet_length
+        request.data.requestId = smartBuffer.readUInt32LE(); // request_id
+        request.data.command = Constants_1.CommandCode[smartBuffer.readUInt32LE()]; // command_code
+    }
+    /**
+     * Load the common DebuggerResponse
+     */
+    loadCommonResponseFields(response, smartBuffer) {
+        response.data.packetLength = smartBuffer.readUInt32LE(); // packet_length
+        response.data.requestId = smartBuffer.readUInt32LE(); // request_id
+        response.data.errorCode = smartBuffer.readUInt32LE(); // error_code
+        //if the error code is non-zero, and we have more bytes, then there will be additional data about the error
+        if (response.data.errorCode !== Constants_1.ErrorCode.OK && response.data.packetLength > smartBuffer.readOffset) {
+            response.data.errorData = {};
+            const errorFlags = smartBuffer.readUInt32LE(); // error_flags
+            // eslint-disable-next-line no-bitwise
+            if (errorFlags & Constants_1.ErrorFlags.INVALID_VALUE_IN_PATH) {
+                response.data.errorData.invalidPathIndex = smartBuffer.readUInt32LE(); // invalid_path_index
+            }
+            // eslint-disable-next-line no-bitwise
+            if (errorFlags & Constants_1.ErrorFlags.MISSING_KEY_IN_PATH) {
+                response.data.errorData.missingKeyIndex = smartBuffer.readUInt32LE(); // missing_key_index
+            }
+        }
+    }
+    loadCommonUpdateFields(update, smartBuffer, updateType) {
+        update.data.packetLength = smartBuffer.readUInt32LE(); // packet_length
+        update.data.requestId = smartBuffer.readUInt32LE(); // request_id
+        update.data.errorCode = smartBuffer.readUInt32LE(); // error_code
+        // requestId 0 means this is an update.
+        if (update.data.requestId === 0) {
+            update.data.updateType = Constants_1.UpdateTypeCode[smartBuffer.readUInt32LE()];
+            //if this is not the update type we want, return false
+            if (update.data.updateType !== updateType) {
+                return false;
+            }
+        }
+        else {
+            //not an update. We should not proceed any further.
+            throw new Error('This is not an update');
+        }
+    }
+    /**
+     * Inserts the common command fields to the beginning of the buffer, and computes
+     * the correct `packet_length` value.
+     */
+    insertCommonRequestFields(request, smartBuffer) {
+        smartBuffer.insertUInt32LE(Constants_1.CommandCode[request.data.command], 0); // command_code - An enum representing the debugging command being sent. See the COMMANDS enum
+        smartBuffer.insertUInt32LE(request.data.requestId, 0); // request_id - The ID of the debugger request (must be >=1). This ID is included in the debugger response.
+        smartBuffer.insertUInt32LE(smartBuffer.writeOffset + 4, 0); // packet_length - The size of the packet to be sent.
+        request.data.packetLength = smartBuffer.writeOffset;
+        return smartBuffer;
+    }
+    insertCommonResponseFields(response, smartBuffer) {
+        var _a, _b, _c, _d, _e;
+        //insert error data
+        const flags = (
+        // eslint-disable-next-line no-bitwise
+        0 |
+            (util_1.util.isNullish((_b = (_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.errorData) === null || _b === void 0 ? void 0 : _b.invalidPathIndex) ? 0 : Constants_1.ErrorFlags.INVALID_VALUE_IN_PATH) |
+            (util_1.util.isNullish((_d = (_c = response === null || response === void 0 ? void 0 : response.data) === null || _c === void 0 ? void 0 : _c.errorData) === null || _d === void 0 ? void 0 : _d.missingKeyIndex) ? 0 : Constants_1.ErrorFlags.MISSING_KEY_IN_PATH));
+        if (response.data.errorCode !== Constants_1.ErrorCode.OK &&
+            //there's some error data
+            Object.values((_e = response.data.errorData) !== null && _e !== void 0 ? _e : {}).some(x => !util_1.util.isNullish(x))) {
+            //do these in reverse order since we're writing to the start of the buffer
+            if (!util_1.util.isNullish(response.data.errorData.missingKeyIndex)) {
+                smartBuffer.insertUInt32LE(response.data.errorData.missingKeyIndex, 0);
+            }
+            //write error data
+            if (!util_1.util.isNullish(response.data.errorData.invalidPathIndex)) {
+                smartBuffer.insertUInt32LE(response.data.errorData.invalidPathIndex, 0);
+            }
+            //write flags
+            smartBuffer.insertUInt32LE(flags, 0);
+        }
+        smartBuffer.insertUInt32LE(response.data.errorCode, 0); // error_code
+        smartBuffer.insertUInt32LE(response.data.requestId, 0); // request_id
+        smartBuffer.insertUInt32LE(smartBuffer.writeOffset + 4, 0); // packet_length
+        response.data.packetLength = smartBuffer.writeOffset;
+        return smartBuffer;
+    }
+    /**
+     * Inserts the common response fields to the beginning of the buffer, and computes
+     * the correct `packet_length` value.
+     */
+    insertCommonUpdateFields(update, smartBuffer) {
+        smartBuffer.insertUInt32LE(Constants_1.UpdateTypeCode[update.data.updateType], 0); // update_type
+        smartBuffer.insertUInt32LE(update.data.errorCode, 0); // error_code
+        smartBuffer.insertUInt32LE(update.data.requestId, 0); // request_id
+        smartBuffer.insertUInt32LE(smartBuffer.writeOffset + 4, 0); // packet_length
+        update.data.packetLength = smartBuffer.writeOffset;
+        return smartBuffer;
+    }
+    /**
+     * Tries to read a string from the buffer and will throw an error if there is no null terminator.
+     * @param {SmartBuffer} bufferReader
+     */
+    readStringNT(bufferReader) {
+        // Find next null character (if one is not found, throw)
+        let buffer = bufferReader.toBuffer();
+        let foundNullTerminator = false;
+        for (let i = bufferReader.readOffset; i < buffer.length; i++) {
+            if (buffer[i] === 0x00) {
+                foundNullTerminator = true;
+                break;
+            }
+        }
+        if (!foundNullTerminator) {
+            throw new Error('Could not read buffer string as there is no null terminator.');
+        }
+        return bufferReader.readStringNT();
+    }
+}
+exports.ProtocolUtil = ProtocolUtil;
+exports.protocolUtil = new ProtocolUtil();
+//# sourceMappingURL=ProtocolUtil.js.map

package/dist/debugProtocol/ProtocolUtil.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolUtil.js","sourceRoot":"","sources":["../../src/debugProtocol/ProtocolUtil.ts"],"names":[],"mappings":"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"}

package/dist/debugProtocol/client/DebugProtocolClient.d.ts

@@ -0,0 +1,310 @@
+/// <reference types="node" />
+import { PROTOCOL_ERROR_CODES, Command } from '../Constants';
+import { ExecuteV3Response } from '../events/responses/ExecuteV3Response';
+import { ListBreakpointsResponse } from '../events/responses/ListBreakpointsResponse';
+import { AddBreakpointsResponse } from '../events/responses/AddBreakpointsResponse';
+import { ThreadsRequest } from '../events/requests/ThreadsRequest';
+import type { ProtocolRequest, ProtocolResponse, ProtocolUpdate } from '../events/ProtocolEvent';
+import { HandshakeResponse } from '../events/responses/HandshakeResponse';
+import { HandshakeV3Response } from '../events/responses/HandshakeV3Response';
+import { GenericV3Response } from '../events/responses/GenericV3Response';
+import { AllThreadsStoppedUpdate } from '../events/updates/AllThreadsStoppedUpdate';
+import { CompileErrorUpdate } from '../events/updates/CompileErrorUpdate';
+import { GenericResponse } from '../events/responses/GenericResponse';
+import type { StackTraceResponse } from '../events/responses/StackTraceResponse';
+import { ThreadsResponse } from '../events/responses/ThreadsResponse';
+import { VariablesResponse } from '../events/responses/VariablesResponse';
+import { ThreadAttachedUpdate } from '../events/updates/ThreadAttachedUpdate';
+import { StackTraceV3Response } from '../events/responses/StackTraceV3Response';
+import type { DebugProtocolClientPlugin } from './DebugProtocolClientPlugin';
+import PluginInterface from '../PluginInterface';
+import type { VerifiedBreakpoint } from '../events/updates/BreakpointVerifiedUpdate';
+export declare class DebugProtocolClient {
+    logger: import("@rokucommunity/logger/dist/Logger").Logger;
+    supportedVersionRange: string;
+    constructor(options?: ConstructorOptions);
+    private addCorePlugin;
+    static DEBUGGER_MAGIC: string;
+    scriptTitle: string;
+    isHandshakeComplete: boolean;
+    connectedToIoPort: boolean;
+    /**
+     * Debug protocol version 3.0.0 introduced a packet_length to all responses. Prior to that, most responses had no packet length at all.
+     * This field indicates whether we should be looking for packet_length or not in the responses we get from the device
+     */
+    watchPacketLength: boolean;
+    protocolVersion: string;
+    primaryThread: number;
+    stackFrameIndex: number;
+    /**
+     * A collection of plugins that can interact with the client at lifecycle points
+     */
+    plugins: PluginInterface<DebugProtocolClientPlugin>;
+    private emitter;
+    /**
+     * The primary socket for this session. It's used to communicate with the debugger by sending commands and receives responses or updates
+     */
+    private controlSocket;
+    /**
+     * Promise that is resolved when the control socket is closed
+     */
+    private controlSocketClosed;
+    /**
+     * A socket where the debug server will send stdio
+     */
+    private ioSocket;
+    /**
+     * Resolves when the ioSocket has closed
+     */
+    private ioSocketClosed;
+    /**
+     * The buffer where all unhandled data will be stored until successfully consumed
+     */
+    private buffer;
+    /**
+     * Is the debugger currently stopped at a line of code in the program
+     */
+    isStopped: boolean;
+    private requestIdSequence;
+    private activeRequests;
+    private options;
+    /**
+     * Prior to protocol v3.1.0, the Roku device would regularly set the wrong thread as "active",
+     * so this flag lets us know if we should use our better-than-nothing workaround
+     */
+    private get enableThreadHoppingWorkaround();
+    /**
+     * Starting in protocol v3.1.0, component libary breakpoints must be added in the format `lib:/<library_name>/<filepath>`, but prior they didn't require this.
+     * So this flag tells us which format to support
+     */
+    private get enableComponentLibrarySpecificBreakpoints();
+    /**
+     * Starting in protocol v3.1.0, breakpoints can support conditional expressions. This flag indicates whether the current sessuion supports that functionality.
+     */
+    private get supportsConditionalBreakpoints();
+    get supportsBreakpointRegistrationWhileRunning(): boolean;
+    get supportsBreakpointVerification(): boolean;
+    /**
+     * Get a promise that resolves after an event occurs exactly once
+     */
+    once(eventName: 'app-exit' | 'cannot-continue' | 'close' | 'start'): Promise<void>;
+    once(eventName: 'breakpoints-verified'): Promise<BreakpointsVerifiedEvent>;
+    once<T = AllThreadsStoppedUpdate | ThreadAttachedUpdate>(eventName: 'runtime-error' | 'suspend'): Promise<T>;
+    once(eventName: 'io-output'): Promise<string>;
+    once(eventName: 'data'): Promise<Buffer>;
+    once(eventName: 'response'): Promise<ProtocolResponse>;
+    once(eventName: 'update'): Promise<ProtocolUpdate>;
+    once(eventName: 'protocol-version'): Promise<ProtocolVersionDetails>;
+    once(eventName: 'handshake-verified'): Promise<HandshakeResponse>;
+    on(eventName: 'compile-error', handler: (event: CompileErrorUpdate) => void): any;
+    on(eventName: 'app-exit' | 'cannot-continue' | 'close' | 'start', handler: () => void): any;
+    on(eventName: 'breakpoints-verified', handler: (event: BreakpointsVerifiedEvent) => void): any;
+    on(eventName: 'response', handler: (response: ProtocolResponse) => void): any;
+    on(eventName: 'update', handler: (update: ProtocolUpdate) => void): any;
+    /**
+     * The raw data from the server socket. You probably don't need this...
+     */
+    on(eventName: 'data', handler: (data: Buffer) => void): any;
+    on<T = AllThreadsStoppedUpdate | ThreadAttachedUpdate>(eventName: 'runtime-error' | 'suspend', handler: (data: T) => void): any;
+    on(eventName: 'io-output', handler: (output: string) => void): any;
+    on(eventName: 'protocol-version', handler: (data: ProtocolVersionDetails) => void): any;
+    on(eventName: 'handshake-verified', handler: (data: HandshakeResponse) => void): any;
+    private emit;
+    /**
+     * A function that can be used to cancel the repeating interval that's running to try and establish a connection to the control socket.
+     */
+    private cancelControlConnectInterval;
+    /**
+     * A collection of sockets created when trying to connect to the debug protocol's control socket. We keep these around for quicker tear-down
+     * whenever there is an early-terminated debug session
+     */
+    private pendingControlConnectionSockets;
+    private establishControlConnection;
+    /**
+     * A queue for processing the incoming buffer, every transmission at a time
+     */
+    private bufferQueue;
+    /**
+     * Connect to the debug server.
+     * @param sendHandshake should the handshake be sent as part of this connect process. If false, `.sendHandshake()` will need to be called before a session can begin
+     */
+    connect(sendHandshake?: boolean): Promise<boolean>;
+    /**
+     * Send the initial handshake request, and wait for the handshake response
+     */
+    sendHandshake(): Promise<HandshakeResponse | HandshakeV3Response>;
+    private processHandshakeRequest;
+    /**
+     * Write a specific buffer log entry to the logger, which, when file logging is enabled
+     * can be extracted and processed through the DebugProtocolClientReplaySession
+     */
+    private writeToBufferLog;
+    continue(): Promise<GenericResponse>;
+    private processContinueRequest;
+    pause(): Promise<GenericResponse>;
+    private processStopRequest;
+    /**
+     * Send the "exit channel" command, which will tell the debug session to immediately quit
+     */
+    exitChannel(): Promise<GenericResponse>;
+    stepIn(threadIndex?: number): Promise<GenericResponse>;
+    stepOver(threadIndex?: number): Promise<GenericResponse>;
+    stepOut(threadIndex?: number): Promise<GenericResponse>;
+    private step;
+    private processStepRequest;
+    threads(): Promise<ThreadsResponse>;
+    processThreadsRequest(request: ThreadsRequest): Promise<ThreadsResponse>;
+    /**
+     * Get the stackTrace from the device IF currently stopped
+     */
+    getStackTrace(threadIndex?: number): Promise<StackTraceResponse>;
+    private processStackTraceRequest;
+    /**
+     * @param variablePathEntries One or more path entries to the variable to be inspected. E.g., m.top.myObj["someKey"] can be accessed with ["m","top","myobj","\"someKey\""].
+     *
+     *                            If no path is specified, the variables accessible from the specified stack frame are returned.
+     *
+     *                            Starting in protocol v3.1.0, The keys for indexed gets (i.e. obj["key"]) should be wrapped in quotes so they can be handled in a case-sensitive fashion (if applicable on device).
+     *                            All non-quoted keys (i.e. strings without leading and trailing quotes inside them) will be treated as case-insensitive).
+     * @param getChildKeys  If set, VARIABLES response include the child keys for container types like lists and associative arrays
+     * @param stackFrameIndex 0 = first function called, nframes-1 = last function. This indexing does not match the order of the frames returned from the STACKTRACE command
+     * @param threadIndex the index (or perhaps ID?) of the thread to get variables for
+     */
+    getVariables(variablePathEntries?: Array<string>, stackFrameIndex?: number, threadIndex?: number): Promise<VariablesResponse>;
+    private processVariablesRequest;
+    executeCommand(sourceCode: string, stackFrameIndex?: number, threadIndex?: number): Promise<ExecuteV3Response>;
+    private processExecuteRequest;
+    addBreakpoints(breakpoints: Array<BreakpointSpec & {
+        componentLibraryName?: string;
+    }>): Promise<AddBreakpointsResponse>;
+    listBreakpoints(): Promise<ListBreakpointsResponse>;
+    /**
+     * Remove breakpoints having the specified IDs
+     */
+    removeBreakpoints(breakpointIds: number[]): Promise<ListBreakpointsResponse>;
+    private processRemoveBreakpointsRequest;
+    /**
+     * Given a request, process it in the proper fashion. This is mostly used for external mocking/testing of
+     * this client, but it should force the client to flow in the same fashion as a live debug session
+     */
+    processRequest<TResponse extends ProtocolResponse>(request: ProtocolRequest): Promise<TResponse>;
+    /**
+     * Send a request to the roku device, and get a promise that resolves once we have received the response
+     */
+    private sendRequest;
+    /**
+     * Sometimes a request arrives that we don't understand. If that's the case, this function can be used
+     * to discard that entire response by discarding `packet_length` number of bytes
+     */
+    private discardNextResponseOrUpdate;
+    /**
+     * A counter to help give a unique id to each update (mostly just for logging purposes)
+     */
+    private updateSequence;
+    private logEvent;
+    private process;
+    /**
+     * Given a buffer, try to parse into a specific ProtocolResponse or ProtocolUpdate
+     */
+    getResponseOrUpdate(buffer: Buffer): Promise<ProtocolResponse | ProtocolUpdate>;
+    static getResponse(buffer: Buffer, command: Command): ExecuteV3Response | ListBreakpointsResponse | GenericV3Response | StackTraceV3Response | ThreadsResponse | VariablesResponse;
+    getUpdate(buffer: Buffer): ProtocolUpdate;
+    private handleUpdateQueue;
+    /**
+     * Handle/process any received updates from the debug protocol
+     */
+    private handleUpdate;
+    /**
+     * Verify all the handshake data
+     */
+    private verifyHandshake;
+    /**
+     * When the debugger emits the IOPortOpenedUpdate, we need to immediately connect to the IO port to start receiving that data
+     */
+    private connectToIoPort;
+    /**
+     * Destroy this instance, shutting down any sockets or other long-running items and cleaning up.
+     * @param immediate if true, all sockets are immediately closed and do not gracefully shut down
+     */
+    destroy(immediate?: boolean): Promise<void>;
+    private shutdown;
+    private isDestroyingControlSocket;
+    private destroyControlSocket;
+    private isDestroyingIOSocket;
+    /**
+     * @param immediate if true, force close immediately instead of waiting for it to settle
+     */
+    private destroyIOSocket;
+}
+export interface ProtocolVersionDetails {
+    message: string;
+    errorCode: PROTOCOL_ERROR_CODES;
+}
+export interface BreakpointSpec {
+    /**
+     * The path of the source file where the breakpoint is to be inserted.
+     */
+    filePath: string;
+    /**
+     * The (1-based) line number in the channel application code where the breakpoint is to be executed.
+     */
+    lineNumber: number;
+    /**
+     * The number of times to ignore the breakpoint condition before executing the breakpoint. This number is decremented each time the channel application reaches the breakpoint.
+     */
+    hitCount?: number;
+    /**
+     * BrightScript code that evaluates to a boolean value. The expression is compiled and executed in
+     * the context where the breakpoint is located. If specified, the hitCount is only be
+     * updated if this evaluates to true.
+     * @avaiable since protocol version 3.1.0
+     */
+    conditionalExpression?: string;
+}
+export interface ConstructorOptions {
+    /**
+     * The host/ip address of the Roku
+     */
+    host: string;
+    /**
+     * The port number used to send all debugger commands. This is static/unchanging for Roku devices,
+     * but is configurable here to support unit testing or alternate runtimes (i.e. https://www.npmjs.com/package/brs)
+     */
+    controlPort?: number;
+    /**
+     * The interval (in milliseconds) for how frequently the `connect`
+     * call should retry connecting to the control port. At the start of a debug session,
+     * the protocol debugger will start trying to connect the moment the channel is sideloaded,
+     * and keep trying until a successful connection is established or the debug session is terminated
+     * @default 250
+     */
+    controlConnectInterval?: number;
+    /**
+     * The maximum time (in milliseconds) the debugger will keep retrying connections.
+     * This is here to prevent infinitely pinging the Roku device.
+     */
+    controlConnectMaxTime?: number;
+    /**
+     * The number of milliseconds that the client should wait during a shutdown request before forcefully terminating the sockets
+     */
+    shutdownTimeout?: number;
+    /**
+     * The max time the client will wait for the `exit channel` response before forcefully terminating the sockets
+     */
+    exitChannelTimeout?: number;
+}
+/**
+ * Is the event a ProtocolRequest
+ */
+export declare function isProtocolRequest(event: ProtocolRequest | ProtocolResponse | ProtocolUpdate): event is ProtocolRequest;
+/**
+ * Is the event a ProtocolResponse
+ */
+export declare function isProtocolResponse(event: ProtocolRequest | ProtocolResponse | ProtocolUpdate): event is ProtocolResponse;
+/**
+ * Is the event a ProtocolUpdate update
+ */
+export declare function isProtocolUpdate(event: ProtocolRequest | ProtocolResponse | ProtocolUpdate): event is ProtocolUpdate;
+export interface BreakpointsVerifiedEvent {
+    breakpoints: VerifiedBreakpoint[];
+}