@florianpat/lando-core 3.23.7-compose → 3.23.22-test1

package/tasks/setup.js

@@ -67,7 +67,7 @@ module.exports = lando => {
   // get defaults from the lando config
   const defaults = lando.config.setup;
   // determine label for build engine
-  const buildEngine = process.platform === 'linux' ? 'docker-engine' : 'docker-desktop';
+  const buildEngine = process.landoPlatform === 'linux' || process.platform === 'linux' ? 'docker-engine' : 'docker-desktop';
   // default options
   const options = {
     'build-engine': {
@@ -218,7 +218,7 @@ module.exports = lando => {
 
         // print table
         console.log('');
-        ux.table(sortBy(rows, ['row', 'weight']), columns);
+        ux.table(sortBy(rows, ['description', 'weight']), columns);
         console.log('');
 
         // things are good!

package/tasks/shellenv.js

@@ -62,7 +62,7 @@ module.exports = lando => {
           console.log();
           console.log(color.bold(binPaths.join(os.EOL)));
           console.log();
-          console.log(`Open a new shell to load the changes!`);
+          console.log(`Start a new terminal session to use ${color.bold(`lando`)}`);
           return;
 
         // otherwise update the shell profile
@@ -72,7 +72,7 @@ module.exports = lando => {
           console.log();
           console.log(color.bold(shellEnv.map(line => line[0]).join(os.EOL)));
           console.log();
-          console.log(`Open a new shell or run ${color.bold(`source ${options.add}`)} to load the changes`);
+          console.log(`Start a new terminal session or run ${color.bold(`eval "$(lando shellenv)"`)} to use ${color.bold(`lando`)}`);
         } else {
           console.log(`Looks like ${color.green(options.add)} is already ready to go!`);
         }

package/tasks/start.js

@@ -16,17 +16,11 @@ module.exports = lando => {
       if (app) {
         console.log(lando.cli.makeArt('appStart', {name: app.name, phase: 'pre'}));
 
-        // run any setup if we need to but without common plugins or build engine
-        const sopts = lando?.config?.setup;
-        sopts.buildEngine = false;
-        sopts.skipCommonPlugins = true;
-        sopts.yes = true;
-        const setupTasks = await lando.getSetupStatus(sopts);
+        // run setup if we need to
+        await require('../hooks/lando-run-setup')(lando);
 
         // Normal bootup
         try {
-          // run a limited setup if needed
-          if (setupTasks.length > 0) await lando.setup(sopts);
           // then start up
           await app.start();
           // determine legacy settings

package/tasks/stop.js

@@ -10,6 +10,9 @@ module.exports = lando => ({
     // Stop it if we can!
     if (app) {
       console.log(lando.cli.makeArt('appStop', {name: app.name, phase: 'pre'}));
+      // run setup if we need to
+      await require('../hooks/lando-run-setup')(lando);
+      // stop
       await app.stop();
       console.log(' ');
       console.log(lando.cli.makeArt('appStop', {name: app.name, phase: 'post'}));

package/utils/build-config.js

@@ -67,6 +67,8 @@ module.exports = options => {
   config.engineConfig = getEngineConfig(config);
   // Strip all COMPOSE_ envvars
   config.env = stripEnv('COMPOSE_');
+  // Disable docker CLI_HINTS
+  config.env.DOCKER_CLI_HINTS = false;
 
   // if composeBin is set and orchestratorBin is not set then set one to the other
   if (config.composeBin && !config.orchestratorBin) config.orchestratorBin = config.composeBin;

package/utils/build-tooling-runner.js

@@ -4,7 +4,8 @@ const _ = require('lodash');
 const path = require('path');
 
 const getContainer = (app, service) => {
-  return app?.containers?.[service] ?? `${app.project}-${service}-1`;
+  const separator = _.get(app, '_config.orchestratorSeparator', '_');
+  return app?.containers?.[service] ?? `${app.project}${separator}${service}${separator}1`;
 };
 
 const getContainerPath = (appRoot, appMount = undefined) => {

package/utils/get-app.js

@@ -24,7 +24,7 @@ module.exports = (files, userConfRoot) => {
   // cast the name to a string...just to make sure.
   config.name = require('../utils/slugify')(config.name);
   // slugify project
-  config.project = config.name;
+  config.project = require('../utils/docker-composify')(config.name);
 
   return _.merge({}, config, {
     configFiles: files,

package/utils/get-bin-paths.js

@@ -3,8 +3,8 @@
 const fs = require('fs');
 const path = require('path');
 
-module.exports = ({entrypoint, file, installPath}) => {
-  return [entrypoint, file, installPath]
+module.exports = ({installPath}) => {
+  return [installPath]
     .filter(p => typeof p === 'string' && p !== '' && fs.existsSync(p))
     .map(p => !fs.lstatSync(p).isDirectory() ? path.dirname(p) : p)
     .filter(p => !process.env.PATH.split(path.delimiter).includes(p))

package/utils/get-compose-x.js

@@ -27,7 +27,7 @@ const getDockerBin = (bin, base, pathFallback = true) => {
   }
 };
 
-module.exports = ({orchestratorVersion = '2.29.2', userConfRoot = os.tmpdir()} = {}) => {
+module.exports = ({orchestratorVersion = '2.30.3', userConfRoot = os.tmpdir()} = {}) => {
   const orchestratorBin = `docker-compose-v${orchestratorVersion}`;
   switch (process.platform) {
     case 'darwin':

package/utils/get-config-defaults.js

@@ -5,21 +5,23 @@ const browsers = ['electron', 'chrome', 'atom-shell'];
 const path = require('path');
 const os = require('os');
 
-const getBuildEngineVersion = () => {
-  switch (process.platform) {
+const getBuildEngineVersion = (platform = process.landoPlatform ?? process.platform) => {
+  switch (platform) {
     case 'darwin':
-      return '4.34.3';
+      return '4.36.0';
     case 'linux':
       return '27.3.1';
     case 'win32':
-      return '4.34.3';
+      return '4.36.0';
+    case 'wsl':
+      return '4.36.0';
   }
 };
 
 // Default config
 const defaultConfig = options => ({
-  orchestratorSeparator: '-',
-  orchestratorVersion: '2.29.2',
+  orchestratorSeparator: '_',
+  orchestratorVersion: '2.30.3',
   configSources: [],
   coreBase: path.resolve(__dirname, '..'),
   disablePlugins: [],
@@ -29,13 +31,16 @@ const defaultConfig = options => ({
   home: os.homedir(),
   isArmed: _.includes(['arm64', 'aarch64'], process.arch),
   logLevel: 'debug',
+  networkLimit: 32,
   node: process.version,
   os: {
     type: os.type(),
     platform: os.platform(),
+    landoPlatform: process.landoPlatform ?? process.platform,
     release: os.release(),
     arch: os.arch(),
     isWsl: os.release().toLowerCase().includes('microsoft'),
+    isWslInterop: require('../utils/is-wsl-interop')(),
   },
   pluginDirs: [{path: path.join(__dirname, '..'), subdir: 'plugins', namespace: '@lando'}],
   plugins: [],
@@ -44,7 +49,7 @@ const defaultConfig = options => ({
   // this governs both autosetup and the defaults of lando setup
   // @TODO: orchestrator works a bit differently because it predates lando.setup() we set it elsewhere
   setup: {
-    buildEngine: getBuildEngineVersion(),
+    buildEngine: getBuildEngineVersion(process.landoPlatform ?? process.platform),
     buildEngineAcceptLicense: !require('is-interactive')(),
     commonPlugins: {
       '@lando/acquia': 'latest',

package/utils/get-docker-bin-path.js

@@ -3,8 +3,8 @@
 const fs = require('fs');
 const path = require('path');
 
-module.exports = () => {
-  switch (process.platform) {
+module.exports = (platform = process.landoPlatform ?? process.platform) => {
+  switch (platform) {
     case 'darwin':
       return '/Applications/Docker.app/Contents/Resources/bin';
     case 'linux':
@@ -19,5 +19,9 @@ module.exports = () => {
       } else {
          return path.win32.join(programFiles + '\\Docker\\Docker\\resources\\bin');
       }
+    case 'wsl':
+      return '/mnt/wsl/docker-desktop/cli-tools/usr/bin';
+    default:
+      return '/usr/bin';
   }
 };

package/utils/get-docker-desktop-x.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const getWinEnvar = require('../utils/get-win32-envvar-from-wsl');
+const path = require('path');
+const wslpath = require('./winpath-2-wslpath');
+
+module.exports = (platform = process.landoPlatform ?? process.platform) => {
+  switch (platform) {
+    case 'darwin':
+      return '/Applications/Docker.app';
+    case 'win32': {
+      const programFiles = process.env.ProgramW6432 ?? process.env.ProgramFiles;
+      return path.win32.join(`${programFiles}\\Docker\\Docker\\Docker Desktop.exe`);
+    }
+    case 'wsl': {
+      const programFiles = getWinEnvar('ProgramW6432') ?? getWinEnvar('ProgramFiles');
+      const winpath = path.win32.join(`${programFiles}\\Docker\\Docker\\Docker Desktop.exe`);
+      return wslpath(winpath);
+    }
+  }
+};

package/utils/get-docker-x.js

@@ -19,14 +19,15 @@ const getDockerBin = (bin, base, pathFallback = true) => {
   if (!fs.existsSync(binPath)) return false;
 
   // Otherwise return a normalized binpath
-  switch (process.platform) {
+  switch (process.landoPlatform ?? process.platform) {
     case 'darwin': return path.posix.normalize(binPath);
     case 'linux': return path.posix.normalize(binPath);
     case 'win32': return path.win32.normalize(binPath);
+    case 'wsl': return path.posix.normalize(binPath);
   }
 };
 
 module.exports = () => {
-  const base = (process.platform === 'linux') ? '/usr/bin' : require('./get-docker-bin-path')();
+  const base = (process.landoPlatform === 'linux' || process.platform === 'linux') ? '/usr/bin' : require('./get-docker-bin-path')();
   return getDockerBin('docker', base);
 };

package/utils/get-shellenv.js

@@ -29,8 +29,7 @@ module.exports = (paths = [], shell = require('./get-user-shell')()) => {
 
     default:
       return [
-        ['# Lando'],
-        [`export PATH="${paths}\${PATH+:$PATH}"; #landopath`, '#landopath'],
+        [`export PATH="${paths}:$PATH"; #landopath`, '#landopath'],
       ];
   }
 };

package/utils/get-system-cas.js

@@ -1,6 +1,8 @@
 'use strict';
 
-/**
+const os = require('os');
+
+/*
  * Retrieves system Certificate Authority (CA) certificates based on the current platform.
  *
  * This function handles different platforms (macOS, Linux, Windows) and returns
@@ -15,17 +17,21 @@
  * @throws {Error} May throw errors during certificate processing, which are logged
  *                 to the console but do not interrupt the function's execution.
  */
-module.exports = (format = 'fingerprint') => {
+module.exports = async ({
+  format = 'fingerprint',
+  platform = process.landoPlatform ?? process.platform,
+}= {}) => {
   const fingerprints = [];
 
-  switch (process.platform) {
+  switch (platform) {
     case 'darwin':
       // For macOS, we use the 'mac-ca' library which handles the formatting
       return require('mac-ca').get({format});
+
     case 'linux':
       // For Linux, we use the 'system-ca' library to get system certificates
-      const {systemCertsSync} = require('system-ca');
-      for (const cert of systemCertsSync()) {
+      const {systemCertsAsync} = require('system-ca');
+      for (const cert of await systemCertsAsync()) {
         try {
           fingerprints.push(require('./get-fingerprint')(cert));
         } catch {
@@ -48,8 +54,21 @@ module.exports = (format = 'fingerprint') => {
         }
       }
 
+      return fingerprints;
+    case 'wsl':
+      const {stdout} = await require('./run-command')(
+        'powershell.exe',
+        ['-Command', 'Get-ChildItem -Path Cert:\\CurrentUser\\Root | Select-Object -ExpandProperty Thumbprint'],
+      );
+
+      fingerprints.push(...stdout
+        .split(os.EOL)
+        .map(fingerprint => fingerprint.trim())
+        .map(fingerprint => fingerprint.toLowerCase())
+        .filter(fingerprint => fingerprint && fingerprint !== ''));
+
       return fingerprints;
     default:
-      throw new Error(`Unsupported platform: ${process.platform}`);
+      throw new Error(`Unsupported platform: ${platform}`);
   }
 };

package/utils/get-win32-envvar-from-wsl.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = varname => {
+  const args = ['-Command', `[Environment]::GetEnvironmentVariable('${varname}')`];
+  const {stdout} = require('./spawn-sync-stringer')('powershell.exe', args, {encoding: 'utf-8'});
+  return stdout.trim();
+};

package/utils/is-admin-user.js

@@ -2,21 +2,22 @@
 
 const os = require('os');
 
-module.exports = user => {
+module.exports = (user, {platform = process.platform} = {}) => {
   // set user to person running this process if its not set
   if (!user) user = os.userInfo().username;
 
   // differetn strokes, different folks
-  switch (process.platform) {
+  switch (platform) {
     case 'darwin':
-      return require('./is-group-member')('admin', user);
+      return require('./is-group-member')('admin', user, platform);
     case 'linux':
-      return require('./is-group-member')('sudo', user)
-        || require('./is-group-member')('admin', user)
-        || require('./is-group-member')('wheel', user)
-        || require('./is-group-member')('adm', user);
+      return require('./is-group-member')('sudo', user, platform)
+        || require('./is-group-member')('admin', user, platform)
+        || require('./is-group-member')('wheel', user, platform)
+        || require('./is-group-member')('adm', user, platform);
     case 'win32':
-      return require('./is-group-member')('administrators', user);
+      return require('./is-group-member')('S-1-5-32-544', user, platform)
+        || require('./is-group-member')('administrators', user, platform);
     default:
       return false;
   }

package/utils/is-group-member.js

@@ -4,35 +4,42 @@ const os = require('os');
 
 const posixCmd = user => (['groups', [user]]);
 const win32Cmd = user => ([
-  'powershell',
+  'powershell.exe',
   [
     '-Command',
     `Get-LocalGroup | Where-Object { ($_ | Get-LocalGroupMember | Where-Object { $_.Name -like "*\\${user}" }).Count -gt 0 } | Select-Object -Property Name`, // eslint-disable-line max-len
   ],
 ]);
 
-module.exports = (group, user) => {
+module.exports = (group, user, platform = process.platform) => {
   // @TODO: throw error if no group specified?
   // set user to person running this process if its not set
   if (!user) user = os.userInfo().username;
 
   // get the result of the membership command
-  const cmd = process.platform === 'win32' ? win32Cmd(user) : posixCmd(user);
+  const cmd = platform === 'win32' ? win32Cmd(user) : posixCmd(user);
   const {status, stdout, stderr} = require('./spawn-sync-stringer')(...cmd);
 
   // if we failed for some reason
   if (status !== 0) throw new Error(`Could not determine group situation: ${stderr}`);
 
   // mac and linux
-  if (process.platform === 'darwin' || process.platform === 'linux') {
+  if (platform === 'darwin' || platform === 'linux') {
     const groups = stdout.split(' ').map(group => group.trim());
     return groups.includes(group);
   }
 
   // if windows we have a long command to check
-  if (process.platform === 'win32') {
-    const groups = stdout.split(os.EOL).map(group => group.trim()).filter(group => group !== 'Name' && group !== '----'); // eslint-disable-line max-len
-    return groups.includes(group);
+  if (platform === 'win32') {
+    const ids = stdout
+      .split(os.EOL)
+      .map(group => group.trim())
+      .filter(group => group !== 'Name' && group !== '----')
+      .map(group => group.toUpperCase());
+
+    const matches = ids.filter(id => id === group.toUpperCase() || id.endsWith(group.toUpperCase()));
+
+    return matches.length > 0;
   }
 
   // otherwise false?

package/utils/is-wsl-interop.js

@@ -3,9 +3,22 @@
 const fs = require('fs');
 const os = require('os');
 
+const WINBIN_REGEX = /\/mnt\/.\/WINDOWS\/System32$/i;
+
 // Checks to see if Docker is installed via WSL/Windows interop.
-module.exports = engineBin => {
-  const isWsl = os.release().toLowerCase().includes('microsoft');
-  // Docker Desktop for Windows keeps the .exe in the same directory as the WSL binary.
-  return isWsl && fs.existsSync(`${engineBin}.exe`);
+module.exports = () => {
+  // return anything that is not wsl as false
+  if (!os.release().toLowerCase().includes('microsoft')) return false;
+
+  // if we dont have have WSL_INTEROP then
+  if (!process.env.WSL_INTEROP) return false;
+
+  // attempt to find there the winbin is at
+  const winbin = process.env.PATH.split(':').filter(path => WINBIN_REGEX.test(path));
+
+  // if we cant find anything then false
+  if (winbin.length === 0) return false;
+
+  // otherwise return whether our first match exists
+  return fs.existsSync(winbin[0]);
 };

package/utils/run-elevated.js

@@ -11,6 +11,7 @@ const {spawn} = require('child_process');
 
 // get the bosmang
 const defaults = {
+  encode: undefined,
   env: process.env,
   debug: require('debug')('@lando/run-elevated'),
   ignoreReturnCode: false,
@@ -95,9 +96,17 @@ module.exports = (command, options, stdout = '', stderr = '') => {
         debug('elevated command %o done with code %o', command, code);
         // with run-elevate we want to clean up stderr a bit if we can eg remove the powershell shit
         if (options.method === 'run-elevated') {
+          const raw = stderr;
+
           stderr = stderr.split('. At line')[0];
           stderr = stderr.split(`${os.EOL}At `)[0];
 
+          // add nse if we have one
+          if (raw.split('NativeCommandError')[1]) {
+            const nse = raw.split('NativeCommandError')[1];
+            stderr = `${stderr}. ${nse.trim()}`;
+          }
+
           // simplify the UAC cancel error
           if (stderr.includes('The operation was canceled by the user.')) {
             stderr = 'The operation was canceled by the user.';

package/utils/run-powershell-script.js

@@ -2,24 +2,50 @@
 
 // Modules
 const merge = require('lodash/merge');
+const read = require('./read-file');
+const winpath = require('./wslpath-2-winpath');
 
-const {spawn} = require('child_process');
+const {spawn, spawnSync} = require('child_process');
+
+const parseArgs = args => args.map(arg => arg.startsWith('-') ? arg : `"${arg}"`).join(' ');
 
 // get the bosmang
 const defaults = {
+  encode: undefined,
+  env: process.env,
   debug: require('debug')('@lando/run-powershell-script'),
   ignoreReturnCode: false,
+  toWSLPath: false,
 };
 
-module.exports = (script, args = [], options = {}, stdout = '', stderr = '') => {
-  // @TODO: error handling?
+module.exports = (script, args = [], options = {}, stdout = '', stderr = '', cargs = []) => {
   // merge our options over the defaults
   options = merge({}, defaults, options);
+
+  // if encode is not explicitly set then we need to pick a good value
+  if (options.encode === undefined) {
+    const bargs = ['Set-ExecutionPolicy', '-Scope', 'Process', '-ExecutionPolicy', 'Bypass'];
+    const {status} = spawnSync('powershell.exe', bargs, options);
+    options.encode = status !== 0;
+  }
+
+  // if encode is true we need to do a bunch of other stuff
+  if (options.encode === true) {
+    const command = `& {${read(script)}} ${parseArgs(args)}`;
+    cargs.push('-EncodedCommand', Buffer.from(command, 'utf16le').toString('base64'));
+
+  // otherwise its pretty easy but note that we may path translate to a winpath if toWSLPath is on
+  } else {
+    if (options.toWSLPath) script = winpath(script);
+    cargs.push('-ExecutionPolicy', 'Bypass', '-File', script, ...args);
+  }
+
+  // pull out debug
   const {debug} = options;
 
   // birth
-  debug('running powershell script %o %o', script, args);
-  const child = spawn('powershell', ['-ExecutionPolicy', 'Bypass', '-File', script].concat(args), options);
+  debug('running powershell script %o %o %o', script, args);
+  const child = spawn('powershell.exe', ['-NoProfile'].concat(cargs), options);
 
   return require('./merge-promise')(child, async () => {
     return new Promise((resolve, reject) => {

package/utils/run-tasks.js

@@ -35,8 +35,9 @@ module.exports = async (tasks, {
     fallbackRendererOptions = rendererOptions;
   }
 
-  // if terminal is DUMB then force the verbose renderer
-  if (process?.env?.TERM === 'dumb') renderer = 'verbose';
+  // some sitautions just need the bare minimum
+  if (process?.env?.TERM === 'dumb') renderer = 'simple';
+  if (process?.env?.CI && !require('is-interactive')()) renderer = 'simple';
 
   const defaults = {
     ctx: {data: {}, errors: [], results: [], skipped: 0, ran: 0, total: 0},

package/utils/setup-metrics.js

@@ -18,10 +18,19 @@ const getMetricsContext = () => {
 module.exports = (log, config) => {
   const Metrics = require('./../lib/metrics');
   const command = _.get(config, 'command._', 'unknown');
+
+  // group by endpoints and resolve multiples
+  const endpoints = _(_.groupBy(config.stats, 'url'))
+    .map((data, url) => ({
+      url,
+      report: data.map(data => data.report).every(report => report === true),
+    }))
+    .value();
+
   return new Metrics({
     log,
     id: config.id,
-    endpoints: config.stats,
+    endpoints,
     data: {
       command: `lando ${command}`,
       context: getMetricsContext(),

package/utils/shutdown-os.js

@@ -6,11 +6,12 @@ module.exports = ({
   message = 'Lando wants to restart your computer',
   password = undefined,
   type = 'restart',
-  wait = process.platform === 'win32' ? 5 : 'now',
+  wait = process.landoPlatform === 'win32' || process.platform === 'win32' ? 5 : 'now',
+  platform = process.landoPlatform ?? process.platform,
 } = {}) => {
   debug('shutdown with %o %o', type, {message, wait});
 
-  switch (process.platform) {
+  switch (platform) {
     case 'darwin':
       args.push('shutdown');
       // handle the restart type
@@ -48,6 +49,10 @@ module.exports = ({
       args.push('/c');
       args.push(message);
 
-      return require('./run-command')('shutdown', args, {debug});
+      return require('./run-command')('shutdown.exe', args, {debug});
+    case 'wsl':
+      args.push('-Command');
+      args.push(`wsl --terminate ${process.env.WSL_DISTRO_NAME}`);
+      return require('./run-command')('powershell.exe', args, {debug});
   }
 };

package/utils/spawn-sync-stringer.js

@@ -4,6 +4,7 @@ const {spawnSync} = require('child_process');
 
 module.exports = (...args) => {
   const result = spawnSync(...args);
+
   // stringify and trim
   result.stdout = result.stdout.toString().trim();
   result.stderr = result.stderr.toString().trim();

package/utils/update-shell-profile.js

@@ -6,6 +6,12 @@ const os = require('os');
 const read = require('./read-file');
 const write = require('./write-file');
 
+const trim = (data = []) => {
+  while (data.length > 0 && data[data.length - 1] === '') data.pop();
+  data.push('');
+  return data;
+};
+
 module.exports = (file, updates = []) => {
   // create empty file if it doesnt exist first
   if (!fs.existsSync(file)) {
@@ -17,9 +23,7 @@ module.exports = (file, updates = []) => {
     // get the content
     const content = read(file);
     // split into lines
-    const lines = content.split('\n');
-    // if we end up with second to last line that is empty then pop
-    if (lines[lines.length - 2].trim() === '') lines.pop();
+    const lines = trim(content.split('\n'));
 
     // loops through the updates and add/update as needed
     for (const [update, search] of updates) {
@@ -31,11 +35,8 @@ module.exports = (file, updates = []) => {
       }
     }
 
-    // if the last element doesnt contain a newline
-    if (!lines[lines.length - 1].includes(os.EOL)) lines.push(os.EOL);
-
     // Write the modified content back to the file
-    write(file, lines.join(os.EOL));
+    write(file, `${trim(lines).join(os.EOL)}${os.EOL}`);
 
   // handle errors
   } catch (error) {

package/utils/validate-ca.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const forge = require('node-forge');
+const read = require('./read-file');
+
+module.exports = (cert, key, {
+  debug = require('debug')('@lando/validate-script'),
+} = {}) => {
+  try {
+    cert = forge.pki.certificateFromPem(read(cert));
+    key = forge.pki.privateKeyFromPem(read(key));
+
+    // verify the signature using the public key in the CA certificate
+    const md = forge.md.sha256.create();
+    md.update('taanab', 'utf8');
+    const signature = key.sign(md);
+
+    // if they dont match then throw
+    if (!cert.publicKey.verify(md.digest().bytes(), signature)) {
+      debug('CA and its private key do not match');
+      return false;
+    }
+
+    // otherwise we are good
+    return true;
+  } catch (error) {
+    debug('something is wrong with the CA %o', error.message);
+    debug('%o', error);
+    return false;
+  }
+};