@andersbakken/fisk 4.0.61 → 4.0.63

package/monitor/fisk-monitor.js

@@ -1,38 +1,38 @@
 #!/usr/bin/env node
 'use strict';
 
-var require$$0$3 = require('events');
+var blessed = require('@andersbakken/blessed');
+var require$$0$4 = require('events');
 var require$$1 = require('https');
 var require$$2$1 = require('http');
 var require$$3 = require('net');
 var require$$4 = require('tls');
-var require$$5 = require('crypto');
-var require$$0$2 = require('stream');
-var require$$7 = require('url');
+var require$$0$3 = require('crypto');
+var require$$6 = require('url');
 var require$$0$1 = require('zlib');
 var require$$0 = require('fs');
 var path = require('path');
 var require$$2 = require('os');
+var require$$0$2 = require('stream');
 var assert = require('assert');
-var blessed = require('@andersbakken/blessed');
 var require$$1$1 = require('module');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var require$$0__default$3 = /*#__PURE__*/_interopDefaultLegacy(require$$0$3);
+var blessed__default = /*#__PURE__*/_interopDefaultLegacy(blessed);
+var require$$0__default$4 = /*#__PURE__*/_interopDefaultLegacy(require$$0$4);
 var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
 var require$$2__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$2$1);
 var require$$3__default = /*#__PURE__*/_interopDefaultLegacy(require$$3);
 var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
-var require$$5__default = /*#__PURE__*/_interopDefaultLegacy(require$$5);
-var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$2);
-var require$$7__default = /*#__PURE__*/_interopDefaultLegacy(require$$7);
+var require$$0__default$3 = /*#__PURE__*/_interopDefaultLegacy(require$$0$3);
+var require$$6__default = /*#__PURE__*/_interopDefaultLegacy(require$$6);
 var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
 var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var require$$2__default = /*#__PURE__*/_interopDefaultLegacy(require$$2);
+var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$2);
 var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
-var blessed__default = /*#__PURE__*/_interopDefaultLegacy(blessed);
 var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
 
 var bufferUtilExports = {};
@@ -1028,7 +1028,6 @@ function inflateOnData(chunk) {
   }
 
   this[kError] = new RangeError('Max payload size exceeded');
-  this[kError].code = 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH';
   this[kError][kStatusCode$2] = 1009;
   this.removeListener('data', inflateOnData);
   this.reset();
