dcp-worker 3.3.19 → 4.0.1

package/README.md

@@ -32,7 +32,7 @@ This document was last updated Sep 12, 2024.
 | bin/dcp-worker             | Program which requests work from the scheduler and coordinates its evaluation in a secure environment called dcp-evaluator-v8
 | bin/dcp-evaluator-start    | Program which launches dcp-evaluator-v8
 | bin/dcp-evaluator-manager  | Program which which manages the launching of dcp-evaluator-v8; e.g. based on system load, terminal activity, screensaver activity, etc.
-| etc/dcp-worker-config.js   | Default configuration for dcp-worker
+| examples/dcp-config.js     | Default configuration for dcp-worker, copy to /etc/dcp/overrides/dcp-worker to override sections
 
 ### Related Packages
 - dcp-evaluator-v8, our isolated JS/WASM/WebGPU evaluation environment, ships separately. Installing dcp-worker with your system's package manager will automatically install dcp-evaluator-v8 as a dependency.

package/bin/dcp-evaluator-manager

@@ -527,6 +527,12 @@ async function main()
   const parser = new getopt.BasicParser('h(help)P:(prefix)d:(disable-monitor)l:(max-load)r:(rate)Li:ap:s:(signal)T:(loadavg-type)f:(pidfile)', process.argv);
   var option;
 
