projen 0.91.17 → 0.91.19

package/node_modules/shelljs/shell.js

@@ -11,7 +11,7 @@ var common = require('./src/common');
 //@
 //@ All commands run synchronously, unless otherwise stated.
 //@ All commands accept standard bash globbing characters (`*`, `?`, etc.),
-//@ compatible with the [node `glob` module](https://github.com/isaacs/node-glob).
+//@ compatible with [`fast-glob`](https://www.npmjs.com/package/fast-glob).
 //@
 //@ For less-commonly used commands and features, please check out our [wiki
 //@ page](https://github.com/shelljs/shelljs/wiki).
@@ -20,21 +20,68 @@ var common = require('./src/common');
 // Include the docs for all the default commands
 //@commands
 
-// Load all default commands
-require('./commands').forEach(function (command) {
-  require('./src/' + command);
-});
+// Load all default commands. We import these for their side effect of loading
+// using the plugin architecture via `common.register()`.
+require('./src/cat');
+require('./src/cd');
+require('./src/chmod');
+require('./src/cmd');
+require('./src/cp');
+require('./src/dirs');
+require('./src/echo');
+require('./src/exec');
+require('./src/exec-child'); // A hint to the bundler to keep exec-child.js
+require('./src/find');
+require('./src/grep');
+require('./src/head');
+require('./src/ln');
+require('./src/ls');
+require('./src/mkdir');
+require('./src/mv');
+require('./src/popd');
+require('./src/pushd');
+require('./src/pwd');
+require('./src/rm');
+require('./src/sed');
+require('./src/set');
+require('./src/sort');
+require('./src/tail');
+require('./src/tempdir');
+require('./src/test');
+require('./src/to');
+require('./src/toEnd');
+require('./src/touch');
+require('./src/uniq');
+require('./src/which');
 
 //@
 //@ ### exit(code)
 //@
 //@ Exits the current process with the given exit `code`.
-exports.exit = process.exit;
-
-//@include ./src/error
+exports.exit = function exit(code) {
+  common.state.error = null;
+  common.state.errorCode = 0;
+  if (code) {
+    common.error('exit', {
+      continue: true,
+      code: code,
+      prefix: '',
+      silent: true,
+      fatal: false,
+    });
+    process.exit(code);
+  } else {
+    process.exit();
+  }
+};
+
+//@include ./src/error.js
 exports.error = require('./src/error');
 
-//@include ./src/common
+//@include ./src/errorCode.js
+exports.errorCode = require('./src/errorCode');
+
+//@include ./src/common.js
 exports.ShellString = common.ShellString;
 
 //@
@@ -51,7 +98,7 @@ exports.env = process.env;
 //@
 //@ ```javascript
 //@ grep('foo', 'file1.txt', 'file2.txt').sed(/o/g, 'a').to('output.txt');
-//@ echo('files with o\'s in the name:\n' + ls().grep('o'));
+//@ echo("files with o's in the name:\n" + ls().grep('o'));
 //@ cat('test.js').exec('node'); // pipe to exec() call
 //@ ```
 //@
@@ -118,7 +165,14 @@ exports.config = common.config;
 //@ ```
 
 //@
-//@ ### config.globOptions
+//@ ### config.globOptions (deprecated)
+//@
+//@ **Deprecated**: we recommend that you do not edit `config.globOptions`.
+//@ Support for this configuration option may be changed or removed in a future
+//@ ShellJS release.
+//@
+//@ **Breaking change**: ShellJS v0.8.x uses `node-glob`. Starting with ShellJS
+//@ v0.9.x, `config.globOptions` is compatible with `fast-glob`.
 //@
 //@ Example:
 //@
@@ -126,7 +180,11 @@ exports.config = common.config;
 //@ config.globOptions = {nodir: true};
 //@ ```
 //@
-//@ Use this value for calls to `glob.sync()` instead of the default options.
+//@ `config.globOptions` changes how ShellJS expands glob (wildcard)
+//@ expressions. See
+//@ [fast-glob](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#options-3)
+//@ for available options. Be aware that modifying `config.globOptions` **may
+//@ break ShellJS functionality.**
 
 //@
 //@ ### config.reset()

package/node_modules/shelljs/src/cat.js

