dcp-worker 3.2.28-2 → 3.2.28

package/.gitlab-ci.yml

@@ -1,31 +1,31 @@
 # @file    .gitlab-ci.yml - GitLab CI configuration file.
-# @author  Bryan Hoang <bryan@distributive.network>
+# @author  Eddie Roosenmallen <eddie@distributive.network>
 # @date    September 2022
 
-# Note: The CLI requires `glibc`.
-image: node:14
-
-stages:
-  - build
-
-# Use in-house GitLab runners.
 default:
+  # Use in-house GitLab runners.
   tags:
     - dcp
     - linux
 
+stages:
+  - build
+
 tidelift:
   stage: build
   variables:
     # This should be kept in a GitLab Variable. Read more:
     # https://docs.gitlab.com/ee/ci/variables/#create-a-custom-variable-in-the-ui
     TIDELIFT_API_KEY: $TIDELIFT_API_KEY
-  script:
+  # The CLI only requires `glibc`.
+  image: frolvlad/alpine-glibc
+  before_script:
+    - apk add --no-cache curl
     - echo "Downloading Tidelift CLI"
     - curl https://download.tidelift.com/cli/tidelift -o tidelift
     - echo "Setting permissions"
     - chmod +x tidelift
+  script:
     - echo "Running alignment and saving to Tidelift"
     - ./tidelift alignment save --wait
-  allow_failure: true
   cache: []

package/bin/dcp-worker

@@ -9,14 +9,19 @@
 'use strict';
 
 const process = require('process');
-const os      = require('os');
 const fs      = require('fs');
 const crypto  = require('crypto');
 const chalk   = require('chalk');
 
 const configName = process.env.DCP_CONFIG || '../etc/dcp-worker-config';
-const TOTAL_CPU_VCORES = os.cpus().length;
-var worker, dcpConfig;
+var worker, dcpConfig, debugging;
+
+const debug = (...args) => {
+  if (!debugging)
+    debugging = require('dcp/internal/debugging').scope('dcp-worker');
+  if (debugging())
+    console.debug('dcp-worker:', ...args);
+};
 
 const EXIT_UNHANDLED = 5;
 
@@ -55,9 +60,14 @@ function parseCliArgs()
       },
       cores: {
         alias: 'c',
-        describe: 'Number of cores to work with',
-        type: 'number',
-        default: TOTAL_CPU_VCORES - 1,
+        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',
+        type: 'string',
+      },
+      density: {
+        alias: 'd',
+        describe: 'default proportion of CPU,GPU to use when cores not specified',
+        type: 'string',
+        default: JSON.stringify(dcpConfig.worker.defaultCoreDensity),
       },
       verbose: {
         alias: 'v',
@@ -232,6 +242,8 @@ async function main()
     port:     cliArgs.port
   };
 
+  verifyDefaultConfigIntegrity();
+
   process.on('SIGINT', handleSigDeath);
   process.on('SIGTERM', handleSigDeath);
   process.on('SIGQUIT', handleSigDeath);
@@ -270,8 +282,7 @@ async function main()
   const dcpWorkerOptions = dcpConfig.worker;
   const forceOptions = {
     paymentAddress,
-    leavePublicGroup: cliArgs.leavePublicGroup || (dcpConfig.worker.leavePublicGroup === 'true') || (dcpConfig.worker.leavePublicGroup === true) || false,
-    maxWorkingSandboxes: cliArgs.cores,
+    leavePublicGroup: cliArgs.leavePublicGroup || dcpConfig.worker.leavePublicGroup || cliArgs.publicGroupFallback || false,
   };
   const defaultOptions = {
     sandboxOptions: {
@@ -280,6 +291,7 @@ async function main()
   };
 
   addConfig(dcpWorkerOptions, defaultOptions, dcpConfig.worker, forceOptions);
+  processCoresAndDensity(dcpWorkerOptions, cliArgs);
 
   /* cliArgs.join is the list of compute groups to join */
   if (cliArgs.join && cliArgs.join.length)
@@ -325,20 +337,13 @@ async function main()
     worker.on('end', () => setTimeout(process.exit, getCleanupTimeoutMs()).unref());
 
   if (cliArgs.eventDebug)
-  {
-    worker.debug = true;
-    worker.supervisor.debug = true;
-  }
+    worker.enableDebugEvents = true;
 
   worker.on('stop', () => { console.log('Worker is stopping') });
   worker.on('end',  () => { logClosing('log', 'Worker has stopped') });
   startWorkerLogger(worker, cliArgs);
 
   require('../lib/remote-console').setMainEval(function mainEval() { return eval(arguments[0]) });
-  require('../lib/remote-console').reintercept();
-
-  // Only after intercepting console for remote and for event-log
-  verifyDefaultConfigIntegrity();
 
   // Activate public group fallback
   // If requested by CLI
@@ -365,11 +370,11 @@ async function main()
   }
 
   let introBanner = '';
