mpp-client-net 1.1.3

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,33 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://help.github.com/actions/language-and-framework-guides/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - run: npm ci
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/.prettierrc

@@ -0,0 +1,5 @@
+{
+    "arrowParens": "avoid",
+    "tabWidth": 4,
+    "trailingComma": "none"
+}

package/Client.d.ts

@@ -0,0 +1,242 @@
+import type { EventEmitter } from "events";
+
+declare interface Tag {
+    text: string;
+    color: string;
+}
+
+declare interface User {
+    _id: string; // user id
+    name: string;
+    color: string;
+    tag?: Tag;
+}
+
+declare interface Participant extends User {
+    id: string; // participant id (same as user id on mppclone)
+}
+
+declare type ChannelSettings = {
+    color: string;
+    crownsolo: boolean;
+    chat: boolean;
+    visible: boolean;
+    limit: number;
+} & Partial<{
+    color2: string;
+    lobby: boolean;
+    owner_id: string;
+    "lyrical notes": boolean;
+    "no cussing": boolean;
+    noindex: boolean;
+}>;
+
+declare type ChannelSettingValue = Partial<string | number | boolean>;
+
+declare type NoteLetter = `a` | `b` | `c` | `d` | `e` | `f` | `g`;
+declare type NoteOctave = -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
+
+declare interface Note {
+    n: `${NoteLetter}${NoteOctave}`;
+    d: number;
+    v: number;
+    s?: 1;
+}
+
+declare type Notification = Partial<{
+    duration: number;
+    class: string;
+    id: string;
+    title: string;
+    text: string;
+    html: string;
+    target: string;
+}>;
+
+declare type CustomTarget = {
+    global?: boolean;
+} & (
+    | {
+          mode: "subscribed";
+      }
+    | {
+          mode: "ids";
+          ids: string[];
+      }
+    | {
+          mode: "id";
+          id: string;
+      }
+);
+
+declare interface Crown {
+    userId: string;
+    partcipantId?: string;
+    time: number;
+    startPos: {
+        x: number;
+        y: number;
+    };
+    endPos: {
+        x: number;
+        y: number;
+    };
+}
+
+declare interface ChannelInfo {
+    banned?: boolean;
+    count: number;
+    id: string;
+    _id: string;
+    crown?: Crown;
+    settings: ChannelSettings;
+}
+
+declare class Client extends EventEmitter {
+    public uri: string;
+    public ws: WebSocket | undefined;
+    public serverTimeOffset: number;
+    public user: User | undefined;
+    public participantId: string | undefined;
+    public ppl: Record<string, Participant>;
+    public connectionTime: number;
+    public connectionAttempts: number;
+    public desiredChannelId: string | undefined;
+    public desiredChannelSettings: ChannelSettings | undefined;
+    public pingInterval: number | undefined;
+    public canConnect: boolean;
+    public noteBuffer: OutgoingMPPEvents["n"][];
+    public noteBufferTime: number;
+    public noteFlushInterval: number | undefined;
+    public permissions: Record<any, unknown>;
+    public ["🐈"]: number;
+    public loginInfo: unknown | undefined;
+    public token: string;
+
+    constructor(uri: string, token: string);
+
+    public isSupported(): boolean;
+    public isConnected(): boolean;
+    public isConnecting(): boolean;
+
+    public start(): void;
+    public stop(): void;
+    protected connect(): void;
+
+    protected bindEventListeners(): void;
+
+    public send(raw: string): void;
+    public sendArray<Event extends keyof OutgoingMPPEvents>(
+        arr: OutgoingMPPEvents[Event][]
+    ): void;
+    public setChannel(id: string, set?: Partial<ChannelSettings>): void;
+
+    public offlineChannelSettings: ChannelSettings;
+
+    public getChannelSetting(key: string): ChannelSettings[];
+    public setChannelSettings(settings: ChannelSettings): void;
+
+    public offlineParticipant: Participant;
+
+    public getOwnParticipant(): Participant;
+    public setParticipants(ppl: Participant[]): void;
+    public countParticipants(): number;
+    public participantUpdate(update: Participant): void;
+    public participantMoveMouse(update: Participant): void;
+    public removeParticipant(id: string): void;
+    public findParticipantById(id: string): void;
+
+    public isOwner(): boolean;
+    public preventsPlaying(): boolean;
+    public receiveServerTime(time: number, echo: number): void;
+    public startNote(note: string, vel: number): void;
+    public stopNote(note: string): void;
+    public sendPing(): void;
+    public setLoginInfo(loginInfo: any): void;
+
+    public on<Event extends keyof IncomingMPPEvents>(
+        event: Event,
+        listener: (msg: IncomingMPPEvents[Event]) => void
+    ): this;
+
+    public emit<Event extends keyof IncomingMPPEvents>(
+        event: Event,
+        ...args: Parameters<(msg: IncomingMPPEvents[Event]) => void>
+    ): boolean;
+}
+
+export default Client;
+
+declare interface IncomingMPPEvents {
+    a: { m: "a"; a: string; p: Participant; t: number };
+    b: { m: "b"; code: string };
+    c: { m: "c"; c: IncomingMPPEvents["a"][] };
+    ch: { m: "ch"; p: string; ch: ChannelInfo };
+    custom: { m: "custom"; data: any; p: string };
+    hi: {
+        m: "hi";
+        t: number;
+        u: User;
+        permissions: any;
+        token?: any;
+        accountInfo: any;
+    };
+    ls: { m: "ls"; c: boolean; u: ChannelInfo[] };
+    m: { m: "m"; x: number; y: number; id: string };
+    n: { m: "n"; t: number; n: Note[]; p: string };
+    notification: {
+        duration?: number;
+        class?: string;
+        id?: string;
+        title?: string;
+        text?: string;
+        html?: string;
+        target?: string;
+    };
+    nq: {
+        m: "nq";
+        allowance: number;
+        max: number;
+        maxHistLen: number;
+    };
+    p: {
+        m: "p";
+        x: number;
+        y: number;
+    } & Participant;
+    t: { m: "t"; t: number; e: number };
+}
+
+declare interface OutgoingMPPEvents {
+    a: { m: "a"; message: string };
+    bye: { m: "bye" };
+    ch: { m: "ch"; _id: string; set: ChannelSettings };
+    chown: { m: "chown"; id?: string };
+    chset: { m: "chset"; set: ChannelSettings };
+    custom: { m: "custom"; data: any; target: CustomTarget };
+    devices: { m: "devices"; list: any[] };
+    dm: { m: "dm"; message: string; _id: string };
+    hi: {
+        m: "hi";
+        token?: string;
+        login?: { type: string; code: string };
+        code?: string;
+    };
+    kickban: { m: "kickban"; _id: string; ms: number };
+    m: { m: "m"; x?: string | number; y?: string | number };
+    "-custom": { m: "-custom" };
+    "-ls": { m: "-ls" };
+    n: { m: "n"; t: number; n: Note[] };
+    "+custom": { m: "+custom" };
+    "+ls": { m: "+ls" };
+    t: { m: "t"; e: number };
+    unban: { m: "unban"; _id: string };
+    userset: {
+        m: "userset";
+        set: { name?: string; color?: string };
+    };
+    setcolor: { m: "setcolor"; color: string; _id: string };
+    setname: { m: "setname"; name: string; _id: string };
+}
+
+export { OutgoingMPPEvents, IncomingMPPEvents };

