dcp-client 5.1.11 → 5.3.0

package/index.js

@@ -1305,16 +1305,15 @@ exports.createConfigFragments = async function dcpClient$$createConfigFragments(
         addConfigFile(localConfig, resourceDir,  'dcp-config');
   await addConfigRKey(localConfig, 'HKCU', 'dcp/dcp-config');
         addConfigFile(localConfig, resourceDir,  `${programName}/dcp-config`);
-  await addConfigRKey(localConfig, 'HKCU', `dcp/${programName}/dcp-config`);
+  await addConfigRKey(localConfig, 'HKCU', `${programName}/dcp-config`);
         addConfig    (localConfig, initConfig);
         addConfigEnv (localConfig, 'DCP_CONFIG_');
         addConfig    (localConfig, mkEnvConfig());
         addConfig    (localConfig, mkCliConfig(options));
         addConfigFile(localConfig, etc,    `dcp/${programName}/dcp-config`);
-  await addConfigRKey(localConfig, 'HKLM', `dcp/${programName}/dcp-config`);
+  await addConfigRKey(localConfig, 'HKLM', `${programName}/dcp-config`);
         addConfigFile(localConfig, etc,    'dcp/override-dcp-config');
   await addConfigRKey(localConfig, 'HKLM', 'dcp/override-dcp-config');
-  await addConfigRKey(localConfig, 'HKLM', 'dcp-client/dcp-config'); /* legacy - used by screen saver, /wg sep'22 */
 
   /* 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
@@ -1351,8 +1350,10 @@ exports.createConfigFragments = async function dcpClient$$createConfigFragments(
     {
       if (reportErrors !== false)
       {
-        console.error('Error: dcp-client::init could not fetch scheduler configuration at ' + aggrConfig.scheduler.configLocation);
-        console.debug(require('dcp/utils').justFetchPrettyError(error));
+        const code = error.code ? ` (${error.code})` : '';
+        console.error('Error: dcp-client::init could not fetch scheduler configuration at ' + aggrConfig.scheduler.configLocation + code);
+        if (error.code !== 'EHTTP_STATUS_ECONNREFUSED')
+          console.debug(require('dcp/utils').justFetchPrettyError(error));
         process.exit(1);
       }
       throw error;

package/lib/getopt.js

@@ -0,0 +1,94 @@
+/**
+ * @file     getopt.js - utility functions for parsing command-line options for DCP programs.
+ *                       Depends on posix-getopt npm library.  
+ * @author   Wes Garland, wes@distributive.network
+ * @date     Nov 2025
+ */
+'use strict';
+
+exports.parse = parse;
+exports.uniq  = uniq;
+
+/**
+ * A posix getopt parser with a nice UX and API.
+ * - accepts optionsDefn string like posix-getopt module, but understands that the character * means
+ *   long option only, and the -- option means to stop processing.
+ * - is a generator that yields for each option
+ *   - option:      character or long option when character is *.
+ *                  Magic option -- means that argvSegment is remainder of argv.
+ *   - optarg:      argument to option
+ *   - optind:      position of option character in argv
+ *   - argvSegment: elements of argv used to make up option and optarg
+ *
+ * @note this generator intercepts process.stderr for the duration of iteration
+ * @note option characters above \u1000 are not supported
+ *
+ * @example parse(process.argv.slice(2), 'vh(help)*:(earnings-account)p:(port)')
+ *          -v
+ *          -h, --help
+ *          --earnings-account=0xc0ffee
+ *          -p123, --port=123
+ *
+ * @param {Array}   argv          array of options to parse
+ * @param {string}  optionsDefn
+ * @throws {Error} when the options string is invalid
+ */
+function *parse(argv, optionsDefn)
+{
+  const { BasicParser } = require('posix-getopt');
+  var longOptCount = 0;
+
+  optionsDefn = optionsDefn /* patchup long opt * to > \u1000 chars */
+    .match(/[A-Za-z*]:?(\([^)]*\))?/g)
+    .map(s => s[0] === '*' ? String.fromCharCode(++longOptCount + 0x1000) + s.slice(1) : s).join('');
+  const optionChars = optionsDefn.match(/[A-Za-z\u1000-\u1100/](:?\([^)]*\))?/g).map(s=>s[0]);
+  const uniqueOptionChars = uniq(optionChars);
+  if (optionChars.length !== uniqueOptionChars.length)
+  {
+    uniqueOptionChars.forEach(ch => {
+      if (optionChars.lastIndexOf(ch) !== optionChars.indexOf(ch))
+        throw new Error(`getopt - option character '${ch}' used more than once`);
+    });
+    throw new Error('unreachable code');
+  }
+
+  argv = process.argv.slice(0,2).concat(argv);
+  const parser = new BasicParser(optionsDefn, argv);
+  const psw = process.stderr.write;
+  process.stderr.write = function patchupGetoptErrorOutput(s, ...args) {
+    /* posix-getopt library has useless chr for long opts when stderr.write('option requires an argument -- ' + chr + '\n'); */
+    if (s.startsWith('option requires an argument -- '))
+      s = `option ${argv[parser.optind() - 1]} requires an argument\n`;
+    psw.call(process.stderr, s, ...args);
+  };
+
+  for (let opthnd, lastOpt=2; (opthnd = parser.getopt()); lastOpt = parser.optind())
+  {
+    let option;
+
+    /* To fake long-only-opts, we use short opts >= \u1000), and present only the long opt below */
+    if (opthnd.option < '\u1000')
+      option = opthnd.option;
+    else
+      option = (Object.entries(parser.gop_aliases).filter(longShort => longShort[1] === opthnd.option)[0] || ['?'])[0];
+
+    yield { option, optarg: opthnd.optarg, optind: parser.optind() - 2, argvSegment: argv.slice(lastOpt, parser.optind()) };
+    if (opthnd.error)
+      break;
+  }
+
+  if (argv.length !== parser.optind())
+    yield { option: '--', optind: parser.optind(), argvSegment: argv.slice(parser.optind()) };
+
+  process.stderr.write = psw; // eslint-disable-line require-atomic-updates
+}
+
+/**
+ * Return a new array composed only of unique elements of arr
+ * @param {Array} arr
+ * @returns {Array}
+ */
+function uniq(array)
+{
+  return array.filter((val, idx, arr) => arr.indexOf(val) === idx);
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "dcp-client",
-  "version": "5.1.11",
+  "version": "5.3.0",
   "dcp": {
-    "version": "9f78dfbb5671e31a2a41670c694fd05a56962d65",
+    "version": "3eaced9015812e24ed08f2a0432c53b493483c37",
     "repository": "git@gitlab.com:Distributed-Compute-Protocol/dcp.git"
   },
   "description": "Core libraries for accessing DCP network",
@@ -21,7 +21,8 @@
   "author": "Distributive",
   "main": "index",
   "bin": {
-    "dcp-config-value": "bin/dcp-config-value"
+    "dcp-config-value": "bin/dcp-config-value",
+    "dcp-bank": "bin/dcp-bank"
   },
   "directories": {
     "example": "examples"
@@ -45,11 +46,12 @@
     "http-proxy-agent": "^4.0.1",
     "https-agent": "^1.0.0",
     "https-proxy-agent": "^5.0.0",
-    "kvin": "^1.2.18",
+    "kvin": "^9.0.0",
     "memfs": "4.17.2",
     "nanoid": "3.3.11",
     "physical-cpu-count": "^2.0.0",
     "polyfill-crypto.getrandomvalues": "^1.0.0",
+    "posix-getopt": "1.2.1",
     "regedit": "^3.0.3",
     "semver": "^7.3.5",
     "socket.io-client": "4.8.0",

package/windows-registry.js

@@ -1,156 +1,154 @@
-/**
- * @file        windows-registry.js
- *              Windows registry configuration/integration utility for DCP. All exported functions
- *              return false on non-Windows platforms.
- *
- *              Basic idea: summarize registry into an objects which can be used as the
- *              initializer object for DCP Client and wallet cache. Multiple hives are read
- *              to support higher-priviledged overrides for Administrators writing Group
- *              Policy files in Enterprise installs.
- *
- *              Note: In registry-speak, keys are like directories and values are like files -- i.e. a key can
- *              contain keys and/or values, but values cannot contain keys; only strings and numbers and stuff.
- *
- * 
- * future - we will need a better way to return registry values, current proposal is to use
- * REG_BINARY to encode richer types thus:
- *   0x00 - null
- *   0x20 - next 8 bytes are a little-endian float64
- *   0x40 - next byte is start of Uint8Array
- *   0x80 - false
- *   0x81 - true
- *   0x82 - undefined
- * future - we should probably expand our understanding of types as follows
- *   REG_DWORD - integer
- *   REG_QWORD - bigint
- *   REG_NONE  - treat as missing
- *   
- * @author      Wes Garland, wes@kingsds.network
- * @date        Jul 2020
- */
-const machHive = 'HKLM';
-const userHive = 'HKCU';
-const regedit = require('regedit');
-
-exports.baseKey = process.env.DCP_REGISTRY_BASEKEY || 'Software\\Distributive\\DCP';
-
-/** Join multiple registry keys fragments together into a full path. 
- *  @param      {string|Array} ...
- *  @returns    {string}
- */
-function keyJoin(/*...*/) {
-  var args = Array.from(arguments);
-  var flat = args.reduce((arr, x) => arr.concat(x), []);
-
-  return flat.join('\\');
-}
-
-/** Get all of the entries for a given key.  Keys are returned in a property
- *  named keys.  Values are returned in a property named values.
- */
-async function getEntries(key) {
-  var entries = {};
-
-  return new Promise(function (resolve, reject) {
-    try {
-      let stream = regedit.list([key]);
-
-      stream.on('data', function(entry) {
-        entries[entry.key] = entry.data;
-      });
-
-      stream.on('finish', function () {
-        resolve(entries);
-      })
-    } catch(e) {
-      reject(e);
-    }
-  })
-}
-
-/** Get all of the keys for a given key */
-async function getKeys(key) {
-  let entries = await getEntries(key);
-  return entries[key].keys || [];
-}
-
-/** Get all of the values for a given key */
-async function getValues(key) {
-  let entries = await getEntries(key);
-  return entries[key].values || {};
-}
-
-/** Returns true if a given key exists in the registry. Strange algorithm works
- *  around bugs in the npm regedit package.
- *
- *  @param      {string}        key            The key to check, eg HKLM\\Software\\Kings Distributed Systems
- *  @returns Promise which resolves to boolean
- */
-async function keyExists(key) {
-  var lhs, rhs;
-
-  for (rhs = key.split('\\'), lhs = rhs.splice(0,2).join('\\');
-       rhs.length;
-       lhs += '\\' + rhs.shift()) {
-    let subKeys = await getKeys(lhs);
-    if ((subKeys.map((a) => a.toUpperCase()).filter((a) => a === rhs[0].toUpperCase())).length === 0)
-      return false;
-  }
-  return true;
-}
-
-/**
- * Return the registry tree, including both keys and values, from the rootPath on down. 
- * keys are represented as JS objects, values are represented as JS values. For example,
- * a registry with \\HKCU\KDS\dcp-client\scheduler\location = 'https://scheduler.kds.net'
- * would become { 'dcp-client': scheduler: { location: 'https://scheduler.kds.net' } } if
- * the rootPath were \\HKCU\KDS.
- *
- * @param {string}      rootPath        The registry key to traverse
- * @param {object}      tree            [optional]      the JS object to decorate with the registry tree
- * @returns tree or a newly-created object
- */
-async function regTree(rootPath, tree) {
-  var values;
-
-  if (arguments.length !== 2)
-    tree = {};
-
-  for (let path of await getKeys(rootPath)) {
-    tree[path] = {};
-  }
-
-  for (let path in tree) {
-    await regTree(rootPath + '\\' + path, tree[path]);
-  }
-
-  values = await getValues(rootPath);
-  for (let prop in values) {
-    tree[prop] = values[prop].value;
-  }
-
-  return tree;
-}
-
-exports.getObject = async function dcpClient$$windowsRegistry$getObject(hive, keyTail) {
-  var tree = {};
-
-  keyTail = keyTail.replace(/\//g, '\\');
-  key = `${hive}\\${exports.baseKey}\\${keyTail}`;
-
-  if (await keyExists(key))
-    await regTree(key, tree);
-  else
-    return false;
-  
-  return tree;
-}
-
-/** Make all exported functions fast-path false return on non-windows */
-if (require('os').platform() !== 'win32') {
-  for (let exp in exports) {
-    if (typeof exports[exp] === 'function') {
-      exports[exp] = function() { return false };
-    }
-  }
-}
+/**
+ * @file        windows-registry.js
+ *              Windows registry configuration/integration utility for DCP. All exported functions
+ *              return false on non-Windows platforms.
+ *
+ *              Basic idea: summarize registry into an objects which can be used as the
+ *              initializer object for DCP Client and wallet cache. Multiple hives are read
+ *              to support higher-priviledged overrides for Administrators writing Group
+ *              Policy files in Enterprise installs.
+ *
+ *              Note: In registry-speak, keys are like directories and values are like files -- i.e. a key can
+ *              contain keys and/or values, but values cannot contain keys; only strings and numbers and stuff.
+ *
+ * 
+ * future - we will need a better way to return registry values, current proposal is to use
+ * REG_BINARY to encode richer types thus:
+ *   0x00 - null
+ *   0x20 - next 8 bytes are a little-endian float64
+ *   0x40 - next byte is start of Uint8Array
+ *   0x80 - false
+ *   0x81 - true
+ *   0x82 - undefined
+ * future - we should probably expand our understanding of types as follows
+ *   REG_DWORD - integer
+ *   REG_QWORD - bigint
+ *   REG_NONE  - treat as missing
+ *   
+ * @author      Wes Garland, wes@kingsds.network
+ * @date        Jul 2020
+ */
+'use strict';
+
+const regedit = require('regedit');
+exports.baseKey = process.env.DCP_REGISTRY_BASEKEY || 'Software\\Distributive';
+
+/** Get all of the entries for a given key.  Keys are returned in a property
+ *  named keys.  Values are returned in a property named values.
+ */
+async function getEntries(key) {
+  var entries = {};
+
+  return new Promise(function (resolve, reject) {
+    try {
+      let stream = regedit.list([key]);
+
+      stream.on('data', function(entry) {
+        entries[entry.key] = entry.data;
+      });
+
+      stream.on('finish', function () {
+        resolve(entries);
+      })
+    } catch(e) {
+      reject(e);
+    }
+  })
+}
+
+/** Get all of the keys for a given key */
+async function getKeys(key) {
+  let entries = await getEntries(key);
+  return entries[key].keys || [];
+}
+
+/** Get all of the values for a given key */
+async function getValues(key) {
+  let entries = await getEntries(key);
+  return entries[key].values || {};
+}
+
+/** Returns true if a given key exists in the registry. Strange algorithm works
+ *  around bugs in the npm regedit package.
+ *
+ *  @param      {string}        key            The key to check, eg HKLM\\Software\\Kings Distributed Systems
+ *  @returns Promise which resolves to boolean
+ */
+async function keyExists(key) {
+  var lhs, rhs;
+
+  for (rhs = key.split('\\'), lhs = rhs.splice(0,2).join('\\');
+       rhs.length;
+       lhs += '\\' + rhs.shift()) {
+    let subKeys = await getKeys(lhs);
+    if ((subKeys.map((a) => a.toUpperCase()).filter((a) => a === rhs[0].toUpperCase())).length === 0)
+      return false;
+  }
+  return true;
+}
+
+/**
+ * Return the registry tree, including both keys and values, from the rootPath on down. 
+ * keys are represented as JS objects, values are represented as JS values. For example,
+ * a registry with \\HKCU\KDS\dcp-client\scheduler\location = 'https://scheduler.kds.net'
+ * would become { 'dcp-client': scheduler: { location: 'https://scheduler.kds.net' } } if
+ * the rootPath were \\HKCU\KDS.
+ *
+ * @param {string}      rootPath        The registry key to traverse
+ * @param {object}      tree            [optional]      the JS object to decorate with the registry tree
+ * @returns tree or a newly-created object
+ */
+async function regTree(rootPath, tree) {
+  var values;
+
+  if (arguments.length !== 2)
+    tree = {};
+
+  for (let path of await getKeys(rootPath)) {
+    tree[path] = {};
+  }
+
+  for (let path in tree) {
+    await regTree(rootPath + '\\' + path, tree[path]);
+  }
+
+  values = await getValues(rootPath);
+  for (let prop in values) {
+    tree[prop] = values[prop].value;
+  }
+
+  return tree;
+}
+
+/**
+ * Get an object from the registry.  This is can be a key or a tree. The object is identified
+ * by the hive, exports.baseKey, and the keyTail.
+ *
+ * @param {string} hive        the hive to search (eg HKLM)
+ * @param {string} keyTail     the end of the key
+ *
+ * @returns {Promise} that resolves to false (lookup miss), a registry tree, or a registry object from
+ *                    regTree().
+ */
+exports.getObject = async function dcpClient$$windowsRegistry$getObject(hive, keyTail) {
+  var tree = {};
+
+  keyTail = keyTail.replace(/\//g, '\\');
+  const key = `${hive}\\${exports.baseKey}\\${keyTail}`;
+
+  if (await keyExists(key))
+    await regTree(key, tree);
+  else
+    return false;
+  
+  return tree;
+}
+
+/** Make all exported functions fast-path false return on non-windows */
+if (require('os').platform() !== 'win32') {
+  for (let exp in exports) {
+    if (typeof exports[exp] === 'function') {
+      exports[exp] = function() { return false };
+    }
+  }
+}