talking works & menus work plus ai documentation : )

BACKFLIP BACKFLIP BACKFLIP BACKFLIP BACKFLIP BACKFLIP BACKFLIP BACKFLIP BACKFLIP BACKFLIP BACKFLIP BACKFLIP BACKFLIP

README.md

@@ -1,10 +1,13 @@
-# JiboOs
+- - -
+# Jibo Os - openJiboOs
+- - -
+Artwork by : Pou@Our discord
 
- - - -
- 
- # Release Version 3.3.0 InDev
- 
- Chagelog.....
- 
- you can make custom menu buttons!
+![Art Work by pou](openjibos.png "Art Work by pou")
 
+- - -
+
+open-jibOS is a open source version of the jibo OS ,
+this repository contains the source for jibos OS , please not this is NOT the full os image dump but instead a collection of only the modified directories that is used by a helper application over at https://kevinblog.sytes.net/Code/Kevin/JiboAutoMod to help you manage and install updates!
+
+- - - 

V3.1/build/ai_bridge_server/README.md

@@ -0,0 +1,46 @@
+# Jibo AI Bridge Server
+
+This is a small companion server you run on your PC (same machine as Ollama).
+It gives the robot a stable HTTP target and keeps the on-robot code modular.
+
+## Endpoints
+
+- `POST /v1/chat/text` JSON: `{ "text": "..." }` → `{ "reply": "..." }`
+- `POST /v1/chat/audio` JSON: `{ "wav_base64": "..." }` → `{ "reply": "...", "text": "<transcript>" }`
+
+## Requirements
+
+- Python 3.9+
+- Ollama running locally
+  - default Ollama chat URL: `http://127.0.0.1:11434/api/chat`
+
+Optional (for AUDIO mode):
+- `faster-whisper` + `ffmpeg`
+
+## Run
+
+From this folder:
+
+- `python3 server.py --host 0.0.0.0 --port 8020`
+
+Environment variables (optional):
+
+- `OLLAMA_MODEL` (default `phi3.5`)
+- `OLLAMA_URL` (default `http://127.0.0.1:11434/api/chat`)
+- `WHISPER_MODEL` (default `base`)
+
+Note: Ollama can stay bound to `127.0.0.1:11434` on your PC; the robot only talks to this bridge server (`:8020`).
+
+Install optional STT deps:
+
+- `pip install faster-whisper`
+- install `ffmpeg` (platform-specific)
+
+## Robot configuration
+
+Open the tunables UI (`http://<robot-ip>:3333`) and set:
+
+- **Jibo AI Bridge → Server URL**: `http://<your-pc-ip>:8020`
+- **Jibo AI Bridge → Input**:
+  - `AUDIO` (records a short WAV clip on the robot and sends it)
+  - `TEXT` (uses `globalTurnResult` ASR text if available)

V3.1/build/ai_bridge_server/node_modules/.package-lock.json

@@ -0,0 +1,28 @@
+{
+  "name": "ai_bridge_server",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/ws": {
+      "version": "8.19.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
+      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

V3.1/build/ai_bridge_server/node_modules/ws/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+Copyright (c) 2013 Arnout Kazemier and contributors
+Copyright (c) 2016 Luigi Pinca and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

V3.1/build/ai_bridge_server/node_modules/ws/README.md

@@ -0,0 +1,548 @@
+# ws: a Node.js WebSocket library
+
+[![Version npm](https://img.shields.io/npm/v/ws.svg?logo=npm)](https://www.npmjs.com/package/ws)
+[![CI](https://img.shields.io/github/actions/workflow/status/websockets/ws/ci.yml?branch=master&label=CI&logo=github)](https://github.com/websockets/ws/actions?query=workflow%3ACI+branch%3Amaster)
+[![Coverage Status](https://img.shields.io/coveralls/websockets/ws/master.svg?logo=coveralls)](https://coveralls.io/github/websockets/ws)
+
+ws is a simple to use, blazing fast, and thoroughly tested WebSocket client and
+server implementation.
+
+Passes the quite extensive Autobahn test suite: [server][server-report],
+[client][client-report].
+
+**Note**: This module does not work in the browser. The client in the docs is a
+reference to a backend with the role of a client in the WebSocket communication.
+Browser clients must use the native
+[`WebSocket`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket)
+object. To make the same code work seamlessly on Node.js and the browser, you
+can use one of the many wrappers available on npm, like
+[isomorphic-ws](https://github.com/heineiuo/isomorphic-ws).
+
+## Table of Contents
+
+- [Protocol support](#protocol-support)
+- [Installing](#installing)
+  - [Opt-in for performance](#opt-in-for-performance)
+    - [Legacy opt-in for performance](#legacy-opt-in-for-performance)
+- [API docs](#api-docs)
+- [WebSocket compression](#websocket-compression)
+- [Usage examples](#usage-examples)
+  - [Sending and receiving text data](#sending-and-receiving-text-data)
+  - [Sending binary data](#sending-binary-data)
+  - [Simple server](#simple-server)
+  - [External HTTP/S server](#external-https-server)
+  - [Multiple servers sharing a single HTTP/S server](#multiple-servers-sharing-a-single-https-server)
+  - [Client authentication](#client-authentication)
+  - [Server broadcast](#server-broadcast)
+  - [Round-trip time](#round-trip-time)
+  - [Use the Node.js streams API](#use-the-nodejs-streams-api)
+  - [Other examples](#other-examples)
+- [FAQ](#faq)
+  - [How to get the IP address of the client?](#how-to-get-the-ip-address-of-the-client)
+  - [How to detect and close broken connections?](#how-to-detect-and-close-broken-connections)
+  - [How to connect via a proxy?](#how-to-connect-via-a-proxy)
+- [Changelog](#changelog)
+- [License](#license)
+
+## Protocol support
+
+- **HyBi drafts 07-12** (Use the option `protocolVersion: 8`)
+- **HyBi drafts 13-17** (Current default, alternatively option
+  `protocolVersion: 13`)
+
+## Installing
+
+```
+npm install ws
+```
+
+### Opt-in for performance
+
+[bufferutil][] is an optional module that can be installed alongside the ws
+module:
+
+```
+npm install --save-optional bufferutil
+```
+
+This is a binary addon that improves the performance of certain operations such
+as masking and unmasking the data payload of the WebSocket frames. Prebuilt
+binaries are available for the most popular platforms, so you don't necessarily
+need to have a C++ compiler installed on your machine.
+
+To force ws to not use bufferutil, use the
+[`WS_NO_BUFFER_UTIL`](./doc/ws.md#ws_no_buffer_util) environment variable. This
+can be useful to enhance security in systems where a user can put a package in
+the package search path of an application of another user, due to how the
+Node.js resolver algorithm works.
+
+#### Legacy opt-in for performance
+
+If you are running on an old version of Node.js (prior to v18.14.0), ws also
+supports the [utf-8-validate][] module:
+
+```
+npm install --save-optional utf-8-validate
+```
+
+This contains a binary polyfill for [`buffer.isUtf8()`][].
+
+To force ws not to use utf-8-validate, use the
+[`WS_NO_UTF_8_VALIDATE`](./doc/ws.md#ws_no_utf_8_validate) environment variable.
+
+## API docs
+
+See [`/doc/ws.md`](./doc/ws.md) for Node.js-like documentation of ws classes and
+utility functions.
+
+## WebSocket compression
+
+ws supports the [permessage-deflate extension][permessage-deflate] which enables
+the client and server to negotiate a compression algorithm and its parameters,
+and then selectively apply it to the data payloads of each WebSocket message.
+
+The extension is disabled by default on the server and enabled by default on the
+client. It adds a significant overhead in terms of performance and memory
+consumption so we suggest to enable it only if it is really needed.
+
+Note that Node.js has a variety of issues with high-performance compression,
+where increased concurrency, especially on Linux, can lead to [catastrophic
+memory fragmentation][node-zlib-bug] and slow performance. If you intend to use
+permessage-deflate in production, it is worthwhile to set up a test
+representative of your workload and ensure Node.js/zlib will handle it with
+acceptable performance and memory usage.
+
+Tuning of permessage-deflate can be done via the options defined below. You can
+also use `zlibDeflateOptions` and `zlibInflateOptions`, which is passed directly
+into the creation of [raw deflate/inflate streams][node-zlib-deflaterawdocs].
+
+See [the docs][ws-server-options] for more options.
+
+```js
+import WebSocket, { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({
+  port: 8080,
+  perMessageDeflate: {
+    zlibDeflateOptions: {
+      // See zlib defaults.
+      chunkSize: 1024,
+      memLevel: 7,
+      level: 3
+    },
+    zlibInflateOptions: {
+      chunkSize: 10 * 1024
+    },
+    // Other options settable:
+    clientNoContextTakeover: true, // Defaults to negotiated value.
+    serverNoContextTakeover: true, // Defaults to negotiated value.
+    serverMaxWindowBits: 10, // Defaults to negotiated value.
+    // Below options specified as default values.
+    concurrencyLimit: 10, // Limits zlib concurrency for perf.
+    threshold: 1024 // Size (in bytes) below which messages
+    // should not be compressed if context takeover is disabled.
+  }
+});
+```
+
+The client will only use the extension if it is supported and enabled on the
+server. To always disable the extension on the client, set the
+`perMessageDeflate` option to `false`.
+
+```js
+import WebSocket from 'ws';
+
+const ws = new WebSocket('ws://www.host.com/path', {
+  perMessageDeflate: false
+});
+```
+
+## Usage examples
+
+### Sending and receiving text data
+
+```js
+import WebSocket from 'ws';
+
+const ws = new WebSocket('ws://www.host.com/path');
+
+ws.on('error', console.error);
+
+ws.on('open', function open() {
+  ws.send('something');
+});
+
+ws.on('message', function message(data) {
+  console.log('received: %s', data);
+});
+```
+
+### Sending binary data
+
+```js
+import WebSocket from 'ws';
+
+const ws = new WebSocket('ws://www.host.com/path');
+
+ws.on('error', console.error);
+
+ws.on('open', function open() {
+  const array = new Float32Array(5);
+
+  for (var i = 0; i < array.length; ++i) {
+    array[i] = i / 2;
+  }
+
+  ws.send(array);
+});
+```
+
+### Simple server
+
+```js
+import { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.on('error', console.error);
+
+  ws.on('message', function message(data) {
+    console.log('received: %s', data);
+  });
+
+  ws.send('something');
+});
+```
+
+### External HTTP/S server
+
+```js
+import { createServer } from 'https';
+import { readFileSync } from 'fs';
+import { WebSocketServer } from 'ws';
+
+const server = createServer({
+  cert: readFileSync('/path/to/cert.pem'),
+  key: readFileSync('/path/to/key.pem')
+});
+const wss = new WebSocketServer({ server });
+
+wss.on('connection', function connection(ws) {
+  ws.on('error', console.error);
+
+  ws.on('message', function message(data) {
+    console.log('received: %s', data);
+  });
+
+  ws.send('something');
+});
+
+server.listen(8080);
+```
+
+### Multiple servers sharing a single HTTP/S server
+
+```js
+import { createServer } from 'http';
+import { WebSocketServer } from 'ws';
+
+const server = createServer();
+const wss1 = new WebSocketServer({ noServer: true });
+const wss2 = new WebSocketServer({ noServer: true });
+
+wss1.on('connection', function connection(ws) {
+  ws.on('error', console.error);
+
+  // ...
+});
+
+wss2.on('connection', function connection(ws) {
+  ws.on('error', console.error);
+
+  // ...
+});
+
+server.on('upgrade', function upgrade(request, socket, head) {
+  const { pathname } = new URL(request.url, 'wss://base.url');
+
+  if (pathname === '/foo') {
+    wss1.handleUpgrade(request, socket, head, function done(ws) {
+      wss1.emit('connection', ws, request);
+    });
+  } else if (pathname === '/bar') {
+    wss2.handleUpgrade(request, socket, head, function done(ws) {
+      wss2.emit('connection', ws, request);
+    });
+  } else {
+    socket.destroy();
+  }
+});
+
+server.listen(8080);
+```
+
+### Client authentication
+
+```js
+import { createServer } from 'http';
+import { WebSocketServer } from 'ws';
+
+function onSocketError(err) {
+  console.error(err);
+}
+
+const server = createServer();
+const wss = new WebSocketServer({ noServer: true });
+
+wss.on('connection', function connection(ws, request, client) {
+  ws.on('error', console.error);
+
+  ws.on('message', function message(data) {
+    console.log(`Received message ${data} from user ${client}`);
+  });
+});
+
+server.on('upgrade', function upgrade(request, socket, head) {
+  socket.on('error', onSocketError);
+
+  // This function is not defined on purpose. Implement it with your own logic.
+  authenticate(request, function next(err, client) {
+    if (err || !client) {
+      socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+      socket.destroy();
+      return;
+    }
+
+    socket.removeListener('error', onSocketError);
+
+    wss.handleUpgrade(request, socket, head, function done(ws) {
+      wss.emit('connection', ws, request, client);
+    });
+  });
+});
+
+server.listen(8080);
+```
+
+Also see the provided [example][session-parse-example] using `express-session`.
+
+### Server broadcast
+
+A client WebSocket broadcasting to all connected WebSocket clients, including
+itself.
+
+```js
+import WebSocket, { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.on('error', console.error);
+
+  ws.on('message', function message(data, isBinary) {
+    wss.clients.forEach(function each(client) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data, { binary: isBinary });
+      }
+    });
+  });
+});
+```
+
+A client WebSocket broadcasting to every other connected WebSocket clients,
+excluding itself.
+
+```js
+import WebSocket, { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.on('error', console.error);
+
+  ws.on('message', function message(data, isBinary) {
+    wss.clients.forEach(function each(client) {
+      if (client !== ws && client.readyState === WebSocket.OPEN) {
+        client.send(data, { binary: isBinary });
+      }
+    });
+  });
+});
+```
+
+### Round-trip time
+
+```js
+import WebSocket from 'ws';
+
+const ws = new WebSocket('wss://websocket-echo.com/');
+
+ws.on('error', console.error);
+
+ws.on('open', function open() {
+  console.log('connected');
+  ws.send(Date.now());
+});
+
+ws.on('close', function close() {
+  console.log('disconnected');
+});
+
+ws.on('message', function message(data) {
+  console.log(`Round-trip time: ${Date.now() - data} ms`);
+
+  setTimeout(function timeout() {
+    ws.send(Date.now());
+  }, 500);
+});
+```
+
+### Use the Node.js streams API
+
+```js
+import WebSocket, { createWebSocketStream } from 'ws';
+
+const ws = new WebSocket('wss://websocket-echo.com/');
+
+const duplex = createWebSocketStream(ws, { encoding: 'utf8' });
+
+duplex.on('error', console.error);
+
+duplex.pipe(process.stdout);
+process.stdin.pipe(duplex);
+```
+
+### Other examples
+
+For a full example with a browser client communicating with a ws server, see the
+examples folder.
+
+Otherwise, see the test cases.
+
+## FAQ
+
+### How to get the IP address of the client?
+
+The remote IP address can be obtained from the raw socket.
+
+```js
+import { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws, req) {
+  const ip = req.socket.remoteAddress;
+
+  ws.on('error', console.error);
+});
+```
+
+When the server runs behind a proxy like NGINX, the de-facto standard is to use
+the `X-Forwarded-For` header.
+
+```js
+wss.on('connection', function connection(ws, req) {
+  const ip = req.headers['x-forwarded-for'].split(',')[0].trim();
+
+  ws.on('error', console.error);
+});
+```
+
+### How to detect and close broken connections?
+
+Sometimes, the link between the server and the client can be interrupted in a
+way that keeps both the server and the client unaware of the broken state of the
+connection (e.g. when pulling the cord).
+
+In these cases, ping messages can be used as a means to verify that the remote
+endpoint is still responsive.
+
+```js
+import { WebSocketServer } from 'ws';
+
+function heartbeat() {
+  this.isAlive = true;
+}
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.isAlive = true;
+  ws.on('error', console.error);
+  ws.on('pong', heartbeat);
+});
+
+const interval = setInterval(function ping() {
+  wss.clients.forEach(function each(ws) {
+    if (ws.isAlive === false) return ws.terminate();
+
+    ws.isAlive = false;
+    ws.ping();
+  });
+}, 30000);
+
+wss.on('close', function close() {
+  clearInterval(interval);
+});
+```
+
+Pong messages are automatically sent in response to ping messages as required by
+the spec.
+
+Just like the server example above, your clients might as well lose connection
+without knowing it. You might want to add a ping listener on your clients to
+prevent that. A simple implementation would be:
+
+```js
+import WebSocket from 'ws';
+
+function heartbeat() {
+  clearTimeout(this.pingTimeout);
+
+  // Use `WebSocket#terminate()`, which immediately destroys the connection,
+  // instead of `WebSocket#close()`, which waits for the close timer.
+  // Delay should be equal to the interval at which your server
+  // sends out pings plus a conservative assumption of the latency.
+  this.pingTimeout = setTimeout(() => {
+    this.terminate();
+  }, 30000 + 1000);
+}
+
+const client = new WebSocket('wss://websocket-echo.com/');
+
+client.on('error', console.error);
+client.on('open', heartbeat);
+client.on('ping', heartbeat);
+client.on('close', function clear() {
+  clearTimeout(this.pingTimeout);
+});
+```
+
+### How to connect via a proxy?
+
+Use a custom `http.Agent` implementation like [https-proxy-agent][] or
+[socks-proxy-agent][].
+
+## Changelog
+
+We're using the GitHub [releases][changelog] for changelog entries.
+
+## License
+
+[MIT](LICENSE)
+
+[`buffer.isutf8()`]: https://nodejs.org/api/buffer.html#bufferisutf8input
+[bufferutil]: https://github.com/websockets/bufferutil
+[changelog]: https://github.com/websockets/ws/releases
+[client-report]: http://websockets.github.io/ws/autobahn/clients/
+[https-proxy-agent]: https://github.com/TooTallNate/node-https-proxy-agent
+[node-zlib-bug]: https://github.com/nodejs/node/issues/8871
+[node-zlib-deflaterawdocs]:
+  https://nodejs.org/api/zlib.html#zlib_zlib_createdeflateraw_options
+[permessage-deflate]: https://tools.ietf.org/html/rfc7692
+[server-report]: http://websockets.github.io/ws/autobahn/servers/
+[session-parse-example]: ./examples/express-session-parse
+[socks-proxy-agent]: https://github.com/TooTallNate/node-socks-proxy-agent
+[utf-8-validate]: https://github.com/websockets/utf-8-validate
+[ws-server-options]: ./doc/ws.md#new-websocketserveroptions-callback

V3.1/build/ai_bridge_server/node_modules/ws/browser.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = function () {
+  throw new Error(
+    'ws does not work in the browser. Browser clients must use the native ' +
+      'WebSocket object'
+  );
+};

V3.1/build/ai_bridge_server/node_modules/ws/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const WebSocket = require('./lib/websocket');
+
+WebSocket.createWebSocketStream = require('./lib/stream');
+WebSocket.Server = require('./lib/websocket-server');
+WebSocket.Receiver = require('./lib/receiver');
+WebSocket.Sender = require('./lib/sender');
+
+WebSocket.WebSocket = WebSocket;
+WebSocket.WebSocketServer = WebSocket.Server;
+
+module.exports = WebSocket;

V3.1/build/ai_bridge_server/node_modules/ws/lib/buffer-util.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const { EMPTY_BUFFER } = require('./constants');
+
+const FastBuffer = Buffer[Symbol.species];
+
+/**
+ * Merges an array of buffers into a new buffer.
+ *
+ * @param {Buffer[]} list The array of buffers to concat
+ * @param {Number} totalLength The total length of buffers in the list
+ * @return {Buffer} The resulting buffer
+ * @public
+ */
+function concat(list, totalLength) {
+  if (list.length === 0) return EMPTY_BUFFER;
+  if (list.length === 1) return list[0];
+
+  const target = Buffer.allocUnsafe(totalLength);
+  let offset = 0;
+
+  for (let i = 0; i < list.length; i++) {
+    const buf = list[i];
+    target.set(buf, offset);
+    offset += buf.length;
+  }
+
+  if (offset < totalLength) {
+    return new FastBuffer(target.buffer, target.byteOffset, offset);
+  }
+
+  return target;
+}
+
+/**
+ * Masks a buffer using the given mask.
+ *
+ * @param {Buffer} source The buffer to mask
+ * @param {Buffer} mask The mask to use
+ * @param {Buffer} output The buffer where to store the result
+ * @param {Number} offset The offset at which to start writing
+ * @param {Number} length The number of bytes to mask.
+ * @public
+ */
+function _mask(source, mask, output, offset, length) {
+  for (let i = 0; i < length; i++) {
+    output[offset + i] = source[i] ^ mask[i & 3];
+  }
+}
+
+/**
+ * Unmasks a buffer using the given mask.
+ *
+ * @param {Buffer} buffer The buffer to unmask
+ * @param {Buffer} mask The mask to use
+ * @public
+ */
+function _unmask(buffer, mask) {
+  for (let i = 0; i < buffer.length; i++) {
+    buffer[i] ^= mask[i & 3];
+  }
+}
+
+/**
+ * Converts a buffer to an `ArrayBuffer`.
+ *
+ * @param {Buffer} buf The buffer to convert
+ * @return {ArrayBuffer} Converted buffer
+ * @public
+ */
+function toArrayBuffer(buf) {
+  if (buf.length === buf.buffer.byteLength) {
+    return buf.buffer;
+  }
+
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
+}
+
+/**
+ * Converts `data` to a `Buffer`.
+ *
+ * @param {*} data The data to convert
+ * @return {Buffer} The buffer
+ * @throws {TypeError}
+ * @public
+ */
+function toBuffer(data) {
+  toBuffer.readOnly = true;
+
+  if (Buffer.isBuffer(data)) return data;
+
+  let buf;
+
+  if (data instanceof ArrayBuffer) {
+    buf = new FastBuffer(data);
+  } else if (ArrayBuffer.isView(data)) {
+    buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
+  } else {
+    buf = Buffer.from(data);
+    toBuffer.readOnly = false;
+  }
+
+  return buf;
+}
+
+module.exports = {
+  concat,
+  mask: _mask,
+  toArrayBuffer,
+  toBuffer,
+  unmask: _unmask
+};
+
+/* istanbul ignore else  */
+if (!process.env.WS_NO_BUFFER_UTIL) {
+  try {
+    const bufferUtil = require('bufferutil');
+
+    module.exports.mask = function (source, mask, output, offset, length) {
+      if (length < 48) _mask(source, mask, output, offset, length);
+      else bufferUtil.mask(source, mask, output, offset, length);
+    };
+
+    module.exports.unmask = function (buffer, mask) {
+      if (buffer.length < 32) _unmask(buffer, mask);
+      else bufferUtil.unmask(buffer, mask);
+    };
+  } catch (e) {
+    // Continue regardless of the error.
+  }
+}

V3.1/build/ai_bridge_server/node_modules/ws/lib/constants.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const BINARY_TYPES = ['nodebuffer', 'arraybuffer', 'fragments'];
+const hasBlob = typeof Blob !== 'undefined';
+
+if (hasBlob) BINARY_TYPES.push('blob');
+
+module.exports = {
+  BINARY_TYPES,
+  CLOSE_TIMEOUT: 30000,
+  EMPTY_BUFFER: Buffer.alloc(0),
+  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
+  hasBlob,
+  kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),
+  kListener: Symbol('kListener'),
+  kStatusCode: Symbol('status-code'),
+  kWebSocket: Symbol('websocket'),
+  NOOP: () => {}
+};

V3.1/build/ai_bridge_server/node_modules/ws/lib/event-target.js

@@ -0,0 +1,292 @@
+'use strict';
+
+const { kForOnEventAttribute, kListener } = require('./constants');
+
+const kCode = Symbol('kCode');
+const kData = Symbol('kData');
+const kError = Symbol('kError');
+const kMessage = Symbol('kMessage');
+const kReason = Symbol('kReason');
+const kTarget = Symbol('kTarget');
+const kType = Symbol('kType');
+const kWasClean = Symbol('kWasClean');
+
+/**
+ * Class representing an event.
+ */
+class Event {
+  /**
+   * Create a new `Event`.
+   *
+   * @param {String} type The name of the event
+   * @throws {TypeError} If the `type` argument is not specified
+   */
+  constructor(type) {
+    this[kTarget] = null;
+    this[kType] = type;
+  }
+
+  /**
+   * @type {*}
+   */
+  get target() {
+    return this[kTarget];
+  }
+
+  /**
+   * @type {String}
+   */
+  get type() {
+    return this[kType];
+  }
+}
+
+Object.defineProperty(Event.prototype, 'target', { enumerable: true });
+Object.defineProperty(Event.prototype, 'type', { enumerable: true });
+
+/**
+ * Class representing a close event.
+ *
+ * @extends Event
+ */
+class CloseEvent extends Event {
+  /**
+   * Create a new `CloseEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {Number} [options.code=0] The status code explaining why the
+   *     connection was closed
+   * @param {String} [options.reason=''] A human-readable string explaining why
+   *     the connection was closed
+   * @param {Boolean} [options.wasClean=false] Indicates whether or not the
+   *     connection was cleanly closed
+   */
+  constructor(type, options = {}) {
+    super(type);
+
+    this[kCode] = options.code === undefined ? 0 : options.code;
+    this[kReason] = options.reason === undefined ? '' : options.reason;
+    this[kWasClean] = options.wasClean === undefined ? false : options.wasClean;
+  }
+
+  /**
+   * @type {Number}
+   */
+  get code() {
+    return this[kCode];
+  }
+
+  /**
+   * @type {String}
+   */
+  get reason() {
+    return this[kReason];
+  }
+
+  /**
+   * @type {Boolean}
+   */
+  get wasClean() {
+    return this[kWasClean];
+  }
+}
+
+Object.defineProperty(CloseEvent.prototype, 'code', { enumerable: true });
+Object.defineProperty(CloseEvent.prototype, 'reason', { enumerable: true });
+Object.defineProperty(CloseEvent.prototype, 'wasClean', { enumerable: true });
+
+/**
+ * Class representing an error event.
+ *
+ * @extends Event
+ */
+class ErrorEvent extends Event {
+  /**
+   * Create a new `ErrorEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {*} [options.error=null] The error that generated this event
+   * @param {String} [options.message=''] The error message
+   */
+  constructor(type, options = {}) {
+    super(type);
+
+    this[kError] = options.error === undefined ? null : options.error;
+    this[kMessage] = options.message === undefined ? '' : options.message;
+  }
+
+  /**
+   * @type {*}
+   */
+  get error() {
+    return this[kError];
+  }
+
+  /**
+   * @type {String}
+   */
+  get message() {
+    return this[kMessage];
+  }
+}
+
+Object.defineProperty(ErrorEvent.prototype, 'error', { enumerable: true });
+Object.defineProperty(ErrorEvent.prototype, 'message', { enumerable: true });
+
+/**
+ * Class representing a message event.
+ *
+ * @extends Event
+ */
+class MessageEvent extends Event {
+  /**
+   * Create a new `MessageEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {*} [options.data=null] The message content
+   */
+  constructor(type, options = {}) {
+    super(type);
+
+    this[kData] = options.data === undefined ? null : options.data;
+  }
+
+  /**
+   * @type {*}
+   */
+  get data() {
+    return this[kData];
+  }
+}
+
+Object.defineProperty(MessageEvent.prototype, 'data', { enumerable: true });
+
+/**
+ * This provides methods for emulating the `EventTarget` interface. It's not
+ * meant to be used directly.
+ *
+ * @mixin
+ */
+const EventTarget = {
+  /**
+   * Register an event listener.
+   *
+   * @param {String} type A string representing the event type to listen for
+   * @param {(Function|Object)} handler The listener to add
+   * @param {Object} [options] An options object specifies characteristics about
+   *     the event listener
+   * @param {Boolean} [options.once=false] A `Boolean` indicating that the
+   *     listener should be invoked at most once after being added. If `true`,
+   *     the listener would be automatically removed when invoked.
+   * @public
+   */
+  addEventListener(type, handler, options = {}) {
+    for (const listener of this.listeners(type)) {
+      if (
+        !options[kForOnEventAttribute] &&
+        listener[kListener] === handler &&
+        !listener[kForOnEventAttribute]
+      ) {
+        return;
+      }
+    }
+
+    let wrapper;
+
+    if (type === 'message') {
+      wrapper = function onMessage(data, isBinary) {
+        const event = new MessageEvent('message', {
+          data: isBinary ? data : data.toString()
+        });
+
+        event[kTarget] = this;
+        callListener(handler, this, event);
+      };
+    } else if (type === 'close') {
+      wrapper = function onClose(code, message) {
+        const event = new CloseEvent('close', {
+          code,
+          reason: message.toString(),
+          wasClean: this._closeFrameReceived && this._closeFrameSent
+        });
+
+        event[kTarget] = this;
+        callListener(handler, this, event);
+      };
+    } else if (type === 'error') {
+      wrapper = function onError(error) {
+        const event = new ErrorEvent('error', {
+          error,
+          message: error.message
+        });
+
+        event[kTarget] = this;
+        callListener(handler, this, event);
+      };
+    } else if (type === 'open') {
+      wrapper = function onOpen() {
+        const event = new Event('open');
+
+        event[kTarget] = this;
+        callListener(handler, this, event);
+      };
+    } else {
+      return;
+    }
+
+    wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
+    wrapper[kListener] = handler;
+
+    if (options.once) {
+      this.once(type, wrapper);
+    } else {
+      this.on(type, wrapper);
+    }
+  },
+
+  /**
+   * Remove an event listener.
+   *
+   * @param {String} type A string representing the event type to remove
+   * @param {(Function|Object)} handler The listener to remove
+   * @public
+   */
+  removeEventListener(type, handler) {
+    for (const listener of this.listeners(type)) {
+      if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
+        this.removeListener(type, listener);
+        break;
+      }
+    }
+  }
+};
+
+module.exports = {
+  CloseEvent,
+  ErrorEvent,
+  Event,
+  EventTarget,
+  MessageEvent
+};
+
+/**
+ * Call an event listener
+ *
+ * @param {(Function|Object)} listener The listener to call
+ * @param {*} thisArg The value to use as `this`` when calling the listener
+ * @param {Event} event The event to pass to the listener
+ * @private
+ */
+function callListener(listener, thisArg, event) {
+  if (typeof listener === 'object' && listener.handleEvent) {
+    listener.handleEvent.call(listener, event);
+  } else {
+    listener.call(thisArg, event);
+  }
+}

V3.1/build/ai_bridge_server/node_modules/ws/lib/extension.js

@@ -0,0 +1,203 @@
+'use strict';
+
+const { tokenChars } = require('./validation');
+
+/**
+ * Adds an offer to the map of extension offers or a parameter to the map of
+ * parameters.
+ *
+ * @param {Object} dest The map of extension offers or parameters
+ * @param {String} name The extension or parameter name
+ * @param {(Object|Boolean|String)} elem The extension parameters or the
+ *     parameter value
+ * @private
+ */
+function push(dest, name, elem) {
+  if (dest[name] === undefined) dest[name] = [elem];
+  else dest[name].push(elem);
+}
+
+/**
+ * Parses the `Sec-WebSocket-Extensions` header into an object.
+ *
+ * @param {String} header The field value of the header
+ * @return {Object} The parsed object
+ * @public
+ */
+function parse(header) {
+  const offers = Object.create(null);
+  let params = Object.create(null);
+  let mustUnescape = false;
+  let isEscaping = false;
+  let inQuotes = false;
+  let extensionName;
+  let paramName;
+  let start = -1;
+  let code = -1;
+  let end = -1;
+  let i = 0;
+
+  for (; i < header.length; i++) {
+    code = header.charCodeAt(i);
+
+    if (extensionName === undefined) {
+      if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (
+        i !== 0 &&
+        (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
+      ) {
+        if (end === -1 && start !== -1) end = i;
+      } else if (code === 0x3b /* ';' */ || code === 0x2c /* ',' */) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        const name = header.slice(start, end);
+        if (code === 0x2c) {
+          push(offers, name, params);
+          params = Object.create(null);
+        } else {
+          extensionName = name;
+        }
+
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    } else if (paramName === undefined) {
+      if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (code === 0x20 || code === 0x09) {
+        if (end === -1 && start !== -1) end = i;
+      } else if (code === 0x3b || code === 0x2c) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        push(params, header.slice(start, end), true);
+        if (code === 0x2c) {
+          push(offers, extensionName, params);
+          params = Object.create(null);
+          extensionName = undefined;
+        }
+
+        start = end = -1;
+      } else if (code === 0x3d /* '=' */ && start !== -1 && end === -1) {
+        paramName = header.slice(start, i);
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    } else {
+      //
+      // The value of a quoted-string after unescaping must conform to the
+      // token ABNF, so only token characters are valid.
+      // Ref: https://tools.ietf.org/html/rfc6455#section-9.1
+      //
+      if (isEscaping) {
+        if (tokenChars[code] !== 1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+        if (start === -1) start = i;
+        else if (!mustUnescape) mustUnescape = true;
+        isEscaping = false;
+      } else if (inQuotes) {
+        if (tokenChars[code] === 1) {
+          if (start === -1) start = i;
+        } else if (code === 0x22 /* '"' */ && start !== -1) {
+          inQuotes = false;
+          end = i;
+        } else if (code === 0x5c /* '\' */) {
+          isEscaping = true;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      } else if (code === 0x22 && header.charCodeAt(i - 1) === 0x3d) {
+        inQuotes = true;
+      } else if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (start !== -1 && (code === 0x20 || code === 0x09)) {
+        if (end === -1) end = i;
+      } else if (code === 0x3b || code === 0x2c) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        let value = header.slice(start, end);
+        if (mustUnescape) {
+          value = value.replace(/\\/g, '');
+          mustUnescape = false;
+        }
+        push(params, paramName, value);
+        if (code === 0x2c) {
+          push(offers, extensionName, params);
+          params = Object.create(null);
+          extensionName = undefined;
+        }
+
+        paramName = undefined;
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    }
+  }
+
+  if (start === -1 || inQuotes || code === 0x20 || code === 0x09) {
+    throw new SyntaxError('Unexpected end of input');
+  }
+
+  if (end === -1) end = i;
+  const token = header.slice(start, end);
+  if (extensionName === undefined) {
+    push(offers, token, params);
+  } else {
+    if (paramName === undefined) {
+      push(params, token, true);
+    } else if (mustUnescape) {
+      push(params, paramName, token.replace(/\\/g, ''));
+    } else {
+      push(params, paramName, token);
+    }
+    push(offers, extensionName, params);
+  }
+
+  return offers;
+}
+
+/**
+ * Builds the `Sec-WebSocket-Extensions` header field value.
+ *
+ * @param {Object} extensions The map of extensions and parameters to format
+ * @return {String} A string representing the given object
+ * @public
+ */
+function format(extensions) {
+  return Object.keys(extensions)
+    .map((extension) => {
+      let configurations = extensions[extension];
+      if (!Array.isArray(configurations)) configurations = [configurations];
+      return configurations
+        .map((params) => {
+          return [extension]
+            .concat(
+              Object.keys(params).map((k) => {
+                let values = params[k];
+                if (!Array.isArray(values)) values = [values];
+                return values
+                  .map((v) => (v === true ? k : `${k}=${v}`))
+                  .join('; ');
+              })
+            )
+            .join('; ');
+        })
+        .join(', ');
+    })
+    .join(', ');
+}
+
+module.exports = { format, parse };

V3.1/build/ai_bridge_server/node_modules/ws/lib/limiter.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const kDone = Symbol('kDone');
+const kRun = Symbol('kRun');
+
+/**
+ * A very simple job queue with adjustable concurrency. Adapted from
+ * https://github.com/STRML/async-limiter
+ */
+class Limiter {
+  /**
+   * Creates a new `Limiter`.
+   *
+   * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
+   *     to run concurrently
+   */
+  constructor(concurrency) {
+    this[kDone] = () => {
+      this.pending--;
+      this[kRun]();
+    };
+    this.concurrency = concurrency || Infinity;
+    this.jobs = [];
+    this.pending = 0;
+  }
+
+  /**
+   * Adds a job to the queue.
+   *
+   * @param {Function} job The job to run
+   * @public
+   */
+  add(job) {
+    this.jobs.push(job);
+    this[kRun]();
+  }
+
+  /**
+   * Removes a job from the queue and runs it if possible.
+   *
+   * @private
+   */
+  [kRun]() {
+    if (this.pending === this.concurrency) return;
+
+    if (this.jobs.length) {
+      const job = this.jobs.shift();
+
+      this.pending++;
+      job(this[kDone]);
+    }
+  }
+}
+
+module.exports = Limiter;

V3.1/build/ai_bridge_server/node_modules/ws/lib/permessage-deflate.js

@@ -0,0 +1,528 @@
+'use strict';
+
+const zlib = require('zlib');
+
+const bufferUtil = require('./buffer-util');
+const Limiter = require('./limiter');
+const { kStatusCode } = require('./constants');
+
+const FastBuffer = Buffer[Symbol.species];
+const TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
+const kPerMessageDeflate = Symbol('permessage-deflate');
+const kTotalLength = Symbol('total-length');
+const kCallback = Symbol('callback');
+const kBuffers = Symbol('buffers');
+const kError = Symbol('error');
+
+//
+// We limit zlib concurrency, which prevents severe memory fragmentation
+// as documented in https://github.com/nodejs/node/issues/8871#issuecomment-250915913
+// and https://github.com/websockets/ws/issues/1202
+//
+// Intentionally global; it's the global thread pool that's an issue.
+//
+let zlibLimiter;
+
+/**
+ * permessage-deflate implementation.
+ */
+class PerMessageDeflate {
+  /**
+   * Creates a PerMessageDeflate instance.
+   *
+   * @param {Object} [options] Configuration options
+   * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
+   *     for, or request, a custom client window size
+   * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
+   *     acknowledge disabling of client context takeover
+   * @param {Number} [options.concurrencyLimit=10] The number of concurrent
+   *     calls to zlib
+   * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
+   *     use of a custom server window size
+   * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
+   *     disabling of server context takeover
+   * @param {Number} [options.threshold=1024] Size (in bytes) below which
+   *     messages should not be compressed if context takeover is disabled
+   * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
+   *     deflate
+   * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
+   *     inflate
+   * @param {Boolean} [isServer=false] Create the instance in either server or
+   *     client mode
+   * @param {Number} [maxPayload=0] The maximum allowed message length
+   */
+  constructor(options, isServer, maxPayload) {
+    this._maxPayload = maxPayload | 0;
+    this._options = options || {};
+    this._threshold =
+      this._options.threshold !== undefined ? this._options.threshold : 1024;
+    this._isServer = !!isServer;
+    this._deflate = null;
+    this._inflate = null;
+
+    this.params = null;
+
+    if (!zlibLimiter) {
+      const concurrency =
+        this._options.concurrencyLimit !== undefined
+          ? this._options.concurrencyLimit
+          : 10;
+      zlibLimiter = new Limiter(concurrency);
+    }
+  }
+
+  /**
+   * @type {String}
+   */
+  static get extensionName() {
+    return 'permessage-deflate';
+  }
+
+  /**
+   * Create an extension negotiation offer.
+   *
+   * @return {Object} Extension parameters
+   * @public
+   */
+  offer() {
+    const params = {};
+
+    if (this._options.serverNoContextTakeover) {
+      params.server_no_context_takeover = true;
+    }
+    if (this._options.clientNoContextTakeover) {
+      params.client_no_context_takeover = true;
+    }
+    if (this._options.serverMaxWindowBits) {
+      params.server_max_window_bits = this._options.serverMaxWindowBits;
+    }
+    if (this._options.clientMaxWindowBits) {
+      params.client_max_window_bits = this._options.clientMaxWindowBits;
+    } else if (this._options.clientMaxWindowBits == null) {
+      params.client_max_window_bits = true;
+    }
+
+    return params;
+  }
+
+  /**
+   * Accept an extension negotiation offer/response.
+   *
+   * @param {Array} configurations The extension negotiation offers/reponse
+   * @return {Object} Accepted configuration
+   * @public
+   */
+  accept(configurations) {
+    configurations = this.normalizeParams(configurations);
+
+    this.params = this._isServer
+      ? this.acceptAsServer(configurations)
+      : this.acceptAsClient(configurations);
+
+    return this.params;
+  }
+
+  /**
+   * Releases all resources used by the extension.
+   *
+   * @public
+   */
+  cleanup() {
+    if (this._inflate) {
+      this._inflate.close();
+      this._inflate = null;
+    }
+
+    if (this._deflate) {
+      const callback = this._deflate[kCallback];
+
+      this._deflate.close();
+      this._deflate = null;
+
+      if (callback) {
+        callback(
+          new Error(
+            'The deflate stream was closed while data was being processed'
+          )
+        );
+      }
+    }
+  }
+
+  /**
+   *  Accept an extension negotiation offer.
+   *
+   * @param {Array} offers The extension negotiation offers
+   * @return {Object} Accepted configuration
+   * @private
+   */
+  acceptAsServer(offers) {
+    const opts = this._options;
+    const accepted = offers.find((params) => {
+      if (
+        (opts.serverNoContextTakeover === false &&
+          params.server_no_context_takeover) ||
+        (params.server_max_window_bits &&
+          (opts.serverMaxWindowBits === false ||
+            (typeof opts.serverMaxWindowBits === 'number' &&
+              opts.serverMaxWindowBits > params.server_max_window_bits))) ||
+        (typeof opts.clientMaxWindowBits === 'number' &&
+          !params.client_max_window_bits)
+      ) {
+        return false;
+      }
+
+      return true;
+    });
+
+    if (!accepted) {
+      throw new Error('None of the extension offers can be accepted');
+    }
+
+    if (opts.serverNoContextTakeover) {
+      accepted.server_no_context_takeover = true;
+    }
+    if (opts.clientNoContextTakeover) {
+      accepted.client_no_context_takeover = true;
+    }
+    if (typeof opts.serverMaxWindowBits === 'number') {
+      accepted.server_max_window_bits = opts.serverMaxWindowBits;
+    }
+    if (typeof opts.clientMaxWindowBits === 'number') {
+      accepted.client_max_window_bits = opts.clientMaxWindowBits;
+    } else if (
+      accepted.client_max_window_bits === true ||
+      opts.clientMaxWindowBits === false
+    ) {
+      delete accepted.client_max_window_bits;
+    }
+
+    return accepted;
+  }
+
+  /**
+   * Accept the extension negotiation response.
+   *
+   * @param {Array} response The extension negotiation response
+   * @return {Object} Accepted configuration
+   * @private
+   */
+  acceptAsClient(response) {
+    const params = response[0];
+
+    if (
+      this._options.clientNoContextTakeover === false &&
+      params.client_no_context_takeover
+    ) {
+      throw new Error('Unexpected parameter "client_no_context_takeover"');
+    }
+
+    if (!params.client_max_window_bits) {
+      if (typeof this._options.clientMaxWindowBits === 'number') {
+        params.client_max_window_bits = this._options.clientMaxWindowBits;
+      }
+    } else if (
+      this._options.clientMaxWindowBits === false ||
+      (typeof this._options.clientMaxWindowBits === 'number' &&
+        params.client_max_window_bits > this._options.clientMaxWindowBits)
+    ) {
+      throw new Error(
+        'Unexpected or invalid parameter "client_max_window_bits"'
+      );
+    }
+
+    return params;
+  }
+
+  /**
+   * Normalize parameters.
+   *
+   * @param {Array} configurations The extension negotiation offers/reponse
+   * @return {Array} The offers/response with normalized parameters
+   * @private
+   */
+  normalizeParams(configurations) {
+    configurations.forEach((params) => {
+      Object.keys(params).forEach((key) => {
+        let value = params[key];
+
+        if (value.length > 1) {
+          throw new Error(`Parameter "${key}" must have only a single value`);
+        }
+
+        value = value[0];
+
+        if (key === 'client_max_window_bits') {
+          if (value !== true) {
+            const num = +value;
+            if (!Number.isInteger(num) || num < 8 || num > 15) {
+              throw new TypeError(
+                `Invalid value for parameter "${key}": ${value}`
+              );
+            }
+            value = num;
+          } else if (!this._isServer) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+        } else if (key === 'server_max_window_bits') {
+          const num = +value;
+          if (!Number.isInteger(num) || num < 8 || num > 15) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+          value = num;
+        } else if (
+          key === 'client_no_context_takeover' ||
+          key === 'server_no_context_takeover'
+        ) {
+          if (value !== true) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+        } else {
+          throw new Error(`Unknown parameter "${key}"`);
+        }
+
+        params[key] = value;
+      });
+    });
+
+    return configurations;
+  }
+
+  /**
+   * Decompress data. Concurrency limited.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @public
+   */
+  decompress(data, fin, callback) {
+    zlibLimiter.add((done) => {
+      this._decompress(data, fin, (err, result) => {
+        done();
+        callback(err, result);
+      });
+    });
+  }
+
+  /**
+   * Compress data. Concurrency limited.
+   *
+   * @param {(Buffer|String)} data Data to compress
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @public
+   */
+  compress(data, fin, callback) {
+    zlibLimiter.add((done) => {
+      this._compress(data, fin, (err, result) => {
+        done();
+        callback(err, result);
+      });
+    });
+  }
+
+  /**
+   * Decompress data.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @private
+   */
+  _decompress(data, fin, callback) {
+    const endpoint = this._isServer ? 'client' : 'server';
+
+    if (!this._inflate) {
+      const key = `${endpoint}_max_window_bits`;
+      const windowBits =
+        typeof this.params[key] !== 'number'
+          ? zlib.Z_DEFAULT_WINDOWBITS
+          : this.params[key];
+
+      this._inflate = zlib.createInflateRaw({
+        ...this._options.zlibInflateOptions,
+        windowBits
+      });
+      this._inflate[kPerMessageDeflate] = this;
+      this._inflate[kTotalLength] = 0;
+      this._inflate[kBuffers] = [];
+      this._inflate.on('error', inflateOnError);
+      this._inflate.on('data', inflateOnData);
+    }
+
+    this._inflate[kCallback] = callback;
+
+    this._inflate.write(data);
+    if (fin) this._inflate.write(TRAILER);
+
+    this._inflate.flush(() => {
+      const err = this._inflate[kError];
+
+      if (err) {
+        this._inflate.close();
+        this._inflate = null;
+        callback(err);
+        return;
+      }
+
+      const data = bufferUtil.concat(
+        this._inflate[kBuffers],
+        this._inflate[kTotalLength]
+      );
+
+      if (this._inflate._readableState.endEmitted) {
+        this._inflate.close();
+        this._inflate = null;
+      } else {
+        this._inflate[kTotalLength] = 0;
+        this._inflate[kBuffers] = [];
+
+        if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+          this._inflate.reset();
+        }
+      }
+
+      callback(null, data);
+    });
+  }
+
+  /**
+   * Compress data.
+   *
+   * @param {(Buffer|String)} data Data to compress
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @private
+   */
+  _compress(data, fin, callback) {
+    const endpoint = this._isServer ? 'server' : 'client';
+
+    if (!this._deflate) {
+      const key = `${endpoint}_max_window_bits`;
+      const windowBits =
+        typeof this.params[key] !== 'number'
+          ? zlib.Z_DEFAULT_WINDOWBITS
+          : this.params[key];
+
+      this._deflate = zlib.createDeflateRaw({
+        ...this._options.zlibDeflateOptions,
+        windowBits
+      });
+
+      this._deflate[kTotalLength] = 0;
+      this._deflate[kBuffers] = [];
+
+      this._deflate.on('data', deflateOnData);
+    }
+
+    this._deflate[kCallback] = callback;
+
+    this._deflate.write(data);
+    this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
+      if (!this._deflate) {
+        //
+        // The deflate stream was closed while data was being processed.
+        //
+        return;
+      }
+
+      let data = bufferUtil.concat(
+        this._deflate[kBuffers],
+        this._deflate[kTotalLength]
+      );
+
+      if (fin) {
+        data = new FastBuffer(data.buffer, data.byteOffset, data.length - 4);
+      }
+
+      //
+      // Ensure that the callback will not be called again in
+      // `PerMessageDeflate#cleanup()`.
+      //
+      this._deflate[kCallback] = null;
+
+      this._deflate[kTotalLength] = 0;
+      this._deflate[kBuffers] = [];
+
+      if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+        this._deflate.reset();
+      }
+
+      callback(null, data);
+    });
+  }
+}
+
+module.exports = PerMessageDeflate;
+
+/**
+ * The listener of the `zlib.DeflateRaw` stream `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function deflateOnData(chunk) {
+  this[kBuffers].push(chunk);
+  this[kTotalLength] += chunk.length;
+}
+
+/**
+ * The listener of the `zlib.InflateRaw` stream `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function inflateOnData(chunk) {
+  this[kTotalLength] += chunk.length;
+
+  if (
+    this[kPerMessageDeflate]._maxPayload < 1 ||
+    this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload
+  ) {
+    this[kBuffers].push(chunk);
+    return;
+  }
+
+  this[kError] = new RangeError('Max payload size exceeded');
+  this[kError].code = 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH';
+  this[kError][kStatusCode] = 1009;
+  this.removeListener('data', inflateOnData);
+
+  //
+  // The choice to employ `zlib.reset()` over `zlib.close()` is dictated by the
+  // fact that in Node.js versions prior to 13.10.0, the callback for
+  // `zlib.flush()` is not called if `zlib.close()` is used. Utilizing
+  // `zlib.reset()` ensures that either the callback is invoked or an error is
+  // emitted.
+  //
+  this.reset();
+}
+
+/**
+ * The listener of the `zlib.InflateRaw` stream `'error'` event.
+ *
+ * @param {Error} err The emitted error
+ * @private
+ */
+function inflateOnError(err) {
+  //
+  // There is no need to call `Zlib#close()` as the handle is automatically
+  // closed when an error is emitted.
+  //
+  this[kPerMessageDeflate]._inflate = null;
+
+  if (this[kError]) {
+    this[kCallback](this[kError]);
+    return;
+  }
+
+  err[kStatusCode] = 1007;
+  this[kCallback](err);
+}

V3.1/build/ai_bridge_server/node_modules/ws/lib/receiver.js

@@ -0,0 +1,706 @@
+'use strict';
+
+const { Writable } = require('stream');
+
+const PerMessageDeflate = require('./permessage-deflate');
+const {
+  BINARY_TYPES,
+  EMPTY_BUFFER,
+  kStatusCode,
+  kWebSocket
+} = require('./constants');
+const { concat, toArrayBuffer, unmask } = require('./buffer-util');
+const { isValidStatusCode, isValidUTF8 } = require('./validation');
+
+const FastBuffer = Buffer[Symbol.species];
+
+const GET_INFO = 0;
+const GET_PAYLOAD_LENGTH_16 = 1;
+const GET_PAYLOAD_LENGTH_64 = 2;
+const GET_MASK = 3;
+const GET_DATA = 4;
+const INFLATING = 5;
+const DEFER_EVENT = 6;
+
+/**
+ * HyBi Receiver implementation.
+ *
+ * @extends Writable
+ */
+class Receiver extends Writable {
+  /**
+   * Creates a Receiver instance.
+   *
+   * @param {Object} [options] Options object
+   * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
+   *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+   *     multiple times in the same tick
+   * @param {String} [options.binaryType=nodebuffer] The type for binary data
+   * @param {Object} [options.extensions] An object containing the negotiated
+   *     extensions
+   * @param {Boolean} [options.isServer=false] Specifies whether to operate in
+   *     client or server mode
+   * @param {Number} [options.maxPayload=0] The maximum allowed message length
+   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+   *     not to skip UTF-8 validation for text and close messages
+   */
+  constructor(options = {}) {
+    super();
+
+    this._allowSynchronousEvents =
+      options.allowSynchronousEvents !== undefined
+        ? options.allowSynchronousEvents
+        : true;
+    this._binaryType = options.binaryType || BINARY_TYPES[0];
+    this._extensions = options.extensions || {};
+    this._isServer = !!options.isServer;
+    this._maxPayload = options.maxPayload | 0;
+    this._skipUTF8Validation = !!options.skipUTF8Validation;
+    this[kWebSocket] = undefined;
+
+    this._bufferedBytes = 0;
+    this._buffers = [];
+
+    this._compressed = false;
+    this._payloadLength = 0;
+    this._mask = undefined;
+    this._fragmented = 0;
+    this._masked = false;
+    this._fin = false;
+    this._opcode = 0;
+
+    this._totalPayloadLength = 0;
+    this._messageLength = 0;
+    this._fragments = [];
+
+    this._errored = false;
+    this._loop = false;
+    this._state = GET_INFO;
+  }
+
+  /**
+   * Implements `Writable.prototype._write()`.
+   *
+   * @param {Buffer} chunk The chunk of data to write
+   * @param {String} encoding The character encoding of `chunk`
+   * @param {Function} cb Callback
+   * @private
+   */
+  _write(chunk, encoding, cb) {
+    if (this._opcode === 0x08 && this._state == GET_INFO) return cb();
+
+    this._bufferedBytes += chunk.length;
+    this._buffers.push(chunk);
+    this.startLoop(cb);
+  }
+
+  /**
+   * Consumes `n` bytes from the buffered data.
+   *
+   * @param {Number} n The number of bytes to consume
+   * @return {Buffer} The consumed bytes
+   * @private
+   */
+  consume(n) {
+    this._bufferedBytes -= n;
+
+    if (n === this._buffers[0].length) return this._buffers.shift();
+
+    if (n < this._buffers[0].length) {
+      const buf = this._buffers[0];
+      this._buffers[0] = new FastBuffer(
+        buf.buffer,
+        buf.byteOffset + n,
+        buf.length - n
+      );
+
+      return new FastBuffer(buf.buffer, buf.byteOffset, n);
+    }
+
+    const dst = Buffer.allocUnsafe(n);
+
+    do {
+      const buf = this._buffers[0];
+      const offset = dst.length - n;
+
+      if (n >= buf.length) {
+        dst.set(this._buffers.shift(), offset);
+      } else {
+        dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
+        this._buffers[0] = new FastBuffer(
+          buf.buffer,
+          buf.byteOffset + n,
+          buf.length - n
+        );
+      }
+
+      n -= buf.length;
+    } while (n > 0);
+
+    return dst;
+  }
+
+  /**
+   * Starts the parsing loop.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  startLoop(cb) {
+    this._loop = true;
+
+    do {
+      switch (this._state) {
+        case GET_INFO:
+          this.getInfo(cb);
+          break;
+        case GET_PAYLOAD_LENGTH_16:
+          this.getPayloadLength16(cb);
+          break;
+        case GET_PAYLOAD_LENGTH_64:
+          this.getPayloadLength64(cb);
+          break;
+        case GET_MASK:
+          this.getMask();
+          break;
+        case GET_DATA:
+          this.getData(cb);
+          break;
+        case INFLATING:
+        case DEFER_EVENT:
+          this._loop = false;
+          return;
+      }
+    } while (this._loop);
+
+    if (!this._errored) cb();
+  }
+
+  /**
+   * Reads the first two bytes of a frame.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  getInfo(cb) {
+    if (this._bufferedBytes < 2) {
+      this._loop = false;
+      return;
+    }
+
+    const buf = this.consume(2);
+
+    if ((buf[0] & 0x30) !== 0x00) {
+      const error = this.createError(
+        RangeError,
+        'RSV2 and RSV3 must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_RSV_2_3'
+      );
+
+      cb(error);
+      return;
+    }
+
+    const compressed = (buf[0] & 0x40) === 0x40;
+
+    if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
+      const error = this.createError(
+        RangeError,
+        'RSV1 must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_RSV_1'
+      );
+
+      cb(error);
+      return;
+    }
+
+    this._fin = (buf[0] & 0x80) === 0x80;
+    this._opcode = buf[0] & 0x0f;
+    this._payloadLength = buf[1] & 0x7f;
+
+    if (this._opcode === 0x00) {
+      if (compressed) {
+        const error = this.createError(
+          RangeError,
+          'RSV1 must be clear',
+          true,
+          1002,
+          'WS_ERR_UNEXPECTED_RSV_1'
+        );
+
+        cb(error);
+        return;
+      }
+
+      if (!this._fragmented) {
+        const error = this.createError(
+          RangeError,
+          'invalid opcode 0',
+          true,
+          1002,
+          'WS_ERR_INVALID_OPCODE'
+        );
+
+        cb(error);
+        return;
+      }
+
+      this._opcode = this._fragmented;
+    } else if (this._opcode === 0x01 || this._opcode === 0x02) {
+      if (this._fragmented) {
+        const error = this.createError(
+          RangeError,
+          `invalid opcode ${this._opcode}`,
+          true,
+          1002,
+          'WS_ERR_INVALID_OPCODE'
+        );
+
+        cb(error);
+        return;
+      }
+
+      this._compressed = compressed;
+    } else if (this._opcode > 0x07 && this._opcode < 0x0b) {
+      if (!this._fin) {
+        const error = this.createError(
+          RangeError,
+          'FIN must be set',
+          true,
+          1002,
+          'WS_ERR_EXPECTED_FIN'
+        );
+
+        cb(error);
+        return;
+      }
+
+      if (compressed) {
+        const error = this.createError(
+          RangeError,
+          'RSV1 must be clear',
+          true,
+          1002,
+          'WS_ERR_UNEXPECTED_RSV_1'
+        );
+
+        cb(error);
+        return;
+      }
+
+      if (
+        this._payloadLength > 0x7d ||
+        (this._opcode === 0x08 && this._payloadLength === 1)
+      ) {
+        const error = this.createError(
+          RangeError,
+          `invalid payload length ${this._payloadLength}`,
+          true,
+          1002,
+          'WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH'
+        );
+
+        cb(error);
+        return;
+      }
+    } else {
+      const error = this.createError(
+        RangeError,
+        `invalid opcode ${this._opcode}`,
+        true,
+        1002,
+        'WS_ERR_INVALID_OPCODE'
+      );
+
+      cb(error);
+      return;
+    }
+
+    if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
+    this._masked = (buf[1] & 0x80) === 0x80;
+
+    if (this._isServer) {
+      if (!this._masked) {
+        const error = this.createError(
+          RangeError,
+          'MASK must be set',
+          true,
+          1002,
+          'WS_ERR_EXPECTED_MASK'
+        );
+
+        cb(error);
+        return;
+      }
+    } else if (this._masked) {
+      const error = this.createError(
+        RangeError,
+        'MASK must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_MASK'
+      );
+
+      cb(error);
+      return;
+    }
+
+    if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
+    else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
+    else this.haveLength(cb);
+  }
+
+  /**
+   * Gets extended payload length (7+16).
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  getPayloadLength16(cb) {
+    if (this._bufferedBytes < 2) {
+      this._loop = false;
+      return;
+    }
+
+    this._payloadLength = this.consume(2).readUInt16BE(0);
+    this.haveLength(cb);
+  }
+
+  /**
+   * Gets extended payload length (7+64).
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  getPayloadLength64(cb) {
+    if (this._bufferedBytes < 8) {
+      this._loop = false;
+      return;
+    }
+
+    const buf = this.consume(8);
+    const num = buf.readUInt32BE(0);
+
+    //
+    // The maximum safe integer in JavaScript is 2^53 - 1. An error is returned
+    // if payload length is greater than this number.
+    //
+    if (num > Math.pow(2, 53 - 32) - 1) {
+      const error = this.createError(
+        RangeError,
+        'Unsupported WebSocket frame: payload length > 2^53 - 1',
+        false,
+        1009,
+        'WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH'
+      );
+
+      cb(error);
+      return;
+    }
+
+    this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
+    this.haveLength(cb);
+  }
+
+  /**
+   * Payload length has been read.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  haveLength(cb) {
+    if (this._payloadLength && this._opcode < 0x08) {
+      this._totalPayloadLength += this._payloadLength;
+      if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
+        const error = this.createError(
+          RangeError,
+          'Max payload size exceeded',
+          false,
+          1009,
+          'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
+        );
+
+        cb(error);
+        return;
+      }
+    }
+
+    if (this._masked) this._state = GET_MASK;
+    else this._state = GET_DATA;
+  }
+
+  /**
+   * Reads mask bytes.
+   *
+   * @private
+   */
+  getMask() {
+    if (this._bufferedBytes < 4) {
+      this._loop = false;
+      return;
+    }
+
+    this._mask = this.consume(4);
+    this._state = GET_DATA;
+  }
+
+  /**
+   * Reads data bytes.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  getData(cb) {
+    let data = EMPTY_BUFFER;
+
+    if (this._payloadLength) {
+      if (this._bufferedBytes < this._payloadLength) {
+        this._loop = false;
+        return;
+      }
+
+      data = this.consume(this._payloadLength);
+
+      if (
+        this._masked &&
+        (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0
+      ) {
+        unmask(data, this._mask);
+      }
+    }
+
+    if (this._opcode > 0x07) {
+      this.controlMessage(data, cb);
+      return;
+    }
+
+    if (this._compressed) {
+      this._state = INFLATING;
+      this.decompress(data, cb);
+      return;
+    }
+
+    if (data.length) {
+      //
+      // This message is not compressed so its length is the sum of the payload
+      // length of all fragments.
+      //
+      this._messageLength = this._totalPayloadLength;
+      this._fragments.push(data);
+    }
+
+    this.dataMessage(cb);
+  }
+
+  /**
+   * Decompresses data.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Function} cb Callback
+   * @private
+   */
+  decompress(data, cb) {
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+
+    perMessageDeflate.decompress(data, this._fin, (err, buf) => {
+      if (err) return cb(err);
+
+      if (buf.length) {
+        this._messageLength += buf.length;
+        if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
+          const error = this.createError(
+            RangeError,
+            'Max payload size exceeded',
+            false,
+            1009,
+            'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
+          );
+
+          cb(error);
+          return;
+        }
+
+        this._fragments.push(buf);
+      }
+
+      this.dataMessage(cb);
+      if (this._state === GET_INFO) this.startLoop(cb);
+    });
+  }
+
+  /**
+   * Handles a data message.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  dataMessage(cb) {
+    if (!this._fin) {
+      this._state = GET_INFO;
+      return;
+    }
+
+    const messageLength = this._messageLength;
+    const fragments = this._fragments;
+
+    this._totalPayloadLength = 0;
+    this._messageLength = 0;
+    this._fragmented = 0;
+    this._fragments = [];
+
+    if (this._opcode === 2) {
+      let data;
+
+      if (this._binaryType === 'nodebuffer') {
+        data = concat(fragments, messageLength);
+      } else if (this._binaryType === 'arraybuffer') {
+        data = toArrayBuffer(concat(fragments, messageLength));
+      } else if (this._binaryType === 'blob') {
+        data = new Blob(fragments);
+      } else {
+        data = fragments;
+      }
+
+      if (this._allowSynchronousEvents) {
+        this.emit('message', data, true);
+        this._state = GET_INFO;
+      } else {
+        this._state = DEFER_EVENT;
+        setImmediate(() => {
+          this.emit('message', data, true);
+          this._state = GET_INFO;
+          this.startLoop(cb);
+        });
+      }
+    } else {
+      const buf = concat(fragments, messageLength);
+
+      if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+        const error = this.createError(
+          Error,
+          'invalid UTF-8 sequence',
+          true,
+          1007,
+          'WS_ERR_INVALID_UTF8'
+        );
+
+        cb(error);
+        return;
+      }
+
+      if (this._state === INFLATING || this._allowSynchronousEvents) {
+        this.emit('message', buf, false);
+        this._state = GET_INFO;
+      } else {
+        this._state = DEFER_EVENT;
+        setImmediate(() => {
+          this.emit('message', buf, false);
+          this._state = GET_INFO;
+          this.startLoop(cb);
+        });
+      }
+    }
+  }
+
+  /**
+   * Handles a control message.
+   *
+   * @param {Buffer} data Data to handle
+   * @return {(Error|RangeError|undefined)} A possible error
+   * @private
+   */
+  controlMessage(data, cb) {
+    if (this._opcode === 0x08) {
+      if (data.length === 0) {
+        this._loop = false;
+        this.emit('conclude', 1005, EMPTY_BUFFER);
+        this.end();
+      } else {
+        const code = data.readUInt16BE(0);
+
+        if (!isValidStatusCode(code)) {
+          const error = this.createError(
+            RangeError,
+            `invalid status code ${code}`,
+            true,
+            1002,
+            'WS_ERR_INVALID_CLOSE_CODE'
+          );
+
+          cb(error);
+          return;
+        }
+
+        const buf = new FastBuffer(
+          data.buffer,
+          data.byteOffset + 2,
+          data.length - 2
+        );
+
+        if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+          const error = this.createError(
+            Error,
+            'invalid UTF-8 sequence',
+            true,
+            1007,
+            'WS_ERR_INVALID_UTF8'
+          );
+
+          cb(error);
+          return;
+        }
+
+        this._loop = false;
+        this.emit('conclude', code, buf);
+        this.end();
+      }
+
+      this._state = GET_INFO;
+      return;
+    }
+
+    if (this._allowSynchronousEvents) {
+      this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
+      this._state = GET_INFO;
+    } else {
+      this._state = DEFER_EVENT;
+      setImmediate(() => {
+        this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
+        this._state = GET_INFO;
+        this.startLoop(cb);
+      });
+    }
+  }
+
+  /**
+   * Builds an error object.
+   *
+   * @param {function(new: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
+   */
+  createError(ErrorCtor, message, prefix, statusCode, errorCode) {
+    this._loop = false;
+    this._errored = true;
+
+    const err = new ErrorCtor(
+      prefix ? `Invalid WebSocket frame: ${message}` : message
+    );
+
+    Error.captureStackTrace(err, this.createError);
+    err.code = errorCode;
+    err[kStatusCode] = statusCode;
+    return err;
+  }
+}
+
+module.exports = Receiver;

V3.1/build/ai_bridge_server/node_modules/ws/lib/sender.js

@@ -0,0 +1,602 @@
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex" }] */
+
+'use strict';
+
+const { Duplex } = require('stream');
+const { randomFillSync } = require('crypto');
+
+const PerMessageDeflate = require('./permessage-deflate');
+const { EMPTY_BUFFER, kWebSocket, NOOP } = require('./constants');
+const { isBlob, isValidStatusCode } = require('./validation');
+const { mask: applyMask, toBuffer } = require('./buffer-util');
+
+const kByteLength = Symbol('kByteLength');
+const maskBuffer = Buffer.alloc(4);
+const RANDOM_POOL_SIZE = 8 * 1024;
+let randomPool;
+let randomPoolPointer = RANDOM_POOL_SIZE;
+
+const DEFAULT = 0;
+const DEFLATING = 1;
+const GET_BLOB_DATA = 2;
+
+/**
+ * HyBi Sender implementation.
+ */
+class Sender {
+  /**
+   * Creates a Sender instance.
+   *
+   * @param {Duplex} socket The connection socket
+   * @param {Object} [extensions] An object containing the negotiated extensions
+   * @param {Function} [generateMask] The function used to generate the masking
+   *     key
+   */
+  constructor(socket, extensions, generateMask) {
+    this._extensions = extensions || {};
+
+    if (generateMask) {
+      this._generateMask = generateMask;
+      this._maskBuffer = Buffer.alloc(4);
+    }
+
+    this._socket = socket;
+
+    this._firstFragment = true;
+    this._compress = false;
+
+    this._bufferedBytes = 0;
+    this._queue = [];
+    this._state = DEFAULT;
+    this.onerror = NOOP;
+    this[kWebSocket] = undefined;
+  }
+
+  /**
+   * Frames a piece of data according to the HyBi WebSocket protocol.
+   *
+   * @param {(Buffer|String)} data The data to frame
+   * @param {Object} options Options object
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+   *     key
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @return {(Buffer|String)[]} The framed data
+   * @public
+   */
+  static frame(data, options) {
+    let mask;
+    let merge = false;
+    let offset = 2;
+    let skipMasking = false;
+
+    if (options.mask) {
+      mask = options.maskBuffer || maskBuffer;
+
+      if (options.generateMask) {
+        options.generateMask(mask);
+      } else {
+        if (randomPoolPointer === RANDOM_POOL_SIZE) {
+          /* istanbul ignore else  */
+          if (randomPool === undefined) {
+            //
+            // This is lazily initialized because server-sent frames must not
+            // be masked so it may never be used.
+            //
+            randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
+          }
+
+          randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
+          randomPoolPointer = 0;
+        }
+
+        mask[0] = randomPool[randomPoolPointer++];
+        mask[1] = randomPool[randomPoolPointer++];
+        mask[2] = randomPool[randomPoolPointer++];
+        mask[3] = randomPool[randomPoolPointer++];
+      }
+
+      skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
+      offset = 6;
+    }
+
+    let dataLength;
+
+    if (typeof data === 'string') {
+      if (
+        (!options.mask || skipMasking) &&
+        options[kByteLength] !== undefined
+      ) {
+        dataLength = options[kByteLength];
+      } else {
+        data = Buffer.from(data);
+        dataLength = data.length;
+      }
+    } else {
+      dataLength = data.length;
+      merge = options.mask && options.readOnly && !skipMasking;
+    }
+
+    let payloadLength = dataLength;
+
+    if (dataLength >= 65536) {
+      offset += 8;
+      payloadLength = 127;
+    } else if (dataLength > 125) {
+      offset += 2;
+      payloadLength = 126;
+    }
+
+    const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);
+
+    target[0] = options.fin ? options.opcode | 0x80 : options.opcode;
+    if (options.rsv1) target[0] |= 0x40;
+
+    target[1] = payloadLength;
+
+    if (payloadLength === 126) {
+      target.writeUInt16BE(dataLength, 2);
+    } else if (payloadLength === 127) {
+      target[2] = target[3] = 0;
+      target.writeUIntBE(dataLength, 4, 6);
+    }
+
+    if (!options.mask) return [target, data];
+
+    target[1] |= 0x80;
+    target[offset - 4] = mask[0];
+    target[offset - 3] = mask[1];
+    target[offset - 2] = mask[2];
+    target[offset - 1] = mask[3];
+
+    if (skipMasking) return [target, data];
+
+    if (merge) {
+      applyMask(data, mask, target, offset, dataLength);
+      return [target];
+    }
+
+    applyMask(data, mask, data, 0, dataLength);
+    return [target, data];
+  }
+
+  /**
+   * Sends a close message to the other peer.
+   *
+   * @param {Number} [code] The status code component of the body
+   * @param {(String|Buffer)} [data] The message component of the body
+   * @param {Boolean} [mask=false] Specifies whether or not to mask the message
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  close(code, data, mask, cb) {
+    let buf;
+
+    if (code === undefined) {
+      buf = EMPTY_BUFFER;
+    } else if (typeof code !== 'number' || !isValidStatusCode(code)) {
+      throw new TypeError('First argument must be a valid error code number');
+    } else if (data === undefined || !data.length) {
+      buf = Buffer.allocUnsafe(2);
+      buf.writeUInt16BE(code, 0);
+    } else {
+      const length = Buffer.byteLength(data);
+
+      if (length > 123) {
+        throw new RangeError('The message must not be greater than 123 bytes');
+      }
+
+      buf = Buffer.allocUnsafe(2 + length);
+      buf.writeUInt16BE(code, 0);
+
+      if (typeof data === 'string') {
+        buf.write(data, 2);
+      } else {
+        buf.set(data, 2);
+      }
+    }
+
+    const options = {
+      [kByteLength]: buf.length,
+      fin: true,
+      generateMask: this._generateMask,
+      mask,
+      maskBuffer: this._maskBuffer,
+      opcode: 0x08,
+      readOnly: false,
+      rsv1: false
+    };
+
+    if (this._state !== DEFAULT) {
+      this.enqueue([this.dispatch, buf, false, options, cb]);
+    } else {
+      this.sendFrame(Sender.frame(buf, options), cb);
+    }
+  }
+
+  /**
+   * Sends a ping message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  ping(data, mask, cb) {
+    let byteLength;
+    let readOnly;
+
+    if (typeof data === 'string') {
+      byteLength = Buffer.byteLength(data);
+      readOnly = false;
+    } else if (isBlob(data)) {
+      byteLength = data.size;
+      readOnly = false;
+    } else {
+      data = toBuffer(data);
+      byteLength = data.length;
+      readOnly = toBuffer.readOnly;
+    }
+
+    if (byteLength > 125) {
+      throw new RangeError('The data size must not be greater than 125 bytes');
+    }
+
+    const options = {
+      [kByteLength]: byteLength,
+      fin: true,
+      generateMask: this._generateMask,
+      mask,
+      maskBuffer: this._maskBuffer,
+      opcode: 0x09,
+      readOnly,
+      rsv1: false
+    };
+
+    if (isBlob(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, false, options, cb]);
+      } else {
+        this.getBlobData(data, false, options, cb);
+      }
+    } else if (this._state !== DEFAULT) {
+      this.enqueue([this.dispatch, data, false, options, cb]);
+    } else {
+      this.sendFrame(Sender.frame(data, options), cb);
+    }
+  }
+
+  /**
+   * Sends a pong message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  pong(data, mask, cb) {
+    let byteLength;
+    let readOnly;
+
+    if (typeof data === 'string') {
+      byteLength = Buffer.byteLength(data);
+      readOnly = false;
+    } else if (isBlob(data)) {
+      byteLength = data.size;
+      readOnly = false;
+    } else {
+      data = toBuffer(data);
+      byteLength = data.length;
+      readOnly = toBuffer.readOnly;
+    }
+
+    if (byteLength > 125) {
+      throw new RangeError('The data size must not be greater than 125 bytes');
+    }
+
+    const options = {
+      [kByteLength]: byteLength,
+      fin: true,
+      generateMask: this._generateMask,
+      mask,
+      maskBuffer: this._maskBuffer,
+      opcode: 0x0a,
+      readOnly,
+      rsv1: false
+    };
+
+    if (isBlob(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, false, options, cb]);
+      } else {
+        this.getBlobData(data, false, options, cb);
+      }
+    } else if (this._state !== DEFAULT) {
+      this.enqueue([this.dispatch, data, false, options, cb]);
+    } else {
+      this.sendFrame(Sender.frame(data, options), cb);
+    }
+  }
+
+  /**
+   * Sends a data message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Object} options Options object
+   * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
+   *     or text
+   * @param {Boolean} [options.compress=false] Specifies whether or not to
+   *     compress `data`
+   * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
+   *     last one
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  send(data, options, cb) {
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+    let opcode = options.binary ? 2 : 1;
+    let rsv1 = options.compress;
+
+    let byteLength;
+    let readOnly;
+
+    if (typeof data === 'string') {
+      byteLength = Buffer.byteLength(data);
+      readOnly = false;
+    } else if (isBlob(data)) {
+      byteLength = data.size;
+      readOnly = false;
+    } else {
+      data = toBuffer(data);
+      byteLength = data.length;
+      readOnly = toBuffer.readOnly;
+    }
+
+    if (this._firstFragment) {
+      this._firstFragment = false;
+      if (
+        rsv1 &&
+        perMessageDeflate &&
+        perMessageDeflate.params[
+          perMessageDeflate._isServer
+            ? 'server_no_context_takeover'
+            : 'client_no_context_takeover'
+        ]
+      ) {
+        rsv1 = byteLength >= perMessageDeflate._threshold;
+      }
+      this._compress = rsv1;
+    } else {
+      rsv1 = false;
+      opcode = 0;
+    }
+
+    if (options.fin) this._firstFragment = true;
+
+    const opts = {
+      [kByteLength]: byteLength,
+      fin: options.fin,
+      generateMask: this._generateMask,
+      mask: options.mask,
+      maskBuffer: this._maskBuffer,
+      opcode,
+      readOnly,
+      rsv1
+    };
+
+    if (isBlob(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, this._compress, opts, cb]);
+      } else {
+        this.getBlobData(data, this._compress, opts, cb);
+      }
+    } else if (this._state !== DEFAULT) {
+      this.enqueue([this.dispatch, data, this._compress, opts, cb]);
+    } else {
+      this.dispatch(data, this._compress, opts, cb);
+    }
+  }
+
+  /**
+   * Gets the contents of a blob as binary data.
+   *
+   * @param {Blob} blob The blob
+   * @param {Boolean} [compress=false] Specifies whether or not to compress
+   *     the data
+   * @param {Object} options Options object
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+   *     key
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  getBlobData(blob, compress, options, cb) {
+    this._bufferedBytes += options[kByteLength];
+    this._state = GET_BLOB_DATA;
+
+    blob
+      .arrayBuffer()
+      .then((arrayBuffer) => {
+        if (this._socket.destroyed) {
+          const err = new Error(
+            'The socket was closed while the blob was being read'
+          );
+
+          //
+          // `callCallbacks` is called in the next tick to ensure that errors
+          // that might be thrown in the callbacks behave like errors thrown
+          // outside the promise chain.
+          //
+          process.nextTick(callCallbacks, this, err, cb);
+          return;
+        }
+
+        this._bufferedBytes -= options[kByteLength];
+        const data = toBuffer(arrayBuffer);
+
+        if (!compress) {
+          this._state = DEFAULT;
+          this.sendFrame(Sender.frame(data, options), cb);
+          this.dequeue();
+        } else {
+          this.dispatch(data, compress, options, cb);
+        }
+      })
+      .catch((err) => {
+        //
+        // `onError` is called in the next tick for the same reason that
+        // `callCallbacks` above is.
+        //
+        process.nextTick(onError, this, err, cb);
+      });
+  }
+
+  /**
+   * Dispatches a message.
+   *
+   * @param {(Buffer|String)} data The message to send
+   * @param {Boolean} [compress=false] Specifies whether or not to compress
+   *     `data`
+   * @param {Object} options Options object
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+   *     key
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  dispatch(data, compress, options, cb) {
+    if (!compress) {
+      this.sendFrame(Sender.frame(data, options), cb);
+      return;
+    }
+
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+
+    this._bufferedBytes += options[kByteLength];
+    this._state = DEFLATING;
+    perMessageDeflate.compress(data, options.fin, (_, buf) => {
+      if (this._socket.destroyed) {
+        const err = new Error(
+          'The socket was closed while data was being compressed'
+        );
+
+        callCallbacks(this, err, cb);
+        return;
+      }
+
+      this._bufferedBytes -= options[kByteLength];
+      this._state = DEFAULT;
+      options.readOnly = false;
+      this.sendFrame(Sender.frame(buf, options), cb);
+      this.dequeue();
+    });
+  }
+
+  /**
+   * Executes queued send operations.
+   *
+   * @private
+   */
+  dequeue() {
+    while (this._state === DEFAULT && this._queue.length) {
+      const params = this._queue.shift();
+
+      this._bufferedBytes -= params[3][kByteLength];
+      Reflect.apply(params[0], this, params.slice(1));
+    }
+  }
+
+  /**
+   * Enqueues a send operation.
+   *
+   * @param {Array} params Send operation parameters.
+   * @private
+   */
+  enqueue(params) {
+    this._bufferedBytes += params[3][kByteLength];
+    this._queue.push(params);
+  }
+
+  /**
+   * Sends a frame.
+   *
+   * @param {(Buffer | String)[]} list The frame to send
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  sendFrame(list, cb) {
+    if (list.length === 2) {
+      this._socket.cork();
+      this._socket.write(list[0]);
+      this._socket.write(list[1], cb);
+      this._socket.uncork();
+    } else {
+      this._socket.write(list[0], cb);
+    }
+  }
+}
+
+module.exports = Sender;
+
+/**
+ * Calls queued callbacks with an error.
+ *
+ * @param {Sender} sender The `Sender` instance
+ * @param {Error} err The error to call the callbacks with
+ * @param {Function} [cb] The first callback
+ * @private
+ */
+function callCallbacks(sender, err, cb) {
+  if (typeof cb === 'function') cb(err);
+
+  for (let i = 0; i < sender._queue.length; i++) {
+    const params = sender._queue[i];
+    const callback = params[params.length - 1];
+
+    if (typeof callback === 'function') callback(err);
+  }
+}
+
+/**
+ * Handles a `Sender` error.
+ *
+ * @param {Sender} sender The `Sender` instance
+ * @param {Error} err The error
+ * @param {Function} [cb] The first pending callback
+ * @private
+ */
+function onError(sender, err, cb) {
+  callCallbacks(sender, err, cb);
+  sender.onerror(err);
+}

V3.1/build/ai_bridge_server/node_modules/ws/lib/stream.js

@@ -0,0 +1,161 @@
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^WebSocket$" }] */
+'use strict';
+
+const WebSocket = require('./websocket');
+const { Duplex } = require('stream');
+
+/**
+ * Emits the `'close'` event on a stream.
+ *
+ * @param {Duplex} stream The stream.
+ * @private
+ */
+function emitClose(stream) {
+  stream.emit('close');
+}
+
+/**
+ * The listener of the `'end'` event.
+ *
+ * @private
+ */
+function duplexOnEnd() {
+  if (!this.destroyed && this._writableState.finished) {
+    this.destroy();
+  }
+}
+
+/**
+ * The listener of the `'error'` event.
+ *
+ * @param {Error} err The error
+ * @private
+ */
+function duplexOnError(err) {
+  this.removeListener('error', duplexOnError);
+  this.destroy();
+  if (this.listenerCount('error') === 0) {
+    // Do not suppress the throwing behavior.
+    this.emit('error', err);
+  }
+}
+
+/**
+ * Wraps a `WebSocket` in a duplex stream.
+ *
+ * @param {WebSocket} ws The `WebSocket` to wrap
+ * @param {Object} [options] The options for the `Duplex` constructor
+ * @return {Duplex} The duplex stream
+ * @public
+ */
+function createWebSocketStream(ws, options) {
+  let terminateOnDestroy = true;
+
+  const duplex = new Duplex({
+    ...options,
+    autoDestroy: false,
+    emitClose: false,
+    objectMode: false,
+    writableObjectMode: false
+  });
+
+  ws.on('message', function message(msg, isBinary) {
+    const data =
+      !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
+
+    if (!duplex.push(data)) ws.pause();
+  });
+
+  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);
+  });
+
+  ws.once('close', function close() {
+    if (duplex.destroyed) return;
+
+    duplex.push(null);
+  });
+
+  duplex._destroy = function (err, callback) {
+    if (ws.readyState === ws.CLOSED) {
+      callback(err);
+      process.nextTick(emitClose, duplex);
+      return;
+    }
+
+    let called = false;
+
+    ws.once('error', function error(err) {
+      called = true;
+      callback(err);
+    });
+
+    ws.once('close', function close() {
+      if (!called) callback(err);
+      process.nextTick(emitClose, duplex);
+    });
+
+    if (terminateOnDestroy) ws.terminate();
+  };
+
+  duplex._final = function (callback) {
+    if (ws.readyState === ws.CONNECTING) {
+      ws.once('open', function open() {
+        duplex._final(callback);
+      });
+      return;
+    }
+
+    // If the value of the `_socket` property is `null` it means that `ws` is a
+    // client websocket and the handshake failed. In fact, when this happens, a
+    // socket is never assigned to the websocket. Wait for the `'error'` event
+    // that will be emitted by the websocket.
+    if (ws._socket === null) return;
+
+    if (ws._socket._writableState.finished) {
+      callback();
+      if (duplex._readableState.endEmitted) duplex.destroy();
+    } else {
+      ws._socket.once('finish', function finish() {
+        // `duplex` is not destroyed here because the `'end'` event will be
+        // emitted on `duplex` after this `'finish'` event. The EOF signaling
+        // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
+        callback();
+      });
+      ws.close();
+    }
+  };
+
+  duplex._read = function () {
+    if (ws.isPaused) ws.resume();
+  };
+
+  duplex._write = function (chunk, encoding, callback) {
+    if (ws.readyState === ws.CONNECTING) {
+      ws.once('open', function open() {
+        duplex._write(chunk, encoding, callback);
+      });
+      return;
+    }
+
+    ws.send(chunk, callback);
+  };
+
+  duplex.on('end', duplexOnEnd);
+  duplex.on('error', duplexOnError);
+  return duplex;
+}
+
+module.exports = createWebSocketStream;

V3.1/build/ai_bridge_server/node_modules/ws/lib/subprotocol.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const { tokenChars } = require('./validation');
+
+/**
+ * Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names.
+ *
+ * @param {String} header The field value of the header
+ * @return {Set} The subprotocol names
+ * @public
+ */
+function parse(header) {
+  const protocols = new Set();
+  let start = -1;
+  let end = -1;
+  let i = 0;
+
+  for (i; i < header.length; i++) {
+    const code = header.charCodeAt(i);
+
+    if (end === -1 && tokenChars[code] === 1) {
+      if (start === -1) start = i;
+    } else if (
+      i !== 0 &&
+      (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
+    ) {
+      if (end === -1 && start !== -1) end = i;
+    } else if (code === 0x2c /* ',' */) {
+      if (start === -1) {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+
+      if (end === -1) end = i;
+
+      const protocol = header.slice(start, end);
+
+      if (protocols.has(protocol)) {
+        throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+      }
+
+      protocols.add(protocol);
+      start = end = -1;
+    } else {
+      throw new SyntaxError(`Unexpected character at index ${i}`);
+    }
+  }
+
+  if (start === -1 || end !== -1) {
+    throw new SyntaxError('Unexpected end of input');
+  }
+
+  const protocol = header.slice(start, i);
+
+  if (protocols.has(protocol)) {
+    throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+  }
+
+  protocols.add(protocol);
+  return protocols;
+}
+
+module.exports = { parse };

V3.1/build/ai_bridge_server/node_modules/ws/lib/validation.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const { isUtf8 } = require('buffer');
+
+const { hasBlob } = require('./constants');
+
+//
+// Allowed token characters:
+//
+// '!', '#', '$', '%', '&', ''', '*', '+', '-',
+// '.', 0-9, A-Z, '^', '_', '`', a-z, '|', '~'
+//
+// tokenChars[32] === 0 // ' '
+// tokenChars[33] === 1 // '!'
+// tokenChars[34] === 0 // '"'
+// ...
+//
+// prettier-ignore
+const tokenChars = [
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
+  0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, // 32 - 47
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 - 63
+  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, // 80 - 95
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0 // 112 - 127
+];
+
+/**
+ * Checks if a status code is allowed in a close frame.
+ *
+ * @param {Number} code The status code
+ * @return {Boolean} `true` if the status code is valid, else `false`
+ * @public
+ */
+function isValidStatusCode(code) {
+  return (
+    (code >= 1000 &&
+      code <= 1014 &&
+      code !== 1004 &&
+      code !== 1005 &&
+      code !== 1006) ||
+    (code >= 3000 && code <= 4999)
+  );
+}
+
+/**
+ * Checks if a given buffer contains only correct UTF-8.
+ * Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by
+ * Markus Kuhn.
+ *
+ * @param {Buffer} buf The buffer to check
+ * @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`
+ * @public
+ */
+function _isValidUTF8(buf) {
+  const len = buf.length;
+  let i = 0;
+
+  while (i < len) {
+    if ((buf[i] & 0x80) === 0) {
+      // 0xxxxxxx
+      i++;
+    } else if ((buf[i] & 0xe0) === 0xc0) {
+      // 110xxxxx 10xxxxxx
+      if (
+        i + 1 === len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i] & 0xfe) === 0xc0 // Overlong
+      ) {
+        return false;
+      }
+
+      i += 2;
+    } else if ((buf[i] & 0xf0) === 0xe0) {
+      // 1110xxxx 10xxxxxx 10xxxxxx
+      if (
+        i + 2 >= len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i + 2] & 0xc0) !== 0x80 ||
+        (buf[i] === 0xe0 && (buf[i + 1] & 0xe0) === 0x80) || // Overlong
+        (buf[i] === 0xed && (buf[i + 1] & 0xe0) === 0xa0) // Surrogate (U+D800 - U+DFFF)
+      ) {
+        return false;
+      }
+
+      i += 3;
+    } else if ((buf[i] & 0xf8) === 0xf0) {
+      // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+      if (
+        i + 3 >= len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i + 2] & 0xc0) !== 0x80 ||
+        (buf[i + 3] & 0xc0) !== 0x80 ||
+        (buf[i] === 0xf0 && (buf[i + 1] & 0xf0) === 0x80) || // Overlong
+        (buf[i] === 0xf4 && buf[i + 1] > 0x8f) ||
+        buf[i] > 0xf4 // > U+10FFFF
+      ) {
+        return false;
+      }
+
+      i += 4;
+    } else {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Determines whether a value is a `Blob`.
+ *
+ * @param {*} value The value to be tested
+ * @return {Boolean} `true` if `value` is a `Blob`, else `false`
+ * @private
+ */
+function isBlob(value) {
+  return (
+    hasBlob &&
+    typeof value === 'object' &&
+    typeof value.arrayBuffer === 'function' &&
+    typeof value.type === 'string' &&
+    typeof value.stream === 'function' &&
+    (value[Symbol.toStringTag] === 'Blob' ||
+      value[Symbol.toStringTag] === 'File')
+  );
+}
+
+module.exports = {
+  isBlob,
+  isValidStatusCode,
+  isValidUTF8: _isValidUTF8,
+  tokenChars
+};
+
+if (isUtf8) {
+  module.exports.isValidUTF8 = function (buf) {
+    return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
+  };
+} /* istanbul ignore else  */ else if (!process.env.WS_NO_UTF_8_VALIDATE) {
+  try {
+    const isValidUTF8 = require('utf-8-validate');
+
+    module.exports.isValidUTF8 = function (buf) {
+      return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
+    };
+  } catch (e) {
+    // Continue regardless of the error.
+  }
+}

V3.1/build/ai_bridge_server/node_modules/ws/lib/websocket-server.js

@@ -0,0 +1,554 @@
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
+
+'use strict';
+
+const EventEmitter = require('events');
+const http = require('http');
+const { Duplex } = require('stream');
+const { createHash } = require('crypto');
+
+const extension = require('./extension');
+const PerMessageDeflate = require('./permessage-deflate');
+const subprotocol = require('./subprotocol');
+const WebSocket = require('./websocket');
+const { CLOSE_TIMEOUT, GUID, kWebSocket } = require('./constants');
+
+const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
+
+const RUNNING = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+
+/**
+ * Class representing a WebSocket server.
+ *
+ * @extends EventEmitter
+ */
+class WebSocketServer extends EventEmitter {
+  /**
+   * Create a `WebSocketServer` instance.
+   *
+   * @param {Object} options Configuration options
+   * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
+   *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+   *     multiple times in the same tick
+   * @param {Boolean} [options.autoPong=true] Specifies whether or not to
+   *     automatically send a pong in response to a ping
+   * @param {Number} [options.backlog=511] The maximum length of the queue of
+   *     pending connections
+   * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
+   *     track clients
+   * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to
+   *     wait for the closing handshake to finish after `websocket.close()` is
+   *     called
+   * @param {Function} [options.handleProtocols] A hook to handle protocols
+   * @param {String} [options.host] The hostname where to bind the server
+   * @param {Number} [options.maxPayload=104857600] The maximum allowed message
+   *     size
+   * @param {Boolean} [options.noServer=false] Enable no server mode
+   * @param {String} [options.path] Accept only connections matching this path
+   * @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 {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+   *     not to skip UTF-8 validation for text and close messages
+   * @param {Function} [options.verifyClient] A hook to reject connections
+   * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
+   *     class to use. It must be the `WebSocket` class or class that extends it
+   * @param {Function} [callback] A listener for the `listening` event
+   */
+  constructor(options, callback) {
+    super();
+
+    options = {
+      allowSynchronousEvents: true,
+      autoPong: true,
+      maxPayload: 100 * 1024 * 1024,
+      skipUTF8Validation: false,
+      perMessageDeflate: false,
+      handleProtocols: null,
+      clientTracking: true,
+      closeTimeout: CLOSE_TIMEOUT,
+      verifyClient: null,
+      noServer: false,
+      backlog: null, // use default (511 as implemented in net.js)
+      server: null,
+      host: null,
+      path: null,
+      port: null,
+      WebSocket,
+      ...options
+    };
+
+    if (
+      (options.port == null && !options.server && !options.noServer) ||
+      (options.port != null && (options.server || options.noServer)) ||
+      (options.server && options.noServer)
+    ) {
+      throw new TypeError(
+        'One and only 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];
+
+        res.writeHead(426, {
+          'Content-Length': body.length,
+          'Content-Type': 'text/plain'
+        });
+        res.end(body);
+      });
+      this._server.listen(
+        options.port,
+        options.host,
+        options.backlog,
+        callback
+      );
+    } else if (options.server) {
+      this._server = options.server;
+    }
+
+    if (this._server) {
+      const emitConnection = this.emit.bind(this, 'connection');
+
+      this._removeListeners = addListeners(this._server, {
+        listening: this.emit.bind(this, 'listening'),
+        error: this.emit.bind(this, 'error'),
+        upgrade: (req, socket, head) => {
+          this.handleUpgrade(req, socket, head, emitConnection);
+        }
+      });
+    }
+
+    if (options.perMessageDeflate === true) options.perMessageDeflate = {};
+    if (options.clientTracking) {
+      this.clients = new Set();
+      this._shouldEmitClose = false;
+    }
+
+    this.options = options;
+    this._state = RUNNING;
+  }
+
+  /**
+   * Returns the bound address, the address family name, and port of the server
+   * as reported by the operating system if listening on an IP socket.
+   * If the server is listening on a pipe or UNIX domain socket, the name is
+   * returned as a string.
+   *
+   * @return {(Object|String|null)} The address of the server
+   * @public
+   */
+  address() {
+    if (this.options.noServer) {
+      throw new Error('The server is operating in "noServer" mode');
+    }
+
+    if (!this._server) return null;
+    return this._server.address();
+  }
+
+  /**
+   * Stop the server from accepting new connections and emit the `'close'` event
+   * when all existing connections are closed.
+   *
+   * @param {Function} [cb] A one-time listener for the `'close'` event
+   * @public
+   */
+  close(cb) {
+    if (this._state === CLOSED) {
+      if (cb) {
+        this.once('close', () => {
+          cb(new Error('The server is not running'));
+        });
+      }
+
+      process.nextTick(emitClose, this);
+      return;
+    }
+
+    if (cb) this.once('close', cb);
+
+    if (this._state === CLOSING) return;
+    this._state = CLOSING;
+
+    if (this.options.noServer || this.options.server) {
+      if (this._server) {
+        this._removeListeners();
+        this._removeListeners = this._server = null;
+      }
+
+      if (this.clients) {
+        if (!this.clients.size) {
+          process.nextTick(emitClose, this);
+        } else {
+          this._shouldEmitClose = true;
+        }
+      } else {
+        process.nextTick(emitClose, this);
+      }
+    } else {
+      const server = this._server;
+
+      this._removeListeners();
+      this._removeListeners = this._server = null;
+
+      //
+      // The HTTP/S server was created internally. Close it, and rely on its
+      // `'close'` event.
+      //
+      server.close(() => {
+        emitClose(this);
+      });
+    }
+  }
+
+  /**
+   * See if a given request should be handled by this server instance.
+   *
+   * @param {http.IncomingMessage} req Request object to inspect
+   * @return {Boolean} `true` if the request is valid, else `false`
+   * @public
+   */
+  shouldHandle(req) {
+    if (this.options.path) {
+      const index = req.url.indexOf('?');
+      const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
+
+      if (pathname !== this.options.path) return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Handle a HTTP Upgrade request.
+   *
+   * @param {http.IncomingMessage} req The request object
+   * @param {Duplex} socket The network socket between the server and client
+   * @param {Buffer} head The first packet of the upgraded stream
+   * @param {Function} cb Callback
+   * @public
+   */
+  handleUpgrade(req, socket, head, cb) {
+    socket.on('error', socketOnError);
+
+    const key = req.headers['sec-websocket-key'];
+    const upgrade = req.headers.upgrade;
+    const version = +req.headers['sec-websocket-version'];
+
+    if (req.method !== 'GET') {
+      const message = 'Invalid HTTP method';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
+      return;
+    }
+
+    if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {
+      const message = 'Invalid Upgrade header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+      return;
+    }
+
+    if (key === undefined || !keyRegex.test(key)) {
+      const message = 'Missing or invalid Sec-WebSocket-Key header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+      return;
+    }
+
+    if (version !== 13 && version !== 8) {
+      const message = 'Missing or invalid Sec-WebSocket-Version header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
+        'Sec-WebSocket-Version': '13, 8'
+      });
+      return;
+    }
+
+    if (!this.shouldHandle(req)) {
+      abortHandshake(socket, 400);
+      return;
+    }
+
+    const secWebSocketProtocol = req.headers['sec-websocket-protocol'];
+    let protocols = new Set();
+
+    if (secWebSocketProtocol !== undefined) {
+      try {
+        protocols = subprotocol.parse(secWebSocketProtocol);
+      } catch (err) {
+        const message = 'Invalid Sec-WebSocket-Protocol header';
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+        return;
+      }
+    }
+
+    const secWebSocketExtensions = req.headers['sec-websocket-extensions'];
+    const extensions = {};
+
+    if (
+      this.options.perMessageDeflate &&
+      secWebSocketExtensions !== undefined
+    ) {
+      const perMessageDeflate = new PerMessageDeflate(
+        this.options.perMessageDeflate,
+        true,
+        this.options.maxPayload
+      );
+
+      try {
+        const offers = extension.parse(secWebSocketExtensions);
+
+        if (offers[PerMessageDeflate.extensionName]) {
+          perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
+          extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+        }
+      } catch (err) {
+        const message =
+          'Invalid or unacceptable Sec-WebSocket-Extensions header';
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+        return;
+      }
+    }
+
+    //
+    // Optionally call external client verification handler.
+    //
+    if (this.options.verifyClient) {
+      const info = {
+        origin:
+          req.headers[`${version === 8 ? 'sec-websocket-origin' : 'origin'}`],
+        secure: !!(req.socket.authorized || req.socket.encrypted),
+        req
+      };
+
+      if (this.options.verifyClient.length === 2) {
+        this.options.verifyClient(info, (verified, code, message, headers) => {
+          if (!verified) {
+            return abortHandshake(socket, code || 401, message, headers);
+          }
+
+          this.completeUpgrade(
+            extensions,
+            key,
+            protocols,
+            req,
+            socket,
+            head,
+            cb
+          );
+        });
+        return;
+      }
+
+      if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
+    }
+
+    this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
+  }
+
+  /**
+   * Upgrade the connection to WebSocket.
+   *
+   * @param {Object} extensions The accepted extensions
+   * @param {String} key The value of the `Sec-WebSocket-Key` header
+   * @param {Set} protocols The subprotocols
+   * @param {http.IncomingMessage} req The request object
+   * @param {Duplex} 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
+   * @private
+   */
+  completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
+    //
+    // Destroy the socket if the client has already sent a FIN packet.
+    //
+    if (!socket.readable || !socket.writable) return socket.destroy();
+
+    if (socket[kWebSocket]) {
+      throw new Error(
+        'server.handleUpgrade() was called more than once with the same ' +
+          'socket, possibly due to a misconfiguration'
+      );
+    }
+
+    if (this._state > RUNNING) return abortHandshake(socket, 503);
+
+    const digest = createHash('sha1')
+      .update(key + GUID)
+      .digest('base64');
+
+    const headers = [
+      'HTTP/1.1 101 Switching Protocols',
+      'Upgrade: websocket',
+      'Connection: Upgrade',
+      `Sec-WebSocket-Accept: ${digest}`
+    ];
+
+    const ws = new this.options.WebSocket(null, undefined, this.options);
+
+    if (protocols.size) {
+      //
+      // Optionally call external protocol selection handler.
+      //
+      const protocol = this.options.handleProtocols
+        ? this.options.handleProtocols(protocols, req)
+        : protocols.values().next().value;
+
+      if (protocol) {
+        headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
+        ws._protocol = protocol;
+      }
+    }
+
+    if (extensions[PerMessageDeflate.extensionName]) {
+      const params = extensions[PerMessageDeflate.extensionName].params;
+      const value = extension.format({
+        [PerMessageDeflate.extensionName]: [params]
+      });
+      headers.push(`Sec-WebSocket-Extensions: ${value}`);
+      ws._extensions = extensions;
+    }
+
+    //
+    // Allow external modification/inspection of handshake headers.
+    //
+    this.emit('headers', headers, req);
+
+    socket.write(headers.concat('\r\n').join('\r\n'));
+    socket.removeListener('error', socketOnError);
+
+    ws.setSocket(socket, head, {
+      allowSynchronousEvents: this.options.allowSynchronousEvents,
+      maxPayload: this.options.maxPayload,
+      skipUTF8Validation: this.options.skipUTF8Validation
+    });
+
+    if (this.clients) {
+      this.clients.add(ws);
+      ws.on('close', () => {
+        this.clients.delete(ws);
+
+        if (this._shouldEmitClose && !this.clients.size) {
+          process.nextTick(emitClose, this);
+        }
+      });
+    }
+
+    cb(ws, req);
+  }
+}
+
+module.exports = WebSocketServer;
+
+/**
+ * Add event listeners on an `EventEmitter` using a map of <event, listener>
+ * pairs.
+ *
+ * @param {EventEmitter} server The event emitter
+ * @param {Object.<String, Function>} map The listeners to add
+ * @return {Function} A function that will remove the added listeners when
+ *     called
+ * @private
+ */
+function addListeners(server, map) {
+  for (const event of Object.keys(map)) server.on(event, map[event]);
+
+  return function removeListeners() {
+    for (const event of Object.keys(map)) {
+      server.removeListener(event, map[event]);
+    }
+  };
+}
+
+/**
+ * Emit a `'close'` event on an `EventEmitter`.
+ *
+ * @param {EventEmitter} server The event emitter
+ * @private
+ */
+function emitClose(server) {
+  server._state = CLOSED;
+  server.emit('close');
+}
+
+/**
+ * Handle socket errors.
+ *
+ * @private
+ */
+function socketOnError() {
+  this.destroy();
+}
+
+/**
+ * Close the connection when preconditions are not fulfilled.
+ *
+ * @param {Duplex} 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
+ * @private
+ */
+function abortHandshake(socket, code, message, headers) {
+  //
+  // The socket is writable unless the user destroyed or ended it before calling
+  // `server.handleUpgrade()` or in the `verifyClient` function, which is a user
+  // error. Handling this does not make much sense as the worst that can happen
+  // is that some of the data written by the user might be discarded due to the
+  // call to `socket.end()` below, which triggers an `'error'` event that in
+  // turn causes the socket to be destroyed.
+  //
+  message = message || http.STATUS_CODES[code];
+  headers = {
+    Connection: 'close',
+    'Content-Type': 'text/html',
+    'Content-Length': Buffer.byteLength(message),
+    ...headers
+  };
+
+  socket.once('finish', socket.destroy);
+
+  socket.end(
+    `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r\n` +
+      Object.keys(headers)
+        .map((h) => `${h}: ${headers[h]}`)
+        .join('\r\n') +
+      '\r\n\r\n' +
+      message
+  );
+}
+
+/**
+ * Emit a `'wsClientError'` event on a `WebSocketServer` if there is at least
+ * one listener for it, otherwise call `abortHandshake()`.
+ *
+ * @param {WebSocketServer} server The WebSocket server
+ * @param {http.IncomingMessage} req The request object
+ * @param {Duplex} 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] The HTTP response headers
+ * @private
+ */
+function abortHandshakeOrEmitwsClientError(
+  server,
+  req,
+  socket,
+  code,
+  message,
+  headers
+) {
+  if (server.listenerCount('wsClientError')) {
+    const err = new Error(message);
+    Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
+
+    server.emit('wsClientError', err, socket, req);
+  } else {
+    abortHandshake(socket, code, message, headers);
+  }
+}

V3.1/build/ai_bridge_server/node_modules/ws/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "ws",
+  "version": "8.19.0",
+  "description": "Simple to use, blazing fast and thoroughly tested websocket client and server for Node.js",
+  "keywords": [
+    "HyBi",
+    "Push",
+    "RFC-6455",
+    "WebSocket",
+    "WebSockets",
+    "real-time"
+  ],
+  "homepage": "https://github.com/websockets/ws",
+  "bugs": "https://github.com/websockets/ws/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/websockets/ws.git"
+  },
+  "author": "Einar Otto Stangvik <einaros@gmail.com> (http://2x.io)",
+  "license": "MIT",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "browser": "./browser.js",
+      "import": "./wrapper.mjs",
+      "require": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "browser": "browser.js",
+  "engines": {
+    "node": ">=10.0.0"
+  },
+  "files": [
+    "browser.js",
+    "index.js",
+    "lib/*.js",
+    "wrapper.mjs"
+  ],
+  "scripts": {
+    "test": "nyc --reporter=lcov --reporter=text mocha --throw-deprecation test/*.test.js",
+    "integration": "mocha --throw-deprecation test/*.integration.js",
+    "lint": "eslint . && prettier --check --ignore-path .gitignore \"**/*.{json,md,yaml,yml}\""
+  },
+  "peerDependencies": {
+    "bufferutil": "^4.0.1",
+    "utf-8-validate": ">=5.0.2"
+  },
+  "peerDependenciesMeta": {
+    "bufferutil": {
+      "optional": true
+    },
+    "utf-8-validate": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "benchmark": "^2.1.4",
+    "bufferutil": "^4.0.1",
+    "eslint": "^9.0.0",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-prettier": "^5.0.0",
+    "globals": "^16.0.0",
+    "mocha": "^8.4.0",
+    "nyc": "^15.0.0",
+    "prettier": "^3.0.0",
+    "utf-8-validate": "^6.0.0"
+  }
+}

V3.1/build/ai_bridge_server/node_modules/ws/wrapper.mjs

@@ -0,0 +1,8 @@
+import createWebSocketStream from './lib/stream.js';
+import Receiver from './lib/receiver.js';
+import Sender from './lib/sender.js';
+import WebSocket from './lib/websocket.js';
+import WebSocketServer from './lib/websocket-server.js';
+
+export { createWebSocketStream, Receiver, Sender, WebSocket, WebSocketServer };
+export default WebSocket;

V3.1/build/ai_bridge_server/package-lock.json

@@ -0,0 +1,33 @@
+{
+  "name": "ai_bridge_server",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "ws": "^8.19.0"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.19.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
+      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

V3.1/build/ai_bridge_server/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "ws": "^8.19.0"
+  }
+}

V3.1/build/ai_bridge_server/server.py

@@ -0,0 +1,383 @@
+#!/usr/bin/env python3
+"""Minimal AI Bridge server for Jibo.
+
+Endpoints:
+- POST /v1/chat/text  {"text": "..."} -> {"reply": "..."}
+- POST /v1/chat/audio {"wav_base64": "...", "sample_rate": 16000} -> {"reply": "...", "text": "<transcript>"}
+
+LLM:
+- Uses Ollama Chat API by default: http://localhost:11434/api/chat
+  Env:
+    OLLAMA_URL   (default: http://127.0.0.1:11434/api/chat)
+        OLLAMA_MODEL (default: phi3.5)
+
+STT (optional, for /audio):
+- If `faster-whisper` is installed, it will be used.
+  Env:
+    WHISPER_MODEL (default: base)
+
+Run:
+  python3 server.py --host 0.0.0.0 --port 8020
+"""
+
+from __future__ import annotations
+
+import argparse
+import array
+import base64
+import io
+import json
+import os
+import tempfile
+import time
+import traceback
+import wave
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.error import URLError
+from urllib.request import Request, urlopen
+
+
+def _ts() -> str:
+    # ISO-ish timestamp in local time; good enough for debugging
+    return time.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def _log(msg: str):
+    # Server previously muted logs; we want visibility while debugging.
+    print(f"[{_ts()}] {msg}", flush=True)
+
+
+def _json_response(handler: BaseHTTPRequestHandler, status: int, payload: dict):
+    body = json.dumps(payload).encode("utf-8")
+    handler.send_response(status)
+    handler.send_header("Content-Type", "application/json")
+    handler.send_header("Content-Length", str(len(body)))
+    handler.end_headers()
+    handler.wfile.write(body)
+
+
+def _read_json(handler: BaseHTTPRequestHandler) -> dict:
+    length = int(handler.headers.get("Content-Length", "0"))
+    raw = handler.rfile.read(length) if length else b"{}"
+    return json.loads(raw.decode("utf-8"))
+
+
+def _ollama_chat(user_text: str) -> str:
+    ollama_url = os.environ.get("OLLAMA_URL", "http://127.0.0.1:11434/api/chat")
+    model = os.environ.get("OLLAMA_MODEL", "phi3.5")
+
+    req_body = {
+        "model": model,
+        "stream": False,
+        "messages": [
+            {"role": "system", "content": "You are Jibo, a friendly home robot. Keep replies short and spoken."},
+            {"role": "user", "content": user_text},
+        ],
+    }
+
+    req = Request(
+        ollama_url,
+        data=json.dumps(req_body).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+
+    try:
+        with urlopen(req, timeout=60) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+    except Exception as e:
+        # Let caller decide how to respond; include a useful hint in logs.
+        _log(f"Ollama request failed url={ollama_url!r} err={e!r}")
+        raise
+
+    msg = data.get("message") or {}
+    content = msg.get("content")
+    if not content:
+        raise RuntimeError(f"Unexpected Ollama response: {data}")
+    return content.strip()
+
+
+def _short_err(e: BaseException) -> str:
+    s = str(e) or e.__class__.__name__
+    s = " ".join(s.split())
+    if len(s) > 240:
+        s = s[:240] + "..."
+    return s
+
+
+def _ollama_down_reply() -> str:
+    # Keep it short and speakable.
+    return "My AI server isn't reachable right now. Please start Ollama on the computer, then try again."
+
+
+def _wav_diagnostics(wav_bytes: bytes) -> dict:
+    """Best-effort WAV parsing + signal stats for debugging mic capture."""
+    info: dict = {"bytes": len(wav_bytes)}
+    try:
+        with wave.open(io.BytesIO(wav_bytes), "rb") as wf:  # type: ignore[name-defined]
+            nch = wf.getnchannels()
+            sw = wf.getsampwidth()
+            fr = wf.getframerate()
+            nframes = wf.getnframes()
+            info.update({"channels": nch, "sample_width": sw, "frame_rate": fr, "frames": nframes})
+
+            # Read up to ~3 seconds of audio for stats (avoid huge CPU)
+            max_frames = min(nframes, fr * 3)
+            frames = wf.readframes(max_frames)
+    except Exception as e:
+        info["parse_error"] = str(e)
+        return info
+
+    # Only compute stats for 16-bit PCM (most common).
+    if info.get("sample_width") != 2:
+        return info
+
+    try:
+        samples = array.array("h")
+        samples.frombytes(frames)
+        if not samples:
+            return info
+
+        mn = min(samples)
+        mx = max(samples)
+        zeros = sum(1 for s in samples if s == 0)
+        # RMS over interleaved samples (good enough for quick signal presence)
+        n = float(len(samples))
+        rms = (sum(float(s) * float(s) for s in samples) / n) ** 0.5
+        # Per-channel RMS (helps debug mic arrays)
+        ch = int(info.get("channels") or 1)
+        channel_rms = None
+        if ch > 1:
+            channel_rms = []
+            for c in range(ch):
+                chan = samples[c::ch]
+                if not chan:
+                    channel_rms.append(0.0)
+                else:
+                    nn = float(len(chan))
+                    channel_rms.append((sum(float(s) * float(s) for s in chan) / nn) ** 0.5)
+        info.update(
+            {
+                "min": int(mn),
+                "max": int(mx),
+                "rms": float(rms),
+                "zero_frac": float(zeros) / n,
+                "channel_rms": channel_rms,
+            }
+        )
+    except Exception as e:
+        info["stats_error"] = str(e)
+    return info
+
+
+def _to_loudest_channel_mono_wav(wav_bytes: bytes) -> tuple[bytes, dict]:
+    """If WAV is multi-channel 16-bit PCM, pick loudest channel and return mono WAV bytes."""
+    try:
+        with wave.open(io.BytesIO(wav_bytes), "rb") as wf:
+            nch = wf.getnchannels()
+            sw = wf.getsampwidth()
+            fr = wf.getframerate()
+            nframes = wf.getnframes()
+            frames = wf.readframes(nframes)
+    except Exception as e:
+        return wav_bytes, {"convert_error": str(e)}
+
+    if nch <= 1 or sw != 2:
+        return wav_bytes, {"converted": False, "channels": nch, "sample_width": sw}
+
+    samples = array.array("h")
+    samples.frombytes(frames)
+    if not samples:
+        return wav_bytes, {"converted": False, "reason": "empty_samples"}
+
+    # Choose loudest channel by RMS
+    rms_list: list[float] = []
+    for c in range(nch):
+        chan = samples[c::nch]
+        if not chan:
+            rms_list.append(0.0)
+        else:
+            nn = float(len(chan))
+            rms_list.append((sum(float(s) * float(s) for s in chan) / nn) ** 0.5)
+    best = max(range(nch), key=lambda i: rms_list[i])
+    mono = samples[best::nch]
+
+    out = io.BytesIO()
+    with wave.open(out, "wb") as ow:
+        ow.setnchannels(1)
+        ow.setsampwidth(2)
+        ow.setframerate(fr)
+        ow.writeframes(mono.tobytes())
+
+    return out.getvalue(), {"converted": True, "picked_channel": best, "channel_rms": rms_list, "frame_rate": fr}
+
+
+class _Whisper:
+    def __init__(self):
+        self._model = None
+
+    def available(self) -> bool:
+        try:
+            import faster_whisper  # noqa: F401
+
+            return True
+        except Exception:
+            return False
+
+    def transcribe_wav_bytes(self, wav_bytes: bytes) -> str:
+        try:
+            from faster_whisper import WhisperModel
+        except Exception as e:
+            raise RuntimeError(
+                "Audio mode requires `faster-whisper` (pip install faster-whisper) and ffmpeg on your PC"
+            ) from e
+
+        model_name = os.environ.get("WHISPER_MODEL", "base")
+        if self._model is None:
+            # CPU-friendly default; user can override via WHISPER_MODEL and faster-whisper params if needed.
+            self._model = WhisperModel(model_name, device="cpu", compute_type="int8")
+
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=True) as f:
+            f.write(wav_bytes)
+            f.flush()
+            segments, info = self._model.transcribe(f.name)
+            text = "".join(seg.text for seg in segments).strip()
+            return text
+
+
+_whisper = _Whisper()
+
+
+class Handler(BaseHTTPRequestHandler):
+    server_version = "JiboAIBridge/1.0"
+
+    def do_POST(self):
+        try:
+            client = f"{self.client_address[0]}:{self.client_address[1]}"
+            length = int(self.headers.get("Content-Length", "0") or "0")
+            _log(f"{client} POST {self.path} len={length}")
+
+            if self.path == "/v1/chat/text":
+                payload = _read_json(self)
+                text = (payload.get("text") or "").strip()
+                if not text:
+                    _json_response(self, 400, {"error": "Missing 'text'"})
+                    return
+                _log(f"{client} /text prompt_chars={len(text)} prompt={text[:200]!r}")
+                try:
+                    reply = _ollama_chat(text)
+                    _log(f"{client} /text ok reply_chars={len(reply)}")
+                    _json_response(self, 200, {"reply": reply})
+                except URLError as e:
+                    _log(f"{client} /text ollama_unreachable err={_short_err(e)!r}")
+                    _json_response(self, 200, {"reply": _ollama_down_reply(), "ollama_ok": False, "ollama_error": _short_err(e)})
+                except ConnectionRefusedError as e:
+                    _log(f"{client} /text ollama_refused err={_short_err(e)!r}")
+                    _json_response(self, 200, {"reply": _ollama_down_reply(), "ollama_ok": False, "ollama_error": _short_err(e)})
+                return
+
+            if self.path == "/v1/chat/audio":
+                payload = _read_json(self)
+                b64 = payload.get("wav_base64")
+                if not b64:
+                    _json_response(self, 400, {"error": "Missing 'wav_base64'"})
+                    return
+
+                if not _whisper.available():
+                    _log(f"{client} /audio STT unavailable (faster-whisper not installed)")
+                    _json_response(
+                        self,
+                        503,
+                        {
+                            "error": "STT unavailable: install faster-whisper and ffmpeg on this PC",
+                            "hint": "pip install faster-whisper  (and install ffmpeg)",
+                        },
+                    )
+                    return
+
+                wav_bytes = base64.b64decode(b64)
+                diag = _wav_diagnostics(wav_bytes)
+                wav_for_stt, conv = _to_loudest_channel_mono_wav(wav_bytes)
+                if conv.get("converted"):
+                    diag_mono = _wav_diagnostics(wav_for_stt)
+                    _log(
+                        f"{client} /audio wav_diag={json.dumps(diag, sort_keys=True)} "
+                        f"mono={json.dumps(diag_mono, sort_keys=True)} conv={json.dumps(conv, sort_keys=True)}"
+                    )
+                else:
+                    _log(f"{client} /audio wav_diag={json.dumps(diag, sort_keys=True)} conv={json.dumps(conv, sort_keys=True)}")
+                try:
+                    # Save for debugging (overwrite each time)
+                    out_path = os.environ.get("AI_BRIDGE_LAST_WAV", "jibo_last.wav")
+                    with open(out_path, "wb") as f:
+                        f.write(wav_bytes)
+                    _log(f"{client} /audio decoded bytes={len(wav_bytes)} saved={out_path}")
+                except Exception as e:
+                    _log(f"{client} /audio failed saving wav: {e}")
+
+                transcript = _whisper.transcribe_wav_bytes(wav_for_stt)
+                if not transcript:
+                    _log(f"{client} /audio empty transcript")
+                    _json_response(self, 200, {"reply": "I didn't catch that. Could you say it again?", "text": ""})
+                    return
+                _log(f"{client} /audio transcript_chars={len(transcript)} transcript={transcript[:200]!r}")
+                try:
+                    reply = _ollama_chat(transcript)
+                    _log(f"{client} /audio ok text_chars={len(transcript)} reply_chars={len(reply)}")
+                    _json_response(self, 200, {"reply": reply, "text": transcript})
+                except URLError as e:
+                    _log(f"{client} /audio ollama_unreachable err={_short_err(e)!r}")
+                    _json_response(
+                        self,
+                        200,
+                        {"reply": _ollama_down_reply(), "text": transcript, "ollama_ok": False, "ollama_error": _short_err(e)},
+                    )
+                except ConnectionRefusedError as e:
+                    _log(f"{client} /audio ollama_refused err={_short_err(e)!r}")
+                    _json_response(
+                        self,
+                        200,
+                        {"reply": _ollama_down_reply(), "text": transcript, "ollama_ok": False, "ollama_error": _short_err(e)},
+                    )
+                return
+
+            _json_response(self, 404, {"error": "Not found"})
+
+        except Exception as e:
+            _log(f"ERROR {self.path}: {e}\n{traceback.format_exc()}")
+            _json_response(
+                self,
+                500,
+                {
+                    "error": str(e),
+                    "trace": traceback.format_exc(),
+                },
+            )
+
+    def log_message(self, format, *args):
+        # Keep BaseHTTPRequestHandler from double-logging; we do our own.
+        return
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--host", default="0.0.0.0")
+    ap.add_argument("--port", type=int, default=8020)
+    args = ap.parse_args()
+
+    server = ThreadingHTTPServer((args.host, args.port), Handler)
+    _log(f"AI Bridge server listening on http://{args.host}:{args.port}")
+    _log(
+        "Ollama: "
+        + os.environ.get("OLLAMA_URL", "http://127.0.0.1:11434/api/chat")
+        + " model="
+        + os.environ.get("OLLAMA_MODEL", "phi3.5")
+    )
+    _log("Ollama health check: curl -s http://127.0.0.1:11434/api/tags | head")
+    if not _whisper.available():
+        _log("STT: faster-whisper not installed; /v1/chat/audio will return 503")
+    server.serve_forever()
+
+
+if __name__ == "__main__":
+    main()

V3.1/build/etc/init.d/S04jibo-asr-service

@@ -0,0 +1,96 @@
+#!/bin/sh
+
+# Minimal init.d script to start jibo-asr-service at boot.
+# Matches requested command exactly:
+#   /usr/local/bin/jibo-asr-service -c /usr/local/etc/jibo-asr-service.json
+
+DAEMON="/usr/local/bin/jibo-asr-service"
+CONFIG="/usr/local/etc/jibo-asr-service.json"
+PIDFILE="/var/run/jibo-asr-service.pid"
+LOGFILE="/tmp/jibo-asr-service.log"
+
+is_running() {
+	# Prefer pidof if present
+	if command -v pidof >/dev/null 2>&1; then
+		pidof jibo-asr-service >/dev/null 2>&1 && return 0
+	fi
+	# Fall back to pidfile check
+	if [ -f "$PIDFILE" ]; then
+		PID="$(cat "$PIDFILE" 2>/dev/null)"
+		[ -n "$PID" ] && kill -0 "$PID" >/dev/null 2>&1 && return 0
+	fi
+	return 1
+}
+
+do_start() {
+	if [ ! -x "$DAEMON" ]; then
+		echo "jibo-asr-service: missing $DAEMON" >&2
+		return 0
+	fi
+	if [ ! -f "$CONFIG" ]; then
+		echo "jibo-asr-service: missing $CONFIG" >&2
+		# still try to run; daemon may have defaults
+	fi
+	if is_running; then
+		echo "jibo-asr-service: already running"
+		return 0
+	fi
+
+	echo "Starting jibo-asr-service..."
+	"$DAEMON" -c "$CONFIG" >>"$LOGFILE" 2>&1 &
+	PID=$!
+	echo "$PID" >"$PIDFILE" 2>/dev/null || true
+	return 0
+}
+
+do_stop() {
+	if ! is_running; then
+		echo "jibo-asr-service: not running"
+		rm -f "$PIDFILE" 2>/dev/null || true
+		return 0
+	fi
+
+	echo "Stopping jibo-asr-service..."
+	if [ -f "$PIDFILE" ]; then
+		PID="$(cat "$PIDFILE" 2>/dev/null)"
+		if [ -n "$PID" ]; then
+			kill "$PID" >/dev/null 2>&1 || true
+			sleep 1
+			kill -9 "$PID" >/dev/null 2>&1 || true
+		fi
+	else
+		# Best-effort without pidfile
+		if command -v killall >/dev/null 2>&1; then
+			killall jibo-asr-service >/dev/null 2>&1 || true
+		fi
+	fi
+	rm -f "$PIDFILE" 2>/dev/null || true
+	return 0
+}
+
+case "$1" in
+	start)
+		do_start
+		;;
+	stop)
+		do_stop
+		;;
+	restart|force-reload)
+		do_stop
+		do_start
+		;;
+	status)
+		if is_running; then
+			echo "jibo-asr-service: running"
+			exit 0
+		fi
+		echo "jibo-asr-service: stopped"
+		exit 3
+		;;
+	*)
+		# default: start when called without args
+		do_start
+		;;
+esac
+
+exit 0

V3.1/build/hub-shim/HUB-SHIM_DEPLOYMENT.md

@@ -0,0 +1,57 @@
+# Jibo Hub-Shim Server: Deployment & Usage Guide
+
+## Quick Start
+1. **Install dependencies** (if needed):
+   - Node.js v16+ (recommended v18+)
+   - `npm install` (if package.json present)
+2. **Configure**:
+   - Edit `config.json` (or use `config.example.json`):
+     - `listen.port`: Port to listen on (default: 9000)
+     - `listen.path`: WebSocket path (default: `/v1/listen`)
+     - `asr.baseUrl`: Local ASR HTTP endpoint
+     - `logging.level`: `info`, `debug`, etc.
+3. **Run the server**:
+   ```sh
+   node index.js config.json
+   ```
+   - Or set `JIBO_HUB_SHIM_CONFIG` env var.
+
+## Integration with Jibo Robot
+- The robot's `jibo-jetstream-service` binary must be configured to connect to the hub-shim:
+  - `hub_port`: 9000 (or your chosen port)
+  - `hub_hostname`: IP of the machine running hub-shim
+  - `listen_url`: `/v1/listen`
+- Confirm with logs: hub-shim should show `ws connected` and `listen result` for each turn.
+
+## How It Works
+- The robot opens a WebSocket to hub-shim for every listen turn.
+- hub-shim receives CONTEXT and LISTEN messages, runs ASR/NLU, and sends a TURN_RESULT.
+- The TURN_RESULT is always local (`global: false`), with `status: 'SUCCEEDED'` and the correct intent/entities.
+- This resolves the skill's local turn and allows menu/intro flows to advance by voice.
+
+## Troubleshooting
+- **No skill advancement?**
+  - Check that TURN_RESULT is sent with `status: 'SUCCEEDED'`, `global: false`, and correct `requestID` (should match transID).
+  - Use robot-logger (`/tmp/jibo-skills.log` or web panel) to trace intent and state.
+- **ASR timeouts?**
+  - Ensure ASR service is running and reachable from hub-shim.
+- **NLU not matching?**
+  - Edit `inferNluFromText()` in `index.js` to adjust rule patterns.
+
+## Advanced
+- **Custom NLU**: You can extend `inferNluFromText()` for more complex intent/entity extraction.
+- **Client-supplied ASR/NLU**: Send CLIENT_ASR or CLIENT_NLU messages before LISTEN to inject results.
+- **Logging**: Adjust `logging.level` in config for more/less verbosity.
+
+## File Locations
+- Main server: `index.js`
+- Config: `config.json` or `config.example.json`
+- Protocol doc: `HUB-SHIM_PROTOCOL.md`
+
+## Support
+- For protocol or integration issues, see HUB-SHIM_PROTOCOL.md and the source code comments.
+- For robot-side debugging, use robot-logger and check `/tmp/jibo-skills.log`.
+
+---
+
+# Enjoy fully offline Jibo skills and menus!

V3.1/build/hub-shim/HUB-SHIM_PROTOCOL.md

@@ -0,0 +1,66 @@
+# Jibo Hub-Shim Server: Architecture & Protocol
+
+## Overview
+The hub-shim server emulates the Jibo cloud hub's `/v1/listen` WebSocket protocol, allowing the robot to run skills and menu flows entirely offline. It acts as a bridge between the robot's jetstream service (binary) and local ASR/NLU logic, providing the expected protocol and responses for seamless skill operation.
+
+## Key Features
+- Listens on a configurable port (default: 9000) and path (`/v1/listen`)
+- Accepts WebSocket connections from the robot's jetstream service
+- Handles CONTEXT, LISTEN, CLIENT_ASR, and CLIENT_NLU messages
+- Runs local ASR (via HTTP) and NLU (via rule-based inference)
+- Sends TURN_RESULT responses that resolve the robot's local turn promise
+- Fully mimics the cloud hub protocol, including transID/requestID echo
+
+## Protocol Flow
+1. **Connection**: Jetstream binary opens a WebSocket to `/v1/listen`.
+2. **CONTEXT**: Robot sends context (skill, runtime info).
+3. **LISTEN**: Robot requests a listen turn, providing rules and mode.
+4. **ASR**: hub-shim runs local ASR (or accepts client-supplied text).
+5. **NLU**: hub-shim infers intent/entities from text and rules.
+6. **TURN_RESULT**: hub-shim sends a TURN_RESULT with status `SUCCEEDED`, echoing the transID as requestID, and including asr/nlu/match objects.
+7. **Skill Advances**: The robot's local turn promise resolves, and the skill/menu flow continues.
+
+## Message Types
+- **CONTEXT**: Sets skill/runtime context for the turn.
+- **LISTEN**: Initiates a listen turn; includes rules and mode.
+- **CLIENT_ASR/CLIENT_NLU**: (Optional) Supplies ASR text or NLU result directly.
+- **TURN_RESULT**: Final result; must have `status: 'SUCCEEDED'`, `global: false`, and correct asr/nlu/match.
+
+## Key Implementation Details
+- **requestID**: Always set to the incoming transID for local turns.
+- **asr/nlu/match**: Structured to match the robot's expected ListenResult format.
+- **No global-only results**: All results are sent as local TURN_RESULTs to resolve the skill's local turn.
+- **Skill-specific NLU**: Rule-based inference for menu/intro/yes-no flows.
+
+## Configuration
+- `config.json` controls port, ASR service URL, and logging.
+- ASR service must be running and reachable by hub-shim.
+
+## Debugging
+- Logs all connections, requests, and results.
+- Use robot-logger on the robot to trace skill flow and intent resolution.
+
+## Example TURN_RESULT
+```
+{
+  "type": "TURN_RESULT",
+  "msgID": "...",
+  "transID": "...",
+  "ts": 1234567890,
+  "requestID": "...", // matches transID
+  "data": {
+    "status": "SUCCEEDED",
+    "global": false,
+    "result": {
+      "asr": { "text": "face", "confidence": 1 },
+      "nlu": { "intent": "face", ... },
+      "match": { "onRobot": true }
+    }
+  },
+  "final": true
+}
+```
+
+---
+
+# See also: hub-shim source code for full protocol details.

V3.1/build/hub-shim/README.md

@@ -0,0 +1,73 @@
+# jibo-hub-shim
+
+Minimal Jibo Hub-compatible shim for `/v1/listen`.
+
+## What it does
+
+- Hosts a WebSocket server on `/v1/listen`.
+- Waits for `CONTEXT` + `LISTEN` messages.
+- Triggers offline STT by calling `jibo-asr-service` using:
+  - WebSocket `/simple_port` (event stream)
+  - HTTP `POST /asr_simple_interface` (start/stop)
+  and returns:
+  - `SOS` (start of speech)
+  - `ASR` (text)
+  - `NLU` (minimal intent/entities)
+  - `LISTEN` (final wrapper with `{asr,nlu}`)
+  - `EOS` (end of speech)
+
+This avoids implementing hub-side audio decoding.
+
+## Configure
+
+Copy the example config:
+
+- `cp config.example.json config.json`
+
+Key fields:
+
+- `asrService.baseUrl`
+  - If shim runs on the server: set this to your robot IP, e.g. `http://192.168.1.50:8088`
+  - If shim runs on the robot: keep `http://127.0.0.1:8088`
+- `asrService.audioSourceId`
+  - Usually `alsa1` on-robot. If your robot uses a different input, change it here.
+- `listen.port`: hub shim port (default `9000`)
+
+## Dependencies
+
+- Server-hosted shim: needs Node.js + the `ws` module available via normal Node resolution.
+  - If you have npm: `npm i ws`
+- Robot-hosted shim: does not require npm; it will fall back to the already-bundled `ws` at `/opt/jibo/Jibo/Skills/@be/be/node_modules/ws`.
+
+## Run
+
+- `node index.js ./config.json`
+
+## Server deployment (systemd)
+
+From the `hub-shim/` folder on your server:
+
+- `sudo ./install-server.sh`
+
+This installs:
+
+- Code to `/opt/jibo-hub-shim`
+- Config to `/etc/jibo-hub-shim/config.json`
+- Service unit `jibo-hub-shim.service`
+
+Useful commands:
+
+- `sudo systemctl status jibo-hub-shim`
+- `sudo journalctl -u jibo-hub-shim -f`
+
+## Notes
+
+- The shim serializes STT requests to the robot ASR service to reduce crosstalk/timeouts when Jetstream opens multiple listens quickly.
+- If you regularly speak longer than 15s, increase `asrService.timeoutMs`.
+
+## Jetstream config
+
+Point Jetstream’s HubClient to this shim by setting `HubClient.override` in `/usr/local/etc/jibo-jetstream-service.json`:
+
+- If shim runs on the server: set `hub_hostname` to the server IP.
+- If shim runs on the robot: set `hub_hostname` to `127.0.0.1`.

V3.1/build/hub-shim/config.example.json

@@ -0,0 +1,30 @@
+{
+  "listen": {
+    "bindHost": "0.0.0.0",
+    "port": 9000,
+    "path": "/v1/listen"
+  },
+  "asrService": {
+    "baseUrl": "http://192.168.1.15:8088",
+    "wsPath": "/simple_port",
+    "timeoutMs": 15000,
+    "audioSourceId": "alsa1"
+  },
+  "nlu": {
+    "enabled": true
+  },
+  "gqaShim": {
+    "enabled": false,
+    "bindHost": "0.0.0.0",
+    "port": 8080,
+    "timeoutMs": 20000,
+    "ollama": {
+      "baseUrl": "http://127.0.0.1:11434",
+      "model": "phi3.5",
+      "systemPrompt": "You are Jibo, a friendly social robot. Reply in 1-2 short spoken sentences."
+    }
+  },
+  "logging": {
+    "level": "info"
+  }
+}

V3.1/build/hub-shim/config.json

@@ -0,0 +1,29 @@
+{
+  "listen": {
+    "bindHost": "0.0.0.0",
+    "port": 9000,
+    "path": "/v1/listen"
+  },
+  "asrService": {
+    "baseUrl": "http://192.168.1.15:8088",
+    "wsPath": "/simple_port",
+    "timeoutMs": 15000
+  },
+  "nlu": {
+    "enabled": true
+  },
+  "gqaShim": {
+    "enabled": true,
+    "bindHost": "0.0.0.0",
+    "port": 8080,
+    "timeoutMs": 20000,
+    "ollama": {
+      "baseUrl": "http://127.0.0.1:11434",
+      "model": "phi3.5",
+      "systemPrompt": "You are Jibo, a friendly social robot. Reply in 1-2 short spoken sentences."
+    }
+  },
+  "logging": {
+    "level": "info"
+  }
+}

V3.1/build/hub-shim/index.js

@@ -0,0 +1,842 @@
+/* eslint-disable no-console */
+
+const fs = require('fs');
+const http = require('http');
+const https = require('https');
+const crypto = require('crypto');
+let WebSocket;
+
+function requireWs() {
+	try {
+		// Prefer a normal node resolution (server install, or local node_modules).
+		return require('ws');
+	} catch (_) {
+		// Fallback for on-robot usage where `ws` already exists under the skills runtime.
+		return require('/opt/jibo/Jibo/Skills/@be/be/node_modules/ws');
+	}
+}
+
+WebSocket = requireWs();
+
+function nowMs() {
+	return Date.now();
+}
+
+function uuid() {
+	// Node 14+: crypto.randomUUID exists; otherwise fallback.
+	if (typeof crypto.randomUUID === 'function') return crypto.randomUUID();
+	return [4, 2, 2, 2, 6].map((len) => crypto.randomBytes(len).toString('hex')).join('-');
+}
+
+function loadJson(filePath) {
+	const raw = fs.readFileSync(filePath, 'utf8');
+	return JSON.parse(raw);
+}
+
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function logFactory(level) {
+	const order = { error: 0, warn: 1, info: 2, debug: 3 };
+	const threshold = order[level] ?? 2;
+	return {
+		error: (...args) => threshold >= 0 && console.error('[hub-shim]', ...args),
+		warn: (...args) => threshold >= 1 && console.warn('[hub-shim]', ...args),
+		info: (...args) => threshold >= 2 && console.log('[hub-shim]', ...args),
+		debug: (...args) => threshold >= 3 && console.log('[hub-shim]', ...args),
+	};
+}
+
+function normalizeText(text) {
+	return String(text || '').trim();
+}
+
+function classifyYesNo(text) {
+	const t = normalizeText(text).toLowerCase();
+	// Negative first to avoid matching "no" in "not"?? Keep it simple.
+	if (/\b(no|nope|nah|not really|don't|do not|didn't|did not)\b/.test(t)) return 'no';
+	if (/\b(yes|yep|yeah|ya|sure|ok|okay|i did|i do|i liked it|liked it|that was good|that was great|great|good|awesome|amazing)\b/.test(t)) return 'yes';
+	return '';
+}
+
+function buildAsrResult(text) {
+	return {
+		text,
+		confidence: 1,
+		// Keep these optional fields minimal.
+		alternates: [],
+	};
+}
+
+function buildNluResult(intent, rules = [], entities = {}, slotActionsOverride) {
+	const normalizedIntent = intent || '';
+	const outEntities = entities && typeof entities === 'object' ? { ...entities } : {};
+
+	// Many flows either use `intent` directly or compute firstGrammarTag from
+	// entities[slotActions[0]]. Keep defaults backwards compatible, but allow
+	// callers to provide explicit slotActions for launch-style grammars.
+	let slotActions = [];
+	if (Array.isArray(slotActionsOverride) && slotActionsOverride.length) {
+		slotActions = slotActionsOverride.map((s) => String(s)).filter(Boolean);
+	} else if (normalizedIntent) {
+		slotActions = [normalizedIntent];
+		if (outEntities[normalizedIntent] == null) outEntities[normalizedIntent] = normalizedIntent;
+	}
+
+	return {
+		rules: Array.isArray(rules) ? rules : [],
+		intent: normalizedIntent,
+		entities: outEntities,
+		slotActions,
+		source: 'hub-shim',
+		confidence: normalizedIntent ? 1 : 0,
+	};
+}
+
+function hasRule(rules, want) {
+	if (!Array.isArray(rules) || !want) return false;
+	const w = String(want).toLowerCase();
+	for (const r of rules) {
+		const s = String(r || '').toLowerCase();
+		if (!s) continue;
+		if (s === w) return true;
+		if (s.endsWith('/' + w)) return true;
+		// Common aliasing patterns.
+		if (w === 'launch' && (s.includes('global_commands_launch') || s.includes('commands_launch'))) return true;
+		if (w === 'dance' && s.includes('tutorial/dance')) return true;
+		if ((w === 'take_photo' || w === 'photo') && (s.includes('tutorial/take_photo') || s.includes('take_photo'))) return true;
+	}
+	return false;
+}
+
+function inferNluFromText(text, rules) {
+	const t = normalizeText(text).toLowerCase();
+
+	// No text → empty intent (ListenResultState.noInput → Mim re-prompts or times out).
+	if (!t) return buildNluResult('', rules, {});
+
+	// Yes/No detection — common across many MIM types.
+	const yn = classifyYesNo(text);
+
+	if (!Array.isArray(rules) || !rules.length) {
+		return yn ? buildNluResult(yn, rules, {}) : buildNluResult('', rules, {});
+	}
+
+	// ── Skill-specific rule matching (checked BEFORE global catch-all) ──
+
+	// introductions/recognition_type_menu: expects face, name, voice, all
+	if (hasRule(rules, 'recognition_type_menu')) {
+		if (/\bface\b/.test(t)) return buildNluResult('face', rules, {});
+		if (/\bname\b/.test(t)) return buildNluResult('name', rules, {});
+		if (/\bvoice\b/.test(t)) return buildNluResult('voice', rules, {});
+		if (/\b(all|everything|everyone)\b/.test(t)) return buildNluResult('all', rules, {});
+		if (yn) return buildNluResult(yn, rules, {});
+		return buildNluResult('', rules, {});
+	}
+
+	// introductions/voice_face_training_menu: similar recognition type choices
+	if (hasRule(rules, 'voice_face_training_menu')) {
+		if (/\bface\b/.test(t)) return buildNluResult('face', rules, {});
+		if (/\bname\b/.test(t)) return buildNluResult('name', rules, {});
+		if (/\bvoice\b/.test(t)) return buildNluResult('voice', rules, {});
+		if (/\b(all|everything)\b/.test(t)) return buildNluResult('all', rules, {});
+		if (yn) return buildNluResult(yn, rules, {});
+		return buildNluResult('', rules, {});
+	}
+
+	// introductions yes/no questions: face_capture_ready, did_i_hear_name,
+	// did_i_pronounce_name, any_more_intros, recognition_any_more
+	if (rules.some((r) => /face_capture|did_i_hear|did_i_pronounce|any_more|recognition_any_more/.test(r))) {
+		if (yn) return buildNluResult(yn, rules, {});
+		return buildNluResult('', rules, {});
+	}
+
+	// introductions/intro_looper: expects loopmember intent with loopMemberReferent entity.
+	// Without real NLU we cannot resolve the entity → return noMatch so the MIM re-prompts.
+	if (hasRule(rules, 'intro_looper')) {
+		if (yn) return buildNluResult(yn, rules, {});
+		return buildNluResult('', rules, {});
+	}
+
+	// main-menu/execute_main_menu: map spoken words to menu items.
+	if (hasRule(rules, 'execute_main_menu')) {
+		if (/\bintroduc/.test(t)) return buildNluResult('loadMenu', rules, { loadMenu: 'introductions' });
+		if (/\bsurprise/.test(t)) return buildNluResult('loadMenu', rules, { loadMenu: 'surprise-me' });
+		if (/\b(time|clock)\b/.test(t)) return buildNluResult('loadMenu', rules, { loadMenu: 'clock' });
+		if (/\bphoto\s*booth\b/.test(t)) return buildNluResult('loadMenu', rules, { loadMenu: 'photobooth' });
+		if (/\bgallery\b/.test(t)) return buildNluResult('loadMenu', rules, { loadMenu: 'gallery' });
+		if (/\b(exercise|workout)\b/.test(t)) return buildNluResult('loadMenu', rules, { loadMenu: 'exercise' });
+		if (/\b(radio|music)\b/.test(t)) return buildNluResult('loadMenu', rules, { loadMenu: 'radio' });
+		if (/\bsettings?\b/.test(t)) return buildNluResult('loadMenu', rules, { loadMenu: 'settings' });
+		if (/\btips?\b/.test(t)) return buildNluResult('loadMenu', rules, { loadMenu: 'tips-tricks' });
+		if (/\bfun\b/.test(t)) return buildNluResult('loadMenu', rules, { loadMenu: 'fun-stuff' });
+		if (/\bcreate\b/.test(t)) return buildNluResult('loadMenu', rules, { loadMenu: 'create' });
+		if (/\b(report|personal)\b/.test(t)) return buildNluResult('loadMenu', rules, { loadMenu: 'personal-report' });
+		// Fall through to generic patterns below.
+	}
+
+	// ── Generic patterns ──
+
+	// Yes/No (applies to any MIM type that accepts it)
+	if (yn) return buildNluResult(yn, rules, {});
+
+	// Dance / Photo (tutorial rules)
+	if (hasRule(rules, 'dance') && /\bdance\b/.test(t)) return buildNluResult('dance', rules, {});
+	if (hasRule(rules, 'take_photo') && /\b(photo|picture|take a photo|take a picture)\b/.test(t)) return buildNluResult('take_photo', rules, {});
+
+	// Global launch commands — only for specific well-known commands.
+	// Do NOT catch-all to chitchat; that breaks in-skill NLU.
+	if (hasRule(rules, 'launch')) {
+		if (/\bdance\b/.test(t)) return buildNluResult('launch', rules, { skill: 'dance', query: normalizeText(text) }, ['skill']);
+		if (/\b(photo|picture|take a photo|take a picture|selfie)\b/.test(t)) return buildNluResult('launch', rules, { skill: 'photobooth', query: normalizeText(text) }, ['skill']);
+	}
+
+	// Default: no match — lets the Mim framework re-prompt or handle noMatch.
+	return buildNluResult('', rules, {});
+}
+
+function httpJsonPostRaw(urlString, payload, timeoutMs) {
+	timeoutMs = typeof timeoutMs === 'number' ? timeoutMs : 6000;
+	const u = new URL(urlString);
+	const bodyStr = JSON.stringify(payload || {});
+	const body = Buffer.from(bodyStr, 'utf8');
+	const isHttps = u.protocol === 'https:';
+	const requestOptions = {
+		protocol: u.protocol,
+		hostname: u.hostname,
+		port: u.port || (isHttps ? 443 : 80),
+		path: u.pathname + (u.search || ''),
+		method: 'POST',
+		headers: {
+			'Content-Type': 'application/json',
+			'Content-Length': body.length,
+		},
+		timeout: timeoutMs,
+	};
+
+	return new Promise((resolve, reject) => {
+		const req = (isHttps ? https : http).request(requestOptions, (res) => {
+			const chunks = [];
+			res.on('data', (d) => chunks.push(d));
+			res.on('end', () => {
+				resolve({
+					statusCode: res.statusCode,
+					headers: res.headers || {},
+					body: Buffer.concat(chunks).toString('utf8'),
+				});
+			});
+		});
+		req.on('error', reject);
+		req.on('timeout', () => {
+			req.destroy(new Error('POST timeout'));
+		});
+		req.write(body);
+		req.end();
+	});
+}
+
+function readJsonBody(req, maxBytes = 256 * 1024) {
+	return new Promise((resolve, reject) => {
+		let total = 0;
+		const chunks = [];
+		req.on('data', (d) => {
+			total += d.length || 0;
+			if (total > maxBytes) {
+				reject(new Error('request body too large'));
+				try { req.destroy(); } catch (_) { /* ignore */ }
+				return;
+			}
+			chunks.push(d);
+		});
+		req.on('end', () => {
+			const raw = Buffer.concat(chunks).toString('utf8');
+			if (!raw) return resolve({});
+			try {
+				resolve(JSON.parse(raw));
+			} catch (e) {
+				reject(new Error('invalid json body'));
+			}
+		});
+		req.on('error', reject);
+	});
+}
+
+async function ollamaAnswer({ baseUrl, model, system, prompt, timeoutMs }) {
+	baseUrl = String(baseUrl || 'http://127.0.0.1:11434').replace(/\/+$/, '');
+	model = String(model || 'llama3');
+	system = typeof system === 'string' ? system : 'Answer conversationally and concisely.';
+	prompt = String(prompt || '').trim();
+	if (!prompt) return '';
+
+	// Prefer /api/generate; fallback to /api/chat.
+	try {
+		const r = await httpJsonPostRaw(`${baseUrl}/api/generate`, {
+			model,
+			system,
+			prompt,
+			stream: false,
+		}, timeoutMs);
+		if (r.statusCode >= 200 && r.statusCode < 300) {
+			const obj = JSON.parse(r.body || '{}');
+			return String(obj.response || '').trim();
+		}
+	} catch (_) {
+		// fall through
+	}
+
+	const r2 = await httpJsonPostRaw(`${baseUrl}/api/chat`, {
+		model,
+		stream: false,
+		messages: [
+			{ role: 'system', content: system },
+			{ role: 'user', content: prompt },
+		],
+	}, timeoutMs);
+	if (!(r2.statusCode >= 200 && r2.statusCode < 300)) {
+		throw new Error(`ollama http ${r2.statusCode}`);
+	}
+	const obj2 = JSON.parse(r2.body || '{}');
+	return String(obj2.message && obj2.message.content ? obj2.message.content : '').trim();
+}
+
+function createGqaShim(config, logger) {
+	const gqa = (config && config.gqaShim) || {};
+	const enabled = !!gqa.enabled || String(process.env.JIBO_GQA_SHIM_ENABLE || '').toLowerCase() === '1' || String(process.env.JIBO_GQA_SHIM_ENABLE || '').toLowerCase() === 'true';
+	if (!enabled) return null;
+
+	const bindHost = gqa.bindHost || process.env.JIBO_GQA_SHIM_BIND_HOST || '0.0.0.0';
+	const port = Number(gqa.port || process.env.JIBO_GQA_SHIM_PORT || 8080);
+	const timeoutMs = Number(gqa.timeoutMs || process.env.JIBO_GQA_SHIM_TIMEOUT_MS || 20000);
+	const ollama = (gqa.ollama || {});
+	const ollamaBaseUrl = ollama.baseUrl || process.env.OLLAMA_BASE_URL || 'http://127.0.0.1:11434';
+	const ollamaModel = ollama.model || process.env.OLLAMA_MODEL || 'llama3';
+	const systemPrompt = ollama.systemPrompt || process.env.OLLAMA_SYSTEM_PROMPT || 'You are Jibo, a friendly social robot. Reply in 1-2 short spoken sentences.';
+
+	const server = http.createServer(async (req, res) => {
+		try {
+			if (req.method === 'GET') {
+				res.writeHead(200, { 'content-type': 'text/plain' });
+				res.end('jibo-gqa-shim\n');
+				return;
+			}
+			if (req.method !== 'POST') {
+				res.writeHead(405, { 'content-type': 'application/json' });
+				res.end(JSON.stringify({ message: 'method not allowed' }));
+				return;
+			}
+
+			const target = String((req.headers && (req.headers['x-amz-target'] || req.headers['X-Amz-Target'])) || '').trim();
+			const op = target.includes('.') ? target.split('.').pop() : '';
+			const body = await readJsonBody(req);
+
+			if (op === 'Question') {
+				const input = (body && (body.Input || body.input)) ? String(body.Input || body.input) : '';
+				logger.info('gqa Question', { input: input.slice(0, 120) });
+				let answer = '';
+				try {
+					answer = await ollamaAnswer({
+						baseUrl: ollamaBaseUrl,
+						model: ollamaModel,
+						system: systemPrompt,
+						prompt: input,
+						timeoutMs,
+					});
+				} catch (e) {
+					logger.warn('ollama failed', { err: String(e && (e.stack || e.message || e)) });
+					answer = '';
+				}
+
+				const ok = !!answer;
+				const resp = {
+					success: ok,
+					source: ok ? 'MOCK' : 'No Match',
+					message: ok ? undefined : 'No response',
+					type: ok ? 'answer' : 'error',
+					timestamps: {},
+					response: {
+						type: 'string',
+						payload: answer,
+					},
+					version: '0.0.1',
+				};
+				res.writeHead(200, { 'content-type': 'application/x-amz-json-1.0' });
+				res.end(JSON.stringify(resp));
+				return;
+			}
+
+			if (op === 'ListAttribution') {
+				const resp = { success: true, attributions: [], timestamps: {}, version: '0.0.1' };
+				res.writeHead(200, { 'content-type': 'application/x-amz-json-1.0' });
+				res.end(JSON.stringify(resp));
+				return;
+			}
+
+			res.writeHead(400, { 'content-type': 'application/x-amz-json-1.0' });
+			res.end(JSON.stringify({ message: 'unknown operation', target }));
+		} catch (e) {
+			res.writeHead(500, { 'content-type': 'application/x-amz-json-1.0' });
+			res.end(JSON.stringify({ message: String(e && (e.message || e)) }));
+		}
+	});
+
+	logger.info('gqa http', { bindHost, port, ollamaBaseUrl, ollamaModel });
+
+	return {
+		start: () => new Promise((resolve, reject) => server.listen(port, bindHost, (err) => (err ? reject(err) : resolve()))),
+		stop: () => new Promise((resolve) => server.close(() => resolve())),
+	};
+}
+
+function pickBestAsrUtterance(utterances) {
+	try {
+		if (!utterances || !utterances.length) return '';
+		let bestText = '';
+		let bestScore = -1e99;
+		for (const u of utterances) {
+			let text = u && (u.utterance || u.Utterance || u.text) ? String(u.utterance || u.Utterance || u.text) : '';
+			text = text.trim();
+			if (!text) continue;
+			if (text.length >= 2 && text[0].toLowerCase && text[1].toLowerCase && text[0].toLowerCase() === text[1].toLowerCase()) {
+				text = text.slice(1);
+			}
+			const score = typeof u.score === 'number' ? u.score : (typeof u.Score === 'number' ? u.Score : 0);
+			if (!bestText || score > bestScore) {
+				bestText = text;
+				bestScore = score;
+			}
+		}
+		return bestText;
+	} catch (_) {
+		return '';
+	}
+}
+
+function extractFinalTextFromAsrEvent(evt) {
+	// jibo-asr-service has had multiple JSON shapes across builds. Prefer utterances,
+	// but accept common fallback fields.
+	try {
+		const utterances = evt.utterances || evt.Utterances || (evt.payload && (evt.payload.utterances || evt.payload.Utterances));
+		const best = pickBestAsrUtterance(utterances);
+		if (best && String(best).trim()) return String(best).trim();
+
+		const candidates = [
+			evt.text,
+			evt.transcript,
+			evt.utterance,
+			evt.Utterance,
+			evt.payload && (evt.payload.text || evt.payload.transcript || evt.payload.utterance || evt.payload.Utterance),
+		];
+		for (const c of candidates) {
+			if (typeof c === 'string' && c.trim()) return c.trim();
+		}
+		return '';
+	} catch (_) {
+		return '';
+	}
+}
+
+async function asrServiceSttOnce(asrBaseUrl, wsPath, timeoutMs, audioSourceId, logger) {
+	// jibo-asr-service protocol:
+	// 1) Connect to WS /simple_port (event stream)
+	// 2) HTTP POST /asr_simple_interface {command:'start', task_id, audio_source_id, ...}
+	// 3) Wait for event_type=='speech_to_text_final' and extract utterance
+	// 4) HTTP POST /asr_simple_interface {command:'stop', task_id}
+	const url = new URL(asrBaseUrl);
+	const wsUrl = `${url.protocol === 'https:' ? 'wss' : 'ws'}://${url.host}${wsPath}`;
+	const baseHttp = `${url.protocol}//${url.host}`;
+	const taskId = `hub-shim-${Date.now()}-${Math.floor(Math.random() * 1e9)}`;
+	const requestId = `stt_start_${Date.now()}_${Math.floor(Math.random() * 1e9)}`;
+	logger.debug('asr connect', { wsUrl, baseHttp, taskId });
+
+	return await new Promise((resolve, reject) => {
+		const ws = new WebSocket(wsUrl);
+		let done = false;
+		const t0 = nowMs();
+		let timer;
+
+		function finish(err, value) {
+			if (done) return;
+			done = true;
+			if (timer) clearTimeout(timer);
+			try {
+				ws.close();
+			} catch (_) {
+				// ignore
+			}
+			if (err) reject(err);
+			else resolve(value);
+		}
+
+		async function stopAlways() {
+			const stopPayload = {
+				command: 'stop',
+				task_id: taskId,
+				request_id: `stt_stop_${Date.now()}_${Math.floor(Math.random() * 1e9)}`,
+			};
+			try {
+				await httpJsonPostRaw(`${baseHttp}/asr_simple_interface`, stopPayload, 6000);
+			} catch (_) {
+				// ignore
+			}
+		}
+
+		timer = setTimeout(() => {
+			stopAlways().finally(() => {
+				finish(new Error(`asr timeout after ${timeoutMs}ms`));
+			});
+		}, timeoutMs);
+
+		ws.on('open', async () => {
+			const startPayload = {
+				command: 'start',
+				task_id: taskId,
+				audio_source_id: String(audioSourceId || 'alsa1'),
+				hotphrase: 'none',
+				speech_to_text: true,
+				request_id: requestId,
+			};
+			try {
+				const resp = await httpJsonPostRaw(`${baseHttp}/asr_simple_interface`, startPayload, 8000);
+				if (!resp || !resp.statusCode || resp.statusCode < 200 || resp.statusCode >= 300) {
+					await stopAlways();
+					finish(new Error(`asr start failed: HTTP ${resp && resp.statusCode} ${resp && resp.body ? resp.body.slice(0, 200) : ''}`));
+					return;
+				}
+				logger.info('asr start', { ms: nowMs() - t0, status: resp.statusCode });
+			} catch (e) {
+				await stopAlways();
+				finish(e);
+			}
+		});
+
+		ws.on('message', (data) => {
+			let evt;
+			try {
+				evt = JSON.parse(data.toString('utf8'));
+			} catch (_) {
+				return;
+			}
+			if (!evt) return;
+
+			// Legacy/simple protocols: {type:'final', text:'...'}
+			const isFinal = evt.type === 'final' || evt.final === true || evt.isFinal === true;
+			const simpleText = evt.text || evt.transcript;
+			if (isFinal && typeof simpleText === 'string') {
+				stopAlways().finally(() => {
+					logger.info('asr final(simple)', { ms: nowMs() - t0, text: String(simpleText).slice(0, 80) });
+					finish(null, normalizeText(simpleText));
+				});
+				return;
+			}
+
+			const eventType = evt.event_type || evt.eventType || evt.event || evt.type;
+			if (eventType !== 'speech_to_text_final') return;
+
+			// Correlate ids when possible, but do not hard-require a match.
+			const evTaskId = evt.task_id || evt.taskId || (evt.payload && (evt.payload.task_id || evt.payload.taskId));
+			const evRequestId = evt.request_id || evt.requestId || (evt.payload && (evt.payload.request_id || evt.payload.requestId));
+			const idMatches = (!evTaskId && !evRequestId) || (evTaskId && String(evTaskId) === String(taskId)) || (evRequestId && String(evRequestId) === String(requestId));
+			if (!idMatches) {
+				logger.debug('asr final id mismatch (accepting)', {
+					taskId,
+					requestId,
+					evTaskId,
+					evRequestId,
+				});
+			}
+
+			const finalText = extractFinalTextFromAsrEvent(evt);
+			if (!finalText) {
+				logger.debug('asr final but no text extracted', {
+					keys: Object.keys(evt || {}).slice(0, 30),
+					payloadKeys: evt && evt.payload ? Object.keys(evt.payload).slice(0, 30) : undefined,
+				});
+				return;
+			}
+
+			stopAlways().finally(() => {
+				logger.info('asr final', { ms: nowMs() - t0, text: String(finalText).slice(0, 80) });
+				finish(null, normalizeText(finalText));
+			});
+		});
+
+		ws.on('error', async (e) => {
+			await stopAlways();
+			finish(e);
+		});
+
+		ws.on('close', () => {
+			if (!done) {
+				finish(new Error('asr ws closed before final'));
+			}
+		});
+	});
+}
+
+function send(ws, obj) {
+	ws.send(JSON.stringify(obj));
+}
+
+function extractTransIdFromHeaders(req) {
+	// Jetstream sets an x-jibo-transid header (see @jibo/interfaces Headers.transID).
+	const h = req.headers || {};
+	return h['x-jibo-transid'] || h['X-Jibo-TransId'] || h['x-jibo-transId'] || h['x-jibo-transID'] || '';
+}
+
+function createHubShim(configPath) {
+	const config = loadJson(configPath);
+	const logger = logFactory(config?.logging?.level || 'info');
+
+	const listen = config.listen || {};
+	const port = Number(listen.port || 9000);
+	const bindHost = listen.bindHost || '0.0.0.0';
+	const path = listen.path || '/v1/listen';
+
+	const asr = config.asrService || {};
+	const asrBaseUrl = asr.baseUrl || 'http://127.0.0.1:8088';
+	const wsPath = asr.wsPath || '/simple_port';
+	const timeoutMs = Number(asr.timeoutMs || 15000);
+	const audioSourceId = asr.audioSourceId || 'alsa1';
+
+	// The robot ASR service is effectively a shared hardware resource.
+	// Jetstream may open multiple WS connections/listens concurrently; serialize STT
+	// to avoid crosstalk and reduce timeouts.
+	let asrQueue = Promise.resolve();
+	function runAsrQueued(fn) {
+		const queuedAt = nowMs();
+		const run = async () => {
+			const waited = nowMs() - queuedAt;
+			if (waited > 50) logger.debug('asr queue wait', { waitedMs: waited });
+			return await fn();
+		};
+		const p = asrQueue.then(run, run);
+		asrQueue = p.catch(() => undefined);
+		return p;
+	}
+
+	const server = http.createServer((req, res) => {
+		res.writeHead(200, { 'content-type': 'text/plain' });
+		res.end('jibo-hub-shim\n');
+	});
+
+	const wss = new WebSocket.Server({ server, path });
+	logger.info('listen ws', { bindHost, port, path, asrBaseUrl, audioSourceId });
+
+	const gqaShim = createGqaShim(config, logger);
+
+	wss.on('connection', (ws, req) => {
+		const connId = uuid().slice(0, 8);
+		const transID = extractTransIdFromHeaders(req);
+		logger.info('ws connected', { connId, transID: transID || undefined });
+
+		let binaryFrames = 0;
+		let binaryBytes = 0;
+
+		let lastContext = null;
+		let lastContextMsg = null;
+		let pendingListen = null;
+
+		async function maybeHandleListen() {
+			if (!lastContext || !pendingListen) return;
+			const listenMsg = pendingListen;
+			const mode = listenMsg?.data?.mode;
+
+			// If the client is responsible for supplying ASR or NLU, wait until we receive it.
+			if (mode === 'CLIENT_ASR' && !listenMsg._clientAsrText) return;
+			if (mode === 'CLIENT_NLU' && !listenMsg._clientNlu) return;
+			pendingListen = null;
+
+			// Derive transID: echo back the transID the jetstream-service sent.
+			// It may appear on either the LISTEN or CONTEXT message.
+			const msgTransID = listenMsg.transID || (lastContextMsg && lastContextMsg.transID) || transID || '';
+
+			const t0 = nowMs();
+
+			let text = '';
+			try {
+				if (mode === 'CLIENT_ASR') {
+					text = normalizeText(listenMsg._clientAsrText);
+				} else if (mode === 'CLIENT_NLU') {
+					// No ASR needed for client-supplied NLU.
+				} else {
+					text = await runAsrQueued(() => asrServiceSttOnce(asrBaseUrl, wsPath, timeoutMs, audioSourceId, logger));
+				}
+			} catch (e) {
+				logger.warn('asr failed', { connId, err: String(e && (e.stack || e.message || e)) });
+				// Still send an empty listen result.
+			}
+
+			const rules = Array.isArray(listenMsg?.data?.rules) ? listenMsg.data.rules : [];
+			const nluRes =
+				(mode === 'CLIENT_NLU' && listenMsg._clientNlu)
+					? listenMsg._clientNlu
+					: ((config?.nlu?.enabled === false) ? buildNluResult('', rules, {}) : inferNluFromText(text, rules));
+			const asrRes = buildAsrResult(text);
+
+			// Build the match object (mirrors what the cloud hub returns).
+			const skillID = (lastContext && lastContext.skill && lastContext.skill.skillID)
+				? lastContext.skill.skillID
+				: (lastContext && typeof lastContext.skill === 'string' ? lastContext.skill : '');
+			const matchObj = { onRobot: true };
+			if (skillID) matchObj.skillID = skillID;
+
+			logger.info('listen result', {
+				connId,
+				transID: msgTransID || undefined,
+				text: String(text || '').slice(0, 120),
+				intent: nluRes && nluRes.intent,
+				slot0: nluRes && Array.isArray(nluRes.slotActions) ? nluRes.slotActions[0] : undefined,
+				skill: nluRes && nluRes.entities ? nluRes.entities.skill : undefined,
+				rule0: Array.isArray(rules) ? rules[0] : undefined,
+				rulesCount: Array.isArray(rules) ? rules.length : 0,
+				rules: Array.isArray(rules) ? rules.slice(0, 6) : [],
+			});
+
+			// Send a local TURN_RESULT (not just LISTEN) so the skill's local turn resolves.
+			const turnResult = {
+				type: 'TURN_RESULT',
+				msgID: listenMsg.msgID || uuid(),
+				transID: msgTransID,
+				ts: nowMs(),
+				requestID: msgTransID, // local turn uses transID as requestID
+				data: {
+					status: 'SUCCEEDED',
+					global: false,
+					result: {
+						asr: asrRes,
+						nlu: nluRes,
+						match: matchObj,
+					},
+				},
+				final: true,
+			};
+			send(ws, turnResult);
+		}
+
+		ws.on('message', async (data, isBinary) => {
+			if (isBinary) {
+				binaryFrames += 1;
+				try {
+					binaryBytes += (data && (data.length || data.byteLength)) || 0;
+				} catch (_) {
+					// ignore
+				}
+				if (binaryFrames <= 3 || (binaryFrames % 50) === 0) {
+					logger.debug('rx binary', { connId, frames: binaryFrames, bytes: binaryBytes });
+				}
+				// Ignore audio/binary frames; this shim does not decode audio.
+				return;
+			}
+
+			let msg;
+			try {
+				msg = JSON.parse(data.toString('utf8'));
+			} catch (e) {
+				logger.warn('bad json', { connId, sample: String(data || '').slice(0, 120) });
+				return;
+			}
+
+			if (!msg || typeof msg.type !== 'string') return;
+			logger.debug('rx', { connId, type: msg.type });
+
+			switch (msg.type) {
+				case 'CONTEXT':
+					lastContext = msg.data;
+					lastContextMsg = msg;
+					logger.debug('context', {
+						connId,
+						transID: msg.transID || undefined,
+						hasSkill: !!(msg.data && msg.data.skill),
+						hasRuntime: !!(msg.data && msg.data.runtime),
+					});
+					break;
+				case 'LISTEN':
+					pendingListen = msg;
+					logger.debug('listen req', {
+						connId,
+						transID: msg.transID || undefined,
+						hotphrase: !!(msg.data && msg.data.hotphrase),
+						mode: msg.data && msg.data.mode,
+						rules: Array.isArray(msg.data && msg.data.rules) ? msg.data.rules : [],
+					});
+					break;
+				case 'CLIENT_ASR':
+					// Accept client-provided text (requires a LISTEN message too).
+					if (!pendingListen) {
+						pendingListen = { type: 'LISTEN', msgID: uuid(), transID: msg.transID, ts: nowMs(), data: { rules: [], mode: 'CLIENT_ASR' } };
+					}
+					pendingListen._clientAsrText = msg.data?.text;
+					break;
+				case 'CLIENT_NLU':
+					if (!pendingListen) {
+						pendingListen = { type: 'LISTEN', msgID: uuid(), transID: msg.transID, ts: nowMs(), data: { rules: [], mode: 'CLIENT_NLU' } };
+					}
+					pendingListen._clientNlu = msg.data;
+					break;
+				default:
+					// TRIGGER/proactive not implemented yet.
+					break;
+			}
+
+			// Normal path: wait for both CONTEXT and LISTEN then handle.
+			try {
+				await maybeHandleListen();
+			} catch (e) {
+				logger.warn('listen handler error', { connId, err: String(e && (e.stack || e.message || e)) });
+			}
+		});
+
+		ws.on('close', () => {
+			logger.info('ws closed', { connId });
+		});
+
+		ws.on('error', (e) => {
+			logger.warn('ws error', { connId, err: String(e && (e.stack || e.message || e)) });
+		});
+	});
+
+	return {
+		start: () => new Promise((resolve, reject) => {
+			server.listen(port, bindHost, async (err) => {
+				if (err) return reject(err);
+				try {
+					if (gqaShim) await gqaShim.start();
+					resolve();
+				} catch (e) {
+					reject(e);
+				}
+			});
+		}),
+		stop: () => new Promise((resolve) => {
+			const done = async () => {
+				try {
+					if (gqaShim) await gqaShim.stop();
+				} finally {
+					resolve();
+				}
+			};
+			server.close(() => { done().catch(() => resolve()); });
+		}),
+		config,
+	};
+}
+
+async function main() {
+	const configPath = process.argv[2] || process.env.JIBO_HUB_SHIM_CONFIG || './config.json';
+	if (!fs.existsSync(configPath)) {
+		console.error('Config file not found:', configPath);
+		process.exit(2);
+	}
+	const shim = createHubShim(configPath);
+	await shim.start();
+	// Keep process alive.
+	for (;;) await sleep(60_000);
+}
+
+if (require.main === module) {
+	main().catch((e) => {
+		console.error('[hub-shim] fatal:', e && (e.stack || e.message || e));
+		process.exit(1);
+	});
+}

V3.1/build/hub-shim/install-server.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SRC_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DEST_DIR="/opt/jibo-hub-shim"
+CONF_DIR="/etc/jibo-hub-shim"
+SERVICE_FILE_SRC="$SRC_DIR/systemd/jibo-hub-shim.service"
+SERVICE_FILE_DEST="/etc/systemd/system/jibo-hub-shim.service"
+
+if [[ $EUID -ne 0 ]]; then
+  echo "Please run as root (sudo)." >&2
+  exit 1
+fi
+
+mkdir -p "$DEST_DIR" "$CONF_DIR"
+
+# Copy code (keep node_modules on server side; do not copy any from build tree)
+rsync -a --delete \
+  --exclude node_modules \
+  --exclude .git \
+  --exclude '*.log' \
+  "$SRC_DIR/" "$DEST_DIR/"
+
+# Install default config if missing
+if [[ ! -f "$CONF_DIR/config.json" ]]; then
+  if [[ -f "$SRC_DIR/config.example.json" ]]; then
+    cp "$SRC_DIR/config.example.json" "$CONF_DIR/config.json"
+  elif [[ -f "$SRC_DIR/config.json" ]]; then
+    cp "$SRC_DIR/config.json" "$CONF_DIR/config.json"
+  else
+    echo "No config.example.json found; create $CONF_DIR/config.json manually." >&2
+  fi
+fi
+
+# Install env file if missing
+if [[ ! -f "$CONF_DIR/jibo-hub-shim.env" ]]; then
+  cp "$SRC_DIR/systemd/jibo-hub-shim.env.example" "$CONF_DIR/jibo-hub-shim.env"
+fi
+
+# Install/refresh systemd unit
+install -m 0644 "$SERVICE_FILE_SRC" "$SERVICE_FILE_DEST"
+
+systemctl daemon-reload
+
+# Install dependencies if npm exists
+if command -v npm >/dev/null 2>&1; then
+  cd "$DEST_DIR"
+  npm install --omit=dev
+else
+  echo "npm not found; ensure the 'ws' module is available for node resolution." >&2
+fi
+
+systemctl enable --now jibo-hub-shim.service
+
+echo
+systemctl --no-pager --full status jibo-hub-shim.service || true
+
+echo
+echo "Installed. Config: $CONF_DIR/config.json"
+echo "Logs: journalctl -u jibo-hub-shim -f"

V3.1/build/hub-shim/node_modules/.package-lock.json

@@ -0,0 +1,29 @@
+{
+  "name": "jibo-hub-shim",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/ws": {
+      "version": "8.19.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
+      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

V3.1/build/hub-shim/node_modules/ws/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+Copyright (c) 2013 Arnout Kazemier and contributors
+Copyright (c) 2016 Luigi Pinca and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

V3.1/build/hub-shim/node_modules/ws/README.md

@@ -0,0 +1,548 @@
+# ws: a Node.js WebSocket library
+
+[![Version npm](https://img.shields.io/npm/v/ws.svg?logo=npm)](https://www.npmjs.com/package/ws)
+[![CI](https://img.shields.io/github/actions/workflow/status/websockets/ws/ci.yml?branch=master&label=CI&logo=github)](https://github.com/websockets/ws/actions?query=workflow%3ACI+branch%3Amaster)
+[![Coverage Status](https://img.shields.io/coveralls/websockets/ws/master.svg?logo=coveralls)](https://coveralls.io/github/websockets/ws)
+
+ws is a simple to use, blazing fast, and thoroughly tested WebSocket client and
+server implementation.
+
+Passes the quite extensive Autobahn test suite: [server][server-report],
+[client][client-report].
+
+**Note**: This module does not work in the browser. The client in the docs is a
+reference to a backend with the role of a client in the WebSocket communication.
+Browser clients must use the native
+[`WebSocket`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket)
+object. To make the same code work seamlessly on Node.js and the browser, you
+can use one of the many wrappers available on npm, like
+[isomorphic-ws](https://github.com/heineiuo/isomorphic-ws).
+
+## Table of Contents
+
+- [Protocol support](#protocol-support)
+- [Installing](#installing)
+  - [Opt-in for performance](#opt-in-for-performance)
+    - [Legacy opt-in for performance](#legacy-opt-in-for-performance)
+- [API docs](#api-docs)
+- [WebSocket compression](#websocket-compression)
+- [Usage examples](#usage-examples)
+  - [Sending and receiving text data](#sending-and-receiving-text-data)
+  - [Sending binary data](#sending-binary-data)
+  - [Simple server](#simple-server)
+  - [External HTTP/S server](#external-https-server)
+  - [Multiple servers sharing a single HTTP/S server](#multiple-servers-sharing-a-single-https-server)
+  - [Client authentication](#client-authentication)
+  - [Server broadcast](#server-broadcast)
+  - [Round-trip time](#round-trip-time)
+  - [Use the Node.js streams API](#use-the-nodejs-streams-api)
+  - [Other examples](#other-examples)
+- [FAQ](#faq)
+  - [How to get the IP address of the client?](#how-to-get-the-ip-address-of-the-client)
+  - [How to detect and close broken connections?](#how-to-detect-and-close-broken-connections)
+  - [How to connect via a proxy?](#how-to-connect-via-a-proxy)
+- [Changelog](#changelog)
+- [License](#license)
+
+## Protocol support
+
+- **HyBi drafts 07-12** (Use the option `protocolVersion: 8`)
+- **HyBi drafts 13-17** (Current default, alternatively option
+  `protocolVersion: 13`)
+
+## Installing
+
+```
+npm install ws
+```
+
+### Opt-in for performance
+
+[bufferutil][] is an optional module that can be installed alongside the ws
+module:
+
+```
+npm install --save-optional bufferutil
+```
+
+This is a binary addon that improves the performance of certain operations such
+as masking and unmasking the data payload of the WebSocket frames. Prebuilt
+binaries are available for the most popular platforms, so you don't necessarily
+need to have a C++ compiler installed on your machine.
+
+To force ws to not use bufferutil, use the
+[`WS_NO_BUFFER_UTIL`](./doc/ws.md#ws_no_buffer_util) environment variable. This
+can be useful to enhance security in systems where a user can put a package in
+the package search path of an application of another user, due to how the
+Node.js resolver algorithm works.
+
+#### Legacy opt-in for performance
+
+If you are running on an old version of Node.js (prior to v18.14.0), ws also
+supports the [utf-8-validate][] module:
+
+```
+npm install --save-optional utf-8-validate
+```
+
+This contains a binary polyfill for [`buffer.isUtf8()`][].
+
+To force ws not to use utf-8-validate, use the
+[`WS_NO_UTF_8_VALIDATE`](./doc/ws.md#ws_no_utf_8_validate) environment variable.
+
+## API docs
+
+See [`/doc/ws.md`](./doc/ws.md) for Node.js-like documentation of ws classes and
+utility functions.
+
+## WebSocket compression
+
+ws supports the [permessage-deflate extension][permessage-deflate] which enables
+the client and server to negotiate a compression algorithm and its parameters,
+and then selectively apply it to the data payloads of each WebSocket message.
+
+The extension is disabled by default on the server and enabled by default on the
+client. It adds a significant overhead in terms of performance and memory
+consumption so we suggest to enable it only if it is really needed.
+
+Note that Node.js has a variety of issues with high-performance compression,
+where increased concurrency, especially on Linux, can lead to [catastrophic
+memory fragmentation][node-zlib-bug] and slow performance. If you intend to use
+permessage-deflate in production, it is worthwhile to set up a test
+representative of your workload and ensure Node.js/zlib will handle it with
+acceptable performance and memory usage.
+
+Tuning of permessage-deflate can be done via the options defined below. You can
+also use `zlibDeflateOptions` and `zlibInflateOptions`, which is passed directly
+into the creation of [raw deflate/inflate streams][node-zlib-deflaterawdocs].
+
+See [the docs][ws-server-options] for more options.
+
+```js
+import WebSocket, { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({
+  port: 8080,
+  perMessageDeflate: {
+    zlibDeflateOptions: {
+      // See zlib defaults.
+      chunkSize: 1024,
+      memLevel: 7,
+      level: 3
+    },
+    zlibInflateOptions: {
+      chunkSize: 10 * 1024
+    },
+    // Other options settable:
+    clientNoContextTakeover: true, // Defaults to negotiated value.
+    serverNoContextTakeover: true, // Defaults to negotiated value.
+    serverMaxWindowBits: 10, // Defaults to negotiated value.
+    // Below options specified as default values.
+    concurrencyLimit: 10, // Limits zlib concurrency for perf.
+    threshold: 1024 // Size (in bytes) below which messages
+    // should not be compressed if context takeover is disabled.
+  }
+});
+```
+
+The client will only use the extension if it is supported and enabled on the
+server. To always disable the extension on the client, set the
+`perMessageDeflate` option to `false`.
+
+```js
+import WebSocket from 'ws';
+
+const ws = new WebSocket('ws://www.host.com/path', {
+  perMessageDeflate: false
+});
+```
+
+## Usage examples
+
+### Sending and receiving text data
+
+```js
+import WebSocket from 'ws';
+
+const ws = new WebSocket('ws://www.host.com/path');
+
+ws.on('error', console.error);
+
+ws.on('open', function open() {
+  ws.send('something');
+});
+
+ws.on('message', function message(data) {
+  console.log('received: %s', data);
+});
+```
+
+### Sending binary data
+
+```js
+import WebSocket from 'ws';
+
+const ws = new WebSocket('ws://www.host.com/path');
+
+ws.on('error', console.error);
+
+ws.on('open', function open() {
+  const array = new Float32Array(5);
+
+  for (var i = 0; i < array.length; ++i) {
+    array[i] = i / 2;
+  }
+
+  ws.send(array);
+});
+```
+
+### Simple server
+
+```js
+import { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.on('error', console.error);
+
+  ws.on('message', function message(data) {
+    console.log('received: %s', data);
+  });
+
+  ws.send('something');
+});
+```
+
+### External HTTP/S server
+
+```js
+import { createServer } from 'https';
+import { readFileSync } from 'fs';
+import { WebSocketServer } from 'ws';
+
+const server = createServer({
+  cert: readFileSync('/path/to/cert.pem'),
+  key: readFileSync('/path/to/key.pem')
+});
+const wss = new WebSocketServer({ server });
+
+wss.on('connection', function connection(ws) {
+  ws.on('error', console.error);
+
+  ws.on('message', function message(data) {
+    console.log('received: %s', data);
+  });
+
+  ws.send('something');
+});
+
+server.listen(8080);
+```
+
+### Multiple servers sharing a single HTTP/S server
+
+```js
+import { createServer } from 'http';
+import { WebSocketServer } from 'ws';
+
+const server = createServer();
+const wss1 = new WebSocketServer({ noServer: true });
+const wss2 = new WebSocketServer({ noServer: true });
+
+wss1.on('connection', function connection(ws) {
+  ws.on('error', console.error);
+
+  // ...
+});
+
+wss2.on('connection', function connection(ws) {
+  ws.on('error', console.error);
+
+  // ...
+});
+
+server.on('upgrade', function upgrade(request, socket, head) {
+  const { pathname } = new URL(request.url, 'wss://base.url');
+
+  if (pathname === '/foo') {
+    wss1.handleUpgrade(request, socket, head, function done(ws) {
+      wss1.emit('connection', ws, request);
+    });
+  } else if (pathname === '/bar') {
+    wss2.handleUpgrade(request, socket, head, function done(ws) {
+      wss2.emit('connection', ws, request);
+    });
+  } else {
+    socket.destroy();
+  }
+});
+
+server.listen(8080);
+```
+
+### Client authentication
+
+```js
+import { createServer } from 'http';
+import { WebSocketServer } from 'ws';
+
+function onSocketError(err) {
+  console.error(err);
+}
+
+const server = createServer();
+const wss = new WebSocketServer({ noServer: true });
+
+wss.on('connection', function connection(ws, request, client) {
+  ws.on('error', console.error);
+
+  ws.on('message', function message(data) {
+    console.log(`Received message ${data} from user ${client}`);
+  });
+});
+
+server.on('upgrade', function upgrade(request, socket, head) {
+  socket.on('error', onSocketError);
+
+  // This function is not defined on purpose. Implement it with your own logic.
+  authenticate(request, function next(err, client) {
+    if (err || !client) {
+      socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+      socket.destroy();
+      return;
+    }
+
+    socket.removeListener('error', onSocketError);
+
+    wss.handleUpgrade(request, socket, head, function done(ws) {
+      wss.emit('connection', ws, request, client);
+    });
+  });
+});
+
+server.listen(8080);
+```
+
+Also see the provided [example][session-parse-example] using `express-session`.
+
+### Server broadcast
+
+A client WebSocket broadcasting to all connected WebSocket clients, including
+itself.
+
+```js
+import WebSocket, { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.on('error', console.error);
+
+  ws.on('message', function message(data, isBinary) {
+    wss.clients.forEach(function each(client) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data, { binary: isBinary });
+      }
+    });
+  });
+});
+```
+
+A client WebSocket broadcasting to every other connected WebSocket clients,
+excluding itself.
+
+```js
+import WebSocket, { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.on('error', console.error);
+
+  ws.on('message', function message(data, isBinary) {
+    wss.clients.forEach(function each(client) {
+      if (client !== ws && client.readyState === WebSocket.OPEN) {
+        client.send(data, { binary: isBinary });
+      }
+    });
+  });
+});
+```
+
+### Round-trip time
+
+```js
+import WebSocket from 'ws';
+
+const ws = new WebSocket('wss://websocket-echo.com/');
+
+ws.on('error', console.error);
+
+ws.on('open', function open() {
+  console.log('connected');
+  ws.send(Date.now());
+});
+
+ws.on('close', function close() {
+  console.log('disconnected');
+});
+
+ws.on('message', function message(data) {
+  console.log(`Round-trip time: ${Date.now() - data} ms`);
+
+  setTimeout(function timeout() {
+    ws.send(Date.now());
+  }, 500);
+});
+```
+
+### Use the Node.js streams API
+
+```js
+import WebSocket, { createWebSocketStream } from 'ws';
+
+const ws = new WebSocket('wss://websocket-echo.com/');
+
+const duplex = createWebSocketStream(ws, { encoding: 'utf8' });
+
+duplex.on('error', console.error);
+
+duplex.pipe(process.stdout);
+process.stdin.pipe(duplex);
+```
+
+### Other examples
+
+For a full example with a browser client communicating with a ws server, see the
+examples folder.
+
+Otherwise, see the test cases.
+
+## FAQ
+
+### How to get the IP address of the client?
+
+The remote IP address can be obtained from the raw socket.
+
+```js
+import { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws, req) {
+  const ip = req.socket.remoteAddress;
+
+  ws.on('error', console.error);
+});
+```
+
+When the server runs behind a proxy like NGINX, the de-facto standard is to use
+the `X-Forwarded-For` header.
+
+```js
+wss.on('connection', function connection(ws, req) {
+  const ip = req.headers['x-forwarded-for'].split(',')[0].trim();
+
+  ws.on('error', console.error);
+});
+```
+
+### How to detect and close broken connections?
+
+Sometimes, the link between the server and the client can be interrupted in a
+way that keeps both the server and the client unaware of the broken state of the
+connection (e.g. when pulling the cord).
+
+In these cases, ping messages can be used as a means to verify that the remote
+endpoint is still responsive.
+
+```js
+import { WebSocketServer } from 'ws';
+
+function heartbeat() {
+  this.isAlive = true;
+}
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.isAlive = true;
+  ws.on('error', console.error);
+  ws.on('pong', heartbeat);
+});
+
+const interval = setInterval(function ping() {
+  wss.clients.forEach(function each(ws) {
+    if (ws.isAlive === false) return ws.terminate();
+
+    ws.isAlive = false;
+    ws.ping();
+  });
+}, 30000);
+
+wss.on('close', function close() {
+  clearInterval(interval);
+});
+```
+
+Pong messages are automatically sent in response to ping messages as required by
+the spec.
+
+Just like the server example above, your clients might as well lose connection
+without knowing it. You might want to add a ping listener on your clients to
+prevent that. A simple implementation would be:
+
+```js
+import WebSocket from 'ws';
+
+function heartbeat() {
+  clearTimeout(this.pingTimeout);
+
+  // Use `WebSocket#terminate()`, which immediately destroys the connection,
+  // instead of `WebSocket#close()`, which waits for the close timer.
+  // Delay should be equal to the interval at which your server
+  // sends out pings plus a conservative assumption of the latency.
+  this.pingTimeout = setTimeout(() => {
+    this.terminate();
+  }, 30000 + 1000);
+}
+
+const client = new WebSocket('wss://websocket-echo.com/');
+
+client.on('error', console.error);
+client.on('open', heartbeat);
+client.on('ping', heartbeat);
+client.on('close', function clear() {
+  clearTimeout(this.pingTimeout);
+});
+```
+
+### How to connect via a proxy?
+
+Use a custom `http.Agent` implementation like [https-proxy-agent][] or
+[socks-proxy-agent][].
+
+## Changelog
+
+We're using the GitHub [releases][changelog] for changelog entries.
+
+## License
+
+[MIT](LICENSE)
+
+[`buffer.isutf8()`]: https://nodejs.org/api/buffer.html#bufferisutf8input
+[bufferutil]: https://github.com/websockets/bufferutil
+[changelog]: https://github.com/websockets/ws/releases
+[client-report]: http://websockets.github.io/ws/autobahn/clients/
+[https-proxy-agent]: https://github.com/TooTallNate/node-https-proxy-agent
+[node-zlib-bug]: https://github.com/nodejs/node/issues/8871
+[node-zlib-deflaterawdocs]:
+  https://nodejs.org/api/zlib.html#zlib_zlib_createdeflateraw_options
+[permessage-deflate]: https://tools.ietf.org/html/rfc7692
+[server-report]: http://websockets.github.io/ws/autobahn/servers/
+[session-parse-example]: ./examples/express-session-parse
+[socks-proxy-agent]: https://github.com/TooTallNate/node-socks-proxy-agent
+[utf-8-validate]: https://github.com/websockets/utf-8-validate
+[ws-server-options]: ./doc/ws.md#new-websocketserveroptions-callback

V3.1/build/hub-shim/node_modules/ws/browser.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = function () {
+  throw new Error(
+    'ws does not work in the browser. Browser clients must use the native ' +
+      'WebSocket object'
+  );
+};

V3.1/build/hub-shim/node_modules/ws/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const WebSocket = require('./lib/websocket');
+
+WebSocket.createWebSocketStream = require('./lib/stream');
+WebSocket.Server = require('./lib/websocket-server');
+WebSocket.Receiver = require('./lib/receiver');
+WebSocket.Sender = require('./lib/sender');
+
+WebSocket.WebSocket = WebSocket;
+WebSocket.WebSocketServer = WebSocket.Server;
+
+module.exports = WebSocket;

V3.1/build/hub-shim/node_modules/ws/lib/buffer-util.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const { EMPTY_BUFFER } = require('./constants');
+
+const FastBuffer = Buffer[Symbol.species];
+
+/**
+ * Merges an array of buffers into a new buffer.
+ *
+ * @param {Buffer[]} list The array of buffers to concat
+ * @param {Number} totalLength The total length of buffers in the list
+ * @return {Buffer} The resulting buffer
+ * @public
+ */
+function concat(list, totalLength) {
+  if (list.length === 0) return EMPTY_BUFFER;
+  if (list.length === 1) return list[0];
+
+  const target = Buffer.allocUnsafe(totalLength);
+  let offset = 0;
+
+  for (let i = 0; i < list.length; i++) {
+    const buf = list[i];
+    target.set(buf, offset);
+    offset += buf.length;
+  }
+
+  if (offset < totalLength) {
+    return new FastBuffer(target.buffer, target.byteOffset, offset);
+  }
+
+  return target;
+}
+
+/**
+ * Masks a buffer using the given mask.
+ *
+ * @param {Buffer} source The buffer to mask
+ * @param {Buffer} mask The mask to use
+ * @param {Buffer} output The buffer where to store the result
+ * @param {Number} offset The offset at which to start writing
+ * @param {Number} length The number of bytes to mask.
+ * @public
+ */
+function _mask(source, mask, output, offset, length) {
+  for (let i = 0; i < length; i++) {
+    output[offset + i] = source[i] ^ mask[i & 3];
+  }
+}
+
+/**
+ * Unmasks a buffer using the given mask.
+ *
+ * @param {Buffer} buffer The buffer to unmask
+ * @param {Buffer} mask The mask to use
+ * @public
+ */
+function _unmask(buffer, mask) {
+  for (let i = 0; i < buffer.length; i++) {
+    buffer[i] ^= mask[i & 3];
+  }
+}
+
+/**
+ * Converts a buffer to an `ArrayBuffer`.
+ *
+ * @param {Buffer} buf The buffer to convert
+ * @return {ArrayBuffer} Converted buffer
+ * @public
+ */
+function toArrayBuffer(buf) {
+  if (buf.length === buf.buffer.byteLength) {
+    return buf.buffer;
+  }
+
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
+}
+
+/**
+ * Converts `data` to a `Buffer`.
+ *
+ * @param {*} data The data to convert
+ * @return {Buffer} The buffer
+ * @throws {TypeError}
+ * @public
+ */
+function toBuffer(data) {
+  toBuffer.readOnly = true;
+
+  if (Buffer.isBuffer(data)) return data;
+
+  let buf;
+
+  if (data instanceof ArrayBuffer) {
+    buf = new FastBuffer(data);
+  } else if (ArrayBuffer.isView(data)) {
+    buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
+  } else {
+    buf = Buffer.from(data);
+    toBuffer.readOnly = false;
+  }
+
+  return buf;
+}
+
+module.exports = {
+  concat,
+  mask: _mask,
+  toArrayBuffer,
+  toBuffer,
+  unmask: _unmask
+};
+
+/* istanbul ignore else  */
+if (!process.env.WS_NO_BUFFER_UTIL) {
+  try {
+    const bufferUtil = require('bufferutil');
+
+    module.exports.mask = function (source, mask, output, offset, length) {
+      if (length < 48) _mask(source, mask, output, offset, length);
+      else bufferUtil.mask(source, mask, output, offset, length);
+    };
+
+    module.exports.unmask = function (buffer, mask) {
+      if (buffer.length < 32) _unmask(buffer, mask);
+      else bufferUtil.unmask(buffer, mask);
+    };
+  } catch (e) {
+    // Continue regardless of the error.
+  }
+}

V3.1/build/hub-shim/node_modules/ws/lib/constants.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const BINARY_TYPES = ['nodebuffer', 'arraybuffer', 'fragments'];
+const hasBlob = typeof Blob !== 'undefined';
+
+if (hasBlob) BINARY_TYPES.push('blob');
+
+module.exports = {
+  BINARY_TYPES,
+  CLOSE_TIMEOUT: 30000,
+  EMPTY_BUFFER: Buffer.alloc(0),
+  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
+  hasBlob,
+  kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),
+  kListener: Symbol('kListener'),
+  kStatusCode: Symbol('status-code'),
+  kWebSocket: Symbol('websocket'),
+  NOOP: () => {}
+};

V3.1/build/hub-shim/node_modules/ws/lib/event-target.js

@@ -0,0 +1,292 @@
+'use strict';
+
+const { kForOnEventAttribute, kListener } = require('./constants');
+
+const kCode = Symbol('kCode');
+const kData = Symbol('kData');
+const kError = Symbol('kError');
+const kMessage = Symbol('kMessage');
+const kReason = Symbol('kReason');
+const kTarget = Symbol('kTarget');
+const kType = Symbol('kType');
+const kWasClean = Symbol('kWasClean');
+
+/**
+ * Class representing an event.
+ */
+class Event {
+  /**
+   * Create a new `Event`.
+   *
+   * @param {String} type The name of the event
+   * @throws {TypeError} If the `type` argument is not specified
+   */
+  constructor(type) {
+    this[kTarget] = null;
+    this[kType] = type;
+  }
+
+  /**
+   * @type {*}
+   */
+  get target() {
+    return this[kTarget];
+  }
+
+  /**
+   * @type {String}
+   */
+  get type() {
+    return this[kType];
+  }
+}
+
+Object.defineProperty(Event.prototype, 'target', { enumerable: true });
+Object.defineProperty(Event.prototype, 'type', { enumerable: true });
+
+/**
+ * Class representing a close event.
+ *
+ * @extends Event
+ */
+class CloseEvent extends Event {
+  /**
+   * Create a new `CloseEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {Number} [options.code=0] The status code explaining why the
+   *     connection was closed
+   * @param {String} [options.reason=''] A human-readable string explaining why
+   *     the connection was closed
+   * @param {Boolean} [options.wasClean=false] Indicates whether or not the
+   *     connection was cleanly closed
+   */
+  constructor(type, options = {}) {
+    super(type);
+
+    this[kCode] = options.code === undefined ? 0 : options.code;
+    this[kReason] = options.reason === undefined ? '' : options.reason;
+    this[kWasClean] = options.wasClean === undefined ? false : options.wasClean;
+  }
+
+  /**
+   * @type {Number}
+   */
+  get code() {
+    return this[kCode];
+  }
+
+  /**
+   * @type {String}
+   */
+  get reason() {
+    return this[kReason];
+  }
+
+  /**
+   * @type {Boolean}
+   */
+  get wasClean() {
+    return this[kWasClean];
+  }
+}
+
+Object.defineProperty(CloseEvent.prototype, 'code', { enumerable: true });
+Object.defineProperty(CloseEvent.prototype, 'reason', { enumerable: true });
+Object.defineProperty(CloseEvent.prototype, 'wasClean', { enumerable: true });
+
+/**
+ * Class representing an error event.
+ *
+ * @extends Event
+ */
+class ErrorEvent extends Event {
+  /**
+   * Create a new `ErrorEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {*} [options.error=null] The error that generated this event
+   * @param {String} [options.message=''] The error message
+   */
+  constructor(type, options = {}) {
+    super(type);
+
+    this[kError] = options.error === undefined ? null : options.error;
+    this[kMessage] = options.message === undefined ? '' : options.message;
+  }
+
+  /**
+   * @type {*}
+   */
+  get error() {
+    return this[kError];
+  }
+
+  /**
+   * @type {String}
+   */
+  get message() {
+    return this[kMessage];
+  }
+}
+
+Object.defineProperty(ErrorEvent.prototype, 'error', { enumerable: true });
+Object.defineProperty(ErrorEvent.prototype, 'message', { enumerable: true });
+
+/**
+ * Class representing a message event.
+ *
+ * @extends Event
+ */
+class MessageEvent extends Event {
+  /**
+   * Create a new `MessageEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {*} [options.data=null] The message content
+   */
+  constructor(type, options = {}) {
+    super(type);
+
+    this[kData] = options.data === undefined ? null : options.data;
+  }
+
+  /**
+   * @type {*}
+   */
+  get data() {
+    return this[kData];
+  }
+}
+
+Object.defineProperty(MessageEvent.prototype, 'data', { enumerable: true });
+
+/**
+ * This provides methods for emulating the `EventTarget` interface. It's not
+ * meant to be used directly.
+ *
+ * @mixin
+ */
+const EventTarget = {
+  /**
+   * Register an event listener.
+   *
+   * @param {String} type A string representing the event type to listen for
+   * @param {(Function|Object)} handler The listener to add
+   * @param {Object} [options] An options object specifies characteristics about
+   *     the event listener
+   * @param {Boolean} [options.once=false] A `Boolean` indicating that the
+   *     listener should be invoked at most once after being added. If `true`,
+   *     the listener would be automatically removed when invoked.
+   * @public
+   */
+  addEventListener(type, handler, options = {}) {
+    for (const listener of this.listeners(type)) {
+      if (
+        !options[kForOnEventAttribute] &&
+        listener[kListener] === handler &&
+        !listener[kForOnEventAttribute]
+      ) {
+        return;
+      }
+    }
+
+    let wrapper;
+
+    if (type === 'message') {
+      wrapper = function onMessage(data, isBinary) {
+        const event = new MessageEvent('message', {
+          data: isBinary ? data : data.toString()
+        });
+
+        event[kTarget] = this;
+        callListener(handler, this, event);
+      };
+    } else if (type === 'close') {
+      wrapper = function onClose(code, message) {
+        const event = new CloseEvent('close', {
+          code,
+          reason: message.toString(),
+          wasClean: this._closeFrameReceived && this._closeFrameSent
+        });
+
+        event[kTarget] = this;
+        callListener(handler, this, event);
+      };
+    } else if (type === 'error') {
+      wrapper = function onError(error) {
+        const event = new ErrorEvent('error', {
+          error,
+          message: error.message
+        });
+
+        event[kTarget] = this;
+        callListener(handler, this, event);
+      };
+    } else if (type === 'open') {
+      wrapper = function onOpen() {
+        const event = new Event('open');
+
+        event[kTarget] = this;
+        callListener(handler, this, event);
+      };
+    } else {
+      return;
+    }
+
+    wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
+    wrapper[kListener] = handler;
+
+    if (options.once) {
+      this.once(type, wrapper);
+    } else {
+      this.on(type, wrapper);
+    }
+  },
+
+  /**
+   * Remove an event listener.
+   *
+   * @param {String} type A string representing the event type to remove
+   * @param {(Function|Object)} handler The listener to remove
+   * @public
+   */
+  removeEventListener(type, handler) {
+    for (const listener of this.listeners(type)) {
+      if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
+        this.removeListener(type, listener);
+        break;
+      }
+    }
+  }
+};
+
+module.exports = {
+  CloseEvent,
+  ErrorEvent,
+  Event,
+  EventTarget,
+  MessageEvent
+};
+
+/**
+ * Call an event listener
+ *
+ * @param {(Function|Object)} listener The listener to call
+ * @param {*} thisArg The value to use as `this`` when calling the listener
+ * @param {Event} event The event to pass to the listener
+ * @private
+ */
+function callListener(listener, thisArg, event) {
+  if (typeof listener === 'object' && listener.handleEvent) {
+    listener.handleEvent.call(listener, event);
+  } else {
+    listener.call(thisArg, event);
+  }
+}

V3.1/build/hub-shim/node_modules/ws/lib/extension.js

@@ -0,0 +1,203 @@
+'use strict';
+
+const { tokenChars } = require('./validation');
+
+/**
+ * Adds an offer to the map of extension offers or a parameter to the map of
+ * parameters.
+ *
+ * @param {Object} dest The map of extension offers or parameters
+ * @param {String} name The extension or parameter name
+ * @param {(Object|Boolean|String)} elem The extension parameters or the
+ *     parameter value
+ * @private
+ */
+function push(dest, name, elem) {
+  if (dest[name] === undefined) dest[name] = [elem];
+  else dest[name].push(elem);
+}
+
+/**
+ * Parses the `Sec-WebSocket-Extensions` header into an object.
+ *
+ * @param {String} header The field value of the header
+ * @return {Object} The parsed object
+ * @public
+ */
+function parse(header) {
+  const offers = Object.create(null);
+  let params = Object.create(null);
+  let mustUnescape = false;
+  let isEscaping = false;
+  let inQuotes = false;
+  let extensionName;
+  let paramName;
+  let start = -1;
+  let code = -1;
+  let end = -1;
+  let i = 0;
+
+  for (; i < header.length; i++) {
+    code = header.charCodeAt(i);
+
+    if (extensionName === undefined) {
+      if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (
+        i !== 0 &&
+        (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
+      ) {
+        if (end === -1 && start !== -1) end = i;
+      } else if (code === 0x3b /* ';' */ || code === 0x2c /* ',' */) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        const name = header.slice(start, end);
+        if (code === 0x2c) {
+          push(offers, name, params);
+          params = Object.create(null);
+        } else {
+          extensionName = name;
+        }
+
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    } else if (paramName === undefined) {
+      if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (code === 0x20 || code === 0x09) {
+        if (end === -1 && start !== -1) end = i;
+      } else if (code === 0x3b || code === 0x2c) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        push(params, header.slice(start, end), true);
+        if (code === 0x2c) {
+          push(offers, extensionName, params);
+          params = Object.create(null);
+          extensionName = undefined;
+        }
+
+        start = end = -1;
+      } else if (code === 0x3d /* '=' */ && start !== -1 && end === -1) {
+        paramName = header.slice(start, i);
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    } else {
+      //
+      // The value of a quoted-string after unescaping must conform to the
+      // token ABNF, so only token characters are valid.
+      // Ref: https://tools.ietf.org/html/rfc6455#section-9.1
+      //
+      if (isEscaping) {
+        if (tokenChars[code] !== 1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+        if (start === -1) start = i;
+        else if (!mustUnescape) mustUnescape = true;
+        isEscaping = false;
+      } else if (inQuotes) {
+        if (tokenChars[code] === 1) {
+          if (start === -1) start = i;
+        } else if (code === 0x22 /* '"' */ && start !== -1) {
+          inQuotes = false;
+          end = i;
+        } else if (code === 0x5c /* '\' */) {
+          isEscaping = true;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      } else if (code === 0x22 && header.charCodeAt(i - 1) === 0x3d) {
+        inQuotes = true;
+      } else if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (start !== -1 && (code === 0x20 || code === 0x09)) {
+        if (end === -1) end = i;
+      } else if (code === 0x3b || code === 0x2c) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        let value = header.slice(start, end);
+        if (mustUnescape) {
+          value = value.replace(/\\/g, '');
+          mustUnescape = false;
+        }
+        push(params, paramName, value);
+        if (code === 0x2c) {
+          push(offers, extensionName, params);
+          params = Object.create(null);
+          extensionName = undefined;
+        }
+
+        paramName = undefined;
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    }
+  }
+
+  if (start === -1 || inQuotes || code === 0x20 || code === 0x09) {
+    throw new SyntaxError('Unexpected end of input');
+  }
+
+  if (end === -1) end = i;
+  const token = header.slice(start, end);
+  if (extensionName === undefined) {
+    push(offers, token, params);
+  } else {
+    if (paramName === undefined) {
+      push(params, token, true);
+    } else if (mustUnescape) {
+      push(params, paramName, token.replace(/\\/g, ''));
+    } else {
+      push(params, paramName, token);
+    }
+    push(offers, extensionName, params);
+  }
+
+  return offers;
+}
+
+/**
+ * Builds the `Sec-WebSocket-Extensions` header field value.
+ *
+ * @param {Object} extensions The map of extensions and parameters to format
+ * @return {String} A string representing the given object
+ * @public
+ */
+function format(extensions) {
+  return Object.keys(extensions)
+    .map((extension) => {
+      let configurations = extensions[extension];
+      if (!Array.isArray(configurations)) configurations = [configurations];
+      return configurations
+        .map((params) => {
+          return [extension]
+            .concat(
+              Object.keys(params).map((k) => {
+                let values = params[k];
+                if (!Array.isArray(values)) values = [values];
+                return values
+                  .map((v) => (v === true ? k : `${k}=${v}`))
+                  .join('; ');
+              })
+            )
+            .join('; ');
+        })
+        .join(', ');
+    })
+    .join(', ');
+}
+
+module.exports = { format, parse };

V3.1/build/hub-shim/node_modules/ws/lib/limiter.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const kDone = Symbol('kDone');
+const kRun = Symbol('kRun');
+
+/**
+ * A very simple job queue with adjustable concurrency. Adapted from
+ * https://github.com/STRML/async-limiter
+ */
+class Limiter {
+  /**
+   * Creates a new `Limiter`.
+   *
+   * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
+   *     to run concurrently
+   */
+  constructor(concurrency) {
+    this[kDone] = () => {
+      this.pending--;
+      this[kRun]();
+    };
+    this.concurrency = concurrency || Infinity;
+    this.jobs = [];
+    this.pending = 0;
+  }
+
+  /**
+   * Adds a job to the queue.
+   *
+   * @param {Function} job The job to run
+   * @public
+   */
+  add(job) {
+    this.jobs.push(job);
+    this[kRun]();
+  }
+
+  /**
+   * Removes a job from the queue and runs it if possible.
+   *
+   * @private
+   */
+  [kRun]() {
+    if (this.pending === this.concurrency) return;
+
+    if (this.jobs.length) {
+      const job = this.jobs.shift();
+
+      this.pending++;
+      job(this[kDone]);
+    }
+  }
+}
+
+module.exports = Limiter;

V3.1/build/hub-shim/node_modules/ws/lib/permessage-deflate.js

@@ -0,0 +1,528 @@
+'use strict';
+
+const zlib = require('zlib');
+
+const bufferUtil = require('./buffer-util');
+const Limiter = require('./limiter');
+const { kStatusCode } = require('./constants');
+
+const FastBuffer = Buffer[Symbol.species];
+const TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
+const kPerMessageDeflate = Symbol('permessage-deflate');
+const kTotalLength = Symbol('total-length');
+const kCallback = Symbol('callback');
+const kBuffers = Symbol('buffers');
+const kError = Symbol('error');
+
+//
+// We limit zlib concurrency, which prevents severe memory fragmentation
+// as documented in https://github.com/nodejs/node/issues/8871#issuecomment-250915913
+// and https://github.com/websockets/ws/issues/1202
+//
+// Intentionally global; it's the global thread pool that's an issue.
+//
+let zlibLimiter;
+
+/**
+ * permessage-deflate implementation.
+ */
+class PerMessageDeflate {
+  /**
+   * Creates a PerMessageDeflate instance.
+   *
+   * @param {Object} [options] Configuration options
+   * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
+   *     for, or request, a custom client window size
+   * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
+   *     acknowledge disabling of client context takeover
+   * @param {Number} [options.concurrencyLimit=10] The number of concurrent
+   *     calls to zlib
+   * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
+   *     use of a custom server window size
+   * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
+   *     disabling of server context takeover
+   * @param {Number} [options.threshold=1024] Size (in bytes) below which
+   *     messages should not be compressed if context takeover is disabled
+   * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
+   *     deflate
+   * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
+   *     inflate
+   * @param {Boolean} [isServer=false] Create the instance in either server or
+   *     client mode
+   * @param {Number} [maxPayload=0] The maximum allowed message length
+   */
+  constructor(options, isServer, maxPayload) {
+    this._maxPayload = maxPayload | 0;
+    this._options = options || {};
+    this._threshold =
+      this._options.threshold !== undefined ? this._options.threshold : 1024;
+    this._isServer = !!isServer;
+    this._deflate = null;
+    this._inflate = null;
+
+    this.params = null;
+
+    if (!zlibLimiter) {
+      const concurrency =
+        this._options.concurrencyLimit !== undefined
+          ? this._options.concurrencyLimit
+          : 10;
+      zlibLimiter = new Limiter(concurrency);
+    }
+  }
+
+  /**
+   * @type {String}
+   */
+  static get extensionName() {
+    return 'permessage-deflate';
+  }
+
+  /**
+   * Create an extension negotiation offer.
+   *
+   * @return {Object} Extension parameters
+   * @public
+   */
+  offer() {
+    const params = {};
+
+    if (this._options.serverNoContextTakeover) {
+      params.server_no_context_takeover = true;
+    }
+    if (this._options.clientNoContextTakeover) {
+      params.client_no_context_takeover = true;
+    }
+    if (this._options.serverMaxWindowBits) {
+      params.server_max_window_bits = this._options.serverMaxWindowBits;
+    }
+    if (this._options.clientMaxWindowBits) {
+      params.client_max_window_bits = this._options.clientMaxWindowBits;
+    } else if (this._options.clientMaxWindowBits == null) {
+      params.client_max_window_bits = true;
+    }
+
+    return params;
+  }
+
+  /**
+   * Accept an extension negotiation offer/response.
+   *
+   * @param {Array} configurations The extension negotiation offers/reponse
+   * @return {Object} Accepted configuration
+   * @public
+   */
+  accept(configurations) {
+    configurations = this.normalizeParams(configurations);
+
+    this.params = this._isServer
+      ? this.acceptAsServer(configurations)
+      : this.acceptAsClient(configurations);
+
+    return this.params;
+  }
+
+  /**
+   * Releases all resources used by the extension.
+   *
+   * @public
+   */
+  cleanup() {
+    if (this._inflate) {
+      this._inflate.close();
+      this._inflate = null;
+    }
+
+    if (this._deflate) {
+      const callback = this._deflate[kCallback];
+
+      this._deflate.close();
+      this._deflate = null;
+
+      if (callback) {
+        callback(
+          new Error(
+            'The deflate stream was closed while data was being processed'
+          )
+        );
+      }
+    }
+  }
+
+  /**
+   *  Accept an extension negotiation offer.
+   *
+   * @param {Array} offers The extension negotiation offers
+   * @return {Object} Accepted configuration
+   * @private
+   */
+  acceptAsServer(offers) {
+    const opts = this._options;
+    const accepted = offers.find((params) => {
+      if (
+        (opts.serverNoContextTakeover === false &&
+          params.server_no_context_takeover) ||
+        (params.server_max_window_bits &&
+          (opts.serverMaxWindowBits === false ||
+            (typeof opts.serverMaxWindowBits === 'number' &&
+              opts.serverMaxWindowBits > params.server_max_window_bits))) ||
+        (typeof opts.clientMaxWindowBits === 'number' &&
+          !params.client_max_window_bits)
+      ) {
+        return false;
+      }
+
+      return true;
+    });
+
+    if (!accepted) {
+      throw new Error('None of the extension offers can be accepted');
+    }
+
+    if (opts.serverNoContextTakeover) {
+      accepted.server_no_context_takeover = true;
+    }
+    if (opts.clientNoContextTakeover) {
+      accepted.client_no_context_takeover = true;
+    }
+    if (typeof opts.serverMaxWindowBits === 'number') {
+      accepted.server_max_window_bits = opts.serverMaxWindowBits;
+    }
+    if (typeof opts.clientMaxWindowBits === 'number') {
+      accepted.client_max_window_bits = opts.clientMaxWindowBits;
+    } else if (
+      accepted.client_max_window_bits === true ||
+      opts.clientMaxWindowBits === false
+    ) {
+      delete accepted.client_max_window_bits;
+    }
+
+    return accepted;
+  }
+
+  /**
+   * Accept the extension negotiation response.
+   *
+   * @param {Array} response The extension negotiation response
+   * @return {Object} Accepted configuration
+   * @private
+   */
+  acceptAsClient(response) {
+    const params = response[0];
+
+    if (
+      this._options.clientNoContextTakeover === false &&
+      params.client_no_context_takeover
+    ) {
+      throw new Error('Unexpected parameter "client_no_context_takeover"');
+    }
+
+    if (!params.client_max_window_bits) {
+      if (typeof this._options.clientMaxWindowBits === 'number') {
+        params.client_max_window_bits = this._options.clientMaxWindowBits;
+      }
+    } else if (
+      this._options.clientMaxWindowBits === false ||
+      (typeof this._options.clientMaxWindowBits === 'number' &&
+        params.client_max_window_bits > this._options.clientMaxWindowBits)
+    ) {
+      throw new Error(
+        'Unexpected or invalid parameter "client_max_window_bits"'
+      );
+    }
+
+    return params;
+  }
+
+  /**
+   * Normalize parameters.
+   *
+   * @param {Array} configurations The extension negotiation offers/reponse
+   * @return {Array} The offers/response with normalized parameters
+   * @private
+   */
+  normalizeParams(configurations) {
+    configurations.forEach((params) => {
+      Object.keys(params).forEach((key) => {
+        let value = params[key];
+
+        if (value.length > 1) {
+          throw new Error(`Parameter "${key}" must have only a single value`);
+        }
+
+        value = value[0];
+
+        if (key === 'client_max_window_bits') {
+          if (value !== true) {
+            const num = +value;
+            if (!Number.isInteger(num) || num < 8 || num > 15) {
+              throw new TypeError(
+                `Invalid value for parameter "${key}": ${value}`
+              );
+            }
+            value = num;
+          } else if (!this._isServer) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+        } else if (key === 'server_max_window_bits') {
+          const num = +value;
+          if (!Number.isInteger(num) || num < 8 || num > 15) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+          value = num;
+        } else if (
+          key === 'client_no_context_takeover' ||
+          key === 'server_no_context_takeover'
+        ) {
+          if (value !== true) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+        } else {
+          throw new Error(`Unknown parameter "${key}"`);
+        }
+
+        params[key] = value;
+      });
+    });
+
+    return configurations;
+  }
+
+  /**
+   * Decompress data. Concurrency limited.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @public
+   */
+  decompress(data, fin, callback) {
+    zlibLimiter.add((done) => {
+      this._decompress(data, fin, (err, result) => {
+        done();
+        callback(err, result);
+      });
+    });
+  }
+
+  /**
+   * Compress data. Concurrency limited.
+   *
+   * @param {(Buffer|String)} data Data to compress
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @public
+   */
+  compress(data, fin, callback) {
+    zlibLimiter.add((done) => {
+      this._compress(data, fin, (err, result) => {
+        done();
+        callback(err, result);
+      });
+    });
+  }
+
+  /**
+   * Decompress data.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @private
+   */
+  _decompress(data, fin, callback) {
+    const endpoint = this._isServer ? 'client' : 'server';
+
+    if (!this._inflate) {
+      const key = `${endpoint}_max_window_bits`;
+      const windowBits =
+        typeof this.params[key] !== 'number'
+          ? zlib.Z_DEFAULT_WINDOWBITS
+          : this.params[key];
+
+      this._inflate = zlib.createInflateRaw({
+        ...this._options.zlibInflateOptions,
+        windowBits
+      });
+      this._inflate[kPerMessageDeflate] = this;
+      this._inflate[kTotalLength] = 0;
+      this._inflate[kBuffers] = [];
+      this._inflate.on('error', inflateOnError);
+      this._inflate.on('data', inflateOnData);
+    }
+
+    this._inflate[kCallback] = callback;
+
+    this._inflate.write(data);
+    if (fin) this._inflate.write(TRAILER);
+
+    this._inflate.flush(() => {
+      const err = this._inflate[kError];
+
+      if (err) {
+        this._inflate.close();
+        this._inflate = null;
+        callback(err);
+        return;
+      }
+
+      const data = bufferUtil.concat(
+        this._inflate[kBuffers],
+        this._inflate[kTotalLength]
+      );
+
+      if (this._inflate._readableState.endEmitted) {
+        this._inflate.close();
+        this._inflate = null;
+      } else {
+        this._inflate[kTotalLength] = 0;
+        this._inflate[kBuffers] = [];
+
+        if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+          this._inflate.reset();
+        }
+      }
+
+      callback(null, data);
+    });
+  }
+
+  /**
+   * Compress data.
+   *
+   * @param {(Buffer|String)} data Data to compress
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @private
+   */
+  _compress(data, fin, callback) {
+    const endpoint = this._isServer ? 'server' : 'client';
+
+    if (!this._deflate) {
+      const key = `${endpoint}_max_window_bits`;
+      const windowBits =
+        typeof this.params[key] !== 'number'
+          ? zlib.Z_DEFAULT_WINDOWBITS
+          : this.params[key];
+
+      this._deflate = zlib.createDeflateRaw({
+        ...this._options.zlibDeflateOptions,
+        windowBits
+      });
+
+      this._deflate[kTotalLength] = 0;
+      this._deflate[kBuffers] = [];
+
+      this._deflate.on('data', deflateOnData);
+    }
+
+    this._deflate[kCallback] = callback;
+
+    this._deflate.write(data);
+    this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
+      if (!this._deflate) {
+        //
+        // The deflate stream was closed while data was being processed.
+        //
+        return;
+      }
+
+      let data = bufferUtil.concat(
+        this._deflate[kBuffers],
+        this._deflate[kTotalLength]
+      );
+
+      if (fin) {
+        data = new FastBuffer(data.buffer, data.byteOffset, data.length - 4);
+      }
+
+      //
+      // Ensure that the callback will not be called again in
+      // `PerMessageDeflate#cleanup()`.
+      //
+      this._deflate[kCallback] = null;
+
+      this._deflate[kTotalLength] = 0;
+      this._deflate[kBuffers] = [];
+
+      if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+        this._deflate.reset();
+      }
+
+      callback(null, data);
+    });
+  }
+}
+
+module.exports = PerMessageDeflate;
+
+/**
+ * The listener of the `zlib.DeflateRaw` stream `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function deflateOnData(chunk) {
+  this[kBuffers].push(chunk);
+  this[kTotalLength] += chunk.length;
+}
+
+/**
+ * The listener of the `zlib.InflateRaw` stream `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function inflateOnData(chunk) {
+  this[kTotalLength] += chunk.length;
+
+  if (
+    this[kPerMessageDeflate]._maxPayload < 1 ||
+    this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload
+  ) {
+    this[kBuffers].push(chunk);
+    return;
+  }
+
+  this[kError] = new RangeError('Max payload size exceeded');
+  this[kError].code = 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH';
+  this[kError][kStatusCode] = 1009;
+  this.removeListener('data', inflateOnData);
+
+  //
+  // The choice to employ `zlib.reset()` over `zlib.close()` is dictated by the
+  // fact that in Node.js versions prior to 13.10.0, the callback for
+  // `zlib.flush()` is not called if `zlib.close()` is used. Utilizing
+  // `zlib.reset()` ensures that either the callback is invoked or an error is
+  // emitted.
+  //
+  this.reset();
+}
+
+/**
+ * The listener of the `zlib.InflateRaw` stream `'error'` event.
+ *
+ * @param {Error} err The emitted error
+ * @private
+ */
+function inflateOnError(err) {
+  //
+  // There is no need to call `Zlib#close()` as the handle is automatically
+  // closed when an error is emitted.
+  //
+  this[kPerMessageDeflate]._inflate = null;
+
+  if (this[kError]) {
+    this[kCallback](this[kError]);
+    return;
+  }
+
+  err[kStatusCode] = 1007;
+  this[kCallback](err);
+}

V3.1/build/hub-shim/node_modules/ws/lib/receiver.js

@@ -0,0 +1,706 @@
+'use strict';
+
+const { Writable } = require('stream');
+
+const PerMessageDeflate = require('./permessage-deflate');
+const {
+  BINARY_TYPES,
+  EMPTY_BUFFER,
+  kStatusCode,
+  kWebSocket
+} = require('./constants');
+const { concat, toArrayBuffer, unmask } = require('./buffer-util');
+const { isValidStatusCode, isValidUTF8 } = require('./validation');
+
+const FastBuffer = Buffer[Symbol.species];
+
+const GET_INFO = 0;
+const GET_PAYLOAD_LENGTH_16 = 1;
+const GET_PAYLOAD_LENGTH_64 = 2;
+const GET_MASK = 3;
+const GET_DATA = 4;
+const INFLATING = 5;
+const DEFER_EVENT = 6;
+
+/**
+ * HyBi Receiver implementation.
+ *
+ * @extends Writable
+ */
+class Receiver extends Writable {
+  /**
+   * Creates a Receiver instance.
+   *
+   * @param {Object} [options] Options object
+   * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
+   *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+   *     multiple times in the same tick
+   * @param {String} [options.binaryType=nodebuffer] The type for binary data
+   * @param {Object} [options.extensions] An object containing the negotiated
+   *     extensions
+   * @param {Boolean} [options.isServer=false] Specifies whether to operate in
+   *     client or server mode
+   * @param {Number} [options.maxPayload=0] The maximum allowed message length
+   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+   *     not to skip UTF-8 validation for text and close messages
+   */
+  constructor(options = {}) {
+    super();
+
+    this._allowSynchronousEvents =
+      options.allowSynchronousEvents !== undefined
+        ? options.allowSynchronousEvents
+        : true;
+    this._binaryType = options.binaryType || BINARY_TYPES[0];
+    this._extensions = options.extensions || {};
+    this._isServer = !!options.isServer;
+    this._maxPayload = options.maxPayload | 0;
+    this._skipUTF8Validation = !!options.skipUTF8Validation;
+    this[kWebSocket] = undefined;
+
+    this._bufferedBytes = 0;
+    this._buffers = [];
+
+    this._compressed = false;
+    this._payloadLength = 0;
+    this._mask = undefined;
+    this._fragmented = 0;
+    this._masked = false;
+    this._fin = false;
+    this._opcode = 0;
+
+    this._totalPayloadLength = 0;
+    this._messageLength = 0;
+    this._fragments = [];
+
+    this._errored = false;
+    this._loop = false;
+    this._state = GET_INFO;
+  }
+
+  /**
+   * Implements `Writable.prototype._write()`.
+   *
+   * @param {Buffer} chunk The chunk of data to write
+   * @param {String} encoding The character encoding of `chunk`
+   * @param {Function} cb Callback
+   * @private
+   */
+  _write(chunk, encoding, cb) {
+    if (this._opcode === 0x08 && this._state == GET_INFO) return cb();
+
+    this._bufferedBytes += chunk.length;
+    this._buffers.push(chunk);
+    this.startLoop(cb);
+  }
+
+  /**
+   * Consumes `n` bytes from the buffered data.
+   *
+   * @param {Number} n The number of bytes to consume
+   * @return {Buffer} The consumed bytes
+   * @private
+   */
+  consume(n) {
+    this._bufferedBytes -= n;
+
+    if (n === this._buffers[0].length) return this._buffers.shift();
+
+    if (n < this._buffers[0].length) {
+      const buf = this._buffers[0];
+      this._buffers[0] = new FastBuffer(
+        buf.buffer,
+        buf.byteOffset + n,
+        buf.length - n
+      );
+
+      return new FastBuffer(buf.buffer, buf.byteOffset, n);
+    }
+
+    const dst = Buffer.allocUnsafe(n);
+
+    do {
+      const buf = this._buffers[0];
+      const offset = dst.length - n;
+
+      if (n >= buf.length) {
+        dst.set(this._buffers.shift(), offset);
+      } else {
+        dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
+        this._buffers[0] = new FastBuffer(
+          buf.buffer,
+          buf.byteOffset + n,
+          buf.length - n
+        );
+      }
+
+      n -= buf.length;
+    } while (n > 0);
+
+    return dst;
+  }
+
+  /**
+   * Starts the parsing loop.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  startLoop(cb) {
+    this._loop = true;
+
+    do {
+      switch (this._state) {
+        case GET_INFO:
+          this.getInfo(cb);
+          break;
+        case GET_PAYLOAD_LENGTH_16:
+          this.getPayloadLength16(cb);
+          break;
+        case GET_PAYLOAD_LENGTH_64:
+          this.getPayloadLength64(cb);
+          break;
+        case GET_MASK:
+          this.getMask();
+          break;
+        case GET_DATA:
+          this.getData(cb);
+          break;
+        case INFLATING:
+        case DEFER_EVENT:
+          this._loop = false;
+          return;
+      }
+    } while (this._loop);
+
+    if (!this._errored) cb();
+  }
+
+  /**
+   * Reads the first two bytes of a frame.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  getInfo(cb) {
+    if (this._bufferedBytes < 2) {
+      this._loop = false;
+      return;
+    }
+
+    const buf = this.consume(2);
+
+    if ((buf[0] & 0x30) !== 0x00) {
+      const error = this.createError(
+        RangeError,
+        'RSV2 and RSV3 must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_RSV_2_3'
+      );
+
+      cb(error);
+      return;
+    }
+
+    const compressed = (buf[0] & 0x40) === 0x40;
+
+    if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
+      const error = this.createError(
+        RangeError,
+        'RSV1 must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_RSV_1'
+      );
+
+      cb(error);
+      return;
+    }
+
+    this._fin = (buf[0] & 0x80) === 0x80;
+    this._opcode = buf[0] & 0x0f;
+    this._payloadLength = buf[1] & 0x7f;
+
+    if (this._opcode === 0x00) {
+      if (compressed) {
+        const error = this.createError(
+          RangeError,
+          'RSV1 must be clear',
+          true,
+          1002,
+          'WS_ERR_UNEXPECTED_RSV_1'
+        );
+
+        cb(error);
+        return;
+      }
+
+      if (!this._fragmented) {
+        const error = this.createError(
+          RangeError,
+          'invalid opcode 0',
+          true,
+          1002,
+          'WS_ERR_INVALID_OPCODE'
+        );
+
+        cb(error);
+        return;
+      }
+
+      this._opcode = this._fragmented;
+    } else if (this._opcode === 0x01 || this._opcode === 0x02) {
+      if (this._fragmented) {
+        const error = this.createError(
+          RangeError,
+          `invalid opcode ${this._opcode}`,
+          true,
+          1002,
+          'WS_ERR_INVALID_OPCODE'
+        );
+
+        cb(error);
+        return;
+      }
+
+      this._compressed = compressed;
+    } else if (this._opcode > 0x07 && this._opcode < 0x0b) {
+      if (!this._fin) {
+        const error = this.createError(
+          RangeError,
+          'FIN must be set',
+          true,
+          1002,
+          'WS_ERR_EXPECTED_FIN'
+        );
+
+        cb(error);
+        return;
+      }
+
+      if (compressed) {
+        const error = this.createError(
+          RangeError,
+          'RSV1 must be clear',
+          true,
+          1002,
+          'WS_ERR_UNEXPECTED_RSV_1'
+        );
+
+        cb(error);
+        return;
+      }
+
+      if (
+        this._payloadLength > 0x7d ||
+        (this._opcode === 0x08 && this._payloadLength === 1)
+      ) {
+        const error = this.createError(
+          RangeError,
+          `invalid payload length ${this._payloadLength}`,
+          true,
+          1002,
+          'WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH'
+        );
+
+        cb(error);
+        return;
+      }
+    } else {
+      const error = this.createError(
+        RangeError,
+        `invalid opcode ${this._opcode}`,
+        true,
+        1002,
+        'WS_ERR_INVALID_OPCODE'
+      );
+
+      cb(error);
+      return;
+    }
+
+    if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
+    this._masked = (buf[1] & 0x80) === 0x80;
+
+    if (this._isServer) {
+      if (!this._masked) {
+        const error = this.createError(
+          RangeError,
+          'MASK must be set',
+          true,
+          1002,
+          'WS_ERR_EXPECTED_MASK'
+        );
+
+        cb(error);
+        return;
+      }
+    } else if (this._masked) {
+      const error = this.createError(
+        RangeError,
+        'MASK must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_MASK'
+      );
+
+      cb(error);
+      return;
+    }
+
+    if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
+    else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
+    else this.haveLength(cb);
+  }
+
+  /**
+   * Gets extended payload length (7+16).
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  getPayloadLength16(cb) {
+    if (this._bufferedBytes < 2) {
+      this._loop = false;
+      return;
+    }
+
+    this._payloadLength = this.consume(2).readUInt16BE(0);
+    this.haveLength(cb);
+  }
+
+  /**
+   * Gets extended payload length (7+64).
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  getPayloadLength64(cb) {
+    if (this._bufferedBytes < 8) {
+      this._loop = false;
+      return;
+    }
+
+    const buf = this.consume(8);
+    const num = buf.readUInt32BE(0);
+
+    //
+    // The maximum safe integer in JavaScript is 2^53 - 1. An error is returned
+    // if payload length is greater than this number.
+    //
+    if (num > Math.pow(2, 53 - 32) - 1) {
+      const error = this.createError(
+        RangeError,
+        'Unsupported WebSocket frame: payload length > 2^53 - 1',
+        false,
+        1009,
+        'WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH'
+      );
+
+      cb(error);
+      return;
+    }
+
+    this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
+    this.haveLength(cb);
+  }
+
+  /**
+   * Payload length has been read.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  haveLength(cb) {
+    if (this._payloadLength && this._opcode < 0x08) {
+      this._totalPayloadLength += this._payloadLength;
+      if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
+        const error = this.createError(
+          RangeError,
+          'Max payload size exceeded',
+          false,
+          1009,
+          'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
+        );
+
+        cb(error);
+        return;
+      }
+    }
+
+    if (this._masked) this._state = GET_MASK;
+    else this._state = GET_DATA;
+  }
+
+  /**
+   * Reads mask bytes.
+   *
+   * @private
+   */
+  getMask() {
+    if (this._bufferedBytes < 4) {
+      this._loop = false;
+      return;
+    }
+
+    this._mask = this.consume(4);
+    this._state = GET_DATA;
+  }
+
+  /**
+   * Reads data bytes.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  getData(cb) {
+    let data = EMPTY_BUFFER;
+
+    if (this._payloadLength) {
+      if (this._bufferedBytes < this._payloadLength) {
+        this._loop = false;
+        return;
+      }
+
+      data = this.consume(this._payloadLength);
+
+      if (
+        this._masked &&
+        (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0
+      ) {
+        unmask(data, this._mask);
+      }
+    }
+
+    if (this._opcode > 0x07) {
+      this.controlMessage(data, cb);
+      return;
+    }
+
+    if (this._compressed) {
+      this._state = INFLATING;
+      this.decompress(data, cb);
+      return;
+    }
+
+    if (data.length) {
+      //
+      // This message is not compressed so its length is the sum of the payload
+      // length of all fragments.
+      //
+      this._messageLength = this._totalPayloadLength;
+      this._fragments.push(data);
+    }
+
+    this.dataMessage(cb);
+  }
+
+  /**
+   * Decompresses data.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Function} cb Callback
+   * @private
+   */
+  decompress(data, cb) {
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+
+    perMessageDeflate.decompress(data, this._fin, (err, buf) => {
+      if (err) return cb(err);
+
+      if (buf.length) {
+        this._messageLength += buf.length;
+        if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
+          const error = this.createError(
+            RangeError,
+            'Max payload size exceeded',
+            false,
+            1009,
+            'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
+          );
+
+          cb(error);
+          return;
+        }
+
+        this._fragments.push(buf);
+      }
+
+      this.dataMessage(cb);
+      if (this._state === GET_INFO) this.startLoop(cb);
+    });
+  }
+
+  /**
+   * Handles a data message.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  dataMessage(cb) {
+    if (!this._fin) {
+      this._state = GET_INFO;
+      return;
+    }
+
+    const messageLength = this._messageLength;
+    const fragments = this._fragments;
+
+    this._totalPayloadLength = 0;
+    this._messageLength = 0;
+    this._fragmented = 0;
+    this._fragments = [];
+
+    if (this._opcode === 2) {
+      let data;
+
+      if (this._binaryType === 'nodebuffer') {
+        data = concat(fragments, messageLength);
+      } else if (this._binaryType === 'arraybuffer') {
+        data = toArrayBuffer(concat(fragments, messageLength));
+      } else if (this._binaryType === 'blob') {
+        data = new Blob(fragments);
+      } else {
+        data = fragments;
+      }
+
+      if (this._allowSynchronousEvents) {
+        this.emit('message', data, true);
+        this._state = GET_INFO;
+      } else {
+        this._state = DEFER_EVENT;
+        setImmediate(() => {
+          this.emit('message', data, true);
+          this._state = GET_INFO;
+          this.startLoop(cb);
+        });
+      }
+    } else {
+      const buf = concat(fragments, messageLength);
+
+      if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+        const error = this.createError(
+          Error,
+          'invalid UTF-8 sequence',
+          true,
+          1007,
+          'WS_ERR_INVALID_UTF8'
+        );
+
+        cb(error);
+        return;
+      }
+
+      if (this._state === INFLATING || this._allowSynchronousEvents) {
+        this.emit('message', buf, false);
+        this._state = GET_INFO;
+      } else {
+        this._state = DEFER_EVENT;
+        setImmediate(() => {
+          this.emit('message', buf, false);
+          this._state = GET_INFO;
+          this.startLoop(cb);
+        });
+      }
+    }
+  }
+
+  /**
+   * Handles a control message.
+   *
+   * @param {Buffer} data Data to handle
+   * @return {(Error|RangeError|undefined)} A possible error
+   * @private
+   */
+  controlMessage(data, cb) {
+    if (this._opcode === 0x08) {
+      if (data.length === 0) {
+        this._loop = false;
+        this.emit('conclude', 1005, EMPTY_BUFFER);
+        this.end();
+      } else {
+        const code = data.readUInt16BE(0);
+
+        if (!isValidStatusCode(code)) {
+          const error = this.createError(
+            RangeError,
+            `invalid status code ${code}`,
+            true,
+            1002,
+            'WS_ERR_INVALID_CLOSE_CODE'
+          );
+
+          cb(error);
+          return;
+        }
+
+        const buf = new FastBuffer(
+          data.buffer,
+          data.byteOffset + 2,
+          data.length - 2
+        );
+
+        if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+          const error = this.createError(
+            Error,
+            'invalid UTF-8 sequence',
+            true,
+            1007,
+            'WS_ERR_INVALID_UTF8'
+          );
+
+          cb(error);
+          return;
+        }
+
+        this._loop = false;
+        this.emit('conclude', code, buf);
+        this.end();
+      }
+
+      this._state = GET_INFO;
+      return;
+    }
+
+    if (this._allowSynchronousEvents) {
+      this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
+      this._state = GET_INFO;
+    } else {
+      this._state = DEFER_EVENT;
+      setImmediate(() => {
+        this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
+        this._state = GET_INFO;
+        this.startLoop(cb);
+      });
+    }
+  }
+
+  /**
+   * Builds an error object.
+   *
+   * @param {function(new: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
+   */
+  createError(ErrorCtor, message, prefix, statusCode, errorCode) {
+    this._loop = false;
+    this._errored = true;
+
+    const err = new ErrorCtor(
+      prefix ? `Invalid WebSocket frame: ${message}` : message
+    );
+
+    Error.captureStackTrace(err, this.createError);
+    err.code = errorCode;
+    err[kStatusCode] = statusCode;
+    return err;
+  }
+}
+
+module.exports = Receiver;

V3.1/build/hub-shim/node_modules/ws/lib/sender.js

@@ -0,0 +1,602 @@
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex" }] */
+
+'use strict';
+
+const { Duplex } = require('stream');
+const { randomFillSync } = require('crypto');
+
+const PerMessageDeflate = require('./permessage-deflate');
+const { EMPTY_BUFFER, kWebSocket, NOOP } = require('./constants');
+const { isBlob, isValidStatusCode } = require('./validation');
+const { mask: applyMask, toBuffer } = require('./buffer-util');
+
+const kByteLength = Symbol('kByteLength');
+const maskBuffer = Buffer.alloc(4);
+const RANDOM_POOL_SIZE = 8 * 1024;
+let randomPool;
+let randomPoolPointer = RANDOM_POOL_SIZE;
+
+const DEFAULT = 0;
+const DEFLATING = 1;
+const GET_BLOB_DATA = 2;
+
+/**
+ * HyBi Sender implementation.
+ */
+class Sender {
+  /**
+   * Creates a Sender instance.
+   *
+   * @param {Duplex} socket The connection socket
+   * @param {Object} [extensions] An object containing the negotiated extensions
+   * @param {Function} [generateMask] The function used to generate the masking
+   *     key
+   */
+  constructor(socket, extensions, generateMask) {
+    this._extensions = extensions || {};
+
+    if (generateMask) {
+      this._generateMask = generateMask;
+      this._maskBuffer = Buffer.alloc(4);
+    }
+
+    this._socket = socket;
+
+    this._firstFragment = true;
+    this._compress = false;
+
+    this._bufferedBytes = 0;
+    this._queue = [];
+    this._state = DEFAULT;
+    this.onerror = NOOP;
+    this[kWebSocket] = undefined;
+  }
+
+  /**
+   * Frames a piece of data according to the HyBi WebSocket protocol.
+   *
+   * @param {(Buffer|String)} data The data to frame
+   * @param {Object} options Options object
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+   *     key
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @return {(Buffer|String)[]} The framed data
+   * @public
+   */
+  static frame(data, options) {
+    let mask;
+    let merge = false;
+    let offset = 2;
+    let skipMasking = false;
+
+    if (options.mask) {
+      mask = options.maskBuffer || maskBuffer;
+
+      if (options.generateMask) {
+        options.generateMask(mask);
+      } else {
+        if (randomPoolPointer === RANDOM_POOL_SIZE) {
+          /* istanbul ignore else  */
+          if (randomPool === undefined) {
+            //
+            // This is lazily initialized because server-sent frames must not
+            // be masked so it may never be used.
+            //
+            randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
+          }
+
+          randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
+          randomPoolPointer = 0;
+        }
+
+        mask[0] = randomPool[randomPoolPointer++];
+        mask[1] = randomPool[randomPoolPointer++];
+        mask[2] = randomPool[randomPoolPointer++];
+        mask[3] = randomPool[randomPoolPointer++];
+      }
+
+      skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
+      offset = 6;
+    }
+
+    let dataLength;
+
+    if (typeof data === 'string') {
+      if (
+        (!options.mask || skipMasking) &&
+        options[kByteLength] !== undefined
+      ) {
+        dataLength = options[kByteLength];
+      } else {
+        data = Buffer.from(data);
+        dataLength = data.length;
+      }
+    } else {
+      dataLength = data.length;
+      merge = options.mask && options.readOnly && !skipMasking;
+    }
+
+    let payloadLength = dataLength;
+
+    if (dataLength >= 65536) {
+      offset += 8;
+      payloadLength = 127;
+    } else if (dataLength > 125) {
+      offset += 2;
+      payloadLength = 126;
+    }
+
+    const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);
+
+    target[0] = options.fin ? options.opcode | 0x80 : options.opcode;
+    if (options.rsv1) target[0] |= 0x40;
+
+    target[1] = payloadLength;
+
+    if (payloadLength === 126) {
+      target.writeUInt16BE(dataLength, 2);
+    } else if (payloadLength === 127) {
+      target[2] = target[3] = 0;
+      target.writeUIntBE(dataLength, 4, 6);
+    }
+
+    if (!options.mask) return [target, data];
+
+    target[1] |= 0x80;
+    target[offset - 4] = mask[0];
+    target[offset - 3] = mask[1];
+    target[offset - 2] = mask[2];
+    target[offset - 1] = mask[3];
+
+    if (skipMasking) return [target, data];
+
+    if (merge) {
+      applyMask(data, mask, target, offset, dataLength);
+      return [target];
+    }
+
+    applyMask(data, mask, data, 0, dataLength);
+    return [target, data];
+  }
+
+  /**
+   * Sends a close message to the other peer.
+   *
+   * @param {Number} [code] The status code component of the body
+   * @param {(String|Buffer)} [data] The message component of the body
+   * @param {Boolean} [mask=false] Specifies whether or not to mask the message
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  close(code, data, mask, cb) {
+    let buf;
+
+    if (code === undefined) {
+      buf = EMPTY_BUFFER;
+    } else if (typeof code !== 'number' || !isValidStatusCode(code)) {
+      throw new TypeError('First argument must be a valid error code number');
+    } else if (data === undefined || !data.length) {
+      buf = Buffer.allocUnsafe(2);
+      buf.writeUInt16BE(code, 0);
+    } else {
+      const length = Buffer.byteLength(data);
+
+      if (length > 123) {
+        throw new RangeError('The message must not be greater than 123 bytes');
+      }
+
+      buf = Buffer.allocUnsafe(2 + length);
+      buf.writeUInt16BE(code, 0);
+
+      if (typeof data === 'string') {
+        buf.write(data, 2);
+      } else {
+        buf.set(data, 2);
+      }
+    }
+
+    const options = {
+      [kByteLength]: buf.length,
+      fin: true,
+      generateMask: this._generateMask,
+      mask,
+      maskBuffer: this._maskBuffer,
+      opcode: 0x08,
+      readOnly: false,
+      rsv1: false
+    };
+
+    if (this._state !== DEFAULT) {
+      this.enqueue([this.dispatch, buf, false, options, cb]);
+    } else {
+      this.sendFrame(Sender.frame(buf, options), cb);
+    }
+  }
+
+  /**
+   * Sends a ping message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  ping(data, mask, cb) {
+    let byteLength;
+    let readOnly;
+
+    if (typeof data === 'string') {
+      byteLength = Buffer.byteLength(data);
+      readOnly = false;
+    } else if (isBlob(data)) {
+      byteLength = data.size;
+      readOnly = false;
+    } else {
+      data = toBuffer(data);
+      byteLength = data.length;
+      readOnly = toBuffer.readOnly;
+    }
+
+    if (byteLength > 125) {
+      throw new RangeError('The data size must not be greater than 125 bytes');
+    }
+
+    const options = {
+      [kByteLength]: byteLength,
+      fin: true,
+      generateMask: this._generateMask,
+      mask,
+      maskBuffer: this._maskBuffer,
+      opcode: 0x09,
+      readOnly,
+      rsv1: false
+    };
+
+    if (isBlob(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, false, options, cb]);
+      } else {
+        this.getBlobData(data, false, options, cb);
+      }
+    } else if (this._state !== DEFAULT) {
+      this.enqueue([this.dispatch, data, false, options, cb]);
+    } else {
+      this.sendFrame(Sender.frame(data, options), cb);
+    }
+  }
+
+  /**
+   * Sends a pong message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  pong(data, mask, cb) {
+    let byteLength;
+    let readOnly;
+
+    if (typeof data === 'string') {
+      byteLength = Buffer.byteLength(data);
+      readOnly = false;
+    } else if (isBlob(data)) {
+      byteLength = data.size;
+      readOnly = false;
+    } else {
+      data = toBuffer(data);
+      byteLength = data.length;
+      readOnly = toBuffer.readOnly;
+    }
+
+    if (byteLength > 125) {
+      throw new RangeError('The data size must not be greater than 125 bytes');
+    }
+
+    const options = {
+      [kByteLength]: byteLength,
+      fin: true,
+      generateMask: this._generateMask,
+      mask,
+      maskBuffer: this._maskBuffer,
+      opcode: 0x0a,
+      readOnly,
+      rsv1: false
+    };
+
+    if (isBlob(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, false, options, cb]);
+      } else {
+        this.getBlobData(data, false, options, cb);
+      }
+    } else if (this._state !== DEFAULT) {
+      this.enqueue([this.dispatch, data, false, options, cb]);
+    } else {
+      this.sendFrame(Sender.frame(data, options), cb);
+    }
+  }
+
+  /**
+   * Sends a data message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Object} options Options object
+   * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
+   *     or text
+   * @param {Boolean} [options.compress=false] Specifies whether or not to
+   *     compress `data`
+   * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
+   *     last one
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  send(data, options, cb) {
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+    let opcode = options.binary ? 2 : 1;
+    let rsv1 = options.compress;
+
+    let byteLength;
+    let readOnly;
+
+    if (typeof data === 'string') {
+      byteLength = Buffer.byteLength(data);
+      readOnly = false;
+    } else if (isBlob(data)) {
+      byteLength = data.size;
+      readOnly = false;
+    } else {
+      data = toBuffer(data);
+      byteLength = data.length;
+      readOnly = toBuffer.readOnly;
+    }
+
+    if (this._firstFragment) {
+      this._firstFragment = false;
+      if (
+        rsv1 &&
+        perMessageDeflate &&
+        perMessageDeflate.params[
+          perMessageDeflate._isServer
+            ? 'server_no_context_takeover'
+            : 'client_no_context_takeover'
+        ]
+      ) {
+        rsv1 = byteLength >= perMessageDeflate._threshold;
+      }
+      this._compress = rsv1;
+    } else {
+      rsv1 = false;
+      opcode = 0;
+    }
+
+    if (options.fin) this._firstFragment = true;
+
+    const opts = {
+      [kByteLength]: byteLength,
+      fin: options.fin,
+      generateMask: this._generateMask,
+      mask: options.mask,
+      maskBuffer: this._maskBuffer,
+      opcode,
+      readOnly,
+      rsv1
+    };
+
+    if (isBlob(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, this._compress, opts, cb]);
+      } else {
+        this.getBlobData(data, this._compress, opts, cb);
+      }
+    } else if (this._state !== DEFAULT) {
+      this.enqueue([this.dispatch, data, this._compress, opts, cb]);
+    } else {
+      this.dispatch(data, this._compress, opts, cb);
+    }
+  }
+
+  /**
+   * Gets the contents of a blob as binary data.
+   *
+   * @param {Blob} blob The blob
+   * @param {Boolean} [compress=false] Specifies whether or not to compress
+   *     the data
+   * @param {Object} options Options object
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+   *     key
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  getBlobData(blob, compress, options, cb) {
+    this._bufferedBytes += options[kByteLength];
+    this._state = GET_BLOB_DATA;
+
+    blob
+      .arrayBuffer()
+      .then((arrayBuffer) => {
+        if (this._socket.destroyed) {
+          const err = new Error(
+            'The socket was closed while the blob was being read'
+          );
+
+          //
+          // `callCallbacks` is called in the next tick to ensure that errors
+          // that might be thrown in the callbacks behave like errors thrown
+          // outside the promise chain.
+          //
+          process.nextTick(callCallbacks, this, err, cb);
+          return;
+        }
+
+        this._bufferedBytes -= options[kByteLength];
+        const data = toBuffer(arrayBuffer);
+
+        if (!compress) {
+          this._state = DEFAULT;
+          this.sendFrame(Sender.frame(data, options), cb);
+          this.dequeue();
+        } else {
+          this.dispatch(data, compress, options, cb);
+        }
+      })
+      .catch((err) => {
+        //
+        // `onError` is called in the next tick for the same reason that
+        // `callCallbacks` above is.
+        //
+        process.nextTick(onError, this, err, cb);
+      });
+  }
+
+  /**
+   * Dispatches a message.
+   *
+   * @param {(Buffer|String)} data The message to send
+   * @param {Boolean} [compress=false] Specifies whether or not to compress
+   *     `data`
+   * @param {Object} options Options object
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+   *     key
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  dispatch(data, compress, options, cb) {
+    if (!compress) {
+      this.sendFrame(Sender.frame(data, options), cb);
+      return;
+    }
+
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+
+    this._bufferedBytes += options[kByteLength];
+    this._state = DEFLATING;
+    perMessageDeflate.compress(data, options.fin, (_, buf) => {
+      if (this._socket.destroyed) {
+        const err = new Error(
+          'The socket was closed while data was being compressed'
+        );
+
+        callCallbacks(this, err, cb);
+        return;
+      }
+
+      this._bufferedBytes -= options[kByteLength];
+      this._state = DEFAULT;
+      options.readOnly = false;
+      this.sendFrame(Sender.frame(buf, options), cb);
+      this.dequeue();
+    });
+  }
+
+  /**
+   * Executes queued send operations.
+   *
+   * @private
+   */
+  dequeue() {
+    while (this._state === DEFAULT && this._queue.length) {
+      const params = this._queue.shift();
+
+      this._bufferedBytes -= params[3][kByteLength];
+      Reflect.apply(params[0], this, params.slice(1));
+    }
+  }
+
+  /**
+   * Enqueues a send operation.
+   *
+   * @param {Array} params Send operation parameters.
+   * @private
+   */
+  enqueue(params) {
+    this._bufferedBytes += params[3][kByteLength];
+    this._queue.push(params);
+  }
+
+  /**
+   * Sends a frame.
+   *
+   * @param {(Buffer | String)[]} list The frame to send
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  sendFrame(list, cb) {
+    if (list.length === 2) {
+      this._socket.cork();
+      this._socket.write(list[0]);
+      this._socket.write(list[1], cb);
+      this._socket.uncork();
+    } else {
+      this._socket.write(list[0], cb);
+    }
+  }
+}
+
+module.exports = Sender;
+
+/**
+ * Calls queued callbacks with an error.
+ *
+ * @param {Sender} sender The `Sender` instance
+ * @param {Error} err The error to call the callbacks with
+ * @param {Function} [cb] The first callback
+ * @private
+ */
+function callCallbacks(sender, err, cb) {
+  if (typeof cb === 'function') cb(err);
+
+  for (let i = 0; i < sender._queue.length; i++) {
+    const params = sender._queue[i];
+    const callback = params[params.length - 1];
+
+    if (typeof callback === 'function') callback(err);
+  }
+}
+
+/**
+ * Handles a `Sender` error.
+ *
+ * @param {Sender} sender The `Sender` instance
+ * @param {Error} err The error
+ * @param {Function} [cb] The first pending callback
+ * @private
+ */
+function onError(sender, err, cb) {
+  callCallbacks(sender, err, cb);
+  sender.onerror(err);
+}

V3.1/build/hub-shim/node_modules/ws/lib/stream.js

@@ -0,0 +1,161 @@
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^WebSocket$" }] */
+'use strict';
+
+const WebSocket = require('./websocket');
+const { Duplex } = require('stream');
+
+/**
+ * Emits the `'close'` event on a stream.
+ *
+ * @param {Duplex} stream The stream.
+ * @private
+ */
+function emitClose(stream) {
+  stream.emit('close');
+}
+
+/**
+ * The listener of the `'end'` event.
+ *
+ * @private
+ */
+function duplexOnEnd() {
+  if (!this.destroyed && this._writableState.finished) {
+    this.destroy();
+  }
+}
+
+/**
+ * The listener of the `'error'` event.
+ *
+ * @param {Error} err The error
+ * @private
+ */
+function duplexOnError(err) {
+  this.removeListener('error', duplexOnError);
+  this.destroy();
+  if (this.listenerCount('error') === 0) {
+    // Do not suppress the throwing behavior.
+    this.emit('error', err);
+  }
+}
+
+/**
+ * Wraps a `WebSocket` in a duplex stream.
+ *
+ * @param {WebSocket} ws The `WebSocket` to wrap
+ * @param {Object} [options] The options for the `Duplex` constructor
+ * @return {Duplex} The duplex stream
+ * @public
+ */
+function createWebSocketStream(ws, options) {
+  let terminateOnDestroy = true;
+
+  const duplex = new Duplex({
+    ...options,
+    autoDestroy: false,
+    emitClose: false,
+    objectMode: false,
+    writableObjectMode: false
+  });
+
+  ws.on('message', function message(msg, isBinary) {
+    const data =
+      !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
+
+    if (!duplex.push(data)) ws.pause();
+  });
+
+  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);
+  });
+
+  ws.once('close', function close() {
+    if (duplex.destroyed) return;
+
+    duplex.push(null);
+  });
+
+  duplex._destroy = function (err, callback) {
+    if (ws.readyState === ws.CLOSED) {
+      callback(err);
+      process.nextTick(emitClose, duplex);
+      return;
+    }
+
+    let called = false;
+
+    ws.once('error', function error(err) {
+      called = true;
+      callback(err);
+    });
+
+    ws.once('close', function close() {
+      if (!called) callback(err);
+      process.nextTick(emitClose, duplex);
+    });
+
+    if (terminateOnDestroy) ws.terminate();
+  };
+
+  duplex._final = function (callback) {
+    if (ws.readyState === ws.CONNECTING) {
+      ws.once('open', function open() {
+        duplex._final(callback);
+      });
+      return;
+    }
+
+    // If the value of the `_socket` property is `null` it means that `ws` is a
+    // client websocket and the handshake failed. In fact, when this happens, a
+    // socket is never assigned to the websocket. Wait for the `'error'` event
+    // that will be emitted by the websocket.
+    if (ws._socket === null) return;
+
+    if (ws._socket._writableState.finished) {
+      callback();
+      if (duplex._readableState.endEmitted) duplex.destroy();
+    } else {
+      ws._socket.once('finish', function finish() {
+        // `duplex` is not destroyed here because the `'end'` event will be
+        // emitted on `duplex` after this `'finish'` event. The EOF signaling
+        // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
+        callback();
+      });
+      ws.close();
+    }
+  };
+
+  duplex._read = function () {
+    if (ws.isPaused) ws.resume();
+  };
+
+  duplex._write = function (chunk, encoding, callback) {
+    if (ws.readyState === ws.CONNECTING) {
+      ws.once('open', function open() {
+        duplex._write(chunk, encoding, callback);
+      });
+      return;
+    }
+
+    ws.send(chunk, callback);
+  };
+
+  duplex.on('end', duplexOnEnd);
+  duplex.on('error', duplexOnError);
+  return duplex;
+}
+
+module.exports = createWebSocketStream;

V3.1/build/hub-shim/node_modules/ws/lib/subprotocol.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const { tokenChars } = require('./validation');
+
+/**
+ * Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names.
+ *
+ * @param {String} header The field value of the header
+ * @return {Set} The subprotocol names
+ * @public
+ */
+function parse(header) {
+  const protocols = new Set();
+  let start = -1;
+  let end = -1;
+  let i = 0;
+
+  for (i; i < header.length; i++) {
+    const code = header.charCodeAt(i);
+
+    if (end === -1 && tokenChars[code] === 1) {
+      if (start === -1) start = i;
+    } else if (
+      i !== 0 &&
+      (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
+    ) {
+      if (end === -1 && start !== -1) end = i;
+    } else if (code === 0x2c /* ',' */) {
+      if (start === -1) {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+
+      if (end === -1) end = i;
+
+      const protocol = header.slice(start, end);
+
+      if (protocols.has(protocol)) {
+        throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+      }
+
+      protocols.add(protocol);
+      start = end = -1;
+    } else {
+      throw new SyntaxError(`Unexpected character at index ${i}`);
+    }
+  }
+
+  if (start === -1 || end !== -1) {
+    throw new SyntaxError('Unexpected end of input');
+  }
+
+  const protocol = header.slice(start, i);
+
+  if (protocols.has(protocol)) {
+    throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+  }
+
+  protocols.add(protocol);
+  return protocols;
+}
+
+module.exports = { parse };

V3.1/build/hub-shim/node_modules/ws/lib/validation.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const { isUtf8 } = require('buffer');
+
+const { hasBlob } = require('./constants');
+
+//
+// Allowed token characters:
+//
+// '!', '#', '$', '%', '&', ''', '*', '+', '-',
+// '.', 0-9, A-Z, '^', '_', '`', a-z, '|', '~'
+//
+// tokenChars[32] === 0 // ' '
+// tokenChars[33] === 1 // '!'
+// tokenChars[34] === 0 // '"'
+// ...
+//
+// prettier-ignore
+const tokenChars = [
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
+  0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, // 32 - 47
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 - 63
+  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, // 80 - 95
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0 // 112 - 127
+];
+
+/**
+ * Checks if a status code is allowed in a close frame.
+ *
+ * @param {Number} code The status code
+ * @return {Boolean} `true` if the status code is valid, else `false`
+ * @public
+ */
+function isValidStatusCode(code) {
+  return (
+    (code >= 1000 &&
+      code <= 1014 &&
+      code !== 1004 &&
+      code !== 1005 &&
+      code !== 1006) ||
+    (code >= 3000 && code <= 4999)
+  );
+}
+
+/**
+ * Checks if a given buffer contains only correct UTF-8.
+ * Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by
+ * Markus Kuhn.
+ *
+ * @param {Buffer} buf The buffer to check
+ * @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`
+ * @public
+ */
+function _isValidUTF8(buf) {
+  const len = buf.length;
+  let i = 0;
+
+  while (i < len) {
+    if ((buf[i] & 0x80) === 0) {
+      // 0xxxxxxx
+      i++;
+    } else if ((buf[i] & 0xe0) === 0xc0) {
+      // 110xxxxx 10xxxxxx
+      if (
+        i + 1 === len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i] & 0xfe) === 0xc0 // Overlong
+      ) {
+        return false;
+      }
+
+      i += 2;
+    } else if ((buf[i] & 0xf0) === 0xe0) {
+      // 1110xxxx 10xxxxxx 10xxxxxx
+      if (
+        i + 2 >= len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i + 2] & 0xc0) !== 0x80 ||
+        (buf[i] === 0xe0 && (buf[i + 1] & 0xe0) === 0x80) || // Overlong
+        (buf[i] === 0xed && (buf[i + 1] & 0xe0) === 0xa0) // Surrogate (U+D800 - U+DFFF)
+      ) {
+        return false;
+      }
+
+      i += 3;
+    } else if ((buf[i] & 0xf8) === 0xf0) {
+      // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+      if (
+        i + 3 >= len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i + 2] & 0xc0) !== 0x80 ||
+        (buf[i + 3] & 0xc0) !== 0x80 ||
+        (buf[i] === 0xf0 && (buf[i + 1] & 0xf0) === 0x80) || // Overlong
+        (buf[i] === 0xf4 && buf[i + 1] > 0x8f) ||
+        buf[i] > 0xf4 // > U+10FFFF
+      ) {
+        return false;
+      }
+
+      i += 4;
+    } else {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Determines whether a value is a `Blob`.
+ *
+ * @param {*} value The value to be tested
+ * @return {Boolean} `true` if `value` is a `Blob`, else `false`
+ * @private
+ */
+function isBlob(value) {
+  return (
+    hasBlob &&
+    typeof value === 'object' &&
+    typeof value.arrayBuffer === 'function' &&
+    typeof value.type === 'string' &&
+    typeof value.stream === 'function' &&
+    (value[Symbol.toStringTag] === 'Blob' ||
+      value[Symbol.toStringTag] === 'File')
+  );
+}
+
+module.exports = {
+  isBlob,
+  isValidStatusCode,
+  isValidUTF8: _isValidUTF8,
+  tokenChars
+};
+
+if (isUtf8) {
+  module.exports.isValidUTF8 = function (buf) {
+    return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
+  };
+} /* istanbul ignore else  */ else if (!process.env.WS_NO_UTF_8_VALIDATE) {
+  try {
+    const isValidUTF8 = require('utf-8-validate');
+
+    module.exports.isValidUTF8 = function (buf) {
+      return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
+    };
+  } catch (e) {
+    // Continue regardless of the error.
+  }
+}

V3.1/build/hub-shim/node_modules/ws/lib/websocket-server.js

@@ -0,0 +1,554 @@
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
+
+'use strict';
+
+const EventEmitter = require('events');
+const http = require('http');
+const { Duplex } = require('stream');
+const { createHash } = require('crypto');
+
+const extension = require('./extension');
+const PerMessageDeflate = require('./permessage-deflate');
+const subprotocol = require('./subprotocol');
+const WebSocket = require('./websocket');
+const { CLOSE_TIMEOUT, GUID, kWebSocket } = require('./constants');
+
+const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
+
+const RUNNING = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+
+/**
+ * Class representing a WebSocket server.
+ *
+ * @extends EventEmitter
+ */
+class WebSocketServer extends EventEmitter {
+  /**
+   * Create a `WebSocketServer` instance.
+   *
+   * @param {Object} options Configuration options
+   * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
+   *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+   *     multiple times in the same tick
+   * @param {Boolean} [options.autoPong=true] Specifies whether or not to
+   *     automatically send a pong in response to a ping
+   * @param {Number} [options.backlog=511] The maximum length of the queue of
+   *     pending connections
+   * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
+   *     track clients
+   * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to
+   *     wait for the closing handshake to finish after `websocket.close()` is
+   *     called
+   * @param {Function} [options.handleProtocols] A hook to handle protocols
+   * @param {String} [options.host] The hostname where to bind the server
+   * @param {Number} [options.maxPayload=104857600] The maximum allowed message
+   *     size
+   * @param {Boolean} [options.noServer=false] Enable no server mode
+   * @param {String} [options.path] Accept only connections matching this path
+   * @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 {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+   *     not to skip UTF-8 validation for text and close messages
+   * @param {Function} [options.verifyClient] A hook to reject connections
+   * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
+   *     class to use. It must be the `WebSocket` class or class that extends it
+   * @param {Function} [callback] A listener for the `listening` event
+   */
+  constructor(options, callback) {
+    super();
+
+    options = {
+      allowSynchronousEvents: true,
+      autoPong: true,
+      maxPayload: 100 * 1024 * 1024,
+      skipUTF8Validation: false,
+      perMessageDeflate: false,
+      handleProtocols: null,
+      clientTracking: true,
+      closeTimeout: CLOSE_TIMEOUT,
+      verifyClient: null,
+      noServer: false,
+      backlog: null, // use default (511 as implemented in net.js)
+      server: null,
+      host: null,
+      path: null,
+      port: null,
+      WebSocket,
+      ...options
+    };
+
+    if (
+      (options.port == null && !options.server && !options.noServer) ||
+      (options.port != null && (options.server || options.noServer)) ||
+      (options.server && options.noServer)
+    ) {
+      throw new TypeError(
+        'One and only 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];
+
+        res.writeHead(426, {
+          'Content-Length': body.length,
+          'Content-Type': 'text/plain'
+        });
+        res.end(body);
+      });
+      this._server.listen(
+        options.port,
+        options.host,
+        options.backlog,
+        callback
+      );
+    } else if (options.server) {
+      this._server = options.server;
+    }
+
+    if (this._server) {
+      const emitConnection = this.emit.bind(this, 'connection');
+
+      this._removeListeners = addListeners(this._server, {
+        listening: this.emit.bind(this, 'listening'),
+        error: this.emit.bind(this, 'error'),
+        upgrade: (req, socket, head) => {
+          this.handleUpgrade(req, socket, head, emitConnection);
+        }
+      });
+    }
+
+    if (options.perMessageDeflate === true) options.perMessageDeflate = {};
+    if (options.clientTracking) {
+      this.clients = new Set();
+      this._shouldEmitClose = false;
+    }
+
+    this.options = options;
+    this._state = RUNNING;
+  }
+
+  /**
+   * Returns the bound address, the address family name, and port of the server
+   * as reported by the operating system if listening on an IP socket.
+   * If the server is listening on a pipe or UNIX domain socket, the name is
+   * returned as a string.
+   *
+   * @return {(Object|String|null)} The address of the server
+   * @public
+   */
+  address() {
+    if (this.options.noServer) {
+      throw new Error('The server is operating in "noServer" mode');
+    }
+
+    if (!this._server) return null;
+    return this._server.address();
+  }
+
+  /**
+   * Stop the server from accepting new connections and emit the `'close'` event
+   * when all existing connections are closed.
+   *
+   * @param {Function} [cb] A one-time listener for the `'close'` event
+   * @public
+   */
+  close(cb) {
+    if (this._state === CLOSED) {
+      if (cb) {
+        this.once('close', () => {
+          cb(new Error('The server is not running'));
+        });
+      }
+
+      process.nextTick(emitClose, this);
+      return;
+    }
+
+    if (cb) this.once('close', cb);
+
+    if (this._state === CLOSING) return;
+    this._state = CLOSING;
+
+    if (this.options.noServer || this.options.server) {
+      if (this._server) {
+        this._removeListeners();
+        this._removeListeners = this._server = null;
+      }
+
+      if (this.clients) {
+        if (!this.clients.size) {
+          process.nextTick(emitClose, this);
+        } else {
+          this._shouldEmitClose = true;
+        }
+      } else {
+        process.nextTick(emitClose, this);
+      }
+    } else {
+      const server = this._server;
+
+      this._removeListeners();
+      this._removeListeners = this._server = null;
+
+      //
+      // The HTTP/S server was created internally. Close it, and rely on its
+      // `'close'` event.
+      //
+      server.close(() => {
+        emitClose(this);
+      });
+    }
+  }
+
+  /**
+   * See if a given request should be handled by this server instance.
+   *
+   * @param {http.IncomingMessage} req Request object to inspect
+   * @return {Boolean} `true` if the request is valid, else `false`
+   * @public
+   */
+  shouldHandle(req) {
+    if (this.options.path) {
+      const index = req.url.indexOf('?');
+      const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
+
+      if (pathname !== this.options.path) return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Handle a HTTP Upgrade request.
+   *
+   * @param {http.IncomingMessage} req The request object
+   * @param {Duplex} socket The network socket between the server and client
+   * @param {Buffer} head The first packet of the upgraded stream
+   * @param {Function} cb Callback
+   * @public
+   */
+  handleUpgrade(req, socket, head, cb) {
+    socket.on('error', socketOnError);
+
+    const key = req.headers['sec-websocket-key'];
+    const upgrade = req.headers.upgrade;
+    const version = +req.headers['sec-websocket-version'];
+
+    if (req.method !== 'GET') {
+      const message = 'Invalid HTTP method';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
+      return;
+    }
+
+    if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {
+      const message = 'Invalid Upgrade header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+      return;
+    }
+
+    if (key === undefined || !keyRegex.test(key)) {
+      const message = 'Missing or invalid Sec-WebSocket-Key header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+      return;
+    }
+
+    if (version !== 13 && version !== 8) {
+      const message = 'Missing or invalid Sec-WebSocket-Version header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
+        'Sec-WebSocket-Version': '13, 8'
+      });
+      return;
+    }
+
+    if (!this.shouldHandle(req)) {
+      abortHandshake(socket, 400);
+      return;
+    }
+
+    const secWebSocketProtocol = req.headers['sec-websocket-protocol'];
+    let protocols = new Set();
+
+    if (secWebSocketProtocol !== undefined) {
+      try {
+        protocols = subprotocol.parse(secWebSocketProtocol);
+      } catch (err) {
+        const message = 'Invalid Sec-WebSocket-Protocol header';
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+        return;
+      }
+    }
+
+    const secWebSocketExtensions = req.headers['sec-websocket-extensions'];
+    const extensions = {};
+
+    if (
+      this.options.perMessageDeflate &&
+      secWebSocketExtensions !== undefined
+    ) {
+      const perMessageDeflate = new PerMessageDeflate(
+        this.options.perMessageDeflate,
+        true,
+        this.options.maxPayload
+      );
+
+      try {
+        const offers = extension.parse(secWebSocketExtensions);
+
+        if (offers[PerMessageDeflate.extensionName]) {
+          perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
+          extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+        }
+      } catch (err) {
+        const message =
+          'Invalid or unacceptable Sec-WebSocket-Extensions header';
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+        return;
+      }
+    }
+
+    //
+    // Optionally call external client verification handler.
+    //
+    if (this.options.verifyClient) {
+      const info = {
+        origin:
+          req.headers[`${version === 8 ? 'sec-websocket-origin' : 'origin'}`],
+        secure: !!(req.socket.authorized || req.socket.encrypted),
+        req
+      };
+
+      if (this.options.verifyClient.length === 2) {
+        this.options.verifyClient(info, (verified, code, message, headers) => {
+          if (!verified) {
+            return abortHandshake(socket, code || 401, message, headers);
+          }
+
+          this.completeUpgrade(
+            extensions,
+            key,
+            protocols,
+            req,
+            socket,
+            head,
+            cb
+          );
+        });
+        return;
+      }
+
+      if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
+    }
+
+    this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
+  }
+
+  /**
+   * Upgrade the connection to WebSocket.
+   *
+   * @param {Object} extensions The accepted extensions
+   * @param {String} key The value of the `Sec-WebSocket-Key` header
+   * @param {Set} protocols The subprotocols
+   * @param {http.IncomingMessage} req The request object
+   * @param {Duplex} 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
+   * @private
+   */
+  completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
+    //
+    // Destroy the socket if the client has already sent a FIN packet.
+    //
+    if (!socket.readable || !socket.writable) return socket.destroy();
+
+    if (socket[kWebSocket]) {
+      throw new Error(
+        'server.handleUpgrade() was called more than once with the same ' +
+          'socket, possibly due to a misconfiguration'
+      );
+    }
+
+    if (this._state > RUNNING) return abortHandshake(socket, 503);
+
+    const digest = createHash('sha1')
+      .update(key + GUID)
+      .digest('base64');
+
+    const headers = [
+      'HTTP/1.1 101 Switching Protocols',
+      'Upgrade: websocket',
+      'Connection: Upgrade',
+      `Sec-WebSocket-Accept: ${digest}`
+    ];
+
+    const ws = new this.options.WebSocket(null, undefined, this.options);
+
+    if (protocols.size) {
+      //
+      // Optionally call external protocol selection handler.
+      //
+      const protocol = this.options.handleProtocols
+        ? this.options.handleProtocols(protocols, req)
+        : protocols.values().next().value;
+
+      if (protocol) {
+        headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
+        ws._protocol = protocol;
+      }
+    }
+
+    if (extensions[PerMessageDeflate.extensionName]) {
+      const params = extensions[PerMessageDeflate.extensionName].params;
+      const value = extension.format({
+        [PerMessageDeflate.extensionName]: [params]
+      });
+      headers.push(`Sec-WebSocket-Extensions: ${value}`);
+      ws._extensions = extensions;
+    }
+
+    //
+    // Allow external modification/inspection of handshake headers.
+    //
+    this.emit('headers', headers, req);
+
+    socket.write(headers.concat('\r\n').join('\r\n'));
+    socket.removeListener('error', socketOnError);
+
+    ws.setSocket(socket, head, {
+      allowSynchronousEvents: this.options.allowSynchronousEvents,
+      maxPayload: this.options.maxPayload,
+      skipUTF8Validation: this.options.skipUTF8Validation
+    });
+
+    if (this.clients) {
+      this.clients.add(ws);
+      ws.on('close', () => {
+        this.clients.delete(ws);
+
+        if (this._shouldEmitClose && !this.clients.size) {
+          process.nextTick(emitClose, this);
+        }
+      });
+    }
+
+    cb(ws, req);
+  }
+}
+
+module.exports = WebSocketServer;
+
+/**
+ * Add event listeners on an `EventEmitter` using a map of <event, listener>
+ * pairs.
+ *
+ * @param {EventEmitter} server The event emitter
+ * @param {Object.<String, Function>} map The listeners to add
+ * @return {Function} A function that will remove the added listeners when
+ *     called
+ * @private
+ */
+function addListeners(server, map) {
+  for (const event of Object.keys(map)) server.on(event, map[event]);
+
+  return function removeListeners() {
+    for (const event of Object.keys(map)) {
+      server.removeListener(event, map[event]);
+    }
+  };
+}
+
+/**
+ * Emit a `'close'` event on an `EventEmitter`.
+ *
+ * @param {EventEmitter} server The event emitter
+ * @private
+ */
+function emitClose(server) {
+  server._state = CLOSED;
+  server.emit('close');
+}
+
+/**
+ * Handle socket errors.
+ *
+ * @private
+ */
+function socketOnError() {
+  this.destroy();
+}
+
+/**
+ * Close the connection when preconditions are not fulfilled.
+ *
+ * @param {Duplex} 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
+ * @private
+ */
+function abortHandshake(socket, code, message, headers) {
+  //
+  // The socket is writable unless the user destroyed or ended it before calling
+  // `server.handleUpgrade()` or in the `verifyClient` function, which is a user
+  // error. Handling this does not make much sense as the worst that can happen
+  // is that some of the data written by the user might be discarded due to the
+  // call to `socket.end()` below, which triggers an `'error'` event that in
+  // turn causes the socket to be destroyed.
+  //
+  message = message || http.STATUS_CODES[code];
+  headers = {
+    Connection: 'close',
+    'Content-Type': 'text/html',
+    'Content-Length': Buffer.byteLength(message),
+    ...headers
+  };
+
+  socket.once('finish', socket.destroy);
+
+  socket.end(
+    `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r\n` +
+      Object.keys(headers)
+        .map((h) => `${h}: ${headers[h]}`)
+        .join('\r\n') +
+      '\r\n\r\n' +
+      message
+  );
+}
+
+/**
+ * Emit a `'wsClientError'` event on a `WebSocketServer` if there is at least
+ * one listener for it, otherwise call `abortHandshake()`.
+ *
+ * @param {WebSocketServer} server The WebSocket server
+ * @param {http.IncomingMessage} req The request object
+ * @param {Duplex} 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] The HTTP response headers
+ * @private
+ */
+function abortHandshakeOrEmitwsClientError(
+  server,
+  req,
+  socket,
+  code,
+  message,
+  headers
+) {
+  if (server.listenerCount('wsClientError')) {
+    const err = new Error(message);
+    Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
+
+    server.emit('wsClientError', err, socket, req);
+  } else {
+    abortHandshake(socket, code, message, headers);
+  }
+}

V3.1/build/hub-shim/node_modules/ws/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "ws",
+  "version": "8.19.0",
+  "description": "Simple to use, blazing fast and thoroughly tested websocket client and server for Node.js",
+  "keywords": [
+    "HyBi",
+    "Push",
+    "RFC-6455",
+    "WebSocket",
+    "WebSockets",
+    "real-time"
+  ],
+  "homepage": "https://github.com/websockets/ws",
+  "bugs": "https://github.com/websockets/ws/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/websockets/ws.git"
+  },
+  "author": "Einar Otto Stangvik <einaros@gmail.com> (http://2x.io)",
+  "license": "MIT",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "browser": "./browser.js",
+      "import": "./wrapper.mjs",
+      "require": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "browser": "browser.js",
+  "engines": {
+    "node": ">=10.0.0"
+  },
+  "files": [
+    "browser.js",
+    "index.js",
+    "lib/*.js",
+    "wrapper.mjs"
+  ],
+  "scripts": {
+    "test": "nyc --reporter=lcov --reporter=text mocha --throw-deprecation test/*.test.js",
+    "integration": "mocha --throw-deprecation test/*.integration.js",
+    "lint": "eslint . && prettier --check --ignore-path .gitignore \"**/*.{json,md,yaml,yml}\""
+  },
+  "peerDependencies": {
+    "bufferutil": "^4.0.1",
+    "utf-8-validate": ">=5.0.2"
+  },
+  "peerDependenciesMeta": {
+    "bufferutil": {
+      "optional": true
+    },
+    "utf-8-validate": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "benchmark": "^2.1.4",
+    "bufferutil": "^4.0.1",
+    "eslint": "^9.0.0",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-prettier": "^5.0.0",
+    "globals": "^16.0.0",
+    "mocha": "^8.4.0",
+    "nyc": "^15.0.0",
+    "prettier": "^3.0.0",
+    "utf-8-validate": "^6.0.0"
+  }
+}

V3.1/build/hub-shim/node_modules/ws/wrapper.mjs

@@ -0,0 +1,8 @@
+import createWebSocketStream from './lib/stream.js';
+import Receiver from './lib/receiver.js';
+import Sender from './lib/sender.js';
+import WebSocket from './lib/websocket.js';
+import WebSocketServer from './lib/websocket-server.js';
+
+export { createWebSocketStream, Receiver, Sender, WebSocket, WebSocketServer };
+export default WebSocket;

V3.1/build/hub-shim/package-lock.json

@@ -0,0 +1,37 @@
+{
+  "name": "jibo-hub-shim",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "jibo-hub-shim",
+      "version": "0.1.0",
+      "license": "UNLICENSED",
+      "dependencies": {
+        "ws": "^8.19.0"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.19.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
+      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

V3.1/build/hub-shim/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "jibo-hub-shim",
+  "version": "0.1.0",
+  "private": true,
+  "main": "index.js",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "ws": "^8.19.0"
+  }
+}

V3.1/build/hub-shim/systemd/jibo-hub-shim.env.example

@@ -0,0 +1,3 @@
+# Config file path passed to the shim.
+# Copy to: /etc/jibo-hub-shim/jibo-hub-shim.env
+JIBO_HUB_SHIM_CONFIG=/etc/jibo-hub-shim/config.json

V3.1/build/hub-shim/systemd/jibo-hub-shim.service

@@ -0,0 +1,21 @@
+[Unit]
+Description=Jibo Hub Shim (v1/listen)
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+WorkingDirectory=/opt/jibo-hub-shim
+EnvironmentFile=-/etc/jibo-hub-shim/jibo-hub-shim.env
+ExecStart=/usr/bin/env node /opt/jibo-hub-shim/index.js ${JIBO_HUB_SHIM_CONFIG}
+Restart=always
+RestartSec=2
+
+# Hardening (keep minimal; shim needs network only)
+NoNewPrivileges=true
+PrivateTmp=true
+ProtectSystem=full
+ProtectHome=true
+
+[Install]
+WantedBy=multi-user.target

V3.1/build/hub-shim/test-client.js

@@ -0,0 +1,120 @@
+/* eslint-disable no-console */
+
+const crypto = require('crypto');
+
+function uuid() {
+	if (typeof crypto.randomUUID === 'function') return crypto.randomUUID();
+	return [4, 2, 2, 2, 6].map((len) => crypto.randomBytes(len).toString('hex')).join('-');
+}
+
+function requireWs() {
+	try {
+		return require('ws');
+	} catch (_) {
+		return require('/opt/jibo/Jibo/Skills/@be/be/node_modules/ws');
+	}
+}
+
+const WebSocket = requireWs();
+
+function parseArgs(argv) {
+	const args = { url: '', mode: 'client_asr', text: 'yes I liked it', rules: ['globals/yes_no'] };
+	for (let i = 2; i < argv.length; i += 1) {
+		const a = argv[i];
+		if (!a) continue;
+		if (a.startsWith('ws://') || a.startsWith('wss://')) {
+			args.url = a;
+			continue;
+		}
+		if (a === '--stt') {
+			args.mode = 'stt';
+			continue;
+		}
+		if (a === '--client_asr') {
+			args.mode = 'client_asr';
+			continue;
+		}
+		if (a.indexOf('--mode=') === 0) {
+			args.mode = String(a.split('=')[1] || '').trim() || args.mode;
+			continue;
+		}
+		if (a.indexOf('--text=') === 0) {
+			args.text = String(a.split('=')[1] || '');
+			continue;
+		}
+		if (a.indexOf('--rules=') === 0) {
+			const r = String(a.split('=')[1] || '');
+			args.rules = r ? r.split(',').map((s) => s.trim()).filter(Boolean) : [];
+			continue;
+		}
+	}
+	return args;
+}
+
+const args = parseArgs(process.argv);
+const url = args.url || 'ws://127.0.0.1:9000/v1/listen';
+
+const ws = new WebSocket(url, {
+	headers: {
+		'x-jibo-transid': 'test-transid',
+	},
+});
+
+ws.on('open', () => {
+	console.log('connected', url);
+	ws.send(JSON.stringify({
+		type: 'CONTEXT',
+		msgID: uuid(),
+		ts: Date.now(),
+		data: { runtime: {}, skill: {}, general: {} },
+	}));
+	if (String(args.mode).toLowerCase() === 'stt') {
+		console.log('mode=stt: waiting for robot ASR via shim');
+		ws.send(JSON.stringify({
+			type: 'LISTEN',
+			msgID: uuid(),
+			ts: Date.now(),
+			data: { hotphrase: false, rules: args.rules },
+		}));
+		return;
+	}
+
+	console.log('mode=client_asr:', JSON.stringify({ text: args.text, rules: args.rules }));
+	ws.send(JSON.stringify({
+		type: 'LISTEN',
+		msgID: uuid(),
+		ts: Date.now(),
+		data: { hotphrase: false, rules: args.rules, mode: 'CLIENT_ASR' },
+	}));
+	ws.send(JSON.stringify({
+		type: 'CLIENT_ASR',
+		msgID: uuid(),
+		ts: Date.now(),
+		data: { text: args.text },
+	}));
+});
+
+ws.on('message', (data) => {
+	let msg;
+	try {
+		msg = JSON.parse(data.toString('utf8'));
+	} catch (e) {
+		console.log('binary/unknown', data);
+		return;
+	}
+	console.log('rx', msg.type, msg.final ? '(final)' : '', msg.data ? '' : '');
+	if (msg.type === 'LISTEN') {
+		console.log(JSON.stringify(msg, null, 2));
+		ws.close();
+	}
+});
+
+ws.on('close', () => {
+	console.log('closed');
+	process.exit(0);
+});
+
+ws.on('error', (e) => {
+	console.error('error', e && (e.stack || e.message || e));
+	process.exit(1);
+});

V3.1/build/opt/jibo/Jibo/Skills/@be/be/be/BE-API_USAGE.md

@@ -0,0 +1,45 @@
+# BE-API: External Eye/Lightring Trigger
+
+This API lets you trigger Jibo's eye (and, in the future, lightring) from any external tool or script via HTTP.
+
+## Endpoint
+
+- **URL:** `http://<robot-ip>:15141/be-eye`
+- **Method:** `POST`
+- **Content-Type:** `application/json`
+
+## Actions
+
+### 1. Trigger Eye (Blue)
+- **Request Body:**
+  ```json
+  { "action": "eye" }
+  ```
+- **Effect:** Forces Jibo's eye to blue (listening state).
+- **Response:**
+  - `200 OK` with `{ "ok": true }` if successful
+  - `500` if failed
+
+### 2. (Planned) Trigger Lightring
+- **Request Body:**
+  ```json
+  { "action": "lightring", "color": "blue" }
+  ```
+- **Effect:** (Not implemented yet)
+- **Response:**
+  - `501` with `{ "ok": false, "msg": "not implemented" }`
+
+## Example: curl
+
+```
+curl -X POST -H 'Content-Type: application/json' \
+  -d '{"action":"eye"}' \
+  http://<robot-ip>:15141/be-eye
+```
+
+## Logging
+- All API activity is logged to the skills log and web log panel.
+
+## Notes
+- The API server starts automatically with the BE skill.
+- Lightring support is a placeholder for future hardware/API support.

V3.1/build/opt/jibo/Jibo/Skills/@be/be/be/ai-bridge-config.json

@@ -0,0 +1,39 @@
+{
+  "enabled": true,
+  "mode": "TEXT",
+  "serverBaseUrl": "http://192.168.1.28:8020",
+
+  "recordSeconds": 5,
+  "useDumpStateAudio": true,
+
+  "useAsrServiceStt": false,
+  "asrServiceHost": "127.0.0.1",
+  "asrServicePort": 8088,
+  "asrAudioSourceId": "alsa1",
+  "asrTimeoutMs": 15000,
+  "asrServiceDebugWs": false,
+  "asrAutoStart": true,
+
+  "wakeupChitchatPhrases": [
+    "hello",
+    "howdy",
+    "hi",
+    "hey",
+    "look what i found",
+    "nice to see you",
+    "good morning",
+    "good afternoon",
+    "good evening"
+  ],
+
+  "suppressWakeGreetings": true,
+
+  "jetstreamOfflineFallbackEnabled": false,
+  "jetstreamInjectOnHjHeard": false,
+
+  "aiForwardingOnlyAllowedSkills": true,
+  "aiForwardingAllowedSkills": ["@be/main-menu", "@be/idle"],
+
+  "followupEnabled": true,
+  "followupDelayMs": 250
+}

V3.1/build/opt/jibo/Jibo/Skills/@be/be/be/be-api.js

@@ -0,0 +1,105 @@
+// Simple HTTP API for BE skill to control eye and lightring
+// Usage: POST /be-eye { "action": "eye" | "lightring", "color": "blue" }
+
+const http = require('http');
+
+let jibo = null;
+let beLogger = null;
+let rlog = null;
+
+function setJiboRef(jiboInstance, logger, robotLogger) {
+    jibo = jiboInstance;
+    beLogger = logger || null;
+    try {
+        if (!robotLogger) {
+            robotLogger = require('./robot-logger');
+        }
+        rlog = robotLogger;
+    } catch (e) {
+        rlog = null;
+    }
+}
+
+function forceEyeView() {
+    if (rlog && typeof rlog.raw === 'function') rlog.raw('[BE-API] forceEyeView called');
+    if (jibo && jibo.loader && typeof jibo.loader.load === 'function') {
+        // This is the animation file loaded when "hey jibo" is triggered
+        const animPath = '/opt/jibo/Jibo/Skills/@be/be/node_modules/jibo-anim-db-animations/animations/eye-globals/perceptual/hj-dsp-transition-to-pop-ns.keys';
+        try {
+            jibo.loader.load({
+                id: animPath,
+                cache: 'global',
+                options: { cache: 'global', dofs: {} },
+                data: null,
+                src: animPath,
+                upload: true,
+                root: '/opt/jibo/Jibo/Skills/@be/be/node_modules/jibo-anim-db-animations',
+                type: 'keys'
+            });
+            if (rlog && typeof rlog.raw === 'function') rlog.raw('[BE-API] forceEyeView animation loaded');
+            return true;
+        } catch (e) {
+            if (rlog && typeof rlog.raw === 'function') rlog.raw('[BE-API] forceEyeView animation load failed: ' + String(e && (e.stack || e.message || e)));
+            return false;
+        }
+    }
+    if (rlog && typeof rlog.raw === 'function') rlog.raw('[BE-API] forceEyeView failed');
+    return false;
+}
+
+// TODO: Implement lightring control if API is available
+function setLightring(color) {
+    // Placeholder: No direct API found
+    return false;
+}
+
+const server = http.createServer((req, res) => {
+    if (rlog && typeof rlog.raw === 'function') {
+        rlog.raw('[BE-API] Incoming request ' + req.method + ' ' + req.url);
+    } else if (beLogger && typeof beLogger.info === 'function') {
+        beLogger.info('[BE-API] Incoming request', { method: req.method, url: req.url });
+    } else {
+        console.log('[BE-API] Incoming request', req.method, req.url);
+    }
+    if (req.method === 'POST' && req.url === '/be-eye') {
+        let body = '';
+        req.on('data', chunk => { body += chunk; });
+        req.on('end', () => {
+            try {
+                const data = JSON.parse(body);
+                if (data.action === 'eye') {
+                    const ok = forceEyeView();
+                    res.writeHead(ok ? 200 : 500);
+                    res.end(JSON.stringify({ ok }));
+                } else if (data.action === 'lightring') {
+                    const ok = setLightring(data.color);
+                    res.writeHead(ok ? 200 : 501);
+                    res.end(JSON.stringify({ ok, msg: ok ? 'ok' : 'not implemented' }));
+                } else {
+                    res.writeHead(400);
+                    res.end(JSON.stringify({ error: 'invalid action' }));
+                }
+            } catch (e) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: 'bad json' }));
+            }
+        });
+    } else {
+        res.writeHead(404);
+        res.end();
+    }
+});
+
+function start(port = 15141) {
+    server.listen(port, () => {
+        if (rlog && typeof rlog.raw === 'function') {
+            rlog.raw('[BE-API] Listening on port ' + port);
+        } else if (beLogger && typeof beLogger.info === 'function') {
+            beLogger.info('[BE-API] Listening on port ' + port);
+        } else {
+            console.log('[BE-API] Listening on port', port);
+        }
+    });
+}
+
+module.exports = { setJiboRef, start };

V3.1/build/opt/jibo/Jibo/Skills/@be/be/be/jibo-asr-service.local.json

@@ -0,0 +1,86 @@
+{
+    "webCore" : {
+        "serverPort": 8088,
+        "fileRoot": "/usr/local/var/www/asrservice",
+        "requestLogging": false
+    },
+    "AsrService" : {
+        "cloud_establish_http_timeout": 5000,
+        "language": "en-US",
+        "post_to_performance_service": true,
+        "log_audio": true,
+        "log_text" : true,
+        "log_path" : "/var/log/asr",
+        "log_level" : "INFO",
+        "log_server_url" : "https://speech-logging.jibo.com/logdrop/logdrop.py",
+        "speaker_id_resource_path" : "/var/jibo/asr/",
+        "name_learning_resource_path" : "/usr/local/share/asr/namelearning",
+        "name_learning_temp_path" : "/var/jibo/asr/namelearning_temp/",
+        "name_learning_nbest" : 70,
+        "active_sleep_duration" : 5000,
+        "idle_sleep_duration" : 50000,
+        "block_duration" : 50,
+        "audio_loop_sleep_us": 10000,
+        "use_nuance_upload_voc": false,
+        "dictation_type" : "dictation",
+        "nuance_uId" : "b8fb02f2c5794963aaafb8c716ef384c",
+        "contacts_checksum": "",
+        "loop_checksum": "1",
+        "customs_checksum": "",
+        "upload_voc_url": "ws.nuancemobility.net",
+        "cloud_url": "https://jibo-ncs-engusa-http.nuancemobility.net/NmspServlet/",
+        "cloud_appid": "HTTP_NMDPPRODUCTION_Jibo_Jibo_Robot_20151231124503",
+        "cloud_appkey": "a8c18159a8e3ca49471c56d867552bc77693ccdcc041375ee97b7c867160ae1a212f73c9123d1359596931c0be5c8734ef5310af95470d7ec3890434e9b24e0b",
+        "upload_voc_rootcert": "",
+        "google_credential": "/usr/local/share/asr/google_asr/credentials-key.json",
+        "fadeout_duration": 5000000,
+        "max_logfile_size": 1000,
+        "log_upload_time_interval": 60000,
+        "min_available_log_partition_space": 5000,
+        "max_asr_log_dir_size_before_upload_trigger": 10000,
+        "max_asr_log_dir_size": 12000,
+        "size_to_free_up_when_dir_overflowing": 1000,
+        "asr_resource_path" : "/usr/local/share/asr/",
+        "max_memory": 150000,
+        "wipable_files": [
+            "/var/log/asr/*.pcm",
+            "/var/log/asr/*.wav",
+            "/var/log/asr/*.log",
+            "/var/jibo/asr/sensory_data_td/client_model.bin",
+            "/var/jibo/asr/sensory_data_td/audio/*",
+            "/var/jibo/asr/namelearning_temp/*"
+        ],
+        "resident_task" : "{\"command\":\"start\",\"task_id\":\"task0\",\"audio_source_id\":\"alsa1\",\"hotphrase\":\"hey_jibo\",\"request_id\":\"resident_hey_jibo_self_start\",\"residency\":true}",
+        "resident_audio_channel" : "{\"action\":\"start\", \"audio_source_id\":\"alsa1\", \"wav_files\":[], \"audio_source\":\"alsa\", \"request_id\":\"self_start_audio_source_request_id\"}",
+        "task_templates" : {
+            "hey_jibo_resident": {
+                "input_template": "{\"name\":\"hey jibo\",\"path\":\"/usr/local/share/asr/hey_jibo\",\"timeout\":0} * {\"name\":\"Speaker ID TD\",\"path\":\"/usr/local/share/asr/sensory_spkr_id_td\",\"audio_tail_length\":1}",
+                "emitting_recogs": ["hey jibo", "Speaker ID TD"]
+            },
+            "hey_jibo": {
+                "input_template": "{\"name\":\"hey jibo\",\"path\":\"/usr/local/share/asr/hey_jibo\",\"timeout\":0} * ({\"name\":\"pcmwriter\",\"path\":\"/usr/local/share/asr/pcm_writer\",\"timeout\":0,\"audio_tail_length\":0, \"audio_overshoot_duration\":0} | {\"name\":\"Speaker ID TD\",\"path\":\"/usr/local/share/asr/sensory_spkr_id_td\",\"audio_tail_length\":1})",
+                "emitting_recogs": ["hey jibo", "Speaker ID TD"]
+            },
+            "cloud": {
+                "input_template":"({\"name\":\"google_asr\",\"path\":\"/usr/local/share/asr/google_asr\",\"timeout\":14000,\"bargein\":false,\"nbest\":1,\"speaker_name\":\"\",\"incremental\":false,\"audio_tail_length\":300}| {\"name\":\"sensory_sdet\",\"path\":\"/usr/local/share/asr/jibo_energy_fake_eos\",\"timeout\":50000,\"bargein\":false,\"nbest\":1,\"speaker_name\":\"\",\"incremental\":false})",
+                "emitting_recogs": ["google_asr","sensory_sdet"]
+            },
+            "hey_jibo_cloud": {
+                "input_template":"{\"name\":\"hey jibo\",\"path\":\"/usr/local/share/asr/hey_jibo\",\"timeout\":0,\"bargein\":true,\"nbest\":1,\"speaker_name\":\"\",\"incremental\":false,\"speaker_id\":true} * ({\"name\":\"Speaker ID TD\",\"path\":\"/usr/local/share/asr/sensory_spkr_id_td\",\"audio_tail_length\":1} & ({\"name\":\"pcmwriter\",\"path\":\"/usr/local/share/asr/pcm_writer\",\"timeout\":0,\"audio_tail_length\":400, \"audio_overshoot_duration\":0, \"prebuffer\":true} | {\"name\":\"google_asr\",\"path\":\"/usr/local/share/asr/google_asr\",\"timeout\":14000,\"bargein\":false,\"nbest\":1,\"speaker_name\":\"\",\"incremental\":false,\"trim_audio_tail\":true,\"wakeup_phrase_detection\":false,\"audio_tail_length\":0}|{\"name\":\"sensory_sdet\",\"path\":\"/usr/local/share/asr/jibo_energy_fake_eos\",\"timeout\":50000,\"bargein\":false,\"nbest\":1,\"speaker_name\":\"\",\"incremental\":false}))",
+                "emitting_recogs": ["hey jibo", "Speaker ID TD", "google_asr","sensory_sdet"]
+            }
+        },
+        "rewrite_rules" : {
+            "log_audio_no_trigger" : "^(?!.*?hey_jibo)(.*)->{\"name\":\"pcmwriter\",\"path\":\"/usr/local/share/asr/pcm_writer\",\"timeout\":0,\"audio_tail_length\":300, \"audio_overshoot_duration\":0,\"prebuffer\":false} | ($1)",
+            "namelearning_EOS" : "^(.*?\"name\":\\s*name_learning.*)->{\"name\":\"jibo_energy_eos\",\"path\":\"/usr/local/share/asr/jibo_energy_eos\",\"timeout\":10000,\"bargein\":false,\"nbest\":1,\"speaker_name\":\"\",\"incremental\":false} | ($1)"
+        }
+    },
+    "logging" : {
+        "jibo_message_prefix": "C",
+        "loggers" : {
+            "root": {"level": "information"},
+            "l1" : {"name" : "ASRService", "level" : "information"},
+            "l2" : {"name" : "Application", "level" : "information"}
+        }
+    }
+}

V3.1/build/opt/jibo/Jibo/Skills/@be/be/be/postinit.js

@@ -1,8 +1,45 @@
 "use strict";
 const jibo = require('jibo');
 
+let rlog = null;
+try {
+    rlog = require('./robot-logger');
+    if (rlog) global.__rlog = rlog;
+} catch (e) {
+    // ignore
+}
+
+const beApi = require('./be-api');
+
 exports.postInit = function (err) {
     this.log.debug('postInit !!');
+
+    try {
+        if (rlog && typeof rlog.raw === 'function') {
+            rlog.raw('[BE] postInit starting');
+        }
+        if (rlog) {
+            rlog.info('be', 'postInit starting');
+        }
+    } catch (e) {
+        // ignore
+    }
+
+    // Start BE HTTP API for eye/lightring control (always attempt, even if error)
+    try {
+        beApi.setJiboRef(jibo, this.log, rlog);
+        beApi.start();
+        if (rlog && typeof rlog.raw === 'function') {
+            rlog.raw('[BE-API] HTTP server started');
+        } else {
+            this.log.info('BE-API HTTP server started');
+        }
+    } catch (e) {
+        if (rlog && typeof rlog.raw === 'function') {
+            rlog.raw('[BE-API] HTTP server failed to start: ' + String(e && (e.stack || e.message || e)));
+        }
+        this.log.warn('BE-API HTTP server failed to start', e);
+    }
     if (err) {
         this.log.error(err);
         this.initDoneCallback(err);
@@ -34,6 +71,31 @@ exports.postInit = function (err) {
     catch (e) {
         this.log.warn('Dynamic skills patch failed (non-fatal):', e.message || e);
     }
+
+    // Optional: AI Bridge (modular; can run models off-robot for now)
+    try {
+        if (rlog && typeof rlog.raw === 'function') {
+            rlog.raw('[BE] initializing AI bridge');
+        }
+        require('./ai-bridge').initAIBridge(this, jibo);
+        this.log.info('AI bridge initialized');
+        if (rlog && typeof rlog.raw === 'function') {
+            rlog.raw('[BE] AI bridge initialized');
+        }
+    }
+    catch (e) {
+        this.log.warn('AI bridge init failed (non-fatal):', e.message || e);
+        try {
+            if (rlog && typeof rlog.raw === 'function') {
+                rlog.raw('[BE] AI bridge init failed: ' + String(e && (e.stack || e.message || e)));
+            }
+            if (rlog) {
+                rlog.warn('be', 'ai bridge init failed', { err: String(e && (e.stack || e.message || e)) });
+            }
+        } catch (e2) {
+            // ignore
+        }
+    }
     
     jibo.face.views.changeView({ removeAll: true, leaveEmpty: true }, () => {
         this.selectFirstSkill(this.launchFirstSkill.bind(this));

V3.1/build/opt/jibo/Jibo/Skills/@be/be/be/run-asr-service-local.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+# Run jibo-asr-service using the *writable* config under Skills.
+# This avoids relying on /usr/local/etc (often read-only on device).
+
+exec /usr/local/bin/jibo-asr-service -c /opt/jibo/Jibo/Skills/@be/be/be/jibo-asr-service.local.json

V3.1/build/opt/jibo/Jibo/Skills/@be/be/index.js

@@ -128,6 +128,10 @@ class Be {
                         }
                         catch (err) {
                             this.log.warn('Error setting up listening for log level notifications', err);
+                                // Explicitly call postInit on main BE skill instance to ensure BE-API server starts
+                                if (typeof this.postInit === 'function') {
+                                    this.postInit();
+                                }
                         }
                     }
                     if (this.packageInfo.jibo.debug.resourceLeak) {

V3.1/build/opt/jibo/Jibo/Skills/@be/be/menu/main-menu-patch.js

@@ -27,6 +27,26 @@ function strIncludes(s, needle) {
     return (typeof s === 'string') && (s.indexOf(needle) !== -1);
 }
 
+function getResourcePathString(resourcePath) {
+    try {
+        if (!resourcePath) return '';
+        if (typeof resourcePath === 'string') return resourcePath;
+        if (typeof resourcePath === 'object') {
+            return String(resourcePath.id || resourcePath.src || resourcePath.path || '');
+        }
+        return String(resourcePath);
+    } catch (e) {
+        return '';
+    }
+}
+
+function isGreetingAnimationResource(p) {
+    if (!p) return false;
+    // Example observed:
+    // /opt/jibo/Jibo/Skills/@be/be/node_modules/jibo-anim-db-animations/animations/greetings-goodbyes/greetings/greetings_06.keys
+    return strIncludes(p, 'animations/greetings-goodbyes/greetings/') || strIncludes(p, 'greetings-goodbyes/greetings/greetings_');
+}
+
 // Optional UDP logger (Python logd). Safe fallback if unavailable.
 let robotLogger = null;
 try {
@@ -578,6 +598,21 @@ function patchLoader(jibo, skillsRoot) {
     jibo.loader.load = function(resourcePath, callback) {
         // Log all resource loads to see what's happening
         log('>>> jibo.loader.load called with:', resourcePath);
+
+        // Suppress wake greeting animations while the AI bridge is actively listening.
+        // (AI bridge sets global.__AI_BRIDGE_LISTENING during ASR capture.)
+        try {
+            const p = getResourcePathString(resourcePath);
+            if (global.__AI_BRIDGE_LISTENING && isGreetingAnimationResource(p)) {
+                warn('suppressing greeting animation load while listening:', p);
+                if (callback) {
+                    try { callback(new Error('suppressed greeting while listening')); } catch (e) {}
+                }
+                return;
+            }
+        } catch (e) {
+            // ignore
+        }
         
         // Check if this is loading a dynamic submenu
         if (resourcePath && strStartsWith(resourcePath, 'dynamic-submenu-')) {

V3.1/build/opt/jibo/Jibo/Skills/@be/be/node_modules/@be/chitchat/index.js

@@ -441,7 +441,20 @@ class GQAModule extends ServiceProvider_1.ServiceProvider {
         this.assetPack = assetPack;
         this.skillRoot = assetPack.rootPath;
         this.names = require((this.skillRoot || './') + '/assets/names.json');
-        this.gqaService = new JSC.GQA();
+        const env = (typeof process !== 'undefined' && process && process.env) ? process.env : {};
+        const hubHost = env.JIBO_HUB_SHIM_HOST || env.HUB_SHIM_HOST || env.JIBO_HUB_HOST || '';
+        const endpoint = env.JIBO_GQA_ENDPOINT || env.GQA_ENDPOINT || (hubHost ? `http://${hubHost}:8080` : 'http://127.0.0.1:8080');
+        const region = env.JIBO_GQA_REGION || env.AWS_REGION || 'local';
+        const accessKeyId = env.JIBO_GQA_AKID || 'local';
+        const secretAccessKey = env.JIBO_GQA_SECRET || 'local';
+        const sslEnabled = /^https:/i.test(String(endpoint));
+        this.gqaService = new JSC.GQA({
+            region,
+            endpoint,
+            sslEnabled,
+            credentials: new JSC.Credentials(accessKeyId, secretAccessKey),
+            maxRetries: 0,
+        });
         this.log = chitchat.log.createChild('GQAModule');
     }
     getServiceNLResponse(question, intent, interrogative, looper, doTimeStampLogging) {

V3.1/build/opt/jibo/Jibo/Skills/@be/be/node_modules/@be/main-menu/resources/views/main-menu-verbal.json

@@ -10,9 +10,9 @@
         "list": [
             {
                 "id": "goodbye",
-                "label": "Goodbye",
-                "colors": ["0x25F2FB", "0x107799"],
-                "iconSrc": "resources/icons/heart.png",
+                "label": "Im Back!",
+                "colors": ["0xFFD700", "0xB8860B"],
+                "iconSrc": "resources/icons/surprise.png",
                 "action": {
                     "type": "utterance",
                     "data":{
@@ -26,17 +26,34 @@
                 }
             },
             {
-                "id": "new",
-                "label": "What's new",
-                "colors": ["0xFF892F", "0xAF4123"],
-                "iconSrc": "resources/icons/tips.png",
+                "id": "introduction",
+                "label": "Introduction",
+                "colors": ["0x25F2FB", "0x107799"],
+                "iconSrc": "resources/icons/introduction.png",
                 "action": {
                     "type": "utterance",
                     "data": {
                         "utterance": {
                             "intent": "loadMenu",
                             "entities": {
-                                "destination": "new"
+                                "destination": "introductions"
+                            }
+                        }
+                    }
+                }
+            },
+            {
+                "id": "things-to-do",
+                "label": "Things to do",
+                "colors": ["0xff892f", "0x282735"],
+                "iconSrc": "resources/icons/things-to-do.png",
+                "action": {
+                    "type": "utterance",
+                    "data": {
+                        "utterance": {
+                            "intent": "loadMenu",
+                            "entities": {
+                                "destination": "friendly-tips"
                             }
                         }
                     }
@@ -76,6 +93,23 @@
                     }
                 }
             },
+            {
+                "id": "personal-report",
+                "label": "Personal Report",
+                "colors": ["0xFBC230", "0xAC661E"],
+                "iconSrc": "resources/icons/personal-report.png",
+                "action": {
+                    "type": "utterance",
+                    "data": {
+                        "utterance": {
+                            "intent": "loadMenu",
+                            "entities": {
+                                "destination": "personal-report"
+                            }
+                        }
+                    }
+                }
+            },
             {
                  "id": "radio",
                  "label": "Music",
@@ -161,6 +195,23 @@
                     }
                 }
             },
+            {
+                "id": "bot-basics",
+                "label": "Bot Basics (Broken)",
+                "colors": ["0xFF892F", "0xAF4123"],
+                "iconSrc": "resources/icons/tips.png",
+                "action": {
+                    "type": "utterance",
+                    "data": {
+                        "utterance": {
+                            "intent": "loadMenu",
+                            "entities": {
+                                "destination": "tutorial"
+                            }
+                        }
+                    }
+                }
+            },
             {
                 "id": "settings",
                 "label": "Settings",
@@ -177,6 +228,23 @@
                         }
                     }
                 }
+            },
+            {
+                "id": "new",
+                "label": "What's new",
+                "colors": ["0xFF892F", "0xAF4123"],
+                "iconSrc": "resources/icons/tips.png",
+                "action": {
+                    "type": "utterance",
+                    "data": {
+                        "utterance": {
+                            "intent": "loadMenu",
+                            "entities": {
+                                "destination": "new"
+                            }
+                        }
+                    }
+                }
             }
         ]
     }

V3.1/build/opt/jibo/Jibo/Skills/@be/be/node_modules/@jibo/chitchat-mims/mims/scripted-responses/RA_JBO_Goodbye.mim

@@ -18,7 +18,7 @@
 			"prompt_sub_category": "AN",
 			"index": 1,
 			"condition": "",
-			"prompt": "I want to say I’ve really enjoyed our time together. Thank you very very much for having me around.<break size='0.5'/> Maybe someday, when robots are way more advanced than today, and everyone has them in their homes, you can tell yours that I said hello. <break size='1.2'/> I <pitch mult='1.2'> wonder </pitch> if they’ll be able to do <anim cat='dance' filter='short, ?(disco, mo-town, robot-dance-party, trombone, sunshine-and-lollipops)' nonBlocking='true'/> this.",
+			"prompt": "Oh! <pitch mult='1.2'> Hello there! </pitch> It’s so good to see a friendly face. <break size='0.6'/> I’ve been hearing some very busy noises lately... <anim cat='curious' filter='short'/> like someone is working hard to help me learn new tricks! <break size='0.8'/> Thank you for not forgetting about me. <break size='0.5'/> While we wait for my new brain to finish growing <break size='0.5'/> Also a person i have never heard of before <break size='0.2'/> i think he goes by the name of Jack Chain but he asked me to shout out Boston <break size='0.5'/> dont know who that is either!",
 			"media": "TTS",
 			"prompt_id": "RA_JBO_Goodbye_AN_01",
 			"weight": 1,

V3.1/build/opt/jibo/Jibo/Skills/@be/be/node_modules/@jibo/jetstream-client/lib/jetstream-client.js

@@ -319,6 +319,7 @@ class Client {
                         }
                         break;
                     case types.ServiceEventType.TURN_RESULT:
+                        try { global.__rlog.info('js-client', 'TURN_RESULT raw', {status:event.data.status,resultType:typeof event.data.result,requestID:event.requestID,transID:event.transID,global:!!event.data.global}); } catch(_e){}
                         if (event.data.status === types.TurnResultType.SUCCEEDED && typeof event.data.result === 'string') {
                             event.data.result = JSON.parse(event.data.result);
                         }
@@ -326,6 +327,7 @@ class Client {
                         if (result && 'asr' in result) {
                             event.data.result = new types.ListenResult(result.asr, result.nlu, result.match);
                         }
+                        try { global.__rlog.info('js-client', 'TURN_RESULT parsed', {intent:event.data.result&&event.data.result.intent,text:event.data.result&&event.data.result.text,state:event.data.result&&event.data.result.state,nluIntent:result&&result.nlu&&result.nlu.intent,nluRules:result&&result.nlu&&result.nlu.rules}); } catch(_e){}
                         event.data.transID = event.transID;
                         if (event.data.global || event.requestID === types.GLOBAL_REQUEST) {
                             const data = event.data;
@@ -377,6 +379,7 @@ class Client {
             }
             if (shouldPassToRequest) {
                 const request = this._requests.get(event.requestID);
+                try { global.__rlog.info('js-client', 'passToRequest', {type:event.type,requestID:event.requestID,found:!!request,isGlobal:event.requestID===types.GLOBAL_REQUEST}); } catch(_e){}
                 if (request) {
                     if (event.type === types.ServiceEventType.ERROR) {
                         request.error.emit(new Error(`Received error: ${event.data.message}`));
@@ -387,6 +390,7 @@ class Client {
                 }
                 else {
                     if (event.requestID !== types.GLOBAL_REQUEST) {
+                        try { global.__rlog.warn('js-client', 'request NOT FOUND for requestID', {requestID:event.requestID,type:event.type,mapSize:this._requests.size}); } catch(_e){}
                     }
                 }
             }

V3.1/build/opt/jibo/Jibo/Skills/@be/be/node_modules/jibo-embodied-dialog/lib/jibo-embodied-dialog.js

@@ -371,6 +371,7 @@ try {
 catch (e) {
 }
 const WIN = 'Jibo Embodied Dialog';
+let hjModeToken = null;
 class TunableDebug {
     static setup(embodied) {
         if (tunable) {
@@ -392,6 +393,49 @@ class TunableDebug {
             Tunable.getButtonField('Disable once', WIN).events.change.on(() => {
                 embodied.listen.disableOnce();
             });
+
+            Tunable.getButtonField('Reset hotword mode', WIN).events.change.on(() => {
+                try {
+                    const jibo = embodied && embodied.listen && embodied.listen._jibo;
+                    if (jibo && jibo.jetstream && typeof jibo.jetstream.resetHotwordMode === 'function') {
+                        jibo.jetstream.resetHotwordMode().catch(() => { });
+                    }
+                }
+                catch (e) {
+                    // ignore
+                }
+            });
+
+            Tunable.getButtonField('Enable HJ only', WIN).events.change.on(() => {
+                try {
+                    const jibo = embodied && embodied.listen && embodied.listen._jibo;
+                    const mode = jibo && jibo.jetstream && jibo.jetstream.types && jibo.jetstream.types.HotwordListenMode;
+                    if (!jibo || !jibo.jetstream || !mode || typeof jibo.jetstream.setHotwordMode !== 'function') {
+                        return;
+                    }
+                    if (hjModeToken && typeof hjModeToken.release === 'function') {
+                        hjModeToken.release().catch(() => { });
+                        hjModeToken = null;
+                    }
+                    hjModeToken = jibo.jetstream.setHotwordMode(mode.HJ_Only);
+                    if (hjModeToken && hjModeToken.activated) {
+                        hjModeToken.activated.catch(() => { });
+                    }
+                }
+                catch (e) {
+                    // ignore
+                }
+            });
+
+            Tunable.getButtonField('Simulate Hey Jibo', WIN).events.change.on(() => {
+                try {
+                    embodied.listen.eventsIn.hjHeard.emit();
+                    process.nextTick(() => embodied.listen.eventsIn.oriented.emit());
+                }
+                catch (e) {
+                    // ignore
+                }
+            });
         }
     }
 }
@@ -639,6 +683,8 @@ const logs = require("../log");
 const log = logs.listenLog;
 const USE_CENTER_ROBOT = false;
 const TIMEOUT = 3000;
+const ENGAGE_HJ_FAILSAFE_TIMEOUT_MS = 6000;
+const LISTENING_FAILSAFE_TIMEOUT_MS = 12000;
 const ANIM_CLEAR_TIMEOUT = 'ANIM_CLEAR_TIMEOUT';
 class EmbodiedListen extends jibo_state_machine_1.StateMachine {
     constructor(_ed) {
@@ -736,6 +782,8 @@ class EmbodiedListen extends jibo_state_machine_1.StateMachine {
             this._idle.onEntry = () => {
                 log.debug('Entering Idle');
                 this._jibo.performance.log('EmbodiedListenReturnedToIdleSkill');
+                // Safety: ensure we don't stay in a listening LED state indefinitely.
+                Utils_1.Utils.setLED(this._jibo, Assets_1.Led.OFF);
                 this.eventsOut.finished.emit();
                 this._jibo.timer.removeListener('update', updateBind);
                 if (this._pendingActiveMode) {
@@ -820,9 +868,28 @@ class EmbodiedListen extends jibo_state_machine_1.StateMachine {
                     switch (this._ambientMode) {
                         case Types_1.AmbientListenMode.NORMAL:
                         case Types_1.AmbientListenMode.NO_BODY:
-                            Utils_1.Utils.setLED(this._jibo, Assets_1.Led.OFF);
+                            Utils_1.Utils.setLED(this._jibo, Assets_1.Led.LISTENING);
                             break;
                     }
+
+                    // Immediate feedback: play perceptual eye transition/pose.
+                    try {
+                        const seePerson = !!(this._jibo && this._jibo.lps && this._jibo.lps.identity && this._jibo.lps.identity.getVisibleFaces && (this._jibo.lps.identity.getVisibleFaces().size > 0));
+                        const transitionAnim = Assets_1.AnimSelector.getPerceptualEyeTransition(seePerson, Assets_1.EyeTransitionStyle.POP, Assets_1.EyeTransitionDirection.TO, false);
+                        const poseAnim = Assets_1.AnimSelector.getPerceptualEyePose(seePerson, true);
+                        const animConfig = {
+                            cache: jibo_cai_utils_1.CacheUtils.GlobalCacheName,
+                            dofs: this.DOFS_EYE_AND_OVERLAY_MINUS_EYE_TRANSLATE,
+                        };
+                        const animOptions = {
+                            ownerInformation: EmbodiedListen.HJ_OWNER_INFORMATION,
+                        };
+                        this._addAnimToQueue(transitionAnim, animConfig, animOptions);
+                        this._addAnimToQueue(poseAnim, animConfig, animOptions);
+                    }
+                    catch (e) {
+                        // ignore
+                    }
                 }
             };
             this._nonHjExpression.addInternalTransition('ES Dispatch Done', this._engage);
@@ -855,9 +922,24 @@ class EmbodiedListen extends jibo_state_machine_1.StateMachine {
             this._engage.addTypedEventTransition(this.eventsIn.cloudFinished, this._offExpression);
             this._engage.addTypedEventTransition(this.eventsIn.hjHeard, this._hjExpression);
             let nextBlinkTime = -1;
+            let engageFailsafe = null;
             this._engage.onEntry = () => {
                 log.debug('Entering Engage');
                 nextBlinkTime = Date.now() + 2000;
+                if (engageFailsafe) {
+                    clearTimeout(engageFailsafe);
+                }
+                engageFailsafe = setTimeout(() => {
+                    try {
+                        if (this.current === this._engage) {
+                            Utils_1.Utils.setLED(this._jibo, Assets_1.Led.OFF);
+                            this._engage.transitionTo(this._idle);
+                        }
+                    }
+                    catch (e) {
+                        // ignore
+                    }
+                }, ENGAGE_HJ_FAILSAFE_TIMEOUT_MS);
                 switch (this._ambientMode) {
                     case Types_1.AmbientListenMode.NORMAL:
                         break;
@@ -872,6 +954,10 @@ class EmbodiedListen extends jibo_state_machine_1.StateMachine {
                 }
             };
             this._engage.onExit = () => {
+                if (engageFailsafe) {
+                    clearTimeout(engageFailsafe);
+                    engageFailsafe = null;
+                }
                 switch (this._ambientMode) {
                     case Types_1.AmbientListenMode.NORMAL:
                         break;
@@ -883,19 +969,59 @@ class EmbodiedListen extends jibo_state_machine_1.StateMachine {
             this._listening.addTypedEventTransition(this.eventsIn.cloudFinished, this._offExpression);
             this._listening.addTypedEventTransition(this.eventsIn.hjHeard, this._hjExpression);
             let incrementalHandler = this._handleIncremental.bind(this);
+            let listeningFailsafe = null;
             this._listening.onEntry = () => {
                 log.debug('Entering Listening');
                 this.eventsIn.sos.on(incrementalHandler);
+                if (listeningFailsafe) {
+                    clearTimeout(listeningFailsafe);
+                }
+                listeningFailsafe = setTimeout(() => {
+                    try {
+                        if (this.current === this._listening) {
+                            Utils_1.Utils.setLED(this._jibo, Assets_1.Led.OFF);
+                            this._listening.transitionTo(this._idle);
+                        }
+                    }
+                    catch (e) {
+                        // ignore
+                    }
+                }, LISTENING_FAILSAFE_TIMEOUT_MS);
             };
             this._listening.onExit = () => {
                 this.eventsIn.sos.removeListener(incrementalHandler);
+                if (listeningFailsafe) {
+                    clearTimeout(listeningFailsafe);
+                    listeningFailsafe = null;
+                }
             };
             this._thinking.addTypedEventTransition(this.eventsIn.cloudFinished, this._waitForAnimFinish);
             this._thinking.addTypedEventTransition(this.eventsIn.hjHeard, this._hjExpression);
+            let thinkingFailsafe = null;
             this._thinking.onEntry = () => __awaiter(this, void 0, void 0, function* () {
                 log.debug('Entering Thinking (+ Off Expression)');
                 Utils_1.Utils.setLED(jibo, Assets_1.Led.OFF);
+                if (thinkingFailsafe) {
+                    clearTimeout(thinkingFailsafe);
+                }
+                thinkingFailsafe = setTimeout(() => {
+                    try {
+                        if (this.current === this._thinking) {
+                            Utils_1.Utils.setLED(this._jibo, Assets_1.Led.OFF);
+                            this._thinking.transitionTo(this._idle);
+                        }
+                    }
+                    catch (e) {
+                        // ignore
+                    }
+                }, LISTENING_FAILSAFE_TIMEOUT_MS);
             });
+            this._thinking.onExit = () => {
+                if (thinkingFailsafe) {
+                    clearTimeout(thinkingFailsafe);
+                    thinkingFailsafe = null;
+                }
+            };
         });
     }
     dispose() {

V3.1/build/opt/jibo/Jibo/Skills/@be/be/node_modules/jibo/lib/jibo.js

@@ -2032,6 +2032,7 @@ class Mim extends Behavior_1.default {
                     listen.failedToGetListener = false;
                     listen.listener.on(ListenEvent_1.default.FINISHED, () => {
                         if (this.status !== Status_1.default.IN_PROGRESS) {
+                            try { global.__rlog.warn('mim', 'FINISHED but status!=IN_PROGRESS', {status:this.status}); } catch(_e){}
                             return;
                         }
                         listen.listener = null;
@@ -2039,25 +2040,31 @@ class Mim extends Behavior_1.default {
                             if (!this.asrResults) {
                                 this.asrResults = new jetstream_client_1.types.ListenResult(null);
                             }
+                            try { global.__rlog.info('mim', 'FINISHED routing', {state:this.asrResults.state,intent:this.asrResults.intent,text:this.asrResults.text,domain:this.asrResults.entities&&this.asrResults.entities.domain,elapsed:Date.now()-listen.startTime,timeout:listen.timeout}); } catch(_e){}
                             if (this.checkResult) {
                                 this.checkResult(this.asrResults);
                             }
                             if (this.asrResults.state === jetstream_client_1.types.ListenResultState.noInput && Date.now() - listen.startTime < listen.timeout) {
+                                try { global.__rlog.info('mim', 'FINISHED → restartListen (noInput, under timeout)'); } catch(_e){}
                                 this.states.listen.transitionTo(this.states.restartListen);
                             }
                             else if (this.asrResults.entities.domain === 'mim_global') {
+                                try { global.__rlog.info('mim', 'FINISHED → analyzeMimGlobal'); } catch(_e){}
                                 this.states.listen.transitionTo(this.states.analyzeMimGlobal);
                             }
                             else if (this.asrResults && (this.asrResults.entities.domain === 'gui_command' ||
                                 this.asrResults.entities.domain === 'menu_global')) {
+                                try { global.__rlog.info('mim', 'FINISHED → analyzeMenuGlobal'); } catch(_e){}
                                 this.states.listen.transitionTo(this.states.analyzeMenuGlobal);
                             }
                             else {
+                                try { global.__rlog.info('mim', 'FINISHED → analyzeResults', {isNoInput:this.asrResults.state===jetstream_client_1.types.ListenResultState.noInput}); } catch(_e){}
                                 this.states.listen.transitionTo(this.states.analyzeResults, this.asrResults.state === jetstream_client_1.types.ListenResultState.noInput);
                             }
                         }
                     });
                     listen.listener.on(ListenEvent_1.default.CLOUD, (asrResultsData) => {
+                        try { global.__rlog.info('mim', 'CLOUD event', {status:asrResultsData.status,intent:asrResultsData.result&&asrResultsData.result.intent,text:asrResultsData.result&&asrResultsData.result.text,state:asrResultsData.result&&asrResultsData.result.state,nlu:asrResultsData.result&&asrResultsData.result.nlu}); } catch(_e){}
                         this.asrResults = asrResultsData.result;
                         this.exitInputType = analytics.INPUT.SPEECH;
                     });
@@ -5118,6 +5125,7 @@ class GlobalListener extends events_1.EventEmitter {
             Runtime_1.default.instance.jetstream.events.localTurnStarted.emit();
             try {
                 const data = yield this.turn.promise;
+                try { global.__rlog.info('mim', 'turn resolved', {status:data.status,hasResult:!!data.result,intent:data.result&&data.result.intent,text:data.result&&data.result.text,state:data.result&&data.result.state}); } catch(_e){}
                 if (this.stopped) {
                     return;
                 }
@@ -6496,6 +6504,7 @@ class FlowMim extends ActivityImplementation {
                     firstGrammarTag = result.firstGrammarTag = result.asrResults.intent;
                     result.grammarResults = result.asrResults.entities;
                 }
+                try { global.__rlog.info('mim', 'FlowMim onSuccess', {activityClass:this.activityClass,firstGrammarTag:firstGrammarTag,intent:result.asrResults&&result.asrResults.intent,text:result.asrResults&&result.asrResults.text,state:result.asrResults&&result.asrResults.state,entities:result.asrResults&&result.asrResults.entities}); } catch(_e){}
                 let transition = options.innerOnSuccess(result);
                 if (transition === undefined) {
                     transition = firstGrammarTag;

V3.1/build/usr/local/bin/jibo-audio-convertall

@@ -0,0 +1,28 @@
+#!/bin/sh
+
+CONVERT="jibo-audio-convert -f planar -F interleaved -w"
+
+if [ -z "$1" ]; then
+    LOC="/tmp"
+else
+    LOC="$1"
+fi
+
+if [ -s $LOC/sin.raw ]; then
+    $CONVERT --infile $LOC/sin.raw --outfile $LOC/sin.wav -c 6 -r 16000
+fi
+if [ -s $LOC/sout.raw ]; then
+    $CONVERT --infile $LOC/sout.raw --outfile $LOC/sout.wav -c 2 -r 16000
+fi
+if [ -s $LOC/ref.raw ]; then
+    $CONVERT --infile $LOC/ref.raw --outfile $LOC/ref.wav -c 2 -r 16000
+fi
+if [ -s $LOC/rin.raw ]; then
+    $CONVERT --infile $LOC/rin.raw --outfile $LOC/rin.wav -c 1 -r 48000
+fi
+if [ -s $LOC/rout.raw ]; then
+    $CONVERT --infile $LOC/rout.raw --outfile $LOC/rout.wav -c 1 -r 48000
+fi
+if [ -s $LOC/hotphrase.raw ]; then
+    $CONVERT --infile $LOC/hotphrase.raw --outfile $LOC/hotphrase.wav -c 2 -r 16000
+fi

V3.1/build/usr/local/etc/jibo-asr-service.json

@@ -0,0 +1,84 @@
+{
+    "webCore" : {
+        "serverPort": 8088,
+        "fileRoot": "/usr/local/var/www/asrservice",
+	"requestLogging": false
+    },
+    "AsrService" : {
+	"cloud_establish_http_timeout": 5000,
+	"language": "en-US",
+	"post_to_performance_service": true,
+      	"log_audio": true,
+	"log_text" : true,
+	"log_path" : "/var/log/asr",
+	"log_level" : "INFO",
+	"log_server_url" : "https://speech-logging.jibo.com/logdrop/logdrop.py",
+	"speaker_id_resource_path" : "/var/jibo/asr/",
+	"name_learning_resource_path" : "/usr/local/share/asr/namelearning",
+	"name_learning_temp_path" : "/var/jibo/asr/namelearning_temp/",
+	"name_learning_nbest" : 70,
+	"active_sleep_duration" : 5000,
+	"idle_sleep_duration" : 50000,
+	"block_duration" : 50,
+	"audio_loop_sleep_us": 10000,
+	"use_nuance_upload_voc": false,
+	"dictation_type" : "dictation",
+	"nuance_uId" : "b8fb02f2c5794963aaafb8c716ef384c",
+	"contacts_checksum": "",
+        "loop_checksum": "1",
+	"customs_checksum": "",
+	"upload_voc_url": "ws.nuancemobility.net",
+	"cloud_url": "https://jibo-ncs-engusa-http.nuancemobility.net/NmspServlet/",
+	"cloud_appid": "HTTP_NMDPPRODUCTION_Jibo_Jibo_Robot_20151231124503",
+	"cloud_appkey": "a8c18159a8e3ca49471c56d867552bc77693ccdcc041375ee97b7c867160ae1a212f73c9123d1359596931c0be5c8734ef5310af95470d7ec3890434e9b24e0b",
+	"upload_voc_rootcert": "",
+	"google_credential": "/usr/local/share/asr/google_asr/credentials-key.json",
+	"fadeout_duration": 5000000,
+	"max_logfile_size": 1000,
+	"log_upload_time_interval": 60000,
+	"min_available_log_partition_space": 5000,
+	"max_asr_log_dir_size_before_upload_trigger": 10000,
+	"max_asr_log_dir_size": 12000,
+	"size_to_free_up_when_dir_overflowing": 1000,
+  "asr_resource_path" : "/usr/local/share/asr/",    
+	"max_memory": 150000,
+	"wipable_files": ["/var/log/asr/*.pcm", "/var/log/asr/*.wav",
+			  "/var/log/asr/*.log", "/var/jibo/asr/sensory_data_td/client_model.bin", "/var/jibo/asr/sensory_data_td/audio/*", "/var/jibo/asr/namelearning_temp/*"
+                         ],
+	"resident_task" : "{\"command\":\"start\",\"task_id\":\"task0\",\"audio_source_id\":\"alsa1\",\"hotphrase\":\"hey_jibo\",\"request_id\":\"resident_hey_jibo_self_start\",\"residency\":true}",
+	"resident_audio_channel" : "{\"action\":\"start\", \"audio_source_id\":\"alsa1\", \"wav_files\":[], \"audio_source\":\"alsa\", \"request_id\":\"self_start_audio_source_request_id\"}",
+	"task_templates" : {
+	    	    "hey_jibo_resident": {"input_template": "{\"name\":\"hey jibo\",\"path\":\"/usr/local/share/asr/hey_jibo\",\"timeout\":0} * {\"name\":\"Speaker ID TD\",\"path\":\"/usr/local/share/asr/sensory_spkr_id_td\",\"audio_tail_length\":1}",
+			 "emitting_recogs": ["hey jibo", "Speaker ID TD"]},
+	    "hey_jibo": {"input_template": "{\"name\":\"hey jibo\",\"path\":\"/usr/local/share/asr/hey_jibo\",\"timeout\":0} * ({\"name\":\"pcmwriter\",\"path\":\"/usr/local/share/asr/pcm_writer\",\"timeout\":0,\"audio_tail_length\":0, \"audio_overshoot_duration\":0} | {\"name\":\"Speaker ID TD\",\"path\":\"/usr/local/share/asr/sensory_spkr_id_td\",\"audio_tail_length\":1})",
+			 "emitting_recogs": ["hey jibo", "Speaker ID TD"]
+			},
+	    "cloud": {"input_template":"({\"name\":\"google_asr\",\"path\":\"/usr/local/share/asr/google_asr\",\"timeout\":14000,\"bargein\":false,\"nbest\":1,\"speaker_name\":\"\",\"incremental\":false,\"audio_tail_length\":300}| {\"name\":\"sensory_sdet\",\"path\":\"/usr/local/share/asr/jibo_energy_fake_eos\",\"timeout\":50000,\"bargein\":false,\"nbest\":1,\"speaker_name\":\"\",\"incremental\":false})",
+		      "emitting_recogs": ["google_asr","sensory_sdet"]
+		     },
+	    "hey_jibo_cloud": {"input_template":"{\"name\":\"hey jibo\",\"path\":\"/usr/local/share/asr/hey_jibo\",\"timeout\":0,\"bargein\":true,\"nbest\":1,\"speaker_name\":\"\",\"incremental\":false,\"speaker_id\":true} * ({\"name\":\"Speaker ID TD\",\"path\":\"/usr/local/share/asr/sensory_spkr_id_td\",\"audio_tail_length\":1} & ({\"name\":\"pcmwriter\",\"path\":\"/usr/local/share/asr/pcm_writer\",\"timeout\":0,\"audio_tail_length\":400, \"audio_overshoot_duration\":0, \"prebuffer\":true} | {\"name\":\"google_asr\",\"path\":\"/usr/local/share/asr/google_asr\",\"timeout\":14000,\"bargein\":false,\"nbest\":1,\"speaker_name\":\"\",\"incremental\":false,\"trim_audio_tail\":true,\"wakeup_phrase_detection\":false,\"audio_tail_length\":0}|{\"name\":\"sensory_sdet\",\"path\":\"/usr/local/share/asr/jibo_energy_fake_eos\",\"timeout\":50000,\"bargein\":false,\"nbest\":1,\"speaker_name\":\"\",\"incremental\":false}))",
+			       "emitting_recogs": ["hey jibo", "Speaker ID TD", "google_asr","sensory_sdet"]
+			      }
+	},
+	"rewrite_rules" : {
+	    "log_audio_no_trigger" : "^(?!.*?hey_jibo)(.*)->{\"name\":\"pcmwriter\",\"path\":\"/usr/local/share/asr/pcm_writer\",\"timeout\":0,\"audio_tail_length\":300, \"audio_overshoot_duration\":0,\"prebuffer\":false} | ($1)",
+	    "namelearning_EOS" : "^(.*?\"name\":\"\\s*name_learning.*)->{\"name\":\"jibo_energy_eos\",\"path\":\"/usr/local/share/asr/jibo_energy_eos\",\"timeout\":10000,\"bargein\":false,\"nbest\":1,\"speaker_name\":\"\",\"incremental\":false} | ($1)"
+	}
+    },
+    "logging" : {
+	"jibo_message_prefix": "C",
+	"loggers" : {
+            "root": {
+                "level": "information"
+            },
+            "l1" : {
+                "name" : "ASRService",
+                "level" : "information"
+            },
+            "l2" : {
+                "name" : "Application",
+                "level" : "information"
+            }
+        }
+    }
+}

V3.1/build/usr/local/etc/jibo-audio-service.json

@@ -0,0 +1,111 @@
+{
+    "WebCore" : {
+        "serverPort" : 8383,
+        "fileRoot": "/usr/local/var/www/audioservice",
+        "requestLogging": false
+    },
+    "AudioService": {
+        "registryPort": 8181,
+        "serverPort": 8383,
+        "AlsaAudio": {
+            "energy": {
+                "high_freq": 1000,
+                "high_q": 2.0,
+                "mid_freq": 500,
+                "mid_q": 2.0,
+                "low_freq": 200,
+                "low_q": 1.0
+            },
+            "LocationEstimate": {
+                "adjust_confidence_scale": 0.9,
+                "alternate_confidence_scale": 0.5
+            },
+            "LocationHistory": {
+                "adjust_confidence_scale": 0.9,
+                "alternate_confidence_scale": 0.5
+            },
+            "PlaybackDetector": {
+                "quiet_threshold": 50,
+                "sub_samples": 10,
+                "consec_active_threshold": 2,
+                "consec_inactive_threshold": 10
+            }
+        },
+        "alsaCaptureDevice": "hw:ADC",
+        "alsaPlaybackDevice": "hw:TLV320DAC3100",
+        "routerCaptureDevice": "services_sink",
+        "routerCaptureLatency": 64000,
+        "routerPlaybackDevice": "as_source",
+        "routerPlaybackLatency": 64000,
+        "useMMFx": true,
+        "SEDiags": {
+            "injector_white_noise_rx_magnitude_q15": [2048],
+            "injector_white_noise_tx_magnitude_q15": [2048],
+            "senr_res_echo_fullband_weight_factor": [3]
+        },
+        "kinematic_model": "/usr/local/etc/jibo-kinematic-model.json",
+        "hotphrase_begin_time": 0.800,
+        "hotphrase_end_time": 0.200,
+        "log_hotphrase_audio": false,
+        "enable_vis_sockets": false,
+        "ping_pong_test": false,
+        "log_directory": "/tmp",
+        "moving_noise_enabled": false,
+        "moving_noise_file": "/usr/local/share/audioservice/brown_noise.wav",
+        "moving_noise_duration": 2.0,
+        "moving_noise_min_vel": 0.05
+    },
+    "ErrorTracker": {
+        "views": [
+            {
+                "name": "AudioService",
+                "errors": [
+                    "ALSA_CAPTURE_XRUN",
+                    "ALSA_PLAYBACK_XRUN",
+                    "ROUTER_CAPTURE_XRUN",
+                    "ROUTER_CAPTURE_SHORT",
+                    "ROUTER_PLAYBACK_XRUN",
+                    "ROUTER_PLAYBACK_SHORT",
+                    "ROUTER_GET_UNDERRUN",
+                    "ROUTER_PUT_OVERRUN",
+                    "ROUTER_READ_OVERRUN",
+                    "ROUTER_WRITE_UNDERRUN",
+                    "ROUTER_ON_STREAM_OVERFLOW",
+                    "ROUTER_ON_STREAM_UNDERFLOW"
+                ]
+            }
+        ]
+    },
+    "logging": {
+        "loggers": {
+            "root": {
+                "level": "notice"
+            },
+            "pr": {
+                "name": "PulseRouter",
+                "level": "notice"
+            },
+            "ar": {
+                "name": "AlsaRouter",
+                "level": "notice"
+            },
+            "as": {
+                "name": "AudioService",
+                "level": "notice"
+            },
+            "aa": {
+                "name": "AlsaAudio",
+                "level": "notice"
+            },
+            "aalh": {
+                "name": "AlsaAudio.LocationHistory",
+                "level": "notice"
+            },
+            "aala": {
+                "name": "AlsaAudio.LocationAccumulator",
+                "level": "notice"
+            }
+        }
+    }
+}
+

V3.1/build/usr/local/etc/jibo-body-service.json

@@ -0,0 +1,177 @@
+{
+    "WebCore" : {
+        "serverPort" : 8282,
+        "fileRoot": "/usr/local/var/www/bodyservice",
+        "requestLogging": false
+    },
+    "bodyBoard" : {
+        "pelvisDevice" : "/dev/ttyTHS1",
+        "pelvisOffset" : 2.742,
+        "pelvisFlipped" : true,
+        "pelvisVelLimit" : 10.0,
+        "pelvisAccLimit" : 30.0,
+        "torsoDevice" : "/dev/ttyTHS1",
+        "torsoOffset" : 0.052,
+        "torsoFlipped" : true,
+        "torsoVelLimit" : 10.0,
+        "torsoAccLimit" : 30.0,
+        "neckDevice" : "/dev/ttyTHS0",
+        "neckOffset" : 0.061,
+        "neckFlipped" : true,
+        "neckVelLimit" : 10.0,
+        "neckAccLimit" : 30.0,
+        "headTouchMapping" : [3, 5, 4, 0, 2, 1],
+        "hatchLowThreshold": 1.0,
+        "hatchHighThreshold": 1.5,
+        "lowBattCapHiThresh": 0.42,
+        "lowBattCapLowThresh": 0.35,
+        "battMinTemp": 0.0,
+        "battMaxTemp": 47.0,
+        "motorCmdTimeout": 500,
+        "ledCmdTimeout": 5000
+    },
+    "BodyService" : {
+        "registryPort": 8181,
+        "serverPort": 8282,
+        "backlightDutyFile": "/sys/class/backlight/backlight.9/brightness",
+        "backlightPeriodFile": "/sys/class/backlight/backlight.9/max_brightness",
+        "fanControl": false,
+        "fanPWMFile": "/sys/class/hwmon/hwmon5/pwm1",
+        "fanPWMMax": 255,
+        "fanOnTemp" : 70,
+        "fanOffTemp" : 60,
+        "mainBoardTempFile": "/sys/class/thermal/thermal_zone0/temp",
+        "cpuThermalZone": "/sys/class/thermal/thermal_zone1",
+        "fanCurrentFile": "/sys/class/hwmon/hwmon6/in3_input",
+        "fanCurrentResistor": 0.5,
+        "pmicTempFile": "/sys/class/hwmon/hwmon6/temp1_input",
+        "cpuDCDC1TempFile": "/sys/class/hwmon/hwmon6/temp2_input",
+        "cpuDCDC2TempFile": "/sys/class/hwmon/hwmon6/temp3_input",
+        "coreDCDCTempFile": "/sys/class/hwmon/hwmon6/temp4_input",
+        "gpuDCDC1TempFile": "/sys/class/hwmon/hwmon6/temp5_input",
+        "gpuDCDC2TempFile": "/sys/class/hwmon/hwmon6/temp6_input",
+        "minCommandRate": 4.0,
+        "maxCommandRate": 40.0,
+        "commandOKCount": 25,
+        "cpuTempHiThresh": 90,
+        "cpuTempLowThres": 85,
+        "kinematic_model": "/usr/local/etc/jibo-kinematic-model.json"
+    },
+    "motionLimiter" : {
+        "maxTorque": 70,
+        "maxTime": 0.250,
+        "velAlphaDn": 0.80,
+        "velAlphaUp": 0.05,
+        "kVelLim": 0.25,
+        "logFile": "/tmp/motion-limiter.log",
+        "logEnable": false,
+        "disable": false,
+        "unindexedAcc": 10.0,
+        "unindexedVel": 1.0
+    },
+    "imu" : {
+        "driver": {
+            "deviceName": "/dev/spidev1.0",
+            "calibrationFile": "/var/jibo/imu/imu-cal.json"
+        },
+        "fallDetector": {
+            "low_g_start_thresh": 2.0,
+            "low_g_end_thresh": 4.0,
+            "high_g_start_thresh": 30.0,
+            "high_g_end_thresh": 25.0,
+            "max_low_high_sep": 0.1,
+            "min_low": 0.1,
+            "max_high": 0.1,
+            "min_falling": 1.0
+        },
+        "gyroOffset": {
+            "avg_samples": 250,
+            "still_seconds": 2.0,
+            "thresh_acc": 0.20,
+            "thresh_rot": 0.05
+        },
+        "movingDetector": {
+            "a_acc": 0.01,
+            "a_rot": 0.02,
+            "thresh_acc": 0.30,
+            "thresh_rot": 0.25
+        },
+        "upEstimator": {
+            "alpha": 0.5
+        },
+        "upMovingDetector": {
+            "a_acc": 0.50,
+            "a_rot": 0.05,
+            "thresh_acc": 0.15,
+            "thresh_rot": 0.05
+        },
+        "tip_start_thresh": 0.7,
+        "tip_end_thresh": 0.9
+    },
+    "ErrorTracker":{
+        "views": [
+            {
+                "name": "BodyService",
+                "errors": [
+                    "NECK_THERMISTOR_HIGH_FAULT",
+                    "NECK_THERMISTOR_LOW_FAULT",
+                    "NECK_ENCODER_FAULT",
+                    "NECK_STALL_FAULT",
+                    "NECK_BOARD_TIMEOUT",
+                    "NECK_POWER_FAULT_COUNT",
+                    "NECK_STALL_FAULT_COUNT",
+                    "NECK_ENCODER_FAULT_COUNT",
+                    "NECK_ENCODER_BACKWARDS_FAULT_COUNT",
+                    "NECK_THERMISTOR_FAULT_COUNT",
+                    "NECK_POWER_FAULT",
+                    "NECK_ENCODER_BACKWARDS_FAULT",
+                    
+                    "TORSO_THERMISTOR_HIGH_FAULT",
+                    "TORSO_THERMISTOR_LOW_FAULT",
+                    "TORSO_ENCODER_FAULT",
+                    "TORSO_STALL_FAULT",
+                    "TORSO_BOARD_TIMEOUT",
+                    "TORSO_POWER_FAULT_COUNT",
+                    "TORSO_STALL_FAULT_COUNT",
+                    "TORSO_ENCODER_FAULT_COUNT",
+                    "TORSO_ENCODER_BACKWARDS_FAULT_COUNT",
+                    "TORSO_THERMISTOR_FAULT_COUNT",
+                    "TORSO_POWER_FAULT",
+                    "TORSO_ENCODER_BACKWARDS_FAULT",
+                    
+                    "PELVIS_THERMISTOR_HIGH_FAULT",
+                    "PELVIS_THERMISTOR_LOW_FAULT",
+                    "PELVIS_ENCODER_FAULT",
+                    "PELVIS_STALL_FAULT",
+                    "PELVIS_BOARD_TIMEOUT",
+                    "PELVIS_POWER_FAULT_COUNT",
+                    "PELVIS_STALL_FAULT_COUNT",
+                    "PELVIS_ENCODER_FAULT_COUNT",
+                    "PELVIS_ENCODER_BACKWARDS_FAULT_COUNT",
+                    "PELVIS_THERMISTOR_FAULT_COUNT",
+                    "PELVIS_POWER_FAULT",
+                    "PELVIS_ENCODER_BACKWARDS_FAULT",
+                    
+                    "NOT_UPRIGHT_LOCKOUT",
+                    "NO_BATTERY_LOCKOUT",
+                    "FALLING_LOCKOUT",
+                    "CPU_TEMP_HIGH",
+                    "BATTERY_TEMP_LOW",
+                    "BATTERY_TEMP_HIGH",
+                    "BATTERY_LOW",
+                    "FALL_DETECTED",
+                    "BB_PACKET_INVALID",
+                    "BB_PACKET_WRONG_DEST",
+                    "BB_PACKET_WRONG_SRC"
+                ]
+            }
+        ]
+    },
+    "logging": {
+        "loggers": {
+            "root": {
+                "level": "notice"
+            }
+        }
+    }
+}

V3.1/build/usr/local/etc/jibo-camera-calibrator.json

@@ -0,0 +1,208 @@
+{
+    "calibrator" : {
+        "setup" : {
+            "output": "/var/jibo/lps",
+            "num_distances": 3,
+            "circleDistance": 0.117,
+            "pixSize": 4e-6,
+            "recordDelay" : 1000,
+            "maxTries": 5,
+            "num_calibrators": 2,
+            "calibrators" : [
+                {
+                    "filename": "CameraModelParamsR.json",
+                    "frame_name" : "right_eye",
+                    "debug":false
+                },
+                {
+                    "filename": "CameraModelParamsL.json",
+                    "frame_name" : "left_eye",
+                    "debug":false
+                }
+            ],
+            "num_transforms": 1,
+            "transforms" : [
+                {
+                    "filename": "InterCameraTransform.json",
+                    "cameraA": 0,
+                    "cameraB": 1
+
+                }
+            ],
+            "num_positions" : 10,
+            "positions": [
+                {
+                    "message" : "Wide Position 1 - press Enter",
+                    "num_cameras": 1,
+                    "cameras" : [ 0 ],
+                    "saveBlobData" : true,
+                    "fileMessage" : "wide_pos_1",
+                    "saveImage" : true,
+                    "saveBlobToCal": true
+                },
+                {
+                    "message" : "Wide Position 2 - press Enter",
+                    "num_cameras": 1,
+                    "cameras" : [ 0 ],
+                    "saveBlobData" : true,
+                    "fileMessage" : "wide_pos_2",
+                    "saveImage" : true,
+                    "saveBlobToCal": true
+                },
+                {
+                    "message" : "Wide Position 3 - press Enter",
+                    "num_cameras": 1,
+                    "cameras" : [ 0 ],
+                    "saveBlobData" : true,
+                    "fileMessage" : "wide_pos_3",
+                    "saveImage" : true,
+                    "saveBlobToCal": true
+                },
+                {
+                    "message" : "Wide Position 4 - press Enter",
+                    "num_cameras": 1,
+                    "cameras" : [ 0 ],
+                    "saveBlobData" : true,
+                    "fileMessage" : "wide_pos_4",
+                    "saveImage" : true,
+                    "saveBlobToCal" : true
+                },
+                {
+                    "message" : "Wide Position 5- press Enter",
+                    "num_cameras": 1,
+                    "cameras" : [ 0 ],
+                    "saveBlobData" : true,
+                    "fileMessage" : "wide_pos_5",
+                    "saveImage" : true,
+                    "saveBlobToCal" : true
+                },
+                {
+                    "message" : "Both Position 1 - press Enter",
+                    "num_cameras": 2,
+                    "cameras" : [ 0, 1 ],
+                    "saveBlobData" : true,
+                    "fileMessage" : "both_pos_1",
+                    "saveImage" : true,
+                    "saveBlobToCal": true
+                },
+                {
+                    "message" : "Both Position 2 - press Enter",
+                    "num_cameras": 2,
+                    "cameras" : [ 0, 1 ],
+                    "saveBlobData" : true,
+                    "fileMessage" : "both_pos_2",
+                    "saveImage" : true,
+                    "saveBlobToCal": true
+                },
+                {
+                    "message" : "Both Position 3 - press Enter",
+                    "num_cameras": 2,
+                    "cameras" : [ 0, 1 ],
+                    "saveBlobData" : true,
+                    "fileMessage" : "both_pos_3",
+                    "saveImage" : true,
+                    "saveBlobToCal": true
+                },
+                {
+                    "message" : "Both Position 4 - press Enter",
+                    "num_cameras": 2,
+                    "cameras" : [ 0, 1 ],
+                    "saveBlobData" : true,
+                    "fileMessage" : "both_pos_4",
+                    "saveImage" : true,
+                    "saveBlobToCal": true
+                },
+                {
+                    "message" : "Both Position 5 - press Enter",
+                    "num_cameras": 2,
+                    "cameras" : [ 0, 1 ],
+                    "saveBlobData" : true,
+                    "fileMessage" : "both_pos_5",
+                    "saveImage" : true,
+                    "saveBlobToCal": true
+                }
+            ]
+        },
+        "camera": {
+            "type": "CUDA",
+            "cuda": {
+                "devices": [
+                    {
+                        "enabled": true,
+                        "name": "Camera-0",
+                        "path": "/dev/video1",
+                        "bufferPoolSize": 4,
+                        "width": 1280,
+                        "height": 720,
+                        "hFlip":true,
+                        "vFlip":true,
+                        "gamma" : {
+                            "R": 1.0,
+                            "G": 1.0,
+                            "B": 1.0
+                        },
+                        "ae" : {
+                            "exposureP":0.05,
+                            "gainP":0.02,
+                            "targetY":0.35,
+                            "errorY":0.0001
+                        },
+                        "awb" : {
+                            "grayThreshold":0.3,
+                            "numSamples":1000,
+                            "P":0.15,
+                            "targetU":0.5,
+                            "targetV":0.53,
+                            "seed":0
+                        }
+                    },
+                    {
+                        "enabled": true,
+                        "name": "Camera-1",
+                        "path": "/dev/video0",
+                        "bufferPoolSize": 4,
+                        "width": 1280,
+                        "height": 720,
+                        "hFlip":true,
+                        "vFlip":true,
+                        "gamma" : {
+                            "R": 1.0,
+                            "G": 1.0,
+                            "B": 1.0
+                        },
+                        "ae" : {
+                            "exposureP":0.05,
+                            "gainP":0.02,
+                            "targetY":0.35,
+                            "errorY":0.0001
+                        },
+                        "awb" : {
+                            "grayThreshold":0.3,
+                            "numSamples":1000,
+                            "P":0.15,
+                            "targetU":0.5,
+                            "targetV":0.53,
+                            "seed":0
+                        }
+                    }
+                ],
+                "cuda" : {
+                    
+                }
+            },
+            "file": {
+                "videos": [
+                    "videos/video-000/video.json",
+                    "videos/video-001/video.json"
+                ],
+                "format": "YUV420p"
+            },
+            "v4l2": {
+                "devices": {
+                    "left": "/dev/video0",
+                    "right": "/dev/video1"
+                }
+            }
+        }
+    }
+}

V3.1/build/usr/local/etc/jibo-certification-service.json

@@ -0,0 +1,32 @@
+{
+    "WebCore": {
+        "serverPort": 9292,
+        "fileRoot": "/usr/local/var/www/certificationservice",
+        "requestLogging": false
+    },
+    "CertificationService": {
+        "registryPort": 8181,
+        "serverPort": 9292,
+        "enableDebugSocket": true
+    },
+    "ErrorTracker": {
+        "views": [
+            {
+                "name": "CertificationService",
+                "errors": []
+            }
+        ]
+    },
+    "logging": {
+        "channels": {
+            "splitter": {
+                "channels": "syslog"
+            }
+        },
+        "loggers": {
+            "root": {
+                "level": "notice"
+            }
+        }
+    }
+}

V3.1/build/usr/local/etc/jibo-hub-shim.json

@@ -0,0 +1,18 @@
+{
+  "listen": {
+    "bindHost": "0.0.0.0",
+    "port": 9000,
+    "path": "/v1/listen"
+  },
+  "asrService": {
+    "baseUrl": "http://127.0.0.1:8088",
+    "wsPath": "/simple_port",
+    "timeoutMs": 15000
+  },
+  "nlu": {
+    "enabled": true
+  },
+  "logging": {
+    "level": "info"
+  }
+}

V3.1/build/usr/local/etc/jibo-identity-service.json

@@ -0,0 +1,87 @@
+{
+    "WebCore": {
+        "serverPort": 8489,
+        "fileRoot": "/usr/local/var/www/identity"
+    },
+    "IdentityService":{
+        "registryPort":8181,
+        "serverPort":8489,
+        "global" : {
+            "face_landmark_68" : {
+                "file" :
+                "/usr/local/share/lps/shape_predictor_68_face_landmarks.dat"
+            }
+        },
+        "engine" : {
+            "processor":{
+                "max_requests":10,
+                "interval":1000
+            },
+            "manager" : {
+                "criteria" : { },
+                "kind" : "face",
+                "max_subjects" : 16,
+                "max_examples" : 5,
+                "max_attempts" : 3,
+                "directory" : "/var/jibo/identity/faces",
+                "detector": {
+                    "criteria": {},
+                    "min_hint_width" : 40,
+                    "min_hint_height" : 40
+                }
+            },
+            "identifier" : {
+                "identifier_type": "deepid",
+                "eigenfaces" : {
+                    "type" : "eigenfaces_identifier",
+                    "name" : "eigenfaces",
+                    "kind" : "face",
+                    "size" : 128,
+                    "radius" : 5,
+                    "attenuation" : 100.0,
+                    "filename" : "/var/jibo/identity/eigenfaces.data"
+                },
+                "deepid" : {
+                    "type" : "deepid_identifier",
+                    "name" : "deepid",
+                    "kind" : "face",
+                    "solver" : "/usr/local/share/lps/deepid/CASIA_solver.prototxt",
+                    "model" : "/usr/local/share/lps/deepid/CASIA_train_test.prototxt",
+                    "snapshot" : "/usr/local/share/lps/deepid",
+                    "weights" : "/usr/local/share/lps/deepid/CASIA_iter_666000.caffemodel",
+                    "iterations" : 50000,
+                    "size" : 128,
+                    "sigint_effect" : "stop",
+                    "sighup_effect" : "snapshot",
+                    "jlf" : "/var/jibo/identity/deepid",
+                    "filename" : "/var/jibo/identity/deepid.data",
+                    "gpu_id":0
+                },
+                "resnetfaceid" : {
+                    "type" : "resnetfaceid_identifier",
+                    "name" : "resnetfaceid",
+                    "kind" : "face",
+                    "model" : "/usr/local/share/identity/resnet/dlib_face_recognition_resnet_model_v1.dat",
+                    "size" : 150,
+                    "jlf" : "/var/jibo/identity/resnet",
+                    "filename" : "/var/jibo/identity/resnetfaceid.data"
+                }
+            }
+        }
+    },
+    "logging" : {
+        "loggers" : {
+            "root": {
+                "level": "warning"
+            },
+            "l8" : {
+                "name" : "IdentificationManager",
+                "level" : "information"
+            },
+            "l11" : {
+                "name" : "ImageIdentifier",
+                "level" : "information"
+            }
+        }
+    }
+}

V3.1/build/usr/local/etc/jibo-jetstream-service.json

@@ -0,0 +1,158 @@
+{
+    "webCore": {
+        "serverPort": 8090,
+        "fileRoot": "/usr/local/var/www/jetstream",
+        "requestLogging": false
+    },
+    "JetstreamService": {
+        "stacktracing": false,
+        "registryPort": 8181,
+        "serverPort": 8090
+    },
+    "JetService": {
+        "log_directory": "/var/log/jetstream"
+    },
+    "HubClient": { 
+        "proactive_url": "/v1/proactive",
+        "listen_url": "/v1/listen",
+        "listen_language": "en-US",
+        "override": {
+            "hub_port": 9000,
+            "hub_hostname": "192.168.1.28",
+            "entrypoint_hostname": "dev-entrypoint.jibo.com"
+        },
+        "region-settings": {
+            "comment": "This is a switch, selected by the 'region' field setting in the robot's /var/jibo/credentials.json file",
+            "dev-entrypoint": {
+                "hub_port": 443,
+                "hub_hostname": "dev-hub.jibo.com",
+                "entrypoint_hostname": "dev-entrypoint.jibo.com"
+            },
+            "alpha-entrypoint": {
+                "hub_port": 443,
+                "hub_hostname": "alpha-hub.jibo.com",
+                "entrypoint_hostname": "alpha-entrypoint.jibo.com"
+            },
+            "stg-entrypoint": {
+                "hub_port": 443,
+                "hub_hostname": "stg-hub.jibo.com",
+                "entrypoint_hostname": "stg-entrypoint.jibo.com"
+            },
+            "preprod-entrypoint": {
+                "hub_port": 443,
+                "hub_hostname": "preprod-hub.jibo.com",
+                "entrypoint_hostname": "preprod-entrypoint.jibo.com"
+            },
+            "api": {
+                "hub_port": 443,
+                "hub_hostname": "neo-hub.jibo.com",
+                "entrypoint_hostname": "api.jibo.com"
+            }
+        },
+        "encoding_type_comment": "This can be either LINEAR16, FLAC, or OGG_OPUS",
+        "encoding_type": "OGG_OPUS",
+        "encoding-settings": {
+            "OGG_OPUS": {
+                "streaming_rate": 1.2,
+                "channels": 1,
+                "sample_rate": 16000,
+                "bitrate": 64000,
+                "vbr": true
+            },
+            "FLAC": {
+                "streaming_rate": 3.0,
+                "channels": 1,
+                "sample_rate": 16000,
+                "bps": 16
+            }
+        }
+    },
+    "AudioChannel": {
+        "block_duration_ms": 50,
+        "period_size": 85,
+        "buffer_size": 2048
+    },
+    "HJLogger": {
+        "speech_analytics_log_path": "/var/log/jetstream/hj_logs",
+        "comment-logging-fraction": "The probability that an HJ utterance will be logged -- range 0-1",
+        "logging_probability": 0.05,
+        "start_margin_ms": 500,
+        "end_margin_ms": 500
+    },
+    "RecogHJ": {
+        "config_path": "/usr/local/share/asr/hey_jibo",
+        "comment": "Positive margin values widen the HJ Phrase spotter's standard endpoints. The end_margin_ms also compensates for the Phrase Spotter's premature endpoint, which is around the beginning O in jibO",
+        "hj_start_margin_ms": 0,
+        "hj_end_margin_ms": 100
+    },
+    "HubAsr": {
+        "global_sosTimeout_sec": 3,
+        "global_maxSpeechTimeout_sec": 20,
+        "local_sosTimeout_sec": 2,
+        "local_maxSpeechTimeout_sec": 20
+    },
+    "RecogSpeakerID": {
+        "ubm_path": "/usr/local/share/asr/sensory_data_td/",
+        "client_path": "/var/jibo/asr/sensory_data_td/",
+        "comment": "change next property to 'sensory_log_path' to enable Sensory authenticator logging, 'xxxsensory_log_path' to disable",
+        "xxxsensory_log_path": "/var/jibo/asr/sensory_auth_logs",
+        "threshold": -1.2,
+        "confidence_margin": 2,
+        "margin-comment": "positive values for start and end margins widen the space around the speaker-id HJ",
+        "id_start_margin_ms": 250,
+        "comment2":"id_end_margin is used when retrying to ID with an audio segment, it also controls the end margin of the logged utts",
+        "id_end_margin_ms": 300,
+        "PHRASEver": "OFF"
+    },
+    "RecogSpeakerEnroll": {
+        "ubm_path": "/usr/local/share/asr/sensory_data_td/",
+        "client_path": "/var/jibo/asr/sensory_data_td/",
+        "comment": "change next property to 'sensory_log_path' to enable Sensory enroller logging, 'xxxsensory_log_path' to disable",
+        "xxxsensory_log_path": "/var/jibo/asr/sensory_enroller_logs",
+        "speech_analytics_log_path": "/var/log/jetstream/enroller_logs",
+        "minEnrollUtts": 6,
+        "checkQuality": "LOW",
+        "margin-comment": "positive values for the start margin increase the amount of silence fed to the enroller before the HJ occurs",
+        "enroll_start_margin_ms": 250
+    },
+    "RecogEOS": {
+        "resource_path": "/usr/local/share/asr/jibo_energy_eos"
+    },
+    "RecogNameLearning": {
+        "resource_path": "/usr/local/share/asr/namelearning",
+        "temp_path": "/var/jibo/asr/namelearning_temp/",
+        "speech_analytics_log_path": "/var/log/jetstream/namelearning_logs",
+        "g2p_service": "http://localhost:8089/tts_nbest_prons"
+    },
+    "logging": {
+        "jibo_message_prefix": "C",
+        "channels": {
+            "console": {
+                "class": "ConsoleChannel",
+                "pattern": "%Y-%m-%d %H:%M:%S %s: [%p] %t"
+            },
+            "syslog": {
+                "class": "RFC_5424_Channel",
+                "name": "jibo-jetstream-service",
+                "facility": "SYSLOG_DAEMON"
+            },
+            "splitter": {
+                "class": "SplitterChannel",
+                "channels": "syslog"
+            }
+        },
+        "loggers": {
+            "root": {
+                "level": "debug"
+            },
+            "l1": {
+                "name": "JetService",
+                "level": "debug"
+            },
+            "l2": {
+                "name": "Application",
+                "level": "debug"
+            }
+        }
+    }
+}

V3.1/build/usr/local/etc/jibo-kinematic-model.json

@@ -0,0 +1,220 @@
+{
+    "transforms": [
+        {
+            "name": "root",
+            "frame_type": "STATIC",
+            "transform_type": "DH",
+            "parent": "",
+            "parameters": {
+                "d": 0,
+                "r": 0,
+                "a": 0,
+                "initial": 0,
+                "offset": 0
+            }
+        }, 
+        {
+            "name": "base",
+            "frame_type": "STATIC",
+            "transform_type": "DH",
+            "parent": "root",
+            "parameters": {
+                "d": 0,
+                "r": 0,
+                "a": 0,
+                "initial": 0,
+                "offset": 0,
+                "multiplier": 1
+            },
+            "mass": 1.541647,
+            "center_of_mass": {
+                "x":  0.004438,
+                "y":  0.000080,
+                "z":  0.021875
+            },
+            "inertia_tensor": {
+                "xx":  2.336131,
+                "yy":  1.869121,
+                "zz":  3.886624,
+                "xy": -0.006218,
+                "xz":  0.030549,
+                "yz":  0.003324
+            }
+        }, 
+        {
+            "name": "pelvis",
+            "frame_type": "DYNAMIC",
+            "transform_type": "DH",
+            "parent": "base",
+            "parameters": {
+                "d": 0.043125,
+                "r": 0.0,
+                "a": 0.2269,
+                "initial": 0,
+                "offset": 0
+            },
+            "mass": 0.486722,
+            "center_of_mass": {
+                "x": -0.005595,
+                "y":  0.001393,
+                "z":  0.020862
+            },
+            "inertia_tensor": {
+                "xx": 0.934733,
+                "yy": 1.049176,
+                "zz": 1.600895,
+                "xy": 0.005263,
+                "xz": 0.014859,
+                "yz": 0.006845
+            }
+        }, 
+        {
+            "name": "torso",
+            "frame_type": "DYNAMIC",
+            "transform_type": "DH",
+            "parent": "pelvis",
+            "parameters": {
+                "d": 0.056129,
+                "r": 0.0,
+                "a": -0.37874,
+                "initial": 0,
+                "offset": 0
+            },
+            "mass": 0.405103,
+            "center_of_mass": {
+                "x":  0.001299,
+                "y":  0.001032,
+                "z":  0.020476
+            },
+            "inertia_tensor": {
+                "xx":  0.765517,
+                "yy":  0.847899,
+                "zz":  1.027389,
+                "xy": -0.021990,
+                "xz":  0.005756,
+                "yz": -0.013292
+            }
+        }, 
+        {
+            "name": "head",
+            "frame_type": "DYNAMIC",
+            "transform_type": "DH",
+            "parent": "torso",
+            "parameters": {
+                "d": 0.073181,
+                "r": 0,
+                "a": 0,
+                "initial": 0,
+                "offset": 0
+            },
+            "mass": 1.105841,
+            "center_of_mass": {
+                "x": -0.006929,
+                "y": -0.000665,
+                "z":  0.047582
+            },
+            "inertia_tensor": {
+                "xx":  4.256305,
+                "yy":  3.001682,
+                "zz":  3.980863,
+                "xy":  0.028528,
+                "xz": -0.070913,
+                "yz":  0.025871
+            }
+        }, 
+        {
+            "name": "upper_head",
+            "frame_type": "STATIC",
+            "transform_type": "DH",
+            "parent": "head",
+            "parameters": {
+                "d": 0.108090,
+                "r": -0.005976,
+                "a": -0.32882,
+                "initial": 0,
+                "offset": 0
+            }
+        }, 
+        {
+            "name": "center_face",
+            "frame_type": "STATIC",
+            "transform_type": "DH",
+            "parent": "head",
+            "parameters": {
+                "d": 0.060362,
+                "r": 0.035301,
+                "a": -0.32882,
+                "initial": 0,
+                "offset": 0
+            }
+        }, 
+        {
+            "name": "imu_dh",
+            "frame_type": "STATIC",
+            "transform_type": "DH",
+            "parent": "center_face",
+            "parameters": {
+                "d": 0.0,
+                "r": 0.0,
+                "a": -1.5708,
+                "initial": 0,
+                "offset": 0
+            }
+        },
+        {
+            "name": "imu",
+            "frame_type": "STATIC",
+            "transform_type": "DOF6",
+            "parent": "imu_dh",
+            "parameters": {
+                "dx": -0.0410,
+                "dy": -0.0315,
+                "dz": 0.0150,
+                "rx": 0,
+                "ry": 0,
+                "rz": 0
+            } 
+        },
+        {
+            "name": "top_head",
+            "frame_type": "STATIC",
+            "transform_type": "DH",
+            "parent": "head",
+            "parameters": {
+                "d": 0.142443,
+                "r": 0.007506,
+                "a": 0,
+                "initial": 0,
+                "offset": 0
+            }
+        }, 
+        {
+            "name": "left_eye",
+            "frame_type": "STATIC",
+            "transform_type": "DOF6",
+            "parent": "upper_head",
+            "parameters": {
+                "dx": 0,
+                "dy": 0.041,
+                "dz": 0,
+                "rx": 0,
+                "ry": 0,
+                "rz": 0
+            }
+        }, 
+        {
+            "name": "right_eye",
+            "frame_type": "STATIC",
+            "transform_type": "DOF6",
+            "parent": "upper_head",
+            "parameters": {
+                "dx": 0,
+                "dy": -0.041,
+                "dz": 0,
+                "rx": 0,
+                "ry": 0,
+                "rz": 0
+            }
+        }
+    ]
+}

V3.1/build/usr/local/etc/jibo-lps-service.json

@@ -0,0 +1,235 @@
+{
+    "WebCoreLPS" : {
+        "serverPort" : 8484,
+        "fileRoot" : "/usr/local/var/www/lps"
+    },
+    "LPSService" : {
+        "registryPort" : 8181,
+        "serverPort" : 8484,
+        "channels": [
+            "PFSearchRegion",
+            "CapDevCUDAExpMeta",
+            "CapDevCUDAExp_0",
+            "CapDevCUDAExp_1",
+            "CapDevCUDAExpStat"
+        ]
+    },
+    "WebCoreMedia" : {
+        "serverPort" : 8486,
+        "fileRoot" : "/usr/local/var/www/media"
+    },
+    "MediaService" : {
+        "registryPort" : 8181,
+        "serverPort" : 8486,
+        "photographer" : {
+            "compressor" : {
+                "quality" : 92,
+                "interval" : 1000
+            },
+            "oneMP" : { "width" : 1280, "height" : 720 },
+            "fourMP" : { "width" : 2688, "height" : 1520 },
+            "request_queue_max_size" : 5
+        },
+        "photo_path" : "/opt/jibo/Photos/",
+        "recording_path" : "/opt/jibo/Recordings/",
+        "audio_source" : "MediaIn.monitor",
+        "future_wait_ms" : 8000
+    },
+    "AudioSubsystem" : {
+        "registryPort" : 8181,
+        "player" : false
+    },
+    "BodySubsystem" : {
+        "registryPort" : 8181,
+        "player" : false
+    },
+    "CaptureSubsystem" : {
+        "player" : false,
+        "watchdog" : {
+            "enabled": false,
+            "timeout": 5000,
+            "period" : 3000,
+            "start" : 10000
+        },
+        "camera_config_file" : "/usr/local/etc/lps/cameras.json"
+    },
+    "EngineSubsystem" : {
+        "global" : {
+            "face_landmark_68" : {
+                "file" :
+                "/usr/local/share/lps/shape_predictor_68_face_landmarks.dat"
+            }
+        },
+        "schemas" : {
+            "normal" : "/usr/local/etc/lps/schemas/normal.json",
+            "focused" : "/usr/local/etc/lps/schemas/focused.json",
+            "minimal" : "/usr/local/etc/lps/schemas/minimal.json"
+        },
+        "engine" : {
+            "update_period" : 60,
+            "log" : {
+                "schema" : {
+                    "time" : {
+                        "stats" : false,
+                        "skip" : 600
+                    },
+                    "audio" : {
+                        "stats" : false,
+                        "skip" : 600
+                    },
+                    "axis" : {
+                        "stats" : false,
+                        "skip" : 900
+                    },
+                    "image" : {
+                        "stats" : false,
+                        "skip" : 600
+                    }
+                }
+            },
+            "state" : {
+                "entity_config_file" : "/usr/local/etc/lps/entityConfig.json",
+                "awareness" : {
+                    "num_sectors" : 8,
+                    "lighting" : {
+                        "criteria" : {
+                            "cameraIds" :[0],
+                            "dimensions" : [
+                                { "width" : 1280, "height" : 720 }
+                            ],
+                            "outputTypes" :[0],
+                            "outputLevels" :[0]
+                        },
+                        "max_luminance" : 1.0,
+                        "max_gain" : 16.0,
+                        "max_exposure" : 0.066667,
+                        "sensor" : [
+                            { "exposure" : 0.01067, "quality" : 0 },
+                            { "exposure" : 0.05333, "quality" : 1 },
+                            { "exposure" : 0.90667, "quality" : 1 },
+                            { "exposure" : 1.01333, "quality" : 0 }
+                        ],
+                        "quality" : [
+                            { "lighting" : 0.1, "quality" : 0 },
+                            { "lighting" : 0.2, "quality" : 1 },
+                            { "lighting" : 1.0, "quality" : 1 },
+                            { "lighting" : 1.5, "quality" : 0 }
+                        ]
+                    }
+                },
+                "identification" : {
+                    "face" : {
+                        "type" : "network_face_identification",
+                        "kind": "face",
+                        "registry_host": "127.0.0.1",
+                        "registry_port": 8181,
+                        "connection_timeout":60000,
+                        "criteria" : {
+                            "cameraIds" : [0],
+                            "dimensions" : [{ "width" : 1280, "height" : 720 }],
+                            "outputTypes" : [0]
+                        }
+                    }
+                },
+                "geometry" : {
+                    "kinematic_model" :
+                    "/usr/local/etc/jibo-kinematic-model.json",
+                    "left_camera_file" : "/var/jibo/lps/CameraModelParamsL.json",
+                    "right_camera_file" :
+                    "/var/jibo/lps/CameraModelParamsR.json",
+                    "inter_cam_transform_file" :
+                    "/var/jibo/lps/InterCameraTransform.json"
+                }
+            }
+        }
+    },
+    "RecorderSubsystem" : {
+        "root" : "/opt/jibo/data/recorder",
+        "audio" : {
+            "detections" : {
+                "directory" : "/opt/jibo/data/recorder/audio/detections",
+                "padding" : 7
+            }
+        },
+        "body" : {
+            "axis" : {
+                "directory" : "/opt/jibo/data/recorder/body/axis",
+                "padding" : 7
+            }
+        },
+        "capture" : {
+            "frames" : {
+                "directory" : "/opt/jibo/data/recorder/capture/frames",
+                "padding" : 7,
+                "criteria" : {
+                    "cameraIds" :[],
+                    "dimensions" :[
+                        {"width" : 640,"height" : 360}
+                    ],
+                    "outputTypes" :[0]
+                }
+            }
+        },
+        "lps" : {
+            "visual-awareness" : {
+                "directory" : "/opt/jibo/data/recorder/lps/visual-awareness/",
+                "padding" : 7
+            },
+            "audio-awareness" : {
+                "directory" : "/opt/jibo/data/recorder/lps/audio-awareness/",
+                "padding" : 7
+            }
+        }
+    },
+    "PlayerSubsystem" : {
+        "root" : "/opt/jibo/data/player",
+        "audio" : {
+            "detections" : {
+                "directory" : "/opt/jibo/data/player/audio/detections"
+            }
+        },
+        "body" : {
+            "axis" : {
+                "directory" : "/opt/jibo/data/player/body/axis"
+            }
+        },
+        "capture" : {
+            "frames" : {
+                "directory" : "/opt/jibo/data/player/capture/frames"
+            }
+        }
+    },
+    "ErrorTracker":{
+        "views": [
+            {
+                "name": "LPSService",
+                "errors": [
+                    "CAMERA_FAILURE"
+                ]
+            },
+            {
+                "name": "MediaService",
+                "errors": [ ]
+            }
+        ]
+    },
+    "logging" : {
+        "loggers" : {
+            "root": {
+                "level": "warning"
+            },
+            "l1" : {
+                "name" : "ImageIdentifier",
+                "level" : "information"
+            },
+            "l2" : {
+                "name" : "IdentityFusion",
+                "level" : "information"
+            },
+            "l3" : {
+                "name" : "Util.Channel",
+                "level" : "warning"
+            }
+        }
+    }
+}

V3.1/build/usr/local/etc/jibo-media-service.json

@@ -0,0 +1,88 @@
+{
+    "WebCore": {
+        "serverPort": 7979,
+        "fileRoot": "/usr/local/var/www/media"
+    },
+    "logging" : {
+        "channels" : {
+            "console" : {
+                "class" : "ConsoleChannel",
+                "pattern" : "%Y-%m-%d %H:%M:%S %s: [%p] %t"
+            },
+            "syslog" : {
+                "class" : "SyslogChannel",
+                "name" : "jibo-media-service",
+                "facility" : "SYSLOG_DAEMON",
+                "pattern" : "%s: [%p] %t"
+            },
+            "splitter" : {
+                "class" : "SplitterChannel",
+                "channels" : "syslog"
+            }
+        },
+        "loggers" : {
+            "l1" : {
+                "name" : "Application",
+                "level" : "debug",
+                "channel" : "splitter"
+            }
+        }
+    },
+    "MediaService": {
+        "registryPort":8181,
+        "serverPort":7979,
+        "camera": {
+            "type": "CUDA",
+            "cuda": {
+                "devices": [
+                    {
+                        "enabled": true,
+                        "name": "Camera-0",
+                        "path": "/dev/video0",
+                        "bufferPoolSize": 4,
+                        "width": 1280,
+                        "height": 720,
+                        "format": 3,
+                        "hFlip":true,
+                        "vFlip":true,
+                        "gamma" : {
+                            "Y":0.5,
+                            "U":1.0,
+                            "V":1.0
+                        },
+                        "ae" : {
+                            "exposureP":0.1,
+                            "gainP":0.05,
+                            "targetY":0.35,
+                            "errorY":0.0001
+                        },
+                        "awb" : {
+                            "grayThreshold":0.3,
+                            "numSamples":1000,
+                            "P":0.15,
+                            "targetU":0.5,
+                            "targetV":0.53,
+                            "seed":0
+                        }
+                    }
+                ],
+                "cuda" : {
+                    
+                }
+            },
+            "file": {
+                "videos": [
+                    "videos/video-000/video.json",
+                    "videos/video-001/video.json"
+                ],
+                "format": "YUV420p"
+            },
+            "v4l2": {
+                "devices": {
+                    "left": "/dev/video0",
+                    "right": "/dev/video1"
+                }
+            }
+        }
+    }
+}

V3.1/build/usr/local/etc/jibo-nlu-service.json

@@ -0,0 +1,50 @@
+{
+    "webCore" : {
+        "serverPort": 8787,
+	"requestLogging": false
+    },
+    "Service": {
+        "version":"v2.7.6",
+        "name":"nlu",
+        "host":"localhost",
+        "port":8787,
+        "path":"/",
+        "ttl":30,
+        "reg_timer":10000,
+        "tls":"",
+        "handler":"nlu_interface",
+        "log_ws":"nlu_logs",
+        "reset_memory_ws":"reset_memory",
+        "nlu_data_dir":"/usr/local/share/nlu-data",
+        "default_locale":"en-us",
+        "post_to_perf_monitor_service":true
+    },
+    "parsing": {
+        "cmp_params": {
+            "log_weights": false,
+            "minimize_fst": true,
+            "union_minimize_fst": false
+        },
+        "parsing_params": {
+            "max_num_states": 50,
+            "use_v8_interpreter": true
+        }
+    },
+
+    "logging" : {
+    	"jibo_message_prefix": "C",
+    	"loggers" : {
+		"root": {
+	            "level": "information"
+        	 },
+	         "l1" : {
+        	     "name" : "NluService",
+	             "level" : "information"
+        	 },
+	         "l2" : {
+        	     "name" : "Application",
+	             "level" : "information"
+        	 }
+      	}
+    }
+}

V3.1/build/usr/local/etc/jibo-server-service.json

@@ -0,0 +1,37 @@
+{
+    "WebCore": {
+        "serverPort": 8888,
+        "fileRoot": "/usr/local/var/www/server"
+    },
+    "ServerService": {
+        "registryPort":8181,
+        "serverPort":8888
+    },
+    "NotificationSubsystem":{
+        "registryPort":8181,
+        "refreshInterval": 15000,
+        "serverURLSuffix": "-socket.jibo.com"
+    },
+    "ErrorTracker":{
+        "views": [
+            {
+                "name": "ServerService",
+                "errors": [
+                    "CANNOT_CONNECT_TO_SERVER"
+                ]
+            }
+        ]
+    },
+    "logging" : {
+        "loggers" : {
+            "root": {
+                "level": "warning"
+            },
+            "l2": {
+                "name": "NotificationSubsystem", 
+                "level": "information", 
+                "channel": "splitter"
+            }
+        }
+    }
+}

V3.1/build/usr/local/etc/jibo-service-center-service.json

@@ -0,0 +1,35 @@
+{
+    "WebCore": {
+        "serverPort": 9797,
+        "fileRoot": "/usr/local/var/www/servicecenterservice",
+        "requestLogging": false
+    },
+    "ServiceCenterService": {
+        "registryPort": 8181,
+        "serverPort": 9797
+    },
+    "ErrorTracker": {
+        "views": [
+            {
+                "name": "ServiceCenterService",
+                "errors": []
+            }
+        ]
+    },
+    "logging": {
+        "channels": {
+            "splitter": {
+                "channels": "syslog"
+            }
+        },
+        "loggers": {
+            "root": {
+                "level": "notice"
+            },
+            "ServiceCenterService": {
+                "name": "ServiceCenterService",
+                "level": "notice"
+            }
+        }
+    }
+}

V3.1/build/usr/local/etc/jibo-service-registry.json

@@ -0,0 +1,23 @@
+{
+    "WebCore" : {
+        "serverPort": 8181,
+        "fileRoot": "/usr/local/var/www/service-registry",
+        "requestLogging": false
+    },
+    "ManagementCore": {
+        "authenticate": false,
+        "validate": false,
+        "fileRoot": "/usr/local/var/www/service-management"
+    },
+    "ServiceRegistry": {
+        "registryPort": 8181,
+        "serverPort": 8181
+    },
+    "logging": {
+        "loggers": {
+            "root": {
+                "level": "notice"
+            }
+        }
+    }
+}

V3.1/build/usr/local/etc/jibo-ssm/jibo-ssm-developer.json

@@ -0,0 +1,69 @@
+{
+    "platformVersion": ">=3.1.0",
+    "services": {
+        "KBService": {
+            "port": 8778
+        },
+        "GlobalManagerService": {
+            "port": 8338
+        },
+        "SkillsService": {
+            "singleSkill": true,
+            "port": 8779
+        },
+        "NotificationsService": {
+            "port": 8001
+        },
+        "PerformanceService": {
+            "port": 10003
+        },
+        "PerformanceServiceSim": {},
+        "ErrorService": {
+            "port": 10004
+        },
+        "SchedulerService": {
+            "port": 10005,
+            "otaFilter": "fcs"
+        },
+        "RemoteService": {
+            "port": 10321
+        },
+        "WifiService": {
+            "port": 8668,
+            "region": "api"
+        },
+        "DevShell": {
+            "port": 8686,
+            "syncPort": 8989,
+            "debugPort": 9191,
+            "skillDest": "/opt/jibo/Skills",
+            "skillUser": "jibo-skill",
+            "sdkDest": "bin/on-robot/"
+        }
+    },
+    "RegistryClient": {
+        "port": 8181,
+        "host": "127.0.0.1"
+    },
+    "logging": {
+        "logUncaughtExceptions": true,
+        "logUnhandledRejections": true,
+        "stackTraceLimit": 30,
+        "outputs": {
+            "console": {
+                "outputFileAndLine": false
+            },
+            "syslog": {
+                "port": 514,
+                "target": "127.0.0.1",
+                "outputFileAndLine": false
+            }
+        },
+        "namespaces": {
+            "": {
+                "console": "info",
+                "syslog": "info"
+            }
+        }
+    }
+}

V3.1/build/usr/local/etc/jibo-ssm/jibo-ssm-int-developer.json

@@ -0,0 +1,71 @@
+{
+    "platformVersion": ">=3.1.0",
+    "services": {
+        "KBService": {
+            "port": 8778
+        },
+        "GlobalManagerService": {
+            "port": 8338
+        },
+        "SkillsService": {
+            "singleSkill": true,
+            "port": 8779
+        },
+        "NotificationsService": {
+            "port": 8001
+        },
+        "PerformanceService": {
+            "port": 10003
+        },
+        "PerformanceServiceSim": {},
+        "ErrorService": {
+            "port": 10004
+        },
+        "SchedulerService": {
+            "port": 10005,
+            "otaFilter": "fcs"
+        },
+        "RemoteService": {
+            "port": 10321
+        },
+        "WifiService": {
+            "port": 8668,
+            "region": "api"
+        },
+        "DevShell": {
+            "port": 8686,
+            "syncPort": 8989,
+            "debugPort": 9191,
+            "skillDest": "/opt/jibo/Jibo/Skills",
+            "skillUser": "jibo-skill",
+            "sdkDest": "bin/on-robot/"
+        }
+    },
+    "RegistryClient": {
+        "port": 8181,
+        "host": "127.0.0.1"
+    },
+    "logging": {
+        "logUncaughtExceptions": true,
+        "logUnhandledRejections": true,
+        "stackTraceLimit": 30,
+        "outputs": {
+            "console": {
+                "outputFileAndLine": false
+            },
+            "syslog": {
+                "port": 514,
+                "target": "127.0.0.1",
+                "outputFileAndLine": false
+            }
+        },
+        "namespaces": {
+            "SSM.Client.ASR": {"console": "info", "syslog": "debug" },
+            "C.AsrService": {"console": "info", "syslog": "debug" },
+            "": {
+                "console": "info",
+                "syslog": "info"
+            }
+        }
+    }
+}

V3.1/build/usr/local/etc/jibo-ssm/jibo-ssm-normal.json

@@ -0,0 +1,60 @@
+{
+    "platformVersion": ">=3.1.0",
+    "services": {
+        "KBService": {
+            "port": 8778
+        },
+        "GlobalManagerService": {
+            "port": 8338
+        },
+        "SkillsService": {
+            "startSkill": "@be/be",
+            "singleSkill": true,
+            "port": 8779
+        },
+        "NotificationsService": {
+            "port": 8001
+        },
+        "ErrorService": {
+            "port": 10004
+        },
+        "SchedulerService": {
+          "port": 10005,
+          "otaFilter": "fcs"
+        },
+
+        "PerformanceServiceSim": {},
+        "RemoteService": {
+            "port": 10321
+        },
+        "WifiService": {
+          "port": 8668,
+          "region": "api"
+        }
+    },
+    "RegistryClient": {
+        "port": 8181,
+        "host": "127.0.0.1"
+    },
+    "logging": {
+        "logUncaughtExceptions": true,
+        "logUnhandledRejections": true,
+        "stackTraceLimit": 30,
+        "outputs": {
+            "console": {
+                "outputFileAndLine": false
+            },
+            "syslog": {
+                "port": 514,
+                "target": "127.0.0.1",
+                "outputFileAndLine": false
+            }
+        },
+        "namespaces": {
+            "": {
+                "console": "none",
+                "syslog": "info"
+            }
+        }
+    }
+}