dcp-worker 4.5.0 → 4.5.1

package/.gitlab-ci.yml

@@ -17,6 +17,7 @@ default:
   image: node:lts
   before_script:
     - npm add --global npm@latest
+    - npm config set allow-git=all
     # Access private deps. e.g., `dcp-client` from GitLab.
     - git config --global
       url."${CI_SERVER_PROTOCOL}://gitlab-ci-token:${CI_JOB_TOKEN}@${CI_SERVER_HOST}:${CI_SERVER_PORT}".insteadOf

package/bin/collect-debug-info

@@ -26,45 +26,36 @@ process.stdout.write(`
 *** This program collects information from your computer, and sends it to
 *** Distributive and our analytics partners. This includes your local DCP
 *** configuration, which might include sensitive information such as Compute
-*** Group credentials, or API keys.
+*** Group information, or API keys.
 
 `);
 
-while (argv[0])
+for (; argv.length; argv.shift())
 {
-  if (argv[0] === '-f' || argv[0] === '--force')
-  {
-    argv.shift();
-    force = true;
-    continue;
-  }
-
-  if (argv[0] === '-s')
-  {
-    syslogUrl = argv[0];
-    argv.shift();
-    continue;
-  }
-
   if (argv[0].startsWith('--syslog='))
-  {
     syslogUrl = argv[0].slice(0);
-    argv.shift();
+  else if (argv[0].startsWith('--dcp-'))
     continue;
+  else if (argv[0] === '-f' || argv[0] === '--force')
+    force = true;
+  else if (argv[0] === '-s')
+  {
+    syslogUrl = argv[1];
+    shift();
   }
-
-  break;
+  else if (argv.length === 1)
+    email = argv[0];
+  else
+    throw new Error('invalid argument: ' + argv[0]);
 }
 
 if (force)
 {
   go();
-  email = argv[0] || 'wes+worker-debug-info@distributive.network';
+  email = email || 'dcp+worker-debug-info@distributive.network';
 }
 else
 {
-  email = argv[0];
-
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
@@ -100,8 +91,6 @@ async function emailReport(report)
 {
   const protocol = require('dcp/protocol');
   const worker   = require('dcp/worker');
-
-  const conn = new protocol.Connection(dcpConfig.scheduler.services.mailgw);
   const message = {
     from:        `${os.userInfo().username}-${worker.DistributiveWorker.obtainWorkerId()}-worker-${os.hostname()}@distributive.network`,
     fromName:    'collect-debug-info',
@@ -112,6 +101,15 @@ async function emailReport(report)
     body:        `<html><pre>${report}</pre></html>`
   };
 
+  if (email === '-')
+  {
+    console.log(report);
+    return;
+  }
+
+  const mailgw = dcpConfig.scheduler.services.mailgw;
+  console.log(` - sending email via ${mailgw.location}`);
+  const conn = new protocol.Connection(mailgw);
   const response = await conn.request('sendmail', message);
   conn.close();
   console.log(' - sent report to', message.to);
@@ -126,7 +124,7 @@ async function cmd(prog, args)
   argv.unshift(prog);
   argv.unshift('/c');
   const s = execFileSync('cmd', argv, { encoding: 'utf8' });
-  return `------ [ ${prog} ] ---------------------------------------------------------------\n${s}`;
+  return `------ [ ${prog} ] ------\n${s}`;
 }
 
 async function sh(prog, args)
@@ -134,7 +132,7 @@ async function sh(prog, args)
   const argv = args.slice();
   console.log(' -', prog, argv.join(' '));
   const s = execFileSync(prog, argv, { encoding: 'utf8', maxBuffer: 1e9 });
-  return `------ [ ${prog} ] ---------------------------------------------------------------\n${s}`;
+  return `------ [ ${prog} ] ------\n${s}`;
 }
 
 async function go()
@@ -147,9 +145,29 @@ async function go()
       worker:    { logging: { syslog: {} } },
     }
   });
