dcp-worker 4.5.1 → 4.5.2

package/bin/dcp-worker

@@ -13,6 +13,7 @@
  */
 'use strict';
 var worker;
+var workerStarted = false;
 
 const process = require('process');
 const fs      = require('fs');
@@ -26,6 +27,7 @@ const reports = require('../lib/reports');
 const utils   = require('../lib/utils');
 const loggers = require('../lib/loggers');
 var wallet, a$sleep, DistributiveWorker; /* populate in main() */
+var noStartWorker = false;
 
 const { exitCodes,
         logLevels }          = require('../lib/consts');
@@ -81,6 +83,7 @@ Options:
   -o, --output=mode                  Set the console mode: text|dashboard|none
   -l, --logger=type                  Add an additional logger: syslog, logfile
                                      (all platforms), event-log (win32)
+      --no-logger=type               Remove a logger
       --logfile=filename             Change filename, implies --logger=logfile
       --overwrite-logfile            Overwrite log files instead of appending
       --syslog=url|facility          Change syslog target config, implies
@@ -116,12 +119,6 @@ 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
@@ -154,8 +151,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)*:(management-path)'
+      + 'a:(allow-origin)*(zero-trust)*(no-global)*(kvin)*(json)*:(show)*'
+      + '(unmanaged)*:(management-hostname)*:(management-port)'
       + '*(no-masquerade)*:(force-worker-id)*:(lookup-worker-id)'
       + '*(no-claim-earnings)*:(register)*:(claim-earnings)*(reset)f:(pidfile)*(no-pidfile)v(verbose)';
 
@@ -263,6 +260,9 @@ function processCliOptsPhase1(argv, operatingMode)
       case 'l':
         loggingOptions.loggers.push(optarg);
         break;
+      case 'no-logger':
+        loggingOptions.loggers = loggingOptions.loggers.filter(logger => logger !== optarg);
+        break;
       case 'syslog':
         loggingOptions.loggers.push('syslog');
         loggingOptions.syslogUrl = utils.makeSyslogUrl(loggingOptions.syslogUrl, optarg);
@@ -317,6 +317,7 @@ function processCliOptsPhase1(argv, operatingMode)
         break;
       }
       /* options below this point are processed in both phase 1 and phase 2 */
+      case 'reset':
       case 'claim-earnings':
       case 'register':
         operatingMode.zeroTrust = true;
@@ -391,7 +392,6 @@ async function processCliOptsPhase2(argv, operatingMode, loggingOptions)
         break;
       case 'show':
         operatingMode.show = optarg;
-        operatingMode.consoleType = 'stdio';
         break;
       case 'startup-delay':
         await a$sleep(Number(optarg));
@@ -428,6 +428,7 @@ async function processCliOptsPhase2(argv, operatingMode, loggingOptions)
           console.log('Registration failure:', error.message);
           debug('dcp-worker:registration')(error);
         }
+        worker.config.unmanaged = true;
         await cleanupThenExit(exitCodes.normal);
         break;
       }
@@ -467,21 +468,19 @@ 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;
       default:
         throw new Error(`unhandled option '${option}'`);
-      /* hidden / undocumented options below */
+      /**** hidden / undocumented options below ****/
       case 'slice-report-interval':
         loggingOptions.sliceReportInterval = Number(optarg);
         break;
       case 'reset': /* can lose unclaimed earnings */
         DistributiveWorker.resetLocalStorage();
         console.info('reset complete');
+        worker.config.unmanaged = true;
         await cleanupThenExit(exitCodes.normal);
         break;
     }
@@ -555,6 +554,8 @@ async function main()
     loggingOptions,     /* options to tell us where logs go besides the console */
   } = processCliOptsPhase1(process.argv, operatingMode);
 
+  if (!operatingMode.zeroTrust)
+    loggingOptions.loggers.push('p2p');
   if (dcpConfig.worker.logging?.syslog)
     loggingOptions.loggers.push('syslog');
   if (dcpConfig.worker.logging?.logfile)
@@ -631,6 +632,7 @@ async function main()
 
   require('../lib/default-ui-events').hook(worker, loggingOptions);
   console.setWorker(worker);
+  require('../lib/p2p-shared').init(worker);
 
   if (worker.config.jobIds?.length > 0)
     console.info(` * Processing only ${utils.qty(worker.config.jobIds, 'job')} ` + worker.config.jobIds.join(', '));
@@ -643,29 +645,51 @@ async function main()
     console.info(` + Verbosity level: ${loggingOptions.verbose}`);
 
   /* Poll the evaluator forever until it accepts a connection */
-  let workerInfo = false;
+  let evaluatorInfo = false;
+  let p$throbSleep;
   console.throb(` . Waiting for dcp-evaluator on ${utils.shortLoc(sandboxConfig.location)} to start...`);
