dcp-client 5.1.8 → 5.1.9

package/index.js

@@ -304,9 +304,13 @@ KVIN.userCtors.dcpEth$$Address = require('dcp/wallet').Address;
  * 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.
+ * Instances of Address, URL and dcpUrl::DcpURL receive special treatment: if they are being overwritten
+ * by another type, that value is used as the argument to the constructor to create a new object that
+ * replaces the entire value. This allows us, for example, to replace a URL with a registry string and
+ * still have the correct type once the program loads.
+ *
+ * URL types are always copied by value, not by reference.
+ *
  *
  * 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.
@@ -318,7 +322,7 @@ KVIN.userCtors.dcpEth$$Address = require('dcp/wallet').Address;
  * 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.
  *
- * {} -> {} => leaf merge
+ * {} -> {} => ~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
@@ -333,6 +337,11 @@ function addConfig (existing, neo, dotPath)
 
   if (neo === undefined || neo === existing)
     return;
+
+  /* Caveat debuggor: the "adding" output will only show changes from config files where they return
+   * objects. Any changes which are the result of the config file directly mutating properties of
+   * dcpConfig might not be displayed. See "magicView" for info about those.
+   */
   debug('dcp-client:config-verbose')('adding', neo);
   if (typeof neo !== 'object')
     throw new TypeError(`Unable to merge ${typeof neo} value '${neo}' into ${nodeName()}`);
@@ -351,7 +360,7 @@ function addConfig (existing, neo, dotPath)
   }
 
   /** Make an object from an array so that it can be merged into another object without key collision */
