isaacscript 1.2.2 → 1.2.5

package/src/commands/init/init.ts

@@ -13,15 +13,18 @@ import { promptSaveSlot } from "./promptSaveSlot";
 import { promptVSCode } from "./promptVSCode";
 
 export async function init(argv: Record<string, unknown>): Promise<void> {
+  const vscode = argv.vscode === true;
+  const skipNPMInstall = argv.skipNpmInstall === true;
+  const verbose = argv.verbose === true;
+
   // Prompt the end-user for some information (and validate it as we go)
   const [projectPath, createNewDir] = await getProjectPath(argv);
-  await checkIfProjectPathExists(projectPath);
+  await checkIfProjectPathExists(projectPath, verbose);
   const modsDirectory = await getModsDir(argv);
   checkModSubdirectory(projectPath, modsDirectory);
   const projectName = path.basename(projectPath);
-  await checkModTargetDirectory(modsDirectory, projectName);
+  await checkModTargetDirectory(modsDirectory, projectName, verbose);
   const saveSlot = await promptSaveSlot(argv);
-  const skipNPMInstall = argv.skipNpmInstall === true;
 
   await createMod(
     projectName,
@@ -30,12 +33,17 @@ export async function init(argv: Record<string, unknown>): Promise<void> {
     modsDirectory,
     saveSlot,
     skipNPMInstall,
+    verbose,
   );
-  await openVSCode(projectPath, argv);
+  await openVSCode(projectPath, vscode, verbose);
   printFinishMessage(projectPath, projectName);
 }
 
-async function openVSCode(projectPath: string, argv: Record<string, unknown>) {
+async function openVSCode(
+  projectPath: string,
+  vscode: boolean,
+  verbose: boolean,
+) {
   const VSCodeCommand = getVSCodeCommand();
   if (VSCodeCommand === null) {
     console.log(
@@ -44,8 +52,8 @@ async function openVSCode(projectPath: string, argv: Record<string, unknown>) {
     return;
   }
 
-  installVSCodeExtensions(projectPath, VSCodeCommand);
-  await promptVSCode(projectPath, argv, VSCodeCommand);
+  installVSCodeExtensions(projectPath, VSCodeCommand, verbose);
+  await promptVSCode(projectPath, VSCodeCommand, vscode, verbose);
 }
 
 function getVSCodeCommand() {

package/src/commands/init/installVSCodeExtensions.ts

@@ -1,16 +1,18 @@
 import chalk from "chalk";
 import * as JSONC from "jsonc-parser";
 import path from "path";
+import { execShell } from "../../exec";
 import * as file from "../../file";
-import { error, execShell } from "../../util";
+import { error } from "../../util";
 
 export function installVSCodeExtensions(
   projectPath: string,
   VSCodeCommand: string,
+  verbose: boolean,
 ): void {
   const extensions = getExtensionsFromJSON(projectPath);
   for (const extensionName of extensions) {
-    execShell(VSCodeCommand, ["--install-extension", extensionName]);
+    execShell(VSCodeCommand, ["--install-extension", extensionName], verbose);
   }
 }
 

package/src/commands/init/promptVSCode.ts

@@ -1,17 +1,18 @@
 import path from "path";
 import { MAIN_TS } from "../../constants";
+import { execShell } from "../../exec";
 import { getInputYesNo } from "../../prompt";
-import { execShell } from "../../util";
 
 export async function promptVSCode(
   projectPath: string,
-  argv: Record<string, unknown>,
   VSCodeCommand: string,
+  vscode: boolean,
+  verbose: boolean,
 ): Promise<void> {
-  if (argv.vscode !== undefined) {
+  if (vscode) {
     // They supplied the "--vscode" command-line flag,
     // so there is no need to prompt the user
-    openVSCode(projectPath, VSCodeCommand);
+    openVSCode(projectPath, VSCodeCommand, verbose);
     return;
   }
 
@@ -19,11 +20,15 @@ export async function promptVSCode(
     "Do you want to open your new project in VSCode now?",
   );
   if (shouldOpenVSCode) {
-    openVSCode(projectPath, VSCodeCommand);
+    openVSCode(projectPath, VSCodeCommand, verbose);
   }
 }
 
-function openVSCode(projectPath: string, VSCodeCommand: string) {
+function openVSCode(
+  projectPath: string,
+  VSCodeCommand: string,
+  verbose: boolean,
+) {
   const MAIN_TS_PATH = path.join(projectPath, "src", MAIN_TS);
-  execShell(VSCodeCommand, [projectPath, MAIN_TS_PATH]);
+  execShell(VSCodeCommand, [projectPath, MAIN_TS_PATH], verbose);
 }

package/src/commands/monitor/copyWatcherMod.ts

@@ -8,7 +8,7 @@ import {
 import * as file from "../../file";
 import { Config } from "../../types/Config";
 
-export function copyWatcherMod(config: Config): void {
+export function copyWatcherMod(config: Config, verbose: boolean): void {
   // Check to see if this mod was disabled
   const watcherModPath = path.join(config.modsDirectory, WATCHER_MOD_NAME);
   const disableItPath = path.join(watcherModPath, DISABLE_IT_FILE);
@@ -17,21 +17,21 @@ export function copyWatcherMod(config: Config): void {
   // Delete and re-copy the watcher mod every time IsaacScript starts
   // This ensures that it is always the latest version
   if (file.exists(watcherModPath)) {
-    file.deleteFileOrDirectory(watcherModPath);
+    file.deleteFileOrDirectory(watcherModPath, verbose);
   }
 
-  file.copy(WATCHER_MOD_SOURCE_PATH, watcherModPath);
+  file.copy(WATCHER_MOD_SOURCE_PATH, watcherModPath, verbose);
 
   if (watcherModDisabled) {
     // Since we deleted the directory, the "disable.it" file was deleted
     // Restore it
-    file.write(disableItPath, "");
+    file.write(disableItPath, "", verbose);
   }
 
   // By default, the IsaacScript watcher mod automatically restarts the game,
   // so we only need to disable it if the config option is explicitly set to false
   if (config.enableIsaacScriptWatcherAutoRestart === false) {
-    disableIsaacScriptWatcherAutomaticRestart(watcherModPath);
+    disableIsaacScriptWatcherAutomaticRestart(watcherModPath, verbose);
   }
 
   // If we copied a new version of the watcher mod into place,
@@ -40,7 +40,10 @@ export function copyWatcherMod(config: Config): void {
   // so there is no automated solution for this
 }
 
-function disableIsaacScriptWatcherAutomaticRestart(watcherModPath: string) {
+function disableIsaacScriptWatcherAutomaticRestart(
+  watcherModPath: string,
+  verbose: boolean,
+) {
   const mainLuaPath = path.join(watcherModPath, MAIN_LUA);
   const mainLua = file.read(mainLuaPath);
 
@@ -49,5 +52,5 @@ function disableIsaacScriptWatcherAutomaticRestart(watcherModPath: string) {
     "local RESTART_GAME_ON_RECOMPILATION = false",
   );
 
-  file.write(mainLuaPath, modifiedMainLua);
+  file.write(mainLuaPath, modifiedMainLua, verbose);
 }

package/src/commands/monitor/monitor.ts

@@ -19,6 +19,8 @@ import { spawnSaveDatWriter } from "./spawnSaveDatWriter";
 import { touchWatcherSaveDatFiles } from "./touchWatcherSaveDatFiles";
 
 export function monitor(argv: Record<string, unknown>, config: Config): void {
+  const verbose = argv.verbose === true;
+
   // If they specified some command-line flags, override the values found in the config file
   if (argv.modsDirectory !== undefined) {
     config.modsDirectory = argv.modsDirectory as string; // eslint-disable-line no-param-reassign
@@ -34,13 +36,13 @@ export function monitor(argv: Record<string, unknown>, config: Config): void {
   const modTargetPath = path.join(config.modsDirectory, modTargetDirectoryName);
 
   // Prepare the IsaacScript watcher mod
-  copyWatcherMod(config);
-  touchWatcherSaveDatFiles(config);
+  copyWatcherMod(config, verbose);
+  touchWatcherSaveDatFiles(config, verbose);
 
   // Delete and re-copy the mod every time IsaacScript starts
   // This ensures that it is always the latest version
   if (file.exists(modTargetPath)) {
-    file.deleteFileOrDirectory(modTargetPath);
+    file.deleteFileOrDirectory(modTargetPath, true);
   }
 
   // Subprocess #1 - The "save#.dat" file writer

package/src/commands/monitor/saveDatWriter/saveDatWriter.ts

@@ -27,7 +27,7 @@ function init() {
   // Check to see if the data directory exists
   const watcherModDataPath = path.dirname(saveDatPath);
   if (!file.exists(watcherModDataPath)) {
-    file.makeDir(watcherModDataPath);
+    file.makeDir(watcherModDataPath, false);
   }
 
   // Listen for messages from the parent process

package/src/commands/monitor/touchWatcherSaveDatFiles.ts

@@ -3,15 +3,18 @@ import { WATCHER_MOD_NAME } from "../../constants";
 import * as file from "../../file";
 import { Config } from "../../types/Config";
 
-export function touchWatcherSaveDatFiles(config: Config): void {
+export function touchWatcherSaveDatFiles(
+  config: Config,
+  verbose: boolean,
+): void {
   const modsDataPath = path.join(config.modsDirectory, "..", "data");
   const watcherModDataPath = path.join(modsDataPath, WATCHER_MOD_NAME);
   if (!file.exists(watcherModDataPath)) {
-    file.makeDir(watcherModDataPath);
+    file.makeDir(watcherModDataPath, verbose);
   }
   const saveDatFileName = `save${config.saveSlot}.dat`;
   const saveDatPath = path.join(watcherModDataPath, saveDatFileName);
   if (!file.exists(saveDatPath)) {
-    file.touch(saveDatPath);
+    file.touch(saveDatPath, verbose);
   }
 }

package/src/commands/publish/publish.ts

@@ -12,15 +12,10 @@ import {
   PUBLISH_PRE_COPY_PY_PATH,
   VERSION_TXT_PATH,
 } from "../../constants";
+import { execExe, execShell } from "../../exec";
 import * as file from "../../file";
 import { Config } from "../../types/Config";
-import {
-  error,
-  execExe,
-  execShell,
-  getModTargetDirectoryName,
-  parseIntSafe,
-} from "../../util";
+import { error, getModTargetDirectoryName, parseIntSafe } from "../../util";
 import { compileAndCopy } from "../copy/copy";
 
 const UPDATE_SCRIPT_NAME = "update.sh";
@@ -30,6 +25,7 @@ export function publish(argv: Record<string, unknown>, config: Config): void {
   const setVersion = argv.setVersion as string | undefined;
   const dryRun = argv.dryRun === true;
   const onlyUpload = argv.onlyUpload === true;
+  const verbose = argv.verbose === true;
 
   const modTargetDirectoryName = getModTargetDirectoryName(config);
   const modTargetPath = path.join(config.modsDirectory, modTargetDirectoryName);
@@ -43,7 +39,7 @@ export function publish(argv: Record<string, unknown>, config: Config): void {
   }
 
   if (onlyUpload) {
-    uploadMod(modTargetPath, config.steamCmdPath);
+    uploadMod(modTargetPath, config.steamCmdPath, verbose);
     return;
   }
 
@@ -54,6 +50,7 @@ export function publish(argv: Record<string, unknown>, config: Config): void {
     setVersion,
     config.steamCmdPath,
     dryRun,
+    verbose,
   );
 }
 
@@ -64,42 +61,43 @@ function startPublish(
   setVersion: string | undefined,
   steamCmdPath: string | undefined,
   dryRun: boolean,
+  verbose: boolean,
 ) {
-  updateDeps();
+  updateDeps(verbose);
 
   let version =
     setVersion === undefined ? getVersionFromPackageJSON() : setVersion;
   if (!skipVersionIncrement && setVersion === undefined) {
-    version = bumpVersionInPackageJSON(version);
+    version = bumpVersionInPackageJSON(version, verbose);
   } else if (setVersion !== undefined) {
-    writeVersionInPackageJSON(version);
+    writeVersionInPackageJSON(version, verbose);
   }
 
-  writeVersionToConstantsTS(version);
-  writeVersionToMetadataXML(version);
-  writeVersionToVersionTXT(version);
-  runReleaseScriptPreCopy();
-  compileAndCopy(modSourcePath, modTargetPath);
-  purgeRoomXMLs(modTargetPath);
-  runReleaseScriptPostCopy();
+  writeVersionToConstantsTS(version, verbose);
+  writeVersionToMetadataXML(version, verbose);
+  writeVersionToVersionTXT(version, verbose);
+  runReleaseScriptPreCopy(verbose);
+  compileAndCopy(modSourcePath, modTargetPath, verbose);
+  purgeRoomXMLs(modTargetPath, verbose);
+  runReleaseScriptPostCopy(verbose);
 
   if (!dryRun) {
-    gitCommitIfChanges(version);
-    uploadMod(modTargetPath, steamCmdPath);
+    gitCommitIfChanges(version, verbose);
+    uploadMod(modTargetPath, steamCmdPath, verbose);
   }
 
   const dryRunSuffix = dryRun ? " (dry run)" : "";
   console.log(`\nPublished version ${version} successfully${dryRunSuffix}.`);
 }
 
-function updateDeps() {
+function updateDeps(verbose: boolean) {
   if (!file.exists(UPDATE_SCRIPT_NAME)) {
     error(
       `The "${UPDATE_SCRIPT_NAME}" script does not exist in the current working directory.`,
     );
   }
 
-  execShell("bash", [UPDATE_SCRIPT_NAME]);
+  execShell("bash", [UPDATE_SCRIPT_NAME], verbose);
 }
 
 function getVersionFromPackageJSON() {
@@ -138,7 +136,7 @@ function getVersionFromPackageJSON() {
   return packageJSON.version;
 }
 
-function bumpVersionInPackageJSON(version: string): string {
+function bumpVersionInPackageJSON(version: string, verbose: boolean): string {
   // Get the patch version (i.e. the third number)
   const matches = /(\d+\.\d+\.)(\d+)/.exec(version);
   if (matches === null) {
@@ -168,7 +166,7 @@ function bumpVersionInPackageJSON(version: string): string {
     /"version": ".+",/,
     `"version": "${incrementedVersion}",`,
   );
-  file.write(PACKAGE_JSON_PATH, newPackageJSON);
+  file.write(PACKAGE_JSON_PATH, newPackageJSON, verbose);
 
   console.log(
     `The version of ${incrementedVersion} was written to: ${PACKAGE_JSON_PATH}`,
@@ -177,18 +175,18 @@ function bumpVersionInPackageJSON(version: string): string {
   return incrementedVersion;
 }
 
-function writeVersionInPackageJSON(version: string) {
+function writeVersionInPackageJSON(version: string, verbose: boolean) {
   const packageJSON = file.read(PACKAGE_JSON_PATH);
   const newPackageJSON = packageJSON.replace(
     /"version": ".+",/,
     `"version": "${version}",`,
   );
-  file.write(PACKAGE_JSON_PATH, newPackageJSON);
+  file.write(PACKAGE_JSON_PATH, newPackageJSON, verbose);
 
   console.log(`The version of ${version} was written to: ${PACKAGE_JSON_PATH}`);
 }
 
-function writeVersionToConstantsTS(version: string) {
+function writeVersionToConstantsTS(version: string, verbose: boolean) {
   if (!file.exists(CONSTANTS_TS_PATH)) {
     console.log(
       'Skipping writing the version to "constants.ts" since it was not found.',
@@ -201,63 +199,64 @@ function writeVersionToConstantsTS(version: string) {
     /const VERSION = ".+"/,
     `const VERSION = "${version}"`,
   );
-  file.write(CONSTANTS_TS_PATH, newConstantsTS);
+  file.write(CONSTANTS_TS_PATH, newConstantsTS, verbose);
 
   console.log(`The version of ${version} was written to: ${CONSTANTS_TS_PATH}`);
 }
 
-function writeVersionToMetadataXML(version: string) {
+function writeVersionToMetadataXML(version: string, verbose: boolean) {
   const metadataXML = file.read(METADATA_XML_PATH);
   const newMetadataXML = metadataXML.replace(
     /<version>.+<\/version>/,
     `<version>${version}</version>`,
   );
-  file.write(METADATA_XML_PATH, newMetadataXML);
+  file.write(METADATA_XML_PATH, newMetadataXML, verbose);
 
   console.log(`The version of ${version} was written to: ${METADATA_XML_PATH}`);
 }
 
-function writeVersionToVersionTXT(version: string) {
-  file.write(VERSION_TXT_PATH, version);
+function writeVersionToVersionTXT(version: string, verbose: boolean) {
+  file.write(VERSION_TXT_PATH, version, verbose);
 
   console.log(`The version of ${version} was written to: ${VERSION_TXT_PATH}`);
 }
 
-function runReleaseScriptPreCopy() {
+function runReleaseScriptPreCopy(verbose: boolean) {
   if (!file.exists(PUBLISH_PRE_COPY_PY_PATH)) {
     return;
   }
 
   console.log(`Running the "${PUBLISH_PRE_COPY_PY_PATH}" script.`);
-  let [, stdout] = execShell("python", [PUBLISH_PRE_COPY_PY_PATH]);
+  let [, stdout] = execShell("python", [PUBLISH_PRE_COPY_PY_PATH], verbose);
   stdout = stdout.trim();
   if (stdout.length > 0) {
     console.log(stdout);
   }
 }
 
-function runReleaseScriptPostCopy() {
+function runReleaseScriptPostCopy(verbose: boolean) {
   if (!file.exists(PUBLISH_POST_COPY_PY_PATH)) {
     return;
   }
 
   console.log(`Running the "${PUBLISH_POST_COPY_PY_PATH}" script.`);
-  let [, stdout] = execShell("python", [PUBLISH_POST_COPY_PY_PATH]);
+  let [, stdout] = execShell("python", [PUBLISH_POST_COPY_PY_PATH], verbose);
   stdout = stdout.trim();
   if (stdout.length > 0) {
     console.log(stdout);
   }
 }
 
-function gitCommitIfChanges(version: string) {
+function gitCommitIfChanges(version: string, verbose: boolean) {
   // Throw an error if this is not a git repository
-  execShell("git", ["status"]);
+  execShell("git", ["status"], verbose);
 
   // Check to see if there are any changes
   // https://stackoverflow.com/questions/3878624/how-do-i-programmatically-determine-if-there-are-uncommitted-changes
   const [exitCode] = execShell(
     "git",
     ["diff-index", "--quiet", "HEAD", "--"],
+    verbose,
     true,
   );
   if (exitCode === 0) {
@@ -267,16 +266,16 @@ function gitCommitIfChanges(version: string) {
   }
 
   const commitMessage = `v${version}`;
-  execShell("git", ["add", "-A"]);
-  execShell("git", ["commit", "-m", commitMessage]);
-  execShell("git", ["push"]);
+  execShell("git", ["add", "-A"], verbose);
+  execShell("git", ["commit", "-m", commitMessage], verbose);
+  execShell("git", ["push"], verbose);
 
   console.log(
     `Committed and pushed to the git repository with a message of: ${commitMessage}`,
   );
 }
 
-function purgeRoomXMLs(modTargetPath: string) {
+function purgeRoomXMLs(modTargetPath: string, verbose: boolean) {
   const roomsPath = path.join(modTargetPath, "resources", "rooms");
   if (!file.exists(roomsPath) || !file.isDir(roomsPath)) {
     return;
@@ -286,25 +285,33 @@ function purgeRoomXMLs(modTargetPath: string) {
   roomFileList.forEach((fileName: string) => {
     if (path.extname(fileName) === ".xml") {
       const roomFilePath = path.join(roomsPath, fileName);
-      file.deleteFileOrDirectory(roomFilePath);
+      file.deleteFileOrDirectory(roomFilePath, verbose);
     }
   });
 }
 
-function uploadMod(modTargetPath: string, steamCmdPath: string | undefined) {
+function uploadMod(
+  modTargetPath: string,
+  steamCmdPath: string | undefined,
+  verbose: boolean,
+) {
   if (steamCmdPath === undefined) {
     console.log(
       `The "steamCmdPath" property was not found in the "${chalk.green(
         CONFIG_FILE_NAME,
       )}" file; assuming that we want to use the ModUploader tool.`,
     );
-    execExe(MOD_UPLOADER_PATH, modTargetPath);
+    execExe(MOD_UPLOADER_PATH, verbose, modTargetPath);
   } else {
-    runSteamCmd(modTargetPath, steamCmdPath);
+    runSteamCmd(modTargetPath, steamCmdPath, verbose);
   }
 }
 
-function runSteamCmd(modTargetPath: string, steamCmdPath: string) {
+function runSteamCmd(
+  modTargetPath: string,
+  steamCmdPath: string,
+  verbose: boolean,
+) {
   if (!file.exists(steamCmdPath)) {
     error(
       chalk.red(
@@ -347,14 +354,18 @@ function runSteamCmd(modTargetPath: string, steamCmdPath: string) {
 
   console.log("Uploading the mod to the Steam Workshop...");
 
-  execShell(steamCmdPath, [
-    "+login",
-    username,
-    password,
-    "+workshop_build_item",
-    metadataVDFPath,
-    "+quit",
-  ]);
+  execShell(
+    steamCmdPath,
+    [
+      "+login",
+      username,
+      password,
+      "+workshop_build_item",
+      metadataVDFPath,
+      "+quit",
+    ],
+    verbose,
+  );
 
   console.log("Mod uploaded successfully.");
 }

package/src/configFile.ts

@@ -9,6 +9,8 @@ import { Config } from "./types/Config";
 import { error } from "./util";
 
 export async function get(argv: Record<string, unknown>): Promise<Config> {
+  const verbose = argv.verbose === true;
+
   const existingConfig = readExistingConfig();
   if (existingConfig !== null) {
     return existingConfig;
@@ -18,7 +20,7 @@ export async function get(argv: Record<string, unknown>): Promise<Config> {
   const modsDirectory = await getModsDir(argv);
   const saveSlot = await promptSaveSlot(argv);
   const config = createObject(modsDirectory, saveSlot);
-  createFile(CWD, config);
+  createFile(CWD, config, verbose);
 
   return config;
 }
@@ -66,8 +68,12 @@ export function createObject(modsDirectory: string, saveSlot: number): Config {
   };
 }
 
-export function createFile(projectPath: string, config: Config): void {
+export function createFile(
+  projectPath: string,
+  config: Config,
+  verbose: boolean,
+): void {
   const configFilePath = path.join(projectPath, CONFIG_FILE_NAME);
   const configContents = JSON.stringify(config, null, 2);
-  file.write(configFilePath, configContents);
+  file.write(configFilePath, configContents, verbose);
 }

package/src/exec.ts

@@ -0,0 +1,102 @@
+import chalk from "chalk";
+import { execSync, spawnSync, SpawnSyncReturns } from "child_process";
+import { CWD } from "./constants";
+import { error } from "./util";
+
+export function execExe(path: string, verbose = false, cwd = CWD): string {
+  if (verbose) {
+    console.log(`Executing binary: ${path}`);
+  }
+
+  let stdout: string;
+  try {
+    const buffer = execSync(`"${path}"`, {
+      cwd,
+    });
+    stdout = buffer.toString().trim();
+  } catch (err) {
+    error(`Failed to run "${chalk.green(path)}":`, err);
+  }
+
+  if (verbose) {
+    console.log(`Executed binary: ${path}`);
+  }
+
+  return stdout;
+}
+
+/** Returns an array of exit status and stdout. */
+export function execShell(
+  command: string,
+  args: string[] = [],
+  verbose = false,
+  allowFailure = false,
+  cwd = CWD,
+): [number, string] {
+  // On Windows, "spawnSync()" will not account for spaces in arguments
+  // Thus, wrap everything in a double quote
+  // This will cause arguments that naturally have double quotes to fail
+  if (command.includes('"')) {
+    error(
+      "execShell cannot execute commands with double quotes in the command.",
+    );
+  }
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].includes('"')) {
+      error(
+        "execShell cannot execute commands with double quotes in the arguments.",
+      );
+    }
+
+    args[i] = `"${args[i]}"`; // eslint-disable-line no-param-reassign
+  }
+
+  const commandDescription = `${command} ${args.join(" ")}`.trim();
+
+  if (verbose) {
+    console.log(`Executing command: ${commandDescription}`);
+  }
+
+  let spawnSyncReturns: SpawnSyncReturns<Buffer>;
+  try {
+    spawnSyncReturns = spawnSync(command, args, {
+      shell: true,
+      cwd,
+    });
+  } catch (err) {
+    error(
+      `Failed to run the "${chalk.green(commandDescription)}" command:`,
+      err,
+    );
+  }
+
+  if (verbose) {
+    console.log(`Executed command: ${commandDescription}`);
+  }
+
+  const exitStatus = spawnSyncReturns.status;
+  if (exitStatus === null) {
+    error(
+      `Failed to get the return status of th command: ${commandDescription}`,
+    );
+  }
+
+  const stdout = spawnSyncReturns.output.join("\n").trim();
+
+  if (exitStatus !== 0) {
+    if (allowFailure) {
+      return [exitStatus, stdout];
+    }
+
+    console.error(
+      `Failed to run the "${chalk.green(
+        commandDescription,
+      )}" command with an exit code of ${exitStatus}.`,
+    );
+    console.error("The output was as follows:");
+    console.error(stdout);
+    process.exit(1);
+  }
+
+  return [exitStatus, stdout];
+}