-  for (let i=0; workerInfo === false; i++)
+  function dieBeforeEvaluatorReady()
+  {
+    debug('dcp-worker:exit')('Trapped DistributiveWorker<stop> stop event before evaluator ready');
+    evaluatorInfo = null;
+    p$throbSleep?.intr();
+  }
+  worker.once('end', dieBeforeEvaluatorReady);
+
+  for (let i=0; evaluatorInfo === false; i++)
   {
     const ts = performance.now();
-    if ((workerInfo = await require('../lib/worker-info').getEvaluatorInformation(sandboxConfig)))
+    if ((evaluatorInfo = await require('../lib/worker-info').getEvaluatorInformation(sandboxConfig)))
       break;
     if (i === 0 && operatingMode.unmanaged !== true)
       utils.noteWorkerStart(worker);
     if (performance.now() - ts > 100)
       console.throb();
-    await a$sleep(Math.max(i + 1, 10) / 4);
+    p$throbSleep = a$sleep(Math.max(i + 1, 10) / 4);
+    await p$throbSleep;
     console.throb();
   }
+  worker.off('end', dieBeforeEvaluatorReady);
+  worker.once('end', () => {
+    debug('dcp-worker:exit')('Trapped DistributiveWorker<end>');
+    process.nextTick(() => cleanupThenExit(exitCodes.normal));
+    /* clean up at the end of tick so that other end event handlers can fire. */
+  });
 
-  if (Object.keys(workerInfo.worktimes).length > 0)
+  if (!evaluatorInfo)
+  {
+    console.warn(` . Could not contact dcp-evaluator on ${utils.shortLoc(sandboxConfig.location)} to start...`);
+    await cleanupThenExit(exitCodes.normal);
+  }
+
+  if (Object.keys(evaluatorInfo.worktimes).length > 0)
   {
     console.info(' . Worktimes Available:');
-    for (const wt of workerInfo.worktimes)
+    for (const wt of evaluatorInfo.worktimes)
       console.info(`    - ${wt.name}@${wt.version}`);
   }
 
-  if (!workerInfo.webgpu.enabled)
+  if (!evaluatorInfo.webgpu.enabled)
   {
     console.info(' . WebGPU not enabled');
     systemStateInfo.gpu = false;
@@ -679,9 +703,9 @@ async function main()
   else
   {
     console.info(' . WebGPU available. GPU info:');
-    for (let descriptor in workerInfo.webgpu.info)
-      console.info(`    - ${descriptor}: ${workerInfo.webgpu.info[descriptor]}`);
-    systemStateInfo.gpu = Object.assign({}, workerInfo.webgpu.info);
+    for (let descriptor in evaluatorInfo.webgpu.info)
+      console.info(`    - ${descriptor}: ${evaluatorInfo.webgpu.info[descriptor]}`);
+    systemStateInfo.gpu = Object.assign({}, evaluatorInfo.webgpu.info);
 
     /** @todo move bannedGPU support into DistributiveWorker class /wg jun 2025 */
     const bannedGPUs = Array.isArray(worker.config.bannedGPUs) ? worker.config.bannedGPUs : [ worker.config.bannedGPUs ];
@@ -689,7 +713,7 @@ async function main()
     {
       for (let descriptor in banEntry)
       {
-        if (banEntry[descriptor].test(workerInfo.webgpu.info[descriptor]))
+        if (banEntry[descriptor].test(evaluatorInfo.webgpu.info[descriptor]))
         {
           console.error(' * This GPU is not supported; disabling');
           worker.config.cores = { cpu: worker.config.cores.cpu, gpu: 0 };
@@ -709,7 +733,7 @@ async function main()
       }
       else
       {
-        worker.runInfo.gpuType = workerInfo.webgpu.info.device;
+        worker.runInfo.gpuType = evaluatorInfo.webgpu.info.device;
         worker.runInfo.gpuCores = 1;
       }
     }
@@ -738,21 +762,14 @@ async function main()
   /* 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);
+      throw error;
     });
   });
 
+  worker.ref();
+  worker.on('start', () => workerStarted = true);
   worker.on('error', function handleWorkerError(error) {
     if (worker.isWorkerError && worker.isWorkerError(error))
     {
@@ -777,6 +794,7 @@ async function main()
       console.error('Unrecoverable', error.code ? `${error.name} (${error.code})` : error.name,
                     '- shutting down the worker:',
                     process.env.DCP_SUPERVISOR_DEBUG_DISPLAY_MAX_INFO ? error : error.message);
+      debug('dcp-worker:error')(error);
     }
 
     /* Let the supervisor try to finish slices for up to three minutes after a single unrecoverable error. */
@@ -799,12 +817,13 @@ async function main()
       console.info(` ! not claming earnings in the amount of ${amount} ⊇ (can claim later)`);
   }
 
-  worker.on('stop',  () => { console.log(' - Worker is stopping') });
+  worker.on('stop',  () => { console.log(' . Worker is stopping') });
   worker.on('end',   () => { console.log(' * Worker has stopped') });
   worker.on('job',   job    => console.log(` . Job: ${job.name} ${job.id.slice(0,8)} ${job.description || ''} ${job.link || ''}`));
   worker.on('start', () => console.info(' * Ready.\n'));
 
-  await worker.start();
+  if (!noStartWorker)
+    await worker.start();
 } /* main() */
 
 /**
@@ -843,10 +862,6 @@ 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_'))
@@ -884,6 +899,8 @@ async function handleUnhandled(error)
  */
 async function cleanupThenExit(exitCode)
 {
+  const pr$end = Promise.withResolvers();
+
   debug('dcp-worker:exit')('cleanup and exit, code', exitCode);
   if (process.exitCode === exitCodes.lostRef || process.exitCode === exitCodes.normal)
     process.exitCode = exitCode;
@@ -894,22 +911,33 @@ async function cleanupThenExit(exitCode)
     debug('dcp-worker:exit')('exit race, bailing on cleanup for exit code', exitCode);
     return;
   }
+  /* Final event loop reference; keeps the process alive while the loggers unhook */
+  setTimeout(() => {
+    debug('dcp-worker:exit')('cleanup timeout expired');
+    console.warn(' *** cleanup timeout expired ***');
+    process.exit();
+  }, 10 * 1e3).ref();
 
-  if (worker)
+  if (!worker || !workerStarted || worker.inspect.stopped)
+  {
+    debug('dcp-worker:exit')('cleanup will not wait for DistributiveWorker<end> event');
+    pr$end.resolve();
+  }
+  else
+  {
+    debug('dcp-worker:exit')('cleanup will wait for DistributiveWorker<end> event');
+    worker.once('end',   pr$end.resolve);
+    worker.once('error', pr$end.reject);
     worker.stop(true); /* toggle internal worker state so it won't surprise us by starting sandboxes */
+  }
 
+  console.info(' ! begin shutdown, exit code =', exitCode);
   const p$workerShutdownTasks = Promise.all([
+    require('../lib/p2p-shared').shutdown(),
     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');
@@ -924,6 +952,8 @@ async function cleanupThenExit(exitCode)
       debug('dcp-worker:exit')('closing console');
       console.close();
     }
+    debug('dcp-worker:exit')('waiting for DistributiveWorker<end> event');
+    await pr$end.promise;
     debug('dcp-worker:exit')('unhooking loggers');
     await loggers.unhook()
       .then(() => debug('dcp-worker:exit')('loggers unhooked'))
@@ -969,6 +999,7 @@ async function handleSigDeath(signalName, signal)
     });
   }
 