+  const { DcpURL } = require('dcp/dcp-url');
+  DcpURL.prototype.toJSON = function() { return { href: this.href } };
+  URL.prototype.toJSON = function() { return { href: this.href } };
+  const dcpConfigNoCreds = Object.assign({}, dcpConfig);
+  dcpConfigNoCreds.worker = Object.assign({}, dcpConfigNoCreds.worker);
+  delete dcpConfigNoCreds.worker.computeGroups;
+
+  for (let serviceGroup in dcpConfig)
+  {
+    if (dcpConfig[serviceGroup].location)
+      dcpConfig[serviceGroup].location = new URL(dcpConfig[serviceGroup].location);
+    if (dcpConfig[serviceGroup].services)
+    {
+      for (let service in dcpConfig[serviceGroup].services)
+      {
+        if (dcpConfig[serviceGroup].services[service].location)
+          dcpConfig[serviceGroup].services[service].location = new URL(dcpConfig[serviceGroup].services[service].location);
+      }
+    }
+  }
 
   console.log(' - host information');
-  var report = `------ [ ${new Date()} ] ---------------------------------------------------------------
+  var report = `------ [ ${new Date()} ] ------
 os:            ${os.version()}
 platform:      node ${process.version} ${os.platform()} ${os.release()} ${os.machine()} ${os.endianness()}
 uptime:        ${Math.floor(os.uptime() / 86400)} days ${Number(((os.uptime() / 86400) % 1) * 86400).toFixed(1)} seconds, load average: ${os.loadavg().join(', ')}
@@ -161,11 +179,12 @@ cpus:          ${JSON.stringify(os.cpus, null, 2)}
 network:       ${JSON.stringify(os.networkInterfaces, null, 2)}
 more versions: ${JSON.stringify(process.versions, null, 2)}
 `;
-
+  console.log(' - worker information');
+  report += await createWorkerReport();
   console.log(' - dcp information');
   report +=
 `
