roku-debug 0.8.7 → 0.9.0

package/dist/adapters/TelnetAdapter.js

@@ -1,15 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequestPipeline = exports.PrimativeType = exports.KeyType = exports.HighLevelType = exports.EventName = exports.TelnetAdapter = void 0;
-const EventEmitter = require("events");
+exports.PrimativeType = exports.KeyType = exports.EventName = exports.TelnetAdapter = void 0;
 const natural_orderby_1 = require("natural-orderby");
-const net = require("net");
+const EventEmitter = require("eventemitter3");
+const net_1 = require("net");
 const rokuDeploy = require("roku-deploy");
 const PrintedObjectParser_1 = require("../PrintedObjectParser");
 const CompileErrorProcessor_1 = require("../CompileErrorProcessor");
 const RendezvousTracker_1 = require("../RendezvousTracker");
 const ChanperfTracker_1 = require("../ChanperfTracker");
 const util_1 = require("../util");
+const logging_1 = require("../logging");
+const interfaces_1 = require("../interfaces");
+const TelnetRequestPipeline_1 = require("./TelnetRequestPipeline");
 /**
  * A class that connects to a Roku device over telnet debugger port and provides a standardized way of interacting with it.
  */
@@ -17,6 +20,7 @@ class TelnetAdapter {
     constructor(host, enableDebuggerAutoRecovery = false) {
         this.host = host;
         this.enableDebuggerAutoRecovery = enableDebuggerAutoRecovery;
+        this.logger = logging_1.logger.createLogger(`[${TelnetAdapter.name}]`);
         this.isNextBreakpointSkipped = false;
         this.cache = {};
         this.supportsMultipleRuns = true;
@@ -71,7 +75,7 @@ class TelnetAdapter {
         }, 0);
     }
     async activate() {
-        util_1.util.logDebug('Activate TelnetAdapter');
+        this.logger.log('Activate TelnetAdapter');
         this.isActivated = true;
         await this.handleStartupIfReady();
     }
