Handle Corrupt Install Script Installs (#2235)

* Check if the dotnet install is valid

The dotnet install script has a bug where it wont do the install if the folder is not empty. Sometimes it will leave a partially done install, like if killed, in which case we get to a bad state.

This fixes that by cleaning up the directory, and or checking if dotnet.exe exists, whether it works.
dotnet --list-runtimes is a fast way to do this since it should only invoke the host and not need to invoke the SDK. doing just 'dotnet' will not work as that does not return 0.

Also, gets rid of the 'lock' exception since thats from the proper-lockfile lib which we don't use anymore.

Resolves: #2059
First scrapped attempt: #2106

* Add missing await

* Recursively delete the stuff

wipe dir only wipes the files, and the script looks at the folders

* Remove tests for deprecated code

The Install Multiple versions tests fails bc the deprecated sdk code installs everything into the same folder, so this new cleanup logic will wipe the older folder.

The uninstall logic fails because the original sdk code does not work with respect to finding a local sdk when a global sdk is on the machine (it finds a 7.0.4xx sdk), this code is not used by anything anymore so it is likely not worth investigating.

* Update changelog

* Changelog should mention min vscode version

* Check if dotnet meets the requirement of the install

Author: nagilson

vscode-dotnet-runtime-extension/CHANGELOG.md

@@ -7,10 +7,14 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
-## [2.3.3] - 2025-4
+## [2.3.3] - 2025-4-13
 
 - Performance improvements.
-- Fixes to locking issues, with listen errors.
+- No longer utilizes chcp to try to force dotnet --info to output in english for internal parsing (perf)
+- Checks dotnet from --list-runtimes before checking the PATH to locate dotnet faster in the common case.
+- Fixes for when the install script leaves behind a corrupt install.
+- Fixes to locking issues on darwin when the temp file system is locked.
+- Bumps minimum VS Code version requirement to ensure running on nodejs 20 -- solves previous crypto errors for older versions of vscode.
 
 ## [2.3.2] - 2025-4-10
 

vscode-dotnet-runtime-extension/src/test/functional/DotnetCoreAcquisitionExtension.test.ts

@@ -326,6 +326,23 @@ suite('DotnetCoreAcquisitionExtension End to End', function ()
         await installMultipleVersions(['2.2', '3.0', '3.1'], 'aspnetcore');
     }).timeout(standardTimeoutTime * 2);
 
+    test('Works With Prior Incomplete or Corrupted Install', async () =>
+    {
+        const installPath = await installRuntime('9.0', 'runtime');
+        assert.isTrue(fs.existsSync(installPath), 'The path exists after install');
+        // remove the install executable but not the folder to simulate a corrupt install
+        rimraf.sync(installPath);
+        assert.isFalse(fs.existsSync(installPath), 'The path does not exist after uninstall');
+        // try to acquire again, and it should succeed
+        const _ = await installRuntime('9.0', 'runtime');
+    }).timeout(standardTimeoutTime);
+
+    test('It works if the install exists', async () =>
+    {
+        const installPath = await installRuntime('9.0', 'runtime');
+        const samePath = await installRuntime('9.0', 'runtime');
+    }).timeout(standardTimeoutTime);
+
     test('Find dotnet PATH Command Met Condition', async () =>
     {
         // install 5.0 then look for 5.0 path

vscode-dotnet-runtime-library/src/Acquisition/AcquisitionInvoker.ts

@@ -3,6 +3,7 @@
 *  The .NET Foundation licenses this file to you under the MIT license.
 *--------------------------------------------------------------------------------------------*/
 import * as cp from 'child_process';
+import * as fs from 'fs';
 import * as os from 'os';
 import path = require('path');
 
@@ -20,6 +21,7 @@ import
     EventBasedError,
     PowershellBadExecutionPolicy,
     PowershellBadLanguageMode,
+    SuppressedAcquisitionError,
 } from '../EventStream/EventStreamEvents';
 
 import { TelemetryUtilities } from '../EventStream/TelemetryUtilities';
@@ -29,9 +31,10 @@ import { FileUtilities } from '../Utils/FileUtilities';
 import { InstallScriptAcquisitionWorker } from './InstallScriptAcquisitionWorker';
 
 import { IUtilityContext } from '../Utils/IUtilityContext';
-import { executeWithLock } from '../Utils/TypescriptUtilities';
+import { executeWithLock, getDotnetExecutable } from '../Utils/TypescriptUtilities';
 import { WebRequestWorkerSingleton } from '../Utils/WebRequestWorkerSingleton';
 import { LOCAL_LOCK_PING_DURATION_MS } from './CacheTimeConstants';
+import { DotnetConditionValidator } from './DotnetConditionValidator';
 import { DotnetInstall } from './DotnetInstall';
 import { DotnetInstallMode } from './DotnetInstallMode';
 import { IAcquisitionInvoker } from './IAcquisitionInvoker';
@@ -76,6 +79,30 @@ You will need to restart VS Code after these changes. If PowerShell is still not
                             windowsFullCommand = windowsFullCommand.replace('powershell.exe', powershellReference);
                         }
 
