dcp-worker 3.2.32 → 3.2.34

package/.eslintrc.js

@@ -0,0 +1,31 @@
+/**
+ * @file    .eslintrc.js - ESLint configuration file, following the Core Team's JS Style Guide.
+ *
+ * @author  Wes Garland <wes@distributive.network>
+ * @author  Bryan Hoang <bryan@distributive.network>
+ * @date    Mar. 2022, Sep. 2023
+ */
+
+'use strict';
+
+/**
+ * @see {@link https://eslint.org/docs/latest/use/configure/}
+ * @type {import('eslint').Linter.Config}
+ */
+module.exports = {
+  root: true,
+  reportUnusedDisableDirectives: true,
+  extends: ['eslint:recommended', '@distributive'],
+  env: {
+    node: true,
+    es2022: true,
+  },
+  globals: {
+    dcpConfig: true,
+  },
+  parserOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'script',
+  },
+  rules: {},
+};

package/.gitlab-ci.yml

@@ -1,23 +1,70 @@
 # @file    .gitlab-ci.yml - GitLab CI configuration file.
 # @author  Eddie Roosenmallen <eddie@distributive.network>
+# @author  Bryan Hoang <bryan@distributive.network>
 # @date    September 2022
 
+variables:
+  # Can't cache `~/.npm/`.
+  npm_config_cache: '.cache/npm/'
+  npm_config_prefer_offline: 'true'
+  npm_config_fund: 'false'
+
 default:
   # Use in-house GitLab runners.
   tags:
-    - dcp
+    - dcp-core
     - linux
+  image: node:lts
+  before_script:
+    - npm add --global npm@latest
+    # Access private deps. e.g., `dcp-client` from GitLab.
+    - git config --global
+      url."${CI_SERVER_PROTOCOL}://gitlab-ci-token:${CI_JOB_TOKEN}@${CI_SERVER_HOST}:${CI_SERVER_PORT}".insteadOf
+      "${CI_SERVER_URL}"
+
+workflow:
+  rules:
+    # Only run branch pipelines for `develop`, or merge request pipelines.
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
 
 stages:
   - build
+  - test
   - deploy
 
+# Installs npm dependencies to be cached for subsequent jobs. Also checks that
+# the lock file is synced with the manifest file.
+build:
+  stage: build
+  script:
+    - npm clean-install
+  cache:
+    - key:
+        prefix: $CI_JOB_NAME_SLUG
+        files:
+          - package-lock.json
+      paths:
+        - $npm_config_cache
+    - key:
+        prefix: node-modules
+        files:
+          - package-lock.json
+      paths:
+        - node_modules/
+      policy: push
+
 tidelift:
   stage: build
+  rules:
+    - when: never
   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
+  inherit:
+    default:
+      - tags
   # The CLI only requires `glibc`.
   image: frolvlad/alpine-glibc
   before_script:
@@ -30,9 +77,39 @@ tidelift:
     - echo "Running alignment and saving to Tidelift"
     - ./tidelift alignment save --wait
   allow_failure: true
-  cache: []
+
+# Run `trunk check` on the project to hightlight newly introduced lint issues
+# when compared to the target branch.
+check:
+  variables:
+    # Can't cache `~/.cache/trunk/`.
+    TRUNK_CACHE: ${CI_PROJECT_DIR}/.cache/trunk/
+  stage: test
+  script:
+    - UPSTREAM_BRANCH=${CI_MERGE_REQUEST_TARGET_BRANCH_NAME:-$CI_DEFAULT_BRANCH}
+    # Fetch the branch so that `trunk` has the proper information needed to
+    # determine the upstream changes to compare lint results against.
+    - git fetch origin $UPSTREAM_BRANCH
+    - npm run check -- --ci --upstream origin/$UPSTREAM_BRANCH
+  cache:
+    - key:
+        prefix: $CI_JOB_NAME_SLUG
+        files:
+          - .trunk/trunk.yaml
+      paths:
+        - $TRUNK_CACHE
+    - key:
+        prefix: node-modules
+        files:
+          - package-lock.json
+      paths:
+        - node_modules/
+      policy: pull
 
 publish_docs:
+  stage: deploy
+  needs:
+    - build
   rules:
     - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH
       changes:
@@ -51,8 +128,14 @@ publish_docs:
     ENTITY_NAMESPACE: 'default'
   stage: deploy
   needs: []
-  image: registry.gitlab.com/distributed-compute-protocol/docker/dcp-ci:2023-09-13
+  image: registry.gitlab.com/distributed-compute-protocol/backstage-ci-image:latest
   script:
-    - npm clean-install
-    - python3 -m pip install mkdocs mkdocs-techdocs-core==1.* mkdocs-same-dir
     - bin/publish-docs.sh
+  cache:
+    - key:
+        prefix: node-modules
+        files:
+          - package-lock.json
+      paths:
+        - node_modules/
+      policy: pull

package/.trunk/trunk.yaml

@@ -0,0 +1,29 @@
+# @file    trunk.yaml - This file controls the behavior of Trunk:
+#                       https://docs.trunk.io/cli
+#
+#                       To learn more about the format of this file, see
+#                       https://docs.trunk.io/reference/trunk-yaml
+#
+#                       Initially autogenerated by `npm exec -- trunk init --lock`
+#
+# @author  Bryan Hoang <bryan@distributive.network>
+# @date    Oct. 2023
+
+version: 0.1
+cli:
+  version: 1.17.1
+  sha256:
+    darwin_arm64: 707359316ea1f972cbad8a77cb076449155c19d42933cecfe5b70cfefc38d085
+    darwin_x86_64: d5e5928a24a4eb9931eaed1d5899be12ab2556f17ce5cd89ef73fa42b2293c88
+    linux_x86_64: f2bbf8de19e7961390633fe23599b8890f617a6e8b2563ac6741a0514e7d16e6
+plugins:
+  sources:
+    - id: trunk
+      ref: v1.2.6
+      uri: https://github.com/trunk-io/plugins
+runtimes:
+  enabled:
+    - node@18.12.1
+lint:
+  enabled:
+    - eslint@8.52.0

package/bin/dcp-evaluator-manager

