@manifest-editor/server-vault 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 digirati-co-uk
+
+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.

package/README.md

@@ -0,0 +1,136 @@
+# Vault
+
+
+
+**.vaultfile**
+```
+{
+  "source": { "id": "https://example.org/manifest", "type": "Manifest" },
+  "resources": {
+    "https://example.org/manifest": "./manifest.json",
+  }
+}
+```
+
+
+The server vault will take this optional config and use it to load the manifest from the file system. The instance of
+vault will live on the server for a period of time and can be stopped or started.
+
+Multiple clients can then connect to the vault and use the manifest. They can connect as a read-only user or as a
+read-write user. The read-write user can make changes to the manifest and save it back to the vault. These changes will
+be reflected in the vault and will be available to all users. The changes will also be reflected in the file system
+where the manifest is stored.
+
+Vault communicates using atomic actions. These actions are sent to the vault and the vault will respond with the result
+of the action. The vault will also broadcast the action to all connected clients. The clients can then update their
+state based on the action. If the actions are applied in the same order on all clients then the state of the clients
+will be the same.
+
+Each action will have a unique id. This id will be used to ensure that the actions are applied in the same order on all
+clients. Clients are required to send the previous action id with each action. The vault will then check that the
+previous action id matches the last action id that was applied to the vault. If the previous action id does not match
+then the action will be rejected. The client will then need to update its state to match the vault and then try again.
+
+## Post Message communication
+
+The server will also host a webpage that can be used to communicate with the vault. This webpage will be loaded in an
+iframe on the client. The client will then be able to connect to the vault and send actions to the vault. The vault
+will then broadcast the actions to all connected clients. The client will then update its state based on the actions.
+
+This allows the client to be a static webpage that can be hosted on any server. The client will not need to be hosted
+on the same server as the vault. However, the server will need to allow cross-origin requests from the client, and will
+ensure that only select hosts are allowed to connect to the vault.
+
+For post-message you have the server iframe, communicating to the server via web-sockets and the client application
+that has the server in an iframe. When an event originates from the client, the following happens:
+
+- The client sends a message to the server iframe via post-message
+- The server iframe sends a message to the server via web-sockets
+- The server broadcasts the message to all connected clients via web-sockets
+- The server iframe receives the message from the server via web-sockets
+- The server iframe sends the message to the other clients via post-message
+
+When an event originates from the server, the following happens:
+- The server sends a message to the server iframe via web-sockets
+- The server iframe sends the message to the other clients via post-message
+
+
+- ClientPostMessageVault.dispatch() -> sends message to server iframe
+- ServerPostMessageVault.dispatch() -> sends message to server
+- ServerWebSocketVault.dispatch() -> sends message to all clients
+
+
+
+## GitHub integration
+
+On the server there will be a GitHub integration. This integration will allow the vault to be connected to a GitHub
+repository. The vault will then be able to load the manifest from the GitHub repository. The vault will also be able
+to save the manifest to the GitHub repository.
+
+As changes are made to the manifest the vault will commit the changes to the GitHub repository. The server will also
+create a pull request for the changes.
+
+When a client requests a vault instance, the server will create a new branch in the GitHub repository. The vault will
+then load the manifest from the new branch. The client will then be able to make changes to the manifest. Alternatively
+the client can request a read-only instance of the vault. The client will then be able to view the manifest but will
+not be able to make changes to the manifest.
+
+Clients can also request an existing branch. The vault will then load the manifest from the existing branch. The client
+will then be able to make changes to the manifest. The client will also be able to save the changes to the existing
+branch. If other clients are also connected to the vault then they will be able to see the changes that the client has
+made.
+
+## Authentication
+
+On the client the user will be able to login to GitHub through the server. This will be done by opening a popup window served by the  server. The user will then be able to login to GitHub and grant the server access to their GitHub account.
+Initially this will only be for authentication and will grant access to manifests hosted in SQLite on the server. Eventually
+this will also allow the server to access manifests hosted in GitHub repositories.
+
+Once logged in the server will redirect back to the client. The client will then be able to use the access token to
+create an iFrame that can be used to communicate with the vault.
+
+## Listing projects
+
+Before a client can connect to a vault it will need to know the id of the vault. The client will be able to request a
+list of vaults from the server. This is also done using a post message. The server will then respond with a list of
+vaults that the user has access to. The client will then be able to connect to the vault.
+
+
+## Server responsibilities and routes
+
+- [ ] Request login status of the user using a post message
+- [ ] Request a list of vaults using a post message
+- [ ] Request a vault instance using a post message
+- [ ] Login via Github in a popup
+- [ ] Create a new vault instance
+
+
+2 new types of Vault instance
+
+- Server vault
+- Client vault
+
+**Server vault**
+1. Creates normal internal vault instance
+2. Loads manifest from file system
+3. Handles client opening and closing connections
+4. Accepts client actions
+  - Applies action to internal vault instance
+  - Responds to client with result of action
+  - Broadcasts action to all connected clients
+5. Saves manifest to file system periodically
+
+
+**Client vault**
+1. Connects to server vault
+  - Opens connection
+  - Loads initial state from server vault, including last action id
+2. Sends actions to server vault
+  - Includes last action id
+  - Waits for response from server vault
+  - Updates state based on response from server vault
+  - If response is an error then update state to match server vault
+  - May retry action if response is a conflict
+3. Receives actions from server vault
+4. Applies actions to internal vault instance
+