+  noStartWorker = true; /* sigint before worker.start should not start worker */
   const warning = signal
         ? `\ntrapped ${signalName}, signal ${signal}`
         : `\ntrapped ${signalName === 'SIGESC' ? '<esc>' : signalName}`;

package/lib/loggers.js

@@ -183,7 +183,7 @@ exports.hook = function loggers$$hook(console, options)
    */
   globalThis.console.throb = (...args) => {
     console.throb(...args);
-    multiplex('info', ...args);
+    multiplex('throb', ...args);
   };
 }
 

package/lib/p2p-shared.js

@@ -0,0 +1,314 @@
+/**
+ * @file       lib/p2p-shared.js
+ * @author     Wes Garland, wes@distributive.network
+ * @date       June 2026
+ *
+ * Common code for working with the p2p subsystem of the event router in the dcp-worker application.
+ * The worker uses its local identity for communication and listens on #worker-${workerId} for control
+ * messages. The only authorized sender for the control channel is channel is worker.owner. When an
+ * application wants to hear from a given worker, it must add worker.identity to the list of authorized
+ * senders on the channel it is listening on.
+ */
+'use strict';
+
+const p2p    = require('dcp/p2p');
+const debug  = require('debug');
+const assert = require('assert');
+const wallet = require('dcp/wallet');
+
+const { a$sleep } = require('dcp/utils');
+const { DcpURL }  = require('dcp/dcp-url');
+
+const version = '1.0.0';
+var worker;     /* singleton instance of DistributiveWorker - held even after stop */
+var workerId;   /* worker's opaque id - persisted in case stop() resets it */
+var owner;      /* address of worker owner */
+var running;    /* 'running' | 'will-pause' | false */
+
+const KVIN = new (require('dcp/internal/kvin').KVIN)();
+KVIN.userCtors[wallet.Address.name] = wallet.Address;
+KVIN.userCtors[DcpURL.name]         = URL;
+
+exports.disabled = false;
+exports.init = async function p2pShared$init(__worker)
+{
+  if (__worker.config.unmanaged)
+    return;
+  owner = await require('./utils').getOwner(__worker);
+  if (!owner) /* unregistered worker -- no remote control */
+    return;
+
+  worker = __worker;
+  workerId = worker.id;
+  worker.on('end', () => {
+    p2p.sendMessage(`worker-${workerId}-announce`, { announce: 'stopped', version }, owner);
+    running = false;
+  });
+  worker.on('stop', () => {
+    announce('stopping');
+    running = false;
+  });
+  worker.on('start', () => {
+    running = 'running';
+  });
+  /* "make" a connection to the event router whenever possible by copying it from the worker. */
+  const __erConnectionFactory = p2p.erConnectionFactory;
+  /* Note: disabled July 2026 due to fundamental lifecycle differences between the supervisor's
+   *       protocol manager and our need to manage/log before and after the worker has stopped. /wg
+   */
+  if (false)
+    p2p.erConnectionFactory = () => worker?.getConnection('eventRouter') || __erConnectionFactory();
+
+  /* Listen for control mesages on #worker-ID, and send an unsolicited notification, 'boot', on
+   * #worker-ID-announce so that connected entities (eg portal) will notice that the worker has booted
+   * and will, for example, know to re-send commands like "log on".
+   */
+  p2p.listen([ owner ], `worker-${workerId}`, handleControlMessage);
+  p2p.on('listening', ev => {
+    announce('hello');
+  });
+}
+
+/**
+ * Start the p2p shutdown sequence. No further p2p should take place after the returned promise resolves.
+ */
+exports.shutdown = async function shutdown()
+{
+  if (workerId && owner && !exports.disabled)
+    announce('shutdown');
+  debug('dcp-worker:p2p')('cleanup for exit');
+  await p2p.cleanupForExit();
+}
+
+function announce(announcement, details)
+{
+  debug('dcp-worker:p2p')('sending anouncement', announcement);
+  if (!workerId)
+    throw new Error(`missing worker id for ${announcement} announcement`);
+  if (announcement === 'error')
+  {
+    assert(details instanceof Error);
+    const enumerableDetails = {};
+    Object.getOwnPropertyNames(details).forEach(prop => enumerableDetails[prop] = details[prop]);
+    details = enumerableDetails;
+  }
+
+  if (!exports.disabled)
+    p2p.sendMessage(`worker-${workerId}-announce`, { announce: announcement, version }, owner);
+}
+
+function enqRespond(message, details)
+{
+  assert(message.cmd === 'enq');
+  if (exports.disabled)
+    return;
+  if (!workerId)
+    throw new Error(`missing worker id for ${message.enq} enquiry response`);
+  if (message.detailsSerializer === 'kvin')
+    details = KVIN.marshal(details);
+  p2p.sendMessage(`worker-${workerId}-enq`, { enq: message.enq, detailsSerializer: message.detailsSerializer, details, version }, owner);
+}
+
+function handleEnquireMessage(message, channel, sender, originator)
+{
+  debug('dcp-worker:p2p')('sending enquiry info for', message.enq);
+  assert(message.cmd === 'enq');
+
+  switch(message.enq)
+  {
+    default:
+      console.error(`Invalid enquire message ${message.enq} from ${originator.party}:`, message);
+      break;
+    case 'runinfo':
+      enqRespond(message, worker.runInfo);
+      break;
+    case 'ping':
+      enqRespond(message, 'pong');
+      break;
+    case 'running-config':
+      enqRespond(message, makeRunningConfig(false, message.detailsSerializer !== 'kvin'));
+      break;
+    case 'explain-config':
+      enqRespond(message, { confSources: worker.confSources });
+      break;
+  }
+}
+
+/**
+ * Pause the worker. If it takes more than one second to quiesce the worker, log output is printed which estimates the time to quiescence.
+ * @returns {Promise}    a promise that resolves when the worker is quiescent
+ */
+function pauseWorker()
+{
+  let paused = false;
+  if (!running)
+  {
+    console.info(' . Will pause worker on start');
+    worker.once('start', pauseWorker);
+    running = 'will-pause';
+  }
+  if (running !== 'running')
+    return;
+
+  console.info(' . Pausing worker');
+  announce('paused');
+  const p$pause = worker.pause();
+  p$pause.then(why => {
+    if (why === 'quiescent')
+    {
+      paused = true;
+      console.info(' - Pause: worker quiescent');
+    }
+  });
+  a$sleep(paused ? 0 : 1).then(() => {
+    var remainingMs = null;
+    var duration = '';
+    const sandboxes = worker.inspect.workingSandboxes;
+    if (!worker.inspect.paused)
+      return;
+    for (let sandbox of sandboxes)
+      if (sandbox.remainingMs > remainingMs || remainingMs === null)
+        remainingMs = sandbox.remainingMs;
+    remainingMs = Number(remainingMs);
+    if (sandboxes.length)
+    {
+      duration = isNaN(remainingMs)
+        ? ', unknown duration to quiescence'
+        : ', estimated duration to quiescence: ' + (Number(remainingMs / 1000).toFixed(1) + 's');
+    }
+    console.info(` - Pause: ${sandboxes.length} sandboxes running` + duration);
+  });
+
+  return p$pause;
+}
+
+/**
+ * Handle a control message, eg from the portal.  Control messages are sent on channel worker-ID and
+ * tell the worker what to do, eg enable logs, reboot, change configuration, etc.  These are always
+ * trusted, because the p2p.listen operation restricts communication on this channel to the registered
+ * owner.
+ */
+function handleControlMessage(message, channel, sender, originator)
+{
+  if (!worker || worker.config.unmanaged || exports.disabled)
+    return;
+
+  debug('dcp-worker:p2p')(`p2p party ${sender} sent ${message.cmd} control message`, message);
+
+  switch (message.cmd)
+  {
+    default:
+      console.error(`p2p party ${sender} sent unknown command '${message.cmd}'`);
+      break;
+    case 'bonjour':
+      announce('hello');
+      break;
+    case 'refresh-state':
+      if (running === 'will-pause')
+        announce('will-pause');
+      else if (worker.inspect.paused)
+        announce('paused');
+      if (worker.inspect.stopping)
+        announce('stopping');
+      if (worker.inspect.stopped)
+        announce('stopped');
+      break;
+    case 'pause':
+      pauseWorker();
+      break;
+    case 'unpause':
+      worker.unpause();
+      announce('unpaused');
+      console.info(' . Unpausing worker');
+      break;
+    case 'stop':
+      worker.stop(message.arguments?.[0]); /* announcement comes from worker<stop> */
+      break;
+    case 'halt':
+      throw new Error(`halt (p2p ${message.sender})`);
+    case 'set-cores':
+      Object.assign(worker.config.cores, message.arguments[0]);
+      worker.dropSandboxes();
+      console.info(' . Set cores:',  worker.config.cores);
+      break;
+    case 'set-max-sandboxes':
+      worker.config.maxSandboxes = Number(message.arguments[0]);
+      console.info(' . Set max sandboxes:',  worker.config.maxSandboxes);
+      break;
+    case 'update-runinfo':
+      worker.updateRunInfo();
+      break;
+    case 'register':
+    {
+      const [ s$key, label ] = message.arguments;
+      const key = new wallet.PrivateKey(s$key);
+      console.warn(` * Re-registering worker with key '${label}' (${key})`);
+      const errorReporter = function p2p$$registrationErrorReporter(errorMessage) {
+        const error = new Error(errorMessage);
+        return error;
+      };
+      worker.config.cores.cpu = 0;
+      worker.config.cores.gpu = 0;
+      worker.dropSandboxes().then(async () => {
+        const result = await require('./utils').registerWorker(worker, key, undefined, errorReporter);
+        if (result instanceof(Error))
+        {
+          console.error(result.message);
+          announce('error', result);
+        }
+        else
+        {
+          console.log(' . Registration result:', result?.status);
+          announce('registered', result);
+        }
+      }).finally(() => worker.stop(true));
+      break;
+    }
+    case 'enq':
+      handleEnquireMessage(message, channel, sender, originator);
+      break;
+    case 'log':
+      require('./worker-loggers/p2p').handleLogControlMessage(message, channel, sender, originator);
+      break;
+  }
+}
+
+/**
+ * Make a copy of the running config.
+ * @param {boolean|undefined}    jsonCompat - when true, neuter the output so that it can be serialized with JSON
+ * @param {boolean|undefined}    sanitize   - when true, remove credentials
+ * @returns {Object}
+ */
+function makeRunningConfig(sanitize, jsonCompat)
+{
+  const schedulerUrl = new URL(dcpConfig.scheduler.location.href);
+  var config = Object.assign({}, worker.config);
+  config.allowOrigins = {};
+  delete config.__allowOriginsCurrentScheduler;
+
+  /* resolve the schedulerUrl symbols in the allow origins to a real URL */
+  for (let allowOriginListName in worker.config.allowOrigins)
+  {
+    const allowOriginList = worker.config.allowOrigins[allowOriginListName].slice();
+    config.allowOrigins[allowOriginListName] = allowOriginList;
+    for (let i=0; i < allowOriginList.length; i++)
+    {
+      if (allowOriginList[i] === worker.config.__allowOriginsCurrentScheduler)
+        allowOriginList[i] = schedulerUrl;
+    }
+  }
+
+  if (sanitize)
+  {
+    if (Array.isArray(config.computeGroups))
+      config.computeGroups = config.computeGroups.slice();
+    else
+      config.computeGroups = Object.assign({}, config.computeGroups);
+    for (let computeGroupKey in config.computeGroups)
+      config.computeGroups[computeGroupKey] = { joinKey: config.computeGroups[computeGroupKey].joinKey };
+  }
+
+  if (jsonCompat)
+    config = JSON.parse(JSON.stringify(config));
+  return config;
+}