@@ -0,0 +1,512 @@
+#! /usr/bin/env node
+/**
+ * @file        dcp-evaluator-manager
+ *              Daemon to monitor the state of the system and enable/disable 
+ *              the evaluator as appropriate.
+ *
+ *              The actual mechanics of communicating with the evaluator is
+ *              similar in principle to how inetd works, and the code is, in
+ *              fact, based on the dcp inet-daemon.
+ *
+ *              The methods the system can be monitored include:
+ *              - screensaver enabled/disabled
+ *
+ * @author      Wes Garland, wes@distributive.network
+ * @date        June 2018, Sep 2022
+ */
+'use strict';
+
+const os     = require('os');
+const fs     = require('fs');
+const path   = require('path');
+const net    = require('net')
+const dns    = require('dns');
+const debug  = require('debug');
+const getopt = require('posix-getopt');
+
+var userActivity = { /* no props true => okay to launch evaluator */
+  screensaver: true,
+  session:     true,
+};
+var children;
+var seq = 0;
+var ptsDir = '/dev/pts';
+var lastConnectionMs = 0;
+
+const defaultPrefix = '/usr';
+const daemonConfig = {
+  net:  new URL('tcpip://localhost:9000/'),
+  proc: require.resolve('./dcp-evaluator-start'),
+  argv: [ '-s', '--prefix', `${path.resolve(defaultPrefix)}/` ],
+  limits: {},
+  session: {
+    idlePoll:    3,  /* s between checks*/
+    idleTimeout: 30, /* s to decide the session really IS idle */
+  }
+};
+
+function usage()
+{
+  console.log(
+`
+DCP Evaluator Monitor - Copyright (c) 2022-2023 Distributive Corp.
+Released under the terms of the MIT License.
+
+Usage: ${process.argv[0]} [-h | --help] [--prefix=<dir>] [--pts=<dir>] [-a] 
+       [--disable-monitor=<session|screensaver>] [-i <timeout>] [-p port]
+       [-l | --max-load=<number>] [-r | --rate=<number>] [-L]
+       [-- <options to dcp-evaluator-start, must be last option>]
+Where:
+ - -i sets the idle timeout in seconds for tty sessions (${daemonConfig.session.idleTimeout}s)
+ - -p specifies the port to listen on for dcpsaw: worker connections (${daemonConfig.net.port})
+ - --prefix specifies the directory where the DCP evaluator was installed
+ - --pts specifies the location of the system's pseudo terminal (${ptsDir})
+ - --disable-monitor=session disables monitoring of ssh/telnet/etc sessions
+ - --disable-monitor=screensaver disables monitoring of the screensaver
+ - -a means always run the evaluator, even when the monitors say the machine is busy
+ - --max-load specifies the point at which machine load prevents connections
+ - --rate specifies the minimum number of seconds between connections
+ - -L only apply the limits when the monitors say the machine is busy
+`);
+
+  process.exit(0);
+}
+
+/**
+ * Establish listening socket evaluator proxy 
+ */
+async function listenForConnections(config)
+{
+  var server = net.createServer((socket) => handleConnection(socket, config));
+  var hostaddr;
+  
+  if (config.net.hostname === 'localhost')
+    hostaddr = '::';
+  else
+    hostaddr = await dns.promises.lookup(config.net.hostname, { family: 4 });
+
+  server.on('error', (error) => {
+    delete error.stack;
+    console.error(error);
+    process.exit(2);
+  });
+
+  server.listen({ host: hostaddr, port: config.net.port }, function daemonReady() {
+    console.log('Listening for connections on', server._connectionKey);
+    console.log('Evaluator command is', config.proc, config.argv);
+  });
+}
+
+/**
+ * Check the state of the userActivity object to determine if there has been user activity
+ * on the system. If there has been, it returns a string of activity types. If there
+ * hasn't, it returns false and we are clear to evaluate.
+ */
+function checkUserActivity()
+{
+  var active = [];
+
+  for (let prop in userActivity)
+  {
+    if (userActivity[prop])
+      active.push(prop);
+  }
+
+  if (active.length)
+    debug('dcp-evaluator-manager')('System is not idle; activity detected via', active.join(', '));
+  else
+    debug('dcp-evaluator-manager')('System is idle; checked', Object.entries(userActivity).filter(a => a[1] !== null).map(a => a[0]).join(', '));
+  
+  return active.length ? active.join() : false;
+}
+
+/**
+ * Handle an incoming connection. If the screensaver is not active, the conneciton
+ * is immediately rejected. Otherwise, we spin up an evaluator process and proxy its
+ * stdio to the socket.
+ */
+function handleConnection (socket, config)
+{
+  var child;
+  var userActivityMemo = checkUserActivity();
+  
+  function cleanup()
+  {
+    try
+    {
+      if (socket)
+      {
+        socket.end();
+        socket.destroy();
+        socket = null;
+      }
+    }
+    finally
+    {
+      if (child)
+      {
+        child.kill();
+        if (children.includes(child))
+          children.delete(child);
+      }
+    }
+  }
+
+  if (userActivityMemo && !daemonConfig.limits.onlyWhenBusy)
+  {
+    debug('dcp-evaluator-manager')(`New connection; closing due to activity (${userActivityMemo})`);
+    cleanup();
+    return;
+  }
+
+  if (!daemonConfig.limits.onlyWhenBusy || (daemonConfig.limits.onlyWhenBusy && userActivityMemo))
+  {
+    if (daemonConfig.limits.maxLoad < os.loadavg()[0])
+    {
+      debug('dcp-evaluator-manager')(`New connection; closing due to system load (${os.loadavg().join(', ')})`);
+      cleanup();
+      return;
+    }
+
+    if (daemonConfig.limits.rateMs > (Date.now() - lastConnectionMs))
+    {
+      debug('dcp-evaluator-manager')(`New connection; closing due to rate-limit ${daemonConfig.limits.rateMs} > ${Date.now() - lastConnectionMs}`);
+      cleanup();
+      return;
+    }
+  }
+  
+  debug('dcp-evaluator-manager')('New connection; spawning ', config.proc, config.argv);
+  lastConnectionMs = Date.now();
+  
+  child = require('child_process').spawn(config.proc, config.argv);
+  child.stderr.setEncoding('ascii')
+  child.socket = socket;
+  children.add(child);
+  child.id = ++seq;
+  debug('dcp-evaluator-manager')(`Spawned worker process ${child.pid} for child ${child.id}`);
+
+  socket.on('end', function socketEnd() {
+    debug('dcp-evaluator-manager')('Socket end; killing child', child.id);
+    cleanup();
+  });
+
+  socket.on('error', function socketError(error) {
+    debug('dcp-evaluator-manager')(`Socket error ${error.code}; killing child`, child.id);
+    debug('dcp-evaluator-manager')(error);
+    cleanup();
+  });
+
+  child.on('error', function childError(error) {
+    console.error('Error from worker ' + child.id + ':', error);
+    cleanup();
+  });
+
+  child.on('exit', function(code) {
+    debug('dcp-evaluator-manager')(`child ${child.id} exited; closing socket`, code || '');
+    cleanup();
+  });
+
+  child.stdout.on('data', function (data) {
+    debug('dcp-evaluator-manager:network')('<', child.id, bufToDisplayStr(data), 93);
+    if (socket)
+      socket.write(data)
+  });
+
+  child.stderr.on('data', function (data) {
+    console.log('child ' + child.id + ' stderr: ', data);
+  });
+
+  socket.on('data', function (data) {
+    debug('dcp-evaluator-manager:network')('>', child.id, bufToDisplayStr(data, 93));
+
+    try
+    {
+      child.stdin.write(data)
+    }
+    catch (error)
+    {
+      console.warn('could not write to child process (', child.pid, ', index', child.id, ') stdin')
+      throw error;
+    }
+  });
+}
+
+/** 
+ * Format detailed debug output of raw socket traffic
+ */
+function bufToDisplayStr (buf, limit)
+{
+  const str = buf.toString('utf-8').replace(/\n/, '\u2424').toString('utf-8');
+
+  if (typeof limit === 'number' && str.length > limit)
+    return str.substr(0, limit) + '\u2026';
+  else
+    return str;
+}
+
+/**
+ * Kill all evaluators, as quickly as possible.
+ */
+function killChildren()
+{
+  if (!children.length)
+    return;
+
+  debug('dcp-evaluator-manager')(`Terminating all (${children.length}) running evaluators..`);
+  for (let child of children)
+  {
+    debug('dcp-evaluator-manager')(`killing child ${child.pid}`);
+    try
+    {
+      child.kill('SIGKILL');
+    }
+    catch(error)
+    {
+      /* Don't throw if process death race */
+      if (error.code !== 'ESRCH')
+        throw error;
+    }
+  }
+}
+
+/** 
+ * Monitor dbus messages for screensaver start / stop events.
+ */
+async function dbusScreenSaverMonitor()
+{
+  const dbus = odRequire('dbus-next');
+  const bus = dbus.sessionBus();
+  const screensaverList = [
+    'org.gnome.ScreenSaver',
+    'org.cinnamon.ScreenSaver',
+    'org.kde.screensaver',
+    'org.freedesktop.ScreenSaver'
+  ];
+  var iface;
+
+  for (let ss of screensaverList)
+  {
+    try
+    {
+      let obj = await bus.getProxyObject(ss, '/' + ss.replace(/\./g, '/'));
+      if (obj)
+      {
+        iface = obj.interfaces[ss];
+        break;
+      }
+    }
+    catch (error)
+    {
+      debug('dcp-evaluator-manager:dbus')('Could not acquire screensaver', ss + '; trying next', error);
+    }
+  }
+
+  if (!iface)
+  {
+    console.error('Could not open dbus session to any screensaver, tried', screensaverList);
+    process.exit(3);
+  }
+
+  const ssActive = await iface.GetActive();
+  debug('dcp-evaluator-manager')('Screen saver active:', ssActive);
+  userActivity.screensaver = ssActive ? false : 'active dbus screensaver (initial)';
+
+  /* screensaver not active => user activity */
+  iface.on('ActiveChanged', function screenSaverChangeHandler(active) {
+    userActivity.screensaver = active ? false : 'active dbus screensaver (change)';
+    debug('dcp-evaluator-manager')(`screen saver ${active ? 'started' : 'finished'} at`, new Date());
+    if (!daemonConfig.limits.onlyWhenBusy && checkUserActivity())
+      killChildren();
+  });
+
+  console.log('Monitoring dbus messages for', iface.$name);
+}
+
+/* Activate screensaver monitor. Promise resolves when the initial state has been figured out. */
+function screensaverMonitor()
+{
+  if (userActivity.screensaver === null) /* disabled */
+    return;
+
+  return dbusScreenSaverMonitor();
+}
+
+/**
+ * Activate session monitor - mechanism is similar to last/fingerd, where we check the last
+ * update time on all ttys to see if there is a remote user using the system or not. We poll
+ * this every idleTimeout (15?) seconds, when the screen saver is active.
+ */
+function sessionMonitor()
+{
+  const myTTY = fs.realpathSync('/dev/stdout');
+  
+  if (userActivity.session === null) /* disabled */
+    return;
+
+  function checkSessions()
+  {
+    const recentMs = Date.now() - (daemonConfig.session.idleTimeout * 1000);
+
+    userActivity.session = false;
+    for (let dent of fs.readdirSync(ptsDir, { withFileTypes: true }))
+    {
+      if (!dent.isCharacterDevice())
+        continue;
+
+      const fullPath = path.join(ptsDir, dent.name);
+      debug('dcp-evaluator-manager:session')(`Checking TTY ${fullPath}`);
+      if (fullPath === myTTY)
+        continue;
+
+      const sb = fs.statSync(fullPath);
+      if (sb.atimeMs > recentMs)
+      {
+        /* Experiment suggests atime involves reads and mtime includes writes. Using mtime so that 
+         * tailing logs has anticipated result.
+         */
+        userActivity.session = fullPath;
+        debug('dcp-evaluator-manager:session')(`TTY ${fullPath} is active`);
+        break;
+      }
+    }
+
+    if (!daemonConfig.limits.onlyWhenBusy && checkUserActivity())
+      killChildren();
+  }
+
+  setInterval(checkSessions, daemonConfig.session.idlePoll * 1000);
+  checkSessions();
+}
+
+/* Require an optional dependency, print decent error message if not found, then exit. */
+function odRequire(moduleId)
+{
+  try
+  {
+    return require(moduleId);
+  }
+  catch(error)
+  {
+    if (error.code !== 'MODULE_NOT_FOUND')
+      throw error;
+  }
+
+  console.error(`Screensaver operating mode requires optional dependency ${moduleId}.`);
+  console.error(`Please \`npm i ${moduleId}\` and try again.`);
+  process.exit(2);
+}
+
+/* Main program entry point */
+async function main()
+{
+  const parser = new getopt.BasicParser('h(help)P:(prefix)d:(disable-monitor)l:(max-load)r:(rate)Li:ap:', process.argv);
+  var option;
+  
+  while ((option = parser.getopt()) !== undefined)
+  {
+    switch (option.option)
+    {
+      case 'h':
+        usage();
+        break;
+      
+      default:
+        throw new Error('defined but unspecified option', option);
+
+      case '?':
+        process.exit(1);
+
+      case 'P':
+      {
+        const re = new RegExp(`^${defaultPrefix}/`);
+        for (let i=0; i < daemonConfig.argv.length; i++)
+          daemonConfig.argv[i] = daemonConfig.argv[i].replace(re, path.resolve(option.optarg + '/'));
+        break;
+      }
+
+      case 'd':
+      {
+        let what = option.optarg;
+
+        if (what[0] === '=')
+          what = what.slice(1);
+        userActivity[what] = null; /* null => do not check for this */
+        debug('dcp-evaluator-manager')('!', what, 'monitor is disabled');
+        break;
+      }
+
+      case 'i':
+      {
+        daemonConfig.session.idleTimeout = Number(option.optarg).toFixed(1);
+        break;
+      }
+
+      case 'a': /* always on => disable everything */
+      {
+        for (let prop in userActivity)
+        {
+          if (userActivity.hasOwnProperty(prop))
+            userActivity[prop] = null;
+        }
+        break;
+      }
+
+      case 'L':
+      {
+        daemonConfig.limits.onlyWhenBusy = true;
+        break;
+      }
+
+      case 'p':
+      {
+        daemonConfig.net.port = Number(option.optarg);
+        break;
+      }
+
+      case 'l':
+      {
+        daemonConfig.limits.maxLoad = Number(option.optarg);
+        break;
+      }
+
+      case 'r':
+      {
+        daemonConfig.limits.rateMs = 1000 * Number(option.optarg);
+        break;
+      }
+    }
+  }
+
+  daemonConfig.argv = daemonConfig.argv.concat(process.argv.slice(parser.optind())); /* All options after -- pass to dcp-evaluator-start */
+  
+  process.on('uncaughtException', function (error) {
+    console.error('\n---', (new Date()).toLocaleString(), '-------------------------------------------------')
+    console.error('uncaught exception:', error.stack)
+    console.error('\n')
+  });
+
+  process.on('unhandledRejection', function (error) {
+    console.error('\n---', (new Date()).toLocaleString(), '-------------------------------------------------')
+    console.error('unhandled rejection:', error.stack)
+    console.error('\n')
+  })
+
+  children = new (require('dcp/utils').Inventory)();
+
+  await screensaverMonitor();
+  sessionMonitor();
+
+  listenForConnections(daemonConfig);
+}
+
+/* Initialize dcp-client to use only local resources before launching the main function */
+require('dcp-client').init({
+  progName: 'dcp-worker',
+  parseArgv: false,
+  configName: process.env.DCP_CONFIG || '../etc/dcp-worker-config',
+  dcpConfig: {
+    scheduler: { configLocation: false },
+    bundle:    { location: false },
+  }
+}).then(main);