-dcpConfig:     ${JSON.stringify(dcpConfig, null, 2)}
+dcpConfig:     ${JSON.stringify(dcpConfigNoCreds, null, 2)}
 `;
 
   if (os.platform() === 'win32')
@@ -190,3 +209,27 @@ dcpConfig:     ${JSON.stringify(dcpConfig, null, 2)}
   else if (syslogUrl)
     syslogReport(report);
 }
+
+async function createWorkerReport()
+{
+  const identity = require('dcp/identity');
+  const wallet   = require('dcp/wallet');
+  const utils    = require('../lib/utils');
+  const { DistributiveWorker } = require('dcp/worker');
+  const worker = new DistributiveWorker(Object.assign({
+    unmanaged: true
+  }, dcpConfig.worker), Function).unref();
+  identity.interactive = false;
+  const rootIdentity = await wallet.getId();//identity.get();
+  await identity.masquerade(DistributiveWorker.obtainWorkerId(), '$login');
+  await worker.configure();
+
+  return `
+root identity: ${rootIdentity.address}
+masquerade:    ${identity.get().address}
+worker id:     ${worker.id}
+earnings acct: ${worker.config.paymentAddress}
+join keys:     ${Object.values(worker.config.computeGroups).map(cg => cg.joinKey)}
+worker config: ${JSON.stringify(Object.assign({}, worker.config, { computeGroups: 'HIDDEN' }), null, 2)}
+`
+}

package/bin/dcp-evaluator-manager

@@ -19,10 +19,10 @@
  */
 'use strict';
 
+const net     = require('mux-net').hook();
 const os      = require('os');
 const fs      = require('fs');
 const path    = require('path');
-const net     = require('net');
 const dns     = require('dns');
 const debug   = require('debug');
 const pidfile = require('../lib/pidfile');
@@ -64,6 +64,10 @@ const daemonConfig = {
 
 async function processExit(code)
 {
+  if (processExit.p$exiting)
+    return processExit.p$exiting;
+  processExit.p$exiting = new Promise(()=>1); /* never resolves, other "thread" will exit program */
+
   if (typeof code === 'undefined')
     code = process.exitCode;
   console.debug('Exit, code', code);
@@ -80,7 +84,7 @@ Released under the terms of the MIT License.
 
 Usage: ${process.argv[0]} [-h | --help] [--prefix=<dir>] [--pts=<dir>]
        [--disable-monitor=<session|screensaver|signal>] [-i <timeout>]
-       [-p port] [-H hostname]
+       [-p port] [-H hostname[,hostname...]]
        [-a] [-l | --max-load=<number>] [-r | --rate=<number>] [-L]
        [-s | --signal=[name or number][,<toggle|quick>]]
        [-T | --loadavg-type=<short,medium,long,random>]
@@ -127,32 +131,56 @@ Environment:
  */
 async function listenForConnections(config)
 {
-  var server = net.createServer((socket) => handleConnection(socket, config));
-  var hostaddr;
+  const server = net.createServer((socket) => handleConnection(socket, config));
+  const hostnames = config.net.hostnames || [ config.net.hostname ];
+  const hosts = [];
 
-  if (config.net.hostname === 'localhost')
-    hostaddr = '::';
+  if (!hostnames[0])
+  {
+    hosts[0] = '::1';
+    hosts[1] = '127.0.0.1';
+  }
   else
-    hostaddr = (await dns.promises.lookup(config.net.hostname, { family: 4 })).address || config.net.hostname;
+  {
+    for (let host of hostnames)
+    {
+      try
+      {
+        const hostaddrs = await dns.promises.lookup(host, { all: true, order: 'verbatim' });
+        for (let hostaddr of hostaddrs)
+          hosts.push(hostaddr.address);
+      }
+      catch(error)
+      {
+        if (error.code === 'EAI_AGAIN')
+          console.error(`hostname ${host} not found - check /etc/hosts or DNS configuration`);
+        else
+          console.error(`error ${error.code} resolving host ${host}:`, error.message);
+        await processExit(4);
+      }
+    }
+  }
 
   server.on('error', (error) => {
     delete error.stack;
+    if (processExit.p$exiting)
+      return;
     console.error(error);
     processExit(2);
   });
 
-  server.listen({ host: hostaddr, port: config.net.port }, function daemonReady() {
-    console.log('Listening for connections on', server._connectionKey);
+  console.log('Evaluator command is', config.proc, config.argv);
+  server.listen({ hosts, port: config.net.port }, function daemonReady() {
+    // eslint-ignore-block no-invalid-this
+    console.log(`Listening for connections on ${config.net.hostname} (${this._connectionKey})`);
     if (Number(config.net.port) === 0)
     {
       console.log('Using dynamic port', server.address().port);
       // Send info by IPC, if the spawn is setup for that. Probably don't need to try/catch.
       /* WHAT IS THIS FOR? /wg feb 2026 */
       if (process.send)
-        try { process.send(server.address().port); } catch (e) {}
+        try { process.send(server.address().port); } catch (e) { e; 'dontcare'; }
     }
-
-    console.log('Evaluator command is', config.proc, config.argv);
   });
 }
 
@@ -430,7 +458,7 @@ async function dbusScreenSaverMonitor()
   {
     const prettyName = chosen.split('.')[1];
     console.error(`${prettyName} screensaver doesn't support activeness query, screensaver is not started, or user ${os.userInfo().username} doesn't have access to dbus\n ${error}`);
-    processExit(3);
+    await processExit(3);
   }
 }
 
@@ -654,7 +682,9 @@ async function main()
 
       case 'H':
       {
-        daemonConfig.net.hostname = optarg;
+        delete daemonConfig.net.hostname;
+        daemonConfig.net.hostnames = optarg.split(/[, ]+/);
+        console.log(daemonConfig.net.hostnames);
         break;
       }
 
@@ -763,7 +793,8 @@ async function main()
 }
 
 /* Initialize dcp-client to use only local resources before launching the main function */
-try {
+try
+{
   process.on('SIGHUP',  () => processExit( 1 - 128));
   process.on('SIGINT',  () => processExit( 2 - 128));
   process.on('SIGTERM', () => processExit(15 - 128));

package/bin/dcp-task-probe

@@ -641,7 +641,7 @@ async function main()
   console.log('Worker Id:           ', workerId);
   console.log('Max Sandboxes:       ', workerConfig.maxSandboxes);
   console.log('Cores:               ', Object.assign({}, workerConfig.cores));
-  console.log('Utilization:         ', workerConfig.utilization);
+  console.log('Utilization:         ', Object.assign({}, workerConfig.utilization));
   console.log('DCP Address:         ', String(identity.get().address));
 
   if (!task)
@@ -705,7 +705,4 @@ async function main()
 }
 
 /* Initialize dcp-client to use only local resources before launching the main function */
-require('dcp-client').init({
-  programName: 'dcp-worker',
-  parseArgv: false,
-}).then(main);
+require('dcp-client').init({ programName: 'dcp-worker' }).then(main);

package/bin/dcp-worker

@@ -116,6 +116,12 @@ Options:
       --disable-httpd                Disable management service
       --management-hostname=         Override the management service hostname
       --management-port=             Override the management service port
+      --management-path=             Management service will listen on a unix
+                                     domain socket instead of a tcp socket,
+                                     setting this overrides options
+                                     --management-hostname and --management-port.
+                                     In addition, it will break all webpages that
+                                     come with the management daemon.
       --register=key[,label]         Use the given key to register this worker
                                      with your Distributive account and exit
       --unmanaged                    Do not report statistics to or read config
@@ -148,8 +154,8 @@ function* parseCliOptions(argv)
       + 'h(help)*:(earnings-account)*:(identity-keystore)'
       + 'c:(cores)u:(utilization)m:(max-sandboxes)H:(hostname)p:(port)'
       + 'o:(output)l:(logger)*:(logfile)*(overwrite-logfile)*:(syslog)*:(min-level)j:(job)g:(join)'
-      + 'a:(allow-origin)*(zero-trust)*(no-global)*(kvin)*(json)*:(show)*'
-      + '(unmanaged)*:(management-hostname)*:(management-port)'
+      + 'a:(allow-origin)*(zero-trust)*(no-global)*(kvin)*(json)*:(show)'
+      + '*(unmanaged)*:(management-hostname)*:(management-port)*:(management-path)'
       + '*(no-masquerade)*:(force-worker-id)*:(lookup-worker-id)'
       + '*(no-claim-earnings)*:(register)*:(claim-earnings)*(reset)f:(pidfile)*(no-pidfile)v(verbose)';
 
@@ -314,6 +320,7 @@ function processCliOptsPhase1(argv, operatingMode)
       case 'claim-earnings':
       case 'register':
         operatingMode.zeroTrust = true;
+        /* fallthrough */
       case 'show':
         operatingMode.consoleType = 'stdio';
         /* fallthrough */
@@ -460,6 +467,9 @@ async function processCliOptsPhase2(argv, operatingMode, loggingOptions)
       case 'management-port':
         httpd.config.port = Number(optarg);
         break;
+      case 'management-path':
+        httpd.config.path = optarg;
+        break;
       case 'disable-httpd':
         operatingMode.startHttpd = false;
         break;
@@ -519,7 +529,6 @@ async function mergeDbAppConfig(remainArgv, operatingMode, loggingOptions)
  */
 async function main()
 {
-  var workerIsStopping = false;
   const identity = require('dcp/identity');
   /* handle file-wide dcp-client imports */
   wallet = require('dcp/wallet');
@@ -582,7 +591,6 @@ async function main()
   worker.runInfo.type = 'dcp-worker';
   worker.on('warning', (...payload) => console.warn (...payload));
   worker.on('claim', amount => console.log(` . transfered ${amount} ⊇ to ${worker.config.paymentAddress}`));
-  worker.on('stop', () => workerIsStopping = true );
   await processCliOptsPhase2(remainArgv, operatingMode, loggingOptions);
 
   if (operatingMode.show)
@@ -707,14 +715,11 @@ async function main()
     }
   }
 
-  if (!workerIsStopping)
-  {
-    console.info(` . Utilization Target:  cpu: ${String(Math.round(worker.config.utilization.cpu * 100)).padStart(3, ' ')}% `
-                 + `gpu: ${Math.round(worker.config.utilization.gpu * 100)}%`);
-    console.info(` . Configured Cores:    cpu: ${String(worker.config.cores.cpu).padEnd(3, ' ')} `
+  console.info(` . Utilization Target:  cpu: ${String(Math.round(worker.config.utilization.cpu * 100)).padStart(3, ' ')}% `
+               + `gpu: ${Math.round(worker.config.utilization.gpu * 100)}%`);
+  console.info(` . Configured Cores:    cpu: ${String(worker.config.cores.cpu).padEnd(3, ' ')} `
                  + ` gpu: ${worker.config.cores.gpu}`);
-    console.info(` . Maximum Sandboxes:  ${worker.config.maxSandboxes}`);
-  }
+  console.info(` . Maximum Sandboxes:  ${worker.config.maxSandboxes}`);
   console.info(' . Supervisor version: ' + worker.supervisorVersion);
   console.info(' . Console type:       ' + operatingMode.consoleType);
   console.info(' . Logging:            ' + (loggingOptions.loggers.join(', ') || 'none'));
@@ -730,10 +735,22 @@ async function main()
     return;
   require('../lib/check-scheduler-version').check();
 
-  worker.on('end', async () => {
-    if (process.exitCode === exitCodes.lostRef)
-      process.exitCode = exitCodes.normal;
-    await cleanupThenExit(exitCodes.normal);
+  /* Hold the worker.p$stop promise between the stop and end events, for use by cleanUpThenExit() */
+  worker.on('stop', () => {
+    debug('dcp-worker:exit')('Trapped DistributiveWorker<stop> stop event with running worker');
+    const pr$stop = Promise.withResolvers();
+    worker.p$stop = pr$stop.promise;
+    worker.ref();
+    worker.on('end', () => {
+      debug('dcp-worker:exit')('Trapped DistributiveWorker<end> event after stop event');
+      pr$stop.resolve();
+      worker.unref();
+      cleanupThenExit(exitCodes.normal);
+    });
+    worker.on('error', (error) => {
+      debug('dcp-worker:exit')('Trapped DistributiveWorker<error> event after stop event');
+      pr$stop.reject(error);
+    });
   });
 
   worker.on('error', function handleWorkerError(error) {
@@ -826,6 +843,10 @@ function parseResourceOption(option)
  */
 async function handleUnhandled(error)
 {
+  /* Wrap null/undefined throws so the Android embedder doesn't surface them as a bare "JS Exception: null". */
+  if (error === null || error === undefined)
+    error = new Error(`Non-Error thrown: ${error === null ? 'null' : 'undefined'}`);
+
   if (error instanceof utils.UserError)
     console.error('Error:', error?.message);
   else if (!error.request || !error.code?.startsWith('EHTTP_'))
@@ -864,30 +885,34 @@ async function handleUnhandled(error)
 async function cleanupThenExit(exitCode)
 {
   debug('dcp-worker:exit')('cleanup and exit, code', exitCode);
-  if (worker)
-    worker.stop(true); /* toggle internal worker state so it won't surprise us by starting sandboxes */
-
-  const p$note = utils.noteWorkerShutdown(worker);
-  if (cleanupThenExit.busy)
+  if (process.exitCode === exitCodes.lostRef || process.exitCode === exitCodes.normal)
+    process.exitCode = exitCode;
+  if (!cleanupThenExit.busy)
+    cleanupThenExit.busy = true;
+  else
   {
-    if (!process.exitCode)
-      process.exitCode = exitCode;
     debug('dcp-worker:exit')('exit race, bailing on cleanup for exit code', exitCode);
     return;
   }
 
-  worker = false;
-  cleanupThenExit.busy = true;
-  process.exitCode = exitCode;
+  if (worker)
+    worker.stop(true); /* toggle internal worker state so it won't surprise us by starting sandboxes */
+
+  const p$workerShutdownTasks = Promise.all([
+    utils.noteWorkerShutdown(worker),
+    worker?.p$stop,
+  ]);
 
   /* Final event loop reference; keeps the process alive while the loggers unhook */
   setTimeout(() => {
+    debug('dcp-worker:exit')('logger cleanup timeout expired');
     console.warn(' *** logger cleanup timeout expired ***');
     process.exit();
   }, 10 * 1e3).ref();
 
   try
   {
+    debug('dcp-worker:exit')('unhooking process events');
     process.off('SIGESC',  handleSigDeath);
     process.off('SIGINT',  handleSigDeath);
     process.off('SIGTERM', handleSigDeath);
@@ -895,11 +920,16 @@ async function cleanupThenExit(exitCode)
     process.off('unhandledRejection', handleUnhandled);
     process.off('uncaughtException',  handleUnhandled);
     if (console.close)
+    {
+      debug('dcp-worker:exit')('closing console');
       console.close();
-    loggers.unhook()
+    }
+    debug('dcp-worker:exit')('unhooking loggers');
+    await loggers.unhook()
+      .then(() => debug('dcp-worker:exit')('loggers unhooked'))
       .catch(error => { console.error('Error unhooking loggers:', error) })
       .finally(async () => {
-        await p$note;
+        await p$workerShutdownTasks.catch(console.error);
         debug('dcp-worker:exit')('done cleanup, exitCode=' + process.exitCode);
         process.exit();
       });

package/lib/utils.js

@@ -176,7 +176,6 @@ function makeSyslogUrl(existingUrl, newArg)
 async function getOwner(worker)
 {
   const { DistributiveWorker } = require('dcp/worker');
-  const identity = require('dcp/identity');
 
   if (worker.config.unmanaged)
     return undefined;
@@ -385,6 +384,7 @@ exports.noteWorkerStart = async function noteWorkerStart(worker)
   if (worker.config?.unmanaged)
     return;
 
+  debug('dcp-worker:start')('noting worker start');
   return worker.updateRunInfo({
     lastStartTime:  new Date(),
     status:         'running',

package/lib/web-iface.js

@@ -35,8 +35,17 @@ const bootDate = new Date();
 var worker;
 var totalEarnings = 0;
 
-/** Configuration for the server, must be mutated before a$init */
-exports.config = { hostname: 'localhost', port: 9080 };
+/** Configuration for where the server binds, we support TCP and unix domain sockets, the default is TCP.
+ *  Must be mutated before a$init.
+ */
+exports.config = {
+  // TCP
+  hostname: 'localhost',
+  port: 9080,
+
+  // unix domain socket, setting this will override the TCP settings
+  path: undefined,
+};
 
 /**
  * Web server initialization.
@@ -52,12 +61,17 @@ exports.a$init = function init(__worker)
   try
   {
     worker = __worker;
-    console.info(` . Starting management service on ${exports.config.hostname}:${exports.config.port}`);
+    if (exports.config.path)
+      console.info(` . Starting management service on ${exports.config.path}`);
+    else
+      console.info(` . Starting management service on ${exports.config.hostname}:${exports.config.port}`);
     const target = new protocol.Target(
       ['socketio'],
       {
         identity: identity.get(),
-        listen: new URL(`http://${exports.config.hostname}:${exports.config.port}/dcp/`),
+        listen: exports.config.path ?
+                    new URL(`unix://${exports.config.path}`)
+                  : new URL(`http://${exports.config.hostname}:${exports.config.port}/dcp/`),
       },
       listeningHandler,
       { socketio: { module: require('socket.io') } },