package/lib/pidfile.js

@@ -80,8 +80,8 @@ exports.write = function pidfile$$write(filename)
     }
     catch (error)
     {
-      if (fd)
-        console.warn(`Warning: Could not remove pidfile at ${filename} (${error.code})`);
+      if (fd && error.code !== 'ENOENT')
+        console.warn(`Warning: Could not remove pidfile ${filename} (${error.code})`);
     }
   }
 }

package/lib/utils.js

@@ -171,7 +171,14 @@ function makeSyslogUrl(existingUrl, newArg)
 }
 
 /**
- * Retrieve the registered owner's address from the database
+ * Retrieve the registered owner's address from the database. It is assumed that the ownership will
+ * never change while the program is running, so the database lookup is cached for use by subsequent
+ * calls.
+ *
+ * @returns {Promise} a promise which resolves to
+ *             undefined => worker is running in unmanaged mode
+ *             false     => worker is not registered
+ *             Address   => address of the registered owner
  */
 async function getOwner(worker)
 {
@@ -179,14 +186,20 @@ async function getOwner(worker)
 
   if (worker.config.unmanaged)
     return undefined;
-  const db = await DistributiveWorker.jnuConnect();
-  const cursor = await db.select({
-    table: 'w$worker', prototype: {
-      opaqueId: worker.id,
-    }
-  });
-  const row = await cursor.getFirst();
-  return row?.owner;
+
+  if (getOwner.cache === undefined)
+  {
+    const db = await DistributiveWorker.jnuConnect();
+    const cursor = await db.select({
+      table: 'w$worker', prototype: {
+        opaqueId: worker.id,
+      }
+    });
+    const row = await cursor.getFirst();
+    getOwner.cache = row?.owner || false;
+  }
+
+  return getOwner.cache;
 }
 
 /**
@@ -196,19 +209,26 @@ async function getOwner(worker)
  * @param {string}            rkey             the registration key
  * @param {string|undefined}  label            optional value for worker.label
  * @param {function}          errorReporter    function used to report user errors; accepts string
- * @returns string if successful, instanceof Error if there was an error on the server. In either case,
- *          this is the return value from DistributiveWorker::register.
+ *
+ * @returns {any} the string 'registered' indicates a successful registration. An instance of Error is
+ *                returned when there is an error at the I/O layer; this is the raw return value of 
+ *                DistributiveWorker::register, which actually comes from submitSignedPost. In the case
+ *                when I/O is okay but the worker is not registered, and in the case where there is a
+ *                problem with the registration data itself, this function will pass a string into the
+ *                errorReporter function and return that function's return value.
  */
 async function registerWorker(worker, rkey, label, errorReporter)
 {
   const wallet = require('dcp/wallet');
   if (!wallet.isPrivateKey(rkey))
     return errorReporter('invalid registration key');
+  if (!(rkey instanceof wallet.PrivateKey))
+    rkey = new wallet.PrivateKey(rkey);
 
   if (label)
-    debug('dcp-worker:registration')('registering worker with key', rkey.slice(0,8), 'and label', label);
+    debug('dcp-worker:registration')('registering worker with key', rkey.toShortString(), 'and label', label);
   else
-    debug('dcp-worker:registration')('registering worker with key', rkey.slice(0,8));
+    debug('dcp-worker:registration')('registering worker with key', rkey.toShortString());
 
   const reg = await worker.register(rkey, label);
   if (!(reg instanceof Error))

package/lib/web-iface.js

@@ -35,17 +35,8 @@ const bootDate = new Date();
 var worker;
 var totalEarnings = 0;
 
-/** 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,
-};
+/** Configuration for the server, must be mutated before a$init */
+exports.config = { hostname: 'localhost', port: 9080 };
 
 /**
  * Web server initialization.
@@ -61,17 +52,12 @@ exports.a$init = function init(__worker)
   try
   {
     worker = __worker;
-    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}`);
+    console.info(` . Starting management service on ${exports.config.hostname}:${exports.config.port}`);
     const target = new protocol.Target(
       ['socketio'],
       {
         identity: identity.get(),
-        listen: exports.config.path ?
-                    new URL(`unix://${exports.config.path}`)
-                  : new URL(`http://${exports.config.hostname}:${exports.config.port}/dcp/`),
+        listen: new URL(`http://${exports.config.hostname}:${exports.config.port}/dcp/`),
       },
       listeningHandler,
       { socketio: { module: require('socket.io') } },
@@ -227,7 +213,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-loggers/event-log.js

@@ -39,6 +39,9 @@ exports.open = function eventLog$$open(options)
  */
 exports.at = function eventLog$$at(level, ...items)
 {
+ if (level === 'throb')
+    level = 'info';
+
   // Use the string log-level to look up the severity number:
   let severity = {
     [logLevels.error]:  'error',

package/lib/worker-loggers/logfile.js

@@ -88,6 +88,8 @@ function createLogFile(options, overwrite)
 function logToFile(level, ...items)
 {
   const logPrefix = `${(new Date()).toISOString()} ${level} `;
+  if (level === 'throb')
+    level = 'info';
 
   try
   {

package/lib/worker-loggers/p2p.js

@@ -0,0 +1,197 @@
+/**
+ * @file       worker-loggers/p2p.js
+ * @author     Wes Garland, wes@distributive.network
+ * @date       June 2026
+ *
+ * This logger module emits log lines to a remote listener via the p2p subsystem of the event router.
+ * The worker uses its local identity for communication, listens on #worker-${workerId} for control
+ * messages, and sends logs on the #worker-${workerId}-log channel. The only authorized sender for
+ * the control channel is channel is worker.owner. When an application requests logs, it must add
+ * worker.identity to the list of authorized senders.
+ */
+'use strict';
+
+const os        = require('os');
+const process   = require('process');
+const debug     = require('debug');
+const p2p       = require('dcp/p2p');
+const p2pShared = require('../p2p-shared');
+
+const { RingBuffer } = require('dcp/utils');
+const logDests = new Map();  /* party => set of instances */
+var logIdSeq = 0;
+var logHistory = new RingBuffer(50);
+var disabled = true;
+
+/* Static data in log emission */
+const hostname    = os.hostname();
+const pid         = process.pid;
+const processName = require('path').basename(process.mainModule.filename);
+
+/**
+ *  Initialize the p2p worker logger.
+ *
+ *  @param  {object} options          Options for logger behaviour
+ */
+exports.open = function p2pLogs$$open(options)
+{
+  disabled = false;
+  debug('dcp-worker:logger.p2p')('initializing p2p logger subsystem');
+  p2p.on('mdr', handleMessageDeliveryReport);
+}
+
+/**
+ * Tear down the p2p logging subsystem; used by loggers::unhook(). Invoking this function makes
+ * it impossible to send any more messages to syslog, but we try to wait until all messages have been
+ * sent before resolving the close promise. This dramatically increases the probability that uncaught
+ * exceptions that crash the worker are actually logged some place other than the system console.
+ */
+exports.close = async function p2pLog$$a$close()
+{
+  debug('dcp-worker:logger.p2p')('Flushing p2p log buffers');
+  const stillMore = await p2p.flushPendingNotifications();
+  if (stillMore)
+    await p2p.flushPendingNotifications();
+  debug('dcp-worker:logger.p2p')('Flushed p2p log buffers, cleared log dests');
+  disabled = true;
+  logDests.clear();
+}
+
+/**
+ *  Emit a message via the p2p subsystem
+ *
+ *  @param  {string}    level Event level (info, debug, log, warning, error)
+ *  @param  {...any[]}  argv  Items to log
+ */
+exports.at = function loggers$$p2p$at(level, ...args)
+{
+  if (p2pShared.disabled || disabled)
+    return;
+
+  const date = new Date();
+  const logIdBase = `${Number(date)}-${hostname}-${processName}-${pid}`;
+  const logMessages = args.join(' ').split('\n');
+  for (let logMessage of logMessages)
+  {
+    if (!logMessage && level !== 'throb') /* skip blank lines */
+      continue;
+    const seq = (++logIdSeq).toString(36).padStart(3,0);
+    const logId = logIdBase + `-${seq}`; /* logId must be generated in lexical order including across processes */
+    if (logMessage || logHistory.head()?.logMessage) /* avoid storing excess throbber advances in history */
+      logHistory.push({ logId, date, level, logMessage });
+
+    for (let [ destination, instances ] of logDests)
+    {
+      debug('dcp-worker:logger.p2p.verbose')(`sending log message ${logId} to ${destination} (${instances.size} instances)`);
+      if (instances.size > 0)
+        p2p.sendMessage(instances.outputChannel, {
+          logId,
+          processName,
+          pid,
+          date,
+          hostname,
+          level,
+          logMessage,
+        }, destination, { mdr: 'fail' });
+    }
+  }
+}
+
+/**
+ * @param {object}   message     { cmd: 'log', arguments: [] }
+ *                               arguments[0]:
+ *                                 'off'     - disable log transmission
+ *                                 'on'      - enable log transmission
+ *                                 'history' - (re)transmit whatever is in the history buffer
+ *                                 'on-history' - enable log transmission and send the history buffer,
+ *                                                accepts an optional argument, lastLogId. If used, this
+ *                                                avoids emitting history <= lastLogId.
+ *                              arguments[1]: optional, name of the output channel, default is worker-ID-log
+ * @param {string}  channel     worker-ID (the command channel)
+ * @param {string}  sender      who sent the message (auth'd)
+ * @param {string}  originator  who sent the message (pre-auth, includes instance)
+ *
+ */
+exports.handleLogControlMessage = async function loggers$$p2p$handleLogControlMessage(message, channel, sender, originator)
+{
+  const mode = message.arguments?.[0];
+  if (message.cmd !== 'log')
+    return;
+  const outputChannel = `${channel}-log`;
+
+  switch(mode)
+  {
+    default:
+      console.error(`p2p party ${sender} sent unknown log mode '${mode}'`);
+      return;
+    case 'off':
+      await p2p.flushPendingNotifications();
+      if (logDests.has(sender))
+      {
+        const instances = logDests.get(sender);
+        instances.delete(originator.instance);
+        if (instances.size === 0)
+          logDests.delete(sender);
+      }
+      debug('dcp-worker:logger.p2p')(`p2p remote logging disabled for ${sender} (${originator.party} ${originator.instance})`);
+      break;
+    case 'on': case 'on-history':
+    {
+      debug('dcp-worker:logger.p2p')(`p2p remote logging enabled for ${sender} (${originator.party} ${originator.instance})`);
+      if (!logDests.has(sender))
+        logDests.set(sender, new Set());
+      const instances = logDests.get(sender);
+      instances.add(originator.instance);
+      instances.outputChannel = outputChannel; /* assumption: outputChannel same for all instances */
+      if (mode !== 'on-history')
+        break;
+    }
+    /* fallthrough */
+    case 'history':
+    {
+      /* History replays a few recent log messages, potentially from before remote logging was enabled.
+       * Log receivers are responsible for ignoring logs they have already processed. This can be
+       * accomplished by either tracking logId, or observing the order of logIds, which are guaranteed
+       * to be sortable in emission order. Note that it is possible to receive notifications out of
+       * order...
+       */
+      const lastLogId = message.arguments[1];
+      debug('dcp-worker:logger.p2p')('p2p history request, history length=', logHistory.length);
+      debug('dcp-worker:logger.p2p')('p2p history lastLogId=', lastLogId);
+      const conn = p2p.getErConnection();
+      /* Increase dcp batch size to accomodate the history and related announcements */
+      if (conn.options.maxMessagesPerBatch < (logHistory.length + 5))
+        conn.options.maxMessagesPerBatch = (logHistory.length + 5);
+      logHistory.forEach(entry => {
+        if (!lastLogId || entry.logId > lastLogId)
+        {
+          debug('dcp-worker:logger.p2p.verbose')(`sending historic log message ${entry.logId} to ${sender}`);
+          p2p.sendMessage(outputChannel, Object.assign({ processName, pid, hostname }, entry),
+                          sender, { mdr: 'fail' });
+        }
+        else
+        {
+          debug('dcp-worker:logger.p2p.verbose')(`${sender} already has historic log message ${entry.logId}`);
+        }
+      });
+    }
+  }
+}
+
+function handleMessageDeliveryReport(mdr)
+{
+  debug('dcp-worker:logger.p2p.mdr')('received MDR', mdr);
+  if (mdr.disposition !== 'fail' || mdr.details.failure !== 'nochan')
+    return;
+
+  /* nochan failure => nobody is listening for our messages */
+  for (let [ _destination, instances ] of logDests)
+  {
+    debug('dcp-worker:logger.p2p.mdr')('output channel is', instances.outputChannel);
+    if (instances.outputChannel === mdr.details.channel)
+    {
+      debug('dcp-worker:logger.p2p.mdr')('clearing instance');
+      instances.clear();
+    }
+  }
+}

package/lib/worker-loggers/syslog.js

@@ -145,6 +145,8 @@ exports.close = function a$syslog$$Close()
 function syslogAt(level, ...argv)
 {
   const logPrefix = `${processName}[${process.pid}]: `;
+  if (level === 'throb')
+    level = 'info';
 
   // Use the string log-level to look up the severity number:
   let severity = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcp-worker",
-  "version": "4.5.1",
+  "version": "4.5.2",
   "description": "Node.js Worker for Distributive Compute Platform",
   "main": "bin/dcp-worker",
   "keywords": [
@@ -39,7 +39,7 @@
     "blessed": "0.1.81",
     "blessed-contrib": "4.11.0",
     "chalk": "4.1.2",
-    "dcp-client": "^5.7.4",
+    "dcp-client": "^5.7.5",
     "kvin": "9.1.0",
     "mux-net": "github:wesgarland/mux-net#e7f81800db4a84ec880026596f7ee68549a6d0f5",
     "posix-getopt": "1.2.1",

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

@@ -1,103 +0,0 @@
-#! /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);