@meshagent/meshagent 0.0.11

package/index.js

@@ -0,0 +1,2 @@
+export { ServerXmlDocument } from "./server.js";
+export { ClientXmlDocument } from "./client.js";

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "@meshagent/meshagent",
+    "version": "0.0.11",
+    "description": "Meshagent Client",
+    "homepage": "https://www.meshagent.com",
+    "main": "index.js",
+    "type": "module",
+    "scripts": {
+        "build": "esbuild entrypoint.js --sourcemap --tree-shaking=true --bundle --outdir=dist --target=esnext '--define:process={\"env\":\"production\",\"NODE_ENV\":\"production\"}' --define:global=window --analyze --format=cjs",
+        "test": "jest"
+    },
+    "dependencies": {
+        "@babel/core": "^7.26.0",
+        "@babel/preset-env": "^7.26.0",
+        "@kayahr/text-encoding": "^1.3.0",
+        "base-64": "^1.0.0",
+        "uuid": "^11.0.3",
+        "ws": "^8.18.0",
+        "y-indexeddb": "^9.0.12",
+        "yjs": "^13.6.7"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.14.0",
+        "esbuild": "^0.25.0",
+        "eslint": "^9.14.0",
+        "eslint-plugin-import": "^2.31.0",
+        "globals": "^15.12.0",
+        "jest": "^29.7.0",
+        "mocha": "^11.1.0"
+    },
+    "author": "",
+    "license": "Apache-2.0"
+}

package/protocol.js

