Fix issues with install-run on Windows.

Author: iclanton

libraries/rush-lib/src/scripts/install-run.ts

@@ -11,6 +11,7 @@ import * as path from 'node:path';
 import type { IPackageJson } from '@rushstack/node-core-library';
 
 import { syncNpmrc, type ILogger } from '../utilities/npmrcUtilities';
+import { convertCommandAndArgsToShell } from '../utilities/executionUtilities';
 import type { RushConstants } from '../logic/RushConstants';
 
 export const RUSH_JSON_FILENAME: typeof RushConstants.rushJsonFilename = 'rush.json';
@@ -200,15 +201,14 @@ function _resolvePackageVersion(
         stdio: []
       };
       const platformNpmPath: string = _getPlatformPath(npmPath);
-      const npmVersionSpawnResult: childProcess.SpawnSyncReturns<Buffer | string> = childProcess.spawnSync(
-        platformNpmPath,
-        ['view', `${name}@${version}`, 'version', '--no-update-notifier', '--json'],
-        spawnSyncOptions
-      );
-
-      if (npmVersionSpawnResult.status !== 0) {
-        throw new Error(`"npm view" returned error code ${npmVersionSpawnResult.status}`);
-      }
+
+      const npmVersionSpawnResult: childProcess.SpawnSyncReturns<Buffer | string> =
+        _runAsShellCommandAndConfirmSuccess(
+          platformNpmPath,
+          ['view', `${name}@${version}`, 'version', '--no-update-notifier', '--json'],
+          spawnSyncOptions,
+          'npm view'
+        );
 
       const npmViewVersionOutput: string = npmVersionSpawnResult.stdout.toString();
       const parsedVersionOutput: string | string[] = JSON.parse(npmViewVersionOutput);