@@ -1273,7 +1272,7 @@ const INFLATING = 5;
 /**
  * HyBi Receiver implementation.
  *
- * @extends Writable
+ * @extends stream.Writable
  */
 class Receiver$1 extends Writable {
   /**
@@ -1419,26 +1418,14 @@ class Receiver$1 extends Writable {
 
     if ((buf[0] & 0x30) !== 0x00) {
       this._loop = false;
-      return error(
-        RangeError,
-        'RSV2 and RSV3 must be clear',
-        true,
-        1002,
-        'WS_ERR_UNEXPECTED_RSV_2_3'
-      );
+      return error(RangeError, 'RSV2 and RSV3 must be clear', true, 1002);
     }
 
     const compressed = (buf[0] & 0x40) === 0x40;
 
     if (compressed && !this._extensions[PerMessageDeflate$3.extensionName]) {
       this._loop = false;
-      return error(
-        RangeError,
-        'RSV1 must be clear',
-        true,
-        1002,
-        'WS_ERR_UNEXPECTED_RSV_1'
-      );
+      return error(RangeError, 'RSV1 must be clear', true, 1002);
     }
 
     this._fin = (buf[0] & 0x80) === 0x80;
@@ -1448,61 +1435,31 @@ class Receiver$1 extends Writable {
     if (this._opcode === 0x00) {
       if (compressed) {
         this._loop = false;
-        return error(
-          RangeError,
-          'RSV1 must be clear',
-          true,
-          1002,
-          'WS_ERR_UNEXPECTED_RSV_1'
-        );
+        return error(RangeError, 'RSV1 must be clear', true, 1002);
       }
 
       if (!this._fragmented) {
         this._loop = false;
-        return error(
-          RangeError,
-          'invalid opcode 0',
-          true,
-          1002,
-          'WS_ERR_INVALID_OPCODE'
-        );
+        return error(RangeError, 'invalid opcode 0', true, 1002);
       }
 
       this._opcode = this._fragmented;
     } else if (this._opcode === 0x01 || this._opcode === 0x02) {
       if (this._fragmented) {
         this._loop = false;
-        return error(
-          RangeError,
-          `invalid opcode ${this._opcode}`,
-          true,
-          1002,
-          'WS_ERR_INVALID_OPCODE'
-        );
+        return error(RangeError, `invalid opcode ${this._opcode}`, true, 1002);
       }
 
       this._compressed = compressed;
     } else if (this._opcode > 0x07 && this._opcode < 0x0b) {
       if (!this._fin) {
         this._loop = false;
-        return error(
-          RangeError,
-          'FIN must be set',
-          true,
-          1002,
-          'WS_ERR_EXPECTED_FIN'
-        );
+        return error(RangeError, 'FIN must be set', true, 1002);
       }
 
       if (compressed) {
         this._loop = false;
-        return error(
-          RangeError,
-          'RSV1 must be clear',
-          true,
-          1002,
-          'WS_ERR_UNEXPECTED_RSV_1'
-        );
+        return error(RangeError, 'RSV1 must be clear', true, 1002);
       }
 
       if (this._payloadLength > 0x7d) {
@@ -1511,19 +1468,12 @@ class Receiver$1 extends Writable {
           RangeError,
           `invalid payload length ${this._payloadLength}`,
           true,
-          1002,
-          'WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH'
+          1002
         );
       }
     } else {
       this._loop = false;
-      return error(
-        RangeError,
-        `invalid opcode ${this._opcode}`,
-        true,
-        1002,
-        'WS_ERR_INVALID_OPCODE'
-      );
+      return error(RangeError, `invalid opcode ${this._opcode}`, true, 1002);
     }
 
     if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
@@ -1532,23 +1482,11 @@ class Receiver$1 extends Writable {
     if (this._isServer) {
       if (!this._masked) {
         this._loop = false;
-        return error(
-          RangeError,
-          'MASK must be set',
-          true,
-          1002,
-          'WS_ERR_EXPECTED_MASK'
-        );
+        return error(RangeError, 'MASK must be set', true, 1002);
       }
     } else if (this._masked) {
       this._loop = false;
-      return error(
-        RangeError,
-        'MASK must be clear',
-        true,
-        1002,
-        'WS_ERR_UNEXPECTED_MASK'
-      );
+      return error(RangeError, 'MASK must be clear', true, 1002);
     }
 
     if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
@@ -1597,8 +1535,7 @@ class Receiver$1 extends Writable {
         RangeError,
         'Unsupported WebSocket frame: payload length > 2^53 - 1',
         false,
-        1009,
-        'WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH'
+        1009
       );
     }
 
@@ -1617,13 +1554,7 @@ class Receiver$1 extends Writable {
       this._totalPayloadLength += this._payloadLength;
       if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
         this._loop = false;
-        return error(
-          RangeError,
-          'Max payload size exceeded',
-          false,
-          1009,
-          'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
-        );
+        return error(RangeError, 'Max payload size exceeded', false, 1009);
       }
     }
 
@@ -1703,13 +1634,7 @@ class Receiver$1 extends Writable {
         this._messageLength += buf.length;
         if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
           return cb(
-            error(
-              RangeError,
-              'Max payload size exceeded',
-              false,
-              1009,
-              'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
-            )
+            error(RangeError, 'Max payload size exceeded', false, 1009)
           );
         }
 
@@ -1756,13 +1681,7 @@ class Receiver$1 extends Writable {
 
         if (!isValidUTF8(buf)) {
           this._loop = false;
-          return error(
-            Error,
-            'invalid UTF-8 sequence',
-            true,
-            1007,
-            'WS_ERR_INVALID_UTF8'
-          );
+          return error(Error, 'invalid UTF-8 sequence', true, 1007);
         }
 
         this.emit('message', buf.toString());
@@ -1787,36 +1706,18 @@ class Receiver$1 extends Writable {
         this.emit('conclude', 1005, '');
         this.end();
       } else if (data.length === 1) {
-        return error(
-          RangeError,
-          'invalid payload length 1',
-          true,
-          1002,
-          'WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH'
-        );
+        return error(RangeError, 'invalid payload length 1', true, 1002);
       } else {
         const code = data.readUInt16BE(0);
 
         if (!isValidStatusCode$1(code)) {
-          return error(
-            RangeError,
-            `invalid status code ${code}`,
-            true,
-            1002,
-            'WS_ERR_INVALID_CLOSE_CODE'
-          );
+          return error(RangeError, `invalid status code ${code}`, true, 1002);
         }
 
         const buf = data.slice(2);
 
         if (!isValidUTF8(buf)) {
-          return error(
-            Error,
-            'invalid UTF-8 sequence',
-            true,
-            1007,
-            'WS_ERR_INVALID_UTF8'
-          );
+          return error(Error, 'invalid UTF-8 sequence', true, 1007);
         }
 
         this.emit('conclude', code, buf.toString());
@@ -1837,28 +1738,25 @@ var receiver = Receiver$1;
 /**
  * Builds an error object.
  *
- * @param {function(new:Error|RangeError)} ErrorCtor The error constructor
+ * @param {(Error|RangeError)} ErrorCtor The error constructor
  * @param {String} message The error message
  * @param {Boolean} prefix Specifies whether or not to add a default prefix to
  *     `message`
  * @param {Number} statusCode The status code
- * @param {String} errorCode The exposed error code
  * @return {(Error|RangeError)} The error
  * @private
  */
-function error(ErrorCtor, message, prefix, statusCode, errorCode) {
+function error(ErrorCtor, message, prefix, statusCode) {
   const err = new ErrorCtor(
     prefix ? `Invalid WebSocket frame: ${message}` : message
   );
 
   Error.captureStackTrace(err, error);
-  err.code = errorCode;
   err[kStatusCode$1] = statusCode;
   return err;
 }
 
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^net|tls$" }] */
-const { randomFillSync } = require$$5__default["default"];
+const { randomFillSync } = require$$0__default$3["default"];
 
 const PerMessageDeflate$2 = permessageDeflate;
 const { EMPTY_BUFFER: EMPTY_BUFFER$1 } = constants;
@@ -1874,7 +1772,7 @@ class Sender$1 {
   /**
    * Creates a Sender instance.
    *
-   * @param {(net.Socket|tls.Socket)} socket The connection socket
+   * @param {net.Socket} socket The connection socket
    * @param {Object} [extensions] An object containing the negotiated extensions
    */
   constructor(socket, extensions) {
@@ -2667,15 +2565,13 @@ function format$2(extensions) {
 
 var extension = { format: format$2, parse: parse$2 };
 
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Readable$" }] */
-
-const EventEmitter$1 = require$$0__default$3["default"];
+const EventEmitter$1 = require$$0__default$4["default"];
 const https = require$$1__default["default"];
-const http$1 = require$$2__default$1["default"];
+const http = require$$2__default$1["default"];
 const net = require$$3__default["default"];
 const tls = require$$4__default["default"];
-const { randomBytes, createHash: createHash$1 } = require$$5__default["default"];
-const { URL } = require$$7__default["default"];
+const { randomBytes, createHash: createHash$1 } = require$$0__default$3["default"];
+const { URL } = require$$6__default["default"];
 
 const PerMessageDeflate$1 = permessageDeflate;
 const Receiver = receiver;
@@ -2705,7 +2601,7 @@ class WebSocket$2 extends EventEmitter$1 {
   /**
    * Create a new `WebSocket`.
    *
-   * @param {(String|URL)} address The URL to which to connect
+   * @param {(String|url.URL)} address The URL to which to connect
    * @param {(String|String[])} [protocols] The subprotocols
    * @param {Object} [options] Connection options
    */
@@ -2781,50 +2677,6 @@ class WebSocket$2 extends EventEmitter$1 {
     return Object.keys(this._extensions).join();
   }
 
-  /**
-   * @type {Function}
-   */
-  /* istanbul ignore next */
-  get onclose() {
-    return undefined;
-  }
-
-  /* istanbul ignore next */
-  set onclose(listener) {}
-
-  /**
-   * @type {Function}
-   */
-  /* istanbul ignore next */
-  get onerror() {
-    return undefined;
-  }
-
-  /* istanbul ignore next */
-  set onerror(listener) {}
-
-  /**
-   * @type {Function}
-   */
-  /* istanbul ignore next */
-  get onopen() {
-    return undefined;
-  }
-
-  /* istanbul ignore next */
-  set onopen(listener) {}
-
-  /**
-   * @type {Function}
-   */
-  /* istanbul ignore next */
-  get onmessage() {
-    return undefined;
-  }
-
-  /* istanbul ignore next */
-  set onmessage(listener) {}
-
   /**
    * @type {String}
    */
@@ -2849,8 +2701,7 @@ class WebSocket$2 extends EventEmitter$1 {
   /**
    * Set up the socket and the internal resources.
    *
-   * @param {(net.Socket|tls.Socket)} socket The network socket between the
-   *     server and client
+   * @param {net.Socket} socket The network socket between the server and client
    * @param {Buffer} head The first packet of the upgraded stream
    * @param {Number} [maxPayload=0] The maximum allowed message size
    * @private
@@ -2939,13 +2790,7 @@ class WebSocket$2 extends EventEmitter$1 {
     }
 
     if (this.readyState === WebSocket$2.CLOSING) {
-      if (
-        this._closeFrameSent &&
-        (this._closeFrameReceived || this._receiver._writableState.errorEmitted)
-      ) {
-        this._socket.end();
-      }
-
+      if (this._closeFrameSent && this._closeFrameReceived) this._socket.end();
       return;
     }
 
@@ -2958,13 +2803,7 @@ class WebSocket$2 extends EventEmitter$1 {
       if (err) return;
 
       this._closeFrameSent = true;
-
-      if (
-        this._closeFrameReceived ||
-        this._receiver._writableState.errorEmitted
-      ) {
-        this._socket.end();
-      }
+      if (this._closeFrameReceived) this._socket.end();
     });
 
     //
@@ -3106,76 +2945,11 @@ class WebSocket$2 extends EventEmitter$1 {
   }
 }
 
-/**
- * @constant {Number} CONNECTING
- * @memberof WebSocket
- */
-Object.defineProperty(WebSocket$2, 'CONNECTING', {
-  enumerable: true,
-  value: readyStates.indexOf('CONNECTING')
-});
+readyStates.forEach((readyState, i) => {
+  const descriptor = { enumerable: true, value: i };
 
-/**
- * @constant {Number} CONNECTING
- * @memberof WebSocket.prototype
- */
-Object.defineProperty(WebSocket$2.prototype, 'CONNECTING', {
-  enumerable: true,
-  value: readyStates.indexOf('CONNECTING')
-});
-
-/**
- * @constant {Number} OPEN
- * @memberof WebSocket
- */
-Object.defineProperty(WebSocket$2, 'OPEN', {
-  enumerable: true,
-  value: readyStates.indexOf('OPEN')
-});
-
-/**
- * @constant {Number} OPEN
- * @memberof WebSocket.prototype
- */
-Object.defineProperty(WebSocket$2.prototype, 'OPEN', {
-  enumerable: true,
-  value: readyStates.indexOf('OPEN')
-});
-
-/**
- * @constant {Number} CLOSING
- * @memberof WebSocket
- */
-Object.defineProperty(WebSocket$2, 'CLOSING', {
-  enumerable: true,
-  value: readyStates.indexOf('CLOSING')
-});
-
-/**
- * @constant {Number} CLOSING
- * @memberof WebSocket.prototype
- */
-Object.defineProperty(WebSocket$2.prototype, 'CLOSING', {
-  enumerable: true,
-  value: readyStates.indexOf('CLOSING')
-});
-
-/**
- * @constant {Number} CLOSED
- * @memberof WebSocket
- */
-Object.defineProperty(WebSocket$2, 'CLOSED', {
-  enumerable: true,
-  value: readyStates.indexOf('CLOSED')
-});
-
-/**
- * @constant {Number} CLOSED
- * @memberof WebSocket.prototype
- */
-Object.defineProperty(WebSocket$2.prototype, 'CLOSED', {
-  enumerable: true,
-  value: readyStates.indexOf('CLOSED')
+  Object.defineProperty(WebSocket$2.prototype, readyState, descriptor);
+  Object.defineProperty(WebSocket$2, readyState, descriptor);
 });
 
 [
@@ -3195,7 +2969,14 @@ Object.defineProperty(WebSocket$2.prototype, 'CLOSED', {
 //
 ['open', 'error', 'close', 'message'].forEach((method) => {
   Object.defineProperty(WebSocket$2.prototype, `on${method}`, {
+    configurable: true,
     enumerable: true,
+    /**
+     * Return the listener of the event.
+     *
+     * @return {(Function|undefined)} The event listener or `undefined`
+     * @public
+     */
     get() {
       const listeners = this.listeners(method);
       for (let i = 0; i < listeners.length; i++) {
@@ -3204,6 +2985,12 @@ Object.defineProperty(WebSocket$2.prototype, 'CLOSED', {
 
       return undefined;
     },
+    /**
+     * Add a listener for the event.
+     *
+     * @param {Function} listener The listener to add
+     * @public
+     */
     set(listener) {
       const listeners = this.listeners(method);
       for (let i = 0; i < listeners.length; i++) {
@@ -3226,7 +3013,7 @@ var websocket = WebSocket$2;
  * Initialize a WebSocket client.
  *
  * @param {WebSocket} websocket The client to initialize
- * @param {(String|URL)} address The URL to which to connect
+ * @param {(String|url.URL)} address The URL to which to connect
  * @param {String} [protocols] The subprotocols
  * @param {Object} [options] Connection options
  * @param {(Boolean|Object)} [options.perMessageDeflate=true] Enable/disable
@@ -3284,21 +3071,14 @@ function initAsClient(websocket, address, protocols, options) {
   const isUnixSocket = parsedUrl.protocol === 'ws+unix:';
 
   if (!parsedUrl.host && (!isUnixSocket || !parsedUrl.pathname)) {
-    const err = new Error(`Invalid URL: ${websocket.url}`);
-
-    if (websocket._redirects === 0) {
-      throw err;
-    } else {
-      emitErrorAndClose(websocket, err);
-      return;
-    }
+    throw new Error(`Invalid URL: ${websocket.url}`);
   }
 
   const isSecure =
     parsedUrl.protocol === 'wss:' || parsedUrl.protocol === 'https:';
   const defaultPort = isSecure ? 443 : 80;
   const key = randomBytes(16).toString('base64');
-  const get = isSecure ? https.get : http$1.get;
+  const get = isSecure ? https.get : http.get;
   let perMessageDeflate;
 
   opts.createConnection = isSecure ? tlsConnect : netConnect;
@@ -3348,61 +3128,6 @@ function initAsClient(websocket, address, protocols, options) {
     opts.path = parts[1];
   }
 
-  if (opts.followRedirects) {
-    if (websocket._redirects === 0) {
-      websocket._originalUnixSocket = isUnixSocket;
-      websocket._originalSecure = isSecure;
-      websocket._originalHostOrSocketPath = isUnixSocket
-        ? opts.socketPath
-        : parsedUrl.host;
-
-      const headers = options && options.headers;
-
-      //
-      // Shallow copy the user provided options so that headers can be changed
-      // without mutating the original object.
-      //
-      options = { ...options, headers: {} };
-
-      if (headers) {
-        for (const [key, value] of Object.entries(headers)) {
-          options.headers[key.toLowerCase()] = value;
-        }
-      }
-    } else {
-      const isSameHost = isUnixSocket
-        ? websocket._originalUnixSocket
-          ? opts.socketPath === websocket._originalHostOrSocketPath
-          : false
-        : websocket._originalUnixSocket
-        ? false
-        : parsedUrl.host === websocket._originalHostOrSocketPath;
-
-      if (!isSameHost || (websocket._originalSecure && !isSecure)) {
-        //
-        // Match curl 7.77.0 behavior and drop the following headers. These
-        // headers are also dropped when following a redirect to a subdomain.
-        //
-        delete opts.headers.authorization;
-        delete opts.headers.cookie;
-
-        if (!isSameHost) delete opts.headers.host;
-
-        opts.auth = undefined;
-      }
-    }
-
-    //
-    // Match curl 7.77.0 behavior and make the first `Authorization` header win.
-    // If the `Authorization` header is set, then there is nothing to do as it
-    // will take precedence.
-    //
-    if (opts.auth && !options.headers.authorization) {
-      options.headers.authorization =
-        'Basic ' + Buffer.from(opts.auth).toString('base64');
-    }
-  }
-
   let req = (websocket._req = get(opts));
 
   if (opts.timeout) {
@@ -3415,7 +3140,9 @@ function initAsClient(websocket, address, protocols, options) {
     if (req === null || req.aborted) return;
 
     req = websocket._req = null;
-    emitErrorAndClose(websocket, err);
+    websocket._readyState = WebSocket$2.CLOSING;
+    websocket.emit('error', err);
+    websocket.emitClose();
   });
 
   req.on('response', (res) => {
@@ -3435,14 +3162,7 @@ function initAsClient(websocket, address, protocols, options) {
 
       req.abort();
 
-      let addr;
-
-      try {
-        addr = new URL(location, address);
-      } catch (err) {
-        emitErrorAndClose(websocket, err);
-        return;
-      }
+      const addr = new URL(location, address);
 
       initAsClient(websocket, addr, protocols, options);
     } else if (!websocket.emit('unexpected-response', req, res)) {
@@ -3465,13 +3185,6 @@ function initAsClient(websocket, address, protocols, options) {
 
     req = websocket._req = null;
 
-    const upgrade = res.headers.upgrade;
-
-    if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {
-      abortHandshake$1(websocket, socket, 'Invalid Upgrade header');
-      return;
-    }
-
     const digest = createHash$1('sha1')
       .update(key + GUID$1)
       .digest('base64');
@@ -3500,50 +3213,22 @@ function initAsClient(websocket, address, protocols, options) {
 
     if (serverProt) websocket._protocol = serverProt;
 
-    const secWebSocketExtensions = res.headers['sec-websocket-extensions'];
-
-    if (secWebSocketExtensions !== undefined) {
-      if (!perMessageDeflate) {
-        const message =
-          'Server sent a Sec-WebSocket-Extensions header but no extension ' +
-          'was requested';
-        abortHandshake$1(websocket, socket, message);
-        return;
-      }
-
-      let extensions;
-
+    if (perMessageDeflate) {
       try {
-        extensions = parse$1(secWebSocketExtensions);
-      } catch (err) {
-        const message = 'Invalid Sec-WebSocket-Extensions header';
-        abortHandshake$1(websocket, socket, message);
-        return;
-      }
-
-      const extensionNames = Object.keys(extensions);
-
-      if (extensionNames.length) {
-        if (
-          extensionNames.length !== 1 ||
-          extensionNames[0] !== PerMessageDeflate$1.extensionName
-        ) {
-          const message =
-            'Server indicated an extension that was not requested';
-          abortHandshake$1(websocket, socket, message);
-          return;
-        }
+        const extensions = parse$1(res.headers['sec-websocket-extensions']);
 
-        try {
+        if (extensions[PerMessageDeflate$1.extensionName]) {
           perMessageDeflate.accept(extensions[PerMessageDeflate$1.extensionName]);
-        } catch (err) {
-          const message = 'Invalid Sec-WebSocket-Extensions header';
-          abortHandshake$1(websocket, socket, message);
-          return;
+          websocket._extensions[PerMessageDeflate$1.extensionName] =
+            perMessageDeflate;
         }
-
-        websocket._extensions[PerMessageDeflate$1.extensionName] =
-          perMessageDeflate;
+      } catch (err) {
+        abortHandshake$1(
+          websocket,
+          socket,
+          'Invalid Sec-WebSocket-Extensions header'
+        );
+        return;
       }
     }
 
@@ -3551,19 +3236,6 @@ function initAsClient(websocket, address, protocols, options) {
   });
 }
 
-/**
- * Emit the `'error'` and `'close'` event.
- *
- * @param {WebSocket} websocket The WebSocket instance
- * @param {Error} The error to emit
- * @private
- */
-function emitErrorAndClose(websocket, err) {
-  websocket._readyState = WebSocket$2.CLOSING;
-  websocket.emit('error', err);
-  websocket.emitClose();
-}
-
 /**
  * Create a `net.Socket` and initiate a connection.
  *
@@ -3597,8 +3269,8 @@ function tlsConnect(options) {
  * Abort the handshake and emit an error.
  *
  * @param {WebSocket} websocket The WebSocket instance
- * @param {(http.ClientRequest|net.Socket|tls.Socket)} stream The request to
- *     abort or the socket to destroy
+ * @param {(http.ClientRequest|net.Socket)} stream The request to abort or the
+ *     socket to destroy
  * @param {String} message The error message
  * @private
  */
@@ -3671,15 +3343,13 @@ function sendAfterClose(websocket, data, cb) {
 function receiverOnConclude(code, reason) {
   const websocket = this[kWebSocket$1];
 
+  websocket._socket.removeListener('data', socketOnData);
+  websocket._socket.resume();
+
   websocket._closeFrameReceived = true;
   websocket._closeMessage = reason;
   websocket._closeCode = code;
 
-  if (websocket._socket[kWebSocket$1] === undefined) return;
-
-  websocket._socket.removeListener('data', socketOnData);
-  process.nextTick(resume, websocket._socket);
-
   if (code === 1005) websocket.close();
   else websocket.close(code, reason);
 }
@@ -3702,19 +3372,12 @@ function receiverOnDrain() {
 function receiverOnError(err) {
   const websocket = this[kWebSocket$1];
 
-  if (websocket._socket[kWebSocket$1] !== undefined) {
-    websocket._socket.removeListener('data', socketOnData);
-
-    //
-    // On Node.js < 14.0.0 the `'error'` event is emitted synchronously. See
-    // https://github.com/websockets/ws/issues/1940.
-    //
-    process.nextTick(resume, websocket._socket);
-
-    websocket.close(err[kStatusCode]);
-  }
+  websocket._socket.removeListener('data', socketOnData);
 
+  websocket._readyState = WebSocket$2.CLOSING;
+  websocket._closeCode = err[kStatusCode];
   websocket.emit('error', err);
+  websocket._socket.destroy();
 }
 
 /**
@@ -3759,16 +3422,6 @@ function receiverOnPong(data) {
   this[kWebSocket$1].emit('pong', data);
 }
 
-/**
- * Resume a readable stream
- *
- * @param {Readable} stream The readable stream
- * @private
- */
-function resume(stream) {
-  stream.resume();
-}
-
 /**
  * The listener of the `net.Socket` `'close'` event.
  *
@@ -3778,13 +3431,10 @@ function socketOnClose() {
   const websocket = this[kWebSocket$1];
 
   this.removeListener('close', socketOnClose);
-  this.removeListener('data', socketOnData);
   this.removeListener('end', socketOnEnd);
 
   websocket._readyState = WebSocket$2.CLOSING;
 
-  let chunk;
-
   //
   // The close frame might not have been received or the `'end'` event emitted,
   // for example, if the socket was destroyed due to an error. Ensure that the
@@ -3792,19 +3442,13 @@ function socketOnClose() {
   // it. If the readable side of the socket is in flowing mode then there is no
   // buffered data as everything has been already written and `readable.read()`
   // will return `null`. If instead, the socket is paused, any possible buffered
-  // data will be read as a single chunk.
+  // data will be read as a single chunk and emitted synchronously in a single
+  // `'data'` event.
   //
-  if (
-    !this._readableState.endEmitted &&
-    !websocket._closeFrameReceived &&
-    !websocket._receiver._writableState.errorEmitted &&
-    (chunk = websocket._socket.read()) !== null
-  ) {
-    websocket._receiver.write(chunk);
-  }
-
+  websocket._socket.read();
   websocket._receiver.end();
 
+  this.removeListener('data', socketOnData);
   this[kWebSocket$1] = undefined;
 
   clearTimeout(websocket._closeTimer);
@@ -3867,7 +3511,7 @@ const { Duplex } = require$$0__default$2["default"];
 /**
  * Emits the `'close'` event on a stream.
  *
- * @param {Duplex} stream The stream.
+ * @param {stream.Duplex} The stream.
  * @private
  */
 function emitClose$1(stream) {
@@ -3905,12 +3549,11 @@ function duplexOnError(err) {
  *
  * @param {WebSocket} ws The `WebSocket` to wrap
  * @param {Object} [options] The options for the `Duplex` constructor
- * @return {Duplex} The duplex stream
+ * @return {stream.Duplex} The duplex stream
  * @public
  */
 function createWebSocketStream(ws, options) {
   let resumeOnReceiverDrain = true;
-  let terminateOnDestroy = true;
 
   function receiverOnDrain() {
     if (resumeOnReceiverDrain) ws._socket.resume();
@@ -3944,16 +3587,6 @@ function createWebSocketStream(ws, options) {
   ws.once('error', function error(err) {
     if (duplex.destroyed) return;
 
-    // Prevent `ws.terminate()` from being called by `duplex._destroy()`.
-    //
-    // - If the `'error'` event is emitted before the `'open'` event, then
-    //   `ws.terminate()` is a noop as no socket is assigned.
-    // - Otherwise, the error is re-emitted by the listener of the `'error'`
-    //   event of the `Receiver` object. The listener already closes the
-    //   connection by calling `ws.close()`. This allows a close frame to be
-    //   sent to the other peer. If `ws.terminate()` is called right after this,
-    //   then the close frame might not be sent.
-    terminateOnDestroy = false;
     duplex.destroy(err);
   });
 
@@ -3981,8 +3614,7 @@ function createWebSocketStream(ws, options) {
       if (!called) callback(err);
       process.nextTick(emitClose$1, duplex);
     });
-
-    if (terminateOnDestroy) ws.terminate();
+    ws.terminate();
   };
 
   duplex._final = function (callback) {
@@ -4014,10 +3646,7 @@ function createWebSocketStream(ws, options) {
   };
 
   duplex._read = function () {
-    if (
-      (ws.readyState === ws.OPEN || ws.readyState === ws.CLOSING) &&
-      !resumeOnReceiverDrain
-    ) {
+    if (ws.readyState === ws.OPEN && !resumeOnReceiverDrain) {
       resumeOnReceiverDrain = true;
       if (!ws._receiver._writableState.needDrain) ws._socket.resume();
     }
@@ -4041,11 +3670,9 @@ function createWebSocketStream(ws, options) {
 
 var stream = createWebSocketStream;
 
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^net|tls|https$" }] */
-
-const EventEmitter = require$$0__default$3["default"];
-const http = require$$2__default$1["default"];
-const { createHash } = require$$5__default["default"];
+const EventEmitter = require$$0__default$4["default"];
+const { createHash } = require$$0__default$3["default"];
+const { createServer, STATUS_CODES } = require$$2__default$1["default"];
 
 const PerMessageDeflate = permessageDeflate;
 const WebSocket$1 = websocket;
@@ -4054,10 +3681,6 @@ const { GUID, kWebSocket } = constants;
 
 const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
 
-const RUNNING = 0;
-const CLOSING = 1;
-const CLOSED = 2;
-
 /**
  * Class representing a WebSocket server.
  *
@@ -4081,8 +3704,7 @@ class WebSocketServer extends EventEmitter {
    * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
    *     permessage-deflate
    * @param {Number} [options.port] The port where to bind the server
-   * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
-   *     server to use
+   * @param {http.Server} [options.server] A pre-created HTTP/S server to use
    * @param {Function} [options.verifyClient] A hook to reject connections
    * @param {Function} [callback] A listener for the `listening` event
    */
@@ -4104,20 +3726,15 @@ class WebSocketServer extends EventEmitter {
       ...options
     };
 
-    if (
-      (options.port == null && !options.server && !options.noServer) ||
-      (options.port != null && (options.server || options.noServer)) ||
-      (options.server && options.noServer)
-    ) {
+    if (options.port == null && !options.server && !options.noServer) {
       throw new TypeError(
-        'One and only one of the "port", "server", or "noServer" options ' +
-          'must be specified'
+        'One of the "port", "server", or "noServer" options must be specified'
       );
     }
 
     if (options.port != null) {
-      this._server = http.createServer((req, res) => {
-        const body = http.STATUS_CODES[426];
+      this._server = createServer((req, res) => {
+        const body = STATUS_CODES[426];
 
         res.writeHead(426, {
           'Content-Length': body.length,
@@ -4150,7 +3767,6 @@ class WebSocketServer extends EventEmitter {
     if (options.perMessageDeflate === true) options.perMessageDeflate = {};
     if (options.clientTracking) this.clients = new Set();
     this.options = options;
-    this._state = RUNNING;
   }
 
   /**
@@ -4180,14 +3796,6 @@ class WebSocketServer extends EventEmitter {
   close(cb) {
     if (cb) this.once('close', cb);
 
-    if (this._state === CLOSED) {
-      process.nextTick(emitClose, this);
-      return;
-    }
-
-    if (this._state === CLOSING) return;
-    this._state = CLOSING;
-
     //
     // Terminate all associated clients.
     //
@@ -4205,7 +3813,7 @@ class WebSocketServer extends EventEmitter {
       // Close the http server if it was internally created.
       //
       if (this.options.port != null) {
-        server.close(emitClose.bind(undefined, this));
+        server.close(() => this.emit('close'));
         return;
       }
     }
@@ -4235,8 +3843,7 @@ class WebSocketServer extends EventEmitter {
    * Handle a HTTP Upgrade request.
    *
    * @param {http.IncomingMessage} req The request object
-   * @param {(net.Socket|tls.Socket)} socket The network socket between the
-   *     server and client
+   * @param {net.Socket} socket The network socket between the server and client
    * @param {Buffer} head The first packet of the upgraded stream
    * @param {Function} cb Callback
    * @public
@@ -4248,14 +3855,12 @@ class WebSocketServer extends EventEmitter {
       req.headers['sec-websocket-key'] !== undefined
         ? req.headers['sec-websocket-key'].trim()
         : false;
-    const upgrade = req.headers.upgrade;
     const version = +req.headers['sec-websocket-version'];
     const extensions = {};
 
     if (
       req.method !== 'GET' ||
-      upgrade === undefined ||
-      upgrade.toLowerCase() !== 'websocket' ||
+      req.headers.upgrade.toLowerCase() !== 'websocket' ||
       !key ||
       !keyRegex.test(key) ||
       (version !== 8 && version !== 13) ||
@@ -4317,8 +3922,7 @@ class WebSocketServer extends EventEmitter {
    * @param {String} key The value of the `Sec-WebSocket-Key` header
    * @param {Object} extensions The accepted extensions
    * @param {http.IncomingMessage} req The request object
-   * @param {(net.Socket|tls.Socket)} socket The network socket between the
-   *     server and client
+   * @param {net.Socket} socket The network socket between the server and client
    * @param {Buffer} head The first packet of the upgraded stream
    * @param {Function} cb Callback
    * @throws {Error} If called more than once with the same socket
@@ -4337,8 +3941,6 @@ class WebSocketServer extends EventEmitter {
       );
     }
 
-    if (this._state > RUNNING) return abortHandshake(socket, 503);
-
     const digest = createHash('sha1')
       .update(key + GUID)
       .digest('base64');
@@ -4428,7 +4030,6 @@ function addListeners(server, map) {
  * @private
  */
 function emitClose(server) {
-  server._state = CLOSED;
   server.emit('close');
 }
 
@@ -4444,7 +4045,7 @@ function socketOnError() {
 /**
  * Close the connection when preconditions are not fulfilled.
  *
- * @param {(net.Socket|tls.Socket)} socket The socket of the upgrade request
+ * @param {net.Socket} socket The socket of the upgrade request
  * @param {Number} code The HTTP response status code
  * @param {String} [message] The HTTP response body
  * @param {Object} [headers] Additional HTTP response headers
@@ -4452,7 +4053,7 @@ function socketOnError() {
  */
 function abortHandshake(socket, code, message, headers) {
   if (socket.writable) {
-    message = message || http.STATUS_CODES[code];
+    message = message || STATUS_CODES[code];
     headers = {
       Connection: 'close',
       'Content-Type': 'text/html',
@@ -4461,7 +4062,7 @@ function abortHandshake(socket, code, message, headers) {
     };
 
     socket.write(
-      `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r\n` +
+      `HTTP/1.1 ${code} ${STATUS_CODES[code]}\r\n` +
         Object.keys(headers)
           .map((h) => `${h}: ${headers[h]}`)
           .join('\r\n') +
@@ -5890,17 +5491,6 @@ function options (optionsOptions, argv) {
     });
 }
 
-if (process.argv.includes("--help") || process.argv.includes("-h")) {
-    console.log(`Usage: fisk-monitor [options]
-
-Options:
-  --scheduler=URL        Scheduler URL (default: ws://localhost:8097)
-  --daemon-socket=PATH   Daemon Unix socket path (default: ~/.cache/fisk/daemon/socket)
-
-Config files: ~/.config/fisk/monitor.conf, /etc/xdg/fisk/monitor.conf
-Environment variables: FISK_MONITOR_SCHEDULER, etc.`);
-    process.exit(0);
-}
 const option = options({
     prefix: "fisk/monitor",
     noApplicationPath: true,
@@ -6143,29 +5733,23 @@ clientBox.on("select", (ev) => {
         if (jobs) {
             // clientBox.current = clientKey;
             let str = "";
-            const header = ["Source file", "Builder", "Start time"];
-            const rows = [];
-            const widest = [header[0].length + 1, header[1].length + 1];
+            const data = [["Source file", "Builder", "Start time"]];
+            const widest = [data[0][0].length + 1, data[0][1].length + 1];
             const now = Date.now();
             for (const [jobKey, jobValue] of jobs) {
                 if (jobKey === "total") {
                     continue;
                 }
-                const sourceBasename = path__default["default"].basename(jobValue.sourcePath || jobValue.sourceFile || "");
-                widest[0] = Math.max(sourceBasename.length + 1, widest[0]);
-                const ageMs = now - jobValue.time;
-                const row = {
-                    source: sourceBasename,
-                    builder: jobValue.builder.ip + ":" + jobValue.builder.port,
-                    humanizedAge: humanizeDuration(ageMs),
-                    ageMs
-                };
-                rows.push(row);
-                widest[1] = Math.max(widest[1], row.builder.length + 1);
+                widest[0] = Math.max(jobValue.sourceFile.length + 1, widest[0]);
+                data.push([
+                    jobValue.sourceFile,
+                    jobValue.builder.ip + ":" + jobValue.builder.port,
+                    humanizeDuration(now - jobValue.time)
+                ]);
+                widest[1] = Math.max(widest[1], data[data.length - 1][1].length + 1);
             }
-            rows.sort((a, b) => a.ageMs - b.ageMs);
-            const lines = [header, ...rows.map((r) => [r.source, r.builder, r.humanizedAge])];
-            lines.forEach((line, idx) => {
+            data.sort((a, b) => parseInt(a[2]) - parseInt(b[2]));
+            data.forEach((line, idx) => {
                 if (!idx) {
                     str += "{bold}";
                 }
@@ -6304,13 +5888,7 @@ function notify(msg) {
         return;
     }
     const notifyNow = (message) => {
-        if (message) {
-            notificationBox.setContent(message);
-        }
-        else {
-            updateNotificationBar();
-            return;
-        }
+        notificationBox.setContent(message || "");
         screen.render();
     };
     notificationInterval = setInterval(() => {
@@ -6351,7 +5929,6 @@ function formatCell(str, num, prefix, suffix) {
     return (prefix || "") + (" " + str).padEnd(num, " ").substr(0, num) + (suffix || "");
 }
 let updateTimer;
-let refreshTimer;
 let timeout = 0;
 function updateBuilderBox() {
     const builderWidth = builderContainer.width - 3;
@@ -6432,14 +6009,11 @@ function updateBuilderBox() {
     if (currentFocus !== builderBox) {
         builderBox.scrollTo(0);
     }
-    if (refreshTimer) {
-        clearTimeout(refreshTimer);
-    }
     if (newest < 60000) {
-        refreshTimer = setTimeout(update, 1000);
+        setTimeout(update, 1000);
     }
     else {
-        refreshTimer = setTimeout(update, 60000);
+        setTimeout(update, 60000);
     }
 }
 function updateClientBox() {
@@ -6636,91 +6210,5 @@ function connect() {
         setTimeout(connect, 1000);
     });
 }
-// --- Daemon connection for local slot info ---
-const DaemonJSON = 5;
-const DaemonJSONResponse = 12;
-const daemonSocketPath = String(option("daemon-socket", path__default["default"].join(require$$2__default["default"].homedir(), ".cache", "fisk", "daemon", "socket")));
-let daemonSlotsInfo;
-let daemonSocket;
-let daemonRecvBuffer = Buffer.alloc(0);
-function updateNotificationBar() {
-    if (daemonSlotsInfo && daemonSlotsInfo.local.capacity > 0) {
-        const local = daemonSlotsInfo.local;
-        notificationBox.setContent(`{bold}Local:{/bold} ${local.active}/${local.capacity} active, ${local.total} total`);
-    }
-    else {
-        notificationBox.setContent("");
-    }
-    screen.render();
-}
-function processDaemonMessage(json) {
-    try {
-        const msg = JSON.parse(json);
-        if (msg.type === "slotsInfo") {
-            daemonSlotsInfo = msg;
-            updateNotificationBar();
-        }
-    }
-    catch (e) {
-        // ignore parse errors
-    }
-}
-function processDaemonData() {
-    while (daemonRecvBuffer.length > 0) {
-        const type = daemonRecvBuffer[0];
-        if (type === DaemonJSONResponse) {
-            if (daemonRecvBuffer.length < 5) {
-                break; // need more data for length header
-            }
-            const msgLen = daemonRecvBuffer.readUInt32BE(1);
-            if (daemonRecvBuffer.length < 5 + msgLen) {
-                break; // need more data for body
-            }
-            const json = daemonRecvBuffer.subarray(5, 5 + msgLen).toString("utf8");
-            daemonRecvBuffer = daemonRecvBuffer.subarray(5 + msgLen);
-            processDaemonMessage(json);
-        }
-        else {
-            // Unknown single-byte message, skip it
-            daemonRecvBuffer = daemonRecvBuffer.subarray(1);
-        }
-    }
-}
-function sendDaemonJSON(sock, obj) {
-    const jsonBuf = Buffer.from(JSON.stringify(obj), "utf8");
-    const header = Buffer.allocUnsafe(5);
-    header.writeUInt8(DaemonJSON, 0);
-    header.writeUInt32BE(jsonBuf.length, 1);
-    sock.write(header);
-    sock.write(jsonBuf);
-}
-function connectDaemon() {
-    daemonSlotsInfo = undefined;
-    daemonRecvBuffer = Buffer.alloc(0);
-    daemonSocket = require$$3__default["default"].createConnection(daemonSocketPath);
-    daemonSocket.on("connect", () => {
-        assert__default["default"](daemonSocket);
-        // Send PID (4 bytes, big-endian) as the daemon protocol requires
-        const pidBuf = Buffer.allocUnsafe(4);
-        pidBuf.writeUInt32BE(process.pid, 0);
-        daemonSocket.write(pidBuf);
-        // Subscribe to slot updates
-        sendDaemonJSON(daemonSocket, { type: "subscribeSlots" });
-    });
-    daemonSocket.on("data", (data) => {
-        daemonRecvBuffer = Buffer.concat([daemonRecvBuffer, data]);
-        processDaemonData();
-    });
-    daemonSocket.on("error", () => {
-        // Daemon may not be running, silently retry
-    });
-    daemonSocket.on("close", () => {
-        daemonSocket = undefined;
-        daemonSlotsInfo = undefined;
-        updateNotificationBar();
-        setTimeout(connectDaemon, 5000);
-    });
-}
 connect();
-connectDaemon();
 //# sourceMappingURL=fisk-monitor.js.map