@@ -0,0 +1,459 @@
+import { decode } from "base-64";
+import * as Y from "yjs";
+import { TextEncoder, TextDecoder } from "@kayahr/text-encoding";
+
+export class ServerProtocol {
+    constructor(onServerUpdate) {
+        this.doc = new Y.Doc();
+        this.doc.on('update', onServerUpdate);
+    }
+
+   update(update) {
+        Y.applyUpdate(this.doc, update);
+    }
+}
+
+export class ClientProtocol {
+    constructor(onClientUpdate) {
+        this.doc = new Y.Doc();
+        this.doc.on('update', onClientUpdate);
+    }
+
+   update(update) {
+        Y.applyUpdate(this.doc, update);
+    }
+}
+
+export class Completer {
+    constructor() {
+        const self = this;
+        this.fut = new Promise((resolve, reject) => {
+            self.resolve = () => {
+                this.completed = true;
+                resolve();
+            }
+            self.reject = () => {
+                this.completed = true;
+                reject();
+            };
+        });
+        this.completed = false;
+    }
+    
+}
+
+class ProtocolMessage {
+
+    /**
+     * @param {Object} message - the message
+     * @param {number} id - the message id
+     * @param {Uint8List} data - the data of the message
+     * @param {string} type - the type of the message
+    */
+    constructor({ id, data, type}) {
+        this.sent = new Completer()
+        this.id = id;
+        this.data = data;
+        this.type = type;
+    }
+}
+
+class ProtocolChannel {
+  
+  /* void Function(Uint8List data) */
+  start(onDataReceived) {
+    this.onDataReceived = onDataReceived;
+  }
+
+  dispose() {
+
+  }
+
+   /**
+     * @param {Uint8List} data - the data of the message
+   */
+  async sendData(data) {
+
+  }
+}
+
+
+export class StreamProtocolChannel extends ProtocolChannel {
+    /**
+     * 
+     * @param {Object} options
+     * @param {ProtocolMessageStream} options.input 
+     * @param {ProtocolMessageStream} options.output 
+     */
+    constructor({input, output}) {
+        super();
+        this.input = input;
+        this.output = output;
+    }
+
+    start(onDataReceived) {
+        if (this.started) {
+            throw new Error("Already started");
+        }
+        this.started = true;
+        (async () => {
+            for await (let message of this.input.stream()) {
+                onDataReceived(message);
+            }
+        })();
+    }
+
+    dispose() {
+        this.input.close();
+    }
+
+    async sendData(data)  {
+        this.output.add(data);
+    }
+}
+
+
+export class WebSocketProtocolChannel extends ProtocolChannel {
+    /**
+     * @param {Object} params - the params
+     * @param {string} url - the url to connect to
+    */
+    constructor({ url }) {
+        super();
+        this.url = url;
+        this._opened = new Completer();
+    }
+
+    /**
+     * 
+     * @param {A callback that will be called every time data is received} onDataReceived 
+     */
+    start(onDataReceived) {
+        if(typeof(onDataReceived) != "function") {
+            throw new Error("onDataReceived must be a function")
+        }
+        this.onDataReceived = onDataReceived;
+        this.webSocket = new WebSocket(this.url);
+        this.webSocket.onopen = () => {
+            this._opened.resolve();
+        };
+        this.webSocket.addEventListener("message", this.onData.bind(this))
+    }
+
+
+    onData(event) {
+        this.onDataReceived(new Uint8Array(event.data));
+    }
+
+
+    dispose() {
+        this.webSocket.close()
+    }
+
+    /**
+    * @param {Uint8Array} data - the data to send
+    */
+    async sendData(data) {
+        await this._opened.fut;
+        this.webSocket.send(data);
+    }
+}
+
+/*
+class LivekitProtocolChannel extends ProtocolChannel {
+  LivekitProtocolChannel(
+      {required this.room, required this.topic, required this.remote});
+
+  final lk.RemoteParticipant remote;
+  final lk.Room room;
+  final String topic;
+
+  lk.EventsListener<lk.RoomEvent>? listener;
+
+  void Function(Uint8List data)? onDataReceived;
+
+  @override
+  void start(void Function(Uint8List data) onDataReceived) {
+    this.onDataReceived = onDataReceived;
+    listener = room.createListener();
+    listener!.on<lk.DataReceivedEvent>(onDataPacket);
+  }
+
+  @override
+  void dispose() {
+    listener?.dispose();
+    onDataReceived = null;
+  }
+
+  @override
+  Future<void> sendData(Uint8List data) async {
+    await room.localParticipant!.publishData(data,
+        reliable: true, topic: topic, destinationIdentities: [remote.identity]);
+  }
+
+  void onDataPacket(lk.DataReceivedEvent evt) {
+    debugPrint(
+        "Message on topic $topic ${evt.participant?.identity} vs ${remote.identity}");
+    if (evt.topic == topic && evt.participant == remote) {
+      debugPrint("Processing message on topic $topic");
+
+      onDataReceived!(evt.data as Uint8List);
+    }
+  }
+}
+*/
+
+export class ProtocolMessageStream {
+    constructor() {
+        this._messages = [];
+        this._messageAdded = new Completer();
+        this._closed = false;
+    }
+
+    /**
+     * @param {ProtocolMessage} message 
+     */
+    async add(message) {
+        this._messages.push(message); 
+        if(!this._messageAdded.completed) {
+            this._messageAdded.resolve();
+        }
+    }
+
+    close() {
+        if(!this._messageAdded.completed) {
+            this._closed = true;
+            this._messageAdded.resolve();
+        }
+    }
+
+    async *stream() {
+        while(!this._closed) {
+            await this._messageAdded.fut;
+            this._messageAdded = new Completer();
+            while(this._messages.length > 0) {
+                if(this._closed) {
+                    break;
+                }
+                const msg = this._messages.shift();
+                yield msg;
+            }
+        }
+    }
+}
+
+const encoder = new TextEncoder("utf-8");
+const decoder = new TextDecoder("utf-8");
+
+export function mergeUint8Arrays(...arrays) {
+    const totalSize = arrays.reduce((acc, e) => acc + e.length, 0);
+    const merged = new Uint8Array(totalSize);
+  
+    arrays.forEach((array, i, arrays) => {
+      const offset = arrays.slice(0, i).reduce((acc, e) => acc + e.length, 0);
+      merged.set(array, offset);
+    });
+  
+    return merged;
+}
+
+export class Protocol {
+    /**
+     * @param {Object} params - the params
+     * @param {ProtocolChannel} params.channel - the protocol channel to use
+    */ 
+    constructor({channel}) {
+        this.channel = channel;
+        this.handlers = {}
+        this._id = 0;
+        this._send = new ProtocolMessageStream();
+
+        this._recvPacketId = 0;
+        this._recvState = "ready";
+        this._recvPacketTotal = 0;
+        this._recvMessageId = -1;
+        this._recvType = "";
+        this._recvPackets = [];
+    }
+
+
+     /**
+     * @param {string} type - the type of message to handle
+     * @param {Function} handler - the message handler
+    */ 
+    addHandler(type, handler) {
+        this.handlers[type] = handler;
+    }
+
+    /**
+     * @param {string} type - the type of message to handle
+     * @param {Function} handler - the message handler
+    */ 
+    removeHandler(type, handler) {
+        delete this.handlers[type];
+    }
+
+    /**
+     * @param {number} messageId - the id of the message
+     * @param {string} type - the type of the message
+     * @param {Uint8Array?} data - the data for the message
+    */ 
+    async handleMessage(messageId, type, data) {
+        const handler = this.handlers[type] ?? this.handlers["*"];
+        await handler(this, messageId, type, data);    
+    }
+
+    
+    /**
+     * @returns {number} the next message id
+    */ 
+    getNextMessageId() {
+        return this._id++;
+    }
+
+    /**
+     * @param {string} type - the type of the message
+     * @param {Uint8Array} data - the data for the message
+     * @param {number?} messageId - the id of the message
+    */ 
+    async send(type, data, id) {
+        const msg = new ProtocolMessage({ id: id ?? this.getNextMessageId(), type: type, data: data });
+        this._send.add(msg);
+        await msg.sent.future;
+    }
+
+    /**
+     * @param {Object} object - the type of the message
+    */
+    async sendJson(object) {
+        return await send("application/json", encoder.encode(JSON.stringify(object)));
+    }
+
+    
+    start(onMessage = null) {
+        
+        if(onMessage != null) {
+            this.addHandler("*", onMessage);
+        }
+        this.channel.start(this.onDataReceived.bind(this));
+
+        (async () => {
+            for await (let message of this._send.stream()) {
+                console.log(`message recv on protocol ${message.id} ${message.type}`);
+
+                const packets = Math.ceil((message.data.length / 1024));
+
+                const header = new Uint8Array(4*4);
+                const dataView = new DataView(header.buffer);
+                dataView.setUint32(0, (message.id  & 0x000fffff00000000) / Math.pow(2, 32), false);
+                dataView.setUint32(4,  message.id & 0xffffffff, false);
+                dataView.setUint32(8, 0, false);
+                dataView.setUint32(12, packets, false);
+                const headerPacket = mergeUint8Arrays(
+                    header,
+                    encoder.encode(message.type)
+                );
+                
+                await this.channel.sendData(headerPacket);
+                for (var i = 0; i < packets; i++) {
+
+                    const packetHeader = new Uint8Array(3*4);
+                    const dataView = new DataView(packetHeader.buffer);
+                    dataView.setUint32(0, (message.id  & 0x000fffff00000000) / Math.pow(2, 32), false);
+                    dataView.setUint32(4,  message.id & 0xffffffff, false);
+                    dataView.setUint32(8, i+1, false);
+                    const packet = mergeUint8Arrays(
+                        packetHeader,
+                        message.data.subarray(i * 1024, Math.min((i + 1) * 1024, message.data.length))
+                    );
+
+                    await this.channel.sendData(packet);
+                }
+                message.sent.resolve();
+                console.log(`message sent on protocol ${message.id} ${message.type}`);
+            }
+            console.log("protocol done");
+        })();
+    }
+
+    dispose() {  
+        this.channel.dispose();
+    }
+
+    /**
+     * 
+     * @param {Uint8List} dataPacket
+     */
+    onDataReceived(dataPacket) {
+        const dataView = new DataView(dataPacket.buffer);
+
+        const messageId = dataView.getUint32(4, false) + dataView.getUint32(0, false) * Math.pow(2, 32);
+        const packet =  dataView.getUint32(8, false); 
+
+        if (packet != this._recvPacketId) {
+            this._recvState = "error";
+            console.log(dataPacket);
+            console.log(
+                `received out of order packet got ${packet} expected ${this._recvPacketId}, total ${this._recvPacketTotal} message ID: ${messageId}`);
+        }
+
+        if (packet == 0) {
+        if (this._recvState == "ready" || this._recvState == "error") {
+            this._recvPacketTotal = dataView.getUint32(12, false);
+            this._recvMessageId = messageId;
+            this._recvType = decoder.decode(dataPacket.subarray(16));
+            console.log(`recieved packet ${this._recvType}`);
+
+            if (this._recvPacketTotal == 0) {
+                try {
+                    const merged = mergeUint8Arrays(...this._recvPackets);
+                    this._recvPackets.length = 0;
+                    this.handleMessage(messageId, this._recvType, merged);
+
+                } finally {
+                    console.log("expecting packet reset to 0");
+                    this._recvState = "ready";
+                    this._recvPacketId = 0;
+                    this._recvType = "";
+                    this._recvMessageId = -1;
+                }
+            } else {
+                this._recvPacketId += 1;
+                console.log(`expecting packet ${this._recvPacketId}`);
+                this._recvState = "processing";
+            }
+        } else {
+            this._recvState = "error";
+            this._recvPacketId = 0;
+            console.log("received packet 0 in invalid state");
+        }
+        } else if (this._recvState != "processing") {
+            this._recvState = "error";
+            this._recvPacketId = 0;
+            console.log("received datapacket in invalid state");
+        } else {
+            if (messageId != this._recvMessageId) {
+                this._recvState = "error";
+                this._recvPacketId = 0;
+                console.log("received packet from incorrect message");
+            }
+
+            this._recvPackets.push(dataPacket.subarray(12));
+
+            if (this._recvPacketTotal == this._recvPacketId) {
+                try {
+                    const merged = mergeUint8Arrays(...this._recvPackets);
+                    this._recvPackets.length = 0;
+                    this.handleMessage(messageId, this._recvType, merged);
+                } finally {
+                    this._recvState = "ready";
+                    this._recvPacketId = 0;
+                    this._recvType = "";
+                    this._recvMessageId = -1;
+                }
+            } else {
+                this._recvPacketId += 1;
+            }
+        }
+    }
+}