@vex-chat/libvex 1.0.1 → 1.1.0

package/dist/Client.js

@@ -2,32 +2,31 @@
 import { sleep } from "@extrahash/sleep";
 import { xConcat, xConstants, xDH, xEncode, xHMAC, xKDF, XKeyConvert, xMakeNonce, xMnemonic, XUtils, } from "@vex-chat/crypto";
 import { MailType } from "@vex-chat/types";
-import ax, { AxiosError } from "axios";
-import { isBrowser, isNode } from "browser-or-node";
-import btoa from "btoa";
-import chalk from "chalk";
-import { EventEmitter } from "events";
+import axios, { AxiosError } from "axios";
+import pc from "picocolors";
+import { EventEmitter } from "eventemitter3";
 import { Packr } from "msgpackr";
 // useRecords:false emits standard msgpack (no nonstandard record extension).
 // moreTypes:false keeps the extension set to what every other decoder understands.
-// Packr.pack() returns Node Buffer, which axios sends correctly (plain Uint8Array
-// would have its pool buffer sent in full — see axios issue #4068).
-const msgpack = new Packr({ useRecords: false, moreTypes: false });
+const _packr = new Packr({ useRecords: false, moreTypes: false });
+// Packr.encode() returns a subarray of its internal pool buffer.
+// In browsers, XMLHttpRequest.send() sends the full underlying ArrayBuffer,
+// not just the slice — corrupting the payload (axios issue #4068).
+// Wrap encode to always return a fresh copy.
+const msgpack = {
+    encode: (value) => {
+        const packed = _packr.encode(value);
+        return new Uint8Array(packed.buffer.slice(packed.byteOffset, packed.byteOffset + packed.byteLength));
+    },
+    decode: _packr.decode.bind(_packr),
+};
 import objectHash from "object-hash";
-import * as os from "node:os";
-import { performance } from "node:perf_hooks";
 import nacl from "tweetnacl";
 import * as uuid from "uuid";
-import winston from "winston";
-import WebSocket from "ws";
-import { Storage } from "./Storage.js";
 import { capitalize } from "./utils/capitalize.js";
-import { createLogger } from "./utils/createLogger.js";
 import { formatBytes } from "./utils/formatBytes.js";
 import { sqlSessionToCrypto } from "./utils/sqlSessionToCrypto.js";
 import { uuidToUint8 } from "./utils/uint8uuid.js";
