@swimlane/nodegit 1.1.2

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@swimlane/nodegit",
+  "description": "Node.js libgit2 asynchronous native bindings",
+  "version": "1.1.2",
+  "homepage": "http://nodegit.org",
+  "keywords": [
+    "libgit2",
+    "git2",
+    "git",
+    "native"
+  ],
+  "license": "MIT",
+  "author": "Tim Branyen (@tbranyen)",
+  "contributors": [
+    {
+      "name": "John Haley",
+      "email": "john@haley.io"
+    },
+    {
+      "name": "Max Korp",
+      "email": "maxkorp@8bytealchemy.com"
+    },
+    {
+      "name": "Tyler Ang-Wanek",
+      "email": "tylerw@axosoft.com"
+    }
+  ],
+  "main": "lib/nodegit.js",
+  "repository": "github:swimlane/nodegit",
+  "directories": {
+    "build": "./build",
+    "lib": "./lib"
+  },
+  "engines": {
+    "node": ">= 16"
+  },
+  "dependencies": {
+    "@axosoft/nan": "^2.20.0-gk.1",
+    "fs-extra": "^7.0.0",
+    "got": "^11.8.6",
+    "json5": "^2.1.0",
+    "lodash": "^4.17.14",
+    "node-gyp": "^10.0.1",
+    "node-gyp-build": "^4.8.1",
+    "ramda": "^0.25.0",
+    "tar-fs": "^2.1.1"
+  },
+  "devDependencies": {
+    "cheerio": "^1.0.0-rc.2",
+    "clean-for-publish": "~1.0.2",
+    "combyne": "~0.8.1",
+    "coveralls": "^3.0.2",
+    "istanbul": "^0.4.5",
+    "js-beautify": "~1.5.10",
+    "jshint": "^2.10.0",
+    "lcov-result-merger": "^3.1.0",
+    "mocha": "^5.2.0",
+    "walk": "^2.3.9"
+  },
+  "scripts": {
+    "cov": "npm run cppcov && npm run filtercov && npm run mergecov",
+    "coveralls": "cat ./test/coverage/merged.lcov | coveralls",
+    "cppcov": "mkdir -p test/coverage/cpp && ./lcov-1.10/bin/lcov --gcov-tool /usr/bin/gcov-4.9 --capture --directory build/Release/obj.target/nodegit/src --output-file test/coverage/cpp/lcov_full.info",
+    "filtercov": "./lcov-1.10/bin/lcov --extract test/coverage/cpp/lcov_full.info $(pwd)/src/* $(pwd)/src/**/* $(pwd)/include/* $(pwd)/include/**/* --output-file test/coverage/cpp/lcov.info && rm test/coverage/cpp/lcov_full.info",
+    "generateJson": "node generate/scripts/generateJson",
+    "generateMissingTests": "node generate/scripts/generateMissingTests",
+    "generateNativeCode": "node generate/scripts/generateNativeCode",
+    "install": "node lifecycleScripts/preinstall.js && node-gyp-build",
+    "installDebug": "BUILD_DEBUG=true npm install",
+    "lint": "jshint lib test/tests test/utils lifecycleScripts",
+    "mergecov": "lcov-result-merger 'test/**/*.info' 'test/coverage/merged.lcov' && ./lcov-1.10/bin/genhtml test/coverage/merged.lcov --output-directory test/coverage/report",
+    "mocha": "mocha --expose-gc test/runner test/tests --timeout 15000",
+    "mochaDebug": "mocha --expose-gc --inspect-brk test/runner test/tests --timeout 15000",
+    "preinstall": "node lifecycleScripts/preinstall",
+    "postinstall": "node lifecycleScripts/postinstall",
+    "rebuild": "node generate && node-gyp configure build",
+    "rebuildDebug": "node generate && node-gyp configure --debug build",
+    "recompile": "node-gyp configure build",
+    "recompileDebug": "node-gyp configure --debug build",
+    "test": "npm run lint && node --expose-gc test",
+    "xcodeDebug": "node-gyp configure -- -f xcode"
+  }
+}

package/scripts/Dockerfile.alpine

@@ -0,0 +1,10 @@
+FROM node:18.17.0-alpine3.17
+
+RUN apk add build-base git krb5-dev libgit2-dev libssh-dev pkgconfig python3 tzdata
+
+ADD . /app
+WORKDIR /app
+
+RUN npm ci --ignore-scripts && \
+  npm run preinstall && \
+  npx prebuildify --napi --strip --tag-libc -t "$(node --version | tr -d 'v')"