+  if (dcpConfig.evaluator.listen)
+  {
+    daemonConfig.net.hostname = dcpConfig.evaluator.listen.hostname;
+    daemonConfig.net.port = dcpConfig.evaluator.listen.port;
+  }
+
   while ((option = parser.getopt()) !== undefined)
   {
     switch (option.option)
@@ -655,9 +661,8 @@ async function main()
 
 /* Initialize dcp-client to use only local resources before launching the main function */
 require('dcp-client').init({
-  progName: 'dcp-worker',
+  programName: 'dcp-worker',
   parseArgv: false,
-  configName: process.env.DCP_CONFIG || '../etc/dcp-worker-config', /* => .js or .json */
   dcpConfig: {
     scheduler: { configLocation: false },
     bundle:    { location: false },

package/bin/dcp-evaluator-start

@@ -274,8 +274,7 @@ function main() {
 
 /* Initialize dcp-client to use only local resources before launching the main function */
 require('dcp-client').init({
-  progName: 'dcp-worker',
-  configName: process.env.DCP_CONFIG || '../etc/dcp-worker-config',
+  programName: 'dcp-worker',
   dcpConfig: {
     scheduler: { configLocation: false },
     bundle:    { location: false },

package/bin/dcp-task-probe

@@ -276,7 +276,7 @@ function cpuCommaGpu(str)
  *  - dumpConfig
  *  - workerId
  */
-async function processOptions()
+async function processOptions(workerConfig)
 {
   const opts = { verbose: 0 };
   const parser = new getopt.BasicParser('h(help)C(dumpConfig)S:(set)M:(merge)a:(allowedOrigins)'
@@ -319,35 +319,35 @@ async function processOptions()
         break;
 
       case 'a':
-        dcpConfig.worker.allowedOrigins.any.push(opthnd.optarg);
+        workerConfig.allowOrigins.any.push(opthnd.optarg);
         break;
 
       case 'c':
-        Object.assign(dcpConfig.worker.cores, cpuCommaGpu(opthnd.optarg));
+        Object.assign(workerConfig.cores, cpuCommaGpu(opthnd.optarg));
         break;
 
       case 'u':
-        Object.assign(dcpConfig.worker.utilization, cpuCommaGpu(opthnd.optarg));
+        Object.assign(workerConfig.utilization, cpuCommaGpu(opthnd.optarg));
         break;
 
       case 'm':
-        dcpConfig.worker.maxSandboxes = Number(opthnd.optarg);
+        workerConfig.maxSandboxes = Number(opthnd.optarg);
         break;
 
       case 'J':
-        dcpConfig.worker.jobAddresses = (dcpConfig.worker.jobAddresses || []).concat(opthnd.optarg);
+        workerConfig.jobAddresses = (workerConfig.jobAddresses || []).concat(opthnd.optarg);
         break;
 
       case 'j': /** @todo integrate with upcoming scheduler changes to opaqueId /wg dec 2024 */
-        dcpConfig.worker.jobs = (dcpConfig.worker.jobs || []).concat(opthnd.optarg);
+        workerConfig.jobs = (workerConfig.jobs || []).concat(opthnd.optarg);
         break;
 
       case 'G':
-        dcpConfig.worker.leavePublicGroup = true;
+        workerConfig.leavePublicGroup = true;
         break;
 
       case 'H':
-        dcpConfig.evaluator.location.hostname = opthnd.ortarg;
+        dcpConfig.evaluator.location.hostname = opthnd.optarg;
         break;
 
       case 'p':
@@ -360,9 +360,9 @@ async function processOptions()
         const joinHash = joinSecret;
 
         if (isHash(joinHash))
-          dcpConfig.worker.computeGroups.push({ joinKey, joinHash });
+          workerConfig.computeGroups.push({ joinKey, joinHash });
         else
-          dcpConfig.worker.computeGroups.push({ joinKey, joinSecret });
+          workerConfig.computeGroups.push({ joinKey, joinSecret });
         break;
       }
 
@@ -380,7 +380,7 @@ async function processOptions()
         {
           /* merge mode: objects are merged at the property level, except for arrays, which are concatenated */
           if (confNode === dcpConfig.worker && (prop === 'worktimes' || prop === 'capabilities'))
-            await probeEvaluator(); /* ensure we have something to merge into */
+            await probeEvaluator(dcpConfig.worker); /* ensure we have something to merge into */
           switch(typeof confNode[prop])
           {
             case 'object':
@@ -408,8 +408,8 @@ async function processOptions()
       {
         const wallet = require('dcp/wallet');
         const snapshot = readWorkerSnapshot();
-        dcpConfig.worker = snapshot.workerConfig;
-        dcpConfig.worker.paymentAddress = new wallet.Address(dcpConfig.worker.paymentAddress);
+        workerConfig = snapshot.workerConfig;
+        workerConfig.paymentAddress = new wallet.Address(workerConfig.paymentAddress);
       }
     }
   }
@@ -422,23 +422,35 @@ async function processOptions()
  * as late as possible during the configuration phase so that the user has the option to specify these
  * completely on a system with no evaluator.
  */
-async function probeEvaluator()
+async function probeEvaluator(workerConfig)
 {
+  var evaluatorInfo;
   if (probeEvaluator.probed)
     return;
   probeEvaluator.probed = true;
-  const probeTimer = setTimeout(() => panic('unable to probe evaluator'), 66610e3); /* Need to keep main from exiting */
 
-  if (!dcpConfig.worker.capabilities || !dcpConfig.worker.worktimes)
+  if (!workerConfig.capabilities || !workerConfig.worktimes)
   {
+    const probeTimer = setTimeout(() => panic('unable to probe evaluator'), 66610e3); /* Need to keep main from exiting */
     const { workerFactory } = require('dcp-client/lib/standaloneWorker');
     debug('dcp-task-probe:evaluator')('Probing evaluator at', dcpConfig.evaluator.location);
-    const evaluatorInfo = await require('dcp/worker').probeEvaluator(workerFactory(dcpConfig.evaluator.location));
-    dcpConfig.worker.capabilities ||= evaluatorInfo.capabilities;
-    dcpConfig.worker.worktimes    ||= evaluatorInfo.worktimes;
-  }
+    try
+    {
+      evaluatorInfo = await require('dcp/worker').probeEvaluator(workerFactory(dcpConfig.evaluator.location));
+    }
+    catch(error)
+    {
+      console.warn(`Warning: unable to probe evaluator at ${dcpConfig.evaluator.location} (${error.message + (error.code ? ' ' + error.code : '')})`);
+      return;
+    }
+    finally
+    {
+      clearTimeout(probeTimer);
+    }
 
-  clearTimeout(probeTimer);
+    workerConfig.capabilities ||= evaluatorInfo.capabilities;
+    workerConfig.worktimes    ||= evaluatorInfo.worktimes;
+  }
 }
 
 /**
@@ -470,12 +482,11 @@ function readWorkerSnapshot()
  */
 function makeComputeGroupsRequest(tdConn, dummyWorker)
 {
-  const computeGroups = structuredClone(dcpConfig.worker.computeGroups); /* supervisor code sadly mutates this /wg dec 2024 */
-  const options = Object.assign({}, dcpConfig.worker, { computeGroups });
+  const options = Object.assign({}, dummyWorker.config);
   const taskDistributor = { connection: tdConn };
 
   dummyWorker.badSupervisorBackdoor.dcp4.generateWorkerComputeGroups.apply({ taskDistributor, options });
-  if (!dcpConfig.worker.leavePublicGroup && !dcpConfig.worker.leaveGlobalGroup)
+  if (!dummyWorker.config.leavePublicGroup && !dummyWorker.config.leaveGlobalGroup)
     options.computeGroups.unshift({ joinKey: 'public' });
   return options.computeGroups;
 }
@@ -485,17 +496,14 @@ function makeComputeGroupsRequest(tdConn, dummyWorker)
  * Request a task from the task distributor
  *
  * @todo unify with supervisor /wg dec 2024
- * @param {Keystore} identity   identity of the requesting entity
  * @param {Object}   opts       command-line options to dcp-task-probe
  *                    .replay     truey to use request from worker snapshot instead of a generated request
  *                    .workerId   workerId for request
  */
-async function requestTask(identity, opts)
+async function requestTask(dummyWorker, opts)
 {
   const protocol = require('dcp/protocol');
-  const worker = require('dcp/worker');
   const tdConn = new protocol.Connection(dcpConfig.scheduler.services.taskDistributor);
-  const dummyWorker = new worker.Worker(identity, dcpConfig.worker); /* side effect: initializes dcpConfig.worker */
   var request;
 
   if (opts.replay)
@@ -504,29 +512,29 @@ async function requestTask(identity, opts)
     request = {
       supervisor: dummyWorker.supervisorVersion,
       targetLoad: {
-        cpu: Math.min(dcpConfig.worker.maxSandboxes, dcpConfig.worker.cores.cpu * dcpConfig.worker.utilization.cpu) /* cpuCoreSpace */,
-        gpu: Math.min(dcpConfig.worker.maxSandboxes, dcpConfig.worker.cores.gpu * dcpConfig.worker.utilization.gpu) /* this.maxWorkingGPUs */,
-        longSlices: dcpConfig.worker.maxSandboxes /* Math.floor(cpuCoreSpace) */,
+        cpu: Math.min(dummyWorker.config.maxSandboxes, dummyWorker.config.cores.cpu * dummyWorker.config.utilization.cpu) /* cpuCoreSpace */,
+        gpu: Math.min(dummyWorker.config.maxSandboxes, dummyWorker.config.cores.gpu * dummyWorker.config.utilization.gpu) /* this.maxWorkingGPUs */,
+        longSlices: dummyWorker.config.maxSandboxes /* Math.floor(cpuCoreSpace) */,
       },
       coreStats: { /** @todo why are we specifying these? /wg dec 2024 */
-        worker: dummyWorker.workerId,
+        worker: dummyWorker.id,
         lCores: require('os').cpus().length,
         pCores: require('physical-cpu-count'),
-        sandbox: dcpConfig.worker.maxSandboxes,
+        sandbox: dummyWorker.config.maxSandboxes,
       },
       jobQuanta:            [ 1 ]/* this.quanta.calculateJobQuanta() */,
-      capabilities:         dcpConfig.worker.capabilities,
-      paymentAddress:       dcpConfig.worker.paymentAddress,
-      jobAddresses:         dcpConfig.worker.jobAddresses || [],
+      capabilities:         dummyWorker.config.capabilities,
+      paymentAddress:       dummyWorker.config.paymentAddress,
+      jobAddresses:         dummyWorker.config.jobAddresses || [],
       workerComputeGroups:  makeComputeGroupsRequest(tdConn, dummyWorker),
-      minimumWage:          dcpConfig.worker.minimumWage,
+      minimumWage:          dummyWorker.config.minimumWage,
       soteriaJobs:          [],
       overdueSlices:        [],
       previouslyWorkedJobs: [], /* discrete jobs */
       rejectedJobs:         [],
       unresolvedJobs:       [],
       fetchState:           1, /* normal fetch */
-      worktimes:            dcpConfig.worker.worktimes,
+      worktimes:            dummyWorker.config.worktimes,
     };
 
   debug('dcp-task-probe:connect')('Connecting to task distributor at', tdConn.targetDescriptor.location.href);
@@ -542,7 +550,8 @@ async function requestTask(identity, opts)
   if (!response.success)
     panic('request failed:', response.payload);
 
-  return { response, workerId: request.coreStats?.worker };
+  debugger;
+  return { response, workerId: request.coreStats?.worker, workerConfig: dummyWorker.config };
 }
 
 async function returnTask(taskResponsePayload)
@@ -596,26 +605,35 @@ function fmtMs(ms)
 /** Main program entry point */
 async function main()
 {
-  const wallet   = require('dcp/wallet');
-  const identity = await wallet.getId();
-  const opts = await processOptions();
+  const wallet = require('dcp/wallet');
+  const identity = require('dcp/identity');
+
+  const initialWorkerConfig = {
+    allowOrigins: {
+      any: [],
+    }
+  };
+  const opts = await processOptions(initialWorkerConfig);
+  await identity.login('$login');
 
-  if (!dcpConfig.worker.paymentAddress)
-    dcpConfig.worker.paymentAddress = (await wallet.get()).address;
+  if (typeof initialWorkerConfig.paymentAddress === 'string')
+    initialWorkerConfig.paymentAddress = new wallet.Address(initialWorkerConfig.paymentAddress);
+  else if (!initialWorkerConfig.paymentAddress)
+    initialWorkerConfig.paymentAddress = (await wallet.get({ oAuth: false })).address;
 
   if (!opts.replay)
-    await probeEvaluator();
+    await probeEvaluator(initialWorkerConfig);
+  const dummyWorker = new (require('dcp/worker').DistributiveWorker)(initialWorkerConfig, function FakeSandboxConstructor(){});
 
   if (opts.dumpConfig)
   {
-    /* work around the cores getter/setter that is added by the worker */
-    const dump = Object.assign({}, dcpConfig.worker);
-    dump.cores = { cpu: dcpConfig.worker.cores.cpu, gpu: dcpConfig.worker.cores.gpu };
+    /* work around the cores getter/setter */
+    const dump = Object.assign({}, dummyWorker.config);
     console.log(dump);
     process.exit(0);
   }
 
-  const { workerId, response } = await requestTask(identity, opts);
+  const { workerId, response, workerConfig } = await requestTask(dummyWorker, opts);
   const task = response.payload?.body?.task;
   if (task)
     await returnTask(response.payload);
@@ -623,7 +641,10 @@ async function main()
   console.log('Task Distributor:    ', dcpConfig.scheduler.services.taskDistributor.location.href);
   console.log('Result Submitter:    ', dcpConfig.scheduler.services.resultSubmitter.location.href);
   console.log('Worker Id:           ', workerId);
-  console.log('DCP Address:         ', String(identity.address));
+  console.log('Max Sandboxes:       ', workerConfig.maxSandboxes);
+  console.log('Cores:               ', Object.assign({}, workerConfig.cores));
+  console.log('Utilization:         ', workerConfig.utilization);
+  console.log('DCP Address:         ', String(identity.get().address));
 
   if (!task)
   {
@@ -647,8 +668,8 @@ async function main()
               fmtMs(Object.keys(task).map(jobId => newJobs[jobId].metrics.sliceCPUTime).reduce((a, b) => a+b, 0)) + ',',
               fmtMs(Object.keys(task).map(jobId => newJobs[jobId].metrics.sliceGPUTime).reduce((a, b) => a+b, 0)));
   console.log('CPU,GPU Time/core:   ',
-              fmtMs(Object.keys(task).map(jobId => newJobs[jobId].metrics.sliceCPUTime).reduce((a, b) => a+b, 0) / dcpConfig.worker.cores.cpu) + ',',
-              fmtMs(Object.keys(task).map(jobId => newJobs[jobId].metrics.sliceGPUTime).reduce((a, b) => a+b, 0) / dcpConfig.worker.cores.gpu));
+              fmtMs(Object.keys(task).map(jobId => newJobs[jobId].metrics.sliceCPUTime).reduce((a, b) => a+b, 0) / workerConfig.cores.cpu) + ',',
+              fmtMs(Object.keys(task).map(jobId => newJobs[jobId].metrics.sliceGPUTime).reduce((a, b) => a+b, 0) / workerConfig.cores.gpu));
   console.log('Task Duration:       ', schedulerConfig.targetTaskDuration + 's');
   console.log('Compute Groups:      ', Object.keys(computeGroupJobs).length);
 
@@ -690,7 +711,6 @@ async function main()
 
 /* Initialize dcp-client to use only local resources before launching the main function */
 require('dcp-client').init({
-  progName: 'dcp-worker',
+  programName: 'dcp-worker',
   parseArgv: false,
-  configName: process.env.DCP_CONFIG || '../etc/dcp-worker-config', /* => .js or .json */
 }).then(main);

package/bin/dcp-worker

@@ -1,4 +1,5 @@
 #! /usr/bin/env node
+
 /**
  *  @file       dcp-worker.js
  *              Standalone NodeJS DCP Worker
@@ -18,14 +19,11 @@ var worker;
 const process = require('process');
 const fs      = require('fs');
 const path    = require('path');
-const crypto  = require('crypto');
-const chalk   = require('chalk');
 const telnetd = require('../lib/remote-console');
 
 const { slicesFetched, debugging, displayMaxDiagInfo } = require('../lib/utils');
-const { a$sleep } = require('dcp/utils');
+const { a$sleep, leafMergeInto } = require('dcp/utils');
 
-const configName = process.env.DCP_CONFIG || '../etc/dcp-worker-config';
 const EXIT_UNHANDLED = 5;
 const systemStateInfo = globalThis.systemStateInfo = {};
 
@@ -45,15 +43,7 @@ const replHelpers = {
   },
 };
 telnetd.init(replHelpers);
-
-/**
- * regexps of GPUs we cannot use. Properties match device descriptors. More regexps can be added via
- * dcpConfig.bannedGPUs.
- */
-const bannedGPUs =
-{
-  device: /llvmpipe/,
-}
+require('dcp-client').init().then(main).catch(handleUnhandled);
 
 /**
  * Output startup banner message. Currently a wrapper for console.log, future plans are to make it
@@ -66,12 +56,6 @@ function bannerLog()
 }
 bannerLog.cumulative = [];
 
-/* Initialize dcp-client with local config defaults and run the main function. DCP_CONFIG_COOKIE becomes dcpConfig.cookie.
- * And dcpConfig is defined as a side effect of initializing dcp-client.
- */
-process.env.DCP_CONFIG_COOKIE = (Math.random().toString(16)).slice(2) + '-' + process.pid + '-' + Date.now();
-require('dcp-client').init({ configName }).then(main).catch(handleUnhandled);
-
 function parseCliArgs()
 {
   var defaultPidFileName;
@@ -85,10 +69,6 @@ function parseCliArgs()
         describe: 'The address to deposit funds into, will use the default bank keystore if not provided.',
         type: 'string',
       },
-      defaultPaymentAddressToDCP: {
-        describe: 'If this option is set and no other payment address is provided, send payment for work completed to the DCP Community account',
-        type: 'boolean',
-      },
       cores: {
         alias: 'c',
         describe: 'Number of CPU and GPU cores to work with: the format is 7,1 (or just 7) for 7 CPU cores and 1 GPU',
@@ -185,7 +165,7 @@ function parseCliArgs()
 
       showConfig: {
         hide: false,
-        describe: 'Show merged configuration node (e.g., --showConfig worker)',
+        describe: 'Show worker config',
         type: 'string',
       },
 
@@ -256,20 +236,6 @@ function isHash(b) {
   return b && b.length === 68 && b.startsWith('eh1-');
 }
 
-/**
- * Add one or more configuration objects into a target via leaf-merging.
- */
-function addConfig(target, ...objs)
-{
-  const { leafMerge } = require('dcp/utils');
-  var tmp = target;
-
-  for (let obj of objs)
-    tmp = leafMerge(tmp, obj);
-
-  Object.assign(target, tmp);
-}
-
 /**
  * Replacement for process.exit() that tries to increase the probability
  * that remote log messages will make it out over the network.
@@ -289,17 +255,28 @@ function processExit()
  */
 async function main()
 {
-  const wallet = require('dcp/wallet');
-  const DCPWorker = require('dcp/worker').Worker;
+  const wallet   = require('dcp/wallet');
+  const identity = require('dcp/identity');
+  const { DistributiveWorker } = require('dcp/worker');
+  var   workerConfig = {};
   const cliArgs = parseCliArgs();
+  telnetd.setMainEval(function mainEval() { return eval(arguments[0]) }); // eslint-disable-line no-eval
+  require('../lib/startWorkerLogger').init(cliArgs); /* Start remote logger as early as possible */
+
+  /* Process any identity overrides and then establish our identity. */
+  identity.interactive = false;
+  if (cliArgs.identityKey || cliArgs.identityKeystore)
+    await identity.set(cliArgs.identityKey || cliArgs.identityKeystore);
+  await identity.login('$login');
+
+  /* Eagerly create a worker object and mutate its config property to reflect argv before starting it. */
   const sawOptions = {
     hostname: cliArgs.hostname,
     port:     cliArgs.port
   };
-
-  telnetd.setMainEval(function mainEval() { return eval(arguments[0]) }); // eslint-disable-line no-eval
-  require('../lib/startWorkerLogger').init(cliArgs); /* Start remote logger as early as possible */
-  verifyDefaultConfigIntegrity();                    /* Bail before TUI & as early as possible if bad conf */
+  if (typeof dcpConfig.worker.cleanupTimeout !== 'number')
+    dcpConfig.worker.cleanupTimeout = 60;
+  const SandboxConstructor = require('dcp-client/lib/standaloneWorker').workerFactory(sawOptions);
 
   process.on('SIGINT',  handleSigDeath);
   process.on('SIGTERM', handleSigDeath);
@@ -307,74 +284,26 @@ async function main()
   process.on('unhandledRejection', handleUnhandled);
   process.on('uncaughtException',  handleUnhandled);
 
-  const getOpts = {};
-  if (cliArgs.defaultPaymentAddressToDCP)
-    getOpts.oAuth = false;
-
-  let paymentAddress = false
-      || cliArgs.paymentAddress
-      || dcpConfig.worker.paymentAddress
-      || (await wallet.get(getOpts).catch(error => {
-          // if flag is set and no other address is provided, use the DCP Community Account,
-          // which is 0x079DAC0612C710ab4e975dAb7171C7e4beF78c5a at time of writing
-          if ((error.code === 'ENOENT') && cliArgs.defaultPaymentAddressToDCP)
-          {
-            console.warn('Warning: Defaulting payment to DCP Community Account');
-            return {address:'0x079DAC0612C710ab4e975dAb7171C7e4beF78c5a'};
-          }
-          throw error;
-          })).address;
-  if (typeof paymentAddress === 'string')
-    paymentAddress = new wallet.Address(paymentAddress);
+  if (cliArgs.paymentAddress)
+    workerConfig.paymentAddress = new wallet.Address(cliArgs.paymentAddress);
+  else if (typeof workerConfig.paymentAddress === 'string')
+    workerConfig.paymentAddress = new wallet.Address(workerConfig.paymentAddress);
+  else if (!workerConfig.paymentAddress)
+    workerConfig.paymentAddress = (await wallet.get({ oAuth: false })).address;
 
   if (cliArgs.pidFile)
     require('../lib/pidfile').write(cliArgs.pidFile);
 
-  /* Figure out the worker's identity and put that keystore in the wallet */
-  let identityKeystore = false;
-  if (cliArgs.identityKey)
-    identityKeystore = await new wallet.IdKeystore(cliArgs.identityKey, '');
-  else if (cliArgs.identityKeystore)
-    identityKeystore = await new wallet.IdKeystore(JSON.parse(cliArgs.identityKeystore), '');
-  else
-    identityKeystore = await wallet.getId();
-  await wallet.addId(identityKeystore);
-
-  /* Build the worker options, which are largely given by dcpConfig.worker. We use a reference for
-   * dcpConfig.worker rather than copying it, so that runtime modifications to the worker configuration
-   * in memory take effect immediately.
-   *
-   * forceOptions override any setting in dcpConfig; this can be used for settings calculated above
-   * which were derived from dcpConfig in the first place. defaultOptions are overrideable by the usual
-   * dcpConfig mechanisms, but since they are dynamic (or non-user-facing) they don't come from the
-   * etc/dcp-worker-config.js file that ships with the work.
-   *
-   * It is important to never disable leavePublicGroup as a side effect of any other operation, or
-   * slight configuration errors could have large security impacts.
-z   */
-  const dcpWorkerOptions = dcpConfig.worker;
-  const forceOptions = {
-    paymentAddress,
-  };
-  const defaultOptions = {
-    sandboxOptions: {
-      SandboxConstructor: require('dcp-client/lib/standaloneWorker').workerFactory(sawOptions)
-    },
-  };
-
   if (cliArgs.leavePublicGroup !== undefined)
-    forceOptions.leavePublicGroup = mkBool(cliArgs.leavePublicGroup);
+    workerConfig.leavePublicGroup = mkBool(cliArgs.leavePublicGroup);
   if (cliArgs.publicGroupFallback !== undefined)
-    forceOptions.publicGroupFallback = mkBool(cliArgs.publicGroupFallback);
-
-  addConfig(dcpWorkerOptions, defaultOptions, dcpConfig.worker, forceOptions);
-  processCoresAndMaxSandboxes(dcpWorkerOptions, cliArgs);
+    workerConfig.publicGroupFallback = mkBool(cliArgs.publicGroupFallback);
 
   /* Support magic value used by Windows screensaver configuration /wg June 2023 */
-  if (dcpWorkerOptions.leavePublicGroup === 'fallback')
+  if (workerConfig.leavePublicGroup === 'fallback')
   {
-    dcpWorkerOptions.publicGroupFallback = true;
-    dcpWorkerOptions.leavePublicGroup = undefined;
+    workerConfig.publicGroupFallback = true;
+    workerConfig.leavePublicGroup = undefined;
   }
 
   /* cliArgs.join is the list of compute groups to join */
@@ -388,32 +317,21 @@ z   */
       })
       .filter((el) => el.joinKey); /* Filter out entries with no joinKey */
 
-    addConfig(dcpWorkerOptions.computeGroups, dcpWorkerOptions.computeGroups, cliComputeGroups);
+    leafMergeInto(workerConfig.computeGroups, cliComputeGroups);
   }
 
   if (cliArgs.jobId)
   {
-    if (dcpWorkerOptions.jobAddresses === false || dcpWorkerOptions.jobAddresses === undefined)
-      dcpWorkerOptions.jobAddresses = [];
-    dcpWorkerOptions.jobAddresses.push(...cliArgs.jobId);
+    if (!workerConfig.jobAddresses)
+      workerConfig.jobAddresses = [];
+    workerConfig.jobAddresses.push(...cliArgs.jobId);
   }
 
   if (cliArgs.allowedOrigins)
-  {
-    if (!dcpWorkerOptions.allowOrigins)
-      dcpWorkerOptions.allowOrigins = {};
-    if (!dcpWorkerOptions.allowOrigins.any)
-      dcpWorkerOptions.allowOrigins.any = [];
-    dcpWorkerOptions.allowOrigins.any.push(...cliArgs.allowedOrigins);
-  }
-  if (cliArgs.watchdogInterval)
-    dcpWorkerOptions.watchdogInterval = cliArgs.watchdogInterval;
+    workerConfig.allowOrigins.any.push(...cliArgs.allowedOrigins);
 
-  if (cliArgs.showConfig)
-  {
-    console.log(eval('dcpConfig.' + cliArgs.showConfig));
-    process.exit();
-  }
+  if (cliArgs.watchdogInterval)
+    workerConfig.watchdogInterval = cliArgs.watchdogInterval;
 
   if (cliArgs.dumpConfig)
   {
@@ -421,34 +339,31 @@ z   */
     process.exit();
   }
 
-  if (dcpConfig.worker?.bannedGPUs)
+  worker = new DistributiveWorker(workerConfig, SandboxConstructor);
+  workerConfig = null; /* bug-finder */
+  processCoresAndMaxSandboxes(worker.config, cliArgs);
+
+  if (cliArgs.showConfig)
   {
-    for (let prop in dcpConfig.worker.bannedGPUs)
-    {
-      if (!bannedGPUs[prop])
-        bannedGPUs[prop] = dcpConfig.worker?.bannedGPUs[prop];
-      else
-        bannedGPUs[prop] = new RegExp(`(${dcpConfig.worker?.bannedGPUs[prop].source})|(${bannedGPUs[prop].source})`);
-    }
+    console.log(eval('dcpConfig.' + cliArgs.showConfig)); // eslint-disable-line no-eval
+    process.exit();
   }
 
-  const nascentWorker = new DCPWorker(identityKeystore, dcpWorkerOptions);
-  bannerLog(` * Starting DCP Worker ${nascentWorker.workerId}`);
+  bannerLog(` * Starting Distributive Worker ${worker.id}`);
   bannerLog(` . Using evaluator at ${dcpConfig.evaluator.location}`);
   bannerLog(` . Configured for scheduler ${dcpConfig.scheduler.location}`);
   bannerLog(` . Bank is ${dcpConfig.bank.location}`);
-  bannerLog(` . Earned funds will be deposited in account ${nascentWorker.paymentAddress}`);
-  bannerLog(` . Identity is ${nascentWorker.identityKeystore.address}`);
+  bannerLog(` . Earned funds will be deposited in account ${worker.config.paymentAddress}`);
+  bannerLog(` . Identity is ${identity.get()?.address}`);
 
-  nascentWorker.on('warning', (...payload) => console.warn (...payload));
-  nascentWorker.on('stop', () => { console.log('Worker is stopping') });
-  nascentWorker.on('end',  () => { logClosing('log', 'Worker has stopped') });
-  nascentWorker.on('job', job => console.log(` . Job: ${job.name} ${job.address.slice(0,8)} ${job.description || ''} ${job.link || ''}`));
+  worker.on('warning', (...payload) => console.warn (...payload));
+  worker.on('stop', () => { console.log('Worker is stopping') });
+  worker.on('end',  () => { logClosing('log', 'Worker has stopped') });
+  worker.on('job', job => console.log(` . Job: ${job.name} ${job.address.slice(0,8)} ${job.description || ''} ${job.link || ''}`));
 
   // Display clean diagnostic when not debugging and env var
   //   DCP_SUPERVISOR_DEBUG_DISPLAY_MAX_INFO isn't set.
-  nascentWorker.on('error',   (error) => {
-
+  worker.on('error',   (error) => {
     if (displayMaxDiagInfo())
       console.error(error);
     else
@@ -462,36 +377,36 @@ z   */
       console.error(`Error: ${error.message} ${location}`);
     }
   });
-  require('../lib/default-ui-events').hook(nascentWorker, cliArgs);
+  require('../lib/default-ui-events').hook(worker, cliArgs);
 
   if (cliArgs.outputMode === 'dashboard')
-    require('../lib/dashboard-tui').init(nascentWorker, cliArgs, bannerLog.cumulative);
+    require('../lib/dashboard-tui').init(worker, cliArgs, bannerLog.cumulative);
 
   /* Let incorrect event-loop references keep us alive when linked with a debug library, but
    * exit quickly/accurately for production code even when the library isn't perfect.
    */
   if (require('dcp/build').config.build !== 'debug')
-    nascentWorker.on('end', processExit);
+    worker.on('end', processExit);
   else
-    nascentWorker.on('end', () => setTimeout(processExit, getCleanupTimeoutMs()).unref());
+    worker.on('end', () => setTimeout(processExit, worker.config.cleanupTimeout * 1e3).unref());
 
-  if (dcpWorkerOptions.publicGroupFallback)
+  if (worker.config.publicGroupFallback)
   {
-    if (dcpWorkerOptions.leavePublicGroup)
+    if (worker.config.leavePublicGroup)
       console.warn(' ! Global Group fallback has been requested, but the global group is blocked by local configuration');
     else
     {
       /* Enable global group fallback - this currently works by enabling or disabling the global group
        * on the next fetch based on whether or not the most recent fetch was an empty task or not.
        */
-      nascentWorker.on('fetch', fetchEventHandler);
+      worker.on('fetch', fetchEventHandler);
 
       function fetchEventHandler(ev)
       {
         if (ev instanceof Error)
           console.error('Error fetching task:', ev);
         else
-          dcpWorkerOptions.leavePublicGroup = Boolean(slicesFetched(ev) > 0);
+          worker.config.leavePublicGroup = Boolean(slicesFetched(ev) > 0);
       }
     }
   }
@@ -510,25 +425,26 @@ z   */
     return plural;
   }
 
-  if (dcpWorkerOptions.jobAddresses?.length > 0)
-    bannerLog(` * Processing only ${qty(dcpWorkerOptions.jobAddresses, 'job')} ` + dcpWorkerOptions.jobAddresses.join(', '));
-  if (dcpWorkerOptions.computeGroups && Object.keys(dcpWorkerOptions.computeGroups).length > 0)
-    bannerLog(` . Joining compute ${qty(dcpWorkerOptions.computeGroups, 'group')} ` + dcpWorkerOptions.computeGroups.map(el => el.joinKey).join(', '));
-  if (dcpWorkerOptions.publicGroupFallback)
+  if (worker.config.jobAddresses?.length > 0)
+    bannerLog(` * Processing only ${qty(worker.config.jobAddresses, 'job')} ` + worker.config.jobAddresses.join(', '));
+  if (worker.config.computeGroups && Object.keys(worker.config.computeGroups).length > 0)
+    bannerLog(` . Joining compute ${qty(worker.config.computeGroups, 'group')} ` + worker.config.computeGroups.map(el => el.joinKey).join(', '));
+  if (worker.config.publicGroupFallback)
     bannerLog(' . Falling back on global group when preferred groups have no work');
-  if (dcpWorkerOptions.leavePublicGroup)
+  if (worker.config.leavePublicGroup)
     bannerLog(' . Leaving the global compute group');
-  bannerLog(` . Configured Cores: { cpu: ${dcpWorkerOptions.cores.cpu}, gpu: ${dcpWorkerOptions.cores.gpu} }`);;
-  bannerLog(` . Utilization: { cpu: ${dcpWorkerOptions.utilization.cpu}, gpu: ${dcpWorkerOptions.utilization.gpu} }`);
-  bannerLog(` . Effective Cores: { cpu: ${dcpWorkerOptions.utilization.cpu * dcpWorkerOptions.cores.cpu}, gpu: ${dcpWorkerOptions.utilization.gpu * dcpWorkerOptions.cores.gpu} }`);
-  bannerLog(` . Maximum Sandboxes: ${dcpWorkerOptions.maxSandboxes}`);
+
+  bannerLog(` . Configured Cores: { cpu: ${worker.config.cores.cpu}, gpu: ${worker.config.cores.gpu} }`);
+  bannerLog(` . Utilization: { cpu: ${worker.config.utilization.cpu}, gpu: ${worker.config.utilization.gpu} }`);
+  bannerLog(` . Effective Cores: { cpu: ${worker.config.utilization.cpu * worker.config.cores.cpu}, gpu: ${worker.config.utilization.gpu * worker.config.cores.gpu} }`);
+  bannerLog(` . Maximum Sandboxes: ${worker.config.maxSandboxes}`);
   if (cliArgs.verbose)
     bannerLog(` + Verbosity level: ${cliArgs.verbose}`);
   if (telnetd.hasOwnProperty('port'))
     bannerLog(` ! telnetd listening on port ${telnetd.port}`);
 
   let workerInfo;
-  console.throb('log', ' ! Waiting for dcp-evaluator to start...');
+  console.throb('log', ` ! Waiting for dcp-evaluator on ${sawOptions.hostname}:${sawOptions.port} to start...`);
   for (let i=0; !workerInfo; i++)
   {
     workerInfo = await require('../lib/worker-info').getEvaluatorInformation(sawOptions);
@@ -557,20 +473,19 @@ z   */
     for (let descriptor in workerInfo.webgpu.info)
       bannerLog(`    -\t${descriptor}: ${workerInfo.webgpu.info[descriptor]}`);
     systemStateInfo.gpu = Object.assign({}, workerInfo.webgpu.info);
-    systemStateInfo.gpu.device
-    for (let descriptor in bannedGPUs)
+    for (let descriptor in worker.config.bannedGPUs)
     {
-      if (bannedGPUs[descriptor].test(workerInfo.webgpu.info[descriptor]))
+      if (worker.config.bannedGPUs[descriptor].test(workerInfo.webgpu.info[descriptor]))
       {
         console.error(' * This GPU is not supported; disabling');
-        dcpWorkerOptions.cores = { cpu: dcpWorkerOptions.cores.cpu, gpu: 0 };
+        worker.config.cores = { cpu: worker.config.cores.cpu, gpu: 0 };
         systemStateInfo.gpu.disabled = true;
         break;
       }
     }
   }
 
-  bannerLog(' . Supervisor version: ' + nascentWorker.supervisorVersion);
+  bannerLog(' . Supervisor version: ' + worker.supervisorVersion);
   bannerLog(' . Output mode: ' + cliArgs.outputMode);
 
   if (parseFloat(cliArgs.reportInterval))
@@ -587,7 +502,6 @@ z   */
   setImmediate(async function workerStart() {
     bannerLog(' * Ready.\n');
     require('../lib/check-scheduler-version').check();
-    worker = nascentWorker;
     await worker.start();
   });
 }
@@ -604,20 +518,20 @@ z   */
  *      -u 0.80,0.75 => utilization = { cpu: 0.80, gpu: 0.75 }
  *      -m 5    => maxSandboxes = 5
  */
-function processCoresAndMaxSandboxes (dcpWorkerOptions, cliArgs)
+function processCoresAndMaxSandboxes (workerConfig, cliArgs)
 {
   if (typeof cliArgs['maxSandboxes'] !== 'undefined')
-    dcpWorkerOptions.maxSandboxes = Number(cliArgs['maxSandboxes']);
+    workerConfig.maxSandboxes = Number(cliArgs['maxSandboxes']);
 
   const parseArg = (which) => {
     if (cliArgs[which])
     {
-      dcpWorkerOptions[which] = {};
+      workerConfig[which] = {};
       const [cpu, gpu] = cliArgs[which].split(',');
       if (cpu?.length > 0)
-        dcpWorkerOptions[which].cpu = Number(cpu);
+        workerConfig[which].cpu = Number(cpu);
       if (gpu?.length > 0)
-        dcpWorkerOptions[which].gpu = Number(gpu);
+        workerConfig[which].gpu = Number(gpu);
     }
   };
 
@@ -626,9 +540,9 @@ function processCoresAndMaxSandboxes (dcpWorkerOptions, cliArgs)
 
   if (debugging())
   {
-    console.debug(`dcp-worker: cores = { cpu: ${dcpWorkerOptions.cores.cpu}, gpu: ${dcpWorkerOptions.cores.gpu} }`);
-    console.debug('dcp-worker: utilization =', dcpWorkerOptions.utilization);
-    console.debug('dcp-worker: maxSandboxes =', dcpWorkerOptions.maxSandboxes);
+    console.debug(`dcp-worker: cores = { cpu: ${workerConfig.cores.cpu}, gpu: ${workerConfig.cores.gpu} }`);
+    console.debug('dcp-worker: utilization =',  workerConfig.utilization);
+    console.debug('dcp-worker: maxSandboxes =', workerConfig.maxSandboxes);
   }
 }
 
@@ -646,11 +560,16 @@ function logClosing(facility, ...message)
      * FUTURE: dashboard API should know how to unregister its hook so that we don't have to clobber
      *         it here.
      */
-    screen.log(...message);
-    screen.destroy();
-    screen = false;
-    console = new (require('console').Console)(process); // eslint-disable-line no-global-assign
-    telnetd.reintercept();
+
+    try
+    {
+      screen.log(...message);
+      screen.destroy();
+      screen = false;
+      console = new (require('console').Console)(process); // eslint-disable-line no-global-assign
+      telnetd.reintercept();
+    }
+    catch(error) {} // eslint-disable-line no-empty
   }
 
   console[facility](...message);
@@ -668,33 +587,24 @@ function handleUnhandled(error)
   worker = false;
 
   process.exitCode = process.exitCode || EXIT_UNHANDLED;
+  logClosing('error', 'trapped unhandled', error);
 
-  try
+  if (_worker)
   {
-    logClosing('error', error);
-  } catch(e) {} // eslint-disable-line no-empty
-
-  if (!_worker)
-    console.error('trapped unhandled error:', error)
-  else
-  {
-    console.error('trapped unhandled error -- stopping worker:', error);
+    setTimeout(() => {
+      logClosing('error', 'handleFatalError timeout - exiting now');
+      processExit();
+    }, _worker.config.cleanupTimeout * 1e3).unref();
     _worker.on('end', processExit);
     _worker.stop();
   }
 
-  setTimeout(() => {
-    logClosing('error', 'handleFatalError timeout - exiting now');
-    processExit();
-  }, getCleanupTimeoutMs()).unref();
-
-  try {
-    let log = dcpConfig && dcpConfig.worker && dcpConfig.worker.unhandledRejectionLog;
-    if (!log) log = process.env.DCP_WORKER_UNHANDLED_REJECTION_LOG;
-    if (log) {
+  try
+  {
+    let log = process.env.DCP_WORKER_UNHANDLED_REJECTION_LOG || worker?.config?.unhandledRejectionLog;
+    if (log)
       fs.appendFileSync(process.env.DCP_WORKER_UNHANDLED_REJECTION_LOG,
                         `${Date.now()}: ${error.message}\n${error.stack}\n\n`);
-    }
   } catch(e) {} // eslint-disable-line no-empty
 }
 
@@ -813,7 +723,7 @@ function handleSigDeath(signalName, signal)
     console.warn(`trapped ${signalName}, signal ${signal} -- stopping worker`,
                  immediate ? 'immediately' : `after ${handleSigDeath.count} slices have finished`);
     worker.stop(immediate);
-    setTimeout(die, getCleanupTimeoutMs()).unref();
+    setTimeout(die, worker.config.cleanupTimeout * 1e3).unref();
   }
   process.emit('dcpBeforeExit');
 
@@ -827,81 +737,6 @@ function handleSigDeath(signalName, signal)
 }
 globalThis.die = () => handleSigDeath('QUIT', 15);
 
-/**
- * Returns the duration of the cleanup timeout in milliseconds. It is possible to specify zero.
- */
-function getCleanupTimeoutMs()
-{
-  const defaultCT = 60;
-  var cleanupTimeout = dcpConfig.worker?.cleanupTimeout;
-
-  if (typeof cleanupTimeout === 'undefined')
-    cleanupTimeout = defaultCT;
-  if (typeof cleanupTimeout !== 'number')
-    cleanupTimeout = Number(cleanupTimeout)
-  if (isNaN(cleanupTimeout))
-  {
-    cleanupTimeout = defaultCT;
-    if (!getCleanupTimeoutMs.warned)
-    {
-      console.error(`warning: dcpConfig.worker.cleanupTimeout is not a number (${dcpConfig.worker.cleanupTimeout})`);
-      getCleanupTimeoutMs.warned = true;
-    }
-  }
-  return cleanupTimeout * 1000;
-}
-
-/**
- * Ensure the default configuration hasn't been modified by the end-user-sysadmin. It is an
- * attractive nuisance, as it looks just like the file they should modify, but if they make
- * security changes there that are overwritten in an subsequent update, it will be a problem.
- *
- * Every time a new package is generated, the default config file has its md5 checksum recorded
- * via the pack npm hook; all we do is make sure it hasn't changed.
- */
-function verifyDefaultConfigIntegrity()
-{
-  const workerConfPath = require('dcp-client').__cn;
-  const md5sumPath = workerConfPath + '.md5';
-
-  if (!fs.existsSync(md5sumPath))
-  {
-    console.error(chalk.bold.red(` ! warning: ${md5sumPath} not found; cannot verify configuration integrity`));
-    require('dcp/utils').sleep(2);
-  }
-  else
-  {
-    const originalMd5sum = fs.readFileSync(md5sumPath, 'ascii');
-    const actualMd5sum = crypto.createHash('md5')
-          .update(fs.readFileSync(workerConfPath))
-          .digest('hex');
-
-    if (!originalMd5sum.startsWith(actualMd5sum))
-    {
-      console.warn(chalk.yellow(` ! Detected modified ${workerConfPath};`));
-      console.warn(' ! DCP Worker configuration changes should not be made by updating the default');
-      console.warn('   config, as that file will be overwritten on the next npm update. Instead,');
-      console.warn('   make changes via one of the following locations:');
-      console.warn('    - ~/.dcp/dcp-worker/dcp-config.js');
-      console.warn('    - /etc/dcp/dcp-worker/dcp-config.js');
-      console.warn('    - /etc/override/dcp/dcp-worker/dcp-config.js');
-      console.warn('    - the Windows Registry');
-
-      if (require('dcp/build').config.build !== 'debug')
-        processExit(1);
-
-      console.log(chalk.bold.red.inverse("If this wasn't a debug build, the worker would exit now."));
-      require('dcp/utils').sleep(2);
-    }
-  }
-
-  if (dcpConfig.cookie !== process.env.DCP_CONFIG_COOKIE || !dcpConfig.cookie)
-  {
-    console.error(' ! DCP Worker default configuration was not loaded; exiting.');
-    processExit(1);
-  }
-}
-
 /**
  * Cast b to boolean such that 'false' becomes false, falsey things become false, and everything else
  * becomes true.

package/{etc/dcp-worker-config.js → examples/dcp-config.js}

@@ -1,8 +1,9 @@
 /**
- * @file        dcp-worker-config.js - Default configuration for the DCP Worker.
- *              Copy this file before modifying, so that changes are preserved during the upgrade cycle.
+ * @file        dcp-config.js - Sample configuration for the DCP Worker.
+ *
  *              Remove (or comment out) settings you don't need to change, so that changes to the
- *              defaults can be made during an upgrade. Suggested locations include:
+ *              defaults can be made during an upgrade. The standard dcp-client path options apply;
+ *              Suggested locations include:
  *              - /etc/dcp/dcp-worker/dcp-config.js, or
  *              - ~/.dcp/dcp-worker/dcp-config.js.
  *
@@ -40,17 +41,20 @@
       'in':   0, /* DCC per megabyte of inbound network traffic */
       'out':  0, /* DCC per megabyte of outbound network traffic */
     },
+
+    /* Regexps of GPUs we cannot use. Properties match device descriptors. */
     bannedGPUs: {
-      description: /D3D.*version\s[0-2][0-9]/
+      description: /D3D.*version\s[0-2][0-9]/,
+      device:      /llvmpipe/,
     },
 
     /* Extra Compute Groups this worker can participate in. Join credentials are supplied by
      * Distributive and/or local IT staff at site-licensed locations.
      */
     computeGroups: [
-      // { joinKey: 'scott', joinSecret: 'tiger' },
-      // { joinKey: 'scott', joinHash: 'eh1-672937c2b944982e071185b888770f8b8ea67c11f56d545e403e0d513c609b87' },
-      // keystore('~/.dcp/scott'),
+      { joinKey: 'scott', joinSecret: 'tiger' },
+      { joinKey: 'scott', joinHash: 'eh1-672937c2b944982e071185b888770f8b8ea67c11f56d545e403e0d513c609b87' },
+      { keystore('~/.dcp/scott') },
     ],
   },
 
@@ -61,6 +65,4 @@
   evaluator: {
     listen: new URL('dcpsaw://localhost:9000/'),
   },
-
-  cookie: require('process').env.DCP_CONFIG_COOKIE,   /* Used to verify that this file was loaded. */
 }

