roku-debug 0.20.6 → 0.20.7

package/dist/debugProtocol/Debugger.js

@@ -1,635 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Debugger = void 0;
-const Net = require("net");
-const EventEmitter = require("eventemitter3");
-const semver = require("semver");
-const responses_1 = require("./responses");
-const Constants_1 = require("./Constants");
-const smart_buffer_1 = require("smart-buffer");
-const logging_1 = require("../logging");
-const ExecuteResponseV3_1 = require("./responses/ExecuteResponseV3");
-const ListBreakpointsResponse_1 = require("./responses/ListBreakpointsResponse");
-const AddBreakpointsResponse_1 = require("./responses/AddBreakpointsResponse");
-const RemoveBreakpointsResponse_1 = require("./responses/RemoveBreakpointsResponse");
-const util_1 = require("../util");
-const BreakpointErrorUpdateResponse_1 = require("./responses/BreakpointErrorUpdateResponse");
-const BreakpointVerifiedUpdateResponse_1 = require("./responses/BreakpointVerifiedUpdateResponse");
-class Debugger {
-    constructor(options) {
-        this.logger = logging_1.logger.createLogger(`[${Debugger.name}]`);
-        // The highest tested version of the protocol we support.
-        this.supportedVersionRange = '<=3.0.0';
-        this.handshakeComplete = false;
-        this.connectedToIoPort = false;
-        this.watchPacketLength = false;
-        this.emitter = new EventEmitter();
-        this.stopped = false;
-        this.totalRequests = 0;
-        this.activeRequests = {};
-        this.options = {
-            controllerPort: 8081,
-            host: undefined,
-            //override the defaults with the options from parameters
-            ...options !== null && options !== void 0 ? options : {}
-        };
-    }
-    get isStopped() {
-        return this.stopped;
-    }
-    /**
-     * 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
-     */
-    get enableThreadHoppingWorkaround() {
-        return semver.satisfies(this.protocolVersion, '<3.1.0');
-    }
-    /**
-     * 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
-     */
-    get enableComponentLibrarySpecificBreakpoints() {
-        return semver.satisfies(this.protocolVersion, '>=3.1.0');
-    }
-    /**
-     * Starting in protocol v3.1.0, breakpoints can support conditional expressions. This flag indicates whether the current sessuion supports that functionality.
-     */
-    get supportsConditionalBreakpoints() {
-        return semver.satisfies(this.protocolVersion, '>=3.1.0');
-    }
-    get supportsBreakpointRegistrationWhileRunning() {
-        return semver.satisfies(this.protocolVersion, '>=3.2.0');
-    }
-    get supportsBreakpointVerification() {
-        return semver.satisfies(this.protocolVersion, '>=3.2.0');
-    }
-    once(eventName) {
-        return new Promise((resolve) => {
-            const disconnect = this.on(eventName, (...args) => {
-                disconnect();
-                resolve(...args);
-            });
-        });
-    }
-    // public on(eventname: 'rendezvous', handler: (output: RendezvousHistory) => void);
-    // public on(eventName: 'runtime-error', handler: (error: BrightScriptRuntimeError) => void);
-    on(eventName, handler) {
-        this.emitter.on(eventName, handler);
-        return () => {
-            var _a;
-            (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.removeListener(eventName, handler);
-        };
-    }
-    emit(eventName, data) {
-        //emit these events on next tick, otherwise they will be processed immediately which could cause issues
-        setTimeout(() => {
-            var _a;
-            //in rare cases, this event is fired after the debugger has closed, so make sure the event emitter still exists
-            (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.emit(eventName, data);
-        }, 0);
-    }
-    async establishControllerConnection() {
-        const pendingSockets = new Set();
-        const connection = await new Promise((resolve) => {
-            var _a;
-            util_1.util.setInterval((cancelInterval) => {
-                const socket = new Net.Socket();
-                pendingSockets.add(socket);
-                socket.on('error', (error) => {
-                    console.debug(Date.now(), 'Encountered an error connecting to the debug protocol socket. Ignoring and will try again soon', error);
-                });
-                socket.connect({ port: this.options.controllerPort, host: this.options.host }, () => {
-                    cancelInterval();
-                    this.logger.debug(`Connected to debug protocol controller port. Socket ${[...pendingSockets].indexOf(socket)} of ${pendingSockets.size} was the winner`);
-                    //clean up all remaining pending sockets
-                    for (const pendingSocket of pendingSockets) {
-                        pendingSocket.removeAllListeners();
-                        //cleanup and destroy all other sockets
-                        if (pendingSocket !== socket) {
-                            pendingSocket.end();
-                            pendingSocket === null || pendingSocket === void 0 ? void 0 : pendingSocket.destroy();
-                        }
-                    }
-                    pendingSockets.clear();
-                    resolve(socket);
-                });
-            }, (_a = this.options.controllerConnectInterval) !== null && _a !== void 0 ? _a : 250);
-        });
-        return connection;
-    }
-    async connect() {
-        this.logger.log('connect', this.options);
-        // If there is no error, the server has accepted the request and created a new dedicated control socket
-        this.controllerClient = await this.establishControllerConnection();
-        this.controllerClient.on('data', (buffer) => {
-            var _a, _b;
-            this.writeToBufferLog('server-to-client', buffer);
-            if (this.unhandledData) {
-                this.unhandledData = Buffer.concat([this.unhandledData, buffer]);
-            }
-            else {
-                this.unhandledData = buffer;
-            }
-            this.logger.debug(`on('data'): incoming bytes`, buffer.length, buffer.toJSON());
-            const startBufferSize = this.unhandledData.length;
-            this.parseUnhandledData(this.unhandledData);
-            const endBufferSize = (_b = (_a = this.unhandledData) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
-            this.logger.debug(`buffer size before:`, startBufferSize, ', buffer size after:', endBufferSize, ', bytes consumed:', startBufferSize - endBufferSize);
-        });
-        this.controllerClient.on('end', () => {
-            this.logger.log('TCP connection closed');
-            this.shutdown('app-exit');
-        });
-        // Don't forget to catch error, for your own sake.
-        this.controllerClient.once('error', (error) => {
-            //the Roku closed the connection for some unknown reason...
-            console.error(`TCP connection error on control port`, error);
-            this.shutdown('close');
-        });
-        //send the magic, which triggers the debug session
-        this.sendMagic();
-        //wait for the handshake response from the device
-        const isConnected = await this.once('connected');
-        return isConnected;
-    }
-    sendMagic() {
-        let buffer = new smart_buffer_1.SmartBuffer({ size: Buffer.byteLength(Debugger.DEBUGGER_MAGIC) + 1 }).writeStringNT(Debugger.DEBUGGER_MAGIC).toBuffer();
-        this.logger.log('Sending magic to server');
-        this.writeToBufferLog('client-to-server', buffer);
-        this.controllerClient.write(buffer);
-    }
-    /**
-     * Write a specific buffer log entry to the logger, which, when file logging is enabled
-     * can be extracted and processed through the DebugProtocolClientReplaySession
-     */
-    writeToBufferLog(type, buffer) {
-        this.logger.log('[[bufferLog]]:', JSON.stringify({
-            type: type,
-            timestamp: new Date().toISOString(),
-            buffer: buffer.toJSON()
-        }));
-    }
-    async continue() {
-        if (this.stopped) {
-            this.stopped = false;
-            return this.makeRequest(new smart_buffer_1.SmartBuffer({ size: 12 }), Constants_1.COMMANDS.CONTINUE);
-        }
-    }
-    async pause(force = false) {
-        if (!this.stopped || force) {
-            return this.makeRequest(new smart_buffer_1.SmartBuffer({ size: 12 }), Constants_1.COMMANDS.STOP);
-        }
-    }
-    async exitChannel() {
-        return this.makeRequest(new smart_buffer_1.SmartBuffer({ size: 12 }), Constants_1.COMMANDS.EXIT_CHANNEL);
-    }
-    async stepIn(threadId = this.primaryThread) {
-        return this.step(Constants_1.STEP_TYPE.STEP_TYPE_LINE, threadId);
-    }
-    async stepOver(threadId = this.primaryThread) {
-        return this.step(Constants_1.STEP_TYPE.STEP_TYPE_OVER, threadId);
-    }
-    async stepOut(threadId = this.primaryThread) {
-        return this.step(Constants_1.STEP_TYPE.STEP_TYPE_OUT, threadId);
-    }
-    async step(stepType, threadId) {
-        this.logger.log('[step]', { stepType: Constants_1.STEP_TYPE[stepType], threadId, stopped: this.stopped });
-        let buffer = new smart_buffer_1.SmartBuffer({ size: 17 });
-        buffer.writeUInt32LE(threadId); // thread_index
-        buffer.writeUInt8(stepType); // step_type
-        if (this.stopped) {
-            this.stopped = false;
-            let stepResult = await this.makeRequest(buffer, Constants_1.COMMANDS.STEP);
-            if (stepResult.errorCode === Constants_1.ERROR_CODES.OK) {
-                // this.stopped = true;
-                // this.emit('suspend');
-            }
-            else {
-                // there is a CANT_CONTINUE error code but we can likely treat all errors like a CANT_CONTINUE
-                this.emit('cannot-continue');
-            }
-            return stepResult;
-        }
-    }
-    async threads() {
-        if (this.stopped) {
-            let result = await this.makeRequest(new smart_buffer_1.SmartBuffer({ size: 12 }), Constants_1.COMMANDS.THREADS);
-            if (result.errorCode === Constants_1.ERROR_CODES.OK) {
-                //older versions of the debug protocol had issues with maintaining the active thread, so our workaround is to keep track of it elsewhere
-                if (this.enableThreadHoppingWorkaround) {
-                    //ignore the `isPrimary` flag on threads
-                    this.logger.debug(`Ignoring the 'isPrimary' flag from threads because protocol version ${this.protocolVersion} and lower has a bug`);
-                }
-                else {
-                    //trust the debug protocol's `isPrimary` flag on threads
-                    for (let i = 0; i < result.threadsCount; i++) {
-                        let thread = result.threads[i];
-                        if (thread.isPrimary) {
-                            this.primaryThread = i;
-                            break;
-                        }
-                    }
-                }
-            }
-            return result;
-        }
-    }
-    async stackTrace(threadIndex = this.primaryThread) {
-        let buffer = new smart_buffer_1.SmartBuffer({ size: 16 });
-        buffer.writeUInt32LE(threadIndex); // thread_index
-        if (this.stopped && threadIndex > -1) {
-            return this.makeRequest(buffer, Constants_1.COMMANDS.STACKTRACE);
-        }
-    }
-    /**
-     * @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
-     */
-    async getVariables(variablePathEntries = [], getChildKeys = true, stackFrameIndex = this.stackFrameIndex, threadIndex = this.primaryThread) {
-        if (this.stopped && threadIndex > -1) {
-            //starting in protocol v3.1.0, it supports marking certain path items as case-insensitive (i.e. parts of DottedGet expressions)
-            const sendCaseInsensitiveData = semver.satisfies(this.protocolVersion, '>=3.1.0') && variablePathEntries.length > 0;
-            let buffer = new smart_buffer_1.SmartBuffer({ size: 17 });
-            let flags = 0;
-            if (getChildKeys) {
-                // eslint-disable-next-line no-bitwise
-                flags |= Constants_1.VARIABLE_REQUEST_FLAGS.GET_CHILD_KEYS;
-            }
-            if (sendCaseInsensitiveData) {
-                // eslint-disable-next-line no-bitwise
-                flags |= Constants_1.VARIABLE_REQUEST_FLAGS.CASE_SENSITIVITY_OPTIONS;
-            }
-            buffer.writeUInt8(flags); // variable_request_flags
-            buffer.writeUInt32LE(threadIndex); // thread_index
-            buffer.writeUInt32LE(stackFrameIndex); // stack_frame_index
-            buffer.writeUInt32LE(variablePathEntries.length); // variable_path_len
-            variablePathEntries.forEach(entry => {
-                if (entry.startsWith('"') && entry.endsWith('"')) {
-                    //remove leading and trailing quotes
-                    entry = entry.substring(1, entry.length - 1);
-                }
-                buffer.writeStringNT(entry); // variable_path_entries - optional
-            });
-            if (sendCaseInsensitiveData) {
-                variablePathEntries.forEach(entry => {
-                    buffer.writeUInt8(
-                    //0 means case SENSITIVE lookup, 1 means case INsensitive lookup
-                    entry.startsWith('"') ? 0 : 1);
-                });
-            }
-            return this.makeRequest(buffer, Constants_1.COMMANDS.VARIABLES, variablePathEntries);
-        }
-    }
-    async executeCommand(sourceCode, stackFrameIndex = this.stackFrameIndex, threadIndex = this.primaryThread) {
-        if (this.stopped && threadIndex > -1) {
-            console.log(sourceCode);
-            let buffer = new smart_buffer_1.SmartBuffer({ size: 8 });
-            buffer.writeUInt32LE(threadIndex); // thread_index
-            buffer.writeUInt32LE(stackFrameIndex); // stack_frame_index
-            buffer.writeStringNT(sourceCode); // source_code
-            return this.makeRequest(buffer, Constants_1.COMMANDS.EXECUTE, sourceCode);
-        }
-    }
-    async addBreakpoints(breakpoints) {
-        var _a, _b;
-        const { enableComponentLibrarySpecificBreakpoints } = this;
-        if ((breakpoints === null || breakpoints === void 0 ? void 0 : breakpoints.length) > 0) {
-            const useConditionalBreakpoints = (
-            //does this protocol version support conditional breakpoints?
-            this.supportsConditionalBreakpoints &&
-                //is there at least one conditional breakpoint present?
-                !!breakpoints.find(x => { var _a; return !!((_a = x === null || x === void 0 ? void 0 : x.conditionalExpression) === null || _a === void 0 ? void 0 : _a.trim()); }));
-            let buffer = new smart_buffer_1.SmartBuffer();
-            //set the `FLAGS` value if supported
-            if (useConditionalBreakpoints) {
-                buffer.writeUInt32LE(0); // flags - Should always be passed as 0. Unused, reserved for future use.
-            }
-            buffer.writeUInt32LE(breakpoints.length); // num_breakpoints - The number of breakpoints in the breakpoints array.
-            for (const breakpoint of breakpoints) {
-                let { filePath } = breakpoint;
-                //protocol >= v3.1.0 requires complib breakpoints have a special prefix
-                if (enableComponentLibrarySpecificBreakpoints) {
-                    if (breakpoint.componentLibraryName) {
-                        filePath = filePath.replace(/^pkg:\//i, `lib:/${breakpoint.componentLibraryName}/`);
-                    }
-                }
-                buffer.writeStringNT(filePath); // file_path - The path of the source file where the breakpoint is to be inserted.
-                buffer.writeUInt32LE(breakpoint.lineNumber); // line_number - The line number in the channel application code where the breakpoint is to be executed.
-                buffer.writeUInt32LE((_a = breakpoint.hitCount) !== null && _a !== void 0 ? _a : 0); // ignore_count - 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.
-                //if the protocol supports conditional breakpoints, add any present condition
-                if (useConditionalBreakpoints) {
-                    //There's a bug in 3.1 where empty conditional expressions would crash the breakpoints, so just default to `true` which always succeeds
-                    buffer.writeStringNT((_b = breakpoint.conditionalExpression) !== null && _b !== void 0 ? _b : 'true'); // cond_expr - the condition that must evaluate to `true` in order to hit the breakpoint
-                }
-            }
-            const response = await this.makeRequest(buffer, useConditionalBreakpoints ? Constants_1.COMMANDS.ADD_CONDITIONAL_BREAKPOINTS : Constants_1.COMMANDS.ADD_BREAKPOINTS);
-            //if the device does not support breakpoint verification, then auto-mark all of these as verified
-            if (!this.supportsBreakpointVerification) {
-                this.emit('breakpoints-verified', response);
-            }
-            return response;
-        }
-        const response = new AddBreakpointsResponse_1.AddBreakpointsResponse(null);
-        response.success = true;
-        response.errorCode = Constants_1.ERROR_CODES.OK;
-        return response;
-    }
-    async listBreakpoints() {
-        return this.makeRequest(new smart_buffer_1.SmartBuffer({ size: 12 }), Constants_1.COMMANDS.LIST_BREAKPOINTS);
-    }
-    async removeBreakpoints(breakpointIds) {
-        if ((breakpointIds === null || breakpointIds === void 0 ? void 0 : breakpointIds.length) > 0) {
-            let buffer = new smart_buffer_1.SmartBuffer();
-            buffer.writeUInt32LE(breakpointIds.length); // num_breakpoints - The number of breakpoints in the breakpoints array.
-            breakpointIds.forEach((breakpointId) => {
-                buffer.writeUInt32LE(breakpointId); // breakpoint_ids - An array of breakpoint IDs representing the breakpoints to be removed.
-            });
-            return this.makeRequest(buffer, Constants_1.COMMANDS.REMOVE_BREAKPOINTS);
-        }
-        return new RemoveBreakpointsResponse_1.RemoveBreakpointsResponse(null);
-    }
-    async makeRequest(buffer, command, extraData) {
-        this.totalRequests++;
-        let requestId = this.totalRequests;
-        buffer.insertUInt32LE(command, 0); // command_code - An enum representing the debugging command being sent. See the COMMANDS enum
-        buffer.insertUInt32LE(requestId, 0); // request_id - The ID of the debugger request (must be >=1). This ID is included in the debugger response.
-        buffer.insertUInt32LE(buffer.writeOffset + 4, 0); // packet_length - The size of the packet to be sent.
-        this.activeRequests[requestId] = {
-            commandType: command,
-            commandTypeText: Constants_1.COMMANDS[command],
-            extraData: extraData
-        };
-        return new Promise((resolve, reject) => {
-            let unsubscribe = this.on('data', (data) => {
-                if (data.requestId === requestId) {
-                    unsubscribe();
-                    resolve(data);
-                }
-            });
-            this.logger.debug('makeRequest', `requestId=${requestId}`, this.activeRequests[requestId]);
-            if (this.controllerClient) {
-                const buff = buffer.toBuffer();
-                this.writeToBufferLog('client-to-server', buff);
-                this.controllerClient.write(buff);
-            }
-            else {
-                throw new Error(`Controller connection was closed - Command: ${Constants_1.COMMANDS[command]}`);
-            }
-        });
-    }
-    parseUnhandledData(buffer) {
-        if (buffer.length < 1) {
-            // short circuit if the buffer is empty
-            return false;
-        }
-        if (this.handshakeComplete) {
-            let debuggerRequestResponse = this.watchPacketLength ? new responses_1.ProtocolEventV3(buffer) : new responses_1.ProtocolEvent(buffer);
-            let packetLength = debuggerRequestResponse.packetLength;
-            let slicedBuffer = packetLength ? buffer.slice(4) : buffer;
-            this.logger.log(`incoming bytes: ${buffer.length}`, debuggerRequestResponse, slicedBuffer.toJSON());
-            if (debuggerRequestResponse.success) {
-                if (debuggerRequestResponse.requestId > this.totalRequests) {
-                    this.removedProcessedBytes(debuggerRequestResponse, slicedBuffer, packetLength);
-                    return true;
-                }
-                if (debuggerRequestResponse.errorCode !== Constants_1.ERROR_CODES.OK) {
-                    this.logger.error(debuggerRequestResponse.errorCode, debuggerRequestResponse);
-                    this.removedProcessedBytes(debuggerRequestResponse, buffer, packetLength);
-                    return true;
-                }
-                if (debuggerRequestResponse.updateType > 0) {
-                    this.logger.log('Update Type:', Constants_1.UPDATE_TYPES[debuggerRequestResponse.updateType]);
-                    switch (debuggerRequestResponse.updateType) {
-                        case Constants_1.UPDATE_TYPES.IO_PORT_OPENED:
-                            return this.connectToIoPort(new responses_1.ConnectIOPortResponse(slicedBuffer), buffer, packetLength);
-                        case Constants_1.UPDATE_TYPES.ALL_THREADS_STOPPED:
-                        case Constants_1.UPDATE_TYPES.THREAD_ATTACHED:
-                            let debuggerUpdateThreads = new responses_1.UpdateThreadsResponse(slicedBuffer);
-                            this.logger.log(debuggerUpdateThreads);
-                            if (debuggerUpdateThreads.success) {
-                                this.handleThreadsUpdate(debuggerUpdateThreads);
-                                this.removedProcessedBytes(debuggerUpdateThreads, slicedBuffer, packetLength);
-                                return true;
-                            }
-                            return false;
-                        case Constants_1.UPDATE_TYPES.UNDEF:
-                            return this.checkResponse(new responses_1.UndefinedResponse(slicedBuffer), buffer, packetLength);
-                        case Constants_1.UPDATE_TYPES.BREAKPOINT_ERROR:
-                            const response = new BreakpointErrorUpdateResponse_1.BreakpointErrorUpdateResponse(slicedBuffer);
-                            //we do nothing with breakpoint errors at this time.
-                            return this.checkResponse(response, buffer, packetLength);
-                        case Constants_1.UPDATE_TYPES.COMPILE_ERROR:
-                            return this.checkResponse(new responses_1.UndefinedResponse(slicedBuffer), buffer, packetLength);
-                        case Constants_1.UPDATE_TYPES.BREAKPOINT_VERIFIED:
-                            const bpVerifiedResponse = new BreakpointVerifiedUpdateResponse_1.BreakpointVerifiedUpdateResponse(slicedBuffer);
-                            console.log('breakpoints verified', bpVerifiedResponse.breakpoints.map(x => x.breakpointId));
-                            if (this.checkResponse(bpVerifiedResponse, buffer, packetLength)) {
-                                this.emit('breakpoints-verified', {
-                                    breakpoints: bpVerifiedResponse.breakpoints
-                                });
-                                return true;
-                            }
-                            else {
-                                return false;
-                            }
-                        default:
-                            return this.checkResponse(new responses_1.UndefinedResponse(slicedBuffer), buffer, packetLength);
-                    }
-                }
-                else {
-                    this.logger.log('Command Type:', Constants_1.COMMANDS[this.activeRequests[debuggerRequestResponse.requestId].commandType]);
-                    switch (this.activeRequests[debuggerRequestResponse.requestId].commandType) {
-                        case Constants_1.COMMANDS.STOP:
-                        case Constants_1.COMMANDS.CONTINUE:
-                        case Constants_1.COMMANDS.STEP:
-                        case Constants_1.COMMANDS.EXIT_CHANNEL:
-                            this.removedProcessedBytes(debuggerRequestResponse, buffer, packetLength);
-                            return true;
-                        case Constants_1.COMMANDS.EXECUTE:
-                            return this.checkResponse(new ExecuteResponseV3_1.ExecuteResponseV3(slicedBuffer), buffer, packetLength);
-                        case Constants_1.COMMANDS.ADD_BREAKPOINTS:
-                        case Constants_1.COMMANDS.ADD_CONDITIONAL_BREAKPOINTS:
-                            return this.checkResponse(new AddBreakpointsResponse_1.AddBreakpointsResponse(slicedBuffer), buffer, packetLength);
-                        case Constants_1.COMMANDS.LIST_BREAKPOINTS:
-                            return this.checkResponse(new ListBreakpointsResponse_1.ListBreakpointsResponse(slicedBuffer), buffer, packetLength);
-                        case Constants_1.COMMANDS.REMOVE_BREAKPOINTS:
-                            return this.checkResponse(new RemoveBreakpointsResponse_1.RemoveBreakpointsResponse(slicedBuffer), buffer, packetLength);
-                        case Constants_1.COMMANDS.VARIABLES:
-                            return this.checkResponse(new responses_1.VariableResponse(slicedBuffer), buffer, packetLength);
-                        case Constants_1.COMMANDS.STACKTRACE:
-                            return this.checkResponse(packetLength ? new responses_1.StackTraceResponseV3(slicedBuffer) : new responses_1.StackTraceResponse(slicedBuffer), buffer, packetLength);
-                        case Constants_1.COMMANDS.THREADS:
-                            return this.checkResponse(new responses_1.ThreadsResponse(slicedBuffer), buffer, packetLength);
-                        default:
-                            return this.checkResponse(debuggerRequestResponse, buffer, packetLength);
-                    }
-                }
-            }
-        }
-        else {
-            let debuggerHandshake;
-            debuggerHandshake = new responses_1.HandshakeResponseV3(buffer);
-            this.logger.log(`incoming bytes: ${buffer.length}`, debuggerHandshake);
-            if (!debuggerHandshake.success) {
-                debuggerHandshake = new responses_1.HandshakeResponse(buffer);
-            }
-            if (debuggerHandshake.success) {
-                this.handshakeComplete = true;
-                this.verifyHandshake(debuggerHandshake);
-                this.removedProcessedBytes(debuggerHandshake, buffer);
-                //once the handshake is complete, we have successfully "connected"
-                this.emit('connected', true);
-                return true;
-            }
-        }
-        return false;
-    }
-    checkResponse(responseClass, unhandledData, packetLength = 0) {
-        if (responseClass.success) {
-            this.removedProcessedBytes(responseClass, unhandledData, packetLength);
-            return true;
-        }
-        else if (packetLength > 0 && unhandledData.length >= packetLength) {
-            this.removedProcessedBytes(responseClass, unhandledData, packetLength);
-        }
-        return false;
-    }
-    removedProcessedBytes(responseHandler, unhandledData, packetLength = 0) {
-        var _a, _b, _c;
-        const activeRequest = this.activeRequests[responseHandler.requestId];
-        if (responseHandler.requestId > 0 && this.activeRequests[responseHandler.requestId]) {
-            delete this.activeRequests[responseHandler.requestId];
-        }
-        this.emit('data', responseHandler);
-        this.unhandledData = unhandledData.slice(packetLength ? packetLength : responseHandler.readOffset);
-        this.logger.debug('[raw]', `requestId=${responseHandler === null || responseHandler === void 0 ? void 0 : responseHandler.requestId}`, activeRequest, (_c = (_b = (_a = responseHandler) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : '', responseHandler);
-        this.parseUnhandledData(this.unhandledData);
-    }
-    verifyHandshake(debuggerHandshake) {
-        const magicIsValid = (Debugger.DEBUGGER_MAGIC === debuggerHandshake.magic);
-        if (magicIsValid) {
-            this.logger.log('Magic is valid.');
-            this.protocolVersion = [debuggerHandshake.majorVersion, debuggerHandshake.minorVersion, debuggerHandshake.patchVersion].join('.');
-            this.logger.log('Protocol Version:', this.protocolVersion);
-            this.watchPacketLength = debuggerHandshake.watchPacketLength;
-            let handshakeVerified = true;
-            if (semver.satisfies(this.protocolVersion, this.supportedVersionRange)) {
-                this.logger.log('supported');
-                this.emit('protocol-version', {
-                    message: `Protocol Version ${this.protocolVersion} is supported!`,
-                    errorCode: Constants_1.PROTOCOL_ERROR_CODES.SUPPORTED
-                });
-            }
-            else if (semver.gtr(this.protocolVersion, this.supportedVersionRange)) {
-                this.logger.log('roku-debug has not been tested against protocol version', this.protocolVersion);
-                this.emit('protocol-version', {
-                    message: `Protocol Version ${this.protocolVersion} has not been tested and my not work as intended.\nPlease open any issues you have with this version to https://github.com/rokucommunity/roku-debug/issues`,
-                    errorCode: Constants_1.PROTOCOL_ERROR_CODES.NOT_TESTED
-                });
-            }
-            else {
-                this.logger.log('not supported');
-                this.emit('protocol-version', {
-                    message: `Protocol Version ${this.protocolVersion} is not supported.\nIf you believe this is an error please open an issue at https://github.com/rokucommunity/roku-debug/issues`,
-                    errorCode: Constants_1.PROTOCOL_ERROR_CODES.NOT_SUPPORTED
-                });
-                this.shutdown('close');
-                handshakeVerified = false;
-            }
-            this.emit('handshake-verified', handshakeVerified);
-            return handshakeVerified;
-        }
-        else {
-            this.logger.log('Closing connection due to bad debugger magic', debuggerHandshake.magic);
-            this.emit('handshake-verified', false);
-            this.shutdown('close');
-            return false;
-        }
-    }
-    connectToIoPort(connectIoPortResponse, unhandledData, packetLength = 0) {
-        this.logger.log('Connecting to IO port. response status success =', connectIoPortResponse.success);
-        if (connectIoPortResponse.success) {
-            // Create a new TCP client.
-            this.ioClient = new Net.Socket();
-            // Send a connection request to the server.
-            this.logger.log('Connect to IO Port: port', connectIoPortResponse.data, 'host', this.options.host);
-            this.ioClient.connect({ port: connectIoPortResponse.data, host: this.options.host }, () => {
-                // If there is no error, the server has accepted the request
-                this.logger.log('TCP connection established with the IO Port.');
-                this.connectedToIoPort = true;
-                let lastPartialLine = '';
-                this.ioClient.on('data', (buffer) => {
-                    this.writeToBufferLog('io', buffer);
-                    let responseText = buffer.toString();
-                    if (!responseText.endsWith('\n')) {
-                        // buffer was split, save the partial line
-                        lastPartialLine += responseText;
-                    }
-                    else {
-                        if (lastPartialLine) {
-                            // there was leftover lines, join the partial lines back together
-                            responseText = lastPartialLine + responseText;
-                            lastPartialLine = '';
-                        }
-                        // Emit the completed io string.
-                        this.emit('io-output', responseText.trim());
-                    }
-                });
-                this.ioClient.on('end', () => {
-                    this.ioClient.end();
-                    this.logger.log('Requested an end to the IO connection');
-                });
-                // Don't forget to catch error, for your own sake.
-                this.ioClient.once('error', (err) => {
-                    this.ioClient.end();
-                    this.logger.error(err);
-                });
-            });
-            this.removedProcessedBytes(connectIoPortResponse, unhandledData, packetLength);
-            return true;
-        }
-        return false;
-    }
-    handleThreadsUpdate(update) {
-        this.stopped = true;
-        let stopReason = update.data.stopReason;
-        let eventName = stopReason === Constants_1.STOP_REASONS.RUNTIME_ERROR ? 'runtime-error' : 'suspend';
-        if (update.updateType === Constants_1.UPDATE_TYPES.ALL_THREADS_STOPPED) {
-            if (stopReason === Constants_1.STOP_REASONS.RUNTIME_ERROR || stopReason === Constants_1.STOP_REASONS.BREAK || stopReason === Constants_1.STOP_REASONS.STOP_STATEMENT) {
-                this.primaryThread = update.data.primaryThreadIndex;
-                this.stackFrameIndex = 0;
-                this.emit(eventName, update);
-            }
-        }
-        else if (stopReason === Constants_1.STOP_REASONS.RUNTIME_ERROR || stopReason === Constants_1.STOP_REASONS.BREAK || stopReason === Constants_1.STOP_REASONS.STOP_STATEMENT) {
-            this.primaryThread = update.data.threadIndex;
-            this.emit(eventName, update);
-        }
-    }
-    destroy() {
-        this.shutdown('close');
-    }
-    shutdown(eventName) {
-        if (this.controllerClient) {
-            this.controllerClient.removeAllListeners();
-            this.controllerClient.destroy();
-            this.controllerClient = undefined;
-        }
-        if (this.ioClient) {
-            this.ioClient.removeAllListeners();
-            this.ioClient.destroy();
-            this.ioClient = undefined;
-        }
-        this.emit(eventName);
-    }
-}
-exports.Debugger = Debugger;
-Debugger.DEBUGGER_MAGIC = 'bsdebug'; // 64-bit = [b'bsdebug\0' little-endian]
-//# sourceMappingURL=Debugger.js.map