dcp-client 5.0.4 → 5.1.1

package/index.js

@@ -6,24 +6,23 @@
  *              same directory as this file, and inject the exported modules into the NodeJS
  *              module environment.
  *
- *              There are three initialization styles provided, which are all basically the same, 
+ *              There are three initialization styles provided, which are all basically the same,
  *              have different calling styles;
  *              1. initSync - blocks until initialization is complete
  *              2. init     - returns a Promise, is an "async" function; resolve when initialization is complete
  *              3. initcb   - invokes a callback when initialization is complete
  *
- *              During initialization, we 
- *              2. build the layered dcp-config for the program invoking init 
+ *              During initialization, we
+ *              2. build the layered dcp-config for the program invoking init
  *                 (see: https://people.kingsds.network/wesgarland/dcp-client-priorities.html /wg aug 2020)
  *              3. download a new bundle if auto-update is on
  *              4. make the bundle "see" the layered dcp-config as their global dcpConfig
- *              5. re-inject the bundle modules (possibly from the new bundle) 
+ *              5. re-inject the bundle modules (possibly from the new bundle)
  *
  * @author      Wes Garland, wes@kingsds.network
  * @date        July 2019
  */
 'use strict';
-
 var   reportErrors = true; /* can be overridden by options.reportErrors during init() */
 var   KVIN;                /* KVIN context from internal kvin */
 var   XMLHttpRequest;      /* from internal dcp-xhr */
@@ -40,7 +39,7 @@ const vm = require('vm');
 const protectedDcpConfigKeys = [ 'system', 'bundle', 'worker', 'evaluator' ];
 
 let initInvoked = false; /* flag to help us detect use of Compute API before init */
-let originalDcpConfig = globalThis.dcpConfig || false; /* not false if user set their own dcpConfig global variable before init */
+let originalDcpConfig = globalThis.dcpConfig || undefined; /* not undefined if user set their own dcpConfig global variable before init */
 globalThis.dcpConfig = originalDcpConfig || { __filename };
 
 const distDir = path.resolve(path.dirname(module.filename), 'dist');
@@ -49,15 +48,21 @@ const distDir = path.resolve(path.dirname(module.filename), 'dist');
  * nodes of the right that we can expect to be overwritten by the registry.
  */
 const bootstrapConfig = {
-    build: 'bootstrap',
-    bundleConfig: true,
-    scheduler:          { location: new URL('http://bootstrap.distributed.computer/') },
-    bank:               { location: new URL('http://bootstrap.distributed.computer/') },
-    packageManager:     { location: new URL('http://bootstrap.distributed.computer/') },
-    needs: { urlPatchUp: true },
+  __bootstrapConfig: true,
+  bundleConfig: true,
+  scheduler:          { location: new URL('http://bootstrap.distributed.computer/') },
+  bank:               { location: new URL('http://bootstrap.distributed.computer/') },
+  packageManager:     { location: new URL('http://bootstrap.distributed.computer/') },
+  portal:             { location: new URL('http://bootstrap.distributed.computer/') },
+  pxAuth:             { location: new URL('http://bootstrap.distributed.computer/') },
+  oAuth:              { location: new URL('http://bootstrap.distributed.computer/') },
+  cdn:                { location: new URL('http://bootstrap.distributed.computer/') },
+  worker:             {},
+  global:             {},
+  dcp:                {},
 };
 
-const bundleSandbox = {
+const bundleScope = {
   URL,
   URLSearchParams,
   // GPU,
@@ -90,31 +95,49 @@ const bundleSandbox = {
   window: globalThis,
 };
 
-function runSandboxedCode(sandbox, code, options)
+
+/**
+ * Run code with symbols injected into the function scope.
+ * @param {Object} symbols    An object whose properties are names of symbols which will be available
+ *                            in the evaluation scope; the symbol values are the object values.
+ */
+function runCodeWithSymbols(symbols, code, options)
 {
-  const ctx = vm.createContext(sandbox);
-  const script = new vm.Script(code, options);
-  return script.runInContext(ctx, options);
+  const wrapperFunArgs = Object.keys(symbols);
+  const invokeArgs = Object.values(symbols);
+  const wrappedCode = `"use strict";\n(function __rcws_wrapper(${wrapperFunArgs.join(',')}) { ${code} })`;
+
+  options = Object.assign({ columnOffset: Number(options?.columnOffset) + 12 }, options);
+  const script = new vm.Script(wrappedCode, options);
+  const rcwsWrapper = script.runInThisContext(options);
+  return rcwsWrapper.apply(globalThis, invokeArgs);
 }
 
-/** Evaluate a file in a sandbox without polluting the global object.
- *  @param      filename        {string}    The name of the file to evaluate, relative to
- *  @param      sandbox         {object}    A sandbox object, used for injecting 'global' symbols as needed
+/**
+ * Evaluate a file inside a namespace-protecting IIFE; similar the new vm contexts used for configury,
+ * but using the current context so that Object literals are instances of this context's Object.
+ *
+ * @param {string} filename The name of a file which contains a single JS expression
+ * @param {object} gsymbox  An object which simulates the global object via symbol collision; any
+ *                          symbols which don't collide are resolved up the scope chain against this
+ *                          context's global object.
+ * @param {object} options  Options to pass to vm.runInThisContext()
+ *
+ * @returns the value of the expression in the file
  */
-function evalScriptInSandbox(filename, sandbox)
+function evalBundleCodeInIIFE(code, gsymbox, options)
 {
-  var code
-  try {
-    debug('dcp-client:evalScriptInSandbox')('evaluating', filename);
-    code = fs.readFileSync(path.resolve(distDir, filename), 'utf8');
-  } catch(e) {
-    if (e.code === 'ENOENT')
-      return {}
-    debug('dcp-client:evalScriptInSandbox')(e);
-    throw e
-  }
+  const prologue = '(function __dynamic_evalBundle__IIFE(' + Object.keys(gsymbox).join(',') + '){ return ';
+  const epilogue = '\n});';
+
+  options = Object.assign({ filename: '(eval code)', lineOffset: 0 }, options);
+  if (options?.filename)
+    debug('dcp-client:evalBundle')('evaluating file', options.filename);
+  else
+    debug('dcp-client:evalBundle')(`evaluating code ${code.slice(0,40).replace('\n', ' ')}...`);
 
-  return runSandboxedCode(sandbox, code, { filename, lineOffset: 0 });
+  const fun = vm.runInThisContext(prologue + code + epilogue, options);
+  return fun.apply(null, Object.values(gsymbox));
 }
 
 /**
@@ -122,66 +145,44 @@ function evalScriptInSandbox(filename, sandbox)
  * but using the current context so that Object literals are instances of this context's Object.
  *
  * @param {string} filename The name of a file which contains a single JS expression
- * @param {object} sandbox  An object which simulates the global object via symbol collision; any
+ * @param {object} gsymbox  An object which simulates the global object via symbol collision; any
  *                          symbols which don't collide are resolved up the scope chain against this
  *                          context's global object.
  * @returns the value of the expression in the file
  */
-function evalFileInIIFE(filename, sandbox)
+function evalBundleFileInIIFE(filename, gsymbox)
 {
-  const prologue = '(function __dynamic_evalFile__IIFE(' + Object.keys(sandbox).join(',') + '){ return ';
-  const epilogue = '\n});';
-  const options = { filename, lineOffset: 0 };
-  
-  debug('dcp-client:evalFileInIIFE')('evaluating', filename);
   const fileContents = fs.readFileSync(path.resolve(distDir, filename), 'utf8');
-  const fun = vm.runInThisContext(prologue + fileContents + epilogue, options);
-
-  return fun.apply(null, Object.values(sandbox));
+  return evalBundleCodeInIIFE(fileContents, gsymbox, { filename });
 }
 
-/** Evaluate code in a secure sandbox; in this case, the code is the configuration
- *  file, and the sandbox is a special container with limited objects that we setup
- *  during config file processing.
- *  'code' must come from a trusted source, so we don't execute unknown code.
+/**
+ * Evaluate a config file (eg. dcp-config fragment) in a function scope of the current context that has
+ * extra symbols injected for use by the config file.
  *
- *  @param      code     {string}        The code to eval
- *  @param      sandbox  {object}        A sandbox object, used for injecting 'global' symbols as needed
+ *  @param      symbols  {object}        An object used for injecting 'global' symbols as needed
  *  @param      filename {string}        The name of the file we're evaluating for stack-
  *                                       trace purposes.
  */
-function evalStringInSandbox(code, sandbox, filename = '(dcp-client$$evalStringInSandbox)')
+function evalConfigFile(symbols, filename)
 {
-  var result;
+  var code = fs.readFileSync(filename, 'utf-8');
   const codeHasVeryLongLine = Boolean(/[^\n]{1000,}[^\n]*\n/.test(code));
   const runOptions = {
     filename,
     lineOffset: 0,
-    columnOffset: 12, /* use strict */
+    columnOffset: 0,
     displayErrors: !codeHasVeryLongLine
   };
 
-  /* We support two types of strings - one produces a value, the other returns a value. Use the JS
-   * parser to figure out which syntax this code is in. In the case of a produced value, we use the
-   * last value which was evaluated by the engine as the result, just like eval.
-   */
-  try
-  {
-    result = runSandboxedCode(sandbox, '"use strict";' + code, runOptions);
-  }
-  catch(error)
+  if (withoutComments(code).match(/^\s*{/)) /* config file is just a JS object literal */
   {
-    const nodejsErrorMessage = /^Illegal return statement/;
-    const bunErrorMessage = /^Return statements are only valid inside functions./;
-    if (!nodejsErrorMessage.test(error.message) && !bunErrorMessage.test(error.message))
-      throw error;
-
-    code = `(() => {;${code}})()`; /* wrap in IIFE so conf can return objects */
-    runOptions.columnOffset += 9;
-    result = runSandboxedCode(sandbox, '"use strict";' + code, runOptions);
+    code = `return (${code})`;
+    runOptions.columnOffset = 8;
   }
 
-  return result;
+  debug('dcp-client:evalConfigFile')('evaluating config file', runOptions.filename);
+  return runCodeWithSymbols(symbols, code, runOptions);
 }
 
 /**
@@ -193,26 +194,27 @@ function withoutComments(code) {
   return code.replace(/(\/\*([\s\S]*?)\*\/)|(\/\/(.*)$)/gm, '')
 }
 
-/** 
+/**
  * Load the bootstrap bundle - used primarily to plumb in utils::justFetch.
- * Runs in a different, but identical, sandbox as the config files and client code. This code is
- * evaluated with the bootstrap config as dcpConfig so that static initialization of dcpConfig in
- * any of the bootstrap modules can mutate the bottom-most layer of the dcpConfig stack.
+ * Runs in a different, but identical, scope the config files and client code. This code is evaluated
+ * with the bootstrap config as dcpConfig so that static initialization of dcpConfig in any of the
+ * bootstrap modules can mutate the bottom-most layer of the dcpConfig stack.
  */
 function loadBootstrapBundle() {
-  let sandbox = {}
-
-  Object.assign(sandbox, bundleSandbox)
-  sandbox.globalThis = sandbox;
-  sandbox.window     = sandbox;
-  sandbox.dcpConfig  = bootstrapConfig;
-  
-  return evalScriptInSandbox(path.resolve(distDir, 'dcp-client-bundle.js'), sandbox)
+  const bundleFilename = path.resolve(distDir, 'dcp-client-bundle.js');
+  const scope = Object.assign(bundleScope, { dcpConfig: bootstrapConfig });
+
+  scope.globalThis = scope;
+  scope.window     = scope;
+  scope.dcpConfig  = bootstrapConfig;
+
+  debug('dcp-client:bundle')(' - loading bootstrap bundle');
+  return evalBundleFileInIIFE(bundleFilename, Object.assign({}, bundleScope));
 }
 
 const injectedModules = {};
 const resolveFilenamePrevious = moduleSystem._resolveFilename;
-moduleSystem._resolveFilename = function dcpClient$$injectModule$resolveFilenameShim(moduleIdentifier) { 
+moduleSystem._resolveFilename = function dcpClient$$injectModule$resolveFilenameShim(moduleIdentifier) {
   if (injectedModules.hasOwnProperty(moduleIdentifier)) {
     if (!initInvoked) {
       if( moduleIdentifier === 'dcp/compute') throw new Error(`module ${moduleIdentifier} cannot be required until the dcp-client::init() promise has been resolved.`);
@@ -222,8 +224,8 @@ moduleSystem._resolveFilename = function dcpClient$$injectModule$resolveFilename
 
   return resolveFilenamePrevious.apply(null, arguments)
 }
-/** 
- * Inject an initialized module into the native NodeJS module system. 
+/**
+ * Inject an initialized module into the native NodeJS module system.
  *
  * @param       id              {string}        module identifier
  * @param       moduleExports   {object}        the module's exports object
@@ -247,7 +249,7 @@ function injectModule(id, moduleExports, clobber) {
 /**
  * Inject modules from a bundle according to a namespace map.
  * The namespace map maps bundle exports onto the internal require(dcp/...) namespace.
- * 
+ *
  * @param    nsMap    the namespace map object
  * @param    bundle   the webpack bundle (~moduleGroup object)
  * @param    clobber  {boolean}       inject on top of an existing module identifier
@@ -255,7 +257,7 @@ function injectModule(id, moduleExports, clobber) {
  */
 function injectNsMapModules(nsMap, bundle, bundleLabel, clobber) {
   bundle = Object.assign({}, bundle);
-  
+
   for (let moduleId in nsMap)
   {
     let moduleExports = bundle[nsMap[moduleId]];
@@ -290,53 +292,143 @@ injectNsMapModules(require('./ns-map'), loadBootstrapBundle(), 'bootstrap');
 injectModule('dcp/bootstrap-build', require('dcp/build'));
 
 KVIN = new (require('dcp/internal/kvin')).KVIN();
+const bootstrapClasses = {
+  DcpURL:  require('dcp/dcp-url').DcpURL,
+  Address: require('dcp/wallet').Address,
+};
 KVIN.userCtors.dcpUrl$$DcpURL  = require('dcp/dcp-url').DcpURL;
 KVIN.userCtors.dcpEth$$Address = require('dcp/wallet').Address;
 
-/** Merge a new configuration object on top of an existing one. The new object
- *  is overlaid on the existing object, so that properties specified in the 
- *  existing object graph overwrite, but unspecified edges are left alone.
+/**
+ * Merge a new configuration object on top of an existing one. The new object is overlaid on the
+ * existing object, so that own properties specified in the existing object graph overwrite, but
+ * unspecified edges are left alone.
+ *
+ * Instances of URL and dcpUrl::URL receive special treatment: if they are being overwritten by a
+ * string, the string is used the argument to the constructor to create a new object that replaces
+ * the entire value.
+ *
+ * Arrays are concatenated together when merging. In the case where an Array and an Object are merged,
+ * the result will be an Array and it will be merged with the object's values.
+ *
+ * Objects not mentioned above whose constructors are neither Function nor Object are treated as though
+ * they are primitive values, as they may contain internal  state that is not represented solely by
+ * their own properties.
  *
- *  Instances of URL and dcpUrl::URL receive special treatment: if they are being
- *  overwritten by a string, the string is used the argument to the constructor
- *  to create a new object that replaces the entire value.
- * 
- * *note* -     We treat objects with constructors other than Function or Object
- *              as though they were primitive values, as they may contain internal 
- *              state that is not represented solely by their own properties
+ * It is possible to "merge" Objects with Arrays. We basically decide that the Array indicies have no
+ * special meaning and neither do the own property names.
  *
- * @param       {object}        existing        The top node of an object graph whose 
- *                                              edges may be replaced
- * @param       {object}        neo             The top node of an object graph whose
- *                                              edges describe the replacement
+ * {} -> {} => leaf merge
+ * [] -> [] => concat except it leaves out duplicate elements
+ * {} -> [] => Object.entries({}) -> []                       => concat except it leaves out duplicate elements onto array
+ * [] -> {} => []                 -> Object with dynamic keys => merge into object
+ *
+ * @param {object}            existing  Top node of an object graph whose edges may be replaced
+ * @param {object|undefined}  neo       Top node of an object graph whose edges describe the replacement
  */
-function addConfig (existing, neo) {
+globalThis.addConfig = addConfig;
+function addConfig (existing, neo, dotPath)
+{
   const { DcpURL } = require('dcp/dcp-url');
 
+  if (neo === undefined || neo === existing)
+    return;
   debug('dcp-client:config-verbose')('adding', neo);
+  if (typeof neo !== 'object')
+    throw new TypeError(`Unable to merge ${typeof neo} value '${neo}' into ${nodeName()}`);
 
-  for (let prop in neo) {
-    if (!neo.hasOwnProperty(prop))
-      continue;
-    if (typeof existing[prop] === 'object' && DcpURL.isURL(existing[prop])) {
-      if (neo[prop])
-        existing[prop] = new (existing[prop].constructor)(neo[prop]);
+  function isIntrinsic(val)
+  {
+    return (val === null || (typeof val !== 'object' && typeof val !== 'function'))
+  }
+
+  function nodeName(edge)
+  {
+    if (edge)
+      return dotPath ? `${dotPath}.${edge}` : edge;
+    else
+      return dotPath || 'dcpConfig';
+  }
+
+  /** Make an object from an array so that it can be merged into another object without key collision */
+  function objFromArrForObj(arr, obj)
+  {
+    const numericKeys    = Object.keys(arr).map(key => Number(key)).filter(key => !isNaN(key))
+    const maxNumericKey  = numericKeys.length ? numericKeys[numericKeys.length - 1] : NaN;
+    const nonNumericKeys = Object.keys(arr).filter(key => isNaN(Number(key)));
+    const tmp = {};
+
+    for (let key of nonNumericKeys)
+      tmp[key] = arr[key];
+    for (let idx of numericKeys)
+      tmp[idx + maxNumericKey] = arr[idx];
+    return tmp;
+  }
+
+  for (const prop of Object.getOwnPropertyNames(neo))
+  {
+    if (false
+        || !Object.hasOwnProperty.call(existing, prop)    /* no collision? use new */
+        || existing[prop] === neo[prop]
+        || isIntrinsic(neo[prop])                         /* instrinsic? use new */
+        || isIntrinsic(existing[prop])
+        || neo[prop] instanceof URL                       /* new URLs overwrite old nodes */
+        || DcpURL.isURL(neo[prop])
+        || neo[prop].constructor === RegExp               /* new RegExps overwrite old nodes */
+       )
+    {
+      existing[prop] = neo[prop];
       continue;
     }
-    if (typeof neo[prop] === 'object' && neo[prop] !== null && !Array.isArray(neo[prop]) && ['Function','Object'].includes(neo[prop].constructor.name)) {
-      if (typeof existing[prop] === 'undefined') {
-        existing[prop] = {}
+
+    if (typeof neo[prop] !== 'object')
+      throw new TypeError(`Unable to merge ${typeof neo[prop]} value into ${nodeName(prop)}`);
+    else
+    {
+      switch(neo[prop].constructor)
+      {
+        case RegExp: case Object: case DcpURL: case URL: case Array:
+        case bootstrapClasses.DcpURL: case bootstrapClasses.Address:
+          break;
+        case Function: /* previously supported: do we really need this? /wg May 2025 */
+        default:
+          throw new TypeError(`Unable to merge ${neo[prop].constructor.name} object into ${nodeName(prop)}`);
+      }
+    }
+
+    let neoOfProp = neo[prop]; /* !!! do not use neo[prop] below here !!! */
+
+    if (typeof existing !== 'object' || (existing[prop].constructor !== Object && existing[prop].constructor !== Array))
+      throw new TypeError(`Unable to merge into ${existing[prop].constructor?.name || typeof existing} value of ${nodeName(prop)}`);
+    if (typeof neoOfProp !== 'object' || (neoOfProp.constructor !== Object && neoOfProp.constructor !== Array))
+      throw new TypeError(`Unable to merge ${neoOfProp.constructor?.name || typeof neoOfProp} value into ${nodeName(prop)}`);
+
+    /* When one of the objects is an array and the other is a plain object, we transform the new one to
+     * match the existing one.
+     */
+    if (!Array.isArray(neoOfProp) && Array.isArray(existing[prop]))      /* {} -> [] */
+      neoOfProp = Object.entries(neoOfProp);
+    else if (Array.isArray(neoOfProp) && !Array.isArray(existing[prop])) /* [] -> {} */
+      neoOfProp = objFromArrForObj(neoOfProp, existing[prop]);
+
+    /* Either merge objects or arrays. Objects collide props, Arrays collide exactly equal values. */
+    if (!Array.isArray(existing[prop]))
+      addConfig(existing[prop], neoOfProp, nodeName(prop));
+    else
+    {
+      /* concat new array at end of old array, omitting values which are already in the array */
+      for (let value of neoOfProp)
+      {
+        if (!existing[prop].includes(value))
+          existing[prop].push(value);
       }
-      addConfig(existing[prop], neo[prop])
-    } else {
-      existing[prop] = neo[prop]
     }
   }
 }
 
 /**
  * Returns a graph of empty objects with the same edges as the passed-in node. Only base Objects are
- * considered, not instances of derived classes (like URL). The newly-created nodes inherit from their 
+ * considered, not instances of derived classes (like URL). The newly-created nodes inherit from their
  * equivalent nodes. The net effect is that the returned graph can have its nodes read like usual, but
  * writes "stick" to the new nodes instead of modifying the original node.
  *
@@ -371,7 +463,7 @@ function magicView(node, seen)
 
 /**
  * Throw an exception if the given fullPath is not a "safe" file to load.
- * "Safe" files are those that are unlikely to contain malicious code, as 
+ * "Safe" files are those that are unlikely to contain malicious code, as
  * they are owned by an administrator or the same person who loaded the
  * code.
  *
@@ -397,7 +489,7 @@ function checkConfigFileSafePerms(fullPath, statBuf)
     fun.mainStat = require.main ? fs.statSync(require.main.filename) : {};
 
   statBuf = fs.statSync(fullPath);
-  
+
   /* Disallow files with world-writeable path components. @todo reduce redundant checks */
   if (os.platform() !== 'win32')
   {
@@ -428,7 +520,7 @@ function checkConfigFileSafePerms(fullPath, statBuf)
     return true; /* conf and program in same group */
   if ((fun.mainStat.mode & 0o020) && (statBuf.gid === process.getgid()))
     return true; /* program is group-writeable and we are in group */
-  
+
   throw new Error('did not load configuration file due to invalid permissions: ' + fullPath);
 }
 
@@ -448,19 +540,19 @@ function addConfigFile(existing /*, file path components ... */) {
     fullPath = path.join(fullPath, arguments[i]);
   }
   const fpSnap = fullPath;
-  
+
   /**
    * Make a the global object for this context this config file is evaluated in.
-   * - Top-level keys from dcpConfig become properties of this object, so that we can write statements 
+   * - Top-level keys from dcpConfig become properties of this object, so that we can write statements
    *   like scheduler.location='XXX' in the file.
    * - A variable named `dcpConfig` is also added, so that we could replace nodes wholesale, eg
    *   `dcpConfig.scheduler = { location: 'XXX' }`.
    * - A require object that resolves relative to the config file is injected
    * - All of the globals that we use for evaluating the bundle are also injected
    */
-  function makeConfigSandbox()
+  function makeConfigFileSymbols()
   {
-    var configSandbox = Object.assign({}, bundleSandbox, {
+    var configFileScope = Object.assign({}, bundleScope, {
       dcpConfig: existing,
       require:   moduleSystem.createRequire(fullPath),
       url:       (href) => new (require('dcp/dcp-url').DcpURL)(href),
@@ -469,13 +561,13 @@ function addConfigFile(existing /*, file path components ... */) {
     });
 
     for (let key in existing)
-      if (!configSandbox.hasOwnProperty(key))
-        configSandbox[key] = configSandbox.dcpConfig[key];
+      if (!configFileScope.hasOwnProperty(key))
+        configFileScope[key] = configFileScope.dcpConfig[key];
 
-    assert(configSandbox.console);
-    return configSandbox;
+    assert(configFileScope.console);
+    return configFileScope;
   }
-  
+
   if (fullPath && checkConfigFileSafePerms(fullPath + '.json'))
   {
     fullPath = fullPath + './json';
@@ -496,17 +588,7 @@ function addConfigFile(existing /*, file path components ... */) {
   {
     fullPath = fullPath + '.js';
     debug('dcp-client:config')(` * Loading configuration from ${fullPath}`);
-
-    const configSandbox = makeConfigSandbox();
-    const code = fs.readFileSync(fullPath, 'utf-8');
-    let neo;
-
-    if (withoutComments(code).match(/^\s*{/)) /* config file is just a JS object literal */
-      neo = evalStringInSandbox(`return (${code});`, configSandbox, fullPath);
-    else
-      neo = evalStringInSandbox(code, configSandbox, fullPath);
-
-    addConfig(existing, neo);
+    addConfig(existing, evalConfigFile(makeConfigFileSymbols(), fullPath));
     return fullPath;
   }
 
@@ -540,7 +622,7 @@ function coerceMagicRegProps(o, seen)
 }
 
 /** Merge a new configuration object on top of an existing one, via
- *  addConfig().  The registry key is read, turned into an object, and 
+ *  addConfig().  The registry key is read, turned into an object, and
  *  becomes the neo config.
  */
 async function addConfigRKey(existing, hive, keyTail) {
@@ -564,7 +646,7 @@ async function addConfigRKey(existing, hive, keyTail) {
 function addConfigEnv(existing, prefix) {
   var re = new RegExp('^' + prefix);
   var neo = {};
-  
+
   for (let v in process.env) {
     if (!process.env.hasOwnProperty(v) || !v.match(re)) {
       continue
@@ -600,12 +682,12 @@ function fixCase(ugly)
 }
 
 /**
- * Patch up an object graph to fix up minor class instance issues. For example, if we get a URL from the
- * internal bundle and then download a new URL class, it won't be an instance of the new class and it
- * won't benefit from any bug fixes, new functionality, etc.
+ * Patch up an object graph to fix up minor class instance issues. For example, if we get a DcpURL from
+ * the internal bundle and then download a new DcpURL class, it won't be an instance of the new class
+ * and it won't benefit from any bug fixes, new functionality, etc.
  *
  * @param {object} patchupList    a mapping which tells us how to fix these problems for specific
- *                                classes. This map is an array with each element having the shape 
+ *                                classes. This map is an array with each element having the shape
  *                                { how, right, wrong }.
  *
  *                                right - the right constructor to use
@@ -614,6 +696,8 @@ function fixCase(ugly)
  */
 function patchupClasses(patchupList, o, seen)
 {
+  const pucKVIN = new (require('dcp/internal/kvin')).KVIN();
+
   /* seen list keeps us from blowing the stack on graphs with cycles */
   if (!seen)
     seen = [];
@@ -632,12 +716,18 @@ function patchupClasses(patchupList, o, seen)
       if (typeof o[key] !== 'object' || o[key] === null || (Object.getPrototypeOf(o[key]) !== patchupList[i].wrong.prototype))
         continue;
       assert(patchupList[i].wrong !== patchupList[i].right);
-      
+
       switch (patchupList[i].how)
       {
         case 'kvin':
-          o[key] = KVIN.unmarshal(KVIN.marshal(o[key]));
+        {
+          const className = o[key].constructor.name;
+          pucKVIN.userCtors[className] = patchupList[i].wrong;
+          const tmp = pucKVIN.marshal(o[key]);
+          pucKVIN.userCtors[o[key].constructor.name] = patchupList[i].right;
+          o[key] = pucKVIN.unmarshal(tmp);
           break;
+        }
         case 'ctorStr':
           o[key] = new (patchupList[i].right)(String(o[key]));
           break;
@@ -657,6 +747,7 @@ function patchupClasses(patchupList, o, seen)
           throw new Error(`unknown patchup method ${patchupList[i].how}`);
       }
 
+      assert(o[key].constructor === patchupList[i].right);
       moreTraverse = false; /* don't patch up props of stuff we've patched up */
       break;
     }
@@ -666,7 +757,7 @@ function patchupClasses(patchupList, o, seen)
   }
 }
 
-/** 
+/**
  * Tasks which are run in the early phases of initialization
  * - plumb in global.XMLHttpRequest which lives forever -- that way KeepAlive etc works.
  */
@@ -675,14 +766,14 @@ exports._initHead = function dcpClient$$initHead() {
 
   if (typeof XMLHttpRequest === 'undefined')
     XMLHttpRequest = require('dcp/dcp-xhr').XMLHttpRequest;
-  
-  require('dcp/signal-handler').init();
+
+  require('dcp/signal-handler').init(); /* plumb in dcpExit event support for dcp-client applications */
 }
 
-/** 
+/**
  * Tasks which are run in the late phases of initialization:
- * 1 - activate either the local bundle or the remote bundle against a fresh sandbox 
- *     using the latest config (future: bootstrap bundle will export fewer modules until init; 
+ * 1 - activate either the local bundle or the remote bundle in a fresh funtion scope
+ *     using the latest config (future: bootstrap bundle will export fewer modules until init;
  *     bundle will provide post-initialization nsMap).
  * 2 - inject modules from the final bundle on top of the bootstrap modules
  * 3 - patch up internal (to the final bundle) references to dcpConfig to reference our generated config
@@ -711,19 +802,21 @@ function initTail(configFrags, options, finalBundleCode, finalBundleURL)
   var schedConfLocFun = require('dcp/protocol').getSchedulerConfigLocation;
 
   /* 1 */
-  bundleSandbox.dcpConfig = configFrags.internalConfig;
+  bundleScope.dcpConfig = configFrags.internalConfig;
   if (finalBundleCode) {
     finalBundleLabel = String(finalBundleURL);
-    bundle = evalStringInSandbox(finalBundleCode, bundleSandbox, finalBundleLabel);
+    debug('dcp-client:bundle')(' - loading final bundle from web');
+    bundle = evalBundleCodeInIIFE(finalBundleCode, bundleScope, { filename: finalBundleLabel });
   } else {
     const bundleFilename = path.resolve(distDir, 'dcp-client-bundle.js');
     finalBundleLabel = bundleFilename;
-    bundle = evalFileInIIFE(bundleFilename, bundleSandbox);
+    debug('dcp-client:bundle')(' - loading final bundle from disk');
+    bundle = evalBundleFileInIIFE(bundleFilename, bundleScope);
   }
   nsMap = bundle.nsMap || require('./ns-map');  /* future: need to move non-bootstrap nsMap into bundle for stable auto-update */
 
-  if (bundle.initTailHook) /* for use by auto-update future backwards compat */ 
-    bundle.initTailHook(configFrags, bundle, finalBundleLabel, bundleSandbox, injectModule);
+  if (bundle.initTailHook) /* for use by auto-update future backwards compat */
+    bundle.initTailHook(configFrags, bundle, finalBundleLabel, bundleScope, injectModule);
 
   /* 2 */
   debug('dcp-client:modules')(`Begin phase 2 module injection '${finalBundleLabel}'`);
@@ -746,10 +839,11 @@ function initTail(configFrags, options, finalBundleCode, finalBundleURL)
    * dcpUrl patchup utility and thus a full traversal of the dcpConfig object graph.
    */
   const patchupList = [
-    { how: 'kvin', wrong: KVIN.userCtors.dcpEth$$Address, right: require('dcp/wallet').Address },
-    { how: 'kvin', wrong: KVIN.userCtors.dcpUrl$$DcpURL,  right: require('dcp/dcp-url').DcpURL },
-    { how: 'ctor', wrong: URL,                            right: require('dcp/dcp-url').DcpURL },
+    { how: 'kvin', wrong: bootstrapClasses.Address, right: require('dcp/wallet').Address },
+    { how: 'kvin', wrong: bootstrapClasses.DcpURL,  right: require('dcp/dcp-url').DcpURL },
+    { how: 'ctor', wrong: URL,                      right: require('dcp/dcp-url').DcpURL },
   ];
+  assert(require('dcp/dcp-url').DcpURL !== bootstrapClasses.DcpURL);
   patchupClasses(patchupList, configFrags);
 
   /* Ensure KVIN deserialization from now on uses the current bundle's implementation for these classes */
@@ -773,9 +867,9 @@ function initTail(configFrags, options, finalBundleCode, finalBundleURL)
   addConfig(workingDcpConfig, configFrags.localConfig);
   addConfig(workingDcpConfig, originalDcpConfig);
 
-  bundleSandbox.dcpConfig = workingDcpConfig;
+  bundleScope.dcpConfig = workingDcpConfig;
   globalThis.dcpConfig    = workingDcpConfig;
-  bundleSandbox.dcpConfig.build = require('dcp/build').config.build; /* dcpConfig.build deprecated mar 2023 /wg */
+  bundleScope.dcpConfig.build = require('dcp/build').config.build; /* dcpConfig.build deprecated mar 2023 /wg */
 
   /* 4 */
   if (workingDcpConfig.scheduler.configLocation !== false && typeof process.env.DCP_CLIENT_SKIP_VERSION_CHECK === 'undefined')
@@ -793,33 +887,20 @@ function initTail(configFrags, options, finalBundleCode, finalBundleURL)
         throw require('dcp/utils').versionError('DCP Protocol', 'dcp-client', workingDcpConfig.scheduler.location.href, minVer, 'EDCP_PROTOCOL_VERSION');
     }
   }
-  
-  /* 5 */
-  if (options.parseArgv !== false) {
-    const dcpCli = require('dcp/cli');
-    /* don't enable help output when automating */
-    const argv = dcpCli.base().help(false).argv;
-    const { help, identity, identityFile, defaultBankAccount, defaultBankAccountFile } = argv;
-
-    if (!help) {
-      const wallet = require('dcp/wallet');
-      if (identity || identityFile) {
-        const idKs_p = dcpCli.getIdentityKeystore();
-        wallet.addId(idKs_p);
-      }
 
-      if (defaultBankAccount || defaultBankAccountFile) {
-        const bankKs_p = dcpCli.getAccountKeystore();
-        wallet.add(bankKs_p);
-      }
-    }
+  /* 5 */
+  if (options.parseArgv !== false)
+  {
+    let optarg;
+    if ((optarg = consumeArg('identity')))
+      require('dcp/identity').setDefault(optarg);
   }
 
   /* 6 */
   ret = makeInitReturnObject();
-  if (bundle.postInitTailHook) /* for use by auto-update future backwards compat */ 
-    ret = bundle.postInitTailHook(ret, configFrags, bundle, finalBundleLabel, bundleSandbox, injectModule);
-  dcpConfig.build = bundleSandbox.dcpConfig.build = require('dcp/build').config.build; /* dcpConfig.build deprecated March 2023 */
+  if (bundle.postInitTailHook) /* for use by auto-update future backwards compat */
+    ret = bundle.postInitTailHook(ret, configFrags, bundle, finalBundleLabel, bundleScope, injectModule);
+  dcpConfig.build = bundleScope.dcpConfig.build = require('dcp/build').config.build; /* dcpConfig.build deprecated March 2023 */
 
   return ret;
 }
@@ -829,7 +910,7 @@ function initTail(configFrags, options, finalBundleCode, finalBundleURL)
  * object with two properies:
  * - localConfig: a dcpConfig fragment
  * - options: an options object
- * 
+ *
  * This routine also populates certain key default values, such as the scheduler and program name that
  * need to always be defined, and updates the localConfig fragment to reflect appropriate options.
  *
@@ -873,7 +954,7 @@ function handleInitArgs(initArgv)
 
   options.dcpConfig = Object.assign(initConfig, options.dcpConfig);
   if (options.scheduler)
-    initConfig.scheduler.location = new URL(options.scheduler);    
+    initConfig.scheduler.location = new URL(options.scheduler);
   if (options.autoUpdate)
     initConfig.bundle.autoUpdate = true;
   if (options.bundleLocation)
@@ -887,7 +968,7 @@ function handleInitArgs(initArgv)
 
 /**
  * Initialize the dcp-client bundle for use by the compute API, etc. - Form 1
- * 
+ *
  * @param       {string}                url
  *                                      Location of scheduler, from whom we download
  *                                      dcp-config.js, which in turn tells us where to
@@ -896,7 +977,7 @@ function handleInitArgs(initArgv)
  */
 /**
  * Form 2
- * 
+ *
  * @param       {URL object}            url
  *                                      Location of scheduler, from whom we download
  *                                      dcp-config.js, which in turn tells us where to
@@ -936,6 +1017,8 @@ exports.init = async function dcpClient$$init() {
   var finalBundleCode = false;
   var finalBundleURL;
 
+  debug('dcp-client:init')(' * Initializing dcp-client');
+
   reportErrors = options.reportErrors;
   exports._initHead();
   configFrags = await exports.createConfigFragments(initConfig, options);
@@ -957,7 +1040,10 @@ exports.init = async function dcpClient$$init() {
   }
 
   if (process.env.DCP_CLIENT_ENABLE_SOURCEMAPS || options.enableSourceMaps)
+  {
+    debug('dcp-client:init')(' * Installing source maps');
     require('source-map-support').install();
+  }
 
   return initTail(configFrags, options, finalBundleCode, finalBundleURL);
 }
@@ -970,7 +1056,7 @@ exports.initSync = function dcpClient$$initSync() {
   var configFrags;
   var finalBundleCode = false;
   var finalBundleURL;
-  
+
   exports._initHead();
   configFrags = createConfigFragmentsSync(initConfig, options);
 
@@ -1015,14 +1101,26 @@ function mkEnvConfig()
 
 /**
  * Generate a local config object from the program's command line
+ * Side effect: process.argv is modified to remove these options
  */
-function mkCliConfig(cliOpts)
+function mkCliConfig(options)
 {
-  const cliConfig = { scheduler: {} };
+  const cliConfig = mkCliConfig.__cache || { scheduler: {}, bundle: {} };
+  mkCliConfig.__cache = cliConfig;
 
-  debug('dcp-client:config')(` * Loading configuration from CLI options`);
-
-  if (cliOpts.dcpScheduler) cliConfig.scheduler.location = new URL(cliOpts.dcpScheduler);
+  if (options.parseArgv !== false)
+  {
+    let s;
+    debug('dcp-client:config')(` * Loading configuration from command-line arguments`);
+    if ((s = consumeArg('scheduler')))
+      cliConfig.scheduler.location = new URL(s);
+    if ((s = consumeArg('config-location')))
+      cliConfig.scheduler.configLocation = s;
+    if ((s = consumeArg('bundle-location')))
+      cliConfig.scheduler.configLocation = s;
+    if ((consumeArg('bundle-auto-update', true)))
+      cliConfig.scheduler.configLocation = true;
+  }
 
   return cliConfig;
 }
@@ -1044,8 +1142,7 @@ function mkCliConfig(cliOpts)
  *      - scheduler      {string|URL}:  location of the DCP scheduler
  *      - autoUpdate     {boolean}:     true to download a fresh dcp-client bundle from the scheduler
  *      - bundleLocation {string|URL}:  location from where we will download a new bundle
- *      - configScope    {string}:      arbitrary name to use in forming various config fragment filenames
- *      - configName     {string}:      arbitrary name to use to resolve a config fragment filename 
+ *      - configName     {string}:      arbitrary name to use to resolve a config fragment filename
  *                                      relative to the program module
  * @returns {object} with the following properties:
  *  - defaultConfig:    this is the configuration buried in dcp-client (mostly from the bundle but also index.js)
@@ -1055,9 +1152,9 @@ function mkCliConfig(cliOpts)
  */
 exports.createConfigFragments = async function dcpClient$$createConfigFragments(initConfig, options)
 {
-/* The steps that are followed are in a very careful order; there are default configuration options 
- * which can be overridden by either the API consumer or the scheduler; it is important that the wishes 
- * of the API consumer always take priority, and that the scheduler is unable to override parts of 
+/* The steps that are followed are in a very careful order; there are default configuration options
+ * which can be overridden by either the API consumer or the scheduler; it is important that the wishes
+ * of the API consumer always take priority, and that the scheduler is unable to override parts of
  * dcpConfig which are security-critical, like allowOrigins, minimum wage, bundle auto update, etc.
  *
  *  1 - create the local config by
@@ -1069,17 +1166,15 @@ exports.createConfigFragments = async function dcpClient$$createConfigFragments(
  *       - arguments to init()
  *       - use the config + environment + arguments to figure out where the scheduler is
  *       - etc  (see dcp-docs file dcp-config-file-regkey-priorities)
- *  2 - merge the passed-in configuration on top of the default configuration 
+ *  2 - merge the passed-in configuration on top of the default configuration
  *  5 - pull the scheduler's config, and layer it on top of the current configuration to find scheduler
  */
-  const cliOpts = require('dcp/cli').base().help(false).parse();
   const etc  = process.env.DCP_ETCDIR || (os.platform() === 'win32' ? process.env.ALLUSERSPROFILE : '/etc');
   const home = process.env.DCP_HOMEDIR || os.homedir();
   let programName = options.programName;
-  const configScope = cliOpts.configScope || process.env.DCP_CONFIG_SCOPE || options.configScope;
   const progDir = process.mainModule ? path.dirname(process.mainModule.filename) : process.cwd();
   var   remoteConfig, remoteConfigKVIN;
-  const internalConfig = require('dcp/dcp-config'); /* needed to resolve dcpConfig.future - would like to eliminate this /wg */
+  const internalConfig = require('dcp/dcp-config');
   const defaultConfig = Object.assign({}, bootstrapConfig);
   addConfig(defaultConfig, internalConfig);
   addConfig(defaultConfig, KVIN.unmarshal(require('dcp/internal/dcp-default-config')));
@@ -1091,7 +1186,7 @@ exports.createConfigFragments = async function dcpClient$$createConfigFragments(
    * then these leaf nodes eventually overwrite the same-pathed nodes which arrive in the remote conf.
    *
    * The pre-populated localConfig graph then has each of its nodes inherit from the equivalent node
-   * in defaultConfig. This allows us to read properties in localConfig and get values from 
+   * in defaultConfig. This allows us to read properties in localConfig and get values from
    * defaultConfig (assuming they haven't been overwritten), but writing to localConfig won't alter
    * the defaultConfig.  This is important, because need to preserve the config stack but allow
    * user-supplied dcp-config.js files to read the existing config and use it to generate new
@@ -1107,7 +1202,7 @@ exports.createConfigFragments = async function dcpClient$$createConfigFragments(
 
   /* "warm up" the local ahead of actually reading in the config files. These options are higher-
    * precedence than reading them at the base level, but providing them at the base level first
-   * means that lower-level config files can see them. The class example again is that the worker
+   * means that lower-level config files can see them. The classic example again is that the worker
    * needs to know the scheduler location in order to generate the default allow lists, but the
    * scheduler location can be override by the environment or command-line.  The one thing that
    * we can't really support easily is having a config file modify something in terms of what
@@ -1117,7 +1212,7 @@ exports.createConfigFragments = async function dcpClient$$createConfigFragments(
   addConfig    (localConfig, initConfig);
   addConfigEnv (localConfig, 'DCP_CONFIG_');
   addConfig    (localConfig, mkEnvConfig());
-  addConfig    (localConfig, mkCliConfig(cliOpts));
+  addConfig    (localConfig, mkCliConfig(options));
 
   /**
    * 4. Use the config + environment + arguments to figure out where the
@@ -1125,9 +1220,9 @@ exports.createConfigFragments = async function dcpClient$$createConfigFragments(
    *
    * Only override the scheduler from argv if cli specifies a scheduler.
    * e.g. the user specifies a --dcp-scheduler option.
-   * See spec doc dcp-config-file-regkey-priorities 
+   * See spec doc dcp-config-file-regkey-priorities
    * Note: this code is Sep 2022, overriding older spec, spec update to come. /wg
-   * 
+   *
    * The basic idea is that key collisions are overridden on the basis of "most specificity to current
    * executable wins" - so local disk is stronger than remote network config, homedir is stronger than
    * /etc, BUT we also have an override in /etc, and specific-program-name config files in /etc are more
@@ -1144,22 +1239,18 @@ exports.createConfigFragments = async function dcpClient$$createConfigFragments(
   await addConfigRKey(localConfig, 'HKCU', 'dcp/dcp-config');
         addConfigFile(localConfig, home,  `.dcp/${programName}/dcp-config`);
   await addConfigRKey(localConfig, 'HKCU', `dcp/${programName}/dcp-config`);
-        addConfigFile(localConfig, home,  '.dcp/scope', configScope);
-  await addConfigRKey(localConfig, 'HKCU', 'dcp/scope', configScope);
         addConfig    (localConfig, initConfig);
         addConfigEnv (localConfig, 'DCP_CONFIG_');
         addConfig    (localConfig, mkEnvConfig());
-        addConfig    (localConfig, mkCliConfig(cliOpts));
+        addConfig    (localConfig, mkCliConfig(options));
         addConfigFile(localConfig, etc,    `dcp/${programName}/dcp-config`);
   await addConfigRKey(localConfig, 'HKLM', `dcp/${programName}/dcp-config`);
         addConfigFile(localConfig, etc,    'dcp/override-dcp-config');
   await addConfigRKey(localConfig, 'HKLM', 'dcp/override-dcp-config');
-        addConfigFile(localConfig, etc,    'dcp/scope', configScope);
-  await addConfigRKey(localConfig, 'HKLM', 'dcp/scope', configScope);
   await addConfigRKey(localConfig, 'HKLM', 'dcp-client/dcp-config'); /* legacy - used by screen saver, /wg sep'22 */
 
   exports.__cn = cn; /* memoize for use by dcp-worker etc who need to know where local conf came from */
-  
+
   /* 5. Use the aggregate of the default and local configs to figure out where the scheduler is. Use
    *    this to figure where the web config is and where an auto-update bundle would be if auto-update
    *    were enabled.
@@ -1175,7 +1266,7 @@ exports.createConfigFragments = async function dcpClient$$createConfigFragments(
   if (!aggrConfig.bundle.location && aggrConfig.bundle.location !== false)
     aggrConfig.bundle.location = localConfig.bundle.location = aggrConfig.scheduler.location.resolveUrl('/dcp-client/dist/dcp-client-bundle.js')
   localConfig.scheduler.location = aggrConfig.scheduler.location;
-  
+
   debug('dcp-client:config')(` . scheduler is at ${localConfig.scheduler.location}`);
   debug('dcp-client:config')(` . auto-update is ${localConfig.bundle.autoUpdate ? 'on' : 'off'}; bundle is at ${localConfig.bundle.location}`);
 
@@ -1202,7 +1293,7 @@ exports.createConfigFragments = async function dcpClient$$createConfigFragments(
       throw error;
     }
   }
-  
+
   /**
    * Default location for the auto update bundle is the scheduler so that the
    * scheduler and the client are on the same code.
@@ -1217,9 +1308,9 @@ exports.createConfigFragments = async function dcpClient$$createConfigFragments(
 
 exports.initcb = require('./init-common').initcb
 
-/** 
- * Create the aggregate config - which by definition does async work - by 
- * spawning another process (and other reactor) and then blocking until 
+/**
+ * Create the aggregate config - which by definition does async work - by
+ * spawning another process (and other reactor) and then blocking until
  * it is available.  Used to implement initSync().
  *
  * The other process receives the same command-line options and environment
@@ -1254,7 +1345,7 @@ function createConfigFragmentsSync(initConfig, options)
       input
     },
   );
-  
+
   if (child.status !== 0 || !child.output[3] || child.output[3].length === 0)
     throw new Error(`Error running ${spawnArgv[0]} (exitCode=${child.status})`);
 
@@ -1265,7 +1356,7 @@ function createConfigFragmentsSync(initConfig, options)
   debug('dcp-client:init')('fetched configuration fragments', Object.keys(configFrags));
   return configFrags;
 }
-  
+
 /** Fetch a web resource from the server, blocking the event loop. Used by initSync() to
  *  fetch the remote scheduler's configuration and optionally its autoUpdate bundle. The
  *  download program displays HTTP-level errors on stderr, so we simply inhert and let it
@@ -1280,21 +1371,21 @@ exports.fetchSync = function fetchSync(url) {
   var child;
   var argv = [ process.execPath, require.resolve('./bin/download'), '--fd=3' ];
   var env = { FORCE_COLOR: 1 };
-  
+
   if (reportErrors === false)
     argv.push('--silent');
   if (typeof url !== 'string')
     url = url.href;
   argv.push(url);
 
-  child = spawnSync(argv[0], argv.slice(1), { 
+  child = spawnSync(argv[0], argv.slice(1), {
     env: Object.assign(env, process.env), shell: false, windowsHide: true,
     stdio: [ 'ignore', 'inherit', 'inherit', 'pipe' ],
 
     /**
      * Setting the largest amount of data in bytes allowed on stdout or stderr to 10 MB
      * so that dcp-client-bundle.js (~5.2 MB built in debug mode with source-mapped line
-     * in late jan 2023) can be downloaded without the child exiting with a status of 
+     * in late jan 2023) can be downloaded without the child exiting with a status of
      * null (i.e. ENOBUFS).
      */
     maxBuffer: 10 * 1024 * 1024,
@@ -1314,7 +1405,7 @@ exports.__require = require;
  *
  *  This is the return value from initSync() and the promise resolution value for init().
  */
-function makeInitReturnObject() { 
+function makeInitReturnObject() {
   const nsMap = require('./ns-map');
   var o = {};
 
@@ -1327,3 +1418,47 @@ function makeInitReturnObject() {
 
   return o;
 }
+
+/**
+ * Consume an argument from process.argv, modifying process.argv so as to hide this argument's existence
+ * from the dcp-client app consumer.
+ */
+function consumeArg(ckArg, bool)
+{
+  var ret;
+  ckArg = '--dcp-' + ckArg;
+
+  for (let opt, i=2; i < process.argv.length; i++)
+  {
+    const arg = process.argv[i];
+
+    if (bool ? arg === ckArg : arg.startsWith(ckArg + '='))
+    {
+      debug('dcp-client:config-argv')('consume', process.argv[i]);
+      process.argv.splice(i, 1);
+      if (!bool)
+        ret = arg.slice(2 + ckArg.length + 1);
+      else
+      {
+        /* when ckArg = opt, we can have
+         * --dcp-opt          => true
+         * --dcp-opt=true     => true
+         * --dcp-opt=false    => false
+         */
+        if (arg === ckArg)
+          ret = true;
+        else
+        {
+          const tf = arg.slice(ckArg.length + 1);
+          if (tf !== 'true' && tf !== 'false')
+            throw new Error(`invalid argument ${tf} for ${ckArg}; should be true or false`);
+          ret = tf === 'true';
+        }
+      }
+
+      ret = bool ? true : arg.slice(ckArg.length + 1);
+    }
+  }
+
+  return ret;
+}