@meshagent/meshagent 0.3.1 → 0.4.1

package/dist/esm/protocol.d.ts

@@ -0,0 +1,91 @@
+import WebSocket from "isomorphic-ws";
+export type UpdateCallback = (update: Uint8Array, origin?: any) => void;
+export interface ProtocolChannel {
+    start(onDataReceived: (data: Uint8Array) => void, { onDone, onError }: {
+        onDone?: () => void;
+        onError?: (error: any) => void;
+    }): void;
+    dispose(): void;
+    sendData(data: Uint8Array): Promise<void>;
+}
+export declare class StreamProtocolChannel implements ProtocolChannel {
+    input: ProtocolMessageStream<Uint8Array>;
+    output: ProtocolMessageStream<Uint8Array>;
+    started: boolean;
+    private _iterator;
+    constructor({ input, output }: {
+        input: ProtocolMessageStream<Uint8Array>;
+        output: ProtocolMessageStream<Uint8Array>;
+    });
+    start(onDataReceived: (data: Uint8Array) => void, { onDone, onError }: {
+        onDone?: () => void;
+        onError?: (error: any) => void;
+    }): void;
+    dispose(): void;
+    sendData(data: Uint8Array): Promise<void>;
+}
+export declare class WebSocketProtocolChannel implements ProtocolChannel {
+    url: string;
+    jwt: string;
+    webSocket: WebSocket | null;
+    onDataReceived?: (data: Uint8Array) => void;
+    private _opened;
+    constructor({ url, jwt }: {
+        url: string;
+        jwt: string;
+    });
+    start(onDataReceived: (data: Uint8Array) => void, { onDone, onError }: {
+        onDone?: () => void;
+        onError?: (error: any) => void;
+    }): void;
+    private _onOpen;
+    private _onData;
+    dispose(): void;
+    sendData(data: Uint8Array): Promise<void>;
+}
+export declare class ProtocolMessageStream<T> {
+    private _messages;
+    private _messageAdded;
+    private _closed;
+    add(message: T): Promise<void>;
+    close(): void;
+    stream(): AsyncGenerator<T>;
+}
+export type MessageHandler = (protocol: Protocol, messageId: number, type: string, data?: Uint8Array) => Promise<void> | void;
+export declare class Protocol {
+    channel: ProtocolChannel;
+    handlers: {
+        [type: string]: MessageHandler;
+    };
+    private _id;
+    private _send;
+    private _recvPacketId;
+    private _recvState;
+    private _recvPacketTotal;
+    private _recvMessageId;
+    private _recvType;
+    private _recvPackets;
+    private _iterator;
+    constructor({ channel }: {
+        channel: ProtocolChannel;
+    });
+    addHandler(type: string, handler: MessageHandler): void;
+    removeHandler(type: string): void;
+    handleMessage(messageId: number, type: string, data?: Uint8Array): Promise<void>;
+    getNextMessageId(): number;
+    send(type: string, data: Uint8Array, id?: number): Promise<void>;
+    sendJson(object: any): Promise<void>;
+    start({ onMessage, onDone, onError }?: {
+        onMessage?: MessageHandler;
+        onDone?: () => void;
+        onError?: (error: any) => void;
+    }): void;
+    dispose(): void;
+    onDataReceived(dataPacket: Uint8Array): void;
+}
+export declare class WebSocketClientProtocol extends Protocol {
+    constructor({ url, token }: {
+        url: string;
+        token: string;
+    });
+}

package/dist/esm/protocol.js