package/scripts/Dockerfile.debian

@@ -0,0 +1,15 @@
+FROM node:18.17.0-bullseye
+
+ENV DEBIAN_FRONTEND noninteractive
+ENV LC_ALL en_US.UTF-8
+ENV LANG ${LC_ALL}
+
+RUN apt-get update -y && \
+  apt-get install -y software-properties-common git build-essential clang libssl-dev libkrb5-dev libc++-dev wget python3
+
+ADD . /app
+WORKDIR /app
+
+RUN npm ci --ignore-scripts && \
+  npm run preinstall && \
+  npx prebuildify --napi --strip --tag-libc -t "$(node --version | tr -d 'v')"

package/utils/acquireOpenSSL.js

@@ -0,0 +1,436 @@
+const crypto = require("crypto");
+const execPromise = require("./execPromise");
+// for fs.remove. replace with fs.rm after dropping v12 support
+const fse = require("fs-extra");
+const fsNonPromise = require("fs");
+const { promises: fs } = fsNonPromise;
+const path = require("path");
+const got = require("got");
+const { performance } = require("perf_hooks");
+const { promisify } = require("util");
+const stream = require("stream");
+const tar = require("tar-fs");
+const zlib = require("zlib");
+
+const pipeline = promisify(stream.pipeline);
+
+const packageJson = require('../package.json')
+
+const OPENSSL_VERSION = "1.1.1t";
+const win32BatPath = path.join(__dirname, "build-openssl.bat");
+const vendorPath = path.resolve(__dirname, "..", "vendor");
+const opensslPatchPath = path.join(vendorPath, "patches", "openssl");
+const extractPath = path.join(vendorPath, "openssl");
+
+const pathsToIncludeForPackage = [
+  "include", "lib"
+];
+
+const getOpenSSLSourceUrl = (version) => `https://www.openssl.org/source/openssl-${version}.tar.gz`;
+const getOpenSSLSourceSha256Url = (version) => `${getOpenSSLSourceUrl(version)}.sha256`;
+
+class HashVerify extends stream.Transform {
+  constructor(algorithm, onFinal) {
+    super();
+    this.onFinal = onFinal;
+    this.hash = crypto.createHash(algorithm);
+  }
+
+  _transform(chunk, encoding, callback) {
+    this.hash.update(chunk, encoding);
+    callback(null, chunk);
+  }
+
+  _final(callback) {
+    const digest = this.hash.digest("hex");
+    const onFinalResult = this.onFinal(digest);
+    callback(onFinalResult);
+  }
+}
+
+const makeHashVerifyOnFinal = (expected) => (digest) => {
+  const digestOk = digest === expected;
+  return digestOk
+    ? null
+    : new Error(`Digest not OK: ${digest} !== ${this.expected}`);
+};
+
+// currently this only needs to be done on linux
+const applyOpenSSLPatches = async (buildCwd, operatingSystem) => {
+  try {
+    for (const patchFilename of await fse.readdir(opensslPatchPath)) {
+      const patchTarget = patchFilename.split("-")[1];
+      if (patchFilename.split(".").pop() === "patch" && (patchTarget === operatingSystem || patchTarget === "all")) {
+        console.log(`applying ${patchFilename}`);
+        await execPromise(`patch -up0 -i ${path.join(opensslPatchPath, patchFilename)}`, {
+          cwd: buildCwd
+        }, { pipeOutput: true });
+      }
+    }
+  } catch(e) {
+    console.log("Patch application failed: ", e);
+    throw e;
+  }
+}
+
+const buildDarwin = async (buildCwd, macOsDeploymentTarget) => {
+  if (!macOsDeploymentTarget) {
+    throw new Error("Expected macOsDeploymentTarget to be specified");
+  }
+
+  const arguments = [
+    process.arch === "x64" ? "darwin64-x86_64-cc" : "darwin64-arm64-cc",
+    // speed up ecdh on little-endian platforms with 128bit int support
+    "enable-ec_nistp_64_gcc_128",
+    // compile static libraries
+    "no-shared",
+    // disable ssl2, ssl3, and compression
+    "no-ssl2",
+    "no-ssl3",
+    "no-comp",
+    // set install directory
+    `--prefix="${extractPath}"`,
+    `--openssldir="${extractPath}"`,
+    // set macos version requirement
+    `-mmacosx-version-min=${macOsDeploymentTarget}`
+  ];
+
+  await execPromise(`./Configure ${arguments.join(" ")}`, {
+    cwd: buildCwd
+  }, { pipeOutput: true });
+
+  await applyOpenSSLPatches(buildCwd, "darwin");
+
+  // only build the libraries, not the tests/fuzzer or apps
+  await execPromise("make build_libs", {
+    cwd: buildCwd
+  }, { pipeOutput: true });
+
+  await execPromise("make test", {
+    cwd: buildCwd
+  }, { pipeOutput: true });
+
+  await execPromise("make install_sw", {
+    cwd: buildCwd,
+    maxBuffer: 10 * 1024 * 1024 // we should really just use spawn
+  }, { pipeOutput: true });
+};
+
+const buildLinux = async (buildCwd) => {
+  const arguments = [
+    "linux-x86_64",
+    // Electron(at least on centos7) imports the libcups library at runtime, which has a
+    // dependency on the system libssl/libcrypto which causes symbol conflicts and segfaults.
+    // To fix this we need to hide all the openssl symbols to prevent them from being overridden
+    // by the runtime linker.
+    "-fvisibility=hidden",
+    // compile static libraries
+    "no-shared",
+    // disable ssl2, ssl3, and compression
+    "no-ssl2",
+    "no-ssl3",
+    "no-comp",
+    // set install directory
+    `--prefix="${extractPath}"`,
+    `--openssldir="${extractPath}"`
+  ];
+  await execPromise(`./Configure ${arguments.join(" ")}`, {
+    cwd: buildCwd
+  }, { pipeOutput: true });
+
+  await applyOpenSSLPatches(buildCwd, "linux");
+
+  // only build the libraries, not the tests/fuzzer or apps
+  await execPromise("make build_libs", {
+    cwd: buildCwd
+  }, { pipeOutput: true });
+
+  await execPromise("make test", {
+    cwd: buildCwd
+  }, { pipeOutput: true });
+
+  // only install software, not the docs
+  await execPromise("make install_sw", {
+    cwd: buildCwd,
+    maxBuffer: 10 * 1024 * 1024 // we should really just use spawn
+  }, { pipeOutput: true });
+};
+
+const buildWin32 = async (buildCwd, vsBuildArch) => {
+  if (!vsBuildArch) {
+    throw new Error("Expected vsBuildArch to be specified");
+  }
+
+  const programFilesPath = (process.arch === "x64"
+    ? process.env["ProgramFiles(x86)"]
+    : process.env.ProgramFiles) || "C:\\Program Files";
+  const vcvarsallPath = process.env.npm_config_vcvarsall_path || `${
+    programFilesPath
+  }\\Microsoft Visual Studio\\2017\\BuildTools\\VC\\Auxiliary\\Build\\vcvarsall.bat`;
+  try {
+    await fs.stat(vcvarsallPath);
+  } catch {
+    throw new Error(`vcvarsall.bat not found at ${vcvarsallPath}`);
+  }
+
+  let vcTarget;
+  switch (vsBuildArch) {
+    case "x64": {
+      vcTarget = "VC-WIN64A";
+      break;
+    }
+
+    case "x86": {
+      vcTarget = "VC-WIN32";
+      break;
+    }
+      
+    default: {
+      throw new Error(`Unknown vsBuildArch: ${vsBuildArch}`);
+    }
+  }
+
+  await execPromise(`"${win32BatPath}" "${vcvarsallPath}" ${vsBuildArch} ${vcTarget}`, {
+    cwd: buildCwd,
+    maxBuffer: 10 * 1024 * 1024 // we should really just use spawn
+  }, { pipeOutput: true });
+};
+
+const removeOpenSSLIfOudated = async (openSSLVersion) => {
+  try {
+    let openSSLResult;
+    try {
+      const openSSLPath = path.join(extractPath, "bin", "openssl");
+      openSSLResult = await execPromise(`${openSSLPath} version`);
+    } catch {
+      /* if we fail to get the version, assume removal not required */
+    }
+
+    if (!openSSLResult) {
+      return;
+    }
+
+    const versionMatch = openSSLResult.match(/^OpenSSL (\d\.\d\.\d[a-z]*)/);
+    const installedVersion = versionMatch && versionMatch[1];
+    if (!installedVersion || installedVersion === openSSLVersion) {
+      return;
+    }
+
+    console.log("Removing outdated OpenSSL at: ", extractPath);
+    await fse.remove(extractPath);
+    console.log("Outdated OpenSSL removed.");
+  } catch (err) {
+    console.log("Remove outdated OpenSSL failed: ", err);
+  }
+};
+
+const makeOnStreamDownloadProgress = () => {
+  let lastReport = performance.now();
+  return ({ percent, transferred, total }) => {
+    const currentTime = performance.now();
+    if (currentTime - lastReport > 1 * 1000) {
+      lastReport = currentTime;
+      console.log(`progress: ${transferred}/${total} (${(percent * 100).toFixed(2)}%)`)
+    }
+  };
+};
+
+const buildOpenSSLIfNecessary = async ({
+  macOsDeploymentTarget,
+  openSSLVersion,
+  vsBuildArch
+}) => {
+  if (process.platform !== "darwin" && process.platform !== "win32" && process.platform !== "linux") {
+    console.log(`Skipping OpenSSL build, not required on ${process.platform}`);
+    return;
+  }
+
+  if (process.platform === "linux" && process.env.NODEGIT_OPENSSL_STATIC_LINK !== "1") {
+    console.log(`Skipping OpenSSL build, NODEGIT_OPENSSL_STATIC_LINK !== 1`);
+    return;
+  }
+
+  await removeOpenSSLIfOudated(openSSLVersion);
+
+  try {
+    await fs.stat(extractPath);
+    console.log("Skipping OpenSSL build, dir exists");
+    return;
+  } catch {}
+
+  const openSSLUrl = getOpenSSLSourceUrl(openSSLVersion);
+  const openSSLSha256Url = getOpenSSLSourceSha256Url(openSSLVersion);
+
+  const openSSLSha256 = (await got(openSSLSha256Url)).body.trim();
+
+  const downloadStream = got.stream(openSSLUrl);
+  downloadStream.on("downloadProgress", makeOnStreamDownloadProgress());
+
+  await pipeline(
+    downloadStream,
+    new HashVerify("sha256", makeHashVerifyOnFinal(openSSLSha256)),
+    zlib.createGunzip(),
+    tar.extract(extractPath)
+  );
+
+  console.log(`OpenSSL ${openSSLVersion} download + extract complete: SHA256 OK.`);
+
+  const buildCwd = path.join(extractPath, `openssl-${openSSLVersion}`);
+
+  if (process.platform === "darwin") {
+    await buildDarwin(buildCwd, macOsDeploymentTarget);
+  } else if (process.platform === "linux") {
+    await buildLinux(buildCwd);
+  } else if (process.platform === "win32") {
+    await buildWin32(buildCwd, vsBuildArch);
+  } else {
+    throw new Error(`Unknown platform: ${process.platform}`);
+  }
+
+  console.log("Build finished.");
+}
+
+const downloadOpenSSLIfNecessary = async ({
+  downloadBinUrl,
+  maybeDownloadSha256,
+  maybeDownloadSha256Url
+}) => {
+  if (process.platform !== "darwin" && process.platform !== "win32" && process.platform !== "linux") {
+    console.log(`Skipping OpenSSL download, not required on ${process.platform}`);
+    return;
+  }
+
+  if (process.platform === "linux" && process.env.NODEGIT_OPENSSL_STATIC_LINK !== "1") {
+    console.log(`Skipping OpenSSL download, NODEGIT_OPENSSL_STATIC_LINK !== 1`);
+    return;
+  }
+
+  try {
+    await fs.stat(extractPath);
+    console.log("Skipping OpenSSL download, dir exists");
+    return;
+  } catch {}
+  
+  if (maybeDownloadSha256Url) {
+    maybeDownloadSha256 = (await got(maybeDownloadSha256Url)).body.trim();
+  }
+
+  const downloadStream = got.stream(downloadBinUrl);
+  downloadStream.on("downloadProgress", makeOnStreamDownloadProgress());
+
+  const pipelineSteps = [
+    downloadStream,
+    maybeDownloadSha256
+      ? new HashVerify("sha256", makeHashVerifyOnFinal(maybeDownloadSha256))
+      : null,
+    zlib.createGunzip(),
+    tar.extract(extractPath)
+  ].filter(step => step !== null);
+  await pipeline(
+    ...pipelineSteps
+  );
+
+  console.log(`OpenSSL download + extract complete${maybeDownloadSha256 ? ": SHA256 OK." : "."}`);
+  console.log("Download finished.");
+}
+
+const getOpenSSLPackageName = () => {
+  let arch = process.arch;
+  if (process.platform === "win32" && (
+    process.arch === "ia32" || process.env.NODEGIT_VS_BUILD_ARCH === "x86"
+  )) {
+    arch = "x86";
+  }
+
+  return `openssl-${OPENSSL_VERSION}-${process.platform}-${arch}.tar.gz`;
+}
+
+const getOpenSSLPackageUrl = () => `${packageJson.binary.host}${getOpenSSLPackageName()}`;
+
+const buildPackage = async () => {
+  let resolve, reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  await pipeline(
+    tar.pack(extractPath, {
+      entries: pathsToIncludeForPackage,
+      ignore: (name) => {
+        // Ignore pkgconfig files
+        return path.extname(name) === ".pc"
+          || path.basename(name) === "pkgconfig";
+      },
+      dmode: 0755,
+      fmode: 0644
+    }),
+    zlib.createGzip(),
+    new HashVerify("sha256", (digest) => {
+      resolve(digest);
+    }),
+    fsNonPromise.createWriteStream(getOpenSSLPackageName())
+  );
+  const digest = await promise;
+  await fs.writeFile(`${getOpenSSLPackageName()}.sha256`, digest);
+};
+
+const acquireOpenSSL = async () => {
+  try {
+    const downloadBinUrl = process.env.npm_config_openssl_bin_url
+      || (['win32', 'darwin'].includes(process.platform) ? getOpenSSLPackageUrl() : undefined);
+    if (downloadBinUrl && downloadBinUrl !== 'skip' && !process.env.NODEGIT_OPENSSL_BUILD_PACKAGE) {
+      const downloadOptions = { downloadBinUrl };
+      if (process.env.npm_config_openssl_bin_sha256 !== 'skip') {
+        if (process.env.npm_config_openssl_bin_sha256) {
+          downloadOptions.maybeDownloadSha256 = process.env.npm_config_openssl_bin_sha256;
+        } else {
+          downloadOptions.maybeDownloadSha256Url = `${getOpenSSLPackageUrl()}.sha256`;
+        }
+      }
+
+      await downloadOpenSSLIfNecessary(downloadOptions);
+      return;
+    }
+
+    let macOsDeploymentTarget;
+    if (process.platform === "darwin") {
+      macOsDeploymentTarget = process.argv[2];
+      if (!macOsDeploymentTarget || !macOsDeploymentTarget.match(/\d+\.\d+/)) {
+        throw new Error(`Invalid macOsDeploymentTarget: ${macOsDeploymentTarget}`);
+      }
+    }
+
+    let vsBuildArch;
+    if (process.platform === "win32") {
+      vsBuildArch = process.env.NODEGIT_VS_BUILD_ARCH || (process.arch === "x64" ? "x64" : "x86");
+      if (!["x64", "x86"].includes(vsBuildArch)) {
+        throw new Error(`Invalid vsBuildArch: ${vsBuildArch}`);
+      }
+    }
+
+    await buildOpenSSLIfNecessary({
+      openSSLVersion: OPENSSL_VERSION,
+      macOsDeploymentTarget,
+      vsBuildArch
+    });
+    if (process.env.NODEGIT_OPENSSL_BUILD_PACKAGE) {
+      await buildPackage();
+    }
+  } catch (err) {
+    console.error("Acquire failed: ", err);
+    process.exit(1);
+  }
+};
+
+module.exports = {
+  acquireOpenSSL,
+  getOpenSSLPackageName,
+  OPENSSL_VERSION
+};
+
+if (require.main === module) {
+  acquireOpenSSL().catch((error) => {
+    console.error("Acquire OpenSSL failed: ", error);
+    process.exit(1);
+  });
+}