@@ -81,13 +85,13 @@ class TelnetAdapter {
     async handleStartupIfReady() {
         var _a;
         if (this.isActivated && this.isAppRunning) {
-            util_1.util.logDebug('Handling startup');
+            this.logger.log('Handling startup');
             this.emit('start');
             //if we are already sitting at a debugger prompt, we need to emit the first suspend event.
             //If not, then there are probably still messages being received, so let the normal handler
             //emit the suspend event when it's ready
             if (this.isAtDebuggerPrompt === true) {
-                util_1.util.logDebug('At debug prompt, so trigger suspend event');
+                this.logger.log(`At debug prompt, so trigger the 'suspend' event`);
                 let threads = await this.getThreads();
                 this.emit('suspend', (_a = threads[0]) === null || _a === void 0 ? void 0 : _a.threadId);
             }
@@ -101,21 +105,21 @@ class TelnetAdapter {
      */
     settle(client, name, maxWaitMilliseconds = 400) {
         const startTime = new Date();
-        util_1.util.logDebug('Waiting for telnet client to settle');
+        this.logger.log('Waiting for telnet client to settle');
         return new Promise((resolve) => {
             let callCount = -1;
-            function handler() {
+            const handler = () => {
                 callCount++;
                 let myCallCount = callCount;
                 setTimeout(() => {
                     //if no other calls have been made since the timeout started, then the listener has settled
                     if (myCallCount === callCount) {
                         client.removeListener(name, handler);
-                        util_1.util.logDebug(`Telnet client has settled after ${new Date().getTime() - startTime.getTime()} milliseconds`);
+                        this.logger.log(`Telnet client has settled after ${new Date().getTime() - startTime.getTime()} milliseconds`);
                         resolve(callCount);
                     }
                 }, maxWaitMilliseconds);
-            }
+            };
             client.addListener(name, handler);
             //call the handler immediately so we have a timeout
             handler();
@@ -146,15 +150,15 @@ class TelnetAdapter {
      * Connect to the telnet session. This should be called before the channel is launched.
      */
     async connect() {
-        util_1.util.logDebug('Establishing telnet connection');
+        this.logger.log('Establishing telnet connection');
         let deferred = (0, util_1.defer)();
         this.isInMicroDebugger = false;
         this.isNextBreakpointSkipped = false;
         try {
-            util_1.util.logDebug('Pressing home button');
+            this.logger.log('Pressing home button');
             //force roku to return to home screen. This gives the roku adapter some security in knowing new messages won't be appearing during initialization
             await rokuDeploy.pressHomeButton(this.host);
-            let client = new net.Socket();
+            let client = new net_1.Socket();
             //listen for the close event
             client.addListener('close', (err, data) => {
                 this.emit('close');
@@ -165,13 +169,14 @@ class TelnetAdapter {
             });
             const settlePromise = this.settle(client, 'data');
             client.connect(8085, this.host, () => {
-                util_1.util.logDebug(`Telnet connection established to ${this.host}`);
+                this.logger.log(`Telnet connection established to ${this.host}`);
                 this.connected = true;
                 this.emit('connected', this.connected);
             });
             await settlePromise;
             //hook up the pipeline to the socket
-            this.requestPipeline = new RequestPipeline(client);
+            this.requestPipeline = new TelnetRequestPipeline_1.TelnetRequestPipeline(client);
+            this.requestPipeline.connect();
             //forward all raw console output
             this.requestPipeline.on('console-output', (output) => {
                 this.processBreakpoints(output);
@@ -197,14 +202,14 @@ class TelnetAdapter {
                 }
                 // short circuit after the output has been sent as console output
                 if (hasRuntimeError) {
-                    util_1.util.logDebugFenced('Detected runtime error in output', responseText);
+                    this.logger.log('Detected runtime error in output', { responseText });
                     this.isAtDebuggerPrompt = true;
                     return;
                 }
                 this.compileErrorProcessor.processUnhandledLines(responseText);
                 let match;
                 if (this.isAtCannotContinue(responseText)) {
-                    util_1.util.logDebug('is at cannot continue');
+                    this.logger.log('is at cannot continue');
                     this.isAtDebuggerPrompt = true;
                     return;
                 }
@@ -213,7 +218,7 @@ class TelnetAdapter {
                     // eslint-disable-next-line no-cond-assign
                     if (match = /\[scrpt.ctx.run.enter\]/i.exec(responseText.trim())) {
                         this.isAppRunning = true;
-                        util_1.util.logDebug('Running beacon detected');
+                        this.logger.log('Running beacon detected', { responseText });
                         void this.handleStartupIfReady();
                     }
                     //watch for the end of the program
@@ -222,28 +227,29 @@ class TelnetAdapter {
                         this.beginAppExit();
                     }
                     //watch for debugger prompt output
-                    if (util_1.util.checkForDebuggerPrompt(responseText)) {
-                        util_1.util.logDebugFenced('Debugger prompt detected in', responseText);
+                    if (util_1.util.endsWithDebuggerPrompt(responseText)) {
+                        this.logger.log('Debugger prompt detected in', { responseText });
                         //if we are activated AND this is the first time seeing the debugger prompt since a continue/step action
                         if (this.isNextBreakpointSkipped) {
-                            util_1.util.logDebug('This debugger is flagged to be skipped');
+                            this.logger.log('This debugger is flagged to be skipped');
                             this.isInMicroDebugger = false;
                             this.isNextBreakpointSkipped = false;
-                            void this.requestPipeline.executeCommand('c', false, false, false);
+                            void this.requestPipeline.executeCommand('c', { waitForPrompt: false, insertAtFront: true });
                         }
                         else {
                             if (this.isActivated && this.isAtDebuggerPrompt === false) {
                                 this.isAtDebuggerPrompt = true;
-                                util_1.util.logDebug('Sending the "suspend" event to the client');
+                                this.logger.log('Sending the "suspend" event to the client');
                                 this.emit('suspend');
                             }
                             else {
-                                util_1.util.logDebug('Skipping "suspend" event because we are already suspended');
+                                this.logger.log('Skipping "suspend" event because we are already suspended');
                                 this.isAtDebuggerPrompt = true;
                             }
                         }
                     }
                     else {
+                        this.logger.debug('responseText does not end with debugger prompt. isAtDebuggerPrompt = false', { responseText });
                         this.isAtDebuggerPrompt = false;
                     }
                 }
@@ -257,9 +263,9 @@ class TelnetAdapter {
         return deferred.promise;
     }
     beginAppExit() {
-        util_1.util.logDebug('Beginning app exit');
+        this.logger.log('Beginning app exit');
         this.compileErrorProcessor.compileErrorTimer = setTimeout(() => {
-            console.log('emitting app-exit');
+            this.logger.info('emitting app-exit');
             this.isAppRunning = false;
             this.emit('app-exit');
         }, 200);
@@ -304,42 +310,42 @@ class TelnetAdapter {
      * Send command to step over
      */
     stepOver() {
-        util_1.util.logDebug('stepOver');
+        this.logger.log('stepOver');
         this.clearCache();
-        return this.requestPipeline.executeCommand('over', false);
+        return this.requestPipeline.executeCommand('over', { waitForPrompt: false, insertAtFront: true });
     }
     stepInto() {
-        util_1.util.logDebug('stepInto');
+        this.logger.log('stepInto');
         this.clearCache();
-        return this.requestPipeline.executeCommand('step', false);
+        return this.requestPipeline.executeCommand('step', { waitForPrompt: false, insertAtFront: true });
     }
     stepOut() {
-        util_1.util.logDebug('stepOut');
+        this.logger.log('stepOut');
         this.clearCache();
-        return this.requestPipeline.executeCommand('out', false);
+        return this.requestPipeline.executeCommand('out', { waitForPrompt: false, insertAtFront: true });
     }
     /**
      * Tell the brightscript program to continue (i.e. resume program)
      */
     continue() {
-        util_1.util.logDebug('continue');
+        this.logger.log('continue');
         this.clearCache();
-        return this.requestPipeline.executeCommand('c', false);
+        return this.requestPipeline.executeCommand('c', { waitForPrompt: false, insertAtFront: true });
     }
     /**
      * Tell the brightscript program to pause (fall into debug mode)
      */
     pause() {
-        util_1.util.logDebug('pause');
+        this.logger.log('pause');
         this.clearCache();
-        //send the kill signal, which breaks into debugger mode
-        return this.requestPipeline.executeCommand('\x03;', false, true);
+        //send the kill signal, which breaks into debugger mode. This gets written immediately, regardless of debugger prompt status.
+        this.requestPipeline.write('\x03;');
     }
     /**
      * Clears the state, which means that everything will be retrieved fresh next time it is requested
      */
     clearCache() {
-        util_1.util.logDebug('Clearing TelnetAdapter cache');
+        this.logger.info('Clearing TelnetAdapter cache');
         this.cache = {};
         this.isAtDebuggerPrompt = false;
     }
@@ -348,26 +354,26 @@ class TelnetAdapter {
      * @param command the command to execute. If the command does not start with `print` the command will be prefixed with `print ` because
      */
     async evaluate(command) {
-        util_1.util.logDebug('evaluate ', { command });
+        this.logger.log('evaluate ', { command });
         if (!this.isAtDebuggerPrompt) {
             throw new Error('Cannot run evaluate: debugger is not paused');
         }
         //clear the cache (we don't know what command the user entered)
         this.clearCache();
         //don't wait for the output...we don't know what command the user entered
-        let responseText = await this.requestPipeline.executeCommand(command, true);
+        let responseText = await this.requestPipeline.executeCommand(command, { waitForPrompt: true });
         //we know that if we got a response, we are back at a debugger prompt
         this.isAtDebuggerPrompt = true;
         return responseText;
     }
     async getStackTrace() {
-        util_1.util.logDebug('Get stack trace');
+        this.logger.log(TelnetAdapter.prototype.getStackTrace.name);
         if (!this.isAtDebuggerPrompt) {
             throw new Error('Cannot get stack trace: debugger is not paused');
         }
         return this.resolve('stackTrace', async () => {
             //perform a request to load the stack trace
-            let responseText = await this.requestPipeline.executeCommand('bt', true);
+            let responseText = (await this.requestPipeline.executeCommand('bt', { waitForPrompt: true })).trim();
             let regexp = /#(\d+)\s+(?:function|sub)\s+([\$\w\d]+).*\s+file\/line:\s+(.*)\((\d+)\)/ig;
             let matches;
             let frames = [];
@@ -394,16 +400,6 @@ class TelnetAdapter {
             return frames;
         });
     }
-    /**
-     * Runs a regex to get the content between telnet commands
-     * @param value
-     */
-    getExpressionDetails(value) {
-        const match = /(.*?)\r?\nBrightscript Debugger>\s*/is.exec(value);
-        if (match) {
-            return match[1];
-        }
-    }
     /**
      * Runs a regex to check if the target is an object and get the type if it is
      * @param value
@@ -429,15 +425,15 @@ class TelnetAdapter {
      * @param scope
      */
     async getScopeVariables(scope) {
-        util_1.util.logDebug('getScopeVariables', { scope });
+        this.logger.log('getScopeVariables', { scope });
         if (!this.isAtDebuggerPrompt) {
             throw new Error('Cannot resolve variable: debugger is not paused');
         }
         return this.resolve(`Scope Variables`, async () => {
             let data;
             let vars = [];
-            data = await this.requestPipeline.executeCommand(`var`, true);
-            let splitData = data.split('\n');
+            data = await this.requestPipeline.executeCommand(`var`, { waitForPrompt: true });
+            let splitData = data.trim().split('\n');
             for (const line of splitData) {
                 let match;
                 if (!line.includes('Brightscript Debugger') && (match = this.getFirstWord(line))) {
@@ -456,123 +452,141 @@ class TelnetAdapter {
      * @param expression
      */
     async getVariable(expression) {
-        util_1.util.logDebug('getVariable', { expression });
+        const logger = this.logger.createLogger('[getVariable]');
+        logger.info('begin', { expression });
         if (!this.isAtDebuggerPrompt) {
             throw new Error('Cannot resolve variable: debugger is not paused');
         }
-        return this.resolve(`variable: ${expression}`, async () => {
-            let expressionType = await this.getVariableType(expression);
-            let lowerExpressionType = expressionType ? expressionType.toLowerCase() : null;
-            let data;
-            //if the expression type is a string, we need to wrap the expression in quotes BEFORE we run the print so we can accurately capture the full string value
-            if (lowerExpressionType === 'string' || lowerExpressionType === 'rostring') {
-                data = await this.requestPipeline.executeCommand(`print "--string-wrap--" + ${expression} + "--string-wrap--"`, true);
-                //write a for loop to print every value from the array. This gets around the `...` after the 100th item issue in the roku print call
-            }
-            else if (['roarray', 'rolist', 'roxmllist', 'robytearray'].includes(lowerExpressionType)) {
-                const command = [
-                    `for each vscodeLoopItem in ${expression} : print ` +
-                        `   "vscode_type_start:" + type(vscodeLoopItem) + ":vscode_type_stop "`,
-                    `   "vscode_is_string:"; (invalid <> GetInterface(vscodeLoopItem, "ifString"))`,
-                    `   vscodeLoopItem :` +
-                        ` end for`
-                ].join(';');
-                data = await this.requestPipeline.executeCommand(command, true);
-            }
-            else if (['roassociativearray', 'rosgnode'].includes(lowerExpressionType)) {
-                const command = [
-                    `for each vscodeLoopKey in ${expression}.keys(): print` +
-                        `   "vscode_key_start:" + vscodeLoopKey + ":vscode_key_stop "`,
-                    `   "vscode_type_start:" + type(${expression}[vscodeLoopKey]) + ":vscode_type_stop "`,
-                    `   "vscode_is_string:"; (invalid <> GetInterface(${expression}[vscodeLoopKey], "ifString"))`,
-                    `   ${expression}[vscodeLoopKey] :` +
-                        ' end for'
-                ].join(';');
-                data = await this.requestPipeline.executeCommand(command, true);
-            }
-            else {
-                data = await this.requestPipeline.executeCommand(`print ${expression}`, true);
-            }
-            let match = this.getExpressionDetails(data);
-            if (match !== undefined) {
-                let value = match;
-                if (lowerExpressionType === 'string' || lowerExpressionType === 'rostring') {
-                    value = value.trim().replace(/--string-wrap--/g, '');
-                    //add an escape character in front of any existing quotes
-                    value = value.replace(/"/g, '\\"');
-                    //wrap the string value with literal quote marks
-                    value = '"' + value + '"';
-                }
-                let highLevelType = this.getHighLevelType(expressionType);
-                let children;
-                if (highLevelType === HighLevelType.array || ['roassociativearray', 'rosgnode', 'roxmllist', 'robytearray'].includes(lowerExpressionType)) {
-                    //the print statment will always have 1 trailing newline, so remove that.
-                    value = util_1.util.removeTrailingNewline(value);
-                    //the array/associative array print is a loop of every value, so handle that
-                    children = this.getForLoopPrintedChildren(expression, value);
-                }
-                else if (highLevelType === HighLevelType.object) {
-                    children = this.getObjectChildren(expression, value.trim());
-                }
-                if (['rostring', 'roint', 'rointeger', 'rolonginteger', 'rofloat', 'rodouble', 'roboolean', 'rointrinsicdouble'].includes(lowerExpressionType)) {
-                    return {
-                        name: expression,
-                        value: util_1.util.removeTrailingNewline(value),
-                        type: expressionType,
-                        highLevelType: HighLevelType.primative,
-                        evaluateName: expression,
-                        children: []
-                    };
-                }
-                //add a computed `[[children]]` property to allow expansion of node children
-                if (lowerExpressionType === 'rosgnode') {
-                    let nodeChildren = {
-                        name: '[[children]]',
-                        type: 'roArray',
-                        highLevelType: 'array',
-                        evaluateName: `${expression}.getChildren(-1, 0)`,
-                        children: []
-                    };
-                    children.push(nodeChildren);
-                }
-                //xml elements won't display on their own, so we need to create some sub elements
-                if (lowerExpressionType === 'roxmlelement') {
-                    //add a computed `[[children]]` property to allow expansion of node children
-                    children.push({
-                        name: '[[children]]',
-                        type: 'roArray',
-                        highLevelType: HighLevelType.array,
-                        evaluateName: `${expression}.GetChildNodes()`,
-                        children: []
-                    });
-                    children.push({
-                        name: '[[attributes]]',
-                        type: 'roArray',
-                        highLevelType: HighLevelType.array,
-                        evaluateName: `${expression}.GetAttributes()`,
-                        children: []
-                    });
-                    //look up the element name right now
-                    const container = await this.getVariable(`${expression}.GetName()`);
-                    container.name = '[[name]]';
-                    children.push(container);
-                }
-                //if this item is an array or a list, add the item count to the end of the type
-                if (highLevelType === HighLevelType.array) {
-                    //TODO re-enable once we find how to refresh watch/variables panel, since lazy loaded arrays can't show a length
-                    //expressionType += `(${children.length})`;
-                }
-                let container = {
-                    name: expression,
-                    evaluateName: expression,
-                    type: expressionType,
-                    value: value.trim(),
-                    highLevelType: highLevelType,
-                    children: children
-                };
-                return container;
-            }
-        });
+        let expressionType = await this.getVariableType(expression);
+        let lowerExpressionType = expressionType ? expressionType.toLowerCase() : null;
+        let data;
+        //if the expression type is a string, we need to wrap the expression in quotes BEFORE we run the print so we can accurately capture the full string value
+        if (lowerExpressionType === 'string' || lowerExpressionType === 'rostring') {
+            data = await this.requestPipeline.executeCommand(`print "--string-wrap--" + ${expression} + "--string-wrap--"`, { waitForPrompt: true });
+            //write a for loop to print every value from the array. This gets around the `...` after the 100th item issue in the roku print call
+        }
+        else if (['roarray', 'rolist', 'roxmllist', 'robytearray'].includes(lowerExpressionType)) {
+            const command = [
+                `for each vscodeLoopItem in ${expression} : print ` +
+                    `   "vscode_type_start:" + type(vscodeLoopItem) + ":vscode_type_stop "`,
+                `   "vscode_is_string:"; (invalid <> GetInterface(vscodeLoopItem, "ifString"))`,
+                `   vscodeLoopItem :` +
+                    ` end for`
+            ].join(';');
+            data = await this.requestPipeline.executeCommand(command, { waitForPrompt: true });
+        }
+        else if (['roassociativearray', 'rosgnode'].includes(lowerExpressionType)) {
+            const command = [
+                `for each vscodeLoopKey in ${expression}.keys(): print` +
+                    `   "vscode_key_start:" + vscodeLoopKey + ":vscode_key_stop "`,
+                `   "vscode_type_start:" + type(${expression}[vscodeLoopKey]) + ":vscode_type_stop "`,
+                `   "vscode_is_string:"; (invalid <> GetInterface(${expression}[vscodeLoopKey], "ifString"))`,
+                `   ${expression}[vscodeLoopKey] :` +
+                    ' end for'
+            ].join(';');
+            data = await this.requestPipeline.executeCommand(command, { waitForPrompt: true });
+        }
+        else {
+            data = await this.requestPipeline.executeCommand(`print ${expression}`, { waitForPrompt: true });
+        }
+        logger.info('expression details', { data });
+        //remove excess whitespace
+        data = data.trim();
+        if (lowerExpressionType === 'string' || lowerExpressionType === 'rostring') {
+            data = data.trim().replace(/--string-wrap--/g, '');
+            //add an escape character in front of any existing quotes
+            data = data.replace(/"/g, '\\"');
+            //wrap the string value with literal quote marks
+            data = '"' + data + '"';
+        }
+        let highLevelType = this.getHighLevelType(expressionType);
+        let children;
+        if (highLevelType === interfaces_1.HighLevelType.array || ['roassociativearray', 'rosgnode', 'roxmllist', 'robytearray'].includes(lowerExpressionType)) {
+            //the print statment will always have 1 trailing newline, so remove that.
+            data = util_1.util.removeTrailingNewline(data);
+            //the array/associative array print is a loop of every value, so handle that
+            children = this.getForLoopPrintedChildren(expression, data);
+            children.push({
+                name: '[[count]]',
+                value: children.length.toString(),
+                type: 'integer',
+                highLevelType: interfaces_1.HighLevelType.primative,
+                evaluateName: children.length.toString(),
+                presentationHint: 'virtual',
+                keyType: KeyType.legacy,
+                children: undefined
+            });
+        }
+        else if (highLevelType === interfaces_1.HighLevelType.object) {
+            children = this.getObjectChildren(expression, data.trim());
+        }
+        else if (highLevelType === interfaces_1.HighLevelType.unknown) {
+            logger.warn('there was an issue evaluating this variable', { expression });
+            data = '<UNKNOWN>';
+        }
+        if (['rostring', 'roint', 'rointeger', 'rolonginteger', 'rofloat', 'rodouble', 'roboolean', 'rointrinsicdouble'].includes(lowerExpressionType)) {
+            return {
+                name: expression,
+                value: util_1.util.removeTrailingNewline(data),
+                type: expressionType,
+                highLevelType: interfaces_1.HighLevelType.primative,
+                evaluateName: expression,
+                children: []
+            };
+        }
+        //add a computed `[[children]]` property to allow expansion of node children
+        if (lowerExpressionType === 'rosgnode') {
+            let nodeChildren = {
+                name: '[[children]]',
+                type: 'roArray',
+                highLevelType: 'array',
+                presentationHint: 'virtual',
+                evaluateName: `${expression}.getChildren(-1, 0)`,
+                children: []
+            };
+            children.push(nodeChildren);
+        }
+        //xml elements won't display on their own, so we need to create some sub elements
+        if (lowerExpressionType === 'roxmlelement') {
+            children.push({
+                //look up the name of the xml element
+                ...await this.getVariable(`${expression}.GetName()`),
+                name: '[[name]]',
+                presentationHint: 'virtual'
+            });
+            children.push({
+                name: '[[attributes]]',
+                type: 'roAssociativeArray',
+                highLevelType: interfaces_1.HighLevelType.array,
+                evaluateName: `${expression}.GetAttributes()`,
+                presentationHint: 'virtual',
+                children: []
+            });
+            //add a computed `[[children]]` property to allow expansion of child elements
+            children.push({
+                name: '[[children]]',
+                type: 'roArray',
+                highLevelType: interfaces_1.HighLevelType.array,
+                evaluateName: `${expression}.GetChildNodes()`,
+                presentationHint: 'virtual',
+                children: []
+            });
+        }
+        //if this item is an array or a list, add the item count to the end of the type
+        if (highLevelType === interfaces_1.HighLevelType.array) {
+            //TODO re-enable once we find how to refresh watch/variables panel, since lazy loaded arrays can't show a length
+            //expressionType += `(${children.length})`;
+        }
+        let container = {
+            name: expression,
+            evaluateName: expression,
+            type: expressionType,
+            value: data.trim(),
+            highLevelType: highLevelType,
+            children: children
+        };
+        logger.info('end', { container });
+        return container;
     }
     /**
      * In order to get around the `...` issue in printed arrays, `getVariable` now prints every value from an array or associative array in a for loop.
@@ -647,22 +661,22 @@ class TelnetAdapter {
                 let collectionEnd;
                 if (line.includes('<Component: roList>')) {
                     collectionEnd = ')';
-                    child.highLevelType = HighLevelType.array;
+                    child.highLevelType = interfaces_1.HighLevelType.array;
                     child.type = objectType;
                 }
                 else if (line.includes('<Component: roArray>')) {
                     collectionEnd = ']';
-                    child.highLevelType = HighLevelType.array;
+                    child.highLevelType = interfaces_1.HighLevelType.array;
                     child.type = this.getObjectType(line);
                 }
                 else if (line.includes('<Component: roByteArray>')) {
                     collectionEnd = ']';
-                    child.highLevelType = HighLevelType.array;
+                    child.highLevelType = interfaces_1.HighLevelType.array;
                     child.type = this.getObjectType(line);
                 }
                 else if (line.includes('<Component: roAssociativeArray>') || isRoSGNode) {
                     collectionEnd = '}';
-                    child.highLevelType = HighLevelType.object;
+                    child.highLevelType = interfaces_1.HighLevelType.object;
                     child.type = this.getObjectType(line);
                 }
                 let collectionLineList = [line];
@@ -676,34 +690,24 @@ class TelnetAdapter {
                 }
                 //we have reached the end of the collection. scrap children because they need evaluated in a separate call to compute their types
                 child.children = [];
-                if (isRoSGNode) {
-                    let nodeChildrenProperty = {
-                        name: '[[children]]',
-                        type: 'roArray',
-                        highLevelType: 'array',
-                        evaluateName: `${child.evaluateName}.getChildren(-1,0)`,
-                        children: []
-                    };
-                    child.children.push(nodeChildrenProperty);
-                }
                 //this if block must pre-seek the `line.indexOf('<Component') > -1` line because roInvalid is a component too.
             }
             else if (objectType === 'roInvalid') {
-                child.highLevelType = HighLevelType.uninitialized;
+                child.highLevelType = interfaces_1.HighLevelType.uninitialized;
                 child.type = 'roInvalid';
                 child.value = 'roInvalid';
                 child.children = undefined;
             }
             else if (line.includes('<Component:')) {
                 //handle things like nodes
-                child.highLevelType = HighLevelType.object;
+                child.highLevelType = interfaces_1.HighLevelType.object;
                 child.type = objectType;
             }
             else {
                 //is some primative type
                 child.type = type;
                 child.value = line.trim();
-                child.highLevelType = HighLevelType.primative;
+                child.highLevelType = interfaces_1.HighLevelType.primative;
                 child.children = undefined;
             }
             children.push(child);
@@ -749,7 +753,7 @@ class TelnetAdapter {
             else {
                 child.type = this.getPrimativeTypeFromValue(line);
                 child.value = line;
-                child.highLevelType = HighLevelType.primative;
+                child.highLevelType = interfaces_1.HighLevelType.primative;
             }
             children.push(child);
             arrayIndex++;
@@ -794,7 +798,7 @@ class TelnetAdapter {
                     child = {
                         name: line,
                         type: '<ERROR>',
-                        highLevelType: HighLevelType.uninitialized,
+                        highLevelType: interfaces_1.HighLevelType.uninitialized,
                         evaluateName: undefined,
                         variablePath: [],
                         elementCount: -1,
@@ -819,7 +823,7 @@ class TelnetAdapter {
                     else {
                         child.type = this.getPrimativeTypeFromValue(trimmedLine);
                         child.value = lineParseResult.value;
-                        child.highLevelType = HighLevelType.primative;
+                        child.highLevelType = interfaces_1.HighLevelType.primative;
                     }
                 }
                 children.push(child);
@@ -836,24 +840,24 @@ class TelnetAdapter {
      */
     getHighLevelType(expressionType) {
         if (!expressionType) {
-            throw new Error(`Unknown expression type: ${expressionType}`);
+            return interfaces_1.HighLevelType.unknown;
         }
         expressionType = expressionType.toLowerCase();
         let primativeTypes = ['boolean', 'integer', 'longinteger', 'float', 'double', 'string', 'rostring', 'invalid'];
         if (primativeTypes.includes(expressionType)) {
-            return HighLevelType.primative;
+            return interfaces_1.HighLevelType.primative;
         }
         else if (expressionType === 'roarray' || expressionType === 'rolist') {
-            return HighLevelType.array;
+            return interfaces_1.HighLevelType.array;
         }
         else if (expressionType === 'function') {
-            return HighLevelType.function;
+            return interfaces_1.HighLevelType.function;
         }
         else if (expressionType === '<uninitialized>') {
-            return HighLevelType.uninitialized;
+            return interfaces_1.HighLevelType.uninitialized;
         }
         else {
-            return HighLevelType.object;
+            return interfaces_1.HighLevelType.object;
         }
     }
     /**
@@ -866,17 +870,10 @@ class TelnetAdapter {
         }
         expression = `Type(${expression})`;
         return this.resolve(`${expression}`, async () => {
-            let data = await this.requestPipeline.executeCommand(`print ${expression}`, true);
-            let match = this.getExpressionDetails(data);
-            if (match) {
-                let typeValue = match;
-                //remove whitespace
-                typeValue = typeValue.trim();
-                return typeValue;
-            }
-            else {
-                return null;
-            }
+            var _a;
+            let data = await this.requestPipeline.executeCommand(`print ${expression}`, { waitForPrompt: true });
+            //remove whitespace
+            return (_a = data === null || data === void 0 ? void 0 : data.trim()) !== null && _a !== void 0 ? _a : null;
         });
     }
     /**
@@ -887,11 +884,11 @@ class TelnetAdapter {
     resolve(key, factory) {
         try {
             if (this.cache[key]) {
-                util_1.util.logDebug(`resolve cache "${key}": already exists`);
+                this.logger.debug(`resolve cache "${key}": already exists`);
                 return this.cache[key];
             }
             else {
-                util_1.util.logDebug(`resolve cache "${key}": calling factory`);
+                this.logger.debug(`resolve cache "${key}": calling factory`);
                 const result = factory();
                 this.cache[key] = Promise.resolve(result);
                 return this.cache[key];
@@ -905,14 +902,14 @@ class TelnetAdapter {
      * Get a list of threads. The first thread in the list is the active thread
      */
     async getThreads() {
-        util_1.util.logDebug('getThreads');
+        this.logger.log('getThreads');
         if (!this.isAtDebuggerPrompt) {
-            util_1.util.logDebug('Cannot get threads: debugger is not paused');
+            this.logger.log('Cannot get threads: debugger is not paused');
             return [];
         }
         return this.resolve('threads', async () => {
-            let data = await this.requestPipeline.executeCommand('threads', true);
-            let dataString = data.toString();
+            let data = await this.requestPipeline.executeCommand('threads', { waitForPrompt: true });
+            let dataString = data.toString().trim();
             let matches = /^\s+(\d+\*)\s+(.*)\((\d+)\)\s+(.*)/gm.exec(dataString);
             let threads = [];
             if (matches) {
@@ -956,20 +953,6 @@ class TelnetAdapter {
         //needs to be async to match the DebugProtocolAdapter implementation
         return Promise.resolve();
     }
-    /**
-     * Make sure any active Brightscript Debugger threads are exited
-     */
-    async exitActiveBrightscriptDebugger() {
-        if (this.requestPipeline) {
-            let commandsExecuted = 0;
-            do {
-                let data = await this.requestPipeline.executeCommand(`exit`, false);
-                // This seems to work without the delay but I wonder about slower devices
-                // await setTimeout[Object.getOwnPropertySymbols(setTimeout)[0]](100);
-                commandsExecuted++;
-            } while (commandsExecuted < 10);
-        }
-    }
     // #region Rendezvous Tracker pass though functions
     /**
      * Passes the debug functions used to locate the client files and lines to the RendezvousTracker
@@ -1003,14 +986,6 @@ var EventName;
 (function (EventName) {
     EventName["suspend"] = "suspend";
 })(EventName = exports.EventName || (exports.EventName = {}));
-var HighLevelType;
-(function (HighLevelType) {
-    HighLevelType["primative"] = "primative";
-    HighLevelType["array"] = "array";
-    HighLevelType["function"] = "function";
-    HighLevelType["object"] = "object";
-    HighLevelType["uninitialized"] = "uninitialized";
-})(HighLevelType = exports.HighLevelType || (exports.HighLevelType = {}));
 var KeyType;
 (function (KeyType) {
     KeyType["string"] = "String";
@@ -1025,155 +1000,4 @@ var PrimativeType;
     PrimativeType["integer"] = "Integer";
     PrimativeType["float"] = "Float";
 })(PrimativeType = exports.PrimativeType || (exports.PrimativeType = {}));
-class RequestPipeline {
-    constructor(client) {
-        this.client = client;
-        this.requests = [];
-        this.isAtDebuggerPrompt = false;
-        this.currentRequest = undefined;
-        this.emitter = new EventEmitter();
-        /**
-         * Used to help with logging
-         */
-        this.commandIdSequence = 0;
-        this.connect();
-    }
-    get isProcessing() {
-        return this.currentRequest !== undefined;
-    }
-    get hasRequests() {
-        return this.requests.length > 0;
-    }
-    on(eventName, handler) {
-        this.emitter.on(eventName, handler);
-        return () => {
-            this.emitter.removeListener(eventName, handler);
-        };
-    }
-    emit(eventName, data) {
-        this.emitter.emit(eventName, data);
-    }
-    connect() {
-        let allResponseText = '';
-        let lastPartialLine = '';
-        this.client.addListener('data', (data) => {
-            let responseText = data.toString();
-            util_1.util.logDebugFenced('Raw telnet data', responseText);
-            const cumulative = lastPartialLine + responseText;
-            //ensure all debugger prompts appear completely on their own line
-            responseText = util_1.util.ensureDebugPromptOnOwnLine(responseText);
-            if (!cumulative.endsWith('\n') && !util_1.util.checkForDebuggerPrompt(cumulative)) {
-                // buffer was split and was not the result of a prompt, save the partial line
-                lastPartialLine += responseText;
-                return;
-            }
-            if (lastPartialLine) {
-                // there was leftover lines, join the partial lines back together
-                responseText = lastPartialLine + responseText;
-                lastPartialLine = '';
-            }
-            //forward all raw console output
-            this.emit('console-output', responseText);
-            allResponseText += responseText;
-            let foundDebuggerPrompt = util_1.util.checkForDebuggerPrompt(allResponseText);
-            //if we are not processing, immediately broadcast the latest data
-            if (!this.isProcessing) {
-                this.emit('unhandled-console-output', allResponseText);
-                allResponseText = '';
-                if (foundDebuggerPrompt) {
-                    this.isAtDebuggerPrompt = true;
-                    if (this.hasRequests) {
-                        // There are requests waiting to be processed
-                        this.process();
-                    }
-                }
-            }
-            else {
-                //if responseText produced a prompt, return the responseText
-                if (foundDebuggerPrompt) {
-                    //resolve the command's promise (if it cares)
-                    this.isAtDebuggerPrompt = true;
-                    this.currentRequest.onComplete(allResponseText);
-                    allResponseText = '';
-                    this.currentRequest = undefined;
-                    //try to run the next request
-                    this.process();
-                }
-            }
-        });
-    }
-    /**
-     * Schedule a command to be run. Resolves with the result once the command finishes
-     * @param commandFunction
-     * @param waitForPrompt - if true, the promise will wait until we find a prompt, and return all output in between. If false, the promise will immediately resolve
-     * @param forceExecute - if true, it is assumed the command can be run at any time and will be executed immediately
-     * @param silent - if true, the command will be hidden from the output
-     */
-    executeCommand(command, waitForPrompt, forceExecute = false, silent = false) {
-        const commandId = this.commandIdSequence++;
-        util_1.util.logDebug(`Command ${commandId} execute ${JSON.stringify(command)} and ${waitForPrompt ? '' : ' don\'t'} wait for prompt): \n`, command, '\n');
-        return new Promise((resolve, reject) => {
-            let executeCommand = () => {
-                let commandText = `${command}\r\n`;
-                if (!silent) {
-                    this.emit('console-output', command);
-                }
-                this.client.write(commandText);
-                if (waitForPrompt) {
-                    // The act of executing this command means we are no longer at the debug prompt
-                    this.isAtDebuggerPrompt = false;
-                }
-            };
-            let request = {
-                executeCommand: executeCommand,
-                onComplete: (data) => {
-                    util_1.util.logDebugFenced(`Command ${commandId} execute ${JSON.stringify(command)} result`, data);
-                    resolve(data);
-                },
-                waitForPrompt: waitForPrompt
-            };
-            if (!waitForPrompt) {
-                if (!this.isProcessing || forceExecute) {
-                    //fire and forget the command
-                    request.executeCommand();
-                    //the command doesn't care about the output, resolve it immediately
-                    request.onComplete(undefined);
-                }
-                else {
-                    // Skip this request as the device is not ready to accept the command or it can not be run at any time
-                }
-            }
-            else {
-                this.requests.push(request);
-                if (this.isAtDebuggerPrompt) {
-                    //start processing since we are already at a debug prompt (safe to call multiple times)
-                    this.process();
-                }
-                else {
-                    // do not run the command until the device is at a debug prompt.
-                    // this will be detected in the data listener in the connect function
-                }
-            }
-        });
-    }
-    /**
-     * Internal request processing function
-     */
-    process() {
-        if (this.isProcessing || !this.hasRequests) {
-            return;
-        }
-        //get the oldest command
-        let nextRequest = this.requests.shift();
-        this.currentRequest = nextRequest;
-        //run the request. the data listener will handle launching the next request once this one has finished processing
-        nextRequest.executeCommand();
-    }
-    destroy() {
-        this.client.removeAllListeners();
-        this.client.destroy();
-        this.client = undefined;
-    }
-}
-exports.RequestPipeline = RequestPipeline;
 //# sourceMappingURL=TelnetAdapter.js.map