Add some enhanced launch settings to support more diverse projects

package.json

@@ -111,7 +111,7 @@
         "postman-request": "^2.88.1-postman.32",
         "replace-in-file": "^6.3.2",
         "replace-last": "^1.2.6",
-        "roku-deploy": "^3.11.3",
+        "roku-deploy": "^3.12.0",
         "semver": "^7.5.4",
         "serialize-error": "^8.1.0",
         "smart-buffer": "^4.2.0",

src/LaunchConfiguration.ts

@@ -292,6 +292,39 @@ export interface LaunchConfiguration extends DebugProtocol.LaunchRequestArgument
      * @default false
      */
     deleteDevChannelBeforeInstall: boolean;
+
+    /**
+     * Task to run instead of roku-deploy to produce the .zip file that will be uploaded to the Roku.
+     */
+    packageTask: string;
+
+    /**
+     * Path to the .zip that will be uploaded to the Roku
+     */
+    packagePath: string;
+
+    /**
+     * Overrides for values used during the roku-deploy zip upload process, like the route and various form data. You probably don't need to change these..
+     */
+    packageUploadOverrides?: {
+        /**
+         * The route to use for uploading to the Roku device. Defaults to 'plugin_install'
+         * @default 'plugin_install'
+         */
+        route: string;
+
+        /**
+         * A dictionary of form fields to be included in the package upload request. Set a value to null to delete from the form
+         */
+        formData: Record<string, any>;
+    };
+
+    /**
+     * Should the ChannelPublishedEvent be emitted. This is a hack for when certain roku devices become locked up as a result of this event
+     * being emitted. You probably don't need to set this
+     * @default true
+     */
+    emitChannelPublishedEvent?: boolean;
 }
 
 export interface ComponentLibraryConfiguration {

src/RendezvousTracker.spec.ts

@@ -291,6 +291,20 @@ describe('BrightScriptFileUtils ', () => {
             rendezvousTracker['deviceInfo'].softwareVersion = '12.0.1';
             expect(rendezvousTracker.doesHostSupportEcpRendezvousTracking).to.be.true;
         });
+
+        it('does not crash when softwareVersion is corrupt or missing', () => {
+            rendezvousTracker['deviceInfo'].softwareVersion = '';
+            expect(rendezvousTracker.doesHostSupportEcpRendezvousTracking).to.be.false;
+
+            rendezvousTracker['deviceInfo'].softwareVersion = 'notAVersion';
+            expect(rendezvousTracker.doesHostSupportEcpRendezvousTracking).to.be.false;
+
+            rendezvousTracker['deviceInfo'].softwareVersion = undefined;
+            expect(rendezvousTracker.doesHostSupportEcpRendezvousTracking).to.be.false;
+
+            rendezvousTracker['deviceInfo'] = undefined;
+            expect(rendezvousTracker.doesHostSupportEcpRendezvousTracking).to.be.false;
+        });
     });
 
     describe('on', () => {

src/RendezvousTracker.ts

@@ -38,7 +38,11 @@ export class RendezvousTracker {
      * Determine if the current Roku device supports the ECP rendezvous tracking feature
      */
     public get doesHostSupportEcpRendezvousTracking() {
-        return semver.gte(this.deviceInfo.softwareVersion, '11.5.0');
+        let softwareVersion = this.deviceInfo?.softwareVersion;
+        if (!semver.valid(softwareVersion)) {
+            softwareVersion = '0.0.0';
+        }
+        return semver.gte(softwareVersion, '11.5.0');
     }
 
     public logger = logger.createLogger(`[${RendezvousTracker.name}]`);

src/adapters/TelnetAdapter.ts

@@ -5,7 +5,7 @@ import { rokuDeploy } from 'roku-deploy';
 import { PrintedObjectParser } from '../PrintedObjectParser';
 import type { BSDebugDiagnostic } from '../CompileErrorProcessor';
 import { CompileErrorProcessor } from '../CompileErrorProcessor';
-import type { RendezvousHistory, RendezvousTracker } from '../RendezvousTracker';
+import type { RendezvousTracker } from '../RendezvousTracker';
 import type { ChanperfData } from '../ChanperfTracker';
 import { ChanperfTracker } from '../ChanperfTracker';
 import type { SourceLocation } from '../managers/LocationManager';

src/debugSession/BrightScriptDebugSession.spec.ts

@@ -7,17 +7,19 @@ import type { DebugProtocol } from 'vscode-debugprotocol/lib/debugProtocol';
 import { DebugSession } from 'vscode-debugadapter';
 import { BrightScriptDebugSession } from './BrightScriptDebugSession';
 import { fileUtils } from '../FileUtils';
-import type { EvaluateContainer, StackFrame, TelnetAdapter } from '../adapters/TelnetAdapter';
-import { PrimativeType } from '../adapters/TelnetAdapter';
-import { defer } from '../util';
+import type { EvaluateContainer, StackFrame } from '../adapters/TelnetAdapter';
+import { PrimativeType, TelnetAdapter } from '../adapters/TelnetAdapter';
+import { defer, util } from '../util';
 import { HighLevelType } from '../interfaces';
 import type { LaunchConfiguration } from '../LaunchConfiguration';
 import type { SinonStub } from 'sinon';
 import { DiagnosticSeverity, util as bscUtil, standardizePath as s } from 'brighterscript';
-import { DefaultFiles } from 'roku-deploy';
+import { DefaultFiles, rokuDeploy } from 'roku-deploy';
 import type { AddProjectParams, ComponentLibraryConstructorParams } from '../managers/ProjectManager';
 import { ComponentLibraryProject, Project } from '../managers/ProjectManager';
 import { RendezvousTracker } from '../RendezvousTracker';
+import { ClientToServerCustomEventName, isCustomRequestEvent } from './Events';
+import { EventEmitter } from 'eventemitter3';
 
 const sinon = sinonActual.createSandbox();
 const tempDir = s`${__dirname}/../../.tmp`;
@@ -99,10 +101,10 @@ describe('BrightScriptDebugSession', () => {
             }
         };
         rokuAdapter = {
-            on: () => {
-                return () => {
-                };
-            },
+            emitter: new EventEmitter(),
+            on: TelnetAdapter.prototype.on,
+            once: TelnetAdapter.prototype.once,
+            emit: TelnetAdapter.prototype['emit'],
             activate: () => Promise.resolve(),
             registerSourceLocator: (a, b) => { },
             setConsoleOutput: (a) => { },
@@ -148,6 +150,93 @@ describe('BrightScriptDebugSession', () => {
         sinon.restore();
     });
 
+    it('supports external zipping process', async () => {
+        //write some project files
+        fsExtra.outputFileSync(`${rootDir}/source/main.brs`, `
+            sub main()
+                print "hello"
+            end sub
+        `);
+        fsExtra.outputFileSync(`${rootDir}/manifest`, '');
+
+        const packagePath = s`${tempDir}/custom/app.zip`;
+
+        //init the session
+        session.initializeRequest({} as any, {} as any);
+
+        //set a breakpoint in main
+        await session.setBreakPointsRequest({} as any, {
+            source: {
+                path: s`${rootDir}/source/main.brs`
+            },
+            breakpoints: [{
+                line: 2
+            }]
+        });
+
+        sinon.stub(rokuDeploy, 'getDeviceInfo').returns(Promise.resolve({
+            developerEnabled: true
+        }));
+        sinon.stub(util, 'dnsLookup').callsFake((host) => Promise.resolve(host));
+
+        let sendEvent = session.sendEvent.bind(session);
+        sinon.stub(session, 'sendEvent').callsFake((event) => {
+            if (isCustomRequestEvent(event)) {
+                void rokuDeploy.zipFolder(session['launchConfiguration'].stagingDir, packagePath).then(() => {
+                    //pretend we are the client and send a response back
+                    session.emit(ClientToServerCustomEventName.customRequestEventResponse, {
+                        requestId: event.body.requestId
+                    });
+                });
+            } else {
+                //call through
+                return sendEvent(event);
+            }
+        });
+        sinon.stub(session as any, 'connectRokuAdapter').callsFake(() => {
+            sinon.stub(session['rokuAdapter'], 'connect').returns(Promise.resolve());
+            session['rokuAdapter'].connected = true;
+            return Promise.resolve(session['rokuAdapter']);
+        });
+
+        const publishStub = sinon.stub(session.rokuDeploy, 'publish').callsFake(() => {
+            //emit the app-ready event
+            (session['rokuAdapter'] as TelnetAdapter)['emit']('app-ready');
+
+            return Promise.resolve({
+                message: 'success',
+                results: []
+            });
+        });
+
+        await session.launchRequest({} as any, {
+            cwd: tempDir,
+            //where the source files reside
+            rootDir: rootDir,
+            //where roku-debug should put the staged files (and inject breakpoints)
+            stagingDir: `${stagingDir}/staging`,
+            //the name of the task that should be run to create the zip (doesn't matter for this test...we're going to intercept it anyway)
+            packageTask: 'custom-build',
+            //where the packageTask will be placing the compiled zip
+            packagePath: packagePath,
+            packageUploadOverrides: {
+                route: '1234',
+                formData: {
+                    one: 'two',
+                    three: null
+                }
+            }
+        } as Partial<LaunchConfiguration> as LaunchConfiguration);
+
+        expect(publishStub.getCall(0).args[0].packageUploadOverrides).to.eql({
+            route: '1234',
+            formData: {
+                one: 'two',
+                three: null
+            }
+        });
+    });
+
     describe('evaluateRequest', () => {
         it('resets local var counter on suspend', async () => {
             const stub = sinon.stub(session['rokuAdapter'], 'evaluate').callsFake(x => {