dcp-worker 4.3.7 → 4.4.0

package/lib/web-iface.js

@@ -1,128 +1,532 @@
 /**
- * https://stackoverflow.com/questions/52843900/blessed-server-node-js-over-websocket-to-xterm-js-client-in-browser
+ * @file     web-iface.js - Web Interface for dcp-worker
+ * @author   Wes Garland, wes@distributive.network
+ * @date     July 2025
+ *
+ * @description
+ * This file sets up a daemon listening on localhost:9080 by default, which functions as a DCP Target.
+ *
+ * The security model is:
+ * 1. if the worker is unregistered, only the register command is supported, and anybody on the same
+ *    local network as the worker can invoke it.
+ * 2. if the worker is registered, only commands sent by the registered owner are supported. This
+ *    include the register command.  "Same owner" is determined by the following algorithm:
+ *    - Target receives DCP connection from Initiator (eg portal dcp-client on same host)
+ *    - Initiator makes Request: signed message X that has messageId containing dcpsid
+ *       - worker ensures X.messageId starts with dcpsid
+ *       - worker sends message M to althea owner-check operation
+ *       - M includes { innerMessage: X, operationKey: entity.worker, related: workerId }
+ *       - althea compares peerAddress{entity.worker, r=workerId} and X.owner{entity.worker, r=workerId}
+ *     - Althea sends Response: ok (or close connection when compare does not match)
+ *   - Target memoizes connection as "good"
+ *   - Initiator makes Request: tell me all your secrets
+ *   - Target sends Response: connection "good" ? response with secrets : close connection
+ *
+ *    Note: abc{ok,r=xyz} means "the deproxied address of abc for operation key ok" with pxa related=xyz
  */
-const blessed = require('blessed');
-const contrib = require('blessed-contrib');
-const path    = require('path');
-const fs      = require('fs');
-const http    = require('http');
+'use strict';
+const path        = require('path');
+const fs          = require('fs');
+const process     = require('process');
+const querystring = require('querystring');
+const debug       = require('debug');
 
-const progDir = path.dirname(require.main.filename);
-const wwwDir  = path.resolve(progDir, '../www');
-const nmDir   = path.resolve(progDir, '../node_modules');
-const listenHost = listenUrl.hostname === 'localhost' ? '::' : listenUrl.hostname;
+const bootDate = new Date();
+var worker;
+var totalEarnings = 0;
 
-const magic = {
-  html: 'text/html',
-  txt:  'text/plain',
-  js:   'application/javascript',
-  css:  'text/css',
-  gif:  'image/gif',
-  jpeg: 'image/jpeg',
-  jpg:  'image/jpeg',
-  png:  'image/png',
-  svg:  'image/svg+xml',
-  kvin: 'application/x-kvin',
-}
+/** Configuration for the server, must be mutated before a$init */
+exports.config = { hostname: 'localhost', port: 9080 };
+
+/**
+ * Web server initialization.
+ * @param {DistributiveWorker} __worker
+ * @returns {Promise} that is resolved when the server is listening
+ */
+exports.a$init = function init(__worker)
+{
+  const protocol = require('dcp/protocol');
+  const identity = require('dcp/identity');
+  var p$target, reject;
+
+  try
+  {
+    worker = __worker;
+    console.info(` . Starting management service on ${exports.config.hostname}:${exports.config.port}`);
+    const target = new protocol.Target(
+      ['socketio'],
+      {
+        identity: identity.get(),
+        listen: new URL(`http://${exports.config.hostname}:${exports.config.port}/dcp/`),
+      },
+      listeningHandler,
+      { socketio: { module: require('socket.io') } },
+    );
+    target.constructor.setBufferCtor(Buffer);
+    target.on('error', (error) => {
+      console.error('Management service error:', error.message);
+      reject(error);
+    });
+    target.on('end',        (conn) => debug('dcp-worker:dcp')('connection closed'));
+    target.on('connection', (conn) => debug('dcp-worker:dcp')('new connection'));
+    target.on('session',    (conn) => debug('dcp-worker:dcp')('new session'));
+    target.on('session',    (conn) => newSessionHandler(conn, worker));
+    target.on('error',      (error) => console.log('Management service error:', error));
+
+    p$target = new Promise((resolve, __reject) => {
+      reject = __reject;
+      target.on('listening', () => resolve(target));
+      setupWebServer(target);
+    });
+  }
+  catch(error)
+  {
+    throw new Error(`Unable to start management service: ${error.message}`);
+  }
 
-const clients = [ ];
+  worker.on('payment', function trackTotalEarnings(ev) {
+    const payment = parseFloat(ev);
+    if (!isNaN(payment))
+      totalEarnings += payment;
+  });
 
-function makeSkeletonConfig()
+  return p$target;
+}
+
+function listeningHandler()
 {
-  return `window.dcpConfig = {
-  scheduler: {
-    location: new URL('${dcpConfig.scheduler.location.href}'),
-  },
-const listenUrl = dcpConfig.webConsole.listen;
-  worker: (${JSON.stringify(dcpConfig.worker)})
-}`;
+  debug('dcp-worker:dcp')('web interface listening');
 }
 
 /**
- * HTTP server
+ * Handle new session on connection conn from application connected over dcp to management web server.
+ * Implements an event relay for events of worker.
  */