package/dist/index.cjs

@@ -0,0 +1,240 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  MultiVaultServer: () => MultiVaultServer,
+  ServerVault: () => ServerVault
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/server-vault.ts
+var import_vault = require("@iiif/helpers/vault");
+var import_ws = __toESM(require("ws"), 1);
+var import_uuid = require("uuid");
+var import_timers = require("timers");
+var GenesisId = "@genesis";
+var ServerVault = class {
+  constructor(options = {}) {
+    __publicField(this, "vault");
+    __publicField(this, "ws");
+    __publicField(this, "lastActionId", GenesisId);
+    __publicField(this, "pingInterval");
+    __publicField(this, "_handleMessage", /* @__PURE__ */ new Map());
+    __publicField(this, "_handleOpen", /* @__PURE__ */ new Map());
+    __publicField(this, "_handleClose", /* @__PURE__ */ new Map());
+    __publicField(this, "setupWebSocket", (socket) => {
+      socket.isAlive = true;
+      socket.on("pong", () => {
+        socket.isAlive = true;
+      });
+      socket.on("open", this.handleOpen(socket));
+      socket.on("message", this.handleMessage(socket));
+      socket.on("close", this.handleClose(socket));
+      socket.send(this.createMessage("init-response", { data: this.vault.getState() }));
+    });
+    __publicField(this, "handleMessage", (socket) => {
+      if (this._handleMessage.has(socket)) {
+        return this._handleMessage.get(socket);
+      }
+      const handler = (data, isBinary) => {
+        const parsed = JSON.parse(data.toString());
+        if (parsed._type === "init-request") {
+          socket.send(this.createMessage("init-response", { data: this.vault.getState() }));
+        }
+        if (parsed._type === "vault-action") {
+          try {
+            this.vault.dispatch(parsed.action);
+          } catch (e) {
+            socket.send(
+              this.createMessage("vault-action-rejection", {
+                action: parsed._id
+              })
+            );
+            return;
+          }
+          this.lastActionId = parsed._id;
+          this.rebroadcast(socket, data, parsed, isBinary);
+        }
+      };
+      this._handleMessage.set(socket, handler);
+      return handler;
+    });
+    __publicField(this, "send", (data) => {
+      this.ws.clients.forEach(function each(client) {
+        if (client.readyState === import_ws.default.OPEN) {
+          client.send(data, { binary: true });
+        }
+      });
+    });
+    __publicField(this, "rebroadcast", (source, data, action, isBinary = true) => {
+      this.ws.clients.forEach((client) => {
+        if (client !== source && client.readyState === import_ws.default.OPEN) {
+          client.send(data, { binary: isBinary });
+        } else {
+          client.send(
+            this.createMessage("vault-action-confirmation", {
+              action: action._id
+            })
+          );
+        }
+      });
+    });
+    __publicField(this, "handleOpen", (socket) => {
+      if (this._handleOpen.has(socket)) {
+        return this._handleOpen.get(socket);
+      }
+      const handler = () => {
+      };
+      this._handleOpen.set(socket, handler);
+      return handler;
+    });
+    __publicField(this, "handleClose", (socket) => {
+      if (this._handleClose.has(socket)) {
+        return this._handleClose.get(socket);
+      }
+      const handler = () => {
+      };
+      this._handleClose.set(socket, handler);
+      return handler;
+    });
+    __publicField(this, "createMessage", (type, message) => {
+      return JSON.stringify({
+        _id: (0, import_uuid.v4)(),
+        _type: type,
+        _lastActionId: this.lastActionId,
+        ...message
+      });
+    });
+    this.vault = new import_vault.Vault();
+    this.ws = new import_ws.WebSocketServer({ noServer: true });
+    this.ws.on("connection", this.setupWebSocket);
+    this.pingInterval = (0, import_timers.setInterval)(() => {
+      this.ws.clients.forEach((socket) => {
+        if (socket.isAlive === false) {
+          return socket.terminate();
+        }
+        socket.isAlive = false;
+        socket.ping();
+      });
+    }, options.pingTimeout || 3e4);
+    this.ws.on("close", () => {
+      (0, import_timers.clearInterval)(this.pingInterval);
+      if (options.onClose) {
+        options.onClose();
+      }
+    });
+    this.ws.on("error", (err) => {
+    });
+  }
+  async close() {
+    clearTimeout(this.pingInterval);
+    return new Promise((resolve, error) => {
+      this.ws.close((err) => {
+        if (err) {
+          error(err);
+        }
+        resolve();
+      });
+    });
+  }
+};
+
+// src/server.ts
+var import_http = require("http");
+var MultiVaultServer = class {
+  constructor(server) {
+    __publicField(this, "server");
+    __publicField(this, "vaults", /* @__PURE__ */ new Map());
+    __publicField(this, "handleRequest", (request, response) => {
+      if (request.url === "/vault") {
+        const vaults = Array.from(this.vaults.keys());
+        const json = JSON.stringify({ vaults });
+        response.writeHead(200, {
+          "Content-Length": Buffer.byteLength(json),
+          "Content-Type": "application/json"
+        });
+        response.write(json);
+        response.end();
+        return;
+      }
+      response.writeHead(404);
+      response.end();
+    });
+    __publicField(this, "handleUpgrade", (request, socket, head) => {
+      console.log("ws.url", request.url);
+      const pathname = request.url;
+      if (pathname && pathname.startsWith("/vault")) {
+        const vaultId = pathname.replace("/vault/", "");
+        let vault = this.vaults.get(vaultId);
+        if (!vault) {
+          const newVault = new ServerVault();
+          console.log("new vault", vaultId);
+          this.vaults.set(vaultId, newVault);
+          vault = newVault;
+        }
+        if (vault) {
+          const theVault = vault;
+          theVault.ws.handleUpgrade(request, socket, head, (ws) => {
+            console.log("new client", vaultId);
+            theVault.ws.emit("connection", ws, request);
+            theVault.ws.on("close", () => {
+              if (theVault.ws.clients.size === 0) {
+                console.log("destroying vault", vaultId);
+                this.vaults.delete(vaultId);
+              }
+            });
+          });
+        } else {
+          socket.destroy();
+        }
+        return;
+      }
+      socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+      socket.destroy();
+    });
+    this.server = server || (0, import_http.createServer)();
+    this.server.on("upgrade", this.handleUpgrade);
+    this.server.on("request", this.handleRequest);
+  }
+  listen(port, hostname, backlog, listeningListener) {
+    this.server.listen(port, hostname, backlog, listeningListener);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MultiVaultServer,
+  ServerVault
+});