@@ -355,22 +355,21 @@ function _installPackage(
   packageInstallFolder: string,
   name: string,
   version: string,
-  command: 'install' | 'ci'
+  npmCommand: 'install' | 'ci'
 ): void {
   try {
     logger.info(`Installing ${name}...`);
     const npmPath: string = getNpmPath();
-    const platformNpmPath: string = _getPlatformPath(npmPath);
-    const result: childProcess.SpawnSyncReturns<Buffer> = childProcess.spawnSync(platformNpmPath, [command], {
-      stdio: 'inherit',
-      cwd: packageInstallFolder,
-      env: process.env
-    });
-
-    if (result.status !== 0) {
-      throw new Error(`"npm ${command}" encountered an error`);
-    }
-
+    _runAsShellCommandAndConfirmSuccess(
+      npmPath,
+      [npmCommand],
+      {
+        stdio: 'inherit',
+        cwd: packageInstallFolder,
+        env: process.env
+      },
+      `npm ${npmCommand}`
+    );
     logger.info(`Successfully installed ${name}@${version}`);
   } catch (e) {
     throw new Error(`Unable to install package: ${e}`);
@@ -409,6 +408,40 @@ function _writeFlagFile(packageInstallFolder: string): void {
   }
 }
 
+/**
+ * Run the specified command under the platform's shell and throw if it didn't succeed.
+ */
+function _runAsShellCommandAndConfirmSuccess(
+  command: string,
+  args: string[],
+  options: childProcess.SpawnSyncOptions,
+  commandNameForLogging: string
+): childProcess.SpawnSyncReturns<string | Buffer<ArrayBufferLike>> {
+  if (_isWindows()) {
+    ({ command, args } = convertCommandAndArgsToShell({ command, args }));
+  }
+
+  const result: childProcess.SpawnSyncReturns<string | Buffer<ArrayBufferLike>> = childProcess.spawnSync(
+    command,
+    args,
+    options
+  );
+
+  if (result.status !== 0) {
+    if (result.status === undefined) {
+      if (result.error) {
+        throw new Error(`"${commandNameForLogging}" failed: ${result.error.message.toString()}`);
+      } else {
+        throw new Error(`"${commandNameForLogging}" failed for an unknown reason`);
+      }
+    } else {
+      throw new Error(`"${commandNameForLogging}" returned error code ${result.status}`);
+    }
+  }
+
+  return result;
+}
+
 export function installAndRun(
   logger: ILogger,
   packageName: string,
@@ -456,12 +489,14 @@ export function installAndRun(
   const originalEnvPath: string = process.env.PATH || '';
   let result: childProcess.SpawnSyncReturns<Buffer>;
   try {
-    // `npm` bin stubs on Windows are `.cmd` files
-    // Node.js will not directly invoke a `.cmd` file unless `shell` is set to `true`
-    const platformBinPath: string = _getPlatformPath(binPath);
+    let command: string = binPath;
+    let args: string[] = packageBinArgs;
+    if (_isWindows()) {
+      ({ command, args } = convertCommandAndArgsToShell({ command, args }));
+    }
 
     process.env.PATH = [binFolderPath, originalEnvPath].join(path.delimiter);
-    result = childProcess.spawnSync(platformBinPath, packageBinArgs, {
+    result = childProcess.spawnSync(command, args, {
       stdio: 'inherit',
       windowsVerbatimArguments: false,
       cwd: process.cwd(),
@@ -501,7 +536,8 @@ function _run(): void {
     throw new Error('Unexpected exception: could not detect node path');
   }
 
-  if (path.basename(scriptPath).toLowerCase() !== 'install-run.js') {
+  const scriptFileName: string = path.basename(scriptPath).toLowerCase();
+  if (scriptFileName !== 'install-run.js' && scriptFileName !== 'install-run') {
     // If install-run.js wasn't directly invoked, don't execute the rest of this function. Return control
     // to the script that (presumably) imported this file
 

libraries/rush-lib/src/utilities/Utilities.ts

@@ -24,6 +24,7 @@ import type { RushConfiguration } from '../api/RushConfiguration';
 import { syncNpmrc } from './npmrcUtilities';
 import { EnvironmentVariableNames } from '../api/EnvironmentConfiguration';
 import { RushConstants } from '../logic/RushConstants';
+import { convertCommandAndArgsToShell } from './executionUtilities';
 
 export type UNINITIALIZED = 'UNINITIALIZED';
 // eslint-disable-next-line @typescript-eslint/no-redeclare
@@ -178,11 +179,6 @@ type IExecuteCommandInternalOptions = Omit<IExecuteCommandOptions, 'suppressOutp
   captureOutput: boolean;
 };
 
-interface ICommandAndArgs {
-  command: string;
-  args: string[];
-}
-
 export class Utilities {
   public static syncNpmrc: typeof syncNpmrc = syncNpmrc;
 
@@ -691,7 +687,7 @@ export class Utilities {
       Object.assign(spawnOptions, SubprocessTerminator.RECOMMENDED_OPTIONS);
     }
 
-    const { command, args } = Utilities._convertCommandAndArgsToShell(commandAndArgs);
+    const { command, args } = convertCommandAndArgsToShell(commandAndArgs);
     return spawnFunction(command, args, spawnOptions);
   }
 
@@ -832,7 +828,7 @@ export class Utilities {
     };
 
     if (shell) {
-      ({ command, args } = Utilities._convertCommandAndArgsToShell({ command, args }));
+      ({ command, args } = convertCommandAndArgsToShell({ command, args }));
     }
 
     const childProcess: child_process.ChildProcess = child_process.spawn(command, args, options);
@@ -884,31 +880,4 @@ export class Utilities {
       throw new Error(`The command failed with exit code ${status}\n${stderr}`);
     }
   }
-
-  private static _convertCommandAndArgsToShell(command: string): ICommandAndArgs;
-  private static _convertCommandAndArgsToShell(options: ICommandAndArgs): ICommandAndArgs;
-  private static _convertCommandAndArgsToShell(options: ICommandAndArgs | string): ICommandAndArgs {
-    let shellCommand: string;
-    let commandFlags: string[];
-    if (process.platform !== 'win32') {
-      shellCommand = 'sh';
-      commandFlags = ['-c'];
-    } else {
-      shellCommand = process.env.comspec || 'cmd';
-      commandFlags = ['/d', '/s', '/c'];
-    }
-
-    let commandToRun: string;
-    if (typeof options === 'string') {
-      commandToRun = options;
-    } else {
-      const { command, args } = options;
-      commandToRun = [command, ...args].join(' ');
-    }
-
-    return {
-      command: shellCommand,
-      args: [...commandFlags, commandToRun]
-    };
-  }
 }

libraries/rush-lib/src/utilities/executionUtilities.ts

@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+
+export interface ICommandAndArgs {
+  command: string;
+  args: string[];
+}
+
+export function convertCommandAndArgsToShell(command: string): ICommandAndArgs;
+export function convertCommandAndArgsToShell(options: ICommandAndArgs): ICommandAndArgs;
+export function convertCommandAndArgsToShell(options: ICommandAndArgs | string): ICommandAndArgs {
+  let shellCommand: string;
+  let commandFlags: string[];
+  if (process.platform !== 'win32') {
+    shellCommand = 'sh';
+    commandFlags = ['-c'];
+  } else {
+    shellCommand = process.env.comspec || 'cmd';
+    commandFlags = ['/d', '/s', '/c'];
+  }
+
+  let commandToRun: string;
+  if (typeof options === 'string') {
+    commandToRun = options;
+  } else {
+    const { command, args } = options;
+    commandToRun = [command, ...args].join(' ');
+  }
+
+  return {
+    command: shellCommand,
+    args: [...commandFlags, commandToRun]
+  };
+}