-var server = http.createServer(handleHttpRequest).unref();
-function handleHttpRequest(request, response)
+function newSessionHandler(conn, _worker)
 {
-  if (request.url === '/etc/dcp-config.js')
+  const KVIN = new (require('dcp/internal/kvin').KVIN)();
+  const capturedEvents = {};
+
+  conn.on('request', request => requestHandler(request, worker));
+  /**
+   * Handle a request; these operations are supported:
+   * - event-on:  capture events for event in request.payload.data, returning eventHandlerId
+   * - event-off: stop capturing events corresponding to eventHandlerId
+   * - task-info: get the current task info object
+   * - run-info:  get the current run info object
+   * Captured events are automatically uncaptured when the connection closes.
+   */
+  function requestHandler(request, _worker)
   {
-    response.setHeader('Content-Type', magic.js);
-    response.end(makeSkeletonConfig());
-    return;
+    try
+    {
+      switch(request.payload.operation)
+      {
+        case 'event-on':
+        {
+          const eventName = request.payload.data;
+          const eventHandler = function workerEventCapture(...args) {
+            const data = {
+              type:     'event',
+              name:     eventName,
+              workerId: worker.id,
+              id:       workerEventCapture.id,
+              kvinArgs: KVIN.stringify(args),
+            };
+            request.connection.notify(data).catch(error => conn.close());
+          };
+          eventHandler.id = request.id.match('[A-Za-z0-9]*$')[0]; /* unique id - used for event-off */
+          capturedEvents[eventHandler.id] = { eventName, eventHandler };
+          worker.setMaxListeners(worker.getMaxListeners() + 1);
+          worker.on(eventName, eventHandler);
+          request.respond({ eventHandlerId: eventHandler.id });
+          break;
+      }
+      case 'event-off':
+      {
+        const eventHandlerId = request.payload.data.eventHandlerId;
+        const { eventName, eventHandler } = capturedEvents[eventHandlerId];
+        delete capturedEvents[eventHandlerId];
+        worker.setMaxListeners(worker.getMaxListeners() - 1);
+        if (!eventHandler)
+          console.error('missing event handler for captured event', eventName, eventHandlerId); /* impossible? */
+        else
+          worker.off(eventName, eventHandler);
+        break;
+      }
+      case 'task-info':
+        request.respond(worker.__stiCache || { jobs: [], tasks: [] });
+        break;
+      case 'run-info':
+        request.respond(runInfoObjectFactory());
+        break;
+      case 'worker-id':
+        request.response(worker.id);
+        break;
+      default:
+        throw new Error(`invalid operation '${request.payload.operation}'`);
+      }
+    }
+    catch(error)
+    {
+      request.respond(error);
+    }
   }
 
-  if (request.url === '/etc/dcp-config.kvin')
+  /* Remove all our worker event handlers when client connection closes */
+  conn.on('end', () => {
+    for (let eventName of Object.keys(capturedEvents))
+    {
+      for (let i=0; i < capturedEvents[eventName].length; i++)
+      {
+        const { eventHandler } = capturedEvents[eventName][i];
+        worker.off(eventName, eventHandler);
+      }
+    }
+  });
+}
+
+const magic = {
+  html:  'text/html',
+  shtml: 'text/html',
+  txt:   'text/plain',
+  js:    'application/javascript',
+  mjs:   'application/javascript',
+  css:   'text/css',
+  gif:   'image/gif',
+  jpeg:  'image/jpeg',
+  jpg:   'image/jpeg',
+  png:   'image/png',
+  svg:   'image/svg+xml',
+  ico:   'image/vnd.microsoft.icon',
+  json:  'application/json',
+  kvin:  'application/x-kvin',
+};
+
+function setupWebServer(app)
+{
+  const identity = require('dcp/identity');
+  const wallet = require('dcp/wallet');
+  const KVIN = new (require('dcp/internal/kvin').KVIN)();
+
+  KVIN.userCtors.dcpEth$$Address = wallet.Address;
+  KVIN.userCtors.dcpUrl$$DcpURL  = require('dcp/dcp-url').DcpURL;
+
+  app.use((req, res) => {
+    const ipAddress = req.socket.address().address;
+    const originalUrl = req.originalUrl;
+
+    let endFired = false;
+    res.on('finish', () => {
+      req = req.httpRequest;
+      res = res.httpResponse;
+      endFired = true;
+      console.log(`${res.statusCode} ${req.method.toUpperCase()} ${req.headers.host} ${originalUrl} ` +
+                  `${ipAddress} ${res._hasBody ? res._contentLength : '-'}`);
+    });
+    res.on('close', () => {
+      if (!endFired)
+        console.log(`${res.statusCode} ${req.method.toUpperCase()} ${req.headers.host} ${originalUrl} ` +
+                    `${ipAddress} [abort]`);
+    });
+  });
+
+  app.get('/favicon.ico', (req, res) => {
+    res.redirect(302, '/dcp-client/assets/favicon.ico');
+  });
+  app.get(/^(\/|\/admin\/?)$/, (req, res) => {
+    res.redirect(302, '/admin/index.html');
+  });
+  app.get(/^\/admin\/.+/, (req, res) => {
+    serveStaticContent(req, res, 'www');
+  });
+  app.get(/^(\/|\/hud\/?)$/, (req, res) => {
+    res.redirect(302, '/hud/index.html');
+  });
+  app.get(/^\/hud\/.+\.shtml/, (req, res) => {
+    serveStaticContent(req, res, 'www', { ssi: true });
+  });
+  app.get(/^\/hud\/.+/, (req, res) => {
+    serveStaticContent(req, res, 'www');
+  });
+  app.get(/^\/dcp-client\/.+/, (req, res) => {
+    serveStaticContent(req, res, path.dirname(require.resolve('dcp-client')), {
+      strip: '/dcp-client/', absoluteDocroot: true });
+  });
+  app.get('/etc/dcp-config.js', async (req, res) => {
+    res.set('Content-Type', magic.js);
+    res.send('window.dcpConfig = ' + await makeSkeletonConfig());
+  });
+  app.get(/\/worker\/?$/, (req, res) => {
+    res.redirect(302, '/worker/index.html');
+  });
+  app.get('/worker/id', (req, res) => {
+    res.set('Content-Type', 'text/plain');
+    res.send(worker.id);
+  });
+  app.get('/worker/pid', (req, res) => {
+    res.set('Content-Type', 'text/plain');
+    res.send(String(process.pid));
+  });
+  app.get('/worker/owner', (req, res) => {
+    res.set('Content-Type', 'text/plain');
+    res.send(String(identity.get().address));
+  });
+  app.get('/worker/task-info', (req, res) => {
+    res.set('Content-Type', 'application/javascript');
+    res.send('window.taskInfo=' + JSON.stringify(worker.__stiCache || { jobs: [], tasks: [] }));
+  });
+  app.get('/worker/run-info', (req, res) => {
+    res.set('Content-Type', 'application/javascript');
+    res.send('window.runInfo=' + JSON.stringify(runInfoObjectFactory()));
+  });
+  app.post('/worker/register', (req, res) => handlePostMessage(req, res, workerRegisterPostHandler));
+}
+
+/**
+ * Run handler function, then prepare a JSON response to a POST message. All responses have a 'success'
+ * property, which is true if the handler ran without rejecting. If the handler rejects, then the
+ * success property is false and the rejection argument (eg Error object) is copied to the response.
+ *
+ * The resolved value of the handler is added to the result object, unless it is an instance of Error. In
+ * that case, it is carefully copied into the result as a property named 'error'; this error property has
+ * all of the enumerable properties of the exception, plus message, name, stack, and code (if defined).
+ *
+ * @param {PseudoExpressRequest}  request
+ * @param {PseudoExpressResponse} response
+ * @param {function}              handler - receives query object
+ */
+async function handlePostMessage(request, response, handler)
+{
+  const responseBody = { success: false };
+
+  response.set('access-control-allow-origin', '*');
+  response.set('access-control-allow-headers', '*');
+
+  /* dest, src */
+  function copyError(obj, error)
   {
-    response.setHeader('Content-Type', magic.kvin);
-    response.end('(' + JSON.stringify(dcpConfig) + ')');
-    return;
+    if (!obj)
+      obj = {};
+    Object.assign(obj, error);
+    obj.message = error.message;
+    obj.name    = error.name;
+    obj.stack   = error.stack;
+    if (error.code)
+      obj.code = error.code;
   }
 
-  var filename = (request.url.slice(1) || 'index.html');
-  const contentType = magic[path.extname(filename).slice(1)] || 'text/plain';
-  var errorStatus, contentDir;
+  try
+  {
+    if (request.headers['content-type'] !== 'application/x-www-form-urlencoded')
+      throw new Error(`invalid request content-type '${request.headers['content-type']}'`);
 
-  if (!filename.startsWith('node_modules/'))
-    contentDir = wwwDir;
-  else
+    const query = querystring.parse(request.body.toString('utf-8'));
+    const retval = await handler(query, request, response);
+    responseBody.success = true;
+    if (retval instanceof Error) /* error reported by handler */
+      copyError((responseBody.error = {}), retval);
+    else
+      Object.assign(responseBody, retval);
+  }
+  catch(error)
   {
-    contentDir = nmDir;
-    filename = filename.slice(13);
+    responseBody.success = false;
+    copyError(responseBody, error);
   }
 
-  filename = path.resolve(contentDir, filename);
-  console.log({contentDir,filename,requestUrl:request.url});  
-  if (!filename.startsWith(contentDir) || filename[0] !== '/')
-    errorStatus = 401;
-  else if (!fs.existsSync(filename))
-    errorStatus = 404;
+  response.json(responseBody);
+}
 