+                        // The install script can leave behind a directory in an invalid install state. Make sure the executable is present at the very least.
+                        if (await this.fileUtilities.exists(installContext.installDir))
+                        {
+                            const dotnetPath = path.join(installContext.installDir, getDotnetExecutable());
+                            if (await this.fileUtilities.exists(dotnetPath))
+                            {
+                                const validator = new DotnetConditionValidator(this.workerContext, this.utilityContext);
+                                const meetsRequirement = await validator.dotnetMeetsRequirement(dotnetPath, { acquireContext: installContext, versionSpecRequirement: 'equal' });
+                                if (meetsRequirement)
+                                {
+                                    return resolve();
+                                }
+                            }
+
+                            try
+                            {
+                                await fs.promises.rm(installContext.installDir, { recursive: true, force: true });
+                            }
+                            catch (err: any)
+                            {
+                                this.eventStream.post(new SuppressedAcquisitionError(err, `${installContext.installDir} could not be not removed, and it has a corrupted install. Please remove it manually.`));
+                            }
+                        }
+
                         cp.exec(winOS ? windowsFullCommand : installCommand,
                             { cwd: process.cwd(), maxBuffer: 500 * 1024, timeout: 1000 * installContext.timeoutSeconds, killSignal: 'SIGKILL' },
                             async (error, stdout, stderr) =>

vscode-dotnet-runtime-library/src/Utils/FileUtilities.ts

@@ -81,7 +81,7 @@ export class FileUtilities extends IFileUtilities
             try
             {
                 eventStream?.post(new FileToWipe(`The file ${f} may be deleted.`))
-                if (!fileExtensionsToDelete || fileExtensionsToDelete?.includes(path.extname(f).toLocaleLowerCase()) && !(f?.includes('lock')))
+                if (!fileExtensionsToDelete || fileExtensionsToDelete?.includes(path.extname(f).toLocaleLowerCase()))
                 {
                     eventStream?.post(new FileToWipe(`The file ${f} is being deleted -- if no error is reported, it should be wiped.`))
                     await fs.promises.rm(path.join(directoryToWipe, f));

vscode-dotnet-sdk-extension/src/test/functional/DotnetCoreAcquisitionExtension.test.ts

@@ -304,49 +304,6 @@ suite('DotnetCoreAcquisitionExtension End to End', function ()
       await vscode.commands.executeCommand('dotnet-sdk.uninstallAll');
     }).timeout(standardTimeoutTime);
 
-    test('Uninstall Command', async () =>
-    {
-      const context: IDotnetAcquireContext = { version: '3.1', requestingExtensionId: 'ms-dotnettools.sample-extension' };
-      const result = await vscode.commands.executeCommand<IDotnetAcquireResult>('dotnet-sdk.acquire', context);
-      assert.exists(result);
-      assert.exists(result!.dotnetPath);
-      const sdkDir = fs.readdirSync(path.join(path.dirname(result!.dotnetPath), 'sdk'))[0];
-      assert.include(sdkDir, context.version);
-      assert.isTrue(fs.existsSync(result!.dotnetPath!));
-      await vscode.commands.executeCommand('dotnet-sdk.uninstallAll');
-      assert.isFalse(fs.existsSync(result!.dotnetPath));
-    }).timeout(standardTimeoutTime);
-
-    test('Install Multiple Versions', async () =>
-    {
-      // Install 6.0
-      let version = currentSDKVersion;
-      let result = await vscode.commands.executeCommand<IDotnetAcquireResult>('dotnet-sdk.acquire', { version, requestingExtensionId: 'ms-dotnettools.sample-extension' });
-      assert.exists(result, 'basic install works');
-      assert.exists(result!.dotnetPath, 'basic install has path');
-      let sdkDirs = fs.readdirSync(path.join(path.dirname(result!.dotnetPath), 'sdk'));
-      assert.isNotEmpty(sdkDirs.filter(dir => dir.includes(version)), `sdk directories include version?
-PATH: ${result!.dotnetPath}
-PATH SUBDIRECTORIES: ${fs.readdirSync(path.dirname(result!.dotnetPath))}
-SDK SUBDIRECTORIES: ${sdkDirs}
-VERSION: ${version}`);
-
-      // Install 5.0
-      version = '5.0';
-      result = await vscode.commands.executeCommand<IDotnetAcquireResult>('dotnet-sdk.acquire', { version, requestingExtensionId: 'ms-dotnettools.sample-extension' });
-      assert.exists(result, 'acquire works a 2nd time');
-      assert.exists(result!.dotnetPath, 'acquire returns a path a 2nd time');
-      sdkDirs = fs.readdirSync(path.join(path.dirname(result!.dotnetPath), 'sdk'));
-      assert.isNotEmpty(sdkDirs.filter(dir => dir.includes(version)), 'acquire sdk twice does not overwrite');
-
-      sdkDirs = fs.readdirSync(path.join(path.dirname(result!.dotnetPath), 'sdk'));
-      assert.isNotEmpty(sdkDirs.filter(dir => dir.includes(currentSDKVersion)), 'directories include a version.');
-      assert.isNotEmpty(sdkDirs.filter(dir => dir.includes('5.0')), 'old directories are preserved');
-
-      // Clean up storage
-      await vscode.commands.executeCommand('dotnet-sdk.uninstallAll');
-    }).timeout(standardTimeoutTime * 6);
-
     test('Extension Uninstall Removes SDKs', async () =>
     {
       const context: IDotnetAcquireContext = { version: currentSDKVersion, requestingExtensionId: 'ms-dotnettools.sample-extension' };