roku-debug 0.22.6 → 0.23.0

package/dist/debugSession/BrightScriptDebugSession.js

@@ -32,7 +32,7 @@ const ecpRegistryUtils_1 = require("./ecpRegistryUtils");
 const RokuECP_1 = require("../RokuECP");
 const Exceptions_1 = require("../Exceptions");
 const diagnosticSource = 'roku-debug';
-class BrightScriptDebugSession extends debugadapter_1.DebugSession {
+class BrightScriptDebugSession extends debugadapter_1.LoggingDebugSession {
     constructor() {
         super();
         this.logger = logging_1.logger.createLogger(`[session]`);
@@ -41,6 +41,8 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
          * A sequence used to help identify log statements for requests
          */
         this.idCounter = 1;
+        this.processErrorHandlersRegistered = false;
+        this.isCrashed = false;
         //set imports as class properties so they can be spied upon during testing
         this.rokuDeploy = roku_deploy_1.rokuDeploy;
         this.componentLibraryServer = new ComponentLibraryServer_1.ComponentLibraryServer();
@@ -87,6 +89,120 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
         });
         this.fileLoggingManager = new logging_1.FileLoggingManager();
     }
+    start(inStream, outStream) {
+        super.start(inStream, outStream);
+        // Set up DAP protocol logging as early as possible — immediately after start() so we capture
+        // the initialize request and all early DAP traffic before launchRequest config is available.
+        // The log file path is injected as ROKU_DAP_LOG_FILE by the extension's DebugAdapterDescriptorFactory,
+        // which resolves the path from the `brightscript.debug.debugAdapterProtocolLogging` workspace setting
+        // (or the equivalent launch.json property) before the debug adapter process is spawned.
+        const dapLogFile = process.env.ROKU_DAP_LOG_FILE;
+        if (dapLogFile) {
+            // Use LogLevel.Error (not Verbose) as the console threshold so DAP messages are written
+            // to the log file but are NOT forwarded to VS Code as OutputEvents, which would flood
+            // the debug console and break the extension's output parsing.
+            // Note: InternalLogger always writes ALL messages to the file stream regardless of level,
+            // so the log file will still contain everything.
+            debugadapter_1.logger.setup(debugadapter_1.Logger.LogLevel.Error, dapLogFile);
+        }
+    }
+    setupProcessErrorHandlers() {
+        if (this.processErrorHandlersRegistered) {
+            return;
+        }
+        this.processErrorHandlersRegistered = true;
+        const handleError = (type, error) => {
+            var _a, _b, _c, _d;
+            const logger = this.logger.createLogger(`${type}`);
+            const message = error instanceof Error ? error.message : String(error);
+            const stack = error instanceof Error ? error.stack : undefined;
+            logger.error(message, stack);
+            let output;
+            try {
+                const debuggerVersion = fsExtra.readJsonSync(path.resolve(__dirname, '../../package.json')).version;
+                const clientName = (_b = (_a = this.initRequestArgs) === null || _a === void 0 ? void 0 : _a.clientName) !== null && _b !== void 0 ? _b : 'unknown';
+                const clientId = (_d = (_c = this.initRequestArgs) === null || _c === void 0 ? void 0 : _c.clientID) !== null && _d !== void 0 ? _d : 'unknown';
+                const issueBodyPrefix = [
+                    `**Debugger version:** ${debuggerVersion}`,
+                    `**Client:** ${clientName} (${clientId})`,
+                    `**Error type:** ${type}`,
+                    `**Message:** ${message}`,
+                    '',
+                    `**Steps to reproduce:**`,
+                    `<!-- Please describe what you were doing when this crash occurred -->`,
+                    '',
+                    '**Stack trace:**',
+                    '```',
+                    ''
+                ].join('\n');
+                const issueBodySuffix = '\n```';
+                const issueTitle = encodeURIComponent(`[crash] ${type}: ${message}`);
+                const baseUrl = 'https://github.com/RokuCommunity/roku-debug/issues/new';
+                const maxUrlLength = 2000;
+                const urlOverhead = `${baseUrl}?title=${issueTitle}&body=`.length;
+                const bodyBudget = maxUrlLength - urlOverhead;
+                const encodedPrefix = encodeURIComponent(issueBodyPrefix);
+                const encodedSuffix = encodeURIComponent(issueBodySuffix);
+                const stackBudget = bodyBudget - encodedPrefix.length - encodedSuffix.length;
+                let truncatedStack;
+                if (!stack) {
+                    truncatedStack = '(no stack trace)';
+                }
+                else if (encodeURIComponent(stack).length <= stackBudget) {
+                    truncatedStack = stack;
+                }
+                else {
+                    truncatedStack = decodeURIComponent(encodeURIComponent(stack).slice(0, stackBudget)) + '\n...(truncated)';
+                }
+                const issueUrl = `${baseUrl}?title=${issueTitle}&body=${encodedPrefix}${encodeURIComponent(truncatedStack)}${encodedSuffix}`;
+                output = [
+                    '',
+                    '================================================================',
+                    '  BRIGHTSCRIPT DEBUGGER INTERNAL ERROR',
+                    '  This is a crash in the debug adapter, not in your application.',
+                    '================================================================',
+                    `  Error type:        ${type}`,
+                    `  Message:           ${message}`,
+                    `  Debugger version:  ${debuggerVersion}`,
+                    `  Client:            ${clientName} (${clientId})`,
+                    '',
+                    '  Stack trace:',
+                    ...(stack !== null && stack !== void 0 ? stack : '(no stack trace)').split('\n').map(l => `  ${l}`),
+                    '',
+                    '  Please report this at:',
+                    `  ${issueUrl}`,
+                    '================================================================',
+                    ''
+                ].join('\n');
+            }
+            catch (e) {
+                output = JSON.stringify({
+                    name: e.name,
+                    message: e.message,
+                    stack: e.stack
+                });
+            }
+            void this.sendLogOutput(output).catch(() => { });
+            this.isCrashed = true;
+            this.sendEvent(new Events_1.ProcessCrashEvent({ type, message, stack }));
+            setTimeout(() => void this.shutdown(), 5000);
+        };
+        this._uncaughtExceptionHandler = (error) => handleError('uncaughtException', error);
+        this._unhandledRejectionHandler = (reason) => handleError('unhandledRejection', reason);
+        process.on('uncaughtException', this._uncaughtExceptionHandler);
+        process.on('unhandledRejection', this._unhandledRejectionHandler);
+    }
+    teardownProcessErrorHandlers() {
+        if (this._uncaughtExceptionHandler) {
+            process.removeListener('uncaughtException', this._uncaughtExceptionHandler);
+            this._uncaughtExceptionHandler = undefined;
+        }
+        if (this._unhandledRejectionHandler) {
+            process.removeListener('unhandledRejection', this._unhandledRejectionHandler);
+            this._unhandledRejectionHandler = undefined;
+        }
+        this.processErrorHandlersRegistered = false;
+    }
     onDeviceBreakpointsChanged(eventName, data) {
         this.logger.info('Sending verified device breakpoints to client', data);
         //send all verified breakpoints to the client
@@ -304,6 +420,7 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
         //send the response right away so the UI immediately shows the debugger toolbar
         this.sendResponse(response);
         this.launchConfiguration = this.normalizeLaunchConfig(config);
+        this.setupProcessErrorHandlers();
         //prebake some threads for our ProjectManager to use later on (1 for the main project, and 1 for every complib)
         BscProjectWorkerPool_1.bscProjectWorkerPool.preload(1 + ((_c = (_b = (_a = this.launchConfiguration) === null || _a === void 0 ? void 0 : _a.componentLibraries) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0));
         //set the logLevel provided by the launch config
@@ -343,6 +460,7 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
         this.logger.log('[launchRequest] Packaging and deploying to roku');
         try {
             const packageEnd = this.logger.timeStart('log', 'Packaging');
+            this.sendLaunchProgress('start', 'Packaging');
             //build the main project and all component libraries at the same time
             await Promise.all([
                 this.prepareMainProject(),
@@ -433,12 +551,14 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
             });
             //profiling supports connecting to the socket BEFORE a channel is published, so go ahead and connect now
             await this.tryProfilingConnectOnStart();
+            this.sendLaunchProgress('update', 'Uploading to Roku');
             await this.publish();
             //hack for certain roku devices that lock up when this event is emitted (no idea why!).
             if (this.launchConfiguration.emitChannelPublishedEvent) {
                 this.sendEvent(new Events_1.ChannelPublishedEvent(this.launchConfiguration));
             }
             //tell the adapter adapter that the channel has been launched.
+            this.sendLaunchProgress('update', 'Waiting on application');
             await this.rokuAdapter.activate();
             if (this.rokuAdapter.isDestroyed) {
                 throw new Error('Debug session encountered an error');
@@ -461,7 +581,7 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
                 throw error;
             }
             //at this point, the project has been deployed. If we need to use a deep link, launch it now.
-            if (this.launchConfiguration.deepLinkUrl) {
+            if (this.launchConfiguration.deepLinkUrl && !this.enableDebugProtocol) {
                 //wait until the first entry breakpoint has been hit
                 await this.firstRunDeferred.promise;
                 //if we are at a breakpoint, continue
@@ -484,6 +604,9 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
                 const message = (e instanceof Exceptions_1.SocketConnectionInUseError) ? e.message : ((_f = e === null || e === void 0 ? void 0 : e.stack) !== null && _f !== void 0 ? _f : e);
                 await this.shutdown(message, true);
             }
+            else {
+                this.sendLaunchProgress('end', 'Aborted (compile error)');
+            }
         }
         logEnd();
     }
@@ -491,7 +614,7 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
      * Activate all required functionality for profiling
      */
     async initializeProfiling() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         // Initialize PerfettoManager
         this.perfettoManager = new PerfettoManager_1.PerfettoManager({
             host: this.launchConfiguration.host,
@@ -521,14 +644,24 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
                 error: event.error
             }));
         });