-  if (errorStatus)
+/**
+ * When we receive the registration post message, we respond with a JSON string that is designed for
+ * submitPost.  The string deserializes to an object which has properties
+ * - status:   true if successful, false if this function threw (see handlePostMessage)
+ * - error:    if not successful because an error was thrown, this is an Error-like object like it
+ * - failExpn: if not successful because of another reason, this message explains why
+ * - pid:      if successful, this is the process id of the worker that accepted the request.
+ * - owner:    if successful, this the string value of the wallet.Address of the registered owner
+ *
+ * Once successful, the client polls /worker/pid to know that it has rebooted.
+ */
+async function workerRegisterPostHandler(query, req, res)
+{
+  var failExpn;
+  const utils = require('./utils');
+  const reg = await utils.registerWorker(worker, query.rkey, msg => failExpn = msg);
+  reg.failExpn = failExpn;
+  reg.pid = process.pid;
+
+  /* Restart the worker as soon as the HTTP response with the pid has been sent to the management UI */
+  function restartSelf()
   {
-    response.setHeader('Content-Type', 'text/plain');
-    response.statusCode = errorStatus;
-    response.end(`${errorStatus} accessing ${filename}`);
-    return;
+    require('../lib/pidfile').signal(worker.config.pidfile, 'SIGQUIT', 30, 'stopping worker on pid %i');
   }
+  res.on('finish', restartSelf);
+  setTimeout(restartSelf, 30e3).unref();
 
-  response.setHeader('Content-Type', contentType);
-  response.end(fs.readFileSync(filename));
+  return reg; /* object that came back from the scheduler when we posted the registration request */
 }
 