@@ -0,0 +1,287 @@
+import WebSocket from "isomorphic-ws";
+import { mergeUint8Arrays, decoder, encoder, unpackMessage } from "./utils";
+import { Completer } from "./completer";
+class ProtocolMessage {
+    constructor({ id, type, data }) {
+        this.id = id;
+        this.type = type;
+        this.data = data;
+        this.sent = new Completer();
+    }
+}
+export class StreamProtocolChannel {
+    constructor({ input, output }) {
+        this.started = false;
+        this._iterator = null;
+        this.input = input;
+        this.output = output;
+    }
+    start(onDataReceived, { onDone, onError }) {
+        if (this.started) {
+            throw new Error("Already started");
+        }
+        this.started = true;
+        (async () => {
+            this._iterator?.return(null);
+            try {
+                this._iterator = this.input.stream();
+                for await (const message of this._iterator) {
+                    if (message) {
+                        onDataReceived(message);
+                    }
+                }
+            }
+            catch (error) {
+                if (onError) {
+                    onError(error);
+                }
+            }
+            finally {
+                if (onDone) {
+                    onDone();
+                }
+            }
+        })();
+    }
+    dispose() {
+        this._iterator?.return(null);
+        this._iterator = null;
+        this.input.close();
+    }
+    async sendData(data) {
+        this.output.add(data);
+    }
+}
+export class WebSocketProtocolChannel {
+    constructor({ url, jwt }) {
+        this.webSocket = null;
+        this._opened = new Completer();
+        this._onOpen = () => this._opened.resolve();
+        this._onData = (event) => {
+            const data = event.data;
+            if (data instanceof Blob) {
+                data.arrayBuffer().then((buffer) => {
+                    if (this.onDataReceived) {
+                        this.onDataReceived(new Uint8Array(buffer));
+                    }
+                });
+            }
+            else if (typeof (data) == "string") {
+                if (this.onDataReceived) {
+                    this.onDataReceived(new Uint8Array(encoder.encode(data)));
+                }
+            }
+            else if (data instanceof ArrayBuffer || data instanceof Buffer) {
+                if (this.onDataReceived) {
+                    this.onDataReceived(new Uint8Array(data));
+                }
+            }
+        };
+        this.url = url;
+        this.jwt = jwt;
+    }
+    start(onDataReceived, { onDone, onError }) {
+        if (typeof (onDataReceived) != "function") {
+            throw new Error("onDataReceived must be a function");
+        }
+        const url = new URL(this.url);
+        url.searchParams.set("token", this.jwt);
+        this.onDataReceived = onDataReceived;
+        this.webSocket = new WebSocket(url.toString());
+        this.webSocket.addEventListener("open", this._onOpen);
+        this.webSocket.addEventListener("message", this._onData);
+        if (onDone) {
+            this.webSocket.addEventListener("close", onDone);
+        }
+        if (onError) {
+            this.webSocket.addEventListener("error", onError);
+        }
+    }
+    dispose() {
+        this.webSocket?.close();
+        this.webSocket = null;
+    }
+    async sendData(data) {
+        await this._opened.fut;
+        this.webSocket?.send(data);
+    }
+}
+export class ProtocolMessageStream {
+    constructor() {
+        this._messages = [];
+        this._messageAdded = new Completer();
+        this._closed = false;
+    }
+    async add(message) {
+        this._messages.push(message);
+        if (!this._messageAdded.completed) {
+            this._messageAdded.complete();
+        }
+    }
+    close() {
+        if (!this._messageAdded.completed) {
+            this._closed = true;
+            this._messageAdded.complete();
+        }
+    }
+    async *stream() {
+        while (!this._closed) {
+            await this._messageAdded.fut;
+            this._messageAdded = new Completer();
+            while (this._messages.length > 0 && !this._closed) {
+                const msg = this._messages.shift();
+                if (msg) {
+                    yield msg;
+                }
+            }
+        }
+    }
+}
+export class Protocol {
+    constructor({ 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 = [];
+        this._iterator = null;
+        this.channel = channel;
+    }
+    addHandler(type, handler) {
+        this.handlers[type] = handler;
+    }
+    removeHandler(type) {
+        delete this.handlers[type];
+    }
+    async handleMessage(messageId, type, data) {
+        const handler = this.handlers[type] ?? this.handlers["*"];
+        if (!handler) {
+            const d = data ? unpackMessage(data) : null;
+            console.warn(`No handler for message type ${type}; data: ${d}`);
+            return;
+        }
+        await handler(this, messageId, type, data);
+    }
+    getNextMessageId() {
+        return this._id++;
+    }
+    async send(type, data, id) {
+        const msg = new ProtocolMessage({ id: id ?? this.getNextMessageId(), type: type, data: data });
+        this._send.add(msg);
+        await msg.sent.fut;
+    }
+    async sendJson(object) {
+        return await this.send("application/json", encoder.encode(JSON.stringify(object)));
+    }
+    start({ onMessage, onDone, onError } = {}) {
+        if (onMessage != null) {
+            this.addHandler("*", onMessage);
+        }
+        this.channel.start(this.onDataReceived.bind(this), { onDone, onError });
+        this._iterator?.return(null);
+        (async () => {
+            this._iterator = this._send.stream();
+            for await (const message of this._iterator) {
+                if (message) {
+                    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();
+                }
+            }
+        })();
+    }
+    dispose() {
+        this.channel.dispose();
+        this._iterator?.return(null);
+        this._iterator = null;
+    }
+    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";
+        }
+        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));
+                if (this._recvPacketTotal == 0) {
+                    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;
+                    this._recvState = "processing";
+                }
+            }
+            else {
+                this._recvState = "error";
+                this._recvPacketId = 0;
+            }
+        }
+        else if (this._recvState != "processing") {
+            this._recvState = "error";
+            this._recvPacketId = 0;
+        }
+        else {
+            if (messageId != this._recvMessageId) {
+                this._recvState = "error";
+                this._recvPacketId = 0;
+            }
+            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;
+            }
+        }
+    }
+}
+export class WebSocketClientProtocol extends Protocol {
+    constructor({ url, token }) {
+        const channel = new WebSocketProtocolChannel({ url, jwt: token });
+        super({ channel });
+    }
+}