package/Client.js

@@ -0,0 +1,375 @@
+const { EventEmitter } = require('events');
+const WebSocket = require('ws');
+
+class Client extends EventEmitter {
+    constructor(uri, token) {
+        super()
+
+        this.uri = uri;
+        this.ws = undefined;
+        this.serverTimeOffset = 0;
+        this.user = undefined;
+        this.participantId = undefined;
+        this.channel = undefined;
+        this.ppl = {};
+        this.connectionTime = undefined;
+        this.connectionAttempts = 0;
+        this.desiredChannelId = undefined;
+        this.desiredChannelSettings = undefined;
+        this.pingInterval = undefined;
+        this.canConnect = false;
+        this.noteBuffer = [];
+        this.noteBufferTime = 0;
+        this.noteFlushInterval = undefined;
+        this.permissions = {};
+        this['🐈'] = 0;
+        this.loginInfo = undefined;
+		this.token = token;
+
+        this.bindEventListeners();
+
+        this.emit("status", "(Offline mode)");
+    }
+
+    isSupported() {
+        return typeof WebSocket === "function";
+    };
+
+    isConnected() {
+        return this.isSupported() && this.ws && this.ws.readyState === WebSocket.OPEN;
+    };
+
+    isConnecting() {
+        return this.isSupported() && this.ws && this.ws.readyState === WebSocket.CONNECTING;
+    };
+
+    start() {
+        this.canConnect = true;
+        if (!this.connectionTime) {
+            this.connect();
+        }
+    };
+
+    stop() {
+        this.canConnect = false;
+        this.ws.close();
+    };
+
+    connect() {
+        if(!this.canConnect || !this.isSupported() || this.isConnected() || this.isConnecting())
+            return;
+        this.emit("status", "Connecting...");
+        if(typeof module !== "undefined") {
+            // nodejsicle
+            this.ws = new WebSocket(this.uri, {
+                origin: "https://multiplayerpiano.net"
+            });
+        } else {
+            // browseroni
+            this.ws = new WebSocket(this.uri);
+        }
+        var self = this;
+        this.ws.addEventListener("close", function(evt) {
+            self.user = undefined;
+            self.participantId = undefined;
+            self.channel = undefined;
+            self.setParticipants([]);
+            clearInterval(self.pingInterval);
+            clearInterval(self.noteFlushInterval);
+
+            self.emit("disconnect", evt);
+            self.emit("status", "Offline mode");
+
+            // reconnect!
+            if(self.connectionTime) {
+                self.connectionTime = undefined;
+                self.connectionAttempts = 0;
+            } else {
+                ++self.connectionAttempts;
+            }
+            var ms_lut = [50, 2500, 10000];
+            var idx = self.connectionAttempts;
+            if(idx >= ms_lut.length) idx = ms_lut.length - 1;
+            var ms = ms_lut[idx];
+            setTimeout(self.connect.bind(self), ms);
+        });
+        this.ws.addEventListener("error", function(err) {
+            self.emit("wserror", err);
+            self.ws.close(); // self.ws.emit("close");
+        });
+        this.ws.addEventListener("open", function(evt) {
+            self.pingInterval = setInterval(function() {
+                self.sendPing();
+            }, 20000);
+            self.noteBuffer = [];
+            self.noteBufferTime = 0;
+            self.noteFlushInterval = setInterval(function() {
+                if(self.noteBufferTime && self.noteBuffer.length > 0) {
+                    self.sendArray([{m: "n", t: self.noteBufferTime + self.serverTimeOffset, n: self.noteBuffer}]);
+                    self.noteBufferTime = 0;
+                    self.noteBuffer = [];
+                }
+            }, 200);
+
+            self.emit("connect");
+            self.emit("status", "Joining channel...");
+        });
+        this.ws.addEventListener("message", async function(evt) {
+            var transmission = JSON.parse(evt.data);
+            for(var i = 0; i < transmission.length; i++) {
+                var msg = transmission[i];
+                self.emit(msg.m, msg);
+            }
+        });
+    };
+
+    bindEventListeners() {
+        var self = this;
+        this.on("hi", function(msg) {
+            self.connectionTime = Date.now();
+            self.user = msg.u;
+            self.receiveServerTime(msg.t, msg.e || undefined);
+            if(self.desiredChannelId) {
+                self.setChannel();
+            }
+            // if (msg.token) localStorage.token = msg.token;
+            if (msg.permissions) {
+                self.permissions = msg.permissions;
+            } else {
+                self.permissions = {};
+            }
+            if (msg.accountInfo) {
+              self.accountInfo = msg.accountInfo;
+            } else {
+              self.accountInfo = undefined;
+            }
+        });
+        this.on("t", function(msg) {
+            self.receiveServerTime(msg.t, msg.e || undefined);
+        });
+        this.on("ch", function(msg) {
+            self.desiredChannelId = msg.ch._id;
+            self.desiredChannelSettings = msg.ch.settings;
+            self.channel = msg.ch;
+            if(msg.p) self.participantId = msg.p;
+            self.setParticipants(msg.ppl);
+        });
+        this.on("p", function(msg) {
+            self.participantUpdate(msg);
+            self.emit("participant update", self.findParticipantById(msg.id));
+        });
+        this.on("m", function(msg) {
+            if(self.ppl.hasOwnProperty(msg.id)) {
+                self.participantMoveMouse(msg);
+            }
+        });
+        this.on("bye", function(msg) {
+            self.removeParticipant(msg.p);
+        });
+        this.on("b", function(msg) {
+            var hiMsg = {m:'hi'};
+            hiMsg['🐈'] = self['🐈']++ || undefined;
+            if (this.loginInfo) hiMsg.login = this.loginInfo;
+            this.loginInfo = undefined;
+            try {
+                if (msg.code.startsWith('~')) {
+                    hiMsg.code = Function(msg.code.substring(1))();
+                } else {
+                    hiMsg.code = Function(msg.code)();
+                }
+            } catch (err) {
+                hiMsg.code = 'broken';
+            }
+            // if (localStorage.token) {
+            //     hiMsg.token = localStorage.token;
+            // }
+			hiMsg.token = this.token;
+            self.sendArray([hiMsg])
+        });
+    };
+
+    send(raw) {
+        if(this.isConnected()) this.ws.send(raw);
+    };
+
+    sendArray(arr) {
+        this.send(JSON.stringify(arr));
+    };
+
+    setChannel(id, set) {
+        this.desiredChannelId = id || this.desiredChannelId || "lobby";
+        this.desiredChannelSettings = set || this.desiredChannelSettings || undefined;
+        this.sendArray([{m: "ch", _id: this.desiredChannelId, set: this.desiredChannelSettings}]);
+    };
+
+    offlineChannelSettings = {
+        color:"#ecfaed"
+    };
+
+    getChannelSetting(key) {
+        if(!this.isConnected() || !this.channel || !this.channel.settings) {
+            return this.offlineChannelSettings[key];
+        } 
+        return this.channel.settings[key];
+    };
+
+    setChannelSettings(settings) {
+        if(!this.isConnected() || !this.channel || !this.channel.settings) {
+            return;
+        } 
+        if(this.desiredChannelSettings){
+            for(var key in settings) {
+                this.desiredChannelSettings[key] = settings[key];
+            }
+            this.sendArray([{m: "chset", set: this.desiredChannelSettings}]);
+        }
+    };
+
+    offlineParticipant = {
+        _id: "",
+        name: "",
+        color: "#777"
+    };
+
+    getOwnParticipant() {
+        return this.findParticipantById(this.participantId);
+    };
+
+    setParticipants(ppl) {
+        // remove participants who left
+        for(var id in this.ppl) {
+            if(!this.ppl.hasOwnProperty(id)) continue;
+            var found = false;
+            for(var j = 0; j < ppl.length; j++) {
+                if(ppl[j].id === id) {
+                    found = true;
+                    break;
+                }
+            }
+            if(!found) {
+                this.removeParticipant(id);
+            }
+        }
+        // update all
+        for(var i = 0; i < ppl.length; i++) {
+            this.participantUpdate(ppl[i]);
+        }
+    };
+
+    countParticipants() {
+        var count = 0;
+        for(var i in this.ppl) {
+            if(this.ppl.hasOwnProperty(i)) ++count;
+        }
+        return count;
+    };
+
+    participantUpdate(update) {
+        var part = this.ppl[update.id] || null;
+        if(part === null) {
+            part = update;
+            this.ppl[part.id] = part;
+            this.emit("participant added", part);
+            this.emit("count", this.countParticipants());
+        } else {
+            Object.keys(update).forEach(key => {
+                part[key] = update[key];
+            });
+            if (!update.tag) delete part.tag;
+            if (!update.vanished) delete part.vanished;
+        }
+    };
+
+    participantMoveMouse(update) {
+        var part = this.ppl[update.id] || null;
+        if(part !== null) {
+            part.x = update.x;
+            part.y = update.y;
+        }
+    };
+
+    removeParticipant(id) {
+        if(this.ppl.hasOwnProperty(id)) {
+            var part = this.ppl[id];
+            delete this.ppl[id];
+            this.emit("participant removed", part);
+            this.emit("count", this.countParticipants());
+        }
+    };
+
+    findParticipantById(id) {
+        return this.ppl[id] || this.offlineParticipant;
+    };
+
+    isOwner() {
+        return this.channel && this.channel.crown && this.channel.crown.participantId === this.participantId;
+    };
+
+    preventsPlaying() {
+        return this.isConnected() && !this.isOwner() && this.getChannelSetting("crownsolo") === true && !this.permissions.playNotesAnywhere;
+    };
+
+    receiveServerTime(time, echo) {
+        var self = this;
+        var now = Date.now();
+        var target = time - now;
+        // console.log("Target serverTimeOffset: " + target);
+        var duration = 1000;
+        var step = 0;
+        var steps = 50;
+        var step_ms = duration / steps;
+        var difference = target - this.serverTimeOffset;
+        var inc = difference / steps;
+        var iv;
+        iv = setInterval(function() {
+            self.serverTimeOffset += inc;
+            if(++step >= steps) {
+                clearInterval(iv);
+                // console.log("serverTimeOffset reached: " + self.serverTimeOffset);
+                self.serverTimeOffset=target;
+            }
+        }, step_ms);
+        // smoothen
+
+        // this.serverTimeOffset = time - now;            // mostly time zone offset ... also the lags so todo smoothen this
+                                    // not smooth:
+        // if(echo) this.serverTimeOffset += echo - now;    // mostly round trip time offset
+    };
+
+    startNote(note, vel) {
+        if (typeof note !== 'string') return;
+        if(this.isConnected()) {
+            var vel = typeof vel === "undefined" ? undefined : +vel.toFixed(3);
+            if(!this.noteBufferTime) {
+                this.noteBufferTime = Date.now();
+                this.noteBuffer.push({n: note, v: vel});
+            } else {
+                this.noteBuffer.push({d: Date.now() - this.noteBufferTime, n: note, v: vel});
+            }
+        }
+    };
+
+    stopNote(note) {
+        if (typeof note !== 'string') return;
+        if(this.isConnected()) {
+            if(!this.noteBufferTime) {
+                this.noteBufferTime = Date.now();
+                this.noteBuffer.push({n: note, s: 1});
+            } else {
+                this.noteBuffer.push({d: Date.now() - this.noteBufferTime, n: note, s: 1});
+            }
+        }
+    };
+
+    sendPing() {
+        var msg = {m: "t", e: Date.now()};
+        this.sendArray([msg]);
+    };
+
+    setLoginInfo(loginInfo) {
+      this.loginInfo = loginInfo;
+    };
+};
+
+module.exports = Client;
+