package/dist/index.d.cts

@@ -0,0 +1,85 @@
+import { Vault, AllActions, IIIFStore } from '@iiif/helpers/vault';
+import { BatchAction } from '@iiif/helpers/vault/actions';
+import { Collection, Manifest } from '@iiif/presentation-3';
+import WebSocket, { WebSocketServer, RawData } from 'ws';
+import { Server, IncomingMessage } from 'http';
+import { Socket } from 'net';
+
+type RemoteAction = {
+    _id: string;
+    _type: "vault-action";
+    _lastActionId: string;
+    action: AllActions | BatchAction;
+};
+type ClientInitAction = {
+    _id: string;
+    _type: "init-response";
+    _lastActionId: string;
+    data: IIIFStore;
+};
+type ClientInitRequestAction = {
+    _type: "init-request";
+};
+type RemoteActionConfirmation = {
+    _id: string;
+    _type: "vault-action-confirmation";
+    _lastActionId: string;
+    action: string;
+};
+type RemoteActionRejection = {
+    _id: string;
+    _type: "vault-action-rejection";
+    _lastActionId: string;
+    action: string;
+};
+type InitialiseWithResourceAction = {
+    _id: string;
+    _type: "initialise-with-resource";
+    _lastActionId: string;
+    resource: Collection | Manifest;
+};
+type EmptyVaultResponse = {
+    _id: string;
+    _type: "empty-vault-response";
+    _lastActionId: string;
+};
+type ClientAction = RemoteAction | ClientInitRequestAction | InitialiseWithResourceAction;
+type ServerAction = RemoteAction | RemoteActionConfirmation | RemoteActionRejection | ClientInitAction | EmptyVaultResponse;
+declare module "ws" {
+    interface WebSocket {
+        isAlive: boolean;
+    }
+}
+interface ServerVaultOptions {
+    pingTimeout?: number;
+    onClose?: () => void;
+}
+declare class ServerVault {
+    vault: Vault;
+    ws: WebSocketServer;
+    lastActionId: string;
+    pingInterval: NodeJS.Timeout;
+    private _handleMessage;
+    private _handleOpen;
+    private _handleClose;
+    constructor(options?: ServerVaultOptions);
+    close(): Promise<void>;
+    setupWebSocket: (socket: WebSocket.WebSocket) => void;
+    handleMessage: (socket: WebSocket) => any;
+    send: (data: RawData) => void;
+    rebroadcast: (source: WebSocket, data: RawData, action: RemoteAction, isBinary?: boolean) => void;
+    handleOpen: (socket: WebSocket) => any;
+    handleClose: (socket: WebSocket) => any;
+    createMessage: (type: string, message: any) => string;
+}
+
+declare class MultiVaultServer {
+    server: Server;
+    vaults: Map<string, ServerVault>;
+    constructor(server?: Server);
+    listen(port: number, hostname?: string, backlog?: number, listeningListener?: () => void): void;
+    handleRequest: (request: IncomingMessage, response: any) => void;
+    handleUpgrade: (request: IncomingMessage, socket: Socket, head: Buffer) => void;
+}
+
+export { type ClientAction, MultiVaultServer, type ServerAction, ServerVault, type ServerVaultOptions };

