roku-debug 0.20.6 → 0.20.7

package/dist/adapters/DebugProtocolAdapter.js

@@ -1,26 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeyType = exports.EventName = exports.DebugProtocolAdapter = void 0;
-const Debugger_1 = require("../debugProtocol/Debugger");
+exports.isDebugProtocolAdapter = exports.KeyType = exports.EventName = exports.DebugProtocolAdapter = void 0;
 const EventEmitter = require("events");
 const net_1 = require("net");
+const brighterscript_1 = require("brighterscript");
 const CompileErrorProcessor_1 = require("../CompileErrorProcessor");
 const ChanperfTracker_1 = require("../ChanperfTracker");
 const Constants_1 = require("../debugProtocol/Constants");
 const util_1 = require("../util");
 const logging_1 = require("../logging");
 const semver = require("semver");
-const ActionQueue_1 = require("../managers/ActionQueue");
+const DebugProtocolClient_1 = require("../debugProtocol/client/DebugProtocolClient");
+const VariablesResponse_1 = require("../debugProtocol/events/responses/VariablesResponse");
 /**
  * A class that connects to a Roku device over telnet debugger port and provides a standardized way of interacting with it.
  */
 class DebugProtocolAdapter {
-    constructor(options, projectManager, breakpointManager, rendezvousTracker) {
+    constructor(options, projectManager, breakpointManager, rendezvousTracker, deviceInfo) {
         this.options = options;
         this.projectManager = projectManager;
         this.breakpointManager = breakpointManager;
         this.rendezvousTracker = rendezvousTracker;
-        this.logger = logging_1.logger.createLogger(`[${DebugProtocolAdapter.name}]`);
+        this.deviceInfo = deviceInfo;
+        this.logger = logging_1.logger.createLogger(`[padapter]`);
         /**
          *  Due to casing issues with the variables request on some versions of the debug protocol, we first need to try the request in the supplied case.
          * If that fails we retry in lower case. This flag is used to drive that logic switching
@@ -39,7 +41,12 @@ class DebugProtocolAdapter {
          * which indicates that the app is running on the Roku
          */
         this.isAppRunning = false;
-        this.actionQueue = new ActionQueue_1.ActionQueue();
+        /**
+         * Indicates whether this class had `.destroy()` called at least once. Mostly used for checking externally to see if
+         * the whole debug session has been terminated or is in a bad state.
+         */
+        this.isDestroyed = false;
+        this.syncBreakpointsPromise = Promise.resolve();
         util_1.util.normalizeAdapterOptions(this.options);
         this.emitter = new EventEmitter();
         this.chanperfTracker = new ChanperfTracker_1.ChanperfTracker();
@@ -57,12 +64,20 @@ class DebugProtocolAdapter {
         var _a;
         return (_a = this.socketDebugger) === null || _a === void 0 ? void 0 : _a.protocolVersion;
     }
+    once(eventName) {
+        return new Promise((resolve) => {
+            const disconnect = this.on(eventName, (...args) => {
+                disconnect();
+                resolve(...args);
+            });
+        });
+    }
     on(eventName, handler) {
-        this.emitter.on(eventName, handler);
+        var _a;
+        (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.on(eventName, handler);
         return () => {
-            if (this.emitter !== undefined) {
-                this.emitter.removeListener(eventName, handler);
-            }
+            var _a;
+            (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.removeListener(eventName, handler);
         };
     }
     emit(eventName, data) {
@@ -126,7 +141,7 @@ class DebugProtocolAdapter {
      */
     async connect() {
         let deferred = (0, util_1.defer)();
-        this.socketDebugger = new Debugger_1.Debugger(this.options);
+        this.socketDebugger = new DebugProtocolClient_1.DebugProtocolClient(this.options);
         try {
             // Emit IO from the debugger.
             // eslint-disable-next-line @typescript-eslint/no-misused-promises
@@ -176,7 +191,7 @@ class DebugProtocolAdapter {
                 console.debug('hasRuntimeError!!', data);
                 this.emit('runtime-error', {
                     message: data.data.stopReasonDetail,
-                    errorCode: Constants_1.STOP_REASONS[data.data.stopReason]
+                    errorCode: data.data.stopReason
                 });
             });
             this.socketDebugger.on('cannot-continue', () => {
@@ -185,9 +200,18 @@ class DebugProtocolAdapter {
             //handle when the device verifies breakpoints
             this.socketDebugger.on('breakpoints-verified', (event) => {
                 var _a;
+                let unverifiableDeviceIds = [];
                 //mark the breakpoints as verified
                 for (let breakpoint of (_a = event === null || event === void 0 ? void 0 : event.breakpoints) !== null && _a !== void 0 ? _a : []) {
-                    this.breakpointManager.verifyBreakpoint(breakpoint.breakpointId, true);
+                    const success = this.breakpointManager.verifyBreakpoint(breakpoint.id, true);
+                    if (!success) {
+                        unverifiableDeviceIds.push(breakpoint.id);
+                    }
+                }
+                //if there were any unsuccessful breakpoint verifications, we need to ask the device to delete those breakpoints as they've gone missing on our side
+                if (unverifiableDeviceIds.length > 0) {
+                    this.logger.warn('Could not find breakpoints to verify. Removing from device:', { deviceBreakpointIds: unverifiableDeviceIds });
+                    void this.socketDebugger.removeBreakpoints(unverifiableDeviceIds);
                 }
                 this.emit('breakpoints-verified', event);
             });
@@ -198,6 +222,17 @@ class DebugProtocolAdapter {
                 this.compileClient.destroy();
                 this.compileClient = undefined;
             }
+            this.socketDebugger.on('compile-error', (update) => {
+                let diagnostics = [];
+                diagnostics.push({
+                    path: update.data.filePath,
+                    range: brighterscript_1.util.createRange(update.data.lineNumber - 1, 0, update.data.lineNumber - 1, 999),
+                    message: update.data.errorMessage,
+                    severity: brighterscript_1.DiagnosticSeverity.Error,
+                    code: undefined
+                });
+                this.emit('diagnostics', diagnostics);
+            });
             this.logger.log(`Connected to device`, { host: this.options.host, connected: this.connected });
             this.emit('connected', this.connected);
             //the adapter is connected and running smoothly. resolve the promise
@@ -214,8 +249,18 @@ class DebugProtocolAdapter {
             this.emit('app-exit');
         }, 200);
     }
+    /**
+     * Determines if the current version of the debug protocol supports emitting compile error updates.
+     */
+    get supportsCompileErrorReporting() {
+        return semver.satisfies(this.deviceInfo['brightscript-debugger-version'], '>=3.1.0');
+    }
     async watchCompileOutput() {
         let deferred = (0, util_1.defer)();
+        //If the debugProtocol supports compile error updates, don't scrape telnet logs for compile errors
+        if (this.supportsCompileErrorReporting) {
+            return deferred.resolve();
+        }
         try {
             this.compileClient = new net_1.Socket();
             this.compileErrorProcessor.on('diagnostics', (errors) => {
@@ -228,7 +273,7 @@ class DebugProtocolAdapter {
             });
             this.logger.info('Connecting via telnet to gather compile info', { host: this.options.host, port: this.options.brightScriptConsolePort });
             this.compileClient.connect(this.options.brightScriptConsolePort, this.options.host, () => {
-                this.logger.log(`Connected via telnet to gather compile info`, { host: this.options.host, port: this.options.brightScriptConsolePort });
+                this.logger.log(`CONNECTED via telnet to gather compile info`, { host: this.options.host, port: this.options.brightScriptConsolePort });
             });
             this.logger.debug('Waiting for the compile client to settle');
             await this.settle(this.compileClient, 'data');
@@ -305,7 +350,7 @@ class DebugProtocolAdapter {
      * @returns the output of the command (if possible)
      */
     async evaluate(command, frameId = this.socketDebugger.primaryThread) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f, _g;
         if (this.supportsExecuteCommand) {
             if (!this.isAtDebuggerPrompt) {
                 throw new Error('Cannot run evaluate: debugger is not paused');
@@ -317,15 +362,20 @@ class DebugProtocolAdapter {
             this.logger.log('evaluate ', { command, frameId });
             const response = await this.socketDebugger.executeCommand(command, stackFrame.frameIndex, stackFrame.threadIndex);
             this.logger.info('evaluate response', { command, response });
-            if (response.executeSuccess) {
+            if (response.data.executeSuccess) {
                 return {
                     message: undefined,
                     type: 'message'
                 };
             }
             else {
+                const messages = [
+                    ...(_b = (_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.compileErrors) !== null && _b !== void 0 ? _b : [],
+                    ...(_d = (_c = response === null || response === void 0 ? void 0 : response.data) === null || _c === void 0 ? void 0 : _c.runtimeErrors) !== null && _d !== void 0 ? _d : [],
+                    ...(_f = (_e = response === null || response === void 0 ? void 0 : response.data) === null || _e === void 0 ? void 0 : _e.otherErrors) !== null && _f !== void 0 ? _f : []
+                ];
                 return {
-                    message: (_c = (_b = (_a = response.compileErrors.messages[0]) !== null && _a !== void 0 ? _a : response.runtimeErrors.messages[0]) !== null && _b !== void 0 ? _b : response.otherErrors.messages[0]) !== null && _c !== void 0 ? _c : 'Unknown error executing command',
+                    message: (_g = messages[0]) !== null && _g !== void 0 ? _g : 'Unknown error executing command',
                     type: 'error'
                 };
             }
@@ -337,24 +387,24 @@ class DebugProtocolAdapter {
             };
         }
     }
-    async getStackTrace(threadId = this.socketDebugger.primaryThread) {
+    async getStackTrace(threadIndex = this.socketDebugger.primaryThread) {
         if (!this.isAtDebuggerPrompt) {
             throw new Error('Cannot get stack trace: debugger is not paused');
         }
-        return this.resolve(`stack trace for thread ${threadId}`, async () => {
-            var _a, _b;
-            var _c, _d;
-            let thread = await this.getThreadByThreadId(threadId);
+        return this.resolve(`stack trace for thread ${threadIndex}`, async () => {
+            var _a, _b, _c, _d, _e;
+            var _f, _g;
+            let thread = await this.getThreadByThreadId(threadIndex);
             let frames = [];
-            let stackTraceData = await this.socketDebugger.stackTrace(threadId);
-            for (let i = 0; i < stackTraceData.stackSize; i++) {
-                let frameData = stackTraceData.entries[i];
+            let stackTraceData = await this.socketDebugger.getStackTrace(threadIndex);
+            for (let i = 0; (_c = i < ((_b = (_a = stackTraceData === null || stackTraceData === void 0 ? void 0 : stackTraceData.data) === null || _a === void 0 ? void 0 : _a.entries) === null || _b === void 0 ? void 0 : _b.length)) !== null && _c !== void 0 ? _c : 0; i++) {
+                let frameData = stackTraceData.data.entries[i];
                 let stackFrame = {
                     frameId: this.nextFrameId++,
                     // frame index is the reverse of the returned order.
-                    frameIndex: stackTraceData.stackSize - i - 1,
-                    threadIndex: threadId,
-                    filePath: frameData.fileName,
+                    frameIndex: stackTraceData.data.entries.length - i - 1,
+                    threadIndex: threadIndex,
+                    filePath: frameData.filePath,
                     lineNumber: frameData.lineNumber,
                     // eslint-disable-next-line no-nested-ternary
                     functionIdentifier: this.cleanUpFunctionName(i === 0 ? (frameData.functionName) ? frameData.functionName : thread.functionName : frameData.functionName)
@@ -364,8 +414,8 @@ class DebugProtocolAdapter {
             }
             //if the first frame is missing any data, suppliment with thread information
             if (frames[0]) {
-                (_a = (_c = frames[0]).filePath) !== null && _a !== void 0 ? _a : (_c.filePath = thread.filePath);
-                (_b = (_d = frames[0]).lineNumber) !== null && _b !== void 0 ? _b : (_d.lineNumber = thread.lineNumber);
+                (_d = (_f = frames[0]).filePath) !== null && _d !== void 0 ? _d : (_f.filePath = thread.filePath);
+                (_e = (_g = frames[0]).lineNumber) !== null && _e !== void 0 ? _e : (_g.lineNumber = thread.lineNumber);
             }
             return frames;
         });
@@ -377,11 +427,12 @@ class DebugProtocolAdapter {
         return functionName.substring(functionName.lastIndexOf('@') + 1);
     }
     /**
-     * Given an expression, evaluate that statement ON the roku
-     * @param expression
+     * Get info about the specified variable.
+     * @param expression the expression for the specified variable (i.e. `m`, `someVar.value`, `arr[1][2].three`). If empty string/undefined is specified, all local variables are retrieved instead
      */
-    async getVariable(expression, frameId, withChildren = true) {
-        const logger = this.logger.createLogger(' getVariable');
+    async getVariablesResponse(expression, frameId) {
+        const isScopesRequest = expression === '';
+        const logger = this.logger.createLogger('[getVariable]');
         logger.info('begin', { expression });
         if (!this.isAtDebuggerPrompt) {
             throw new Error('Cannot resolve variable: debugger is not paused');
@@ -390,89 +441,122 @@ class DebugProtocolAdapter {
         if (!frame) {
             throw new Error('Cannot request variable without a corresponding frame');
         }
-        logger.log(`Expression:`, expression);
+        logger.info(`Expression:`, JSON.stringify(expression));
         let variablePath = expression === '' ? [] : util_1.util.getVariablePath(expression);
         // Temporary workaround related to casing issues over the protocol
         if (this.enableVariablesLowerCaseRetry && (variablePath === null || variablePath === void 0 ? void 0 : variablePath.length) > 0) {
             variablePath[0] = variablePath[0].toLowerCase();
         }
-        let response = await this.socketDebugger.getVariables(variablePath, withChildren, frame.frameIndex, frame.threadIndex);
-        if (this.enableVariablesLowerCaseRetry && response.errorCode !== Constants_1.ERROR_CODES.OK) {
+        let response = await this.socketDebugger.getVariables(variablePath, frame.frameIndex, frame.threadIndex);
+        if (this.enableVariablesLowerCaseRetry && response.data.errorCode !== Constants_1.ErrorCode.OK) {
             // Temporary workaround related to casing issues over the protocol
             logger.log(`Retrying expression as lower case:`, expression);
             variablePath = expression === '' ? [] : util_1.util.getVariablePath(expression === null || expression === void 0 ? void 0 : expression.toLowerCase());
-            response = await this.socketDebugger.getVariables(variablePath, withChildren, frame.frameIndex, frame.threadIndex);
-        }
-        if (response.errorCode === Constants_1.ERROR_CODES.OK) {
-            let mainContainer;
-            let children = [];
-            let firstHandled = false;
-            for (let variable of response.variables) {
-                let value;
-                let variableType = variable.variableType;
-                if (variable.value === null) {
-                    value = 'roInvalid';
-                }
-                else if (variableType === 'String') {
-                    value = `\"${variable.value}\"`;
-                }
-                else {
-                    value = variable.value;
-                }
-                if (variableType === 'Subtyped_Object') {
-                    //subtyped objects can only have string values
-                    let parts = variable.value.split('; ');
-                    variableType = `${parts[0]} (${parts[1]})`;
-                }
-                else if (variableType === 'AA') {
-                    variableType = 'AssociativeArray';
-                }
-                let container = {
-                    name: expression,
-                    evaluateName: expression,
-                    variablePath: variablePath,
-                    type: variableType,
-                    value: value,
-                    keyType: variable.keyType,
-                    elementCount: variable.elementCount
-                };
-                if (!firstHandled && variablePath.length > 0) {
-                    firstHandled = true;
-                    mainContainer = container;
-                }
-                else {
-                    if (!firstHandled && variablePath.length === 0) {
-                        // If this is a scope request there will be no entries in the variable path
-                        // We will need to create a fake mainContainer
-                        firstHandled = true;
-                        mainContainer = {
-                            name: expression,
-                            evaluateName: expression,
-                            variablePath: variablePath,
-                            type: '',
-                            value: null,
-                            keyType: 'String',
-                            elementCount: response.numVariables
-                        };
-                    }
-                    let pathAddition = mainContainer.keyType === 'Integer' ? children.length : variable.name;
-                    container.name = pathAddition.toString();
-                    if (mainContainer.evaluateName) {
-                        container.evaluateName = `${mainContainer.evaluateName}["${pathAddition}"]`;
-                    }
-                    else {
-                        container.evaluateName = pathAddition.toString();
-                    }
-                    container.variablePath = [].concat(container.variablePath, [pathAddition.toString()]);
-                    if (container.keyType) {
-                        container.children = [];
-                    }
-                    children.push(container);
-                }
+            response = await this.socketDebugger.getVariables(variablePath, frame.frameIndex, frame.threadIndex);
+        }
+        return response;
+    }
+    /**
+     * Get the variable for the specified expression.
+     */
+    async getVariable(expression, frameId) {
+        var _a;
+        const response = await this.getVariablesResponse(expression, frameId);
+        if (Array.isArray((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.variables)) {
+            const container = this.createEvaluateContainer(response.data.variables[0], 
+            //the name of the top container is the expression itself
+            expression, 
+            //this is the top-level container, so there are no parent keys to this entry
+            undefined);
+            return container;
+        }
+    }
+    /**
+     * Get the list of local variables
+     */
+    async getLocalVariables(frameId) {
+        var _a, _b;
+        const response = await this.getVariablesResponse('', frameId);
+        if (((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.errorCode) === Constants_1.ErrorCode.OK && Array.isArray((_b = response === null || response === void 0 ? void 0 : response.data) === null || _b === void 0 ? void 0 : _b.variables)) {
+            //create a top-level container to hold all the local vars
+            const container = this.createEvaluateContainer(
+            //dummy data
+            {
+                isConst: false,
+                isContainer: true,
+                keyType: VariablesResponse_1.VariableType.String,
+                refCount: undefined,
+                type: VariablesResponse_1.VariableType.AssociativeArray,
+                value: undefined,
+                children: response.data.variables
+            }, 
+            //no name, this is a dummy container
+            undefined, 
+            //there's no parent path
+            undefined);
+            return container;
+        }
+    }
+    /**
+     * Create an EvaluateContainer for the given variable. If the variable has children, those are created and attached as well
+     * @param variable a Variable object from the debug protocol debugger
+     * @param name the name of this variable. For example, `alpha.beta.charlie`, this value would be `charlie`. For local vars, this is the root variable name (i.e. `alpha`)
+     * @param parentEvaluateName the string used to derive the parent, _excluding_ this variable's name (i.e. `alpha.beta` or `alpha[0]`)
+     */
+    createEvaluateContainer(variable, name, parentEvaluateName) {
+        var _a, _b, _c;
+        let value;
+        let variableType = variable.type;
+        if (variable.value === null) {
+            value = 'roInvalid';
+        }
+        else if (variableType === 'String') {
+            value = `\"${variable.value}\"`;
+        }
+        else {
+            value = variable.value;
+        }
+        if (variableType === VariablesResponse_1.VariableType.SubtypedObject) {
+            //subtyped objects can only have string values
+            let parts = variable.value.split('; ');
+            variableType = `${parts[0]} (${parts[1]})`;
+        }
+        else if (variableType === VariablesResponse_1.VariableType.AssociativeArray) {
+            variableType = VariablesResponse_1.VariableType.AssociativeArray;
+        }
+        //build full evaluate name for this var. (i.e. `alpha["beta"]` + ["charlie"]` === `alpha["beta"]["charlie"]`)
+        let evaluateName;
+        if (!(parentEvaluateName === null || parentEvaluateName === void 0 ? void 0 : parentEvaluateName.trim())) {
+            evaluateName = name;
+        }
+        else if (typeof name === 'string') {
+            evaluateName = `${parentEvaluateName}["${name}"]`;
+        }
+        else if (typeof name === 'number') {
+            evaluateName = `${parentEvaluateName}[${name}]`;
+        }
+        let container = {
+            name: name !== null && name !== void 0 ? name : '',
+            evaluateName: evaluateName !== null && evaluateName !== void 0 ? evaluateName : '',
+            type: variableType !== null && variableType !== void 0 ? variableType : '',
+            value: value !== null && value !== void 0 ? value : null,
+            highLevelType: undefined,
+            //non object/array variables don't have a key type
+            keyType: variable.keyType,
+            elementCount: (_c = (_a = variable.childCount) !== null && _a !== void 0 ? _a : (_b = variable.children) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : undefined,
+            //non object/array variables still need to have an empty `children` array to help upstream logic. The `keyType` being null is how we know it doesn't actually have children
+            children: []
+        };
+        //recursively generate children containers
+        if ([KeyType.integer, KeyType.string].includes(container.keyType) && Array.isArray(variable.children)) {
+            container.children = [];
+            for (let i = 0; i < variable.children.length; i++) {
+                const childVariable = variable.children[i];
+                const childContainer = this.createEvaluateContainer(childVariable, container.keyType === KeyType.integer ? i.toString() : childVariable.name, container.evaluateName);
+                container.children.push(childContainer);
             }
-            mainContainer.children = children;
-            return mainContainer;
         }
+        return container;
     }
     /**
      * Cache items by a unique key
@@ -495,18 +579,19 @@ class DebugProtocolAdapter {
             throw new Error('Cannot get threads: debugger is not paused');
         }
         return this.resolve('threads', async () => {
+            var _a, _b, _c;
             let threads = [];
-            let threadsData = await this.socketDebugger.threads();
-            for (let i = 0; i < threadsData.threadsCount; i++) {
-                let threadInfo = threadsData.threads[i];
+            let threadsResponse = await this.socketDebugger.threads();
+            for (let i = 0; (_c = i < ((_b = (_a = threadsResponse.data) === null || _a === void 0 ? void 0 : _a.threads) === null || _b === void 0 ? void 0 : _b.length)) !== null && _c !== void 0 ? _c : 0; i++) {
+                let threadInfo = threadsResponse.data.threads[i];
                 let thread = {
                     // NOTE: On THREAD_ATTACHED events the threads request is marking the wrong thread as primary.
                     // NOTE: Rely on the thead index from the threads update event.
                     isSelected: this.socketDebugger.primaryThread === i,
                     // isSelected: threadInfo.isPrimary,
-                    filePath: threadInfo.fileName,
+                    filePath: threadInfo.filePath,
                     functionName: threadInfo.functionName,
-                    lineNumber: threadInfo.lineNumber + 1,
+                    lineNumber: threadInfo.lineNumber,
                     lineContents: threadInfo.codeSnippet,
                     threadId: i
                 };
@@ -528,21 +613,26 @@ class DebugProtocolAdapter {
         }
     }
     removeAllListeners() {
-        var _a;
-        (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.removeAllListeners();
+        if (this.emitter) {
+            this.emitter.removeAllListeners();
+        }
     }
     /**
      * Disconnect from the telnet session and unset all objects
      */
     async destroy() {
+        this.isDestroyed = true;
+        // destroy the debug client if it's defined
         if (this.socketDebugger) {
-            // destroy might be called due to a compile error so the socket debugger might not exist yet
-            await this.socketDebugger.exitChannel();
+            try {
+                await this.socketDebugger.destroy();
+            }
+            catch (e) {
+                this.logger.error(e);
+            }
         }
         this.cache = undefined;
-        if (this.emitter) {
-            this.emitter.removeAllListeners();
-        }
+        this.removeAllListeners();
         this.emitter = undefined;
     }
     /**
@@ -566,20 +656,34 @@ class DebugProtocolAdapter {
         this.chanperfTracker.clearHistory();
     }
     async syncBreakpoints() {
+        this.logger.log('syncBreakpoints()');
+        //wait for the previous sync to finish
+        this.syncBreakpointsPromise = this.syncBreakpointsPromise
+            //ignore any errors
+            .catch(() => { })
+            //run the next sync
+            .then(() => this._syncBreakpoints());
+        //return the new promise, which will resolve once our latest `syncBreakpoints()` call is finished
+        return this.syncBreakpointsPromise;
+    }
+    async _syncBreakpoints() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         //we can't send breakpoints unless we're stopped (or in a protocol version that supports sending them while running).
         //So...if we're not stopped, quit now. (we'll get called again when the stop event happens)
-        if (!this.socketDebugger.supportsBreakpointRegistrationWhileRunning && !this.isAtDebuggerPrompt) {
+        if (!((_a = this.socketDebugger) === null || _a === void 0 ? void 0 : _a.supportsBreakpointRegistrationWhileRunning) && !this.isAtDebuggerPrompt) {
             return;
         }
         //compute breakpoint changes since last sync
         const diff = await this.breakpointManager.getDiff(this.projectManager.getAllProjects());
-        //delete these breakpoints
+        this.logger.log('Syncing breakpoints', diff);
+        // REMOVE breakpoints (delete these breakpoints from the device)
         if (diff.removed.length > 0) {
-            await this.actionQueue.run(async () => {
-                const response = await this.socketDebugger.removeBreakpoints(diff.removed.map(x => x.deviceId));
-                //return true to mark this action as complete, or false to retry the task again in the future
-                return response.success && response.errorCode === Constants_1.ERROR_CODES.OK;
-            });
+            const response = await this.socketDebugger.removeBreakpoints(
+            //TODO handle retrying to remove breakpoints that don't have deviceIds yet but might get one in the future
+            diff.removed.map(x => x.deviceId).filter(x => typeof x === 'number'));
+            if (((_b = response.data) === null || _b === void 0 ? void 0 : _b.errorCode) === Constants_1.ErrorCode.NOT_STOPPED) {
+                this.breakpointManager.failedDeletions.push(...diff.removed);
+            }
         }
         if (diff.added.length > 0) {
             const breakpointsToSendToDevice = diff.added.map(breakpoint => {
@@ -589,45 +693,44 @@ class DebugProtocolAdapter {
                     lineNumber: breakpoint.line,
                     hitCount: !isNaN(hitCount) ? hitCount : undefined,
                     conditionalExpression: breakpoint.condition,
-                    key: breakpoint.hash,
+                    srcHash: breakpoint.srcHash,
+                    destHash: breakpoint.destHash,
                     componentLibraryName: breakpoint.componentLibraryName
                 };
             });
-            //send these new breakpoints to the device
-            await this.actionQueue.run(async () => {
-                var _a;
-                //split the list into conditional and non-conditional breakpoints.
-                //(TODO we can eliminate this splitting logic once the conditional breakpoints "continue" bug in protocol is fixed)
-                const standardBreakpoints = [];
-                const conditionalBreakpoints = [];
-                for (const breakpoint of breakpointsToSendToDevice) {
-                    if ((_a = breakpoint === null || breakpoint === void 0 ? void 0 : breakpoint.conditionalExpression) === null || _a === void 0 ? void 0 : _a.trim()) {
-                        conditionalBreakpoints.push(breakpoint);
-                    }
-                    else {
-                        standardBreakpoints.push(breakpoint);
-                    }
+            //split the list into conditional and non-conditional breakpoints.
+            //(TODO we can eliminate this splitting logic once the conditional breakpoints "continue" bug in protocol is fixed)
+            const standardBreakpoints = [];
+            const conditionalBreakpoints = [];
+            for (const breakpoint of breakpointsToSendToDevice) {
+                if ((_c = breakpoint === null || breakpoint === void 0 ? void 0 : breakpoint.conditionalExpression) === null || _c === void 0 ? void 0 : _c.trim()) {
+                    conditionalBreakpoints.push(breakpoint);
                 }
-                let success = true;
-                for (const breakpoints of [standardBreakpoints, conditionalBreakpoints]) {
-                    const response = await this.socketDebugger.addBreakpoints(breakpoints);
-                    if (response.errorCode === Constants_1.ERROR_CODES.OK) {
-                        //mark the breakpoints as verified
-                        for (let i = 0; i < response.breakpoints.length; i++) {
-                            const deviceBreakpoint = response.breakpoints[i];
+                else {
+                    standardBreakpoints.push(breakpoint);
+                }
+            }
+            for (const breakpoints of [standardBreakpoints, conditionalBreakpoints]) {
+                const response = await this.socketDebugger.addBreakpoints(breakpoints);
+                //if the response was successful, and we have the correct number of breakpoints in the response
+                if (response.data.errorCode === Constants_1.ErrorCode.OK && ((_e = (_d = response === null || response === void 0 ? void 0 : response.data) === null || _d === void 0 ? void 0 : _d.breakpoints) === null || _e === void 0 ? void 0 : _e.length) === breakpoints.length) {
+                    for (let i = 0; (_h = i < ((_g = (_f = response === null || response === void 0 ? void 0 : response.data) === null || _f === void 0 ? void 0 : _f.breakpoints) === null || _g === void 0 ? void 0 : _g.length)) !== null && _h !== void 0 ? _h : 0; i++) {
+                        const deviceBreakpoint = response.data.breakpoints[i];
+                        if (typeof (deviceBreakpoint === null || deviceBreakpoint === void 0 ? void 0 : deviceBreakpoint.id) === 'number') {
                             //sync this breakpoint's deviceId with the roku-assigned breakpoint ID
-                            this.breakpointManager.setBreakpointDeviceId(breakpoints[i].key, deviceBreakpoint.breakpointId);
+                            this.breakpointManager.setBreakpointDeviceId(breakpoints[i].srcHash, breakpoints[i].destHash, deviceBreakpoint.id);
+                        }
+                        //this breakpoint had an issue. remove it from the client
+                        if (deviceBreakpoint.errorCode !== Constants_1.ErrorCode.OK) {
+                            this.breakpointManager.deleteBreakpoint(breakpoints[i].srcHash);
                         }
-                        //return true to mark this action as complete
-                        success && (success = true);
-                    }
-                    else {
-                        //this action is not yet complete. it should be retried
-                        success && (success = false);
                     }
+                    //the entire response was bad. delete these breakpoints from the client
                 }
-                return success;
-            });
+                else {
+                    this.breakpointManager.deleteBreakpoints(breakpoints.map(x => x.srcHash));
+                }
+            }
         }
     }
 }
@@ -642,4 +745,8 @@ var KeyType;
     KeyType["integer"] = "Integer";
     KeyType["legacy"] = "Legacy";
 })(KeyType = exports.KeyType || (exports.KeyType = {}));
+function isDebugProtocolAdapter(adapter) {
+    return (adapter === null || adapter === void 0 ? void 0 : adapter.constructor.name) === DebugProtocolAdapter.name;
+}
+exports.isDebugProtocolAdapter = isDebugProtocolAdapter;
 //# sourceMappingURL=DebugProtocolAdapter.js.map