package/utils/build-openssl.bat

@@ -0,0 +1,13 @@
+@call %1 %2
+
+perl .\Configure %3 no-shared no-ssl2 no-ssl3 no-comp --prefix="%cd%\.." --openssldir="%cd%\.." || goto :error
+
+nmake || goto :error
+nmake test || goto :error
+nmake install || goto :error
+
+goto :EOF
+
+:error
+echo Failed with error #%errorlevel%.
+exit /b %errorlevel%

package/utils/buildFlags.js

@@ -0,0 +1,19 @@
+var fs = require("fs");
+var path = require("path");
+
+var isGitRepo;
+
+try {
+  fs.statSync(path.join(__dirname, "..", ".git"));
+  isGitRepo = true;
+} catch (e) {
+  isGitRepo = false;
+}
+
+module.exports = {
+  debugBuild: !!process.env.BUILD_DEBUG,
+  isElectron: process.env.npm_config_runtime === "electron",
+  isGitRepo: isGitRepo,
+  isNwjs: process.env.npm_config_runtime === "node-webkit",
+  mustBuild: !!(isGitRepo || process.env.BUILD_DEBUG || process.env.BUILD_ONLY)
+};

package/utils/configureLibssh2.js

@@ -0,0 +1,54 @@
+var cp = require("child_process");
+var fse = require("fs-extra");
+var path = require("path");
+
+const opensslVendorDirectory = path.resolve(__dirname, "..", "vendor", "openssl");
+const libssh2VendorDirectory = path.resolve(__dirname, "..", "vendor", "libssh2");
+const libssh2ConfigureScript = path.join(libssh2VendorDirectory, "configure");
+const libssh2StaticConfigDirectory  = path.resolve(__dirname, "..", "vendor", "static_config", "libssh2");
+
+module.exports = function retrieveExternalDependencies() {
+  console.info("[nodegit] Configuring libssh2.");
+
+  // Copy Windows / Mac preconfigured files
+  if (process.platform === "win32" || process.platform === "darwin") {
+    return fse.copy(
+      path.join(libssh2StaticConfigDirectory, process.platform),
+      path.join(libssh2VendorDirectory, "src")
+    );
+  }
+
+  // Run the `configure` script on Linux
+  return new Promise(function(resolve, reject) {
+    var newEnv = {};
+    Object.keys(process.env).forEach(function(key) {
+      newEnv[key] = process.env[key];
+    });
+
+    let cpArgs = process.env.NODEGIT_OPENSSL_STATIC_LINK === '1'
+      ? ` --with-libssl-prefix=${opensslVendorDirectory}`
+      : '';
+    cp.exec(
+      `${libssh2ConfigureScript}${cpArgs}`,
+      {
+        cwd: libssh2VendorDirectory,
+        env: newEnv
+      },
+      function(err, stdout, stderr) {
+        if (err) {
+          console.error(err);
+          console.error(stderr);
+          reject(err, stderr);
+        }
+        else {
+          resolve(stdout);
+        }
+      }
+    );
+  });
+};
+
+// Called on the command line
+if (require.main === module) {
+  module.exports();
+}

