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

package/tasks/init.js

@@ -44,7 +44,7 @@ const runBuild = (lando, options = {}, steps = []) => lando.Promise.each(steps,
         step,
       )),
     );
-  };
+  }
 });
 
 module.exports = lando => {
@@ -80,7 +80,7 @@ module.exports = lando => {
     [--yes]
     [--other-plugin-provided-options...]`,
     options: _.merge(getInitBaseOpts(recipes, sources), configOpts, getInitOveridesOpts(inits, recipes, sources)),
-    run: options => {
+    run: async options => {
       // Parse options abd and configs
       options = parseInitOptions(options);
       // Get our recipe and source configs
@@ -90,44 +90,49 @@ module.exports = lando => {
       const buildSteps = (_.has(sourceConfig, 'build')) ? sourceConfig.build(options, lando) : [];
       const configStep = (_.has(recipeConfig, 'build')) ? recipeConfig.build : () => {};
 
+      // run setup if we need to
+      await require('../hooks/lando-run-setup')(lando);
+
       // Pre init event and run build steps
       // @NOTE: source build steps are designed to grab code from somewhere
-      return lando.events.emit('pre-init', options, buildSteps).then(() => runBuild(lando, options, buildSteps))
+      await lando.events.emit('pre-init', options, buildSteps);
+
+      // run build
+      await runBuild(lando, options, buildSteps);
+
       // Run any config steps
       // @NOTE: config steps are designed to augmnet the landofile with additional metadata
-      .then(() => configStep(options, lando))
+      const config = await configStep(options, lando);
 
       // Compile and dump the yaml
-      .then((config = {}) => {
-        // if config is false then it means we want to skip landofile mutation
-        if (config !== false) {
-          // Where are we going?
-          const dest = path.join(options.destination, '.lando.yml');
-          const landoFile = getYaml(dest, options, lando);
-
-          // Get a lower level config if needed, merge in current recipe config
-          if (options.full) {
-            const Recipe = lando.factory.get(options.recipe);
-            const recipeConfig = _.merge({}, landoFile, {app: landoFile.name, _app: {_config: lando.config}});
-            _.merge(landoFile, new Recipe(landoFile.name, recipeConfig).config);
-          }
-
-          // Merge in any additional configuration options specified
-          _.forEach(options.option, option => {
-            const key = _.first(option.split('='));
-            _.set(landoFile, `config.${key}`, _.last(option.split('=')));
-          });
-
-          // Merge and dump the config file
-          lando.yaml.dump(dest, _.merge(landoFile, config));
+      // if config is false then it means we want to skip landofile mutation
+      if (config !== false) {
+        // Where are we going?
+        const dest = path.join(options.destination, '.lando.yml');
+        const landoFile = getYaml(dest, options, lando);
+
+        // Get a lower level config if needed, merge in current recipe config
+        if (options.full) {
+          const Recipe = lando.factory.get(options.recipe);
+          const recipeConfig = _.merge({}, landoFile, {app: landoFile.name, _app: {_config: lando.config}});
+          _.merge(landoFile, new Recipe(landoFile.name, recipeConfig).config);
         }
 
-        // Show it
-        showInit(lando, options);
-      })
+        // Merge in any additional configuration options specified
+        _.forEach(options.option, option => {
+          const key = _.first(option.split('='));
+          _.set(landoFile, `config.${key}`, _.last(option.split('=')));
+        });
+
+        // Merge and dump the config file
+        lando.yaml.dump(dest, _.merge(landoFile, config));
+      }
+
+      // Show it
+      showInit(lando, options);
 
       // Post init event
-      .then(() => lando.events.emit('post-init', options));
+      await lando.events.emit('post-init', options);
     },
   };
 };

package/tasks/rebuild.js

@@ -33,16 +33,10 @@ module.exports = lando => {
       if (app) {
         console.log(lando.cli.makeArt('appRebuild', {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);
 
         try {
-          // run a limited setup if needed
-          if (setupTasks.length > 0) await lando.setup(sopts);
           // If user has given us options then set those
           if (!_.isEmpty(options.service)) app.opts = _.merge({}, app.opts, {services: options.service});
           // rebuild hero

package/tasks/restart.js

@@ -16,17 +16,11 @@ module.exports = lando => {
       if (app) {
         console.log(lando.cli.makeArt('appRestart', {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 restart
           await app.restart();
           // determine legacy settings

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) => {