@@ -24,9 +24,9 @@ common.register('cat', _cat, {
 //@ var str = cat(['file1', 'file2']); // same as above
 //@ ```
 //@
-//@ Returns a string containing the given file, or a concatenated string
-//@ containing the files if more than one file is given (a new line character is
-//@ introduced between each file).
+//@ Returns a [ShellString](#shellstringstr) containing the given file, or a
+//@ concatenated string containing the files if more than one file is given (a
+//@ new line character is introduced between each file).
 function _cat(options, files) {
   var cat = common.readFromPipe();
 

package/node_modules/shelljs/src/cd.js

@@ -7,7 +7,8 @@ common.register('cd', _cd, {});
 //@ ### cd([dir])
 //@
 //@ Changes to directory `dir` for the duration of the script. Changes to home
-//@ directory if no argument is supplied.
+//@ directory if no argument is supplied. Returns a
+//@ [ShellString](#shellstringstr) to indicate success or failure.
 function _cd(options, dir) {
   if (!dir) dir = os.homedir();
 

package/node_modules/shelljs/src/chmod.js

@@ -59,6 +59,12 @@ common.register('chmod', _chmod, {
 //@ + In symbolic modes, `a-r` and `-r` are identical.  No consideration is
 //@   given to the `umask`.
 //@ + There is no "quiet" option, since default behavior is to run silent.
+//@ + Windows OS uses a very different permission model than POSIX. `chmod()`
+//@   does its best on Windows, but there are limits to how file permissions can
+//@   be set. Note that WSL (Windows subsystem for Linux) **does** follow POSIX,
+//@   so cross-platform compatibility should not be a concern there.
+//@
+//@ Returns a [ShellString](#shellstringstr) indicating success or failure.
 function _chmod(options, mode, filePattern) {
   if (!filePattern) {
     if (options.length > 0 && options.charAt(0) === '-') {
@@ -119,10 +125,10 @@ function _chmod(options, mode, filePattern) {
 
     var newPerms = perms;
 
-    if (isNaN(parseInt(mode, 8))) {
+    if (Number.isNaN(parseInt(mode, 8))) {
       // parse options
       mode.split(',').forEach(function (symbolicMode) {
-        var pattern = /([ugoa]*)([=\+-])([rwxXst]*)/i;
+        var pattern = /([ugoa]*)([=+-])([rwxXst]*)/i;
         var matches = pattern.exec(symbolicMode);
 
         if (matches) {
@@ -130,16 +136,16 @@ function _chmod(options, mode, filePattern) {
           var operator = matches[2];
           var change = matches[3];
 
-          var changeOwner = applyTo.indexOf('u') !== -1 || applyTo === 'a' || applyTo === '';
-          var changeGroup = applyTo.indexOf('g') !== -1 || applyTo === 'a' || applyTo === '';
-          var changeOther = applyTo.indexOf('o') !== -1 || applyTo === 'a' || applyTo === '';
+          var changeOwner = applyTo.includes('u') || applyTo === 'a' || applyTo === '';
+          var changeGroup = applyTo.includes('g') || applyTo === 'a' || applyTo === '';
+          var changeOther = applyTo.includes('o') || applyTo === 'a' || applyTo === '';
 
-          var changeRead = change.indexOf('r') !== -1;
-          var changeWrite = change.indexOf('w') !== -1;
-          var changeExec = change.indexOf('x') !== -1;
-          var changeExecDir = change.indexOf('X') !== -1;
-          var changeSticky = change.indexOf('t') !== -1;
-          var changeSetuid = change.indexOf('s') !== -1;
+          var changeRead = change.includes('r');
+          var changeWrite = change.includes('w');
+          var changeExec = change.includes('x');
+          var changeExecDir = change.includes('X');
+          var changeSticky = change.includes('t');
+          var changeSetuid = change.includes('s');
 
           if (changeExecDir && isDir) {
             changeExec = true;

package/node_modules/shelljs/src/cmd.js

@@ -0,0 +1,122 @@
+var common = require('./common');
+var execa = require('execa');
+
+var DEFAULT_MAXBUFFER_SIZE = 20 * 1024 * 1024;
+var COMMAND_NOT_FOUND_ERROR_CODE = 127;
+
+common.register('cmd', _cmd, {
+  cmdOptions: null,
+  globStart: 1,
+  canReceivePipe: true,
+  wrapOutput: true,
+});
+
+function commandNotFound(execaResult) {
+  if (process.platform === 'win32') {
+    var str = 'is not recognized as an internal or external command';
+    return execaResult.code && execaResult.stderr.includes(str);
+  } else {
+    return execaResult.code &&
+      execaResult.stdout === null && execaResult.stderr === null;
+  }
+}
+
+//@
+//@ ### cmd(arg1[, arg2, ...] [, options])
+//@
+//@ Available options:
+//@
+//@ + `cwd: directoryPath`: change the current working directory only for this
+//@   cmd() invocation.
+//@ + `maxBuffer: num`: Raise or decrease the default buffer size for
+//@   stdout/stderr.
+//@ + `timeout`: Change the default timeout.
+//@
+//@ Examples:
+//@
+//@ ```javascript
+//@ var version = cmd('node', '--version').stdout;
+//@ cmd('git', 'commit', '-am', `Add suport for node ${version}`);
+//@ console.log(cmd('echo', '1st arg', '2nd arg', '3rd arg').stdout)
+//@ console.log(cmd('echo', 'this handles ;, |, &, etc. as literal characters').stdout)
+//@ ```
+//@
+//@ Executes the given command synchronously. This is intended as an easier
+//@ alternative for [exec()](#execcommand--options--callback), with better
+//@ security around globbing, comamnd injection, and variable expansion. This is
+//@ guaranteed to only run one external command, and won't give special
+//@ treatment for any shell characters (ex. this treats `|` as a literal
+//@ character, not as a shell pipeline).
+//@ This returns a [ShellString](#shellstringstr).
+//@
+//@ By default, this performs globbing on all platforms, but you can disable
+//@ this with `set('-f')`.
+//@
+//@ This **does not** support asynchronous mode. If you need asynchronous
+//@ command execution, check out [execa](https://www.npmjs.com/package/execa) or
+//@ the node builtin `child_process.execFile()` instead.
+function _cmd(options, command, commandArgs, userOptions) {
+  if (!command) {
+    common.error('Must specify a non-empty string as a command');
+  }
+
+  // `options` will usually not have a value: it's added by our commandline flag
+  // parsing engine.
+  commandArgs = [].slice.call(arguments, 2);
+
+  // `userOptions` may or may not be provided. We need to check the last
+  // argument. If it's an object, assume it's meant to be passed as
+  // userOptions (since ShellStrings are already flattened to strings).
+  if (commandArgs.length === 0) {
+    userOptions = {};
+  } else {
+    var lastArg = commandArgs.pop();
+    if (common.isObject(lastArg)) {
+      userOptions = lastArg;
+    } else {
+      userOptions = {};
+      commandArgs.push(lastArg);
+    }
+  }
+
+  var pipe = common.readFromPipe();
+
+  // Some of our defaults differ from execa's defaults. These can be overridden
+  // by the user.
+  var defaultOptions = {
+    maxBuffer: DEFAULT_MAXBUFFER_SIZE,
+    stripEof: false, // Preserve trailing newlines for consistency with unix.
+    reject: false, // Use ShellJS's error handling system.
+  };
+
+  // For other options, we forbid the user from overriding them (either for
+  // correctness or security).
+  var requiredOptions = {
+    input: pipe,
+    shell: false,
+  };
+
+  var execaOptions =
+    Object.assign(defaultOptions, userOptions, requiredOptions);
+
+  var result = execa.sync(command, commandArgs, execaOptions);
+  var stdout;
+  var stderr;
+  var code;
+  if (commandNotFound(result)) {
+    // This can happen if `command` is not an executable binary, or possibly
+    // under other conditions.
+    stdout = '';
+    stderr = "'" + command + "': command not found";
+    code = COMMAND_NOT_FOUND_ERROR_CODE;
+  } else {
+    stdout = result.stdout.toString();
+    stderr = result.stderr.toString();
+    code = result.code;
+  }
+
+  // Pass `continue: true` so we can specify a value for stdout.
+  if (code) common.error(stderr, code, { silent: true, continue: true });
+  return new common.ShellString(stdout, stderr, code);
+}
+module.exports = _cmd;

package/node_modules/shelljs/src/common.js

@@ -1,10 +1,12 @@
-// Ignore warning about 'new String()'
-/* eslint no-new-wrappers: 0 */
+// Ignore warning about 'new String()' and use of the Buffer constructor
+/* eslint no-new-wrappers: "off",
+   no-buffer-constructor: "off" */
+
 'use strict';
 
 var os = require('os');
 var fs = require('fs');
-var glob = require('glob');
+var glob = require('fast-glob');
 var shell = require('..');
 
 var shellMethods = Object.create(shell);
@@ -77,7 +79,16 @@ function convertErrorOutput(msg) {
 }
 exports.convertErrorOutput = convertErrorOutput;
 
-// Shows error message. Throws if config.fatal is true
+// An exception class to help propagate command errors (e.g., non-zero exit
+// status) up to the top-level. {@param value} should be a ShellString.
+function CommandError(value) {
+  this.returnValue = value;
+}
+CommandError.prototype = Object.create(Error.prototype);
+CommandError.prototype.constructor = CommandError;
+exports.CommandError = CommandError; // visible for testing
+
+// Shows error message. Throws if fatal is true (defaults to config.fatal, overridable with options.fatal)
 function error(msg, _code, options) {
   // Validate input
   if (typeof msg !== 'string') throw new Error('msg must be a string');
@@ -87,6 +98,7 @@ function error(msg, _code, options) {
     code: 1,
     prefix: state.currentCmd + ': ',
     silent: false,
+    fatal: config.fatal,
   };
 
   if (typeof _code === 'number' && isObject(options)) {
@@ -107,14 +119,15 @@ function error(msg, _code, options) {
   state.error += logEntry;
 
   // Throw an error, or log the entry
-  if (config.fatal) throw new Error(logEntry);
+  if (options.fatal) {
+    var err = new Error(logEntry);
+    err.code = options.code;
+    throw err;
+  }
   if (msg.length > 0 && !options.silent) log(logEntry);
 
   if (!options.continue) {
-    throw {
-      msg: 'earlyExit',
-      retValue: (new ShellString('', state.error, state.errorCode)),
-    };
+    throw new CommandError(new ShellString('', state.error, state.errorCode));
   }
 }
 exports.error = error;
@@ -125,11 +138,19 @@ exports.error = error;
 //@ Examples:
 //@
 //@ ```javascript
-//@ var foo = ShellString('hello world');
+//@ var foo = new ShellString('hello world');
 //@ ```
 //@
-//@ Turns a regular string into a string-like object similar to what each
-//@ command returns. This has special methods, like `.to()` and `.toEnd()`.
+//@ This is a dedicated type returned by most ShellJS methods, which wraps a
+//@ string (or array) value. This has all the string (or array) methods, but
+//@ also exposes extra methods: [`.to()`](#shellstringprototypetofile),
+//@ [`.toEnd()`](#shellstringprototypetoendfile), and all the pipe-able methods
+//@ (ex. `.cat()`, `.grep()`, etc.). This can be easily converted into a string
+//@ by calling `.toString()`.
+//@
+//@ This type also exposes the corresponding command's stdout, stderr, and
+//@ return status code via the `.stdout` (string), `.stderr` (string), and
+//@ `.code` (number) properties respectively.
 function ShellString(stdout, stderr, code) {
   var that;
   if (stdout instanceof Array) {
@@ -159,13 +180,16 @@ exports.ShellString = ShellString;
 // Throws an error when passed a string that does not start with '-':
 //   parseOptions('a', {'a':'alice'}); // throws
 function parseOptions(opt, map, errorOptions) {
+  errorOptions = errorOptions || {};
   // Validate input
   if (typeof opt !== 'string' && !isObject(opt)) {
-    throw new Error('options must be strings or key-value pairs');
+    throw new TypeError('options must be strings or key-value pairs');
   } else if (!isObject(map)) {
-    throw new Error('parseOptions() internal error: map must be an object');
-  } else if (errorOptions && !isObject(errorOptions)) {
-    throw new Error('parseOptions() internal error: errorOptions must be object');
+    throw new TypeError('parseOptions() internal error: map must be an object');
+  } else if (!isObject(errorOptions)) {
+    throw new TypeError(
+        'parseOptions() internal error: errorOptions must be object'
+    );
   }
 
   if (opt === '--') {
@@ -201,18 +225,25 @@ function parseOptions(opt, map, errorOptions) {
           options[optionName] = true;
         }
       } else {
-        error('option not recognized: ' + c, errorOptions || {});
+        error('option not recognized: ' + c, errorOptions);
       }
     });
   } else { // opt is an Object
     Object.keys(opt).forEach(function (key) {
-      // key is a string of the form '-r', '-d', etc.
-      var c = key[1];
-      if (c in map) {
-        var optionName = map[c];
-        options[optionName] = opt[key]; // assign the given value
+      if (key[0] === '-') {
+        // key is a string of the form '-r', '-d', etc.
+        var c = key[1];
+        if (c in map) {
+          var optionName = map[c];
+          options[optionName] = opt[key]; // assign the given value
+        } else {
+          error('option not recognized: ' + c, errorOptions);
+        }
+      } else if (key in options) {
+        // key is a "long option", so it should be the same
+        options[key] = opt[key];
       } else {
-        error('option not recognized: ' + c, errorOptions || {});
+        error('option not recognized: {' + key + ':...}', errorOptions);
       }
     });
   }
@@ -220,6 +251,42 @@ function parseOptions(opt, map, errorOptions) {
 }
 exports.parseOptions = parseOptions;
 
+function globOptions() {
+  // These options are just to make fast-glob be compatible with POSIX (bash)
+  // wildcard behavior.
+  var defaultGlobOptions = {
+    onlyFiles: false,
+    followSymbolicLinks: false,
+  };
+
+  var newGlobOptions = Object.assign({}, config.globOptions);
+  var optionRenames = {
+    // node-glob's 'nodir' is not quote the same as fast-glob's 'onlyFiles'.
+    // Compatibility for this is implemented at the call site.
+    mark: 'markDirectories',
+    matchBase: 'baseNameMatch',
+  };
+  Object.keys(optionRenames).forEach(function (oldKey) {
+    var newKey = optionRenames[oldKey];
+    if (oldKey in config.globOptions) {
+      newGlobOptions[newKey] = config.globOptions[oldKey];
+    }
+  });
+  var invertedOptionRenames = {
+    nobrace: 'braceExpansion',
+    noglobstar: 'globstar',
+    noext: 'extglob',
+    nocase: 'caseSensitiveMatch',
+  };
+  Object.keys(invertedOptionRenames).forEach(function (oldKey) {
+    var newKey = invertedOptionRenames[oldKey];
+    if (oldKey in config.globOptions) {
+      newGlobOptions[newKey] = !config.globOptions[oldKey];
+    }
+  });
+  return Object.assign({}, defaultGlobOptions, newGlobOptions);
+}
+
 // Expands wildcards with matching (ie. existing) file names.
 // For example:
 //   expand(['file*.js']) = ['file1.js', 'file2.js', ...]
@@ -235,14 +302,20 @@ function expand(list) {
       expanded.push(listEl);
     } else {
       var ret;
+      var globOpts = globOptions();
       try {
-        ret = glob.sync(listEl, config.globOptions);
-        // if nothing matched, interpret the string literally
-        ret = ret.length > 0 ? ret : [listEl];
+        ret = glob.sync(listEl, globOpts);
       } catch (e) {
         // if glob fails, interpret the string literally
         ret = [listEl];
       }
+      // if nothing matched, interpret the string literally
+      ret = ret.length > 0 ? ret.sort() : [listEl];
+      if (globOpts.nodir) {
+        ret = ret.filter(function (file) {
+          return !statNoFollowLinks(file).isDirectory();
+        });
+      }
       expanded = expanded.concat(ret);
     }
   });
@@ -384,8 +457,8 @@ function wrap(cmd, fn, options) {
           retValue = fn.apply(this, args);
         } catch (e) {
           /* istanbul ignore else */
-          if (e.msg === 'earlyExit') {
-            retValue = e.retValue;
+          if (e instanceof CommandError) {
+            retValue = e.returnValue;
           } else {
             throw e; // this is probably a bug that should be thrown up the call stack
           }
@@ -398,7 +471,7 @@ function wrap(cmd, fn, options) {
         e.name = 'ShellJSInternalError';
         throw e;
       }
-      if (config.fatal) throw e;
+      if (config.fatal || options.handlesFatalDynamically) throw e;
     }
 
     if (options.wrapOutput &&
@@ -424,6 +497,7 @@ var DEFAULT_WRAP_OPTIONS = {
   canReceivePipe: false,
   cmdOptions: null,
   globStart: 1,
+  handlesFatalDynamically: false,
   pipeOnly: false,
   wrapOutput: true,
   unix: true,

package/node_modules/shelljs/src/cp.js

@@ -11,6 +11,7 @@ common.register('cp', _cp, {
     'r': 'recursive',
     'L': 'followsymlink',
     'P': 'noFollowsymlink',
+    'p': 'preserve',
   },
   wrapOutput: false,
 });
@@ -51,6 +52,7 @@ function copyFileSync(srcFile, destFile, options) {
     var pos = 0;
     var fdr = null;
     var fdw = null;
+    var srcStat = common.statFollowLinks(srcFile);
 
     try {
       fdr = fs.openSync(srcFile, 'r');
@@ -60,7 +62,7 @@ function copyFileSync(srcFile, destFile, options) {
     }
 
     try {
-      fdw = fs.openSync(destFile, 'w');
+      fdw = fs.openSync(destFile, 'w', srcStat.mode);
     } catch (e) {
       /* istanbul ignore next */
       common.error('copyFileSync: could not write to dest file (code=' + e.code + '):' + destFile);
@@ -72,10 +74,15 @@ function copyFileSync(srcFile, destFile, options) {
       pos += bytesRead;
     }
 
+    if (options.preserve) {
+      fs.fchownSync(fdw, srcStat.uid, srcStat.gid);
+      // Note: utimesSync does not work (rounds to seconds), but futimesSync has
+      // millisecond precision.
+      fs.futimesSync(fdw, srcStat.atime, srcStat.mtime);
+    }
+
     fs.closeSync(fdr);
     fs.closeSync(fdw);
-
-    fs.chmodSync(destFile, common.statFollowLinks(srcFile).mode);
   }
 }
 
@@ -96,8 +103,9 @@ function cpdirSyncRecursive(sourceDir, destDir, currentDepth, opts) {
 
   var isWindows = process.platform === 'win32';
 
-  // Create the directory where all our junk is moving to; read the mode of the
-  // source directory and mirror it
+  // Create the directory where all our junk is moving to; read the mode/etc. of
+  // the source directory (we'll set this on the destDir at the end).
+  var checkDir = common.statFollowLinks(sourceDir);
   try {
     fs.mkdirSync(destDir);
   } catch (e) {
@@ -141,19 +149,19 @@ function cpdirSyncRecursive(sourceDir, destDir, currentDepth, opts) {
       } else {
         copyFileSync(srcFile, destFile, opts);
       }
+    } else if (fs.existsSync(destFile) && opts.no_force) {
+      common.log('skipping existing file: ' + files[i]);
     } else {
-      /* At this point, we've hit a file actually worth copying... so copy it on over. */
-      if (fs.existsSync(destFile) && opts.no_force) {
-        common.log('skipping existing file: ' + files[i]);
-      } else {
-        copyFileSync(srcFile, destFile, opts);
-      }
+      copyFileSync(srcFile, destFile, opts);
     }
   } // for files
 
   // finally change the mode for the newly created directory (otherwise, we
   // couldn't add files to a read-only directory).
-  var checkDir = common.statFollowLinks(sourceDir);
+  // var checkDir = common.statFollowLinks(sourceDir);
+  if (opts.preserve) {
+    fs.utimesSync(destDir, checkDir.atime, checkDir.mtime);
+  }
   fs.chmodSync(destDir, checkDir.mode);
 } // cpdirSyncRecursive
 
@@ -199,6 +207,7 @@ function cpcheckcycle(sourceDir, srcFile) {
 //@ + `-r`, `-R`: recursive
 //@ + `-L`: follow symlinks
 //@ + `-P`: don't follow symlinks
+//@ + `-p`: preserve file mode, ownership, and timestamps
 //@
 //@ Examples:
 //@
@@ -209,7 +218,8 @@ function cpcheckcycle(sourceDir, srcFile) {
 //@ cp('-Rf', ['/tmp/*', '/usr/local/*'], '/home/tmp'); // same as above
 //@ ```
 //@
-//@ Copies files.
+//@ Copies files. Returns a [ShellString](#shellstringstr) indicating success
+//@ or failure.
 function _cp(options, sources, dest) {
   // If we're missing -R, it actually implies -L (unless -P is explicit)
   if (options.followsymlink) {
@@ -260,7 +270,7 @@ function _cp(options, sources, dest) {
 
         try {
           common.statFollowLinks(path.dirname(dest));
-          cpdirSyncRecursive(src, newDest, 0, { no_force: options.no_force, followsymlink: options.followsymlink });
+          cpdirSyncRecursive(src, newDest, 0, options);
         } catch (e) {
           /* istanbul ignore next */
           common.error("cannot create directory '" + dest + "': No such file or directory");