-  introBanner += ` * Starting DCP Worker` + '\n';
+  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 ${paymentAddress}` + '\n';
-  introBanner += ` . Identity is ${identityKeystore.address}` + '\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 */
   {
@@ -384,21 +389,26 @@ async function main()
     return plural;
   }
 
-  if (dcpWorkerOptions.jobAddresses.length)
+  if (dcpWorkerOptions.jobAddresses?.length > 0)
     introBanner += ` * Processing only ${qty(dcpWorkerOptions.jobAddresses, 'job')} ` + dcpWorkerOptions.jobAddresses.join(', ') + '\n';
-  if (dcpWorkerOptions.computeGroups.length)
-    introBanner += ` * Joining compute ${qty(dcpWorkerOptions.computeGroups, 'group')} ` + dcpWorkerOptions.computeGroups.map(el => el.joinKey).join(', ') + '\n';
+  if (dcpWorkerOptions.computeGroups?.length > 0)
+    introBanner += ` . Joining compute ${qty(dcpWorkerOptions.computeGroups, 'group')} ` + dcpWorkerOptions.computeGroups.map(el => el.joinKey).join(', ') + '\n';
   if (dcpWorkerOptions.publicGroupFallback)
-    introBanner += ' * Falling back on public group when preferred groups have no work' + '\n';
+    introBanner += ' . Falling back on public group when preferred groups have no work' + '\n';
   else if (dcpWorkerOptions.leavePublicGroup)
-    introBanner += ' * Leaving the public compute group' + '\n';
+    introBanner += ' . Leaving the public compute group' + '\n';
+  if (dcpWorkerOptions.cores)
+    introBanner += ` . Target cores: ${JSON.stringify(dcpWorkerOptions.cores)}\n`;
+  else
+    introBanner += ` . Target core density: ${JSON.stringify(dcpWorkerOptions.defaultCoreDensity)}\n`;
   if (cliArgs.verbose)
     introBanner += ` + Verbosity level: ${cliArgs.verbose}` + '\n';
   if (cliArgs.eventDebug)
     introBanner += ' + Event debug on' + '\n';
-  introBanner += ' . output mode: ' + cliArgs.outputMode + '\n';
-  
-  introBanner += ' . ready' + '\n';
+
+  introBanner += ' . Supervisor version: ' + worker.supervisorVersion;
+  introBanner += ' . Output mode: ' + cliArgs.outputMode + '\n';
+  introBanner += ' * Ready' + '\n';
 
   console.log(introBanner);
   require('../lib/check-scheduler-version').check();
@@ -415,6 +425,43 @@ async function main()
   await worker.start();
 }
 
+/** 
+ * Process the cores and density cli arguments.
+ *
+ * cliArgs.cores is the core count of the hardware to use.
+ * It can be specified with only the cpu or gpu component, or both.
+ *
+ * E.g. -c 2,1  => cores = { cpu: 2,         gpu: 1 }
+ *      -c 10   => cores = { cpu: 10,        gpu: <default> }
+ *      -c ,10  => cores = { cpu: <default>, gpu: 10 }
+ */
+function processCoresAndDensity (dcpWorkerOptions, cliArgs)
+{
+  const DCPWorker = require('dcp/worker').Worker;
+  const defaultTargets = {
+    density: dcpWorkerOptions.defaultCoreDensity || { cpu: 0, gpu: 0 }, /* 0,0 => user specified corrupt conf */
+    cores: DCPWorker.defaultCores(dcpWorkerOptions),
+  };
+
+  const parseArg = (which) => {
+    if (!cliArgs[which])
+      return false;
+
+    const [cpu, gpu] = cliArgs[which].split(',');
+    dcpWorkerOptions[which] = { cpu: Number(cpu || defaultTargets[which].cpu),
+                                gpu: Number(gpu || defaultTargets[which].gpu) };
+    return true;
+  };
+
+  parseArg('density');
+  parseArg('cores');
+
+  if (dcpWorkerOptions.cores)
+    debug('cores = ', dcpWorkerOptions.cores);
+  else
+    debug('core density = ', dcpWorkerOptions.defaultCoreDensity);
+}
+
 /**
  * Log a closing message (or messages). Since the dashboard clears the screen on exit, we use the
  * memoized console property to log the message after we destroy the instance of screen.
@@ -436,7 +483,7 @@ function logClosing(facility, ...message)
     screen = false;
     console = new (require('console').Console)(process);
     require('../lib/remote-console').reintercept();
-    console[facility](...message);
+    console[facility].call(null, ...message);
   }
 }
 
@@ -504,7 +551,6 @@ function toInterval(el)
 /** retrieve a slice report screen */
 function sliceReport()
 {
-  const sup = worker.supervisor;
   let report = '';
 
   report += ('='.repeat(78)) + '\n';
@@ -521,7 +567,7 @@ function sliceReport()
     READY: 'Ready',
     TERMINATED: 'Terminated',
   };
-  sup.sandboxes.forEach(sb => {
+  worker.sandboxes.forEach(sb => {
     const { state } = sb;
     if (!sbStates[state])
       sbStates[state] = 0;
@@ -534,10 +580,10 @@ function sliceReport()
     const stateName = stateNames[state] || state;
     report += (`  ${(stateName + ':').padEnd(12)} ${sbStates[state]}`) + '\n';
   })
-  report += (`  * ALL:       ${sup.sandboxes.length}`) + '\n';
+  report += (`  * ALL:       ${worker.sandboxes.length}`) + '\n';
 
   report += ('Progress:') + '\n';
-  sup.workingSandboxes.forEach(sb => {
+  worker.workingSandboxes.forEach(sb => {
     const jobName = sb.job && sb.job.public && sb.job.public.name || `idek (${sb.jobAddress})`;
     let el = Date.now() - sb.sliceStartTime;
     const t = el < 1000000
@@ -556,8 +602,8 @@ function sliceReport()
   });
 
   report += ('Slices:') + '\n';
-  report += (`  working:     ${sup.allocatedSlices.length}`) + '\n';
-  report += (`  queued:      ${sup.queuedSlices.length}`) + '\n';
+  report += (`  working:     ${worker.workingSlices.length}`) + '\n';
+  report += (`  queued:      ${worker.queuedSlices.length}`) + '\n';
 
   report += ('='.repeat(78)) + '\n';
 
@@ -581,7 +627,7 @@ function handleSigDeath(signalName, signal)
   else
   {
     console.error(`trapped ${signalName}, signal ${signal} -- stopping worker`);
-    worker.stop();
+    worker.stop(signalName === 'SIGQUIT');
   }
 
   setTimeout(() => process.exit(signal - 128), getCleanupTimeoutMs()).unref();
@@ -633,7 +679,7 @@ function verifyDefaultConfigIntegrity()
   {
     const originalMd5sum = fs.readFileSync(md5sumPath, 'ascii');
     const actualMd5sum = crypto.createHash('md5')
-          .update(fs.readFileSync(workerConfPath))
+          .update(fs.readFileSync(workerConfPath, 'ascii'))
           .digest('hex');
 
     if (!originalMd5sum.startsWith(actualMd5sum))
@@ -647,10 +693,6 @@ function verifyDefaultConfigIntegrity()
       console.warn('    - /etc/override/dcp/dcp-worker/dcp-config.js');
       console.warn('    - the Windows Registry');
 
-      // md5 calculation is incorrect on Windows. Possibly git/npm mangling line-endings?
-      if (require('os').platform() === 'win32')
-        return;
-
       if (require('dcp/build').config.build !== 'debug')
         process.exit(1);
 

package/etc/dcp-worker-config.js

@@ -20,6 +20,7 @@
  */
 {
   worker: {
+    defaultCoreDensity: { cpu: 0.9, gpu: 0.75 }, /* proportion of this machine's cores to use by default */
     trustComputeGroupOrigins: true,  /* Trust the scheduler to modify allowOrigins via Compute Group configuration */
 
     /* Allow lists permitting supervisor network access beyond DCP messages to services */

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

@@ -1,2 +1,2 @@
-db140f1050d7506373319cc282e3c76d  etc/dcp-worker-config.js
+8edf1c57bee521ed7f151a21b8f3f34d
 ### DO NOT MODIFY THIS FILE!!! ###

package/lib/blessed-components/sandboxes.js

@@ -6,6 +6,7 @@
  *  This blessed component produces labeled progress bars
  *  to render the progress of worker sandboxes.
  */
+'use strict';
 
 const { Box, ProgressBar, Text } = require('blessed');
 
@@ -69,7 +70,7 @@ class Sandboxes extends Box {
       if (i < this.progressBars.length) {
         this.updateProgressBar(i, this.data[i]);
       } else {
-        this.createProgressBar(progress);
+        this.createProgressBar();
       }
     }
 
@@ -79,7 +80,7 @@ class Sandboxes extends Box {
       }
     }
 
-    this.setLabel(`${this.options.label} (${this.data.length}/${this.options.defaultProgressBars})`);
+    this.setLabel(`${this.options.label} (${this.data.length})`);
   }
 }
 

package/lib/remote-console.js

@@ -9,7 +9,7 @@
  *              priviledges as the DCP Service Worker.
  *
  *              To enable this feature, create a file in ../etc named enable-debug-console. That
- *              file should contain a number which identities the port number this service will
+ *              file should contain a number which identifies the port number this service will
  *              listen on.
  *
  *              The port file could also contain the string "false", which is just an explicit
@@ -46,6 +46,7 @@ function daemonEval()
 }
 
 function callbackTelnet(port, client, registry) {
+  client.unref();
   debugging() && console.debug(' ! telnetd - listening on port', port);
 }
 

package/lib/startWorkerLogger.js

@@ -75,7 +75,7 @@ Object.assign(exports, {
     for (const [ev, handler] of Object.entries(supervisorEvents))
     {
       if (typeof logger[handler] === 'function')
-        worker.supervisor.on(ev, logger[handler].bind(logger));
+        worker.addSupervisorEventListener(ev, logger[handler].bind(logger));
     }
 
     worker.on('sandbox', (sandbox) => {

package/lib/worker-loggers/console.js

@@ -9,12 +9,34 @@
 
 require('./common-types');
 
-/** @type {WorkerLogger} */
+/**
+ * When this.enhancedDisplay is true
+ *   Sandbox   1:  Slice Started:   slice 1, 0x5b5214D48F0428669c4E: Simple Job
+ *   Sandbox   1:  Slice Completed: slice 1, 0x5b5214D48F0428669c4E: Simple Job: dt 114ms
+ * When this.enhancedDisplay is false
+ *   Sandbox   1:  Slice Started:   0x5b5214D48F0428669c4E68779896D29D77c42903 Simple Job
+ *   Sandbox   1:  Slice Completed: 0x5b5214D48F0428669c4E68779896D29D77c42903 Simple Job
+ * @type {WorkerLogger}
+ */
 const consoleLogger = {
   init(worker, options) {
     this.worker = worker;
-    this.supervisor = worker.supervisor;
     this.options = Object.assign({}, options);
+    this.sliceMap = {};          // jobAddress --> ( sliceNumber, t0 )
+    this.enhancedDisplay = true; // When false, no timing, no sliceNumber, full jobAddress
+    this.truncationLength = 22;  // Extra 2 for '0x'
+  },
+
+  id (sandbox, sliceNumber) {
+    if (!this.enhancedDisplay)
+      return sandbox.public ? `${sandbox.jobAddress} ${sandbox.public.name}` : `${sandbox.jobAddress}`;
+
+    const address = sandbox.jobAddress ? sandbox.jobAddress.slice(0, this.truncationLength) : 'null';
+    const baseInfo = sandbox.public ? `${address}: ${sandbox.public.name}` : `${address}:`;
+
+    if (!sliceNumber)
+      sliceNumber = sandbox.slice ? sandbox.slice.sliceNumber : 0;
+    return sliceNumber ? `slice ${sliceNumber}, ${baseInfo}` : baseInfo;
   },
 
   onSandboxReady(sandbox) {
@@ -29,21 +51,28 @@ const consoleLogger = {
     return sandboxData;
   },
 
-  sandbox$onSliceStart(sandbox, sandboxData, slice) {
-    console.log(` * Sandbox ${sandboxData.shortId}:  Slice Started:   ${sandbox.jobAddress} ${sandbox.public.name}`);
+  sandbox$onSliceStart(sandbox, sandboxData, ev) {
+    const sliceNumber = sandbox.slice ? sandbox.slice.sliceNumber : 0;
+    this.sliceMap[sandbox.id] = { slice: sliceNumber, t0: Date.now() };
+    console.log(` * Sandbox ${sandboxData.shortId}:  Slice Started:   ${this.id(sandbox)}`);
   },
 
   sandbox$onSliceProgress(sandbox, sandboxData, ev) {
     // something
   },
-  
+
   sandbox$onSliceFinish(sandbox, sandboxData, ev) {
-    console.log(` * Sandbox ${sandboxData.shortId}:  Slice Completed: ${sandbox.jobAddress} ${sandbox.public.name}`);
+    const sliceInfo = this.sliceMap[sandbox.id];
+    if (sliceInfo && this.enhancedDisplay)
+      console.log(` * Sandbox ${sandboxData.shortId}:  Slice Completed: ${this.id(sandbox, sliceInfo.slice)}: dt ${Date.now() - sliceInfo.t0}ms`);
+    else
+      console.log(` * Sandbox ${sandboxData.shortId}:  Slice Completed: ${this.id(sandbox)}`);
   },
 
-  sandbox$onWorkerStop(sandbox, sandboxData, _event) {
-    const job = sandbox.public ? `${sandbox.jobAddress} ${sandbox.public.name}` : sandbox.job;
-    console.log(` * Sandbox ${sandboxData.shortId}:  Terminated:      ${job}`);
+  sandbox$onWorkerStop(sandbox, sandboxData, ev) {
+    const sliceInfo = this.sliceMap[sandbox.id];
+    delete this.sliceMap[sandbox.id];
+    console.log(` * Sandbox ${sandboxData.shortId}:  Terminated:      ${this.id(sandbox, sliceInfo?.slice)}`);
   },
 
   onPayment({ payment }) {
@@ -62,7 +91,7 @@ const consoleLogger = {
   },
 
   onFetchedSlices(ev) {
-    this.options.verbose && console.log(" * Fetched", ev, 'slices');
+    this.options.verbose && console.log(" * Fetched", ev);
   },
 
   onFetchSlicesFailed(ev) {

package/lib/worker-loggers/dashboard.js

@@ -28,7 +28,6 @@ const dashboardLogger = {
   init(worker, options) {
     this.worker = worker;
     this.options = options;
-    this.supervisor = worker.supervisor;
     this.totalDCCs = 0;
     this.sliceFetchStatus = SLICE_FETCH_STATUS.IDLE;
     exports.screen = this.screen = blessed.screen();
@@ -57,7 +56,7 @@ const dashboardLogger = {
 
     this.sandboxes = grid.set(0, 0, 2, 2, components.sandboxes, {
       label: 'Sandboxes',
-      defaultProgressBars: this.supervisor.maxWorkingSandboxes,
+      defaultProgressBars: this.worker.cpuCores,
       scrollable: true,
       alwaysScroll: true,
       mouse: true,
@@ -69,7 +68,7 @@ const dashboardLogger = {
     this.workerInfo = grid.set(2, 0, 1, 5, blessed.text);
     this.updateWorkerInfo();
 
-    setInterval(() => this.screen.render(), 1000).unref();
+    setInterval(() => this.screen.render(), 50).unref(); /* 50ms = 20 fps */
 
     function raise(sig)
     {
@@ -79,7 +78,7 @@ const dashboardLogger = {
     /* Apply key bindings which mimic canonical input mode */
     this.screen.key(['C-c'], () => raise('SIGINT'));
     this.screen.key(['C-z'], () => raise('SIGTSTP'));
-    this.screen.key(['C-\\'], () => raise('SIGQUIT'));
+    this.screen.key(['\u001c'], () => raise('SIGQUIT')); /* C-\ */
 
     this.screen.key(['escape'], () => {
       console.log('Stopping worker...');
@@ -96,8 +95,8 @@ const dashboardLogger = {
       '',
       `   Scheduler: ${chalk.yellow(dcpConfig.scheduler.location.href)}`,
       `        Bank: ${chalk.yellow(dcpConfig.bank.location.href)}`,
-      `Bank Account: ${chalk.yellow(this.supervisor.paymentAddress || 'Starting...')}`,
-      `    Identity: ${chalk.yellow(this.supervisor.identityKeystore? this.supervisor.identityKeystore.address : 'Starting...')}`,
+      `Bank Account: ${chalk.yellow(this.worker.paymentAddress || 'Starting...')}`,
+      `    Identity: ${chalk.yellow(this.worker.identityKeystore? this.worker.identityKeystore.address : 'Starting...')}`,
       `        Jobs: ${workerOptions.jobAddresses?.length ? workerOptions.jobAddresses.join(', ') : '<any>'}`,
       ` Priv Groups: ${Object.keys(workerOptions.computeGroups).length}`,
       `   Pub Group: ${workerOptions.leavePublicGroup ? 'no' : 'yes'}`,

package/npm-hooks/prepack

@@ -1,17 +1,21 @@
-#! /bin/bash
-#
-# @file         prepack
-#               Hook which generates the config md5 on pack (or publish)
-# @author       Wes Garland, wes@distributive.network
-# @date         April 2023
-#
-set -e
-set -u
-set -o pipefail
+#! /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
+ */
 
-cd `dirname "$0"`/..
+const fs = require('fs');
+const process = require('process');
+const path = require('path');
 
-(
-  md5sum etc/dcp-worker-config.js
-  echo "### DO NOT MODIFY THIS FILE!!! ###"
-) > etc/dcp-worker-config.js.md5
+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');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcp-worker",
-  "version": "3.2.28-2",
+  "version": "3.2.28",
   "description": "JavaScript portion of DCP Workers for Node.js",
   "main": "bin/dcp-worker",
   "keywords": [
@@ -12,13 +12,10 @@
   },
   "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": "Kings Distributed Systems",
-  "engines": {
-    "node": ">=14.0.0"
-  },
   "bin": {
     "dcp-evaluator-start": "bin/dcp-evaluator-start",
     "dcp-worker": "bin/dcp-worker"
@@ -30,8 +27,9 @@
   "scripts": {
     "start": "node bin/dcp-worker start",
     "start-evaluator": "node bin/dcp-evaluator-start",
+    "hook": "PATH=npm-hooks:$PATH &&",
     "test": "peter tests",
-    "x-prepack": "npm-hooks/prepack",
+    "prepack": "node npm-hooks/prepack",
     "postpublish": "npm-hooks/postpublish",
     "prepublishOnly": "npm-hooks/prepublish"
   },
@@ -39,14 +37,18 @@
     "blessed": "^0.1.81",
     "blessed-contrib": "^4.11.0",
     "chalk": "^4.1.0",
-    "dcp-client": "^4.2.30",
+    "dcp-client": "4.2.31",
     "semver": "^7.3.8"
   },
   "optionalDependencies": {
     "telnet-console": "^1.0.4"
   },
   "devDependencies": {
-    "@kingsds/eslint-config": "1.0.1",
+    "@kingsds/eslint-config": "^1.0.1",
     "eslint": "7.30.0"
+  },
+  "engines": {
+    "node": ">=16",
+    "npm": ">=6"
   }
 }