package/dist/esm/queues-client.d.ts

@@ -0,0 +1,26 @@
+import { RoomClient } from "./room-client";
+export declare class Queue {
+    name: string;
+    size: number;
+    constructor({ name, size }: {
+        name: string;
+        size: number;
+    });
+}
+export declare class QueuesClient {
+    private client;
+    constructor({ room }: {
+        room: RoomClient;
+    });
+    list(): Promise<Queue[]>;
+    open(name: string): Promise<void>;
+    drain(name: string): Promise<void>;
+    close(name: string): Promise<void>;
+    send(name: string, message: Record<string, any>, { create }: {
+        create?: boolean;
+    }): Promise<void>;
+    receive(name: string, { create, wait }: {
+        create?: boolean;
+        wait?: boolean;
+    }): Promise<Record<string, any> | null>;
+}

package/dist/esm/queues-client.js

@@ -0,0 +1,42 @@
+import { EmptyResponse } from "./response";
+export class Queue {
+    constructor({ name, size }) {
+        this.name = name;
+        this.size = size;
+    }
+}
+export class QueuesClient {
+    constructor({ room }) {
+        this.client = room;
+    }
+    async list() {
+        const response = (await this.client.sendRequest("queues.list", {}));
+        const queues = response.json["queues"];
+        return queues.map((q) => new Queue({ name: q["name"], size: q["size"] }));
+    }
+    async open(name) {
+        await this.client.sendRequest("queues.open", { name });
+    }
+    async drain(name) {
+        await this.client.sendRequest("queues.drain", { name });
+    }
+    async close(name) {
+        await this.client.sendRequest("queues.close", { name });
+    }
+    async send(name, message, { create = true }) {
+        await this.client.sendRequest("queues.send", { name, create, message });
+    }
+    async receive(name, { create = true, wait = true }) {
+        const response = await this.client.sendRequest("queues.receive", {
+            name,
+            create,
+            wait,
+        });
+        if (response instanceof EmptyResponse) {
+            return null;
+        }
+        else {
+            return response.json;
+        }
+    }
+}

package/dist/esm/requirement.d.ts

@@ -0,0 +1,25 @@
+export declare class RoomException extends Error {
+    constructor(message: string);
+}
+export declare abstract class Requirement {
+    readonly name: string;
+    constructor({ name }: {
+        name: string;
+    });
+    static fromJson(r: Record<string, any>): Requirement;
+    abstract toJson(): Record<string, any>;
+}
+export declare class RequiredToolkit extends Requirement {
+    readonly tools?: string[];
+    constructor({ name, tools }: {
+        name: string;
+        tools?: string[];
+    });
+    toJson(): Record<string, any>;
+}
+export declare class RequiredSchema extends Requirement {
+    constructor({ name }: {
+        name: string;
+    });
+    toJson(): Record<string, any>;
+}

package/dist/esm/requirement.js

@@ -0,0 +1,42 @@
+export class RoomException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RoomException";
+    }
+}
+export class Requirement {
+    constructor({ name }) {
+        this.name = name;
+    }
+    static fromJson(r) {
+        if ("toolkit" in r) {
+            return new RequiredToolkit({ name: r["toolkit"], tools: r["tools"] });
+        }
+        if ("schema" in r) {
+            return new RequiredSchema({ name: r["schema"] });
+        }
+        throw new RoomException("invalid requirement json");
+    }
+}
+export class RequiredToolkit extends Requirement {
+    constructor({ name, tools }) {
+        super({ name });
+        this.tools = tools;
+    }
+    toJson() {
+        return {
+            toolkit: this.name,
+            tools: this.tools,
+        };
+    }
+}
+export class RequiredSchema extends Requirement {
+    constructor({ name }) {
+        super({ name });
+    }
+    toJson() {
+        return {
+            schema: this.name,
+        };
+    }
+}

package/dist/esm/response.d.ts