-        //enable profiling on the device right away if tracing is enabled in the launch config (this doesn't actually start the trace, it just enables the ability to start a trace from the UI or automatically based on the config)
+        //tracing is explicitly enabled. Turn it on
         if (((_c = (_b = this.launchConfiguration.profiling) === null || _b === void 0 ? void 0 : _b.tracing) === null || _c === void 0 ? void 0 : _c.enable) && this.supportsPerfettoTracing) {
+            this.logger.info('Enabling perfetto tracing because it is supported by the device and enabled in the launch configuration');
             try {
                 await this.perfettoManager.enableTracing();
             }
             catch (e) {
                 this.logger.error('Failed to enable perfetto tracing', e);
             }
+            //tracing is expicitly DISabled. turn it off
+        }
+        else if (((_e = (_d = this.launchConfiguration.profiling) === null || _d === void 0 ? void 0 : _d.tracing) === null || _e === void 0 ? void 0 : _e.enable) === false && this.supportsPerfettoTracing) {
+            this.logger.info('Disabling perfetto tracing because it is disabled in the launch configuration');
+            //TODO implement a way to disable perfetto tracing on the device
+            //profiling.tracing.enabled is set to `undefined`, which means we should do nothing
+        }
+        else {
+            this.logger.info('Skipping perfetto initalization because `profiling.tracing.enable` is not defined in the launch configuration');
         }
     }
     /**
@@ -611,6 +744,7 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
         //find the first compile error (i.e. first DiagnosticSeverity.Error) if there is one
         this.compileError = diagnostics.find(x => x.severity === brighterscript_1.DiagnosticSeverity.Error);
         if (this.compileError) {
+            this.sendLaunchProgress('end', 'Aborted (compile error)');
             this.sendEvent(new debugadapter_1.StoppedEvent(Events_1.StoppedEventReason.exception, this.COMPILE_ERROR_THREAD_ID, `CompileError: ${this.compileError.message}`));
         }
         this.sendEvent(new Events_1.DiagnosticsEvent(diagnostics));
@@ -693,6 +827,9 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
      * @param logOutput
      */
     sendLogOutput(logOutput) {
+        if (this.isCrashed) {
+            return Promise.resolve();
+        }
         this.fileLoggingManager.writeRokuDeviceLog(logOutput);
         this.pendingSendLogPromise = this.pendingSendLogPromise.then(async () => {
             logOutput = await this.convertBacktracePaths(logOutput);
@@ -2035,10 +2172,14 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
      */
     async connectRokuAdapter() {
         this.rokuAdapter.on('start', () => {
+            this.sendLaunchProgress('end', 'Complete');
             if (!this.firstRunDeferred.isCompleted) {
                 this.firstRunDeferred.resolve();
             }
         });
+        this.rokuAdapter.on('launch-status', (message) => {
+            this.sendLaunchProgress('update', message);
+        });
         //when the debugger suspends (pauses for debugger input)
         // eslint-disable-next-line @typescript-eslint/no-misused-promises
         this.rokuAdapter.on('suspend', async () => {
@@ -2295,6 +2436,35 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
         //erase all cached variables
         this.variables = {};
     }
+    /**
+     * Sends a launch progress event to the client if the client supports progress reporting.
+     * - `'start'`: begins a new progress bar with the given message. Assigns a new progressId.
+     * - `'update'`: updates the message on the active progress bar.
+     * - `'end'`: dismisses the active progress bar with an optional final message.
+     */
+    sendLaunchProgress(type, message) {
+        var _a;
+        if (!((_a = this.initRequestArgs) === null || _a === void 0 ? void 0 : _a.supportsProgressReporting)) {
+            return;
+        }
+        if (type === 'start') {
+            this.launchProgressId = `rokudebug-launch-${this.idCounter++}`;
+            this.sendEvent(new debugadapter_1.ProgressStartEvent(this.launchProgressId, 'Launching', `${message}...`));
+        }
+        else if (this.launchProgressId) {
+            if (type === 'update') {
+                this.sendEvent(new debugadapter_1.ProgressUpdateEvent(this.launchProgressId, `${message}...`));
+            }
+            else {
+                const lastId = this.launchProgressId;
+                this.sendEvent(new debugadapter_1.ProgressUpdateEvent(lastId, message));
+                setTimeout(() => {
+                    this.sendEvent(new debugadapter_1.ProgressEndEvent(lastId, message));
+                }, 1000); // add a slight delay before ending the progress to improve UX
+                this.launchProgressId = undefined;
+            }
+        }
+    }
     /**
      * Tells the client to re-request all variables because we've invalidated them
      * @param threadId
@@ -2379,6 +2549,8 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
     }
     async _shutdown(errorMessage, modal = false) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        // Ensure any active launch progress bar is dismissed before showing error messages or the terminated event.
+        this.sendLaunchProgress('end', 'Complete');
         //send the message FIRST before anything else. This improves the chances that the message will be displayed to the user
         try {
             if (errorMessage) {
@@ -2474,6 +2646,12 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
         catch (e) {
             this.logger.error(e);
         }
+        try {
+            this.teardownProcessErrorHandlers();
+        }
+        catch (e) {
+            this.logger.error(e);
+        }
     }
 }
 exports.BrightScriptDebugSession = BrightScriptDebugSession;