Check to make sure default npm exists at path before trying to use it (#30910)

* Check to make sure default npm exists at path before trying to use it

**Bug**
If the typings installer is run under a copy of node that does not include npm—but on a machine that does have npm installed—it will incorrectly try to use the npm that does not exist next to its running version of node

**Fix**
Make sure that we check that npm we select exists before trying to use it as the default. Otherwise, fall back to using plain old `npm`

* Add command line flag to gate new behavior

* Fix missing semicolon

Author: mjbvz

src/jsTyping/shared.ts

@@ -21,6 +21,11 @@ namespace ts.server {
          * typingsInstaller will run the command with `${npmLocation} install ...`.
          */
         export const NpmLocation = "--npmLocation";
+        /**
+         * Flag indicating that the typings installer should try to validate the default npm location.
+         * If the default npm is not found when this flag is enabled, fallback to `npm install`
+         */
+        export const ValidateDefaultNpmLocation = "--validateDefaultNpmLocation";
     }
 
     export function hasArgument(argumentName: string) {

src/tsserver/server.ts

@@ -242,6 +242,7 @@ namespace ts.server {
             readonly typingSafeListLocation: string,
             readonly typesMapLocation: string,
             private readonly npmLocation: string | undefined,
+            private readonly validateDefaultNpmLocation: boolean,
             private event: Event) {
         }
 
@@ -297,6 +298,9 @@ namespace ts.server {
             if (this.npmLocation) {
                 args.push(Arguments.NpmLocation, this.npmLocation);
             }
+            if (this.validateDefaultNpmLocation) {
+                args.push(Arguments.ValidateDefaultNpmLocation);
+            }
 
             const execArgv: string[] = [];
             for (const arg of process.execArgv) {
@@ -497,7 +501,7 @@ namespace ts.server {
 
             const typingsInstaller = disableAutomaticTypingAcquisition
                 ? undefined
-                : new NodeTypingsInstaller(telemetryEnabled, logger, host, getGlobalTypingsCacheLocation(), typingSafeListLocation, typesMapLocation, npmLocation, event);
+                : new NodeTypingsInstaller(telemetryEnabled, logger, host, getGlobalTypingsCacheLocation(), typingSafeListLocation, typesMapLocation, npmLocation, validateDefaultNpmLocation, event);
 
             super({
                 host,
@@ -933,6 +937,7 @@ namespace ts.server {
     const typingSafeListLocation = findArgument(Arguments.TypingSafeListLocation)!; // TODO: GH#18217
     const typesMapLocation = findArgument(Arguments.TypesMapLocation) || combinePaths(getDirectoryPath(sys.getExecutingFilePath()), "typesMap.json");
     const npmLocation = findArgument(Arguments.NpmLocation);
+    const validateDefaultNpmLocation = hasArgument(Arguments.ValidateDefaultNpmLocation);
 
     function parseStringArray(argName: string): ReadonlyArray<string> {
         const arg = findArgument(argName);

src/typingsInstaller/nodeTypingsInstaller.ts

@@ -29,13 +29,17 @@ namespace ts.server.typingsInstaller {
     }
 
     /** Used if `--npmLocation` is not passed. */
-    function getDefaultNPMLocation(processName: string) {
+    function getDefaultNPMLocation(processName: string, validateDefaultNpmLocation: boolean, host: InstallTypingHost): string {
         if (path.basename(processName).indexOf("node") === 0) {
-            return `"${path.join(path.dirname(process.argv[0]), "npm")}"`;
-        }
-        else {
-            return "npm";
+            const npmPath = path.join(path.dirname(process.argv[0]), "npm");
+            if (!validateDefaultNpmLocation) {
+                return npmPath;
+            }
+            if (host.fileExists(npmPath)) {
+                return `"${npmPath}"`;
+            }
         }
+        return "npm";
     }
 
     interface TypesRegistryFile {
@@ -79,15 +83,15 @@ namespace ts.server.typingsInstaller {
 
         private delayedInitializationError: InitializationFailedResponse | undefined;
 
-        constructor(globalTypingsCacheLocation: string, typingSafeListLocation: string, typesMapLocation: string, npmLocation: string | undefined, throttleLimit: number, log: Log) {
+        constructor(globalTypingsCacheLocation: string, typingSafeListLocation: string, typesMapLocation: string, npmLocation: string | undefined, validateDefaultNpmLocation: boolean, throttleLimit: number, log: Log) {
             super(
                 sys,
                 globalTypingsCacheLocation,
                 typingSafeListLocation ? toPath(typingSafeListLocation, "", createGetCanonicalFileName(sys.useCaseSensitiveFileNames)) : toPath("typingSafeList.json", __dirname, createGetCanonicalFileName(sys.useCaseSensitiveFileNames)),
                 typesMapLocation ? toPath(typesMapLocation, "", createGetCanonicalFileName(sys.useCaseSensitiveFileNames)) : toPath("typesMap.json", __dirname, createGetCanonicalFileName(sys.useCaseSensitiveFileNames)),
                 throttleLimit,
                 log);
-            this.npmPath = npmLocation !== undefined ? npmLocation : getDefaultNPMLocation(process.argv[0]);
+            this.npmPath = npmLocation !== undefined ? npmLocation : getDefaultNPMLocation(process.argv[0], validateDefaultNpmLocation, this.installTypingHost);
 
             // If the NPM path contains spaces and isn't wrapped in quotes, do so.
             if (stringContains(this.npmPath, " ") && this.npmPath[0] !== `"`) {
@@ -96,6 +100,7 @@ namespace ts.server.typingsInstaller {
             if (this.log.isEnabled()) {
                 this.log.writeLine(`Process id: ${process.pid}`);
                 this.log.writeLine(`NPM location: ${this.npmPath} (explicit '${Arguments.NpmLocation}' ${npmLocation === undefined ? "not " : ""} provided)`);
+                this.log.writeLine(`validateDefaultNpmLocation: ${validateDefaultNpmLocation}`);
             }
             ({ execSync: this.nodeExecSync } = require("child_process"));
 
@@ -229,6 +234,7 @@ namespace ts.server.typingsInstaller {
     const typingSafeListLocation = findArgument(Arguments.TypingSafeListLocation);
     const typesMapLocation = findArgument(Arguments.TypesMapLocation);
     const npmLocation = findArgument(Arguments.NpmLocation);
+    const validateDefaultNpmLocation = hasArgument(Arguments.ValidateDefaultNpmLocation);
 
     const log = new FileLog(logFilePath);
     if (log.isEnabled()) {
@@ -242,7 +248,7 @@ namespace ts.server.typingsInstaller {
         }
         process.exit(0);
     });
-    const installer = new NodeTypingsInstaller(globalTypingsCacheLocation!, typingSafeListLocation!, typesMapLocation!, npmLocation, /*throttleLimit*/5, log); // TODO: GH#18217
+    const installer = new NodeTypingsInstaller(globalTypingsCacheLocation!, typingSafeListLocation!, typesMapLocation!, npmLocation, validateDefaultNpmLocation, /*throttleLimit*/5, log); // TODO: GH#18217
     installer.listen();
 
     function indent(newline: string, str: string): string {