Add isOptional field to packages and handle optional package failures

Co-authored-by: JoeRobich <611219+JoeRobich@users.noreply.github.com>

Author: Copilot

src/packageManager/IPackage.ts

@@ -13,4 +13,5 @@ export interface IPackage {
     platformId?: string;
     integrity?: string;
     isFramework?: boolean;
+    isOptional?: boolean;
 }

src/packageManager/absolutePathPackage.ts

@@ -20,7 +20,8 @@ export class AbsolutePathPackage implements IPackage {
         public fallbackUrl?: string,
         public platformId?: string,
         public integrity?: string,
-        public isFramework?: boolean
+        public isFramework?: boolean,
+        public isOptional?: boolean
     ) {}
 
     public static getAbsolutePathPackage(pkg: Package, extensionPath: string) {
@@ -36,7 +37,8 @@ export class AbsolutePathPackage implements IPackage {
             pkg.fallbackUrl,
             pkg.platformId,
             pkg.integrity,
-            pkg.isFramework
+            pkg.isFramework,
+            pkg.isOptional
         );
     }
 }

src/packageManager/downloadAndInstallPackages.ts

@@ -61,6 +61,11 @@ export async function downloadAndInstallPackages(
                 eventStream.post(new InstallationFailure(installationStage, error));
             }
 
+            // If the package is optional, log and continue with the next package
+            if (pkg.isOptional) {
+                continue;
+            }
+
             return false;
         } finally {
             try {

test/omnisharp/omnisharpUnitTests/packages/downloadAndInstallPackages.test.ts

@@ -218,6 +218,79 @@ describe(`${downloadAndInstallPackages.name}`, () => {
         });
     });
 
+    describe('Optional packages', () => {
+        test('Returns true and continues when an optional package fails to download', async () => {
+            const optionalPackage = <AbsolutePathPackage[]>[
+                {
+                    url: `${server.baseUrl}/notDownloadablePackage`,
+                    description: 'Optional Package',
+                    installPath: new AbsolutePath(tmpDirPath),
+                    isOptional: true,
+                },
+            ];
+
+            const result = await downloadAndInstallPackages(
+                optionalPackage,
+                networkSettingsProvider,
+                eventStream,
+                downloadValidator
+            );
+            expect(result).toBe(true);
+        });
+
+        test('Continues to install remaining packages after optional package fails', async () => {
+            const tmpInstallDir2 = await CreateTmpDir(true);
+            const mixedPackages = <AbsolutePathPackage[]>[
+                {
+                    url: `${server.baseUrl}/notDownloadablePackage`,
+                    description: 'Optional Package',
+                    installPath: new AbsolutePath(tmpDirPath),
+                    isOptional: true,
+                },
+                {
+                    url: `${server.baseUrl}/downloadablePackage`,
+                    description: packageDescription,
+                    installPath: new AbsolutePath(tmpInstallDir2.name),
+                },
+            ];
+
+            const result = await downloadAndInstallPackages(
+                mixedPackages,
+                networkSettingsProvider,
+                eventStream,
+                downloadValidator
+            );
+            expect(result).toBe(true);
+            expect(await util.fileExists(path.join(tmpInstallDir2.name, 'install.Lock'))).toBe(true);
+            tmpInstallDir2.dispose();
+        });
+
+        test('InstallationFailure event is logged for optional package', async () => {
+            const optionalPackage = <AbsolutePathPackage[]>[
+                {
+                    url: `${server.baseUrl}/notDownloadablePackage`,
+                    description: 'Optional Package',
+                    installPath: new AbsolutePath(tmpDirPath),
+                    isOptional: true,
+                },
+            ];
+
+            eventBus.getEvents(); // Clear any previous events
+            await downloadAndInstallPackages(
+                optionalPackage,
+                networkSettingsProvider,
+                eventStream,
+                downloadValidator
+            );
+            const obtainedEvents = eventBus.getEvents();
+            const installationFailureEvent = obtainedEvents.find(
+                (event) => event instanceof InstallationFailure
+            ) as InstallationFailure;
+            expect(installationFailureEvent).toBeDefined();
+            expect(installationFailureEvent.stage).toEqual('downloadPackage');
+        });
+    });
+
     afterEach(async () => {
         if (tmpInstallDir) {
             tmpInstallDir.dispose();