package/dist/index.d.ts

@@ -0,0 +1,85 @@
+import { Vault, AllActions, IIIFStore } from '@iiif/helpers/vault';
+import { BatchAction } from '@iiif/helpers/vault/actions';
+import { Collection, Manifest } from '@iiif/presentation-3';
+import WebSocket, { WebSocketServer, RawData } from 'ws';
+import { Server, IncomingMessage } from 'http';
+import { Socket } from 'net';
+
+type RemoteAction = {
+    _id: string;
+    _type: "vault-action";
+    _lastActionId: string;
+    action: AllActions | BatchAction;
+};
+type ClientInitAction = {
+    _id: string;
+    _type: "init-response";
+    _lastActionId: string;
+    data: IIIFStore;
+};
+type ClientInitRequestAction = {
+    _type: "init-request";
+};
+type RemoteActionConfirmation = {
+    _id: string;
+    _type: "vault-action-confirmation";
+    _lastActionId: string;
+    action: string;
+};
+type RemoteActionRejection = {
+    _id: string;
+    _type: "vault-action-rejection";
+    _lastActionId: string;
+    action: string;
+};
+type InitialiseWithResourceAction = {
+    _id: string;
+    _type: "initialise-with-resource";
+    _lastActionId: string;
+    resource: Collection | Manifest;
+};
+type EmptyVaultResponse = {
+    _id: string;
+    _type: "empty-vault-response";
+    _lastActionId: string;
+};
+type ClientAction = RemoteAction | ClientInitRequestAction | InitialiseWithResourceAction;
+type ServerAction = RemoteAction | RemoteActionConfirmation | RemoteActionRejection | ClientInitAction | EmptyVaultResponse;
+declare module "ws" {
+    interface WebSocket {
+        isAlive: boolean;
+    }
+}
+interface ServerVaultOptions {
+    pingTimeout?: number;
+    onClose?: () => void;
+}
+declare class ServerVault {
+    vault: Vault;
+    ws: WebSocketServer;
+    lastActionId: string;
+    pingInterval: NodeJS.Timeout;
+    private _handleMessage;
+    private _handleOpen;
+    private _handleClose;
+    constructor(options?: ServerVaultOptions);
+    close(): Promise<void>;
+    setupWebSocket: (socket: WebSocket.WebSocket) => void;
+    handleMessage: (socket: WebSocket) => any;
+    send: (data: RawData) => void;
+    rebroadcast: (source: WebSocket, data: RawData, action: RemoteAction, isBinary?: boolean) => void;
+    handleOpen: (socket: WebSocket) => any;
+    handleClose: (socket: WebSocket) => any;
+    createMessage: (type: string, message: any) => string;
+}
+
+declare class MultiVaultServer {
+    server: Server;
+    vaults: Map<string, ServerVault>;
+    constructor(server?: Server);
+    listen(port: number, hostname?: string, backlog?: number, listeningListener?: () => void): void;
+    handleRequest: (request: IncomingMessage, response: any) => void;
+    handleUpgrade: (request: IncomingMessage, socket: Socket, head: Buffer) => void;
+}
+
+export { type ClientAction, MultiVaultServer, type ServerAction, ServerVault, type ServerVaultOptions };

