dcp-worker 3.3.12-0 → 3.3.12

package/bin/dcp-worker

@@ -23,9 +23,11 @@ const chalk   = require('chalk');
 const telnetd = require('../lib/remote-console');
 
 const { slicesFetched, debugging, displayMaxDiagInfo } = require('../lib/utils');
+const { a$sleep } = require('dcp/utils');
 
 const configName = process.env.DCP_CONFIG || '../etc/dcp-worker-config';
 const EXIT_UNHANDLED = 5;
+const systemStateInfo = globalThis.systemStateInfo = {};
 
 /* Setup the telnet REPL up early to ensure early-failure log messages are captured */
 const replHelpers = {
@@ -44,6 +46,26 @@ 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/,
+}
+
+/**
+ * Output startup banner message. Currently a wrapper for console.log, future plans are to make it
+ * possible to suppress these messages, and also to send them multiple places (eg tty and syslog)
+ */
+function bannerLog()
+{
+  console.log.apply(console, arguments);
+  bannerLog.cumulative.push(arguments);
+}
+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.
  */
@@ -138,13 +160,13 @@ function parseCliArgs()
       leavePublicGroup: {
         type: 'boolean',
         hidden: true,
-        describe: 'Do not fetch slices from public compute group.',
+        describe: 'Do not fetch slices from global compute group.',
         default: undefined,
       },
 
       publicGroupFallback: {
         hidden: true,
-        describe: 'If set, worker will prefer private groups but fall back on the public group if no preferred work is available',
+        describe: 'If set, worker will prefer private groups but fall back on the global group if no preferred work is available',
         type: 'boolean',
         default: undefined,
         defaultDescription: undefined,
@@ -298,11 +320,11 @@ async function main()
   require('../lib/startWorkerLogger').init(cliArgs); /* Start remote logger as early as possible */
   verifyDefaultConfigIntegrity();                    /* Bail before TUI & as early as possible if bad conf */
 
-  process.on('SIGINT', handleSigDeath);
+  process.on('SIGINT',  handleSigDeath);
   process.on('SIGTERM', handleSigDeath);
   process.on('SIGQUIT', handleSigDeath);
   process.on('unhandledRejection', handleUnhandled);
-  process.on('uncaughtException', handleUnhandled);
+  process.on('uncaughtException',  handleUnhandled);
 
   const getOpts = {};
   if (cliArgs.defaultPaymentAddressToDCP)
@@ -405,14 +427,33 @@ async function main()
   if (cliArgs.watchdogInterval)
     dcpWorkerOptions.watchdogInterval = cliArgs.watchdogInterval;
 
-  worker = new DCPWorker(identityKeystore, dcpWorkerOptions);
-  worker.on('warning', (...payload) => console.warn (...payload));
-  worker.on('job', job => console.log(` . Job: ${job.name} ${job.address.slice(0,8)} ${job.description || ''} ${job.link || ''}`));
-  worker.on('stop', () => { console.log('Worker is stopping') });
-  worker.on('end',  () => { logClosing('log', 'Worker has stopped') });
+  if (dcpConfig.bannedGPUs)
+  {
+    for (let prop of dcpConfig.bannedGPUs)
+    {
+      if (!bannedGPUs[prop])
+        bannedGPUs[prop] = dcpConfig.bannedGPUs[prop];
+      else
+        bannedGPUs[prop] = new RegExp(`(${dcpConfig.bannedGPUs[prop].source})|(${bannedGPUs[prop].source})`);
+    }
+  }
+
+  const nascentWorker = new DCPWorker(identityKeystore, dcpWorkerOptions);
+  bannerLog(` * Starting DCP Worker ${nascentWorker.workerId}`);
+  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}`);
+
+  nascentWorker.on('warning', (...payload) => console.warn (...payload));
+  nascentWorker.on('stop', () => { console.log('Worker is stopping') });
+  nascentWorker.on('end',  () => { logClosing('log', 'Worker has stopped') });
+
   // Display clean diagnostic when not debugging and env var
   //   DCP_SUPERVISOR_DEBUG_DISPLAY_MAX_INFO isn't set.
-  worker.on('error',   (error) => {
+  nascentWorker.on('error',   (error) => {
+
     if (displayMaxDiagInfo())
       console.error(error);
     else
@@ -424,29 +465,29 @@ async function main()
         console.error(`Error: ${error.message}`);
     }
   });
-  require('../lib/default-ui-events').hook(worker, cliArgs);
+  require('../lib/default-ui-events').hook(nascentWorker, cliArgs);
 
   if (cliArgs.outputMode === 'dashboard')
-    require('../lib/dashboard-tui').init(worker, cliArgs);
+    require('../lib/dashboard-tui').init(nascentWorker, 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')
-    worker.on('end', processExit);
+    nascentWorker.on('end', processExit);
   else
-    worker.on('end', () => setTimeout(processExit, getCleanupTimeoutMs()).unref());
+    nascentWorker.on('end', () => setTimeout(processExit, getCleanupTimeoutMs()).unref());
 
   if (dcpWorkerOptions.publicGroupFallback)
   {
     if (dcpWorkerOptions.leavePublicGroup)
-      console.warn(' ! Public Group fallback has been requested, but the public group is blocked by local configuration');
+      console.warn(' ! Global Group fallback has been requested, but the global group is blocked by local configuration');
     else
     {
-      /* Enable public group fallback - this currently works by enabling or disabling the public group
+      /* 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.
        */
-      worker.on('fetch', fetchEventHandler);
+      nascentWorker.on('fetch', fetchEventHandler);
 
       function fetchEventHandler(ev)
       {
@@ -458,14 +499,8 @@ async function main()
     }
   }
 
-  let introBanner = '';
-  introBanner += ` * Starting DCP Worker ${worker.workerId}` + '\n';
-  introBanner += ` . Configured for scheduler ${dcpConfig.scheduler.location}` + '\n';
-  introBanner += ` . Bank is ${dcpConfig.bank.location}` + '\n';
-  introBanner += ` . Earned funds will be deposited in account ${worker.paymentAddress}` + '\n';
-  introBanner += ` . Identity is ${worker.identityKeystore.address}` + '\n';
-
-  function qty(amount, singular, plural) /* XXX i18n */
+  /** @todo i18n */
+  function qty(amount, singular, plural)
   {
     if (Array.isArray(amount))
       amount = amount.length;
@@ -479,49 +514,70 @@ async function main()
   }
 
   if (dcpWorkerOptions.jobAddresses?.length > 0)
-    introBanner += ` * Processing only ${qty(dcpWorkerOptions.jobAddresses, 'job')} ` + dcpWorkerOptions.jobAddresses.join(', ') + '\n';
+    bannerLog(` * Processing only ${qty(dcpWorkerOptions.jobAddresses, 'job')} ` + dcpWorkerOptions.jobAddresses.join(', '));
   if (dcpWorkerOptions.computeGroups && Object.keys(dcpWorkerOptions.computeGroups).length > 0)
-    introBanner += ` . Joining compute ${qty(dcpWorkerOptions.computeGroups, 'group')} ` + dcpWorkerOptions.computeGroups.map(el => el.joinKey).join(', ') + '\n';
+    bannerLog(` . Joining compute ${qty(dcpWorkerOptions.computeGroups, 'group')} ` + dcpWorkerOptions.computeGroups.map(el => el.joinKey).join(', '));
   if (dcpWorkerOptions.publicGroupFallback)
-    introBanner += ' . Falling back on public group when preferred groups have no work' + '\n';
+    bannerLog(' . Falling back on global group when preferred groups have no work');
   if (dcpWorkerOptions.leavePublicGroup)
-    introBanner += ' . Leaving the public compute group' + '\n';
+    bannerLog(' . Leaving the global compute group');
   if (dcpWorkerOptions.cores)
-    introBanner += ` . Configured Cores: ${dcpWorkerOptions.cores.cpu},${dcpWorkerOptions.cores.gpu}\n`
+    bannerLog(` . Configured Cores: ${dcpWorkerOptions.cores.cpu},${dcpWorkerOptions.cores.gpu}`);
   if (typeof dcpWorkerOptions.maxSandboxes !== 'undefined')
-    introBanner += ` . Maximum Sandboxes: ${dcpWorkerOptions.maxSandboxes}\n`
+    bannerLog(` . Maximum Sandboxes: ${dcpWorkerOptions.maxSandboxes}`);
   if (cliArgs.verbose)
-    introBanner += ` + Verbosity level: ${cliArgs.verbose}` + '\n';
+    bannerLog(` + Verbosity level: ${cliArgs.verbose}`);
   if (telnetd.hasOwnProperty('port'))
-    introBanner += ` ! telnetd listening on port ${telnetd.port}\n`;
+    bannerLog(` ! telnetd listening on port ${telnetd.port}`);
 
   const { worktimes } = require('dcp-client/libexec/sandbox/worktimes');
   if (Object.keys(worktimes).length > 0)
   {
-    introBanner += ' . Worktimes Available:\n';
+    bannerLog(' . Worktimes Available:');
     for (const wt of worktimes)
-      introBanner += `    -\t${wt.name}@${wt.versions.join(';')}\n`;
+      bannerLog(`    -\t${wt.name}@${wt.versions.join(';')}`);
+  }
+
+  let webgpuInfo;
+  console.throb('log', ' ! Waiting for dcp-evaluator to start...');
+  for (let i=0; !webgpuInfo; i++)
+  {
+    webgpuInfo = await require('../lib/webgpu-info').checkWebGPU();
+    if (webgpuInfo)
+      break;
+    console.throb();
+    await a$sleep(Math.max(i + 1, 10) / 4);
+    console.throb();
   }
 
-  const webgpuInfo = await require('../lib/webgpu-info').checkWebGPU();
   if (!webgpuInfo)
-    introBanner += ' . WebGPU detection failed\n';
+    bannerLog(' . WebGPU detection failed');
   else if (!webgpuInfo.enabled)
-    introBanner += ' . WebGPU not enabled\n';
+  {
+    bannerLog(' . WebGPU not enabled');
+    systemStateInfo.gpu = false;
+  }
   else
   {
-    introBanner += ' . WebGPU available. GPU info:\n';
+    bannerLog(' . WebGPU available. GPU info:');
     for (let descriptor in webgpuInfo.info)
-      introBanner += `    -\t${descriptor}: ${webgpuInfo.info[descriptor]}\n`;
-    dcpConfig.evaluator.gpu = webgpuInfo.info.device;
+      bannerLog(`    -\t${descriptor}: ${webgpuInfo.info[descriptor]}`);
+    systemStateInfo.gpu = Object.assign({}, webgpuInfo.info);
+    systemStateInfo.gpu.device
+    for (let descriptor in bannedGPUs)
+    {
+      if (bannedGPUs[descriptor].test(webgpuInfo.info[descriptor]))
+      {
+        console.error(' * This GPU is not supported; disabling');
+        dcpWorkerOptions.cores = { cpu: dcpWorkerOptions.cores.cpu, gpu: 0 };
+        systemStateInfo.gpu.disabled = true;
+        break;
+      }
+    }
   }
 
-  introBanner += ' . Supervisor version: ' + worker.supervisorVersion + '\n';
-  introBanner += ' . Output mode: ' + cliArgs.outputMode + '\n';
-  introBanner += ' * Ready' + '\n';
-
-  console.log(introBanner);
-  require('../lib/check-scheduler-version').check();
+  bannerLog(' . Supervisor version: ' + nascentWorker.supervisorVersion);
+  bannerLog(' . Output mode: ' + cliArgs.outputMode);
 
   if (parseFloat(cliArgs.reportInterval))
   {
@@ -531,8 +587,15 @@ async function main()
       console.warn('Ignoring --reportInterval in dashboard output mode');
   }
 
-  /* Start the worker. Normal process exit happens by virtue of the worker<end> event */
-  await worker.start();
+  /* Start the worker. Normal process exit happens by virtue of the worker<end> event. Move forward one
+   * tick in case processExit was called during initialization.
+   */
+  setImmediate(async function workerStart() {
+    bannerLog(' * Ready.\n');
+    require('../lib/check-scheduler-version').check();
+    worker = nascentWorker;
+    await worker.start();
+  });
 }
 
 /**
@@ -747,21 +810,25 @@ function handleSigDeath(signalName, signal)
   }
 
   if (!worker)
+  {
     console.warn(`trapped ${signalName}, signal ${signal}`);
+    die();
+  }
   else
   {
     const immediate = signalName === 'SIGQUIT' || handleSigDeath.count > 1;
     console.warn(`trapped ${signalName}, signal ${signal} -- stopping worker`,
                  immediate ? 'immediately' : `after ${handleSigDeath.count} slices have finished`);
     worker.stop(immediate);
+    setTimeout(die, getCleanupTimeoutMs()).unref();
   }
+  process.emit('dcpBeforeExit');
 
   function die()
   {
     processExit(signal - 128);
   }
 
-  setTimeout(die, getCleanupTimeoutMs()).unref();
   if (handleSigDeath.count === 3)
     die();
 }
@@ -818,7 +885,7 @@ function verifyDefaultConfigIntegrity()
     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(' ! 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');

package/lib/blessed-components/log.js

@@ -40,19 +40,22 @@ class Log extends Box
 
   log(...args)
   {
-    const str = args.reduce(
-      (s, arg) => (s += `${typeof arg === 'string'? arg : JSON.stringify(arg, null, 2)} `),
-    '');
-
-    this.logLines.push(str);
+    args = args.map(arg =>`${typeof arg === 'string'? arg : JSON.stringify(arg, null, 2)}`);
+    this.logLines.push(args.join(' '));
 
     if (this.logLines.length > this.options.bufferLength)
       this.logLines.shift();
 
-    this.setContent(this.logLines.join('\n'));
+    this.lastLogContent = this.logLines.join('\n');
+    this.setContent(this.lastLogContent);
     if (!this.paused)
       this.setScrollPerc(100);
   }
+
+  advanceThrob(char)
+  {
+    this.setContent(this.lastLogContent + char);
+  }
 }
 
 Object.assign(exports, {

package/lib/dashboard-tui.js

@@ -18,6 +18,7 @@ const components = require('./blessed-components');
 const utils      = require('../lib/utils');
 
 const { replaceWorkerEventHandler, replaceSandboxEventHandler, newSandboxCallbacks }  = require('./default-ui-events');
+const systemStateInfo = globalThis.systemStateInfo;
 
 const SLICE_FETCH_STATUS = {
   IDLE: chalk.yellow('Idle'),
@@ -36,7 +37,7 @@ const screenConf = {
  *  @param  {Worker}    worker    Reference to the DCP Worker
  *  @param {object} options Options which may affect behaviour. Not currently used.
  */
-exports.init = function dashboard$$init(worker, options)
+exports.init = function dashboard$$init(worker, options, bannerLogCumulative)
 {
   var sliceFetchStatus = SLICE_FETCH_STATUS.IDLE;
   var totalDCCs = 0;
@@ -51,12 +52,12 @@ exports.init = function dashboard$$init(worker, options)
       screen.destroy();
   });
 
-  const grid = new contrib.grid({ rows: 3, cols: 5, screen }); // eslint-disable-line new-cap
-  const workerInfoPane = grid.set(2, 0, 1, 5, components.log, {
+  const grid = new contrib.grid({ rows: 3, cols: 6, screen }); // eslint-disable-line new-cap
+  const workerInfoPane = grid.set(2, 0, 1, 6, components.log, {
     label: 'Worker Status',
     scrollbar: { bg: 'blue' },
   });
-  const logPane = grid.set(0, 2, 2, 3, components.log, {
+  const logPane = grid.set(0, 2, 2, 4, components.log, {
     label: 'Worker Log',
     scrollbar: { bg: 'blue' },
   });
@@ -115,9 +116,11 @@ exports.init = function dashboard$$init(worker, options)
   };
 
   delete exports.init; /* singleton */
-
+  console.log(' . Starting dashboard and redirecting logs');
   if (!usingDebugger)
     exports.logPane = logPane; /* now dashboard log can find the pane */
+  for (let args of bannerLogCumulative) /* re-draw previously-emited log lines as screen has cleared */
+    logPane.log(...args);
   setInterval(() => screen.render(), 2000).unref(); /* ensure we didn't forget to render an important update */
   updateWorkerInfo();
 
@@ -130,10 +133,25 @@ exports.init = function dashboard$$init(worker, options)
   setInterval(updateWorkerInfo, 1000).unref();
   function updateWorkerInfo(fetchInfo)
   {
+    var gpuInfo = '';
     const workerOptions = worker.workerOptions;
     if (fetchInfo)
       lastTask = fetchInfo;
 
+    if (typeof systemStateInfo.gpu === 'undefined')
+      gpuInfo = '';
+    else if (systemStateInfo.gpu === false)
+      gpuInfo = 'none';
+    else if (typeof systemStateInfo.gpu === 'object')
+    {
+      if (systemStateInfo.gpu.disabled)
+        gpuInfo = chalk.red('disabled') + chalk.grey(` (${systemStateInfo.gpu.device})`);
+      else
+        gpuInfo = chalk.cyan(systemStateInfo.gpu.device);
+    }
+    else
+      gpuInfo = chalk.red(`error detecting`);
+
     workerInfoPane.setLabel(`Worker Status [${sliceFetchStatus}]`);
     workerInfoPane.setContent([
       chalk.green(` DCCs Earned: ${chalk.bold(totalDCCs.toFixed(3))} ⊇`),
@@ -142,7 +160,7 @@ exports.init = function dashboard$$init(worker, options)
       `                Bank: ${chalk.yellow(dcpConfig.bank.location.href)}`,
       `        Bank Account: ${chalk.yellow(worker.paymentAddress || 'Starting...')}`,
       `            Identity: ${chalk.yellow(worker.identityKeystore? worker.identityKeystore.address : 'Starting...')}`,
-      `         ${dcpConfig.evaluator.gpu ? `GPU Detected: ${dcpConfig.evaluator.gpu}` : 'GPU Not Detected'}`,
+      `                 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'}`,