-ax.defaults.withCredentials = true;
-ax.defaults.responseType = "arraybuffer";
 const protocolMsgRegex = /��\w+:\w+��/g;
 /**
  * Client provides an interface for you to use a vex chat server and
@@ -78,17 +77,17 @@ const protocolMsgRegex = /��\w+:\w+��/g;
  */
 export class Client extends EventEmitter {
     /**
-     * Loads a key file from disk.
+     * Encrypts a secret key with a password.
      *
      * Pass-through utility from `@vex-chat/crypto`.
      */
-    static loadKeyFile = XUtils.loadKeyFile;
+    static encryptKeyData = XUtils.encryptKeyData;
     /**
-     * Saves a key file to disk.
+     * Decrypts a secret key from encrypted data produced by encryptKeyData().
      *
      * Pass-through utility from `@vex-chat/crypto`.
      */
-    static saveKeyFile = XUtils.saveKeyFile;
+    static decryptKeyData = XUtils.decryptKeyData;
     /**
      * Creates and initializes a client in one step.
      *
@@ -102,7 +101,36 @@ export class Client extends EventEmitter {
      * ```
      */
     static create = async (privateKey, options, storage) => {
-        const client = new Client(privateKey, options, storage);
+        let opts = options;
+        if (!opts?.adapters) {
+            const { default: WebSocket } = await import("ws");
+            const { createLogger: makeLog } = await import("./utils/createLogger.js");
+            opts = {
+                ...opts,
+                adapters: {
+                    logger: makeLog("libvex", opts?.logLevel),
+                    WebSocket: WebSocket,
+                },
+            };
+        }
+        // Lazily create Node Storage only on the Node path (no adapters).
+        // When adapters are provided (browser/RN), the caller must supply storage
+        // via PlatformPreset.createStorage() — there is no Node fallback.
+        let resolvedStorage = storage;
+        if (!resolvedStorage) {
+            if (opts?.adapters) {
+                throw new Error("No storage provided. When using adapters (browser/RN), pass storage from your PlatformPreset.");
+            }
+            const { createNodeStorage } = await import("./storage/node.js");
+            const dbFileName = opts?.inMemoryDb
+                ? ":memory:"
+                : XUtils.encodeHex(nacl.sign.keyPair.fromSecretKey(XUtils.decodeHex(privateKey || "")).publicKey) + ".sqlite";
+            const dbPath = opts?.dbFolder
+                ? opts.dbFolder + "/" + dbFileName
+                : dbFileName;
+            resolvedStorage = createNodeStorage(dbPath, privateKey || XUtils.encodeHex(nacl.sign.keyPair().secretKey));
+        }
+        const client = new Client(privateKey, opts, resolvedStorage);
         await client.init();
         return client;
     };
@@ -397,6 +425,7 @@ export class Client extends EventEmitter {
     dbPath;
     conn;
     host;
+    adapters;
     firstMailFetch = true;
     // these are created from one set of sign keys
     signKeys;
@@ -410,7 +439,7 @@ export class Client extends EventEmitter {
     isAlive = true;
     reading = false;
     fetchingMail = false;
-    cookies = [];
+    ax;
     log;
     pingInterval = null;
     mailInterval;
@@ -418,9 +447,16 @@ export class Client extends EventEmitter {
     token = null;
     forwarded = [];
     prefixes;
+    options;
     constructor(privateKey, options, storage) {
         super();
-        this.log = createLogger("client", options?.logLevel);
+        this.options = options;
+        this.log = options?.adapters?.logger ?? {
+            info() { },
+            warn() { },
+            error() { },
+            debug() { },
+        };
         this.prefixes = options?.unsafeHttp
             ? { HTTP: "http://", WS: "ws://" }
             : { HTTP: "https://", WS: "wss://" };
@@ -438,17 +474,21 @@ export class Client extends EventEmitter {
         this.dbPath = options?.dbFolder
             ? options?.dbFolder + "/" + dbFileName
             : dbFileName;
-        this.database = storage
-            ? storage
-            : new Storage(this.dbPath, XUtils.encodeHex(this.signKeys.secretKey), options);
+        if (!storage) {
+            throw new Error("No storage provided. Use Client.create() which resolves storage automatically.");
+        }
+        this.database = storage;
         this.database.on("error", (error) => {
             this.log.error(error.toString());
             this.close(true);
         });
-        // we want to initialize this later with login()
-        this.conn = new WebSocket("ws://localhost:1234");
-        // silence the error for connecting to junk ws
-        // tslint:disable-next-line: no-empty
+        if (!options?.adapters) {
+            throw new Error("No adapters provided. Use Client.create() which resolves adapters automatically.");
+        }
+        this.adapters = options.adapters;
+        this.ax = axios.create({ responseType: "arraybuffer" });
+        // Placeholder connection — replaced by initSocket() during connect()
+        this.conn = new this.adapters.WebSocket("ws://localhost:1234");
         this.conn.onerror = () => { };
         this.log.info("Client debug information: " +
             JSON.stringify({
@@ -456,8 +496,7 @@ export class Client extends EventEmitter {
                 host: this.getHost(),
                 dbPath: this.dbPath,
                 environment: {
-                    isBrowser,
-                    isNode,
+                    platform: this.options?.deviceName ?? "unknown",
                 },
                 options,
             }, null, 4));
@@ -503,7 +542,7 @@ export class Client extends EventEmitter {
         };
     }
     /**
-     * Authenticates with username/password and stores the auth token/cookie.
+     * Authenticates with username/password and stores the Bearer auth token.
      *
      * @param username Account username.
      * @param password Account password.
@@ -517,23 +556,16 @@ export class Client extends EventEmitter {
      */
     async login(username, password) {
         try {
-            const res = await ax.post(this.getHost() + "/auth", msgpack.encode({
+            const res = await this.ax.post(this.getHost() + "/auth", msgpack.encode({
                 username,
                 password,
             }), {
                 headers: { "Content-Type": "application/msgpack" },
             });
-            const { user, token } = msgpack.decode(Buffer.from(res.data));
-            const cookies = res.headers["set-cookie"];
-            if (cookies) {
-                for (const cookie of cookies) {
-                    if (cookie.includes("auth")) {
-                        this.addCookie(cookie);
-                    }
-                }
-            }
+            const { user, token } = msgpack.decode(new Uint8Array(res.data));
             this.setUser(user);
             this.token = token;
+            this.ax.defaults.headers.common.Authorization = `Bearer ${token}`;
         }
         catch (err) {
             console.error(err.toString());
@@ -542,9 +574,38 @@ export class Client extends EventEmitter {
         return null;
     }
     /**
-     * Returns the authorization cookie details. Throws if you don't have a
-     * valid authorization cookie.
+     * Authenticates using the device's Ed25519 signing key.
+     * No password needed — proves possession of the private key via
+     * challenge-response. Issues a short-lived (1-hour) JWT.
+     *
+     * Used by auto-login when stored credentials have a deviceKey
+     * but no valid session.
      */
+    async loginWithDeviceKey(deviceID) {
+        try {
+            const id = deviceID ?? this.device?.deviceID;
+            if (!id) {
+                return new Error("No deviceID — pass it or connect first.");
+            }
+            const signKeyHex = XUtils.encodeHex(this.signKeys.publicKey);
+            const challengeRes = await this.ax.post(this.getHost() + "/auth/device", msgpack.encode({
+                deviceID: id,
+                signKey: signKeyHex,
+            }), { headers: { "Content-Type": "application/msgpack" } });
+            const { challengeID, challenge } = msgpack.decode(new Uint8Array(challengeRes.data));
+            const signed = XUtils.encodeHex(nacl.sign(XUtils.decodeHex(challenge), this.signKeys.secretKey));
+            const verifyRes = await this.ax.post(this.getHost() + "/auth/device/verify", msgpack.encode({ challengeID, signed }), { headers: { "Content-Type": "application/msgpack" } });
+            const { user, token } = msgpack.decode(new Uint8Array(verifyRes.data));
+            this.setUser(user);
+            this.token = token;
+            this.ax.defaults.headers.common.Authorization = `Bearer ${token}`;
+        }
+        catch (err) {
+            this.log.error("Device-key auth failed: " + err);
+            return err instanceof Error ? err : new Error(String(err));
+        }
+        return null;
+    }
     /**
      * Returns details about the currently authenticated session.
      *
@@ -557,28 +618,26 @@ export class Client extends EventEmitter {
      * ```
      */
     async whoami() {
-        const res = await ax.post(this.getHost() + "/whoami", null, {
-            withCredentials: true,
-            responseType: "arraybuffer",
-        });
-        const whoami = msgpack.decode(Buffer.from(res.data));
+        const res = await this.ax.post(this.getHost() + "/whoami");
+        const whoami = msgpack.decode(new Uint8Array(res.data));
         return whoami;
     }
     /**
      * Logs out the current authenticated session from the server.
      */
     async logout() {
-        await ax.post(this.getHost() + "/goodbye");
+        await this.ax.post(this.getHost() + "/goodbye");
     }
     /**
-     * Connects your device to the chat. You must have an valid authorization cookie.
+     * Connects your device to the chat. You must have a valid Bearer token.
      * You can check whoami() to see before calling connect().
      */
     async connect() {
         const { user, token } = await this.whoami();
         this.token = token;
+        this.ax.defaults.headers.common.Authorization = `Bearer ${token}`;
         if (!user || !token) {
-            throw new Error("Auth cookie missing or expired. Log in again.");
+            throw new Error("Auth token missing or expired. Log in again.");
         }
         this.setUser(user);
         this.device = await this.retrieveOrCreateDevice();
@@ -587,17 +646,14 @@ export class Client extends EventEmitter {
             throw new Error("Couldn't get connect token.");
         }
         const signed = nacl.sign(Uint8Array.from(uuid.parse(connectToken.key)), this.signKeys.secretKey);
-        const res = await ax.post(this.getHost() + "/device/" + this.device.deviceID + "/connect", msgpack.encode({ signed }), { headers: { "Content-Type": "application/msgpack" } });
-        const cookies = res.headers["set-cookie"];
-        if (cookies) {
-            for (const cookie of cookies) {
-                if (cookie.includes("device")) {
-                    this.addCookie(cookie);
-                }
-            }
-        }
+        const res = await this.ax.post(this.getHost() + "/device/" + this.device.deviceID + "/connect", msgpack.encode({ signed }), { headers: { "Content-Type": "application/msgpack" } });
+        const { deviceToken } = msgpack.decode(new Uint8Array(res.data));
+        this.ax.defaults.headers.common["X-Device-Token"] = deviceToken;
         this.log.info("Starting websocket.");
         this.initSocket();
+        // Yield the event loop so the WS open callback fires and sends the
+        // auth message before OTK generation blocks for ~5s on mobile.
+        await new Promise((r) => setTimeout(r, 0));
         await this.negotiateOTK();
     }
     /**
@@ -624,11 +680,11 @@ export class Client extends EventEmitter {
                 preKeySignature: XUtils.encodeHex(this.xKeyRing.preKeys.signature),
                 preKeyIndex: this.xKeyRing.preKeys.index,
                 password,
-                deviceName: `${os.platform()}`,
+                deviceName: this.options?.deviceName ?? "unknown",
             };
             try {
-                const res = await ax.post(this.getHost() + "/register", msgpack.encode(regMsg), { headers: { "Content-Type": "application/msgpack" } });
-                this.setUser(msgpack.decode(Buffer.from(res.data)));
+                const res = await this.ax.post(this.getHost() + "/register", msgpack.encode(regMsg), { headers: { "Content-Type": "application/msgpack" } });
+                this.setUser(msgpack.decode(new Uint8Array(res.data)));
                 return [this.getUser(), null];
             }
             catch (err) {
@@ -651,32 +707,31 @@ export class Client extends EventEmitter {
         return this.user?.username + "<" + this.device?.deviceID + ">";
     }
     async redeemInvite(inviteID) {
-        const res = await ax.patch(this.getHost() + "/invite/" + inviteID);
-        return msgpack.decode(Buffer.from(res.data));
+        const res = await this.ax.patch(this.getHost() + "/invite/" + inviteID);
+        return msgpack.decode(new Uint8Array(res.data));
     }
     async retrieveInvites(serverID) {
-        const res = await ax.get(this.getHost() + "/server/" + serverID + "/invites");
-        return msgpack.decode(Buffer.from(res.data));
+        const res = await this.ax.get(this.getHost() + "/server/" + serverID + "/invites");
+        return msgpack.decode(new Uint8Array(res.data));
     }
     async createInvite(serverID, duration) {
         const payload = {
             serverID,
             duration,
         };
-        const res = await ax.post(this.getHost() + "/server/" + serverID + "/invites", payload);
-        return msgpack.decode(Buffer.from(res.data));
+        const res = await this.ax.post(this.getHost() + "/server/" + serverID + "/invites", payload);
+        return msgpack.decode(new Uint8Array(res.data));
     }
     async retrieveEmojiList(serverID) {
-        const res = await ax.get(this.getHost() + "/server/" + serverID + "/emoji");
-        return msgpack.decode(Buffer.from(res.data));
+        const res = await this.ax.get(this.getHost() + "/server/" + serverID + "/emoji");
+        return msgpack.decode(new Uint8Array(res.data));
     }
     async retrieveEmojiByID(emojiID) {
-        const res = await ax.get(this.getHost() + "/emoji/" + emojiID + "/details");
-        // this is actually empty string
+        const res = await this.ax.get(this.getHost() + "/emoji/" + emojiID + "/details");
         if (!res.data) {
             return null;
         }
-        return msgpack.decode(Buffer.from(res.data));
+        return msgpack.decode(new Uint8Array(res.data));
     }
     async leaveServer(serverID) {
         const permissionList = await this.permissions.retrieve();
@@ -696,25 +751,13 @@ export class Client extends EventEmitter {
         }
         throw new Error("Couldn't kick user.");
     }
-    addCookie(cookie) {
-        if (!this.cookies.includes(cookie)) {
-            this.cookies.push(cookie);
-            this.log.info("cookies changed", this.getCookies());
-            if (isNode) {
-                ax.defaults.headers.cookie = this.cookies.join(";");
-            }
-        }
-    }
-    getCookies() {
-        return this.cookies.join(";");
-    }
     async uploadEmoji(emoji, name, serverID) {
         if (typeof FormData !== "undefined") {
             const fpayload = new FormData();
             fpayload.set("emoji", new Blob([new Uint8Array(emoji)]));
             fpayload.set("name", name);
             try {
-                const res = await ax.post(this.getHost() + "/emoji/" + serverID, fpayload, {
+                const res = await this.ax.post(this.getHost() + "/emoji/" + serverID, fpayload, {
                     headers: { "Content-Type": "multipart/form-data" },
                     onUploadProgress: (progressEvent) => {
                         const percentCompleted = Math.round((progressEvent.loaded * 100) /
@@ -730,7 +773,7 @@ export class Client extends EventEmitter {
                         this.emit("fileProgress", progress);
                     },
                 });
-                return msgpack.decode(Buffer.from(res.data));
+                return msgpack.decode(new Uint8Array(res.data));
             }
             catch (err) {
                 return null;
@@ -741,8 +784,8 @@ export class Client extends EventEmitter {
             name,
         };
         try {
-            const res = await ax.post(this.getHost() + "/emoji/" + serverID + "/json", msgpack.encode(payload), { headers: { "Content-Type": "application/msgpack" } });
-            return msgpack.decode(Buffer.from(res.data));
+            const res = await this.ax.post(this.getHost() + "/emoji/" + serverID + "/json", msgpack.encode(payload), { headers: { "Content-Type": "application/msgpack" } });
+            return msgpack.decode(new Uint8Array(res.data));
         }
         catch (err) {
             return null;
@@ -751,11 +794,11 @@ export class Client extends EventEmitter {
     async retrieveOrCreateDevice() {
         let device;
         try {
-            const res = await ax.get(this.prefixes.HTTP +
+            const res = await this.ax.get(this.prefixes.HTTP +
                 this.host +
                 "/device/" +
                 XUtils.encodeHex(this.signKeys.publicKey));
-            device = msgpack.decode(Buffer.from(res.data));
+            device = msgpack.decode(new Uint8Array(res.data));
         }
         catch (err) {
             this.log.error(err.toString());
@@ -803,15 +846,15 @@ export class Client extends EventEmitter {
             preKey: XUtils.encodeHex(this.xKeyRing.preKeys.keyPair.publicKey),
             preKeySignature: XUtils.encodeHex(this.xKeyRing.preKeys.signature),
             preKeyIndex: this.xKeyRing.preKeys.index,
-            deviceName: `${os.platform()}`,
+            deviceName: this.options?.deviceName ?? "unknown",
         };
         try {
-            const res = await ax.post(this.prefixes.HTTP +
+            const res = await this.ax.post(this.prefixes.HTTP +
                 this.host +
                 "/user/" +
                 userDetails.userID +
                 "/devices", msgpack.encode(devMsg), { headers: { "Content-Type": "application/msgpack" } });
-            return msgpack.decode(Buffer.from(res.data));
+            return msgpack.decode(new Uint8Array(res.data));
         }
         catch (err) {
             throw err;
@@ -819,10 +862,10 @@ export class Client extends EventEmitter {
     }
     async getToken(type) {
         try {
-            const res = await ax.get(this.getHost() + "/token/" + type, {
+            const res = await this.ax.get(this.getHost() + "/token/" + type, {
                 responseType: "arraybuffer",
             });
-            return msgpack.decode(Buffer.from(res.data));
+            return msgpack.decode(new Uint8Array(res.data));
         }
         catch (err) {
             this.log.warn(err.toString());
@@ -833,7 +876,7 @@ export class Client extends EventEmitter {
         if (typeof FormData !== "undefined") {
             const fpayload = new FormData();
             fpayload.set("avatar", new Blob([new Uint8Array(avatar)]));
-            await ax.post(this.prefixes.HTTP +
+            await this.ax.post(this.prefixes.HTTP +
                 this.host +
                 "/avatar/" +
                 this.me.user().userID, fpayload, {
@@ -857,7 +900,7 @@ export class Client extends EventEmitter {
         const payload = {
             file: XUtils.encodeBase64(avatar),
         };
-        await ax.post(this.prefixes.HTTP +
+        await this.ax.post(this.prefixes.HTTP +
             this.host +
             "/avatar/" +
             this.me.user().userID +
@@ -869,12 +912,12 @@ export class Client extends EventEmitter {
      * @returns - The list of IPermissions objects.
      */
     async fetchPermissionList(serverID) {
-        const res = await ax.get(this.prefixes.HTTP +
+        const res = await this.ax.get(this.prefixes.HTTP +
             this.host +
             "/server/" +
             serverID +
             "/permissions");
-        return msgpack.decode(Buffer.from(res.data));
+        return msgpack.decode(new Uint8Array(res.data));
     }
     /**
      * Gets all permissions for the logged in user.
@@ -882,17 +925,17 @@ export class Client extends EventEmitter {
      * @returns - The list of IPermissions objects.
      */
     async getPermissions() {
-        const res = await ax.get(this.getHost() + "/user/" + this.getUser().userID + "/permissions");
-        return msgpack.decode(Buffer.from(res.data));
+        const res = await this.ax.get(this.getHost() + "/user/" + this.getUser().userID + "/permissions");
+        return msgpack.decode(new Uint8Array(res.data));
     }
     async deletePermission(permissionID) {
-        await ax.delete(this.getHost() + "/permission/" + permissionID);
+        await this.ax.delete(this.getHost() + "/permission/" + permissionID);
     }
     async retrieveFile(fileID, key) {
         try {
-            const detailsRes = await ax.get(this.getHost() + "/file/" + fileID + "/details");
-            const details = msgpack.decode(Buffer.from(detailsRes.data));
-            const res = await ax.get(this.getHost() + "/file/" + fileID, {
+            const detailsRes = await this.ax.get(this.getHost() + "/file/" + fileID + "/details");
+            const details = msgpack.decode(new Uint8Array(detailsRes.data));
+            const res = await this.ax.get(this.getHost() + "/file/" + fileID, {
                 onDownloadProgress: (progressEvent) => {
                     const percentCompleted = Math.round((progressEvent.loaded * 100) /
                         (progressEvent.total ?? 1));
@@ -908,11 +951,11 @@ export class Client extends EventEmitter {
                 },
             });
             const fileData = res.data;
-            const decrypted = nacl.secretbox.open(Uint8Array.from(Buffer.from(fileData)), XUtils.decodeHex(details.nonce), XUtils.decodeHex(key));
+            const decrypted = nacl.secretbox.open(new Uint8Array(fileData), XUtils.decodeHex(details.nonce), XUtils.decodeHex(key));
             if (decrypted) {
                 const resp = {
                     details,
-                    data: Buffer.from(decrypted),
+                    data: new Uint8Array(decrypted),
                 };
                 return resp;
             }
@@ -923,14 +966,14 @@ export class Client extends EventEmitter {
         }
     }
     async deleteServer(serverID) {
-        await ax.delete(this.getHost() + "/server/" + serverID);
+        await this.ax.delete(this.getHost() + "/server/" + serverID);
     }
     /**
      * Initializes the keyring. This must be called before anything else.
      */
     async init() {
         if (this.hasInit) {
-            return new Error("You should only call init() once.");
+            throw new Error("You should only call init() once.");
         }
         this.hasInit = true;
         await this.populateKeyRing();
@@ -947,21 +990,21 @@ export class Client extends EventEmitter {
         this.emit("ready");
     }
     async deleteChannel(channelID) {
-        await ax.delete(this.getHost() + "/channel/" + channelID);
+        await this.ax.delete(this.getHost() + "/channel/" + channelID);
     }
     // returns the file details and the encryption key
     async createFile(file) {
-        this.log.info("Creating file, size: " + formatBytes(Buffer.byteLength(file)));
+        this.log.info("Creating file, size: " + formatBytes(file.byteLength));
         const nonce = xMakeNonce();
         const key = nacl.box.keyPair();
         const box = nacl.secretbox(Uint8Array.from(file), nonce, key.secretKey);
-        this.log.info("Encrypted size: " + formatBytes(Buffer.byteLength(box)));
+        this.log.info("Encrypted size: " + formatBytes(box.byteLength));
         if (typeof FormData !== "undefined") {
             const fpayload = new FormData();
             fpayload.set("owner", this.getDevice().deviceID);
             fpayload.set("nonce", XUtils.encodeHex(nonce));
             fpayload.set("file", new Blob([new Uint8Array(box)]));
-            const fres = await ax.post(this.getHost() + "/file", fpayload, {
+            const fres = await this.ax.post(this.getHost() + "/file", fpayload, {
                 headers: { "Content-Type": "multipart/form-data" },
                 onUploadProgress: (progressEvent) => {
                     const percentCompleted = Math.round((progressEvent.loaded * 100) /
@@ -977,7 +1020,7 @@ export class Client extends EventEmitter {
                     this.emit("fileProgress", progress);
                 },
             });
-            const fcreatedFile = msgpack.decode(Buffer.from(fres.data));
+            const fcreatedFile = msgpack.decode(new Uint8Array(fres.data));
             return [fcreatedFile, XUtils.encodeHex(key.secretKey)];
         }
         const payload = {
@@ -985,13 +1028,13 @@ export class Client extends EventEmitter {
             nonce: XUtils.encodeHex(nonce),
             file: XUtils.encodeBase64(box),
         };
-        const res = await ax.post(this.getHost() + "/file/json", msgpack.encode(payload), { headers: { "Content-Type": "application/msgpack" } });
-        const createdFile = msgpack.decode(Buffer.from(res.data));
+        const res = await this.ax.post(this.getHost() + "/file/json", msgpack.encode(payload), { headers: { "Content-Type": "application/msgpack" } });
+        const createdFile = msgpack.decode(new Uint8Array(res.data));
         return [createdFile, XUtils.encodeHex(key.secretKey)];
     }
     async getUserList(channelID) {
-        const res = await ax.post(this.getHost() + "/userList/" + channelID);
-        return msgpack.decode(Buffer.from(res.data));
+        const res = await this.ax.post(this.getHost() + "/userList/" + channelID);
+        return msgpack.decode(new Uint8Array(res.data));
     }
     async markSessionVerified(sessionID) {
         return this.database.markSessionVerified(sessionID);
@@ -1040,7 +1083,7 @@ export class Client extends EventEmitter {
                     const { status } = result;
                     if (status === "rejected") {
                         this.log.warn("Message failed.");
-                        this.log.warn(result);
+                        this.log.warn(JSON.stringify(result));
                     }
                 }
             });
@@ -1073,14 +1116,14 @@ export class Client extends EventEmitter {
                 const { status } = result;
                 if (status === "rejected") {
                     this.log.warn("Message failed.");
-                    this.log.warn(result);
+                    this.log.warn(JSON.stringify(result));
                 }
             }
         });
     }
     async createServer(name) {
-        const res = await ax.post(this.getHost() + "/server/" + btoa(name));
-        return msgpack.decode(Buffer.from(res.data));
+        const res = await this.ax.post(this.getHost() + "/server/" + globalThis.btoa(name));
+        return msgpack.decode(new Uint8Array(res.data));
     }
     async forward(message) {
         const copy = { ...message };
@@ -1109,7 +1152,7 @@ export class Client extends EventEmitter {
                 const { status } = result;
                 if (status === "rejected") {
                     this.log.warn("Message failed.");
-                    this.log.warn(result);
+                    this.log.warn(JSON.stringify(result));
                 }
             }
         });
@@ -1203,13 +1246,13 @@ export class Client extends EventEmitter {
         return this.database.getAllSessions();
     }
     async getServerList() {
-        const res = await ax.get(this.getHost() + "/user/" + this.getUser().userID + "/servers");
-        return msgpack.decode(Buffer.from(res.data));
+        const res = await this.ax.get(this.getHost() + "/user/" + this.getUser().userID + "/servers");
+        return msgpack.decode(new Uint8Array(res.data));
     }
     async createChannel(name, serverID) {
         const body = { name };
-        const res = await ax.post(this.getHost() + "/server/" + serverID + "/channels", msgpack.encode(body), { headers: { "Content-Type": "application/msgpack" } });
-        return msgpack.decode(Buffer.from(res.data));
+        const res = await this.ax.post(this.getHost() + "/server/" + serverID + "/channels", msgpack.encode(body), { headers: { "Content-Type": "application/msgpack" } });
+        return msgpack.decode(new Uint8Array(res.data));
     }
     async getDeviceByID(deviceID) {
         if (this.deviceRecords[deviceID]) {
@@ -1223,9 +1266,9 @@ export class Client extends EventEmitter {
             return device;
         }
         try {
-            const res = await ax.get(this.getHost() + "/device/" + deviceID);
+            const res = await this.ax.get(this.getHost() + "/device/" + deviceID);
             this.log.info("Retrieved device from server.");
-            const fetchedDevice = msgpack.decode(Buffer.from(res.data));
+            const fetchedDevice = msgpack.decode(new Uint8Array(res.data));
             this.deviceRecords[deviceID] = fetchedDevice;
             await this.database.saveDevice(fetchedDevice);
             return fetchedDevice;
@@ -1238,7 +1281,7 @@ export class Client extends EventEmitter {
         if (deviceID === this.getDevice().deviceID) {
             throw new Error("You can't delete the device you're logged in to.");
         }
-        await ax.delete(this.prefixes.HTTP +
+        await this.ax.delete(this.prefixes.HTTP +
             this.host +
             "/user/" +
             this.getUser().userID +
@@ -1247,8 +1290,8 @@ export class Client extends EventEmitter {
     }
     async getMultiUserDeviceList(userIDs) {
         try {
-            const res = await ax.post(this.getHost() + "/deviceList", msgpack.encode(userIDs), { headers: { "Content-Type": "application/msgpack" } });
-            const devices = msgpack.decode(Buffer.from(res.data));
+            const res = await this.ax.post(this.getHost() + "/deviceList", msgpack.encode(userIDs), { headers: { "Content-Type": "application/msgpack" } });
+            const devices = msgpack.decode(new Uint8Array(res.data));
             for (const device of devices) {
                 this.deviceRecords[device.deviceID] = device;
             }
@@ -1260,8 +1303,8 @@ export class Client extends EventEmitter {
     }
     async getUserDeviceList(userID) {
         try {
-            const res = await ax.get(this.getHost() + "/user/" + userID + "/devices");
-            const devices = msgpack.decode(Buffer.from(res.data));
+            const res = await this.ax.get(this.getHost() + "/user/" + userID + "/devices");
+            const devices = msgpack.decode(new Uint8Array(res.data));
             for (const device of devices) {
                 this.deviceRecords[device.deviceID] = device;
             }
@@ -1273,8 +1316,8 @@ export class Client extends EventEmitter {
     }
     async getServerByID(serverID) {
         try {
-            const res = await ax.get(this.getHost() + "/server/" + serverID);
-            return msgpack.decode(Buffer.from(res.data));
+            const res = await this.ax.get(this.getHost() + "/server/" + serverID);
+            return msgpack.decode(new Uint8Array(res.data));
         }
         catch (err) {
             return null;
@@ -1282,16 +1325,16 @@ export class Client extends EventEmitter {
     }
     async getChannelByID(channelID) {
         try {
-            const res = await ax.get(this.getHost() + "/channel/" + channelID);
-            return msgpack.decode(Buffer.from(res.data));
+            const res = await this.ax.get(this.getHost() + "/channel/" + channelID);
+            return msgpack.decode(new Uint8Array(res.data));
         }
         catch (err) {
             return null;
         }
     }
     async getChannelList(serverID) {
-        const res = await ax.get(this.getHost() + "/server/" + serverID + "/channels");
-        return msgpack.decode(Buffer.from(res.data));
+        const res = await this.ax.get(this.getHost() + "/server/" + serverID + "/channels");
+        return msgpack.decode(new Uint8Array(res.data));
     }
     /* Get the currently logged in user. You cannot call this until
     after the auth event is emitted. */
@@ -1318,8 +1361,8 @@ export class Client extends EventEmitter {
             return [this.userRecords[userIdentifier], null];
         }
         try {
-            const res = await ax.get(this.getHost() + "/user/" + userIdentifier);
-            const userRecord = msgpack.decode(Buffer.from(res.data));
+            const res = await this.ax.get(this.getHost() + "/user/" + userIdentifier);
+            const userRecord = msgpack.decode(new Uint8Array(res.data));
             this.userRecords[userIdentifier] = userRecord;
             return [userRecord, null];
         }
@@ -1804,13 +1847,21 @@ export class Client extends EventEmitter {
             if (!this.token) {
                 throw new Error("No token found, did you call login()?");
             }
-            this.conn = new WebSocket(this.prefixes.WS + this.host + "/socket", { headers: { Cookie: "auth=" + this.token } });
+            const wsUrl = this.prefixes.WS + this.host + "/socket";
+            // Auth sent as first message after open
+            this.conn = new this.adapters.WebSocket(wsUrl);
             this.conn.on("open", () => {
                 this.log.info("Connection opened.");
+                // Send auth as first message before anything else.
+                this.conn.send(JSON.stringify({ type: "auth", token: this.token }));
                 this.pingInterval = setInterval(this.ping.bind(this), 15000);
             });
             this.conn.on("close", () => {
                 this.log.info("Connection closed.");
+                if (this.pingInterval) {
+                    clearInterval(this.pingInterval);
+                    this.pingInterval = null;
+                }
                 if (!this.manuallyClosing) {
                     this.emit("disconnect");
                 }
@@ -1820,8 +1871,8 @@ export class Client extends EventEmitter {
             });
             this.conn.on("message", async (message) => {
                 const [header, msg] = XUtils.unpackMessage(message);
-                this.log.debug(chalk.red.bold("INH ") + XUtils.encodeHex(header));
-                this.log.debug(chalk.red.bold("IN ") + JSON.stringify(msg, null, 4));
+                this.log.debug(pc.red(pc.bold("INH ") + XUtils.encodeHex(header)));
+                this.log.debug(pc.red(pc.bold("IN ") + JSON.stringify(msg, null, 4)));
                 switch (msg.type) {
                     case "ping":
                         this.pong(msg.transmissionID);
@@ -1894,12 +1945,12 @@ export class Client extends EventEmitter {
         }
         this.log.info("fetching mail for device " + this.getDevice().deviceID);
         try {
-            const res = await ax.post(this.getHost() +
+            const res = await this.ax.post(this.getHost() +
                 "/device/" +
                 this.getDevice().deviceID +
                 "/mail");
             const inbox = msgpack
-                .decode(Buffer.from(res.data))
+                .decode(new Uint8Array(res.data))
                 .sort((a, b) => b[2].getTime() - a[2].getTime());
             for (const mailDetails of inbox) {
                 const [mailHeader, mailBody, timestamp] = mailDetails;
@@ -1925,21 +1976,21 @@ export class Client extends EventEmitter {
             await sleep(i);
             i *= 2;
         }
-        this.log.debug(chalk.red.bold("OUTH ") +
-            XUtils.encodeHex(header || XUtils.emptyHeader()));
-        this.log.debug(chalk.red.bold("OUT ") + JSON.stringify(msg, null, 4));
+        this.log.debug(pc.red(pc.bold("OUTH ") +
+            XUtils.encodeHex(header || XUtils.emptyHeader())));
+        this.log.debug(pc.red(pc.bold("OUT ") + JSON.stringify(msg, null, 4)));
         this.conn.send(XUtils.packMessage(msg, header));
     }
     async retrieveKeyBundle(deviceID) {
-        const res = await ax.post(this.getHost() + "/device/" + deviceID + "/keyBundle");
-        return msgpack.decode(Buffer.from(res.data));
+        const res = await this.ax.post(this.getHost() + "/device/" + deviceID + "/keyBundle");
+        return msgpack.decode(new Uint8Array(res.data));
     }
     async getOTKCount() {
-        const res = await ax.get(this.getHost() +
+        const res = await this.ax.get(this.getHost() +
             "/device/" +
             this.getDevice().deviceID +
             "/otk/count");
-        return msgpack.decode(Buffer.from(res.data)).count;
+        return msgpack.decode(new Uint8Array(res.data)).count;
     }
     async submitOTK(amount) {
         const otks = [];
@@ -1950,7 +2001,7 @@ export class Client extends EventEmitter {
         const t1 = performance.now();
         this.log.info("Generated " + amount + " one time keys in " + (t1 - t0) + " ms.");
         const savedKeys = await this.database.savePreKeys(otks, true);
-        await ax.post(this.getHost() + "/device/" + this.getDevice().deviceID + "/otk", msgpack.encode(savedKeys.map((key) => this.censorPreKey(key))), {
+        await this.ax.post(this.getHost() + "/device/" + this.getDevice().deviceID + "/otk", msgpack.encode(savedKeys.map((key) => this.censorPreKey(key))), {
             headers: { "Content-Type": "application/msgpack" },
         });
     }