package/dist/index.js

@@ -0,0 +1,204 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/server-vault.ts
+import { Vault } from "@iiif/helpers/vault";
+import WebSocket, { WebSocketServer } from "ws";
+import { v4 } from "uuid";
+import { clearInterval, setInterval } from "timers";
+var GenesisId = "@genesis";
+var ServerVault = class {
+  constructor(options = {}) {
+    __publicField(this, "vault");
+    __publicField(this, "ws");
+    __publicField(this, "lastActionId", GenesisId);
+    __publicField(this, "pingInterval");
+    __publicField(this, "_handleMessage", /* @__PURE__ */ new Map());
+    __publicField(this, "_handleOpen", /* @__PURE__ */ new Map());
+    __publicField(this, "_handleClose", /* @__PURE__ */ new Map());
+    __publicField(this, "setupWebSocket", (socket) => {
+      socket.isAlive = true;
+      socket.on("pong", () => {
+        socket.isAlive = true;
+      });
+      socket.on("open", this.handleOpen(socket));
+      socket.on("message", this.handleMessage(socket));
+      socket.on("close", this.handleClose(socket));
+      socket.send(this.createMessage("init-response", { data: this.vault.getState() }));
+    });
+    __publicField(this, "handleMessage", (socket) => {
+      if (this._handleMessage.has(socket)) {
+        return this._handleMessage.get(socket);
+      }
+      const handler = (data, isBinary) => {
+        const parsed = JSON.parse(data.toString());
+        if (parsed._type === "init-request") {
+          socket.send(this.createMessage("init-response", { data: this.vault.getState() }));
+        }
+        if (parsed._type === "vault-action") {
+          try {
+            this.vault.dispatch(parsed.action);
+          } catch (e) {
+            socket.send(
+              this.createMessage("vault-action-rejection", {
+                action: parsed._id
+              })
+            );
+            return;
+          }
+          this.lastActionId = parsed._id;
+          this.rebroadcast(socket, data, parsed, isBinary);
+        }
+      };
+      this._handleMessage.set(socket, handler);
+      return handler;
+    });
+    __publicField(this, "send", (data) => {
+      this.ws.clients.forEach(function each(client) {
+        if (client.readyState === WebSocket.OPEN) {
+          client.send(data, { binary: true });
+        }
+      });
+    });
+    __publicField(this, "rebroadcast", (source, data, action, isBinary = true) => {
+      this.ws.clients.forEach((client) => {
+        if (client !== source && client.readyState === WebSocket.OPEN) {
+          client.send(data, { binary: isBinary });
+        } else {
+          client.send(
+            this.createMessage("vault-action-confirmation", {
+              action: action._id
+            })
+          );
+        }
+      });
+    });
+    __publicField(this, "handleOpen", (socket) => {
+      if (this._handleOpen.has(socket)) {
+        return this._handleOpen.get(socket);
+      }
+      const handler = () => {
+      };
+      this._handleOpen.set(socket, handler);
+      return handler;
+    });
+    __publicField(this, "handleClose", (socket) => {
+      if (this._handleClose.has(socket)) {
+        return this._handleClose.get(socket);
+      }
+      const handler = () => {
+      };
+      this._handleClose.set(socket, handler);
+      return handler;
+    });
+    __publicField(this, "createMessage", (type, message) => {
+      return JSON.stringify({
+        _id: v4(),
+        _type: type,
+        _lastActionId: this.lastActionId,
+        ...message
+      });
+    });
+    this.vault = new Vault();
+    this.ws = new WebSocketServer({ noServer: true });
+    this.ws.on("connection", this.setupWebSocket);
+    this.pingInterval = setInterval(() => {
+      this.ws.clients.forEach((socket) => {
+        if (socket.isAlive === false) {
+          return socket.terminate();
+        }
+        socket.isAlive = false;
+        socket.ping();
+      });
+    }, options.pingTimeout || 3e4);
+    this.ws.on("close", () => {
+      clearInterval(this.pingInterval);
+      if (options.onClose) {
+        options.onClose();
+      }
+    });
+    this.ws.on("error", (err) => {
+    });
+  }
+  async close() {
+    clearTimeout(this.pingInterval);
+    return new Promise((resolve, error) => {
+      this.ws.close((err) => {
+        if (err) {
+          error(err);
+        }
+        resolve();
+      });
+    });
+  }
+};
+
+// src/server.ts
+import { createServer } from "http";
+var MultiVaultServer = class {
+  constructor(server) {
+    __publicField(this, "server");
+    __publicField(this, "vaults", /* @__PURE__ */ new Map());
+    __publicField(this, "handleRequest", (request, response) => {
+      if (request.url === "/vault") {
+        const vaults = Array.from(this.vaults.keys());
+        const json = JSON.stringify({ vaults });
+        response.writeHead(200, {
+          "Content-Length": Buffer.byteLength(json),
+          "Content-Type": "application/json"
+        });
+        response.write(json);
+        response.end();
+        return;
+      }
+      response.writeHead(404);
+      response.end();
+    });
+    __publicField(this, "handleUpgrade", (request, socket, head) => {
+      console.log("ws.url", request.url);
+      const pathname = request.url;
+      if (pathname && pathname.startsWith("/vault")) {
+        const vaultId = pathname.replace("/vault/", "");
+        let vault = this.vaults.get(vaultId);
+        if (!vault) {
+          const newVault = new ServerVault();
+          console.log("new vault", vaultId);
+          this.vaults.set(vaultId, newVault);
+          vault = newVault;
+        }
+        if (vault) {
+          const theVault = vault;
+          theVault.ws.handleUpgrade(request, socket, head, (ws) => {
+            console.log("new client", vaultId);
+            theVault.ws.emit("connection", ws, request);
+            theVault.ws.on("close", () => {
+              if (theVault.ws.clients.size === 0) {
+                console.log("destroying vault", vaultId);
+                this.vaults.delete(vaultId);
+              }
+            });
+          });
+        } else {
+          socket.destroy();
+        }
+        return;
+      }
+      socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+      socket.destroy();
+    });
+    this.server = server || createServer();
+    this.server.on("upgrade", this.handleUpgrade);
+    this.server.on("request", this.handleRequest);
+  }
+  listen(port, hostname, backlog, listeningListener) {
+    this.server.listen(port, hostname, backlog, listeningListener);
+  }
+};
+export {
+  MultiVaultServer,
+  ServerVault
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@manifest-editor/server-vault",
+  "version": "1.0.2",
+  "type": "module",
+  "bugs": "https://github.com/digirati-co-uk/iiif-manifest-editor/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/digirati-co-uk/iiif-manifest-editor.git",
+    "directory": "packages/server-vault"
+  },
+  "engines": {
+    "node": ">=18.14.1"
+  },
+  "keywords": [
+    "iiif",
+    "editor",
+    "typescript"
+  ],
+  "nodeDependencies": [
+    "http",
+    "net",
+    "url",
+    "timers"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts",
+    "dev": "tsup src/index.ts --watch",
+    "lint": "publint",
+    "typecheck": "tsc --noEmit",
+    "prepack": "tsup src/index.ts"
+  },
+  "dependencies": {
+    "@iiif/helpers": "^1.2.12",
+    "@iiif/presentation-3": "^2.2.3",
+    "uuid": "^9.0.1",
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "0.0.0",
+    "@types/node": "^20.11.24",
+    "@types/uuid": "^9.0.8",
+    "@types/ws": "^8.5.10",
+    "tsup": "^8.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "083fd2ce7d40755fb1857490e006e9854906d031"
+}