package/lib/startWorkerLogger.js

@@ -50,7 +50,7 @@ function getLogger(options)
  * merely a passthrough shim, this is a "dead end" interceptor - we do not pass the log message through
   * to the original console method.  This implies, for example, that sending console messages to syslogd
  * quiesces the tty output.
- * 
+ *
  * @param {object} options - cliArgs from worker
  */
 exports.init = function startWorkerLogger$$init(options)
@@ -92,8 +92,16 @@ exports.init = function startWorkerLogger$$init(options)
     }
   }
 
+  if (logger.throb)
+    console.throb = logger.throb;
+  else
+    console.throb = function throwFallback(facility, ...args) {
+      if (facility && facility !== 'throb')
+        console[facility](...args);
+    };
+
   require('./remote-console').reintercept();
-}  
+}
 
 /**
  * Format console.log arguments for use by a non-native logger, eg syslog.  All non-string arguments are

package/lib/webgpu-info.js

@@ -13,6 +13,9 @@ const evaluatorId = 'webgpuCheck';
 
 async function eval$$webgpu()
 {
+  if (typeof initWebGPU === 'function')
+    await initWebGPU();
+
   if (!(typeof globalThis.navigator?.gpu === 'object'))
     return { enabled: false };
 
@@ -67,15 +70,16 @@ function checkEvaluatorWebGPU(evaluatorConfig)
     noResponse.intr();
   });
 
-  noResponse = a$sleep(1);
-  noResponse.then(() => { resolve(); });
-  process.on('dcpExit', () => noResponse.intr());
+  noResponse = a$sleep(2);
+  noResponse.then(resolve); /* no answer */
+  noResponse.finally(() => process.off('dcpBeforeExit', noResponse.intr));
+  process.on('dcpBeforeExit', noResponse.intr);
   
   evaluatorHandle.onmessage = function onmessage(event)
   {
     const reply = kvin.unmarshal(event.data).value;
     if (reply.request === `evalResult::${evaluatorId}`)
-      resolve(reply.data);
+      resolve(reply.data /* { enabled: false|true } */);
   }
 
   const message = {

package/lib/worker-loggers/console.js

@@ -16,6 +16,9 @@ const process = require('process');
 exports.init = function console$$init(options)
 {
   const myConsole = new (require('console').Console)(process);
+  var lastWasThrobber = false;
+  var i = 0;
+  var throbArgsCache = false;
 
   delete exports.init; // singleton
   if (process.env.RAW_CONSOLE)
@@ -24,12 +27,47 @@ exports.init = function console$$init(options)
     exports.raw = function console$$raw(level, ...args) {
       myConsole[level](...args);
     };
+    return;
   }
-  else
-  {
-    /* Log a single string to the console; conceptually very similar to other loggers */
-    exports.at = function console$$at(level, ...args) {
-      myConsole[level](args.join(' '));
-    };
+
+  /* Log a single string to the console; conceptually very similar to other loggers */
+  exports.at = function console$$at(level, ...args) {
+    if (lastWasThrobber)
+    {
+      args.unshift(' \n');
+      lastWasThrobber = false;
+    }
+    myConsole[level](args.join(' '));
+  };
+
+  const throbChars = '/-\\|';
+  /**
+   * throb API: calls with arguments set facility and message.  First call without argument emits the
+   *            message. All calls without arguments advance the throbber.
+   */
+  exports.throb = function throb(throbFacility, ...args) {
+    if (throbFacility)
+    {
+      throbArgsCache = { throbFacility, args };
+      return;
+    }
+
+    const stream = throbFacility === 'error' || throbFacility === 'warn' ? process.stderr : process.stdout;
+
+    if (throbArgsCache)
+    {
+      if (stream.isTTY)
+        stream.write(throbArgsCache.args.join(' '));
+      else
+        console[throbArgsCache.throbFacility](...throbArgsCache.args);
+      throbArgsCache = false;
+    }
+
+    if (stream.isTTY)
+    {
+      i = (i + 1) % throbChars.length;
+      stream.write(throbChars[i] + '\u0008');
+      lastWasThrobber = true;
+    }
   }
 }

package/lib/worker-loggers/dashboard.js

@@ -2,7 +2,7 @@
  *  @file       worker-loggers/dashboard.js
  *  @author     Ryan Rossiter, ryan@kingsds.network
  *  @date       April 2020
- * 
+ *
  *  This worker logger uses the blessed library to create
  *  a monitoring dashboard for the worker.
  */
@@ -17,11 +17,13 @@ const chalk = require('chalk');
  */
 exports.init = function dashboardLogger$$init(options)
 {
+  const dashboardTui = require('../dashboard-tui');
+  const inspect = Symbol.for('nodejs.util.inspect.custom');
+  var throbPos = 0;
+  var throbArgsCache = false;
+
   function logWrapperFactory(logLevel)
   {
-    const inspect = Symbol.for('nodejs.util.inspect.custom');
-    const dashboardTui = require('../dashboard-tui');
-    
     return function wrappedLogFun() {
       if (!dashboardTui.logPane) /* no logPane => TUI not ready - fallback to console */
       {
@@ -33,7 +35,7 @@ exports.init = function dashboardLogger$$init(options)
         logAt(logLevel, ...arguments);
         return;
       }
-      
+
       const argv = Array.from(arguments);
       for (let i in argv)
       {
@@ -48,5 +50,26 @@ exports.init = function dashboardLogger$$init(options)
 
   for (let level of ['log', 'warn', 'debug', 'info', 'error'])
     exports[level] = logWrapperFactory(level);
-}
 
+  const throbChars = '/-\\|';
+  /**
+   * throb API: calls with arguments set facility and message.  First call without argument emits the
+   *            message. All calls without arguments advance the throbber.
+   */
+  exports.throb = function throb(throbFacility, ...args) {
+    if (throbFacility)
+    {
+      throbArgsCache = { throbFacility, args };
+      return;
+    }
+
+    if (throbArgsCache)
+    {
+      exports[throbArgsCache.throbFacility](...throbArgsCache.args);
+      throbArgsCache = false;
+    }
+
+    throbPos = (throbPos + 1) % throbChars.length;
+    dashboardTui.logPane.advanceThrob(throbChars[throbPos]);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcp-worker",
-  "version": "3.3.12-0",
+  "version": "3.3.12",
   "description": "Node.js Worker for Distributive Compute Platform",
   "main": "bin/dcp-worker",
   "keywords": [
@@ -12,7 +12,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@gitlab.com/Distributed-Compute-Protocol/dcp-worker.git"
+    "url": "git@github.com:Distributed-Compute-Labs/dcp-worker.git"
   },
   "license": "MIT",
   "author": "Distributive Corp.",
@@ -37,18 +37,18 @@
     "prepublishOnly": "npm-hooks/prepublish"
   },
   "dependencies": {
-    "blessed": "^0.1.81",
+    "blessed": "0.1.81",
     "blessed-contrib": "4.11.0",
-    "chalk": "^4.1.0",
-    "dcp-client": "4.4.11-0",
-    "kvin": "^1.2.7",
-    "posix-getopt": "^1.2.1",
-    "semver": "^7.3.8",
+    "chalk": "4.1.2",
+    "dcp-client": "4.4.11",
+    "kvin": "1.2.14",
+    "posix-getopt": "1.2.1",
+    "semver": "7.6.3",
     "syslog-client": "1.1.1"
   },
   "optionalDependencies": {
-    "dbus-next": "^0.10.2",
-    "telnet-console": "^1.0.5"
+    "dbus-next": "0.10.2",
+    "telnet-console": "1.0.5"
   },
   "devDependencies": {
     "@distributive/eslint-config": "2.1.4",