-server.listen({ host: listenHost, port: listenUrl.port }, function(server) {
-  console.log(`listening on port ${listenUrl.href}`);
-});
+function filenameFromPathname(docroot, pathname, strip)
+{
+  if (strip)
+  {
+    if (!pathname.startsWith(strip))
+      throw new Error(`invalid pathname, does not start with '${strip}'`);
+    pathname = pathname.slice(strip.length);
+  }
+  const filename = path.join(docroot, pathname);
+  if (!filename.startsWith(docroot) || filename[docroot.length] !== '/')
+    throw new Error(`invalid pathname ${pathname} ${filename} ${docroot}`);
+  return filename;
+}
 
 /**
- * WebSocket server
+ * relative docroot means relative to dcp-worker package dir
+ * @param {object} options  options object with properties:
+ *                          - strip: chars to strip from pathname before joining to docroot
+ *                          - ssi:   enable server-side-includes
  */
-const WebSocketServer = require('websocket').server;
-const wsServer = new WebSocketServer({
-  httpServer: server,
-  autoAcceptConnections: false
-});
-
-wsServer.on('request', handleWssRequest);
-function handleWssRequest(request)
+function serveStaticContent(req, res, docroot, options)
 {
-  const connection = request.accept(null, request.origin);
-  connection.socket.unref();
-  clients.push(connection);
-  
-  const write = connection.send;
-  const read = connection.socket.read;
-
-  connection.send(JSON.stringify({ type: 'log', facility: 'debug', message: 'hello, world' }));
-  connection.on('message', messageHandler);
-  connection.on('close', closeHandler);
-
-  function messageHandler(message)
+  const hash = require('dcp/utils').hash;
+  const pathname = req.url.match('^[^?#]*')[0];
+  // @TODO: security issue: we are allowing reaching above the dcp-worker folder for serving webcontent.
+  // Repro for why this is required: try creating a new folder, and installing dcp-worker. npm will install
+  // dcp-worker and dcp-client in the node_modules folder, NOT having dcp-worker/node_modules/dcp-client.
+  // Thus, to serve this dcp-client, we need to reach above the dcp-worker root.
+  if (!options?.absoluteDocroot)
+    docroot = path.resolve(path.join(path.dirname(require.main.filename), '..', docroot));
+
+  const filename = filenameFromPathname(docroot, pathname, options?.strip);
+  const contentType = magic[path.extname(filename).slice(1)] || 'application/octet-stream';
+
+  try
   {
-    console.log('message:', message)
-    console.log('this:', this);
-  }
+    let fileDate;
+    const cacheDate = !options?.ssi && (req.headers['if-modified-since'] && new Date(req.headers['if-modified-since']));
+    const nowDate = new Date();
+
+    if (cacheDate)
+    {
+      fileDate = Math.max(bootDate, fs.statSync(filename).mtime);
+      if (!options?.ssi && cacheDate < nowDate && cacheDate > fileDate && cacheDate > bootDate)
+      {
+        /* fast path to 304 without reading file in non-SSI content */
+        res.status(304).send('Not Modified');
+        return;
+      }
+    }
+
+    /** @todo add content log hook to PseudoExpress */
+    let contents = fs.readFileSync(filename);
+    if (options?.ssi)
+    {
+      contents = contents.toString('utf-8');
+      const directives = contents.match(/<!--#include virtual="(.[^"]+)" -->/g);
+      for (let directive of directives)
+      {
+        try
+        {
+          let inclPathname = directive.match(/"[^"]+"/)[0].slice(1, -1);
+          if (inclPathname[0] === '/')
+            inclPathname = inclPathname.slice(1);
+          else
+            inclPathname = path.resolve(path.dirname(pathname), inclPathname);
+          const insert = fs.readFileSync(filenameFromPathname(docroot, inclPathname));
+          contents = contents.replace(directive, insert);
+        }
+        catch(error)
+        {
+          throw new Error(`error '${error.message}' in ssi directive '${directive.slice(2,-2)}'`);
+        }
 
-  function closeHandler()
+        if (cacheDate)
+          fileDate = Math.max(bootDate, fileDate, fs.statSync(filename).mtime);
+      }
+    }
+
+    if (cacheDate && !options?.ssi && cacheDate < nowDate && cacheDate > fileDate && cacheDate > bootDate)
+    {
+      res.status(304).send('Not Modified');
+      return;
+    }
+
+    const etag = `"${hash.calculate(hash.eh0, contents)}"`;
+    if (req.headers['if-none-match'] && req.headers['if-none-match'].split('/, ?/').includes(etag))
+      res.status(304).send('Not Modified');
+    else
+    {
+      res.set('etag', etag);
+      res.set('Content-Type', contentType);
+      res.send(contents);
+    }
+  }
+  catch(error)
   {
+    res.set('Content-Type', 'text/plain');
+    switch(error.code)
+    {
+      case 'ENOENT':
+        res.status(404).send('Not found: ' + pathname);
+        break;
+      default:
+        res.status(500).send('Internal Server Error ' + (error.code || '') + '\n' + error.stack);
+        break;
+    }
+  }
+  res.end();
+}
+
+function runInfoObjectFactory()
+{
+  return {
+    workerId:        worker.id,
+    startTime:       Date.now() - performance.now(),
+    totalEarnings,
+    earningsAccount: worker.config.paymentAddress,
+    maxSandboxes:    worker.config.maxSandboxes,
+    minimumWage:     worker.config.minimumWage,
+    cores:           Object.assign({}, worker.config.cores,
+                                   { gpu: worker.runInfo.gpuCores, gpuType: worker.runInfo.gpuType }),
+    gpuType:         worker.runInfo.gpuType || '',
   }
 }