package/bin/dcp-worker

@@ -155,9 +155,10 @@ function parseCliArgs()
         type: 'number',
         group: 'Output options',
       },
-      eventDebug: {
-        hidden: true,
-        describe: 'If set, dump all sandbox and worker events',
+
+      showConfig: {
+        hide: false,
+        describe: 'Show merged configuration node (eg worker)',
       },
 
       logfile: {
@@ -219,6 +220,12 @@ function parseCliArgs()
   .wrap(process.stdout.columns || 80)
   .argv;
 
+  if (cliArgs.showConfig)
+  {
+    console.log(eval('dcpConfig.' + cliArgs.showConfig));
+    process.exit();
+  }
+
   if (cliArgs.dumpConfig)
   {
     console.log(JSON.stringify(require('dcp/dcp-config'), null, 2));
@@ -391,9 +398,6 @@ async function main()
   else
     worker.on('end', () => setTimeout(processExit, getCleanupTimeoutMs()).unref());
 
-  if (cliArgs.eventDebug)
-    worker.enableDebugEvents = true;
-
   if (dcpWorkerOptions.publicGroupFallback)
   {
     if (dcpWorkerOptions.leavePublicGroup)
@@ -449,8 +453,6 @@ async function main()
     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';
   if (telnetd.hasOwnProperty('port'))
     introBanner += ` ! telnetd listening on port ${telnetd.port}\n`;
   

package/bin/publish-docs.sh

@@ -67,8 +67,8 @@ npx techdocs-cli publish \
   --publisher-type awsS3 \
   --storage-name "$TECHDOCS_S3_BUCKET_NAME" \
   --entity "$ENTITY_NAMESPACE"/"$ENTITY_KIND"/"$ENTITY_NAME" \
-  --directory "$ROOT_DIR"/site
+  --directory "$DOCS_DIR"/site
 
-rm -r "$ROOT_DIR"/site
+rm -r "$DOCS_DIR"/site
 
 echo "View generated component: https://backstage.overwatch.distributive.network/docs/default/component/$ENTITY_NAME"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcp-worker",
-  "version": "3.2.32",
+  "version": "3.2.34",
   "description": "JavaScript portion of DCP Workers for Node.js",
   "main": "bin/dcp-worker",
   "keywords": [
@@ -17,6 +17,7 @@
   "license": "MIT",
   "author": "Kings Distributed Systems",
   "bin": {
+    "dcp-evaluator-manager": "bin/dcp-evaluator-manager",
     "dcp-evaluator-start": "bin/dcp-evaluator-start",
     "dcp-worker": "bin/dcp-worker"
   },
@@ -25,9 +26,11 @@
     "etc": "etc"
   },
   "scripts": {
+    "check": "trunk check",
     "start": "node bin/dcp-worker start",
     "start-evaluator": "node bin/dcp-evaluator-start",
     "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",
@@ -37,17 +40,22 @@
     "blessed": "^0.1.81",
     "blessed-contrib": "^4.11.0",
     "chalk": "^4.1.0",
-    "dcp-client": "4.3.2",
+    "dcp-client": "4.3.4",
+    "kvin": "^1.2.7",
+    "posix-getopt": "^1.2.1",
     "semver": "^7.3.8",
     "syslog-client": "1.1.1"
   },
   "optionalDependencies": {
+    "dbus-next": "^0.10.2",
     "telnet-console": "^1.0.4"
   },
   "devDependencies": {
+    "@distributive/eslint-plugin": "1.0.2",
     "@kingsds/eslint-config": "^1.0.1",
-    "@techdocs/cli": "1.4.6",
-    "eslint": ">=8"
+    "@trunkio/launcher": "1.2.7",
+    "eslint": ">=8",
+    "eslint-plugin-jsdoc": "46.8.2"
   },
   "peerDependencies": {
     "node-eventlog": "https://gitpkg.now.sh/Distributive-Network/node-eventlog/package?dcp/0.0.1"
@@ -60,5 +68,8 @@
   "engines": {
     "node": ">=18",
     "npm": ">=7"
+  },
+  "overrides": {
+    "@azure/msal-node": "2.2.0"
   }
 }

package/.eslintrc.json

@@ -1,12 +0,0 @@
-{
-  "env": {
-    "commonjs": true,
-    "es2021": true,
-    "node": true
-  },
-  "extends": ["@kingsds"],
-  "parserOptions": {
-    "ecmaVersion": 12
-  },
-  "rules": {}
-}