@@ -0,0 +1,60 @@
+export interface Response {
+    pack(): Uint8Array;
+}
+export declare class LinkResponse implements Response {
+    url: string;
+    name: string;
+    constructor({ url, name }: {
+        url: string;
+        name: string;
+    });
+    static unpack(header: Record<string, any>, payload: Uint8Array): LinkResponse;
+    pack(): Uint8Array;
+    toString(): string;
+}
+export declare class FileResponse implements Response {
+    data: Uint8Array;
+    name: string;
+    mimeType: string;
+    constructor({ data, name, mimeType }: {
+        data: Uint8Array;
+        name: string;
+        mimeType: string;
+    });
+    static unpack(header: Record<string, any>, payload: Uint8Array): FileResponse;
+    pack(): Uint8Array;
+    toString(): string;
+}
+export declare class TextResponse implements Response {
+    text: string;
+    constructor({ text }: {
+        text: string;
+    });
+    static unpack(header: Record<string, any>, payload: Uint8Array): TextResponse;
+    pack(): Uint8Array;
+    toString(): string;
+}
+export declare class JsonResponse implements Response {
+    json: Record<string, any>;
+    constructor({ json }: {
+        json: Record<string, any>;
+    });
+    static unpack(header: Record<string, any>, payload: Uint8Array): JsonResponse;
+    pack(): Uint8Array;
+    toString(): string;
+}
+export declare class ErrorResponse implements Response {
+    text: string;
+    constructor({ text }: {
+        text: string;
+    });
+    static unpack(header: Record<string, any>, payload: Uint8Array): ErrorResponse;
+    pack(): Uint8Array;
+    toString(): string;
+}
+export declare class EmptyResponse implements Response {
+    static unpack(header: Record<string, any>, payload: Uint8Array): EmptyResponse;
+    pack(): Uint8Array;
+    toString(): string;
+}
+export declare function unpackResponse(data: Uint8Array): Response;

package/dist/esm/response.js

@@ -0,0 +1,128 @@
+import { packMessage, splitMessageHeader, splitMessagePayload } from "./utils";
+export class LinkResponse {
+    constructor({ url, name }) {
+        this.url = url;
+        this.name = name;
+    }
+    static unpack(header, payload) {
+        return new LinkResponse({
+            url: header["url"],
+            name: header["name"],
+        });
+    }
+    pack() {
+        return packMessage({
+            type: "link",
+            name: this.name,
+            url: this.url,
+        });
+    }
+    toString() {
+        return `LinkResponse (${this.name}): ${this.url}`;
+    }
+}
+export class FileResponse {
+    constructor({ data, name, mimeType }) {
+        this.data = data;
+        this.name = name;
+        this.mimeType = mimeType;
+    }
+    static unpack(header, payload) {
+        return new FileResponse({
+            data: payload,
+            name: header["name"],
+            mimeType: header["mime_type"],
+        });
+    }
+    pack() {
+        return packMessage({
+            type: "file",
+            name: this.name,
+            mime_type: this.mimeType,
+        }, this.data);
+    }
+    toString() {
+        return `FileResponse (${this.name}): ${this.mimeType}`;
+    }
+}
+export class TextResponse {
+    constructor({ text }) {
+        this.text = text;
+    }
+    static unpack(header, payload) {
+        return new TextResponse({
+            text: header["text"],
+        });
+    }
+    pack() {
+        return packMessage({
+            type: "text",
+            text: this.text,
+        });
+    }
+    toString() {
+        return `TextResponse: ${this.text}`;
+    }
+}
+export class JsonResponse {
+    constructor({ json }) {
+        this.json = json;
+    }
+    static unpack(header, payload) {
+        return new JsonResponse({ json: header["json"] });
+    }
+    pack() {
+        return packMessage({
+            type: "json",
+            json: this.json,
+        });
+    }
+    toString() {
+        return `JsonResponse: ${JSON.stringify(this.json)}`;
+    }
+}
+export class ErrorResponse {
+    constructor({ text }) {
+        this.text = text;
+    }
+    static unpack(header, payload) {
+        return new ErrorResponse({ text: header["text"] });
+    }
+    pack() {
+        return packMessage({
+            type: "error",
+            text: this.text,
+        });
+    }
+    toString() {
+        return `ErrorResponse: ${this.text}`;
+    }
+}
+export class EmptyResponse {
+    static unpack(header, payload) {
+        return new EmptyResponse();
+    }
+    pack() {
+        return packMessage({ type: "empty" });
+    }
+    toString() {
+        return `EmptyResponse`;
+    }
+}
+const _responseTypes = {
+    empty: EmptyResponse.unpack,
+    error: ErrorResponse.unpack,
+    file: FileResponse.unpack,
+    json: JsonResponse.unpack,
+    link: LinkResponse.unpack,
+    text: TextResponse.unpack,
+};
+export function unpackResponse(data) {
+    const header = JSON.parse(splitMessageHeader(data));
+    const payload = splitMessagePayload(data);
+    const typeKey = header["type"];
+    if (!_responseTypes[typeKey]) {
+        throw new Error(`Unknown response type: ${typeKey}`);
+    }
+    return _responseTypes[typeKey](header, payload);
+}