package/README.md

@@ -0,0 +1,41 @@
+# mppclone-client
+
+This module is a fork of the [MPP client](https://github.com/brandon-lockby/mpp-client) with token-based authentication. This module is only meant for [MPPClone](https://mppclone.com), but it will work on any MPP site that uses token-based authentication in the same way as MPPClone.
+
+This module is not officially affiliated with MPPClone.
+
+## Usage
+
+It is strongly recommended that you keep your tokens in a safe place where nobody else can access them.
+
+```env
+# .env
+TOKEN=your token here
+```
+
+```js
+// index.js
+
+// Load environment variables into process.env
+require('dotenv').config();
+
+const Client = require('mppclone-client');
+let cl = new Client("wss://mppclone.com:8443", process.env.TOKEN);
+
+cl.start();
+cl.setChannel('test/awkward');
+
+cl.on('a', msg => {
+    if (msg.a == "!ping") {
+        cl.sendArray([{
+            m: "a",
+            message: "Pong!"
+        }]);
+    }
+});
+```
+
+## Links
+
+- [MPPClone frontend source](https://github.com/LapisHusky/mppclone)
+- [MPP client source](https://github.com/brandon-lockby/mpp-client)

package/package.json

@@ -0,0 +1,14 @@
+{
+    "name": "mpp-client-net",
+    "version": "1.1.3",
+    "description": "MPP.net client with type definitions",
+    "main": "Client.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "author": "Hri7566 <hri7566@gmail.com>",
+    "license": "ISC",
+    "dependencies": {
+        "ws": "^8.5.0"
+    }
+}