package/utils/defaultCxxStandard.js

@@ -0,0 +1,18 @@
+const targetSpecified = process.argv[2] !== 'none';
+
+let isNode18OrElectron20AndUp = false;
+if (targetSpecified) {
+  // Assume electron if target is specified.
+  // If building node 18 / 19 via target, will need to specify C++ standard manually
+  const majorVersion = process.argv[2].split('.')[0];
+  isNode18OrElectron20AndUp = majorVersion >= 20;
+} else {
+  // Node 18 === 108
+  isNode18OrElectron20AndUp = Number.parseInt(process.versions.modules) >= 108;
+}
+
+const defaultCxxStandard = isNode18OrElectron20AndUp
+  ? '17'
+  : '14';
+
+process.stdout.write(defaultCxxStandard);

package/utils/execPromise.js

@@ -0,0 +1,24 @@
+var cp = require('child_process');
+
+// We have to manually promisify this because at this is required in lifecycle
+// methods and we are not guaranteed that any 3rd party packages are installed
+// at this point
+module.exports = function(command, opts, extraOpts = {}) {
+  return new Promise(function(resolve, reject) {
+    const childProcess = cp.exec(command, opts, function(err, result) {
+      if (err) {
+        reject(err);
+      }
+      else {
+        resolve(result);
+      }
+    });
+
+    if (extraOpts.pipeOutput) {
+      childProcess.stdout.pipe(process.stdout);
+      childProcess.stderr.pipe(process.stderr);
+    }
+
+    return childProcess;
+  });
+};