@@ -213,7 +227,7 @@ function setupWebServer(app)
   KVIN.userCtors.dcpUrl$$DcpURL  = require('dcp/dcp-url').DcpURL;
 
   app.use((req, res) => {
-    const ipAddress = req.socket.address().address;
+    const ipAddress = req.socket.address().address || '';
     const originalUrl = req.originalUrl;
 
     let endFired = false;

package/lib/worker-consoles/dashboard-console.js

@@ -163,7 +163,7 @@ function createDashboard()
 function setWorker(worker)
 {
   const identity = require('dcp/identity');
-  
+
   console.log(' . Starting dashboard');
   setInterval(() => screen && screen.render(), 2000).unref(); /* ensure we didn't forget to render an important update */
   updateWorkerInfo();
@@ -321,7 +321,12 @@ exports.init = function dashboardConsole$$Init()
   const logHistory = new RingBuffer(closeLogDumpSize);
   const inspect = Symbol.for('nodejs.util.inspect.custom');
 
+  /* createDashoard adds a SIGINT event handler which intereferes with orderly shutdown, so we remove it */
+  const sigintHandlers = process.listeners('SIGINT');
   createDashboard();
+  for (let sigintHandler of process.listeners('SIGINT'))
+    if (sigintHandlers.indexOf(sigintHandler) === -1)
+      process.off('SIGINT', sigintHandler);
 
   function consoleMethodFactory(logLevel)
   {
@@ -367,7 +372,8 @@ exports.init = function dashboardConsole$$Init()
   }
 
   /**
-   * Destroy the dashboard, then dump the most recent lines back to stdout/stderr.
+   * Destroy the dashboard, dump the most recent lines back to stdout/stderr, then replace the console
+   * object's methods with methods that will write to stdio to capture shutdown error locally
    */
   console.close = function dashboardConsole$$close()
   {
@@ -382,6 +388,7 @@ exports.init = function dashboardConsole$$Init()
       const { logLevel, argv } = entry;
       stdioConsole[logLevel](...argv);
     });
+    Object.assign(console, stdioConsole);
   }
 
   console.setWorker = setWorker;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcp-worker",
-  "version": "4.5.0",
+  "version": "4.5.1",
   "description": "Node.js Worker for Distributive Compute Platform",
   "main": "bin/dcp-worker",
   "keywords": [
@@ -39,8 +39,9 @@
     "blessed": "0.1.81",
     "blessed-contrib": "4.11.0",
     "chalk": "4.1.2",
-    "dcp-client": "^5.7.0",
-    "kvin": "^9.0.0",
+    "dcp-client": "^5.7.4",
+    "kvin": "9.1.0",
+    "mux-net": "github:wesgarland/mux-net#e7f81800db4a84ec880026596f7ee68549a6d0f5",
     "posix-getopt": "1.2.1",
     "semver": "7.7.3",
     "socket.io": "4.8.1",
@@ -53,8 +54,11 @@
   },
   "devDependencies": {
     "@distributive/eslint-config": "2.1.4",
+    "@stylistic/eslint-plugin": "3.1.0",
     "@trunkio/launcher": "1.2.7",
     "eslint": "9.39.1",
+    "eslint-plugin-jsdoc": "47.0.2",
+    "eslint-plugin-unicorn": "49.0.0",
     "peter": "2.4.7"
   },
   "peerDependencies": {
@@ -71,11 +75,12 @@
   },
   "overrides": {
     "blessed-contrib": {
+      "lodash": "4.18.1",
       "xml2js": "0.6.2"
     },
     "dbus-next": {
       "xml2js": "0.6.2",
-      "tar": "7.5.11",
+      "tar": "7.5.22",
       "usocket": "1.0.2"
     }
   }

package/tests/worker-with-options.simple

@@ -67,7 +67,11 @@ async function main()
   strictEqual(confObj.leaveGlobalGroup, true, `leaveGlobalGroup is ${confObj.leaveGlobalGroup}`);
   deepEqual(confObj.cores, { cpu: 3, gpu: 1 }, `Mismatch in cores! cpu: ${confObj.cores.cpu}, gpu: ${confObj.cores.gpu}`);
   deepEqual(confObj.utilization, { cpu: 0.1, gpu: 0.5 }, `Mismatch in utilization! cpu: ${confObj.utilization.cpu}, gpu: ${confObj.utilization.gpu}`);
-  deepEqual(confObj.computeGroups, { joinKey1: { joinKey: 'joinKey1', joinSecret: 'joinHash1' }, joinKey2: { joinKey: 'joinKey2', joinSecret: 'joinHash2' } }, 'Mismatch in computeGroups')
+
+  let cgCompare = { joinKey1: { joinKey: 'joinKey1', joinSecret: 'joinHash1' }, joinKey2: { joinKey: 'joinKey2', joinSecret: 'joinHash2' } };
+  if (Array.isArray(confObj.computeGroups))
+    cgCompare = Object.assign([], cgCompare);
+  deepEqual(confObj.computeGroups, cgCompare, 'Mismatch in computeGroups');
   deepEqual(confObj.maxSandboxes, 5, `Mismatch! maxSandboxes:${confObj.maxSandboxes}`);
   deepEqual(confObj.jobIds, ['09fd0909Bd93f7bad915726C3AB4'], `Mismatch  in job ids! jobIds:${confObj.jobIds}`);
 

package/tests/worker-with-unix-management.simple.skip

@@ -0,0 +1,103 @@
+#! /usr/bin/env node
+
+/**
+ * @file        worker-with-unix-management.simple.skip
+ *
+ *              Tests and demonstrates how to bind the management daemon to a unix domain socket and
+ *              query over it. It's marked skip because the worker requires an evaluator and doing so in CI
+ *              is cumbersome. Run it manually.
+ *
+ * @author      Liang Wang <liang@distributive.network>
+ * @date        June 2026
+ *
+ * peter-timeout: 5
+ */
+'use strict';
+
+const assert = require('node:assert');
+
+const { tmpdir } = require('node:os');
+const { spawn } = require('node:child_process');
+const { mkdtempSync, rmSync, existsSync, writeFileSync } = require('node:fs');
+const { join, parse, basename } = require('node:path');
+const { setTimeout } = require('node:timers/promises');
+const { request } = require('node:http');
+const { strictEqual } = assert;
+
+const filename = parse(basename(__filename)).name;
+const tempd = mkdtempSync(join(tmpdir(), `${filename}-`));
+const socketPath = join(tempd, `${filename}.sock`);
+process.chdir(__dirname);
+
+process.on('exit', () => existsSync(tempd) && rmSync(tempd, { recursive: true }));
+
+async function main()
+{
+  const { Keystore } = require('dcp/wallet');
+  const ks = await new Keystore(null);
+  const id = await new Keystore(null);
+
+  writeFileSync(`${tempd}/default.keystore`, JSON.stringify(ks.toJSON()), { encoding: 'utf-8' });
+  writeFileSync(`${tempd}/id.keystore`, JSON.stringify(id.toJSON()), { encoding: 'utf-8' });
+
+  const args = [
+      `--management-path=${socketPath}`,
+  ];
+
+  const worker = spawn(
+    '../bin/dcp-worker', args,
+    {
+      encoding: 'utf-8',
+      env: {
+        ...process.env,
+        DCP_RESOURCE_DIR: tempd
+      }
+    }
+  );
+
+  await setTimeout(1000);
+  const requestComplete = new Promise((resolve, reject) => {
+    const req = request(
+      {
+        socketPath,
+        path: "/worker/id",
+        headers: {
+          Accept: "*/*",
+        },
+      },
+      (res) => {
+        let body = "";
+
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          body += chunk;
+        });
+
+        res.on("end", () => {
+          strictEqual(res.statusCode, 200);
+          console.log("DONE");
+          console.log("headers:", res.headers);
+          console.log("body:", body);
+          resolve();
+        });
+      }
+    );
+
+    req.on("error", (err) => {
+      console.error(`request failed ${err}`);
+      reject(err);
+    });
+
+    req.end();
+  });
+
+  try {
+    await requestComplete;
+  } finally {
+    worker.kill();
+  }
+}
+
+require('dcp-client')
+  .init()
+  .then(main);

package/www/admin/register-worker.html

@@ -7,6 +7,7 @@
 -->
 <html lang="en">
   <head>
+    <meta charset="UTF-8">
     <script src="/dcp-client/dcp-client.js"></script>
     <script>
 window.addEventListener('error',              ev => dcp['dom-tk'].modals.alert(ev));