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

package/lib/art.js

@@ -300,7 +300,7 @@ exports.newContent = (type = 'guide') => [
   '',
 ].join(os.EOL);
 
-exports.setupHeader = (bengine = process.platform === 'linux' ? 'Engine' : 'Desktop') => `
+exports.setupHeader = (bengine = process.landoPlatform === 'linux' || process.platform === 'linux' ? 'Engine' : 'Desktop') => `
 ${chalk.magenta(niceFont('Lando Setup!', 'Small Slant'))}
 
 ${chalk.bold('lando setup')} is a hidden convenience command to help you satisify the
@@ -322,16 +322,14 @@ or visit ${chalk.magenta('https://docs.lando.dev/cli/setup.html')}
 /*
  * Helper to show NO DOCKER error message
  */
-exports.noDockerDep = (dep = 'Docker Desktop') => `
-${chalk.yellow(niceFont('U Need Setup!', 'Small Slant'))}
+exports.needsSetup = (dep = 'Docker Desktop') => `
+${chalk.red(niceFont('U Need Setup!', 'Small Slant'))}
 
-Lando has detected that it does not have all the dependencies it needs to run.
-But ${chalk.bold('FEAR NOT')} because we have a special hidden convenience command called ${chalk.bold('lando setup')}
-which will do the heavy lifting and set you right.
+Lando encountered a setup error and does not have all the dependencies it needs to run!
 
-Run ${chalk.bold('lando setup')} and when it completes try running Lando again.
+Run ${chalk.bold('lando setup --debug')} and when it completes try running Lando again.
 
-If you get an error or have any issues we recommend you post an issue on
+If you get another error or have any issues we recommend you post an issue on
 GitHub or ping us in our Slack channel!
 
 ${chalk.magenta(`${figures.squareSmallFilled} Slack - https://launchpass.com/devwithlando`)}
@@ -401,6 +399,20 @@ exports.releaseChannel = (channel = 'stable') => {
   }
 };
 
+/*
+ * Helper to show that setup is running
+ */
+exports.runningSetup = () => `
+${chalk.yellow(niceFont('Running Setup!', 'Small Slant'))}
+
+Lando has detected that it does not have ${chalk.bold('critical dependencies')} it needs to run.
+But ${chalk.bold('FEAR NOT')} because we are trying to install them ${chalk.bold('right now')}!
+
+This ${chalk.italic('may')} require your password or a restart so heads up.
+
+If you cancel out you can run ${chalk.bold('lando setup')} to manually kick it off.
+`;
+
 /*
  * Helper to show status of secret toggle
  */

package/lib/compose.js

@@ -161,9 +161,6 @@ exports.run = (compose, project, opts = {}) => {
     } else if (opts.cmd[opts.cmd.length - 1] === '&') {
       opts.cmd.pop();
       opts.detach = true;
-    } else if (opts.cmd[opts.cmd.length - 1].endsWith('&')) {
-      opts.cmd[opts.cmd.length - 1] = opts.cmd[opts.cmd.length - 1].slice(0, -1).trim();
-      opts.detach = true;
     }
   }
 

package/lib/daemon.js

@@ -2,6 +2,8 @@
 
 // Modules
 const _ = require('lodash');
+const fs = require('fs');
+const getDockerBinPath = require('../utils/get-docker-bin-path');
 const os = require('os');
 const path = require('path');
 
@@ -14,35 +16,29 @@ const Shell = require('./shell');
 const shell = new Shell();
 
 // Constants