-  function objFromArrForObj(arr, obj)
+  function objFromArrForObj(arr)
   {
     const numericKeys    = Object.keys(arr).map(key => Number(key)).filter(key => !isNaN(key))
     const maxNumericKey  = numericKeys.length ? numericKeys[numericKeys.length - 1] : NaN;
@@ -367,15 +376,28 @@ function addConfig (existing, neo, dotPath)
 
   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 */
-       )
+    /* When existing prop is URL and new prop isn't, use new prop to build a URL. 
+     * Higher precedence than neo[prop] being intrinsic, convert 'http://example.com' to a URL if the existing is a URL
+     */
+    if (DcpURL.isURL(existing?.[prop]))
+    {
+      existing[prop] = new existing[prop].constructor(neo[prop]);
+      continue;
+    }
+
+    if (isIntrinsic(neo[prop]))
+    {
+      existing[prop] = neo[prop];
+      continue;
+    }
+
+    if (neo[prop].constructor === RegExp) /* Regexps are unmergeable and must be cloned */
+    {
+      existing[prop] = new RegExp(neo[prop].source, neo[prop].flags);
+      continue;
+    }
+
+    if (neo[prop].constructor === Promise)
     {
       existing[prop] = neo[prop];
       continue;
@@ -383,36 +405,64 @@ function addConfig (existing, neo, dotPath)
 
     if (typeof neo[prop] !== 'object')
       throw new TypeError(`Unable to merge ${typeof neo[prop]} value into ${nodeName(prop)}`);
-    else
+
+    /* When new prop is URL, copy it by value instead of merging */
+    if (DcpURL.isURL(neo[prop]))
     {
-      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)}`);
-      }
+      const neoUrl = neo[prop];
+      existing[prop] = new neoUrl.constructor(neoUrl.href);
+      continue;
     }
 
-    let neoOfProp = neo[prop]; /* !!! do not use neo[prop] below here !!! */
+    /* When existing prop is Address and new prop isn't, use new prop to build an Address */
+    if (existing[prop]?.constructor === bootstrapClasses.Address &&
+        neo     [prop] .constructor !== bootstrapClasses.Address)
+    {
+      existing[prop] = new bootstrapClasses.Address(neo[prop]);
+      continue;
+    }
 
-    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)}`);
+    switch(neo[prop].constructor)
+    {
+      case RegExp: case bootstrapClasses.DcpURL: case DcpURL: case URL:
+        throw new TypeError(`Unexpected URL type merging ${neo[prop].constructor.name} object into ${nodeName(prop)}`);
+      case Object:
+      case Array:
+      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)}`);
+    }
+
+    if (!existing.hasOwnProperty(prop) || isIntrinsic(existing[prop])) /* clone by merging into empty */
+      existing[prop] = Array.isArray(neo[prop]) ? [] : {};
+
+    const neoPropIsArray      = Array.isArray(neo       [prop]);
+    const existingPropIsArray = Array.isArray(existing?.[prop]);
+
+    const isNotMergeable = (obj) => {
+      return false
+        || typeof obj[prop] !== 'object'
+        || (obj[prop].constructor !== Object && obj[prop].constructor !== Array);
+    };
+    if (isNotMergeable(existing, prop))
+      throw new TypeError(`Unable to merge into ${existing?.[prop].constructor?.name || typeof existing} value of ${nodeName(prop)}`);
+    if (isNotMergeable(neo, prop))
+      throw new TypeError(`Unable to merge ${neo[prop].constructor?.name || typeof neo[prop]} value into ${nodeName(prop)}`);
+
+    let neoOfProp = neo[prop]; /* !!! do not use neo[prop] below here !!! */
 
     /* 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]))      /* {} -> [] */
+    if (!neoPropIsArray && existingPropIsArray)      /* {} -> [] - merge object onto an array? make an array from the object and merge that. */
       neoOfProp = Object.entries(neoOfProp);
-    else if (Array.isArray(neoOfProp) && !Array.isArray(existing[prop])) /* [] -> {} */
+    else if (neoPropIsArray && !existingPropIsArray) /* [] -> {} - merge array onto an object? make an object from the array and merge that. */
       neoOfProp = objFromArrForObj(neoOfProp, existing[prop]);
 
     /* Either merge objects or arrays. Objects collide props, Arrays collide exactly equal values. */
-    if (!Array.isArray(existing[prop]))
+    if (!existingPropIsArray)
       addConfig(existing[prop], neoOfProp, nodeName(prop));
     else
     {
@@ -436,6 +486,10 @@ function addConfig (existing, neo, dotPath)
  * @param {object} seen     internal use only
  *
  * @returns {object}
+ *
+ * @todo inherited objects should actually be read-only Proxies or similar, to prevent users from
+ *       accidentally mutating the internal contents of the underlying object; eg setting the href
+ *       property of a URL inside the default config, when they meant to set the URL itself.
  */
 function magicView(node, seen)
 {
@@ -542,7 +596,7 @@ function addConfigFile(existing /*, file path components ... */) {
   const fpSnap = fullPath;
 
   /**
-   * Make a the global object for this context this config file is evaluated in.
+   * Make a global object for this context for this config file's evaluation.
    * - 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
@@ -553,11 +607,12 @@ function addConfigFile(existing /*, file path components ... */) {
   function makeConfigFileSymbols()
   {
     var configFileScope = Object.assign({}, bundleScope, {
-      dcpConfig: existing,
-      require:   moduleSystem.createRequire(fullPath),
-      url:       (href) => new (require('dcp/dcp-url').DcpURL)(href),
-      env:       process.env,
-      dcp:       { 'dcp-env': require('dcp/dcp-env') }, /* used for web-compat confs */
+      __filename: fullPath,
+      dcpConfig:  existing,
+      require:    moduleSystem.createRequire(fullPath),
+      url:        (href) => new (require('dcp/dcp-url').DcpURL)(href),
+      env:        process.env,
+      dcp:        { 'dcp-env': require('dcp/dcp-env') }, /* used for web-compat confs */
     });
 
     for (let key in existing)
@@ -867,8 +922,7 @@ function initTail(configFrags, options, finalBundleCode, finalBundleURL)
   addConfig(workingDcpConfig, configFrags.localConfig);
   addConfig(workingDcpConfig, originalDcpConfig);
 
-  bundleScope.dcpConfig = workingDcpConfig;
-  globalThis.dcpConfig    = workingDcpConfig;
+  globalThis.dcpConfig = bundleScope.dcpConfig = workingDcpConfig;
   bundleScope.dcpConfig.build = require('dcp/build').config.build; /* dcpConfig.build deprecated mar 2023 /wg */
 
   /* 4 */
@@ -1179,13 +1233,20 @@ exports.createConfigFragments = async function dcpClient$$createConfigFragments(
     resourceDir = path.resolve(os.homedir(), '.dcp');
   let programName = options.programName;
   const progDir = process.mainModule ? path.dirname(process.mainModule.filename) : process.cwd();
+  var   bin = require.main?.filename && path.dirname(require.main.filename);
   var   remoteConfig, remoteConfigKVIN;
   const internalConfig = require('dcp/dcp-config');
-  const defaultConfig = Object.assign({}, bootstrapConfig);
+  const defaultConfig = {};
+  addConfig(defaultConfig, bootstrapConfig);
+  assert(defaultConfig.__bootstrapConfig);
+  defaultConfig.__bootstrapConfig = false;
   addConfig(defaultConfig, internalConfig);
   addConfig(defaultConfig, KVIN.unmarshal(require('dcp/internal/dcp-default-config')));
   defaultConfig.scheduler = { location: new URL('https://scheduler.distributed.computer/') };
 
+  if (bin && !bin.endsWith('/bin'))
+    bin = false;
+
   /* localConfig eventually overrides remoteConfig, and is the dcpConfig variable that is modified by
    * local include files. Pre-populating the graph edges with config nodes that always exist allows
    * config file writers to add properties to leaf nodes without having to construct the entire graph;
@@ -1237,10 +1298,10 @@ exports.createConfigFragments = async function dcpClient$$createConfigFragments(
    * any intelligent user can always change the source code to do whatever they please, but it does
    * make sense for campus configurations where sysadmins believe the machines are locked down, etc.
    */
-  let cn;
         addConfigFile(localConfig, etc,    'dcp/dcp-config');
   await addConfigRKey(localConfig, 'HKLM', 'dcp/dcp-config');
-   cn = addConfigFile(localConfig, options.configName && path.resolve(progDir, options.configName));
+        addConfigFile(localConfig, bin,    '../etc/dcp/dcp-config');
+        addConfigFile(localConfig, options.configName && path.resolve(progDir, options.configName));
         addConfigFile(localConfig, resourceDir,  'dcp-config');
   await addConfigRKey(localConfig, 'HKCU', 'dcp/dcp-config');
         addConfigFile(localConfig, resourceDir,  `${programName}/dcp-config`);
@@ -1255,8 +1316,6 @@ exports.createConfigFragments = async function dcpClient$$createConfigFragments(
   await addConfigRKey(localConfig, 'HKLM', 'dcp/override-dcp-config');
   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.
@@ -1434,7 +1493,7 @@ function consumeArg(ckArg, bool)
   var ret;
   ckArg = '--dcp-' + ckArg;
 
-  for (let opt, i=2; i < process.argv.length; i++)
+  for (let i=2; i < process.argv.length; i++)
   {
     const arg = process.argv[i];
 

package/libexec/sandbox/access-lists.js

@@ -40,6 +40,7 @@ self.wrapScriptLoading({ scriptName: 'access-lists', ringTransition: true }, fun
     'escape',
     'eval',
     'EvalError',
+    'FinalizationRegistry',
     'Float32Array',
     'Float64Array',
     'Function',

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "dcp-client",
-  "version": "5.1.8",
+  "version": "5.1.9",
   "dcp": {
-    "version": "b23316107ba5b96b39a45d1ddda4f63f69dcc680",
+    "version": "40f188481ecd4b4ddabfe62bf127572f1b734c01",
     "repository": "git@gitlab.com:Distributed-Compute-Protocol/dcp.git"
   },
   "description": "Core libraries for accessing DCP network",