Caught uncaught exceptions

.github/workflows/build.yml

@@ -25,7 +25,7 @@ jobs:
       - run: npm ci
       - run: npm run build
       - run: npm run lint
-      - run: npm run test
+      - run: npx cross-env NODE_OPTIONS="--max-old-space-size=4096" npm run test
       #- run: npm run publish-coverage
   npm-release:
     #only run this task if a tag starting with 'v' was used to trigger this (i.e. a tagged release)

.vscode/extensions.json

@@ -1,3 +1,5 @@
 {
-    "recommendations": []
+    "recommendations": [
+        "dbaeumer.vscode-eslint"
+    ]
 }

package.json

@@ -70,7 +70,7 @@
         "@types/fs-extra": "^9.0.13",
         "@types/glob": "^7.2.0",
         "@types/mocha": "^9.0.0",
-        "@types/node": "^16.11.6",
+        "@types/node": "^16.18.119",
         "@types/request": "^2.48.8",
         "@types/semver": "^7.3.9",
         "@types/sinon": "^10.0.6",

src/adapters/DebugProtocolAdapter.ts

@@ -6,7 +6,6 @@ import { CompileErrorProcessor } from '../CompileErrorProcessor';
 import type { RendezvousHistory, RendezvousTracker } from '../RendezvousTracker';
 import type { ChanperfData } from '../ChanperfTracker';
 import { ChanperfTracker } from '../ChanperfTracker';
-import type { SourceLocation } from '../managers/LocationManager';
 import { ErrorCode, PROTOCOL_ERROR_CODES, UpdateType } from '../debugProtocol/Constants';
 import { defer, util } from '../util';
 import { logger } from '../logging';
@@ -21,6 +20,7 @@ import { VariableType } from '../debugProtocol/events/responses/VariablesRespons
 import type { TelnetAdapter } from './TelnetAdapter';
 import type { DeviceInfo } from 'roku-deploy';
 import type { ThreadsResponse } from '../debugProtocol/events/responses/ThreadsResponse';
+import type { ExceptionBreakpointFilter } from '../debugProtocol/events/requests/SetExceptionBreakpointsRequest';
 
 /**
  * A class that connects to a Roku device over telnet debugger port and provides a standardized way of interacting with it.
@@ -185,7 +185,7 @@ export class DebugProtocolAdapter {
         return new Promise((resolve) => {
             let callCount = -1;
 
-            function handler() {
+            function handler(data: Buffer) {
                 callCount++;
                 let myCallCount = callCount;
                 setTimeout(() => {
@@ -199,23 +199,38 @@ export class DebugProtocolAdapter {
 
             client.addListener(name, handler);
             //call the handler immediately so we have a timeout
-            handler();
+            handler(Buffer.from([]));
         });
     }
 
     public get isAtDebuggerPrompt() {
         return this.client?.isStopped ?? false;
     }
 
+    private firstConnectDeferred = defer<void>();
+
+    /**
+     * Resolves when the first connection to the client is established
+     */
+    public onReady() {
+        return this.firstConnectDeferred.promise;
+    }
+
     /**
      * Connect to the telnet session. This should be called before the channel is launched.
      */