-const macOSBase = '/Applications/Docker.app';
+const MACOS_BASE = '/Applications/Docker.app';
+const WSL_DOCKER = '/Docker/host/bin/docker.exe';
 
 /*
  * Get services wrapper
  */
 const buildDockerCmd = (cmd, scriptsDir, dockerBin) => {
   const windowsStartScript = path.join(scriptsDir, 'docker-desktop-start.ps1');
-  switch (process.platform) {
+  switch (process.landoPlatform ?? process.platform) {
     case 'darwin':
-      return ['open', macOSBase];
+      return ['open', MACOS_BASE];
     case 'linux':
-      if (require('../utils/is-wsl-interop')(dockerBin)) {
-        // Docker Desktop WSL2 integration detected
-        return [
-          'powershell.exe', '-ExecutionPolicy', 'Bypass', '-File', `"${windowsStartScript}"`,
-        ];
-      }
       return [path.join(scriptsDir, `docker-engine-${cmd}.sh`)];
     case 'win32':
-      return [
-        'powershell.exe', '-ExecutionPolicy', 'Bypass', '-File', `"${windowsStartScript}"`,
-      ];
+    case 'wsl':
+      return ['powershell.exe', '-ExecutionPolicy', 'Bypass', '-File', `"${windowsStartScript}"`];
   }
 };
 
 /*
  * Helper to build mac docker version get command
  */
-const getMacProp = prop => shell.sh(['defaults', 'read', `${macOSBase}/Contents/Info.plist`, prop])
+const getMacProp = prop => shell.sh(['defaults', 'read', `${MACOS_BASE}/Contents/Info.plist`, prop])
   .then(data => _.trim(data))
   .catch(() => null);
 
@@ -57,11 +53,12 @@ module.exports = class LandoDaemon {
       log = new Log(),
       context = 'node',
       compose = require('../utils/get-compose-x')(),
-      orchestratorVersion = '2.29.2',
+      orchestratorVersion = '2.30.3',
       userConfRoot = path.join(os.homedir(), '.lando'),
   ) {
     this.cache = cache;
     this.compose = compose;
+    this.debug = require('../utils/debug-shim')(log);
     this.orchestratorVersion = orchestratorVersion;
     this.context = context;
     this.docker = docker;
@@ -69,6 +66,7 @@ module.exports = class LandoDaemon {
     this.log = log;
     this.scriptsDir = path.join(userConfRoot, 'scripts');
     this.isRunning = false;
+    this.platform = process.landoPlatform ?? process.platform;
   };
 
   /*
@@ -80,6 +78,12 @@ module.exports = class LandoDaemon {
    * @return {Promise} A Promise.
    */
   up(retry = true, password) {
+    const debug = require('../utils/debug-shim')(this.log);
+
+    // backwards compat
+    if (retry === true) retry = {max: 25, backoff: 1000};
+    else if (retry === false) retry = {max: 0};
+
     /*
      * Not officially documented event that allows you to do some things before
      * the docker engine is booted up.
@@ -90,50 +94,42 @@ module.exports = class LandoDaemon {
     return this.events.emit('pre-engine-up').then(() => {
       // Automatically return true if we are in the GUI and on linux because
       // this requires SUDO and because the daemon should always be running on nix
-      if (this.context !== 'node' && process.platform === 'linux') return Promise.resolve(true);
-
-      // special handling for linux
-      if (
-        this.context === 'node'
-        && process.platform === 'linux'
-        && !require('../utils/is-wsl-interop')(this.docker)
-      ) {
-        return this.isUp().then(async isUp => {
-          if (!isUp) {
-            const debug = require('../utils/debug-shim')(this.log);
-            try {
-              await require('../utils/run-elevated')(
-                buildDockerCmd('start', this.scriptsDir, this.docker),
-                {debug, password},
-              );
-              return Promise.resolve(true);
-            } catch (error) {
-              this.log.debug('%j', error);
-              return Promise.reject(error);
+      if (this.context !== 'node' && this.platform === 'linux') return Promise.resolve(true);
+
+      // retry func
+      const starter = async () => {
+        return await this.isUp().then(async isUp => {
+          if (isUp) return Promise.resolve();
+
+          try {
+            switch (this.platform) {
+              case 'darwin':
+                await require('../utils/run-command')('open', [MACOS_BASE], {debug: this.debug});
+                break;
+              case 'linux':
+                const lscript = path.join(this.scriptsDir, 'docker-engine-start.sh');
+                if (password) await require('../utils/run-elevated')([lscript], {debug, password});
+                else await require('../utils/run-command')(lscript, {debug});
+                break;
+              case 'win32':
+              case 'wsl':
+                const wscript = path.join(this.scriptsDir, 'docker-desktop-start.ps1');
+                await require('../utils/run-powershell-script')(wscript, undefined, {debug: this.debug});
+                await require('delay')(2000);
+                break;
             }
-          }
-        });
 
-      // otherwise fallback to legacy stuff?
-      } else {
-        return this.isUp().then(async isUp => {
-          if (!isUp) {
-            const retryOpts = retry ? {max: 25, backoff: 1000} : {max: 0};
-            return shell.sh(buildDockerCmd('start', this.scriptsDir, this.docker))
-            .catch(err => {
-              throw Error('Could not automatically start the Docker Daemon. Please manually start it to continue.');
-            })
-            // Likely need to retry until start command completes all good
-            .retry(() => this.isUp().then(isUp => (!isUp) ? Promise.reject() : Promise.resolve()), retryOpts)
-            // Fail if retry is no good
-            .catch(err => {
-              throw Error('Could not automatically start the Docker Daemon. Please manually start it to continue.');
-            })
-            // Engine is good!
-            .then(() => this.log.info('engine activated.'));
+            this.debug('build engine started but waiting to connect...');
+            return Promise.reject();
+          } catch (error) {
+            this.debug('could not start build engine with %o', error?.message);
+            this.debug('%j', error);
+            return Promise.reject(error);
           }
         });
-      }
+      };
+
+      return Promise.retry(starter, retry);
     })
 
     /*
@@ -158,11 +154,8 @@ module.exports = class LandoDaemon {
     .then(() => {
       // Automatically return true if we are in browsery context and on linux because
       // this requires SUDO and because the daemon should always be running on nix
-      if (
-        this.context !== 'node'
-        && process.platform === 'linux'
-        && !require('../utils/is-wsl-interop')(this.docker)
-      ) return Promise.resolve(true);
+      if (this.context !== 'node' && this.platform === 'linux') return Promise.resolve(true);
+
       // Automatically return if we are on Windows or Darwin because we don't
       // ever want to automatically turn the VM off since users might be using
       // D4M/W for other things.
@@ -172,15 +165,15 @@ module.exports = class LandoDaemon {
       //
       // @todo: When/if we can run our own isolated docker daemon we can change
       // this back.
-      if (
-        process.platform === 'win32'
-        || process.platform === 'darwin'
-        || require('../utils/is-wsl-interop')(this.docker)
-      ) return Promise.resolve(true);
+      if (this.platform === 'darwin' || this.platform === 'win32' || this.platform === 'wsl') {
+        return Promise.resolve(true);
+      }
+
       // Shut provider down if its status is running.
       return this.isUp(this.log, this.cache, this.docker).then(isUp => {
         if (isUp) return shell.sh(buildDockerCmd('stop', this.scriptsDir, this.docker), {mode: 'collect'});
       })
+
       // Wrap errors.
       .catch(err => {
         throw new Error(err, 'Error while shutting down.');
@@ -202,44 +195,54 @@ module.exports = class LandoDaemon {
    * this means we also assume whatever necessary installation checks have been
    * performed and dockers existence verified
    */
-  isUp(log = this.log, cache = this.cache, docker = this.docker) {
+  async isUp(log = this.log, cache = this.cache, docker = this.docker) {
     // Auto return if cached and true
     if (cache.get('engineup') === true) return Promise.resolve(true);
+
+    // on wsl lets rework docker to avoid perm issues on the socket?
+    if (this.platform === 'wsl' && fs.existsSync(WSL_DOCKER) ) docker = WSL_DOCKER;
+
     // Return true if we get a zero response and cache the result
-    return shell.sh([`"${docker}"`, 'info']).then(() => {
-      log.debug('engine is up.');
+    try {
+      await require('../utils/run-command')(docker, ['ps'], {debug: this.debug});
+      this.debug('engine is up.');
       cache.set('engineup', true, {ttl: 5});
       this.isRunning = true;
       return Promise.resolve(true);
-    })
-    .catch(error => {
-      log.debug('engine is down with error %s', error.message);
+    } catch (error) {
+      this.debug('engine is down with error %s', error.message);
       return Promise.resolve(false);
-    });
+    }
   };
 
   /*
    * Helper to get the versions of the things we need
    */
-  getVersions() {
+  async getVersions() {
     // presumably if we get this far orchestratorVersion is set and orchestratorBin exists
     const versions = {compose: this.orchestratorVersion, desktop: false, engine: false};
     // try to get either the desktop or engine
-    switch (process.platform) {
+    switch (this.platform) {
       case 'darwin':
         return getMacProp('CFBundleShortVersionString').then(version => ({...versions, desktop: version}));
       case 'linux':
         const cmd = [`"${this.docker}"`, 'version', '--format', '{{.Server.Version}}'];
         return shell.sh(cmd).catch(() => '18.0.0').then(version => ({...versions, engine: version}));
       case 'win32':
-        const dockerBinPath = require('../utils/get-docker-bin-path')();
-        const componentsVersionFile = path.resolve(dockerBinPath, '..', 'componentsVersion.json');
+      case 'wsl':
+        const componentsVersionFile = this.platform === 'win32'
+          ? path.resolve(getDockerBinPath('win32'), '..', 'componentsVersion.json') : '/Docker/host/componentsVersion.json';
+
+        // if cvf doesnt exist then just set it to something high and dont worry about it?
+        if (!fs.existsSync(componentsVersionFile)) {
+          versions.desktop = 'skip';
 
         // If we found one, use it but allow for a fallback in case these keys change
-        if (componentsVersionFile) {
+        } else {
           const {appVersion, Version, Informational} = require(componentsVersionFile);
           versions.desktop = appVersion ?? Version ?? Informational;
         }
+
         return Promise.resolve(versions);
     }
   };

package/lib/docker.js

@@ -69,7 +69,7 @@ module.exports = class Landerode extends Dockerode {
   /*
    * Returns a list of Lando containers
    */
-  list(options = {}, separator = '-') {
+  list(options = {}, separator = '_') {
     return this.listContainers(options)
     // Filter out nulls and undefineds.
     .filter(_.identity)
@@ -92,7 +92,7 @@ module.exports = class Landerode extends Dockerode {
     // Filter by app name if an app name was given.
     .then(containers => {
       if (options.project) return _.filter(containers, c => c.app === options.project);
-      else if (options.app) return _.filter(containers, c => c.app === (options.app));
+      else if (options.app) return _.filter(containers, c => c.app === require('../utils/docker-composify')(options.app)); // eslint-disable-line max-len
       return containers;
     })
     // Then finally filter by everything else

package/lib/engine.js

@@ -28,10 +28,13 @@ module.exports = class Engine {
     this.dockerInstalled = this.daemon.docker !== false;
 
     // set the compose separator
-    this.separator = _.get(config, 'orchestratorSeparator', '-');
+    this.separator = _.get(config, 'orchestratorSeparator', '_');
 
     // Grab the supported ranges for our things
     this.supportedVersions = config.dockerSupportedVersions;
+
+    // platform
+    this.platform = process.landoPlatform ?? process.platform;
   };
 
   /**
@@ -183,7 +186,7 @@ module.exports = class Engine {
       .map((data, name) => _.merge({}, data, {name}))
       .map(data => ([data.name, {
         satisfies: data.satisfies || `${data.min} - ${data.max}`,
-        link: data.link[process.platform],
+        link: data.link[this.platform],
         tested: data.tested || 'x.x.x',
         recommendUpdate: data.recommendUpdate || 'x.x.x',
       }]))
@@ -193,9 +196,13 @@ module.exports = class Engine {
     return this.daemon.getVersions().then(versions => {
       // Remove the things we don't need depending on platform
       // @TODO: Should daemon.getVersions just do this automatically?
-      if (process.platform === 'linux') delete versions.desktop;
+      if (this.platform === 'linux') delete versions.desktop;
       else delete versions.engine;
 
+      // handle skip
+      if (versions?.engine === 'skip') delete versions.engine;
+      if (versions?.desktop === 'skip') delete versions.desktop;
+
       // do the version comparison
       return _(versions).map((version, name) => {
         const reqs = supportedVersions[name];

package/lib/lando.js

@@ -715,9 +715,9 @@ module.exports = class Lando {
 
     const results = await Promise.all(options.tasks.map(async task => {
       // break it up
-      const {canRun, comments, description, hasRun, requiresRestart, version} = require('../utils/parse-setup-task')(task); // eslint-disable-line max-len
+      const {id, canRun, comments, description, hasRun, requiresRestart, version} = require('../utils/parse-setup-task')(task); // eslint-disable-line max-len
       // lets start optimistically
-      const status = {version, description, state: 'INSTALLED'};
+      const status = {version, description, id, state: 'INSTALLED'};
       // and slowly spiral down
       // @TODO: woiuld be great if hasRun could also return a "comment" eg
       // "installed but slightly above desired range"

package/lib/metrics.js

@@ -41,16 +41,18 @@ module.exports = class Metrics {
     const id = this.id;
     // Attempt to sanitize merged data as much as possible
     const send = cleanseData(_.merge({}, this.data, data, {action, created: new Date().toJSON()}));
-    // Log the attempt
-    log.verbose('reporting %s action to', action, this.endpoints);
-    log.debug('reported data', send);
     // Start the reporting chain
     return Promise.resolve(this.endpoints)
     // Filter out any inactive endpoints
     .filter(endpoint => endpoint.report)
     // Get the client and report
     .map(endpoint => {
+      // Log the attempt
+      log.verbose('reporting %s action to', action, this.endpoints);
+      log.debug('reporting data', send);
+
       const agent = getAxios({baseURL: endpoint.url});
+
       // Post the data
       return agent.post('/metrics/v2/' + id, send).catch(error => {
         const url = _.get(endpoint, 'url', 'unknown');

package/lib/updates.js

@@ -6,6 +6,7 @@ const get = require('lodash/get');
 const getOctokit = require('../utils/get-octokit');
 const os = require('os');
 const path = require('path');
+const remove = require('../utils/remove');
 const semver = require('semver');
 const uniqBy = require('lodash/uniqBy');
 
@@ -254,7 +255,16 @@ module.exports = class UpdateManager {
             // refresh the "symlink"
             require('../utils/link-bin')(this._cli.installPath, dest, {debug: this.debug});
 
-            // is link is not in PATH then attempt to add it
+            // set a good default update messag
+            task.title = `Updated @lando/cli to ${version}`;
+
+            // if lando.exe exists on windows in the install path then remove it so the link has primacy
+            // in PATHEXT hierarchy
+            if (process.platform === 'win32' && fs.existsSync(path.join(this._cli.installPath, filename))) {
+              remove(path.join(this._cli.installPath, filename));
+            }
+
+            // if link is not in PATH then attempt to add it
             // @NOTE: feels sufficient to just check for `lando` since it _should_ exist in win and posix
             if (!require('../utils/is-in-path')(path.join(this._cli.installPath, 'lando'))) {
               const binPaths = require('../utils/get-bin-paths')(this._cli);
@@ -274,6 +284,7 @@ module.exports = class UpdateManager {
                 const rcFile = require('../utils/get-shell-profile')();
                 require('../utils/update-shell-profile')(rcFile, shellEnv);
                 this.debug('added %o to %o', shellEnv, rcFile);
+                task.title = `${task.title}. Start a new terminal session to use the updated ${color.bold(`lando`)}`;
 
               // otherwis i guess do something else?
               // @TODO: throw a warning?
@@ -281,7 +292,6 @@ module.exports = class UpdateManager {
             }
 
             // finish
-            task.title = `Updated @lando/cli to ${version}`;
             resolve(data);
           });
           // handle errors

package/node_modules/nanoid/.devcontainer.json

@@ -0,0 +1,23 @@
+{
+  "image": "localhost/ai-opensource:latest",
+  "forwardPorts": [],
+  "mounts": [
+    {
+      "source": "pnpm-store",
+      "target": "/home/ai/.local/share/pnpm/store",
+      "type": "volume"
+    },
+    {
+      "source": "shell-history",
+      "target": "/home/ai/.local/share/history/",
+      "type": "volume"
+    }
+  ],
+  "workspaceMount": "",
+  "runArgs": [
+    "--userns=keep-id:uid=1000,gid=1000",
+    "--volume=${localWorkspaceFolder}:/workspaces/${localWorkspaceFolderBasename}:Z",
+    "--network=host",
+    "--ulimit=host"
+  ]
+}