roku-debug 0.20.5 → 0.20.7

package/dist/debugProtocol/client/DebugProtocolClient.js

@@ -0,0 +1,1079 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProtocolUpdate = exports.isProtocolResponse = exports.isProtocolRequest = exports.DebugProtocolClient = void 0;
+const Net = require("net");
+const debounce = require("debounce");
+const EventEmitter = require("eventemitter3");
+const semver = require("semver");
+const Constants_1 = require("../Constants");
+const logging_1 = require("../../logging");
+const ExecuteV3Response_1 = require("../events/responses/ExecuteV3Response");
+const ListBreakpointsResponse_1 = require("../events/responses/ListBreakpointsResponse");
+const AddBreakpointsResponse_1 = require("../events/responses/AddBreakpointsResponse");
+const RemoveBreakpointsResponse_1 = require("../events/responses/RemoveBreakpointsResponse");
+const util_1 = require("../../util");
+const BreakpointErrorUpdate_1 = require("../events/updates/BreakpointErrorUpdate");
+const ContinueRequest_1 = require("../events/requests/ContinueRequest");
+const StopRequest_1 = require("../events/requests/StopRequest");
+const ExitChannelRequest_1 = require("../events/requests/ExitChannelRequest");
+const StepRequest_1 = require("../events/requests/StepRequest");
+const RemoveBreakpointsRequest_1 = require("../events/requests/RemoveBreakpointsRequest");
+const ListBreakpointsRequest_1 = require("../events/requests/ListBreakpointsRequest");
+const VariablesRequest_1 = require("../events/requests/VariablesRequest");
+const StackTraceRequest_1 = require("../events/requests/StackTraceRequest");
+const ThreadsRequest_1 = require("../events/requests/ThreadsRequest");
+const ExecuteRequest_1 = require("../events/requests/ExecuteRequest");
+const AddBreakpointsRequest_1 = require("../events/requests/AddBreakpointsRequest");
+const AddConditionalBreakpointsRequest_1 = require("../events/requests/AddConditionalBreakpointsRequest");
+const HandshakeResponse_1 = require("../events/responses/HandshakeResponse");
+const HandshakeV3Response_1 = require("../events/responses/HandshakeV3Response");
+const HandshakeRequest_1 = require("../events/requests/HandshakeRequest");
+const GenericV3Response_1 = require("../events/responses/GenericV3Response");
+const AllThreadsStoppedUpdate_1 = require("../events/updates/AllThreadsStoppedUpdate");
+const CompileErrorUpdate_1 = require("../events/updates/CompileErrorUpdate");
+const GenericResponse_1 = require("../events/responses/GenericResponse");
+const ThreadsResponse_1 = require("../events/responses/ThreadsResponse");
+const VariablesResponse_1 = require("../events/responses/VariablesResponse");
+const IOPortOpenedUpdate_1 = require("../events/updates/IOPortOpenedUpdate");
+const ThreadAttachedUpdate_1 = require("../events/updates/ThreadAttachedUpdate");
+const StackTraceV3Response_1 = require("../events/responses/StackTraceV3Response");
+const ActionQueue_1 = require("../../managers/ActionQueue");
+const PluginInterface_1 = require("../PluginInterface");
+const BreakpointVerifiedUpdate_1 = require("../events/updates/BreakpointVerifiedUpdate");
+class DebugProtocolClient {
+    constructor(options) {
+        this.logger = logging_1.logger.createLogger(`[client]`);
+        // The highest tested version of the protocol we support.
+        this.supportedVersionRange = '<=3.0.0';
+        this.isHandshakeComplete = false;
+        this.connectedToIoPort = false;
+        /**
+         * 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
+         */
+        this.watchPacketLength = false;
+        /**
+         * A collection of plugins that can interact with the client at lifecycle points
+         */
+        this.plugins = new PluginInterface_1.default();
+        this.emitter = new EventEmitter();
+        /**
+         * Promise that is resolved when the control socket is closed
+         */
+        this.controlSocketClosed = (0, util_1.defer)();
+        /**
+         * Resolves when the ioSocket has closed
+         */
+        this.ioSocketClosed = (0, util_1.defer)();
+        /**
+         * The buffer where all unhandled data will be stored until successfully consumed
+         */
+        this.buffer = Buffer.alloc(0);
+        /**
+         * Is the debugger currently stopped at a line of code in the program
+         */
+        this.isStopped = false;
+        this.requestIdSequence = 1;
+        this.activeRequests = new Map();
+        /**
+         * A queue for processing the incoming buffer, every transmission at a time
+         */
+        this.bufferQueue = new ActionQueue_1.ActionQueue();
+        /**
+         * A counter to help give a unique id to each update (mostly just for logging purposes)
+         */
+        this.updateSequence = 1;
+        this.handleUpdateQueue = new ActionQueue_1.ActionQueue();
+        this.isDestroyingControlSocket = false;
+        this.isDestroyingIOSocket = false;
+        this.options = {
+            controlPort: 8081,
+            host: undefined,
+            //override the defaults with the options from parameters
+            ...options !== null && options !== void 0 ? options : {}
+        };
+        //add the internal plugin last, so it's the final plugin to handle the events
+        this.addCorePlugin();
+    }
+    addCorePlugin() {
+        this.plugins.add({
+            onUpdate: (event) => {
+                return this.handleUpdate(event.update);
+            }
+        }, 999);
+    }
+    /**
+     * 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 () => {
+            this.emitter.removeListener(eventName, handler);
+        };
+    }
+    emit(eventName, data) {
+        //emit these events on next tick, otherwise they will be processed immediately which could cause issues
+        setTimeout(() => {
+            //in rare cases, this event is fired after the debugger has closed, so make sure the event emitter still exists
+            this.emitter.emit(eventName, data);
+        }, 0);
+    }
+    async establishControlConnection() {
+        this.pendingControlConnectionSockets = new Set();
+        const connection = await new Promise((resolve) => {
+            var _a;
+            this.cancelControlConnectInterval = util_1.util.setInterval((cancelInterval) => {
+                const socket = new Net.Socket({
+                    allowHalfOpen: false
+                });
+                this.pendingControlConnectionSockets.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.controlPort, host: this.options.host }, () => {
+                    cancelInterval();
+                    this.logger.debug(`Connected to debug protocol control port. Socket ${[...this.pendingControlConnectionSockets].indexOf(socket)} of ${this.pendingControlConnectionSockets.size} was the winner`);
+                    //clean up all remaining pending sockets
+                    for (const pendingSocket of this.pendingControlConnectionSockets) {
+                        pendingSocket.removeAllListeners();
+                        //cleanup and destroy all other sockets
+                        if (pendingSocket !== socket) {
+                            pendingSocket.end();
+                            pendingSocket === null || pendingSocket === void 0 ? void 0 : pendingSocket.destroy();
+                        }
+                    }
+                    this.pendingControlConnectionSockets.clear();
+                    resolve(socket);
+                });
+            }, (_a = this.options.controlConnectInterval) !== null && _a !== void 0 ? _a : 250);
+        });
+        await this.plugins.emit('onServerConnected', {
+            client: this,
+            server: connection
+        });
+        return connection;
+    }
+    /**
+     * 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
+     */
+    async connect(sendHandshake = true) {
+        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.controlSocket = await this.establishControlConnection();
+        this.controlSocket.on('data', (data) => {
+            this.writeToBufferLog('server-to-client', data);
+            this.emit('data', data);
+            //queue up processing the new data, chunk by chunk
+            void this.bufferQueue.run(async () => {
+                this.buffer = Buffer.concat([this.buffer, data]);
+                while (this.buffer.length > 0 && await this.process()) {
+                    //the loop condition is the actual work
+                }
+                return true;
+            });
+        });
+        this.controlSocket.on('close', () => {
+            this.logger.log('Control socket closed');
+            this.controlSocketClosed.tryResolve();
+            void this.shutdown('app-exit');
+        });
+        // Don't forget to catch error, for your own sake.
+        this.controlSocket.once('error', (error) => {
+            var _a, _b;
+            //the Roku closed the connection for some unknown reason...
+            this.logger.error(`error on control port`, error);
+            (_b = (_a = this.controlSocket) === null || _a === void 0 ? void 0 : _a.destroy) === null || _b === void 0 ? void 0 : _b.call(_a);
+            void this.shutdown('close');
+        });
+        if (sendHandshake) {
+            await this.sendHandshake();
+        }
+        return true;
+    }
+    /**
+     * Send the initial handshake request, and wait for the handshake response
+     */
+    async sendHandshake() {
+        return this.processHandshakeRequest(HandshakeRequest_1.HandshakeRequest.fromJson({
+            magic: DebugProtocolClient.DEBUGGER_MAGIC
+        }));
+    }
+    async processHandshakeRequest(request) {
+        //send the magic, which triggers the debug session
+        this.logger.log('Sending magic to server');
+        //send the handshake request, and wait for the handshake response from the device
+        return this.sendRequest(request);
+    }
+    /**
+     * 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) {
+        let obj = {
+            type: type,
+            timestamp: new Date().toISOString(),
+            buffer: buffer.toJSON()
+        };
+        if (type === 'io') {
+            obj.text = buffer.toString();
+        }
+        this.logger.log('[[bufferLog]]:', JSON.stringify(obj));
+    }
+    continue() {
+        return this.processContinueRequest(ContinueRequest_1.ContinueRequest.fromJson({
+            requestId: this.requestIdSequence++
+        }));
+    }
+    async processContinueRequest(request) {
+        if (this.isStopped) {
+            this.isStopped = false;
+            return this.sendRequest(request);
+        }
+    }
+    pause() {
+        return this.processStopRequest(StopRequest_1.StopRequest.fromJson({
+            requestId: this.requestIdSequence++
+        }));
+    }
+    async processStopRequest(request) {
+        if (this.isStopped === false) {
+            return this.sendRequest(request);
+        }
+    }
+    /**
+     * Send the "exit channel" command, which will tell the debug session to immediately quit
+     */
+    async exitChannel() {
+        return this.sendRequest(ExitChannelRequest_1.ExitChannelRequest.fromJson({
+            requestId: this.requestIdSequence++
+        }));
+    }
+    async stepIn(threadIndex = this.primaryThread) {
+        return this.step(Constants_1.StepType.Line, threadIndex);
+    }
+    async stepOver(threadIndex = this.primaryThread) {
+        return this.step(Constants_1.StepType.Over, threadIndex);
+    }
+    async stepOut(threadIndex = this.primaryThread) {
+        return this.step(Constants_1.StepType.Out, threadIndex);
+    }
+    async step(stepType, threadIndex) {
+        return this.processStepRequest(StepRequest_1.StepRequest.fromJson({
+            requestId: this.requestIdSequence++,
+            stepType: stepType,
+            threadIndex: threadIndex
+        }));
+    }
+    async processStepRequest(request) {
+        if (this.isStopped) {
+            this.isStopped = false;
+            let stepResult = await this.sendRequest(request);
+            if (stepResult.data.errorCode === Constants_1.ErrorCode.OK) {
+                this.isStopped = true;
+                //TODO this is not correct. Do we get a new threads event after a step? Perhaps that should be what triggers the event instead of us?
+                this.emit('suspend', stepResult);
+            }
+            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;
+        }
+        else {
+            this.logger.log('[processStepRequest] skipped because debugger is not paused');
+        }
+    }
+    async threads() {
+        return this.processThreadsRequest(ThreadsRequest_1.ThreadsRequest.fromJson({
+            requestId: this.requestIdSequence++
+        }));
+    }
+    async processThreadsRequest(request) {
+        if (this.isStopped) {
+            let result = await this.sendRequest(request);
+            if (result.data.errorCode === Constants_1.ErrorCode.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 3.0.0 and lower has a bug`);
+                }
+                else {
+                    //trust the debug protocol's `isPrimary` flag on threads
+                    for (let i = 0; i < result.data.threads.length; i++) {
+                        let thread = result.data.threads[i];
+                        if (thread.isPrimary) {
+                            this.primaryThread = i;
+                            break;
+                        }
+                    }
+                }
+            }
+            return result;
+        }
+        else {
+            this.logger.log('[processThreadsRequest] skipped because not stopped');
+        }
+    }
+    /**
+     * Get the stackTrace from the device IF currently stopped
+     */
+    async getStackTrace(threadIndex = this.primaryThread) {
+        return this.processStackTraceRequest(StackTraceRequest_1.StackTraceRequest.fromJson({
+            requestId: this.requestIdSequence++,
+            threadIndex: threadIndex
+        }));
+    }
+    async processStackTraceRequest(request) {
+        var _a, _b;
+        if (!this.isStopped) {
+            this.logger.log('[getStackTrace] skipped because debugger is not paused');
+        }
+        else if (((_a = request === null || request === void 0 ? void 0 : request.data) === null || _a === void 0 ? void 0 : _a.threadIndex) > -1) {
+            return this.sendRequest(request);
+        }
+        else {
+            this.logger.log(`[getStackTrace] skipped because ${(_b = request === null || request === void 0 ? void 0 : request.data) === null || _b === void 0 ? void 0 : _b.threadIndex} is not valid threadIndex`);
+        }
+    }
+    /**
+     * @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 = [], stackFrameIndex = this.stackFrameIndex, threadIndex = this.primaryThread) {
+        const response = await this.processVariablesRequest(VariablesRequest_1.VariablesRequest.fromJson({
+            requestId: this.requestIdSequence++,
+            threadIndex: threadIndex,
+            stackFrameIndex: stackFrameIndex,
+            getChildKeys: true,
+            variablePathEntries: variablePathEntries.map(x => ({
+                //remove leading and trailing quotes
+                name: x.replace(/^"/, '').replace(/"$/, ''),
+                forceCaseInsensitive: !x.startsWith('"') && !x.endsWith('"')
+            })),
+            //starting in protocol v3.1.0, it supports marking certain path items as case-insensitive (i.e. parts of DottedGet expressions)
+            enableForceCaseInsensitivity: semver.satisfies(this.protocolVersion, '>=3.1.0') && variablePathEntries.length > 0
+        }));
+        //if there was an issue, build a "fake" variables response for several known situationsm or throw nicer errors
+        if (util_1.util.hasNonNullishProperty(response === null || response === void 0 ? void 0 : response.data.errorData)) {
+            let variable = {
+                value: null,
+                isContainer: false,
+                isConst: false,
+                refCount: 0,
+                childCount: 0
+            };
+            const simulatedResponse = VariablesResponse_1.VariablesResponse.fromJson({
+                ...response.data,
+                variables: [variable]
+            });
+            let parentVarType;
+            let parentVarTypeText;
+            const loadParentVarInfo = async (index) => {
+                var _a, _b, _c, _d, _e, _f, _g;
+                //fetch the variable one level back from the bad one to get its type
+                const parentVar = await this.getVariables(variablePathEntries.slice(0, index), stackFrameIndex, threadIndex);
+                parentVarType = (_c = (_b = (_a = parentVar === null || parentVar === void 0 ? void 0 : parentVar.data) === null || _a === void 0 ? void 0 : _a.variables) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.type;
+                parentVarTypeText = parentVarType;
+                //convert `roSGNode; Node` to `roSGNode (Node)`
+                if (parentVarType === VariablesResponse_1.VariableType.SubtypedObject) {
+                    const chunks = (_g = (_f = (_e = (_d = parentVar === null || parentVar === void 0 ? void 0 : parentVar.data) === null || _d === void 0 ? void 0 : _d.variables) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.value) === null || _g === void 0 ? void 0 : _g.toString().split(';').map(x => x.trim());
+                    parentVarTypeText = `${chunks[0]} (${chunks[1]})`;
+                }
+            };
+            if (!util_1.util.isNullish(response.data.errorData.missingKeyIndex)) {
+                const { missingKeyIndex } = response.data.errorData;
+                //leftmost var is uninitialized, and we tried to read it
+                //ex: variablePathEntries = [`notThere`]
+                if (variablePathEntries.length === 1 && missingKeyIndex === 0) {
+                    variable.name = variablePathEntries[0];
+                    variable.type = VariablesResponse_1.VariableType.Uninitialized;
+                    return simulatedResponse;
+                }
+                //leftmost var was uninitialized, and tried to read a prop on it
+                //ex: variablePathEntries = ["notThere", "definitelyNotThere"]
+                if (missingKeyIndex === 0 && variablePathEntries.length > 1) {
+                    throw new Error(`Cannot read '${variablePathEntries[missingKeyIndex + 1]}' on type 'Uninitialized'`);
+                }
+                if (variablePathEntries.length > 1 && missingKeyIndex > 0) {
+                    await loadParentVarInfo(missingKeyIndex);
+                    // prop at the end of Node or AA doesn't exist. Treat like `invalid`.
+                    // ex: variablePathEntries = ['there', 'notThere']
+                    if (missingKeyIndex === variablePathEntries.length - 1 &&
+                        [VariablesResponse_1.VariableType.AssociativeArray, VariablesResponse_1.VariableType.SubtypedObject].includes(parentVarType)) {
+                        variable.name = variablePathEntries[variablePathEntries.length - 1];
+                        variable.type = VariablesResponse_1.VariableType.Invalid;
+                        variable.value = 'Invalid (not defined)';
+                        return simulatedResponse;
+                    }
+                }
+                //prop in the middle is missing, tried reading a prop on it
+                // ex: variablePathEntries = ["there", "notThere", "definitelyNotThere"]
+                throw new Error(`Cannot read '${variablePathEntries[missingKeyIndex]}'${parentVarType ? ` on type '${parentVarTypeText}'` : ''}`);
+            }
+            //this flow is when the item at the index exists, but is set to literally `invalid` or is an unknown value
+            if (!util_1.util.isNullish(response.data.errorData.invalidPathIndex)) {
+                const { invalidPathIndex } = response.data.errorData;
+                //leftmost var is literal `invalid`, tried to read it
+                if (variablePathEntries.length === 1 && invalidPathIndex === 0) {
+                    variable.name = variablePathEntries[variablePathEntries.length - 1];
+                    variable.type = VariablesResponse_1.VariableType.Invalid;
+                    return simulatedResponse;
+                }
+                if (variablePathEntries.length > 1 &&
+                    invalidPathIndex > 0 &&
+                    //only do this logic if the invalid item is not the last item
+                    invalidPathIndex < variablePathEntries.length - 1) {
+                    await loadParentVarInfo(invalidPathIndex + 1);
+                    //leftmost var is set to literal `invalid`, tried to read prop
+                    if (invalidPathIndex === 0 && variablePathEntries.length > 1) {
+                        throw new Error(`Cannot read '${variablePathEntries[invalidPathIndex + 1]}' on type '${parentVarTypeText}'`);
+                    }
+                    // prop at the end doesn't exist. Treat like `invalid`.
+                    // ex: variablePathEntries = ['there', 'notThere']
+                    if (invalidPathIndex === variablePathEntries.length - 1 &&
+                        [VariablesResponse_1.VariableType.AssociativeArray, VariablesResponse_1.VariableType.SubtypedObject].includes(parentVarType)) {
+                        variable.name = variablePathEntries[variablePathEntries.length - 1];
+                        variable.type = VariablesResponse_1.VariableType.Invalid;
+                        variable.value = 'Invalid (not defined)';
+                        return simulatedResponse;
+                    }
+                }
+                console.log('Bronley');
+                //prop in the middle is missing, tried reading a prop on it
+                // ex: variablePathEntries = ["there", "thereButSetToInvalid", "definitelyNotThere"]
+                throw new Error(`Cannot read '${variablePathEntries[invalidPathIndex + 1]}'${parentVarType ? ` on type '${parentVarTypeText}'` : ''}`);
+            }
+        }
+        return response;
+    }
+    async processVariablesRequest(request) {
+        if (this.isStopped && request.data.threadIndex > -1) {
+            return this.sendRequest(request);
+        }
+    }
+    async executeCommand(sourceCode, stackFrameIndex = this.stackFrameIndex, threadIndex = this.primaryThread) {
+        return this.processExecuteRequest(ExecuteRequest_1.ExecuteRequest.fromJson({
+            requestId: this.requestIdSequence++,
+            threadIndex: threadIndex,
+            stackFrameIndex: stackFrameIndex,
+            sourceCode: sourceCode
+        }));
+    }
+    async processExecuteRequest(request) {
+        if (this.isStopped && request.data.threadIndex > -1) {
+            return this.sendRequest(request);
+        }
+    }
+    async addBreakpoints(breakpoints) {
+        const { enableComponentLibrarySpecificBreakpoints } = this;
+        if ((breakpoints === null || breakpoints === void 0 ? void 0 : breakpoints.length) > 0) {
+            const json = {
+                requestId: this.requestIdSequence++,
+                breakpoints: breakpoints.map(x => {
+                    let breakpoint = {
+                        ...x,
+                        ignoreCount: x.hitCount
+                    };
+                    if (enableComponentLibrarySpecificBreakpoints && breakpoint.componentLibraryName) {
+                        breakpoint.filePath = breakpoint.filePath.replace(/^pkg:\//i, `lib:/${breakpoint.componentLibraryName}/`);
+                    }
+                    return breakpoint;
+                })
+            };
+            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 response;
+            if (useConditionalBreakpoints) {
+                response = await this.sendRequest(AddConditionalBreakpointsRequest_1.AddConditionalBreakpointsRequest.fromJson(json));
+            }
+            else {
+                response = await this.sendRequest(AddBreakpointsRequest_1.AddBreakpointsRequest.fromJson(json));
+            }
+            //if the device does not support breakpoint verification, then auto-mark all of these as verified
+            if (!this.supportsBreakpointVerification) {
+                this.emit('breakpoints-verified', {
+                    breakpoints: response.data.breakpoints
+                });
+            }
+            return response;
+        }
+        return AddBreakpointsResponse_1.AddBreakpointsResponse.fromBuffer(null);
+    }
+    async listBreakpoints() {
+        return this.processRequest(ListBreakpointsRequest_1.ListBreakpointsRequest.fromJson({
+            requestId: this.requestIdSequence++
+        }));
+    }
+    /**
+     * Remove breakpoints having the specified IDs
+     */
+    async removeBreakpoints(breakpointIds) {
+        return this.processRemoveBreakpointsRequest(RemoveBreakpointsRequest_1.RemoveBreakpointsRequest.fromJson({
+            requestId: this.requestIdSequence++,
+            breakpointIds: breakpointIds
+        }));
+    }
+    async processRemoveBreakpointsRequest(request) {
+        var _a, _b, _c;
+        //throw out null breakpoints
+        request.data.breakpointIds = (_b = (_a = request.data.breakpointIds) === null || _a === void 0 ? void 0 : _a.filter(x => typeof x === 'number')) !== null && _b !== void 0 ? _b : [];
+        if (((_c = request.data.breakpointIds) === null || _c === void 0 ? void 0 : _c.length) > 0) {
+            return this.sendRequest(request);
+        }
+        return RemoveBreakpointsResponse_1.RemoveBreakpointsResponse.fromJson(null);
+    }
+    /**
+     * 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
+     */
+    async processRequest(request) {
+        switch (request === null || request === void 0 ? void 0 : request.constructor.name) {
+            case ContinueRequest_1.ContinueRequest.name:
+                return this.processContinueRequest(request);
+            case ExecuteRequest_1.ExecuteRequest.name:
+                return this.processExecuteRequest(request);
+            case HandshakeRequest_1.HandshakeRequest.name:
+                return this.processHandshakeRequest(request);
+            case RemoveBreakpointsRequest_1.RemoveBreakpointsRequest.name:
+                return this.processRemoveBreakpointsRequest(request);
+            case StackTraceRequest_1.StackTraceRequest.name:
+                return this.processStackTraceRequest(request);
+            case StepRequest_1.StepRequest.name:
+                return this.processStepRequest(request);
+            case StopRequest_1.StopRequest.name:
+                return this.processStopRequest(request);
+            case ThreadsRequest_1.ThreadsRequest.name:
+                return this.processThreadsRequest(request);
+            case VariablesRequest_1.VariablesRequest.name:
+                return this.processVariablesRequest(request);
+            //for all other request types, there's no custom business logic, so just pipe them through manually
+            case AddBreakpointsRequest_1.AddBreakpointsRequest.name:
+            case AddConditionalBreakpointsRequest_1.AddConditionalBreakpointsRequest.name:
+            case ExitChannelRequest_1.ExitChannelRequest.name:
+            case ListBreakpointsRequest_1.ListBreakpointsRequest.name:
+                return this.sendRequest(request);
+            default:
+                this.logger.log('Unknown request type. Sending anyway...', request);
+                //unknown request type. try sending it as-is
+                return this.sendRequest(request);
+        }
+    }
+    /**
+     * Send a request to the roku device, and get a promise that resolves once we have received the response
+     */
+    async sendRequest(request) {
+        request = (await this.plugins.emit('beforeSendRequest', {
+            client: this,
+            request: request
+        })).request;
+        this.activeRequests.set(request.data.requestId, request);
+        return new Promise((resolve, reject) => {
+            let unsubscribe = this.on('response', (response) => {
+                if (response.data.requestId === request.data.requestId) {
+                    unsubscribe();
+                    this.activeRequests.delete(request.data.requestId);
+                    resolve(response);
+                }
+            });
+            this.logEvent(request);
+            if (this.controlSocket) {
+                const buffer = request.toBuffer();
+                this.writeToBufferLog('client-to-server', buffer);
+                this.controlSocket.write(buffer);
+                void this.plugins.emit('afterSendRequest', {
+                    client: this,
+                    request: request
+                });
+            }
+            else {
+                reject(new Error(`Control socket was closed - Command: ${Constants_1.Command[request.data.command]}`));
+            }
+        });
+    }
+    /**
+     * 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
+     */
+    discardNextResponseOrUpdate() {
+        const response = GenericV3Response_1.GenericV3Response.fromBuffer(this.buffer);
+        if (response.success && response.data.packetLength > 0) {
+            this.logger.warn(`Unsupported response or updated encountered. Discarding ${response.data.packetLength} bytes:`, JSON.stringify(this.buffer.slice(0, response.data.packetLength + 1).toJSON().data));
+            //we have a valid event. Clear the buffer of this data
+            this.buffer = this.buffer.slice(response.data.packetLength);
+        }
+    }
+    logEvent(event) {
+        var _a;
+        const [, eventName, eventType] = (_a = /(.+?)((?:v\d+_?\d*)?(?:request|response|update))/ig.exec(event === null || event === void 0 ? void 0 : event.constructor.name)) !== null && _a !== void 0 ? _a : [];
+        if (isProtocolRequest(event)) {
+            this.logger.log(`${eventName} ${event.data.requestId} (${eventType})`, event, `(${event === null || event === void 0 ? void 0 : event.constructor.name})`);
+        }
+        else if (isProtocolUpdate(event)) {
+            this.logger.log(`${eventName} ${this.updateSequence++} (${eventType})`, event, `(${event === null || event === void 0 ? void 0 : event.constructor.name})`);
+        }
+        else {
+            if (event.data.errorCode === Constants_1.ErrorCode.OK) {
+                this.logger.log(`${eventName} ${event.data.requestId} (${eventType})`, event, `(${event === null || event === void 0 ? void 0 : event.constructor.name})`);
+            }
+            else {
+                this.logger.log(`[error] ${eventName} ${event.data.requestId} (${eventType})`, event, `(${event === null || event === void 0 ? void 0 : event.constructor.name})`);
+            }
+        }
+    }
+    async process() {
+        var _a;
+        try {
+            this.logger.info('[process()]: buffer=', this.buffer.toJSON());
+            let { responseOrUpdate } = await this.plugins.emit('provideResponseOrUpdate', {
+                client: this,
+                activeRequests: this.activeRequests,
+                buffer: this.buffer
+            });
+            if (!responseOrUpdate) {
+                responseOrUpdate = await this.getResponseOrUpdate(this.buffer);
+            }
+            //if the event failed to parse, or the buffer doesn't have enough bytes to satisfy the packetLength, exit here (new data will re-trigger this function)
+            if (!responseOrUpdate) {
+                this.logger.info('Unable to convert buffer into anything meaningful', this.buffer);
+                //if we have packet length, and we have at least that many bytes, throw out this message so we can hopefully recover
+                this.discardNextResponseOrUpdate();
+                return false;
+            }
+            if (!responseOrUpdate.success || responseOrUpdate.data.packetLength > this.buffer.length) {
+                this.logger.log(`event parse failed. ${(_a = responseOrUpdate === null || responseOrUpdate === void 0 ? void 0 : responseOrUpdate.data) === null || _a === void 0 ? void 0 : _a.packetLength} bytes required, ${this.buffer.length} bytes available`);
+                return false;
+            }
+            //we have a valid event. Remove this data from the buffer
+            this.buffer = this.buffer.slice(responseOrUpdate.readOffset);
+            if (responseOrUpdate.data.errorCode !== Constants_1.ErrorCode.OK) {
+                this.logEvent(responseOrUpdate);
+            }
+            //we got a result
+            if (responseOrUpdate) {
+                //emit the corresponding event
+                if (isProtocolUpdate(responseOrUpdate)) {
+                    this.logEvent(responseOrUpdate);
+                    this.emit('update', responseOrUpdate);
+                    await this.plugins.emit('onUpdate', {
+                        client: this,
+                        update: responseOrUpdate
+                    });
+                }
+                else {
+                    this.logEvent(responseOrUpdate);
+                    this.emit('response', responseOrUpdate);
+                    await this.plugins.emit('onResponse', {
+                        client: this,
+                        response: responseOrUpdate
+                    });
+                }
+                return true;
+            }
+        }
+        catch (e) {
+            this.logger.error(`process() failed:`, e);
+        }
+    }
+    /**
+     * Given a buffer, try to parse into a specific ProtocolResponse or ProtocolUpdate
+     */
+    async getResponseOrUpdate(buffer) {
+        //if we haven't seen a handshake yet, try to convert the buffer into a handshake
+        if (!this.isHandshakeComplete) {
+            let handshake;
+            //try building the v3 handshake response first
+            handshake = HandshakeV3Response_1.HandshakeV3Response.fromBuffer(buffer);
+            //we didn't get a v3 handshake. try building an older handshake response
+            if (!handshake.success) {
+                handshake = HandshakeResponse_1.HandshakeResponse.fromBuffer(buffer);
+            }
+            if (handshake.success) {
+                await this.verifyHandshake(handshake);
+                return handshake;
+            }
+            return;
+        }
+        let genericResponse = this.watchPacketLength ? GenericV3Response_1.GenericV3Response.fromBuffer(buffer) : GenericResponse_1.GenericResponse.fromBuffer(buffer);
+        //if the response has a non-OK error code, we won't receive the expected response type,
+        //so return the generic response
+        if (genericResponse.success && genericResponse.data.errorCode !== Constants_1.ErrorCode.OK) {
+            return genericResponse;
+        }
+        // a nonzero requestId means this is a response to a request that we sent
+        if (genericResponse.data.requestId !== 0) {
+            //requestId 0 means this is an update
+            const request = this.activeRequests.get(genericResponse.data.requestId);
+            if (request) {
+                return DebugProtocolClient.getResponse(this.buffer, request.data.command);
+            }
+        }
+        else {
+            return this.getUpdate(this.buffer);
+        }
+    }
+    static getResponse(buffer, command) {
+        switch (command) {
+            case Constants_1.Command.Stop:
+            case Constants_1.Command.Continue:
+            case Constants_1.Command.Step:
+            case Constants_1.Command.ExitChannel:
+                return GenericV3Response_1.GenericV3Response.fromBuffer(buffer);
+            case Constants_1.Command.Execute:
+                return ExecuteV3Response_1.ExecuteV3Response.fromBuffer(buffer);
+            case Constants_1.Command.AddBreakpoints:
+            case Constants_1.Command.AddConditionalBreakpoints:
+                return AddBreakpointsResponse_1.AddBreakpointsResponse.fromBuffer(buffer);
+            case Constants_1.Command.ListBreakpoints:
+                return ListBreakpointsResponse_1.ListBreakpointsResponse.fromBuffer(buffer);
+            case Constants_1.Command.RemoveBreakpoints:
+                return RemoveBreakpointsResponse_1.RemoveBreakpointsResponse.fromBuffer(buffer);
+            case Constants_1.Command.Variables:
+                return VariablesResponse_1.VariablesResponse.fromBuffer(buffer);
+            case Constants_1.Command.StackTrace:
+                return StackTraceV3Response_1.StackTraceV3Response.fromBuffer(buffer);
+            case Constants_1.Command.Threads:
+                return ThreadsResponse_1.ThreadsResponse.fromBuffer(buffer);
+            default:
+                return undefined;
+        }
+    }
+    getUpdate(buffer) {
+        var _a, _b, _c, _d;
+        //read the update_type from the buffer (save some buffer parsing time by narrowing to the exact update type)
+        const updateTypeCode = buffer.readUInt32LE(
+        // if the protocol supports packet length, then update_type is bytes 12-16. Otherwise, it's bytes 8-12
+        this.watchPacketLength ? 12 : 8);
+        const updateType = Constants_1.UpdateTypeCode[updateTypeCode];
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.log('getUpdate(): update Type:', updateType);
+        switch (updateType) {
+            case Constants_1.UpdateType.IOPortOpened:
+                //TODO handle this
+                return IOPortOpenedUpdate_1.IOPortOpenedUpdate.fromBuffer(buffer);
+            case Constants_1.UpdateType.AllThreadsStopped:
+                return AllThreadsStoppedUpdate_1.AllThreadsStoppedUpdate.fromBuffer(buffer);
+            case Constants_1.UpdateType.ThreadAttached:
+                return ThreadAttachedUpdate_1.ThreadAttachedUpdate.fromBuffer(buffer);
+            case Constants_1.UpdateType.BreakpointError:
+                //we do nothing with breakpoint errors at this time.
+                return BreakpointErrorUpdate_1.BreakpointErrorUpdate.fromBuffer(buffer);
+            case Constants_1.UpdateType.CompileError:
+                let compileErrorUpdate = CompileErrorUpdate_1.CompileErrorUpdate.fromBuffer(buffer);
+                if (((_b = compileErrorUpdate === null || compileErrorUpdate === void 0 ? void 0 : compileErrorUpdate.data) === null || _b === void 0 ? void 0 : _b.errorMessage) !== '') {
+                    this.emit('compile-error', compileErrorUpdate);
+                }
+                return compileErrorUpdate;
+            case Constants_1.UpdateType.BreakpointVerified:
+                let response = BreakpointVerifiedUpdate_1.BreakpointVerifiedUpdate.fromBuffer(buffer);
+                if (((_d = (_c = response === null || response === void 0 ? void 0 : response.data) === null || _c === void 0 ? void 0 : _c.breakpoints) === null || _d === void 0 ? void 0 : _d.length) > 0) {
+                    this.emit('breakpoints-verified', response.data);
+                }
+                return response;
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * Handle/process any received updates from the debug protocol
+     */
+    async handleUpdate(update) {
+        return this.handleUpdateQueue.run(async () => {
+            update = (await this.plugins.emit('beforeHandleUpdate', {
+                client: this,
+                update: update
+            })).update;
+            if (update instanceof AllThreadsStoppedUpdate_1.AllThreadsStoppedUpdate || update instanceof ThreadAttachedUpdate_1.ThreadAttachedUpdate) {
+                this.isStopped = true;
+                let eventName;
+                if (update.data.stopReason === Constants_1.StopReason.RuntimeError) {
+                    eventName = 'runtime-error';
+                }
+                else {
+                    eventName = 'suspend';
+                }
+                const isValidStopReason = [Constants_1.StopReason.RuntimeError, Constants_1.StopReason.Break, Constants_1.StopReason.StopStatement].includes(update.data.stopReason);
+                if (update instanceof AllThreadsStoppedUpdate_1.AllThreadsStoppedUpdate && isValidStopReason) {
+                    this.primaryThread = update.data.threadIndex;
+                    this.stackFrameIndex = 0;
+                    this.emit(eventName, update);
+                }
+                else if (update instanceof ThreadAttachedUpdate_1.ThreadAttachedUpdate && isValidStopReason) {
+                    this.primaryThread = update.data.threadIndex;
+                    this.emit(eventName, update);
+                }
+            }
+            else if ((0, IOPortOpenedUpdate_1.isIOPortOpenedUpdate)(update)) {
+                this.connectToIoPort(update);
+            }
+            return true;
+        });
+    }
+    /**
+     * Verify all the handshake data
+     */
+    async verifyHandshake(response) {
+        if (DebugProtocolClient.DEBUGGER_MAGIC === response.data.magic) {
+            this.logger.log('Magic is valid.');
+            this.protocolVersion = response.data.protocolVersion;
+            this.logger.log('Protocol Version:', this.protocolVersion);
+            this.watchPacketLength = semver.satisfies(this.protocolVersion, '>=3.0.0');
+            this.isHandshakeComplete = true;
+            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
+                });
+                await this.shutdown('close');
+                handshakeVerified = false;
+            }
+            this.emit('handshake-verified', handshakeVerified);
+            return handshakeVerified;
+        }
+        else {
+            this.logger.log('Closing connection due to bad debugger magic', response.data.magic);
+            this.emit('handshake-verified', false);
+            await this.shutdown('close');
+            return false;
+        }
+    }
+    /**
+     * When the debugger emits the IOPortOpenedUpdate, we need to immediately connect to the IO port to start receiving that data
+     */
+    connectToIoPort(update) {
+        if (update.success) {
+            // Create a new TCP client.
+            this.ioSocket = new Net.Socket({
+                allowHalfOpen: false
+            });
+            // Send a connection request to the server.
+            this.logger.log(`Connect to IO Port ${this.options.host}:${update.data.port}`);
+            //sometimes the server shuts down before we had a chance to connect, so recover more gracefully
+            try {
+                this.ioSocket.connect({
+                    port: update.data.port,
+                    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.ioSocket.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.ioSocket.on('close', () => {
+                        this.logger.log('IO socket closed');
+                        this.ioSocketClosed.tryResolve();
+                    });
+                    // Don't forget to catch error, for your own sake.
+                    this.ioSocket.once('error', (err) => {
+                        this.ioSocket.end();
+                        this.logger.error(err);
+                    });
+                });
+                return true;
+            }
+            catch (e) {
+                this.logger.error(`Failed to connect to IO socket at ${this.options.host}:${update.data.port}`, e);
+                void this.shutdown('app-exit');
+            }
+        }
+        return false;
+    }
+    /**
+     * 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
+     */
+    async destroy(immediate = false) {
+        await this.shutdown('close', immediate);
+    }
+    async shutdown(eventName, immediate = false) {
+        var _a, _b, _c, _d, _e, _f;
+        this.logger.log('Shutting down!');
+        (_a = this.cancelControlConnectInterval) === null || _a === void 0 ? void 0 : _a.call(this);
+        for (const pendingSocket of this.pendingControlConnectionSockets) {
+            pendingSocket.removeAllListeners();
+            //cleanup and destroy all other sockets
+            if (pendingSocket !== this.controlSocket) {
+                pendingSocket.end();
+                pendingSocket === null || pendingSocket === void 0 ? void 0 : pendingSocket.destroy();
+            }
+        }
+        let exitChannelTimeout = (_c = (_b = this.options) === null || _b === void 0 ? void 0 : _b.exitChannelTimeout) !== null && _c !== void 0 ? _c : 30000;
+        let shutdownTimeMax = (_e = (_d = this.options) === null || _d === void 0 ? void 0 : _d.shutdownTimeout) !== null && _e !== void 0 ? _e : 10000;
+        //if immediate is true, this is an instant shutdown force. don't wait for anything
+        if (immediate) {
+            exitChannelTimeout = 0;
+            shutdownTimeMax = 0;
+        }
+        //tell the device to exit the channel
+        try {
+            //ask the device to terminate the debug session. We have to wait for this to come back.
+            //The device might be running unstoppable code, so this might take a while. Wait for the device to send back
+            //the response before we continue with the teardown process
+            await Promise.race([
+                immediate
+                    ? Promise.resolve(null)
+                    : this.exitChannel().finally(() => this.logger.log('exit channel completed')),
+                //if the exit channel request took this long to finish, something's terribly wrong
+                util_1.util.sleep(exitChannelTimeout)
+            ]);
+        }
+        finally { }
+        await Promise.all([
+            this.destroyControlSocket(shutdownTimeMax),
+            this.destroyIOSocket(shutdownTimeMax, immediate)
+        ]);
+        this.emit(eventName);
+        (_f = this.emitter) === null || _f === void 0 ? void 0 : _f.removeAllListeners();
+        this.buffer = Buffer.alloc(0);
+        this.bufferQueue.destroy();
+    }
+    async destroyControlSocket(timeout) {
+        if (this.controlSocket && !this.isDestroyingControlSocket) {
+            this.isDestroyingControlSocket = true;
+            //wait for the controlSocket to be closed
+            await Promise.race([
+                this.controlSocketClosed.promise,
+                util_1.util.sleep(timeout)
+            ]);
+            this.logger.log('[destroy] controlSocket is: ', this.controlSocketClosed.isResolved ? 'closed' : 'not closed');
+            //destroy the controlSocket
+            this.controlSocket.removeAllListeners();
+            this.controlSocket.destroy();
+            this.controlSocket = undefined;
+            this.isDestroyingControlSocket = false;
+        }
+    }
+    /**
+     * @param immediate if true, force close immediately instead of waiting for it to settle
+     */
+    async destroyIOSocket(timeout, immediate = false) {
+        var _a, _b, _c, _d;
+        if (this.ioSocket && !this.isDestroyingIOSocket) {
+            this.isDestroyingIOSocket = true;
+            //wait for the ioSocket to be closed
+            await Promise.race([
+                this.ioSocketClosed.promise.then(() => this.logger.log('IO socket closed')),
+                util_1.util.sleep(timeout)
+            ]);
+            //if the io socket is not closed, wait for it to at least settle
+            if (!this.ioSocketClosed.isCompleted && !immediate) {
+                await new Promise((resolve) => {
+                    var _a;
+                    const callback = debounce(() => {
+                        resolve();
+                    }, 250);
+                    //trigger the current callback once.
+                    callback();
+                    (_a = this.ioSocket) === null || _a === void 0 ? void 0 : _a.on('drain', callback);
+                });
+            }
+            this.logger.log('[destroy] ioSocket is: ', this.ioSocketClosed.isResolved ? 'closed' : 'not closed');
+            //destroy the ioSocket
+            (_b = (_a = this.ioSocket) === null || _a === void 0 ? void 0 : _a.removeAllListeners) === null || _b === void 0 ? void 0 : _b.call(_a);
+            (_d = (_c = this.ioSocket) === null || _c === void 0 ? void 0 : _c.destroy) === null || _d === void 0 ? void 0 : _d.call(_c);
+            this.ioSocket = undefined;
+            this.isDestroyingIOSocket = false;
+        }
+    }
+}
+exports.DebugProtocolClient = DebugProtocolClient;
+DebugProtocolClient.DEBUGGER_MAGIC = 'bsdebug'; // 64-bit = [b'bsdebug\0' little-endian]
+/**
+ * Is the event a ProtocolRequest
+ */
+function isProtocolRequest(event) {
+    var _a, _b;
+    return ((_a = event === null || event === void 0 ? void 0 : event.constructor) === null || _a === void 0 ? void 0 : _a.name.endsWith('Request')) && ((_b = event === null || event === void 0 ? void 0 : event.data) === null || _b === void 0 ? void 0 : _b.requestId) > 0;
+}
+exports.isProtocolRequest = isProtocolRequest;
+/**
+ * Is the event a ProtocolResponse
+ */
+function isProtocolResponse(event) {
+    var _a, _b;
+    return ((_a = event === null || event === void 0 ? void 0 : event.constructor) === null || _a === void 0 ? void 0 : _a.name.endsWith('Response')) && ((_b = event === null || event === void 0 ? void 0 : event.data) === null || _b === void 0 ? void 0 : _b.requestId) !== 0;
+}
+exports.isProtocolResponse = isProtocolResponse;
+/**
+ * Is the event a ProtocolUpdate update
+ */
+function isProtocolUpdate(event) {
+    var _a, _b;
+    return ((_a = event === null || event === void 0 ? void 0 : event.constructor) === null || _a === void 0 ? void 0 : _a.name.endsWith('Update')) && ((_b = event === null || event === void 0 ? void 0 : event.data) === null || _b === void 0 ? void 0 : _b.requestId) === 0;
+}
+exports.isProtocolUpdate = isProtocolUpdate;
+//# sourceMappingURL=DebugProtocolClient.js.map