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

package/hooks/lando-setup-build-engine-wsl.js

@@ -0,0 +1,210 @@
+'use strict';
+
+const axios = require('../utils/get-axios')();
+const fs = require('fs');
+const getDockerDesktopBin = require('../utils/get-docker-desktop-x');
+const getWinEnvar = require('../utils/get-win32-envvar-from-wsl');
+const path = require('path');
+const semver = require('semver');
+const wslpath = require('../utils/winpath-2-wslpath');
+
+const {color} = require('listr2');
+const {nanoid} = require('nanoid');
+
+const buildIds = {
+  '4.36.0': '175267',
+  '4.35.1': '173168',
+  '4.35.0': '172550',
+  '4.34.3': '170107',
+  '4.34.2': '167172',
+  '4.34.1': '166053',
+  '4.34.0': '165256',
+  '4.33.1': '161083',
+  '4.33.0': '160616',
+  '4.32.0': '157355',
+  '4.31.1': '153621',
+  '4.31.0': '153195',
+  '4.30.0': '149282',
+  '4.29.0': '145265',
+  '4.28.0': '139021',
+  '4.27.2': '137060',
+  '4.27.1': '136059',
+  '4.27.0': '135262',
+  '4.26.1': '131620',
+  '4.26.0': '130397',
+  '4.25.2': '129061',
+  '4.25.1': '128006',
+  '4.25.0': '126437',
+};
+
+/*
+ * Helper to get build engine id
+ */
+const getId = version => {
+  // if version is an integer then assume its already the id
+  if (semver.valid(version) === null && Number.isInteger(parseInt(version))) return version;
+  // otherwise return that corresponding build-id
+  return buildIds[version];
+};
+
+const getVersion = version => {
+  // if version is not an integer then assume its already the version
+  if (semver.valid(version) !== null) return version;
+  // otherwise return the version that corresponds to the build id
+  return Object.keys(buildIds).find(key => buildIds[key] === version);
+};
+
+/*
+ * Helper to get docker compose v2 download url
+ */
+const getEngineDownloadUrl = (id = '175267') => {
+  const arch = process.arch === 'arm64' ? 'arm64' : 'amd64';
+  return `https://desktop.docker.com/win/main/${arch}/${id}/Docker%20Desktop%20Installer.exe`;
+};
+
+/*
+ * wrapper for docker-desktop install
+ */
+const downloadDockerDesktop = (url, {debug, dest, task, ctx}) => new Promise((resolve, reject) => {
+  const download = require('../utils/download-x')(url, {
+    debug,
+    dest: path.posix.join(dest, `${nanoid()}.exe`),
+  });
+
+  // success
+  download.on('done', result => {
+    task.title = `Downloaded build engine`;
+    resolve(result);
+  });
+  // handle errors
+  download.on('error', error => {
+    ctx.errors.push(error);
+    reject(error);
+  });
+  // update title to reflect download progress
+  download.on('progress', progress => {
+    task.title = `Downloading build engine ${color.dim(`[${progress.percentage}%]`)}`;
+  });
+});
+
+module.exports = async (lando, options) => {
+  const debug = require('../utils/debug-shim')(lando.log);
+  debug.enabled = lando.debuggy;
+
+  // if build engine is set to false allow it to be skipped
+  // @NOTE: this is mostly for internal stuff
+  if (options.buildEngine === false) return;
+
+  // get stuff from config/opts
+  const build = getId(options.buildEngine);
+  const version = getVersion(options.buildEngine);
+
+  // cosmetics
+  const install = version ? `v${version}` : `build ${build}`;
+
+  // download url
+  const url = getEngineDownloadUrl(build);
+
+  // win32 install docker desktop task
+  options.tasks.push({
+    title: 'Downloading build engine',
+    id: 'setup-build-engine',
+    description: '@lando/build-engine (docker-desktop)',
+    version: `Docker Desktop ${install}`,
+    hasRun: async () => {
+      // if we are missing the docker desktop executable then false
+      if (!fs.existsSync(getDockerDesktopBin())) return false;
+
+      // if we get here let's make sure the engine is on
+      try {
+        await lando.engine.daemon.up({max: 3, backoff: 1000});
+        return true;
+      } catch (error) {
+        lando.log.debug('docker install task has not run %j', error);
+        return false;
+      }
+    },
+    canRun: async () => {
+      // throw if we cannot resolve a semantic version to a buildid
+      if (!build) throw new Error(`Could not resolve ${install} to an installable version!`);
+      // throw error if we cannot ping the download link
+      await axios.head(url);
+      // @TODO: check for wsl2?
+      return true;
+    },
+    task: async (ctx, task) => {
+      try {
+        // get tmp dir from windows side
+        const winTmpDir = getWinEnvar('TEMP', {debug});
+        const dest = wslpath(winTmpDir);
+        debug('resolved win dir %o to wsl path %o', winTmpDir, dest);
+
+        // download the installer
+        ctx.download = await downloadDockerDesktop(url, {ctx, debug, dest, task});
+        ctx.download.windest = path.win32.join(winTmpDir, path.basename(ctx.download.dest));
+
+        // script
+        const script = path.posix.join(lando.config.userConfRoot, 'scripts', 'install-docker-desktop.ps1');
+        // args
+        const args = ['-Installer', ctx.download.windest];
+        if (options.buildEngineAcceptLicense) args.push('-AcceptLicense');
+        if ((options.debug || options.verbose > 0 || lando.debuggy) && lando.config.isInteractive) args.push('-Debug');
+
+        // run install command
+        task.title = `Installing build engine ${color.dim('(this may take a minute)')}`;
+        const result = await require('../utils/run-powershell-script')(script, args, {debug});
+        result.download = ctx.download;
+
+        // finish up
+        const location = getWinEnvar('ProgramW6432') ?? getWinEnvar('ProgramFiles');
+        task.title = `Installed build engine (Docker Desktop) to ${location}/Docker/Docker!`;
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    },
+  });
+
+  // add docker group add task
+  options.tasks.push({
+    title: `Adding ${lando.config.username} to docker group`,
+    id: 'setup-build-engine-group',
+    dependsOn: ['setup-build-engine'],
+    description: `@lando/build-engine-group (${lando.config.username}@docker)`,
+    requiresRestart: true,
+    comments: {
+      'NOT INSTALLED': `Will add ${lando.config.username} to docker group`,
+    },
+    hasRun: async () => require('../utils/is-group-member')('docker'),
+    task: async (ctx, task) => {
+      // check one last time incase this was added by a dependee or otherwise
+      if (require('../utils/is-group-member')('docker')) return {code: 0};
+
+      // prompt for password if interactive and we dont have it
+      if (ctx.password === undefined && lando.config.isInteractive) {
+        ctx.password = await task.prompt({
+          type: 'password',
+          name: 'password',
+          message: `Enter computer password for ${lando.config.username} to add them to docker group`,
+          validate: async (input, state) => {
+            const options = {debug, ignoreReturnCode: true, password: input};
+            const response = await require('../utils/run-elevated')(['echo', 'hello there'], options);
+            if (response.code !== 0) return response.stderr;
+            return true;
+          },
+        });
+      }
+
+      try {
+        const script = path.join(lando.config.userConfRoot, 'scripts', 'add-to-group.sh');
+        const command = [script, '--user', lando.config.username, '--group', 'docker'];
+        const response = await require('../utils/run-elevated')(command, {debug, password: ctx.password});
+        task.title = `Added ${lando.config.username} to docker group`;
+        return response;
+      } catch (error) {
+        throw error;
+      }
+    },
+  });
+};
+

package/hooks/lando-setup-check.js

@@ -0,0 +1,19 @@
+'use strict';
+
+module.exports = async lando => {
+  // fetch the command we are running
+  const command = lando?.config?.command?._?.[0] ?? 'unknown';
+
+  // only run if engine bootstrap or above and if engine/orchestrator have been installed
+  if (lando._bootstrapLevel >= 3 && command !== 'setup') {
+    lando.log.verbose('build-engine exists: %s', lando.engine.dockerInstalled);
+    lando.log.verbose('orchestrator exists: %s', lando.engine.composeInstalled);
+
+    // if we cannot even locate the buld engine then go into run setup
+    // @NOTE: this is mostly a catch-all fail-safe fall-back in case something
+    // gets through the setup cracks
+    if (lando.engine.dockerInstalled === false) {
+      await require('./lando-run-setup')(lando);
+    }
+  }
+};

package/hooks/lando-setup-create-ca-wsl.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const fs = require('fs');
+const getWinEnvar = require('../utils/get-win32-envvar-from-wsl');
+const path = require('path');
+const wslpath = require('../utils/winpath-2-wslpath');
+const remove = require('../utils/remove');
+
+module.exports = async lando => {
+  const {caCert, caKey} = lando.config;
+
+  // if we dont have any CA stuff, lets see if we can get them from windows
+  // @NOTE: we preempt like this so our setup tasks will asses install successfully
+  if (lando.config.os.landoPlatform === 'wsl' && !fs.existsSync(caCert) && !fs.existsSync(caKey)) {
+    const debug = require('../utils/debug-shim')(lando.log);
+    const winHome = getWinEnvar('USERPROFILE');
+    const winCertsDir = wslpath(path.join(winHome, '.lando', 'certs'));
+    const wcaCert = path.join(winCertsDir, path.basename(caCert));
+    const wcaKey = path.join(winCertsDir, path.basename(caKey));
+
+    // if it makes sense to copy then lets to it
+    if (fs.existsSync(wcaCert) && fs.existsSync(wcaKey) && require('../utils/validate-ca')(wcaCert, wcaKey, {debug})) {
+      fs.copyFileSync(wcaCert, caCert);
+      fs.copyFileSync(wcaKey, caKey);
+      debug('copied existing and valid CA from %o to %o', wcaCert, caCert);
+
+    // otherwise lets purge
+    } else {
+      remove(wcaCert);
+      remove(wcaKey);
+      debug('removed invalid CA stuff from %o and %o', wcaCert, wcaKey);
+    }
+  }
+};

package/hooks/lando-setup-create-ca.js

@@ -1,6 +1,10 @@
 'use strict';
 
 const fs = require('fs');
+const getWinEnvar = require('../utils/get-win32-envvar-from-wsl');
+const path = require('path');
+const wslpath = require('../utils/winpath-2-wslpath');
+const remove = require('../utils/remove');
 
 module.exports = async (lando, options) => {
   const debug = require('../utils/debug-shim')(lando.log);
@@ -16,34 +20,17 @@ module.exports = async (lando, options) => {
       'NOT INSTALLED': 'Will create Lando Development Certificate Authority (CA)',
     },
     hasRun: async () => {
-      const forge = require('node-forge');
-      const read = require('../utils/read-file');
-
       if ([caCert, caKey].some(file => !fs.existsSync(file))) return false;
 
       // check if the ca is valid and has a matching key
-      try {
-        const ca = forge.pki.certificateFromPem(read(caCert));
-        const key = forge.pki.privateKeyFromPem(read(caKey));
-
-        // 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 (!ca.publicKey.verify(md.digest().bytes(), signature)) {
-          throw new Error('CA and its private key do not match');
-        }
-
-        // @TODO: throw error if CA has expired?
-
-        return true;
-      } catch (error) {
-        debug('Something is wrong with the CA %o %o', error.message, error.stack);
-        [caCert, caKey].some(file => !fs.unlinkSync(file));
+      if (!require('../utils/validate-ca')(caCert, caKey, {debug})) {
+        remove(caCert);
+        remove(caKey);
         return false;
       }
+
+      // otherwise we are good
+      return true;
     },
     task: async (ctx, task) => {
       const write = require('../utils/write-file');
@@ -61,6 +48,18 @@ module.exports = async (lando, options) => {
       // write the cert and key
       write(caCert, cert);
       write(caKey, key);
+
+      // on wsl we also want to move these over
+      if (lando.config.os.landoPlatform === 'wsl') {
+        const write = require('../utils/write-file');
+        const winHome = getWinEnvar('USERPROFILE');
+        const winCertsDir = wslpath(path.join(winHome, '.lando', 'certs'));
+        const wcaCert = path.join(winCertsDir, path.basename(caCert));
+        const wcaKey = path.join(winCertsDir, path.basename(caKey));
+        write(wcaCert, cert);
+        write(wcaKey, key);
+      }
+
       task.title = 'Created Lando Development CA';
     },
   });

package/hooks/lando-setup-install-ca-darwin.js

@@ -31,7 +31,11 @@ module.exports = async (lando, options) => {
       try {
         const fingerprint = require('../utils/get-fingerprint')(caCert);
         debug('computed sha1 fingerprint %o for ca %o', fingerprint, caCert);
-        return require('../utils/get-system-cas')().includes(fingerprint);
+
+        // get fingerprints
+        const darwinfps = await require('../utils/get-system-cas')();
+
+        return darwinfps.includes(fingerprint);
       } catch (error) {
         debug('error determining fingerprint of %o: %o %o', caCert, error.message, error.stack);
         return false;

package/hooks/lando-setup-install-ca-linux.js

@@ -33,7 +33,10 @@ module.exports = async (lando, options) => {
         const fingerprint = require('../utils/get-fingerprint')(caCert);
         debug('computed sha1 fingerprint %o for ca %o', fingerprint, caCert);
 
-        return require('../utils/get-system-cas')().includes(fingerprint);
+        // get fingerprints
+        const linuxfps = await require('../utils/get-system-cas')();
+
+        return linuxfps.includes(fingerprint);
       } catch (error) {
         debug('error determining fingerprint of %o: %o %o', caCert, error.message, error.stack);
         return false;

package/hooks/lando-setup-install-ca-win32.js

@@ -31,7 +31,11 @@ module.exports = async (lando, options) => {
       try {
         const fingerprint = require('../utils/get-fingerprint')(caCert);
         debug('computed sha1 fingerprint %o for ca %o', fingerprint, caCert);
-        return require('../utils/get-system-cas')().includes(fingerprint);
+
+        // get fingerprints
+        const winfps = await require('../utils/get-system-cas')();
+
+        return winfps.includes(fingerprint);
       } catch (error) {
         debug('error determining fingerprint of %o: %o %o', caCert, error.message, error.stack);
         return false;

package/hooks/lando-setup-install-ca-wsl.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+
+/**
+ * Installs the Lando Development Certificate Authority (CA) on Windows systems.
+ * This module is called by `lando setup` to ensure the Lando CA is trusted by the system.
+ *
+ * @param {Object} lando - The Lando config object
+ * @param {Object} options - Options passed to the setup command
+ * @return {Promise<void>}
+ */
+module.exports = async (lando, options) => {
+  const debug = require('../utils/debug-shim')(lando.log);
+
+  const {caCert} = lando.config;
+
+  // Skip the installation of the CA if set in options
+  if (options.skipInstallCa) return;
+
+  // Add linux CA installation task
+  options.tasks.push({
+    title: `Installing Lando Development CA on Linux`,
+    id: 'install-ca-linux',
+    dependsOn: ['create-ca'],
+    description: '@lando/install-ca-linux',
+    comments: {
+      'NOT INSTALLED': 'Will install Lando Development Certificate Authority (CA) to Linux store',
+    },
+    hasRun: async () => {
+      try {
+        const fingerprint = require('../utils/get-fingerprint')(caCert);
+        debug('computed sha1 fingerprint %o for ca %o', fingerprint, caCert);
+
+        // get fingerprints
+        const linuxfps = await require('../utils/get-system-cas')({platform: 'linux'});
+
+        // check if we have it in both
+        return linuxfps.includes(fingerprint);
+      } catch (error) {
+        debug('error determining fingerprint of %o: %o %o', caCert, error.message, error.stack);
+        return false;
+      }
+    },
+    canRun: async () => {
+      // Check for admin privileges
+      if (!await require('../utils/is-admin-user')()) {
+        throw new Error([
+          `User "${lando.config.username}" does not have permission to trust the CA!`,
+          'Contact your system admin for permission and then rerun setup.',
+        ].join(os.EOL));
+      }
+
+      return true;
+    },
+    task: async (ctx, task) => {
+      try {
+        task.title = 'Installing Lando Development Certificate Authority (CA) to Linux store';
+
+        // Prompt for password if in interactive mode and password not provided
+        if (ctx.password === undefined && lando.config.isInteractive) {
+          ctx.password = await task.prompt({
+            type: 'password',
+            name: 'password',
+            message: `Enter computer password for ${lando.config.username} to install the CA`,
+            validate: async (input, state) => {
+              const options = {debug, ignoreReturnCode: true, password: input};
+              const response = await require('../utils/run-elevated')(['echo', 'Validating elevated access'], options);
+              if (response.code !== 0) return response.stderr;
+              return true;
+            },
+          });
+        }
+
+        // Prepare the installation command
+        const script = path.join(lando.config.userConfRoot, 'scripts', 'install-system-ca-linux.sh');
+        const command = [script, '--ca', caCert];
+
+        // Add debug flag if necessary
+        if (options.debug || options.verbose > 0 || lando.debuggy) command.push('--debug');
+
+        // Execute the installation command with elevated privileges
+        const result = await require('../utils/run-elevated')(command, {debug, password: ctx.password});
+
+        // Update task title on successful installation
+        task.title = 'Installed Lando Development Certificate Authority (CA) to Linux store';
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    },
+  });
+
+  // Add windows CA installation task
+  options.tasks.push({
+    title: `Installing Lando Development CA on Windows`,
+    id: 'install-ca-win32',
+    dependsOn: ['copy-ca'],
+    description: '@lando/install-ca-win32',
+    comments: {
+      'NOT INSTALLED': 'Will install Lando Development Certificate Authority (CA) to Windows store',
+    },
+    hasRun: async () => {
+      try {
+        const fingerprint = require('../utils/get-fingerprint')(caCert);
+        debug('computed sha1 fingerprint %o for ca %o', fingerprint, caCert);
+
+        // get fingerprints
+        const winfps = await require('../utils/get-system-cas')();
+
+        // check if we have it in both
+        return winfps.includes(fingerprint);
+      } catch (error) {
+        debug('error determining fingerprint of %o: %o %o', caCert, error.message, error.stack);
+        return false;
+      }
+    },
+    canRun: async () => {
+      return true;
+    },
+    task: async (ctx, task) => {
+      try {
+        task.title = 'Installing Lando Development Certificate Authority (CA) to Windows store';
+
+        // Assemble the installation command
+        const script = path.join(lando.config.userConfRoot, 'scripts', 'install-system-ca-win32.ps1');
+        const args = ['-CA', caCert];
+
+        // Add optional arguments
+        if (options.debug || options.verbose > 0 || lando.debuggy) args.push('-Debug');
+        if (!lando.config.isInteractive) args.push('-NonInteractive');
+
+        // Run the installation command
+        const result = await require('../utils/run-powershell-script')(script, args, {debug});
+
+        // Update task title on successful installation
+        task.title = 'Installed Lando Development Certificate Authority (CA) to Windows store';
+        return result;
+      } catch (error) {
+        throw error;
+      }
+    },
+  });
+};

package/hooks/lando-setup-orchestrator.js

@@ -7,7 +7,7 @@ const path = require('path');
 /*
  * Helper to get docker compose v2 download url
  */
-const getComposeDownloadUrl = (version = '2.29.2') => {
+const getComposeDownloadUrl = (version = '2.30.3') => {
   const mv = version.split('.')[0] > 1 ? '2' : '1';
   const arch = process.arch === 'arm64' ? 'aarch64' : 'x86_64';
   const toggle = `${process.platform}-${mv}`;
@@ -31,7 +31,7 @@ const getComposeDownloadUrl = (version = '2.29.2') => {
 /*
  * Helper to get docker compose v2 download destination
  */
-const getComposeDownloadDest = (base, version = '2.29.2') => {
+const getComposeDownloadDest = (base, version = '2.30.3') => {
   switch (process.platform) {
     case 'linux':
     case 'darwin':
@@ -60,7 +60,7 @@ module.exports = async (lando, options) => {
     title: `Downloading orchestrator`,
     id: 'setup-orchestrator',
     description: '@lando/orchestrator (docker-compose)',
-    version: `docker-compose v${orchestrator}`,
+    version: `Docker Compose v${orchestrator}`,
     hasRun: async () => {
       return !!orchestratorBin && typeof orchestrator === 'string' && fs.existsSync(dest);
     },
@@ -74,7 +74,7 @@ module.exports = async (lando, options) => {
       const download = require('../utils/download-x')(url, {debug, dest, test: ['--version']});
       // success
       download.on('done', data => {
-        task.title = `Installed orchestrator to ${dest}`;
+        task.title = `Installed orchestrator (Docker Compose) to ${dest}`;
         resolve(data);
       });
       // handle errors

package/index.js

@@ -37,7 +37,7 @@ const uc = () => ({
 });
 
 module.exports = async lando => {
-  // Set some stuff and set seom stuff up
+  // set some stuff and set seom stuff up
   const caDir = path.join(lando.config.userConfRoot, 'certs');
   const sshDir = path.join(lando.config.home, '.ssh');
   const binDir = path.join(lando.config.userConfRoot, 'bin');
@@ -49,26 +49,32 @@ module.exports = async lando => {
   const caCert = path.join(caDir, `${caName}.crt`);
   const caKey = path.join(caDir, `${caName}.key`);
 
-  // Ensure some dirs exist before we start
+  const platform = lando.config.os.landoPlatform;
+
+  // ensure some dirs exist before we start
   _.forEach([binDir, caDir, sshDir], dir => fs.mkdirSync(dir, {recursive: true}));
 
-  // Ensure we munge plugin stuff together appropriately
-  lando.events.once('pre-install-plugins', async options => await require('./hooks/lando-setup-common-plugins')(lando, options)); // eslint-disable-line max-len
+  // ensure we munge plugin stuff together appropriately
+  lando.events.once('pre-install-plugins', async options => await require('./hooks/lando-setup-common-plugins')(lando, options));
 
   // move v3 scripts directories as needed
   lando.events.on('pre-setup', 0, async () => await require('./hooks/lando-copy-v3-scripts')(lando));
 
-  // Ensure we setup docker if needed
-  lando.events.once('pre-setup', async options => await require(`./hooks/lando-setup-build-engine-${process.platform}`)(lando, options)); // eslint-disable-line max-len
+  // ensure we setup docker if needed
+  lando.events.once('pre-setup', async options => await require(`./hooks/lando-setup-build-engine-${platform}`)(lando, options));
 
-  // Ensure we create and install ca if needed
+  // do some sepecial handling on wsl
+  lando.events.once('pre-setup', async options => await require('./hooks/lando-setup-create-ca-wsl')(lando, options));
+  // ensure we create ca
   lando.events.once('pre-setup', async options => await require('./hooks/lando-setup-create-ca')(lando, options));
-  lando.events.once('pre-setup', async options => await require(`./hooks/lando-setup-install-ca-${process.platform}`)(lando, options)); // eslint-disable-line max-len
+
+  // and install ca
+  lando.events.once('pre-setup', async options => await require(`./hooks/lando-setup-install-ca-${platform}`)(lando, options));
 
   // also move scripts for init considerations
   lando.events.on('pre-init', 0, async () => await require('./hooks/lando-copy-v3-scripts')(lando));
 
-  // Ensure we setup docker-compose if needed
+  // ensure we setup docker-compose if needed
   lando.events.once('pre-setup', async options => await require('./hooks/lando-setup-orchestrator')(lando, options));
 
   // move v3 scripts directories as needed
@@ -87,8 +93,8 @@ module.exports = async lando => {
   // run engine compat checks
   lando.events.on('almost-ready', 2, async () => await require('./hooks/lando-get-compat')(lando));
 
-  // throw error if engine/orchestrator is not available
-  lando.events.once('pre-engine-autostart', async () => await require('./hooks/lando-dep-check')(lando));
+  // throw error if engine is not available
+  lando.events.once('pre-engine-autostart', async () => await require('./hooks/lando-setup-check')(lando));
 
   // autostart docker if we need to
   lando.events.once('engine-autostart', async () => await require('./hooks/lando-autostart-engine')(lando));
@@ -96,7 +102,7 @@ module.exports = async lando => {
   // move v3 scripts directories as needed
   lando.events.on('pre-engine-start', 0, async () => await require('./hooks/lando-copy-v3-scripts')(lando));
 
-  // Return some default things
+  // return some default things
   return _.merge({}, defaults, uc(), {config: {
     appEnv: {
       LANDO_CA_CERT: '/lando/certs/' + path.basename(caCert),

package/lib/app.js

@@ -57,7 +57,7 @@ module.exports = class App {
      * @alias app.name
      */
     this.name = require('../utils/slugify')(name);
-    this.project = this.name;
+    this.project = require('../utils/docker-composify')(this.name);
     this._serviceApi = 3;
     this._config = lando.config;
     this._defaultService = 'appserver';
@@ -315,7 +315,7 @@ module.exports = class App {
       // Merge whatever we have thus far together
       this.info = require('../utils/get-app-info-defaults')(this);
       // finally just make a list of containers
-      const separator = _.get(this, '_config.orchestratorSeparator', '-');
+      const separator = _.get(this, '_config.orchestratorSeparator', '_');
       this.containers = _(this.info)
         .map(service => ([service.service, `${this.project}${separator}${service.service}${separator}1`]))
         .fromPairs()