@vex-chat/spire 0.7.4 → 1.0.0

package/dist/ClientManager.js

@@ -1,510 +1,115 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientManager = exports.POWER_LEVELS = void 0;
-const sleep_1 = require("@extrahash/sleep");
-const crypto_1 = require("@vex-chat/crypto");
-const chalk_1 = __importDefault(require("chalk"));
-const events_1 = require("events");
-const msgpack_lite_1 = __importDefault(require("msgpack-lite"));
-const tweetnacl_1 = __importDefault(require("tweetnacl"));
-const uuid_1 = require("uuid");
-const utils_1 = require("./server/utils");
-const Spire_1 = require("./Spire");
-const createLogger_1 = require("./utils/createLogger");
-const createUint8UUID_1 = require("./utils/createUint8UUID");
-exports.POWER_LEVELS = {
-    INVITE: 25,
+import { EventEmitter } from "events";
+import { setTimeout as sleep } from "node:timers/promises";
+import { xConcat, XUtils } from "@vex-chat/crypto";
+import { xSignOpen } from "@vex-chat/crypto";
+import { MailWSSchema, SocketAuthErrors } from "@vex-chat/types";
+import pc from "picocolors";
+import { parse as uuidParse, validate as uuidValidate } from "uuid";
+import { TOKEN_EXPIRY } from "./Spire.js";
+import { createLogger } from "./utils/createLogger.js";
+import { createUint8UUID } from "./utils/createUint8UUID.js";
+import { msgpack } from "./utils/msgpack.js";
+export const POWER_LEVELS = {
     CREATE: 50,
     DELETE: 50,
+    EMOJI: 25,
+    INVITE: 25,
 };
 function emptyHeader() {
     return new Uint8Array(32);
 }
 const MAX_MSG_SIZE = 2048;
-function unpackMessage(msg) {
-    const msgp = Uint8Array.from(msg);
-    const msgh = msgp.slice(0, 32);
-    const msgb = msgpack_lite_1.default.decode(msgp.slice(32));
-    return [msgh, msgb];
-}
-function packMessage(msg, header) {
-    const msgb = Uint8Array.from(msgpack_lite_1.default.encode(msg));
-    const msgh = header || emptyHeader();
-    return crypto_1.xConcat(msgh, msgb);
-}
-class ClientManager extends events_1.EventEmitter {
-    constructor(ws, db, notify, jwtDetails, options) {
+export class ClientManager extends EventEmitter {
+    alive = true;
+    authed = false;
+    challengeID = createUint8UUID();
+    conn;
+    db;
+    device;
+    failed = false;
+    log;
+    notify;
+    user;
+    userDetails;
+    constructor(ws, db, notify, userDetails, options) {
         super();
-        this.authed = false;
-        this.alive = true;
-        this.challengeID = createUint8UUID_1.createUint8UUID();
-        this.failed = false;
         this.conn = ws;
         this.db = db;
         this.user = null;
-        this.jwtDetails = jwtDetails;
+        this.userDetails = userDetails;
         this.device = null;
         this.notify = notify;
-        this.log = createLogger_1.createLogger("client-manager", (options === null || options === void 0 ? void 0 : options.logLevel) || "error");
+        this.log = createLogger("client-manager", options?.logLevel || "error");
         this.initListeners();
         this.challenge();
     }
-    toString() {
-        if (!this.user || !this.device) {
-            return "Unauthorized#0000";
+    getDevice() {
+        if (!this.device) {
+            throw new Error("No device set on this client.");
         }
-        return this.user.username + "<" + this.getDevice().deviceID + ">";
+        return this.device;
     }
     getUser() {
-        if (!this.authed) {
+        if (!this.authed || !this.user) {
             throw new Error("You must be authed before getting user info.");
         }
         return this.user;
     }
     send(msg, header) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (header) {
-                this.log.debug(chalk_1.default.red.bold("OUTH"), header.toString());
-            }
-            else {
-                this.log.debug(chalk_1.default.red.bold("OUTH"), emptyHeader.toString());
-            }
-            const packedMessage = packMessage(msg, header);
-            this.log.info(chalk_1.default.bold("⟶   ") +
-                responseColor(msg.type.toUpperCase()) +
-                " " +
-                this.toString() +
-                " " +
-                chalk_1.default.yellow(Buffer.byteLength(packedMessage)));
-            this.log.debug(chalk_1.default.red.bold("OUT"), msg);
-            try {
-                this.conn.send(packedMessage);
-            }
-            catch (err) {
-                this.log.warn(err.toString());
-                this.fail();
-            }
-        });
+        if (header) {
+            this.log.debug(pc.bold(pc.red("OUTH")), header.toString());
+        }
+        else {
+            this.log.debug(pc.bold(pc.red("OUTH")), emptyHeader.toString());
+        }
+        const packedMessage = packMessage(msg, header);
+        this.log.info(pc.bold("⟶   ") +
+            responseColor(msg.type.toUpperCase()) +
+            " " +
+            this.toString() +
+            " " +
+            pc.yellow(Buffer.byteLength(packedMessage)));
+        this.log.debug(pc.bold(pc.red("OUT")), msg);
+        try {
+            this.conn.send(packedMessage);
+        }
+        catch (err) {
+            this.log.warn(String(err));
+            this.fail();
+        }
     }
-    getDevice() {
-        return this.device;
+    toString() {
+        if (!this.user || !this.device) {
+            return "Unauthorized#0000";
+        }
+        return this.user.username + "<" + this.getDevice().deviceID + ">";
     }
     authorize(transmissionID) {
         this.authed = true;
         this.sendAuthedMessage(transmissionID);
+        void this.db.markDeviceLogin(this.getDevice());
         this.emit("authed");
     }
-    // notifies all users when a given resourceID changes
-    notifyServerChange(serverID, transmissionID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const affectedUsers = yield this.db.retrieveAffectedUsers(serverID);
-            // tell everyone about server change
-            for (const user of affectedUsers) {
-                this.notify(user.userID, "serverChange", transmissionID, serverID);
-            }
-        });
+    challenge() {
+        this.challengeID = new Uint8Array(uuidParse(crypto.randomUUID()));
+        const challenge = {
+            challenge: this.challengeID,
+            transmissionID: crypto.randomUUID(),
+            type: "challenge",
+        };
+        this.send(challenge);
     }
     fail() {
         if (this.failed) {
             return;
         }
         this.log.warn("Connection closed.");
-        if (this.conn) {
-            this.conn.close();
-        }
+        this.conn.close();
         this.failed = true;
         this.emit("fail");
     }
-    setAlive(status) {
-        this.alive = status;
-    }
-    pingLoop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            while (true) {
-                this.ping();
-                yield sleep_1.sleep(5000);
-            }
-        });
-    }
-    ping() {
-        if (!this.alive) {
-            this.fail();
-            return;
-        }
-        this.setAlive(false);
-        const p = { transmissionID: uuid_1.v4(), type: "ping" };
-        this.send(p);
-    }
-    pong(transmissionID) {
-        // ping is allowed before auth
-        if (this.user) {
-            this.db.markUserSeen(this.user);
-        }
-        const p = { transmissionID, type: "pong" };
-        this.send(p);
-    }
-    verifyResponse(msg) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const user = yield this.db.retrieveUser(this.jwtDetails.userID);
-            if (user) {
-                const devices = yield this.db.retrieveUserDeviceList([user.userID]);
-                let message = null;
-                for (const device of devices) {
-                    const verified = tweetnacl_1.default.sign.open(msg.signed, crypto_1.XUtils.decodeHex(device.signKey));
-                    if (verified) {
-                        message = verified;
-                        this.device = device;
-                    }
-                }
-                if (!message) {
-                    console.warn("Bad response from client.");
-                    this.fail();
-                    return;
-                }
-                if (message) {
-                    if (crypto_1.XUtils.bytesEqual(this.challengeID, message)) {
-                        this.user = user;
-                        this.authorize(msg.transmissionID);
-                    }
-                }
-                else {
-                    this.log.info("Signature verification failed!");
-                    this.fail();
-                }
-            }
-            else {
-                this.log.info("User is not registered.");
-                this.fail();
-            }
-        });
-    }
-    challenge() {
-        this.challengeID = new Uint8Array(uuid_1.parse(uuid_1.v4()));
-        const challenge = {
-            transmissionID: uuid_1.v4(),
-            type: "challenge",
-            challenge: this.challengeID,
-        };
-        this.send(challenge);
-    }
-    sendErr(transmissionID, message, data) {
-        const error = {
-            transmissionID,
-            type: "error",
-            error: message,
-            data,
-        };
-        this.send(error);
-    }
-    sendAuthedMessage(transmissionID) {
-        this.send({ type: "authorized", transmissionID });
-    }
-    sendSuccess(transmissionID, data, header) {
-        const msg = {
-            transmissionID,
-            type: "success",
-            data,
-        };
-        this.send(msg, header);
-    }
-    parseResourceMsg(msg, header) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (msg.resourceType) {
-                case "permissions":
-                    if (msg.action === "RETRIEVE") {
-                        try {
-                            const permissions = yield this.db.retrievePermissions(this.getUser().userID, "all");
-                            this.sendSuccess(msg.transmissionID, permissions);
-                            break;
-                        }
-                        catch (err) {
-                            this.sendErr(msg.transmissionID, err.toString());
-                        }
-                    }
-                    if (msg.action === "DELETE") {
-                        try {
-                            // msg.data is permID
-                            const permToDelete = yield this.db.retrievePermission(msg.data);
-                            if (!permToDelete) {
-                                this.sendErr(msg.transmissionID, "That doesn't exist.");
-                                break;
-                            }
-                            const permissions = yield this.db.retrievePermissions(this.getUser().userID, permToDelete.resourceType);
-                            let found = false;
-                            for (const perm of permissions) {
-                                // msg.data is resourceID
-                                if (perm.resourceID === permToDelete.resourceID &&
-                                    (perm.userID === this.getUser().userID ||
-                                        (perm.powerLevel > exports.POWER_LEVELS.DELETE &&
-                                            perm.powerLevel >
-                                                permToDelete.powerLevel))) {
-                                    this.db.deletePermission(perm.permissionID);
-                                    this.sendSuccess(msg.transmissionID, null);
-                                    found = true;
-                                    break;
-                                }
-                            }
-                            if (!found) {
-                                this.sendErr(msg.transmissionID, "You don't have permission to do that.");
-                                break;
-                            }
-                        }
-                        catch (err) {
-                            this.sendErr(msg.transmissionID, err.toString());
-                            break;
-                        }
-                    }
-                    if (msg.action === "CREATE") {
-                        try {
-                            const { resourceType, userID, resourceID } = msg.data;
-                            const userHeldPerms = yield this.db.retrievePermissions(this.getUser().userID, "all");
-                            let found = false;
-                            for (const perm of userHeldPerms) {
-                                if (perm.resourceID === resourceID) {
-                                    if (perm.powerLevel > exports.POWER_LEVELS.CREATE) {
-                                        // he's got the perm and the power level, we're good to go
-                                        const newPerm = yield this.db.createPermission(userID, resourceType, resourceID, 0);
-                                        this.sendSuccess(msg.transmissionID, newPerm);
-                                        // notify the user of their new permission
-                                        this.notify(userID, "permission", msg.transmissionID, newPerm);
-                                        found = true;
-                                        break;
-                                    }
-                                }
-                            }
-                            if (!found) {
-                                this.sendErr(msg.transmissionID, "You don't have permission for that.");
-                            }
-                            break;
-                        }
-                        catch (err) {
-                            this.sendErr(msg.transmissionID, err.toString());
-                        }
-                    }
-                    break;
-                case "otk":
-                    if (msg.action === "RETRIEVE") {
-                        try {
-                            const keyCount = yield this.db.getOTKCount(this.getDevice().deviceID);
-                            this.sendSuccess(msg.transmissionID, keyCount);
-                        }
-                        catch (err) {
-                            this.log.error(err);
-                            this.sendErr(msg.transmissionID, err.toString());
-                        }
-                    }
-                    if (msg.action === "CREATE") {
-                        try {
-                            yield this.db.saveOTK(this.getDevice().deviceID, msg.data);
-                            this.sendSuccess(msg.transmissionID, msg);
-                        }
-                        catch (err) {
-                            this.log.error(err);
-                            this.sendErr(msg.transmissionID, err.toString());
-                        }
-                    }
-                    break;
-                case "user":
-                    if (msg.action === "RETRIEVE") {
-                        try {
-                            const user = yield this.db.retrieveUser(msg.data);
-                            if (user) {
-                                this.sendSuccess(msg.transmissionID, utils_1.censorUser(user));
-                            }
-                            else {
-                                this.log.error("User doesn't exist.");
-                                this.sendErr(msg.transmissionID, "That user doesn't exist.");
-                            }
-                        }
-                        catch (err) {
-                            this.log.error(err);
-                            this.sendErr(msg.transmissionID, err.toString());
-                        }
-                    }
-                    break;
-                // this is a single channel userlist
-                case "userlist":
-                    if (msg.action === "RETRIEVE") {
-                        const channelID = msg.data;
-                        try {
-                            const channel = yield this.db.retrieveChannel(channelID);
-                            if (!channel) {
-                                this.sendErr(msg.transmissionID, "That channel doesn't exist.");
-                                break;
-                            }
-                            const permissions = yield this.db.retrievePermissions(this.getUser().userID, "server");
-                            for (const permission of permissions) {
-                                if (permission.resourceID === channel.serverID) {
-                                    // we've got the permission, it's ok to give them the userlist
-                                    const groupMembers = yield this.db.retrieveGroupMembers(channelID);
-                                    this.sendSuccess(msg.transmissionID, groupMembers.map((user) => utils_1.censorUser(user)));
-                                    break;
-                                }
-                            }
-                        }
-                        catch (err) {
-                            this.sendErr(msg.transmissionID, err.toString());
-                        }
-                    }
-                    break;
-                case "keyBundle":
-                    if (msg.action === "RETRIEVE") {
-                        try {
-                            const keyBundle = yield this.db.getKeyBundle(msg.data);
-                            if (keyBundle) {
-                                this.sendSuccess(msg.transmissionID, keyBundle);
-                            }
-                            else {
-                                this.sendErr(msg.transmissionID, "Couldn't retrieve key bundle.");
-                            }
-                        }
-                        catch (err) {
-                            this.log.error(err);
-                            this.sendErr(msg.transmissionID, err.toString());
-                        }
-                    }
-                    break;
-                case "mail":
-                    if (msg.action === "RETRIEVE") {
-                        try {
-                            const inbox = yield this.db.retrieveMail(this.getDevice().deviceID);
-                            for (const mail of inbox) {
-                                const [mailHeader, mailBody] = mail;
-                                this.sendSuccess(msg.transmissionID, mailBody, mailHeader);
-                            }
-                            this.sendSuccess(msg.transmissionID, null);
-                        }
-                        catch (err) {
-                            this.log.error(err);
-                            this.sendErr(msg.transmissionID, err.toString());
-                        }
-                    }
-                    if (msg.action === "CREATE") {
-                        const mail = msg.data;
-                        try {
-                            yield this.db.saveMail(mail, header, this.getDevice().deviceID, this.getUser().userID);
-                            this.log.info("Received mail for " + msg.data.recipient);
-                            const deviceDetails = yield this.db.retrieveDevice(msg.data.recipient);
-                            if (!deviceDetails) {
-                                this.sendErr(msg.transmissionID, "No associated user record found for device.");
-                                return;
-                            }
-                            this.sendSuccess(msg.transmissionID, null);
-                            this.notify(deviceDetails.owner, "mail", msg.transmissionID, null, msg.data.recipient);
-                        }
-                        catch (err) {
-                            this.log.error(err);
-                            this.sendErr(msg.transmissionID, err.toString());
-                        }
-                    }
-                    break;
-                case "servers":
-                    if (msg.action === "RETRIEVE") {
-                        const servers = yield this.db.retrieveServers(this.getUser().userID);
-                        this.sendSuccess(msg.transmissionID, servers);
-                    }
-                    if (msg.action === "CREATE") {
-                        const server = yield this.db.createServer(msg.data, this.getUser().userID);
-                        this.sendSuccess(msg.transmissionID, server);
-                    }
-                    if (msg.action === "DELETE") {
-                        const permissions = yield this.db.retrievePermissions(this.getUser().userID, "server");
-                        let found = false;
-                        for (const permission of permissions) {
-                            if (permission.resourceID === msg.data &&
-                                permission.powerLevel > 50) {
-                                // msg.data is the serverID
-                                yield this.db.deleteServer(msg.data);
-                                this.sendSuccess(msg.transmissionID, null);
-                                found = true;
-                                break;
-                            }
-                        }
-                        if (!found) {
-                            this.sendErr(msg.transmissionID, "You don't have permission to do that.");
-                        }
-                    }
-                    break;
-                case "channels":
-                    if (msg.action === "RETRIEVE") {
-                        const permissions = yield this.db.retrievePermissions(this.getUser().userID, "server");
-                        for (const permission of permissions) {
-                            if (msg.data === permission.resourceID) {
-                                const channels = yield this.db.retrieveChannels(permission.resourceID);
-                                this.sendSuccess(msg.transmissionID, channels);
-                                break;
-                            }
-                        }
-                        this.sendSuccess(msg.transmissionID, []);
-                    }
-                    if (msg.action === "CREATE") {
-                        // resourceID is serverID
-                        const { serverID, name } = msg.data;
-                        const permissions = yield this.db.retrievePermissions(this.getUser().userID, "server");
-                        let found = false;
-                        for (const permission of permissions) {
-                            if (permission.resourceID === serverID &&
-                                permission.powerLevel > exports.POWER_LEVELS.CREATE) {
-                                const channel = yield this.db.createChannel(name, serverID);
-                                this.sendSuccess(msg.transmissionID, channel);
-                                found = true;
-                                break;
-                            }
-                        }
-                        if (!found) {
-                            this.sendErr(msg.transmissionID, "You don't have permission to do that.");
-                        }
-                        else {
-                            this.notifyServerChange(serverID, msg.transmissionID);
-                        }
-                        break;
-                    }
-                    if (msg.action === "DELETE") {
-                        const channel = yield this.db.retrieveChannel(msg.data || "");
-                        if (!channel) {
-                            this.sendErr(msg.transmissionID, "You don't have permission to do that.");
-                            break;
-                        }
-                        const permissions = yield this.db.retrievePermissions(this.getUser().userID, "server");
-                        let found = false;
-                        for (const permission of permissions) {
-                            if (permission.resourceID === channel.serverID &&
-                                permission.powerLevel > 50) {
-                                found = true;
-                                // msg.data is the channelID
-                                yield this.db.deleteChannel(msg.data);
-                                this.sendSuccess(msg.transmissionID, null);
-                                this.notifyServerChange(channel.serverID, msg.transmissionID);
-                                found = true;
-                                break;
-                            }
-                        }
-                        if (!found) {
-                            this.sendErr(msg.transmissionID, "You don't have permission to do that.");
-                        }
-                    }
-                    break;
-                default:
-                    this.log.info("Unsupported resource type " + msg.resourceType);
-            }
-        });
-    }
-    handleReceipt(msg) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.db.deleteMail(msg.nonce, this.getDevice().deviceID);
-        });
+    async handleReceipt(msg) {
+        await this.db.deleteMail(msg.nonce, this.getDevice().deviceID);
     }
     initListeners() {
         this.conn.on("open", () => {
@@ -512,8 +117,8 @@ class ClientManager extends events_1.EventEmitter {
                 if (!this.authed) {
                     this.conn.close();
                 }
-            }, Spire_1.TOKEN_EXPIRY);
-            this.pingLoop();
+            }, TOKEN_EXPIRY);
+            void this.pingLoop();
         });
         this.conn.on("close", () => {
             this.fail();
@@ -523,50 +128,49 @@ class ClientManager extends events_1.EventEmitter {
             const size = Buffer.byteLength(message);
             if (size > MAX_MSG_SIZE) {
                 this.sendErr(msg.transmissionID, "Message is too big. Received size " +
-                    size +
+                    String(size) +
                     " while max size is " +
-                    MAX_MSG_SIZE);
+                    String(MAX_MSG_SIZE));
                 return;
             }
-            this.log.info(chalk_1.default.bold("⟵   ") +
-                (msg.type === "resource"
-                    ? crudColor(msg.action.toUpperCase()) +
-                        " " +
-                        chalk_1.default.bold(msg.resourceType.toUpperCase())
-                    : chalk_1.default.bold(msg.type.toUpperCase())) +
+            this.log.info(pc.bold("⟵   ") +
+                pc.bold(msg.type.toUpperCase()) +
                 " " +
                 this.toString() +
                 " " +
-                chalk_1.default.yellow(size));
-            this.log.debug(chalk_1.default.red.bold("INH"), header.toString());
-            this.log.debug(chalk_1.default.red.bold("IN"), msg);
+                pc.yellow(String(size)));
+            this.log.debug(pc.bold(pc.red("INH")), header.toString());
+            this.log.debug(pc.bold(pc.red("IN")), msg);
             if (!msg.type) {
                 this.sendErr(msg.transmissionID, "Message type is required.");
                 return;
             }
-            if (!uuid_1.validate(msg.transmissionID)) {
-                this.sendErr(uuid_1.v4(), "transmissionID is required and must be a valid uuid.");
+            if (!uuidValidate(msg.transmissionID)) {
+                this.sendErr(crypto.randomUUID(), "transmissionID is required and must be a valid uuid.");
                 return;
             }
             switch (msg.type) {
+                case "ping":
+                    this.pong(msg.transmissionID);
+                    break;
+                case "pong":
+                    this.setAlive(true);
+                    break;
                 case "receipt":
-                    this.handleReceipt(msg);
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- narrowed by msg.type
+                    void this.handleReceipt(msg);
                     break;
                 case "resource":
                     if (!this.authed) {
                         this.sendErr(msg.transmissionID, "You are not authenticated.");
                         break;
                     }
-                    this.parseResourceMsg(msg, header);
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- narrowed by msg.type
+                    void this.parseResourceMsg(msg, header);
                     break;
                 case "response":
-                    this.verifyResponse(msg);
-                    break;
-                case "ping":
-                    this.pong(msg.transmissionID);
-                    break;
-                case "pong":
-                    this.setAlive(true);
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- narrowed by msg.type
+                    void this.verifyResponse(msg);
                     break;
                 default:
                     this.log.info("unsupported message %s", msg.type);
@@ -574,29 +178,148 @@ class ClientManager extends events_1.EventEmitter {
             }
         });
     }
-}
-exports.ClientManager = ClientManager;
-const crudColor = (action) => {
-    switch (action) {
-        case "CREATE":
-            return chalk_1.default.yellow.bold(action);
-        case "RETRIEVE":
-            return chalk_1.default.yellow.bold(action);
-        case "UPDATE":
-            return chalk_1.default.cyan.bold(action);
-        case "DELETE":
-            return chalk_1.default.red.bold(action);
-        default:
-            return action;
+    async parseResourceMsg(msg, header) {
+        switch (msg.resourceType) {
+            case "mail":
+                if (msg.action === "CREATE") {
+                    const mailResult = MailWSSchema.safeParse(msg.data);
+                    if (!mailResult.success) {
+                        this.sendErr(msg.transmissionID, "Invalid mail payload: " +
+                            JSON.stringify(mailResult.error.issues));
+                        return;
+                    }
+                    const mail = mailResult.data;
+                    try {
+                        await this.db.saveMail(mail, header, this.getDevice().deviceID, this.getUser().userID);
+                        this.log.info("Received mail for " + mail.recipient);
+                        const deviceDetails = await this.db.retrieveDevice(mail.recipient);
+                        if (!deviceDetails) {
+                            this.sendErr(msg.transmissionID, "No associated user record found for device.");
+                            return;
+                        }
+                        this.sendSuccess(msg.transmissionID, null);
+                        this.notify(deviceDetails.owner, "mail", msg.transmissionID, null, mail.recipient);
+                    }
+                    catch (err) {
+                        this.log.error(String(err));
+                        this.sendErr(msg.transmissionID, String(err));
+                    }
+                }
+                break;
+            default:
+                this.log.info("Unsupported resource type " + msg.resourceType);
+        }
     }
-};
+    ping() {
+        if (!this.alive) {
+            this.fail();
+            return;
+        }
+        this.setAlive(false);
+        const p = { transmissionID: crypto.randomUUID(), type: "ping" };
+        this.send(p);
+    }
+    async pingLoop() {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- intentional infinite loop
+        while (true) {
+            this.ping();
+            await sleep(5000);
+        }
+    }
+    pong(transmissionID) {
+        // ping is allowed before auth
+        if (this.user) {
+            void this.db.markUserSeen(this.user);
+        }
+        const p = { transmissionID, type: "pong" };
+        this.send(p);
+    }
+    sendAuthedMessage(transmissionID) {
+        this.send({ transmissionID, type: "authorized" });
+    }
+    sendAuthError(error) {
+        const msg = {
+            error,
+            transmissionID: crypto.randomUUID(),
+            type: "authErr",
+        };
+        this.send(msg);
+    }
+    sendErr(transmissionID, message, data) {
+        const error = {
+            data,
+            error: message,
+            transmissionID,
+            type: "error",
+        };
+        this.send(error);
+    }
+    sendSuccess(transmissionID, data, header, timestamp) {
+        const msg = {
+            data,
+            timestamp,
+            transmissionID,
+            type: "success",
+        };
+        this.send(msg, header);
+    }
+    setAlive(status) {
+        this.alive = status;
+    }
+    async verifyResponse(msg) {
+        const user = await this.db.retrieveUser(this.userDetails.userID);
+        if (user) {
+            const devices = await this.db.retrieveUserDeviceList([user.userID]);
+            let message = null;
+            for (const device of devices) {
+                const verified = xSignOpen(msg.signed, XUtils.decodeHex(device.signKey));
+                if (verified) {
+                    message = verified;
+                    this.device = device;
+                }
+            }
+            if (!message) {
+                this.log.warn("Signature verification failed!");
+                this.sendAuthError(SocketAuthErrors.BadSignature);
+                this.fail();
+                return;
+            }
+            if (XUtils.bytesEqual(this.challengeID, message)) {
+                this.user = user;
+                this.authorize(msg.transmissionID);
+            }
+            else {
+                this.log.warn("Token is bad!");
+                this.sendAuthError(SocketAuthErrors.InvalidToken);
+            }
+        }
+        else {
+            this.log.info("User is not registered.");
+            this.sendAuthError(SocketAuthErrors.UserNotRegistered);
+            this.fail();
+        }
+    }
+}
+function packMessage(msg, header) {
+    const msgb = Uint8Array.from(msgpack.encode(msg));
+    const msgh = header || emptyHeader();
+    return xConcat(msgh, msgb);
+}
+function unpackMessage(msg) {
+    const msgp = Uint8Array.from(msg);
+    const msgh = msgp.slice(0, 32);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- msgpack.decode returns any
+    const msgb = msgpack.decode(msgp.slice(32));
+    return [msgh, msgb];
+}
 const responseColor = (status) => {
     switch (status) {
-        case "SUCCESS":
-            return chalk_1.default.green.bold(status);
         case "ERROR":
-            return chalk_1.default.red.bold(status);
+            return pc.bold(pc.red(status));
+        case "SUCCESS":
+            return pc.bold(pc.green(status));
         default:
             return status;
     }
 };
+//# sourceMappingURL=ClientManager.js.map