-    public async connect() {
+    public async connect(): Promise<void> {
         //Start processing telnet output to look for compile errors or the debugger prompt
         await this.processTelnetOutput();
 
-        this.on('waiting-for-debugger', () => {
-            void this.createDebugProtocolClient();
+        this.on('waiting-for-debugger', async () => { // eslint-disable-line @typescript-eslint/no-misused-promises
+            await this.createDebugProtocolClient();
+
+            //if this is the first time we are connecting, resolve the promise.
+            //(future events fire for "reconnect" situations, we don't need to resolve again for those)
+            if (!this.firstConnectDeferred.isCompleted) {
+                this.firstConnectDeferred.resolve();
+            }
         });
     }
 
@@ -515,7 +530,7 @@ export class DebugProtocolAdapter {
             let thread = await this.getThreadByThreadId(threadIndex);
             let frames: StackFrame[] = [];
             let stackTraceData = await this.client.getStackTrace(threadIndex);
-            for (let i = 0; i < stackTraceData?.data?.entries?.length ?? 0; i++) {
+            for (let i = 0; i < (stackTraceData?.data?.entries?.length ?? 0); i++) {
                 let frameData = stackTraceData.data.entries[i];
                 let stackFrame: StackFrame = {
                     frameId: this.nextFrameId++,
@@ -736,7 +751,7 @@ export class DebugProtocolAdapter {
                 return [];
             }
 
-            for (let i = 0; i < threadsResponse.data?.threads?.length ?? 0; i++) {
+            for (let i = 0; i < (threadsResponse.data?.threads?.length ?? 0); i++) {
                 let threadInfo = threadsResponse.data.threads[i];
                 let thread = <Thread>{
                     // NOTE: On THREAD_ATTACHED events the threads request is marking the wrong thread as primary.
@@ -829,6 +844,16 @@ export class DebugProtocolAdapter {
         this.chanperfTracker.clearHistory();
     }
 
+    public async setExceptionBreakpoints(filters: ExceptionBreakpointFilter[]) {
+        if (this.client?.supportsExceptionBreakpointFilters) {
+            //tell the client to set the exception breakpoints
+            const response = await this.client?.setExceptionBreakpoints(filters);
+            console.log(response);
+            return response;
+        }
+        return undefined;
+    }
+
     private syncBreakpointsPromise = Promise.resolve();
     public async syncBreakpoints() {
         this.logger.log('syncBreakpoints()');
@@ -902,7 +927,7 @@ export class DebugProtocolAdapter {
 
                 //if the response was successful, and we have the correct number of breakpoints in the response
                 if (response.data.errorCode === ErrorCode.OK && response?.data?.breakpoints?.length === breakpoints.length) {
-                    for (let i = 0; i < response?.data?.breakpoints?.length ?? 0; i++) {
+                    for (let i = 0; i < (response?.data?.breakpoints?.length ?? 0); i++) {
                         const deviceBreakpoint = response.data.breakpoints[i];
 
                         if (typeof deviceBreakpoint?.id === 'number') {

src/adapters/TelnetAdapter.ts

@@ -15,6 +15,7 @@ import type { AdapterOptions, RokuAdapterEvaluateResponse } from '../interfaces'
 import { HighLevelType } from '../interfaces';
 import { TelnetRequestPipeline } from './TelnetRequestPipeline';
 import type { DebugProtocolAdapter } from './DebugProtocolAdapter';
+import type { ExceptionBreakpointFilter } from '../debugProtocol/events/requests/SetExceptionBreakpointsRequest';
 
 /**
  * A class that connects to a Roku device over telnet debugger port and provides a standardized way of interacting with it.
@@ -71,6 +72,7 @@ export class TelnetAdapter {
     public supportsExecute = true;
 
     public once(eventName: 'app-ready'): Promise<void>;
+    public once(eventName: 'connected'): Promise<boolean>;
     public once(eventName: string) {
         return new Promise((resolve) => {
             const disconnect = this.on(eventName as Parameters<DebugProtocolAdapter['on']>[0], (...args) => {
@@ -226,6 +228,12 @@ export class TelnetAdapter {
         }
     }
 
+    private firstConnectDeferred = defer<void>();
+
+    public onReady() {
+        return this.firstConnectDeferred.promise;
+    }
+
     /**
      * Connect to the telnet session. This should be called before the channel is launched.
      */
@@ -356,6 +364,7 @@ export class TelnetAdapter {
         } catch (e) {
             deferred.reject(e);
         }
+        this.firstConnectDeferred.resolve();
         return deferred.promise;
     }
 
@@ -1076,6 +1085,10 @@ export class TelnetAdapter {
         this.chanperfTracker.clearHistory();
     }
 
+    public async setExceptionBreakpoints(filters: ExceptionBreakpointFilter[]) {
+        //we can't send dynamic breakpoints to the server...so just do nothing
+    }
+
     public async syncBreakpoints() {
         //we can't send dynamic breakpoints to the server...so just do nothing
     }

src/debugProtocol/Constants.ts

@@ -65,6 +65,12 @@ export enum Command {
      * @since protocol 3.1.0 (Roku OS 11.5)
      */
     AddConditionalBreakpoints = 'AddConditionalBreakpoints',
+    /**
+     * Adds a exception breakpoint.
+     *
+     * @since protocol TBD
+     */
+    SetExceptionBreakpoints = 'SetExceptionBreakpoints',
     /**
      *
      */
@@ -85,6 +91,7 @@ export enum CommandCode {
     RemoveBreakpoints = 9,
     Execute = 10,
     AddConditionalBreakpoints = 11,
+    SetExceptionBreakpoints = 12,
     ExitChannel = 122
 }
 
@@ -113,7 +120,9 @@ export enum ErrorCode {
     UNDEFINED_COMMAND = 2,
     CANT_CONTINUE = 3,
     NOT_STOPPED = 4,
-    INVALID_ARGS = 5
+    INVALID_ARGS = 5,
+    THREAD_DETACHED = 6,
+    EXECUTION_TIMEOUT = 7
 }
 
 export enum ErrorFlags {
@@ -198,7 +207,18 @@ export enum UpdateType {
      * Breakpoints were successfully verified
      * @since protocol 3.2
      */
-    BreakpointVerified = 'BreakpointVerified'
+    BreakpointVerified = 'BreakpointVerified',
+    /**
+     * An unrecoverable error has occurred on the protocol stream. As a result, the debug target is terminated.
+     * @since Roku OS 12.0
+     */
+    ProtocolError = 'ProtocolError',
+    /**
+     * ExceptionBreakpointError updates will be sent for compile and runtime errors for exception breakpoint conditions.
+     * These updates will be sent every time the condition fails to compile/run while throwing an exception.
+     * @since protocol 3.3 (OS 14.1.4 or greater)
+     */
+    ExceptionBreakpointError = 'ExceptionBreakpointError'
 }
 /**
  * The integer values for `UPDATE_TYPE`. Only used for serializing/deserializing over the debug protocol. Use `UpdateType` in your code.
@@ -210,10 +230,19 @@ export enum UpdateTypeCode {
     ThreadAttached = 3,
     BreakpointError = 4,
     CompileError = 5,
-    // /**
-    //  * Breakpoints were successfully verified
-    //  * @since protocol 3.2
-    //  */
-    BreakpointVerified = 6
+    /**
+     * Breakpoints were successfully verified
+     * @since protocol 3.2
+     */
+    BreakpointVerified = 6,
+    /**
+     * An unrecoverable error has occurred on the protocol stream. As a result, the debug target is terminated.
+     */
+    ProtocolError = 7,
+    /**
+     * ExceptionBreakpointError updates will be sent for compile and runtime errors for exception breakpoint conditions.
+     * These updates will be sent every time the condition fails to compile/run while throwing an exception.
+     * @since protocol 3.2
+     */
+    ExceptionBreakpointError = 8
 }
-

src/debugProtocol/client/DebugProtocolClient.spec.ts

@@ -519,6 +519,29 @@ describe('DebugProtocolClient', () => {
         ).to.be.true;
     });
 
+    it('knows when to enable exception breakpoint filters', () => {
+        //only supported on version 3.3.0 and above
+        client.protocolVersion = '1.0.0';
+        expect(
+            client['supportsExceptionBreakpointFilters']
+        ).to.be.false;
+
+        client.protocolVersion = '3.0.0';
+        expect(
+            client['supportsExceptionBreakpointFilters']
+        ).to.be.false;
+
+        client.protocolVersion = '3.3.0';
+        expect(
+            client['supportsExceptionBreakpointFilters']
+        ).to.be.true;
+
+        client.protocolVersion = '4.0.0';
+        expect(
+            client['supportsExceptionBreakpointFilters']
+        ).to.be.true;
+    });
+
     it('handles v3 handshake', async () => {
         //these are false by default
         expect(client.watchPacketLength).to.be.equal(false);