+
+async function makeSkeletonConfig()
+{
+  const owner = await require('./utils').getOwner(worker);
+  const ownerStr = owner ? `'${String(owner)}'` : 'undefined';
+
+  return `window.dcpConfig = {
+  scheduler: {
+    location: new URL('${dcpConfig.scheduler.location.href}'),
+  },
+  bank: {
+    location: new URL('${dcpConfig.bank.location.href}'),
+  },
+  portal: {
+    location: new URL('${dcpConfig.portal.location.href}'),
+  },
+  cdn: {
+    location: new URL('${dcpConfig.cdn.location.href}'),
+  },
+  pxAuth: {
+    location: new URL('${dcpConfig.pxAuth.location.href}'),
+  },
+  oAuth: {
+    identityIntegration: false,
+    walletIntegration: false,
+  },
+  worker: {
+    id: '${worker.id}',
+    _owner: ${ownerStr},
+  },
+};
+
+window.addEventListener('dcpclientready', () => {
+  dcpConfig.worker.owner = dcpConfig.worker._owner && new dcp.wallet.Address(dcpConfig.worker._owner);
+});
+`;
+}

package/lib/worker-consoles/dashboard-console.js

@@ -346,12 +346,19 @@ exports.init = function dashboardConsole$$Init()
 
   /**
    * throb API: calls with arguments set facility and message.  First call without argument emits the
-   *            message. All calls without arguments advance the throbber.
+   *            message. All calls without arguments advance the throbber. Null cancels the throbber.
    */
   console.throb = function dashboardConsole$$throb(...args)
   {
     const throb = dashboardConsole$$throb;
     var throbPos = throb.pos || 0;
+    if (args[0] === null && args.length === 1)
+    {
+      if (typeof throb.pos === 'number')
+        logPane.advanceThrob(' ');
+      throb.pos = undefined;
+      return;
+    }
     if (args.length)
       logPane.log(...args);
     const throbChars = '/-\\|';

package/lib/worker-consoles/stdio-console.js

@@ -45,12 +45,19 @@ exports.init = function stdioConsole$$init(options)
   const throbChars = '/-\\|';
   /**
    * throb API: Writes message to stdout with a newline. Throb char is appended to message. If no message,
-   *            advance the previous throb char.
+   *            advance the previous throb char. Null cancels the throbber.
    */
   console.throb = function throb(...args) {
-    if (args.length && lastWasThrobber)
+    if ((args.length && lastWasThrobber) || args[0] === null)
       stdout.write(' \n');
 
+    if (args[0] === null && args.length === 1)
+    {
+      lastWasThrobber = false;
+      throbIdx = 0;
+      return;
+    }
+
     for (let i=0; i < args.length; i++)
     {
       if (i)