package/lib/dashboard-tui.js

@@ -135,7 +135,7 @@ exports.init = function dashboard$$init(worker, options, bannerLogCumulative)
   function updateWorkerInfo(fetchInfo)
   {
     var gpuInfo = '';
-    const workerOptions = worker.workerOptions;
+
     if (fetchInfo)
       lastTask = fetchInfo;
 
@@ -162,10 +162,10 @@ exports.init = function dashboard$$init(worker, options, bannerLogCumulative)
       `        Bank Account: ${chalk.yellow(worker.paymentAddress || 'Starting...')}`,
       `            Identity: ${chalk.yellow(worker.identityKeystore? worker.identityKeystore.address : 'Starting...')}`,
       `                 GPU: ${gpuInfo}`,
-      `                Jobs: ${workerOptions.jobAddresses?.length ? workerOptions.jobAddresses.join(', ') : '<any>'}`,
-      `      Compute Groups: ${Object.keys(workerOptions.computeGroups).length + (workerOptions.leavePublicGroup ? 0 : 1)}`,
-      `Global Compute Group: ${workerOptions.leavePublicGroup ? 'no' : 'yes'}`,
-      `           Worker Id: ${worker.workerId}`,
+      `                Jobs: ${worker.config.jobAddresses?.length ? worker.config.jobAddresses.join(', ') : '<any>'}`,
+      `      Compute Groups: ${Object.keys(worker.config.computeGroups).length + (worker.config.leavePublicGroup ? 0 : 1)}`,
+      `Global Compute Group: ${worker.config.leavePublicGroup ? 'no' : 'yes'}`,
+      `           Worker Id: ${worker.id}`,
       `        Current Time: ${new Date(Date.now()).toUTCString()}`,
       `   Last Task Request: ${lastTask ? new Date(lastTask.fetchStart).toUTCString() : 0}`,
       `      Slices in task: ${lastTask ? Object.values(lastTask.slices).reduce((acc, val) => acc + val, 0) : 0}`,

package/lib/worker-loggers/console.js

@@ -7,6 +7,7 @@
 'use strict';
 
 const process = require('process');
+const usingDebugger = require('module')._cache.niim instanceof require('module').Module;
 
 /**
  *  Initialize the console logger
@@ -56,14 +57,14 @@ exports.init = function console$$init(options)
 
     if (throbArgsCache)
     {
-      if (stream.isTTY)
+      if (stream.isTTY && !usingDebugger)
         stream.write(throbArgsCache.args.join(' '));
       else
         console[throbArgsCache.throbFacility](...throbArgsCache.args);
       throbArgsCache = false;
     }
 
-    if (stream.isTTY)
+    if (stream.isTTY && !usingDebugger)
     {
       i = (i + 1) % throbChars.length;
       stream.write(throbChars[i] + '\u0008');

package/lib/worker-loggers/dashboard.js

@@ -70,6 +70,7 @@ exports.init = function dashboardLogger$$init(options)
     }
 
     throbPos = (throbPos + 1) % throbChars.length;
-    dashboardTui.logPane.advanceThrob(throbChars[throbPos]);
+    if (dashboardTui.logPane?.advanceThrob)
+      dashboardTui.logPane.advanceThrob(throbChars[throbPos]);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcp-worker",
-  "version": "3.3.19",
+  "version": "4.0.1",
   "description": "Node.js Worker for Distributive Compute Platform",
   "main": "bin/dcp-worker",
   "keywords": [
@@ -23,7 +23,7 @@
   },
   "directories": {
     "lib": "lib",
-    "etc": "etc"
+    "examples": "examples"
   },
   "scripts": {
     "check": "trunk check",
@@ -32,7 +32,6 @@
     "hook": "PATH=npm-hooks:$PATH &&",
     "lint": "eslint --cache --cache-strategy=content --cache-location=.cache/eslint/ --ignore-path=.gitignore --ext=js .",
     "test": "peter tests",
-    "prepack": "node npm-hooks/prepack",
     "postpublish": "npm-hooks/postpublish",
     "prepublishOnly": "npm-hooks/prepublish"
   },
@@ -40,7 +39,7 @@
     "blessed": "^0.1.81",
     "blessed-contrib": "4.11.0",
     "chalk": "^4.1.0",
-    "dcp-client": "^4.4.24",
+    "dcp-client": "^4.4.28",
     "kvin": "^1.2.7",
     "posix-getopt": "^1.2.1",
     "semver": "^7.3.8",

package/etc/dcp-worker-config.js.md5

@@ -1,2 +0,0 @@
-271fe64e9b77126815dbb9aff6a3412f
-### DO NOT MODIFY THIS FILE!!! ###

package/npm-hooks/prepack

@@ -1,21 +0,0 @@
-#! /usr/bin/env node
-/**
- * @file        prepack
- *              Hook which generates the config md5 on pack (or publish)
- * @author      Wes Garland, wes@distributive.network
- * @date        April 2023, June 2023
- */
-
-const fs = require('fs');
-const process = require('process');
-const path = require('path');
-
-function md5(content)
-{  
-  return require('crypto').createHash('md5').update(content).digest('hex');
-}
-
-process.chdir(path.resolve(__dirname, '..'));
-fs.writeFileSync('etc/dcp-worker-config.js.md5', ''
-                 + `${md5(fs.readFileSync('etc/dcp-worker-config.js'))}\n`
-                 + '### DO NOT MODIFY THIS FILE!!! ###\n');