@meshagent/meshagent 0.3.1 → 0.4.1

package/dist/esm/event-emitter.d.ts

@@ -0,0 +1,13 @@
+export type EventHandler<T> = (event: T) => void;
+export type EventName = string | symbol;
+export declare class EventEmitter<T> {
+    private eventMap;
+    constructor();
+    addListener: (eventName: EventName, callback: EventHandler<T>) => void;
+    removeListener: (eventName: EventName, callback: EventHandler<T>) => void;
+    notifyListeners: (eventName: EventName, event: T) => void;
+    on: (eventName: EventName, callback: EventHandler<T>) => void;
+    off: (eventName: EventName, callback: EventHandler<T>) => void;
+    emit: (eventName: EventName, event: T) => void;
+    dispose(): void;
+}

package/dist/esm/event-emitter.js

@@ -0,0 +1,34 @@
+export class EventEmitter {
+    constructor() {
+        this.addListener = (eventName, callback) => {
+            const listeners = this.eventMap.get(eventName);
+            if (listeners) {
+                listeners.push(callback);
+            }
+            else {
+                this.eventMap.set(eventName, [callback]);
+            }
+        };
+        this.removeListener = (eventName, callback) => {
+            const listeners = this.eventMap.get(eventName) || [];
+            this.eventMap.set(eventName, listeners.filter((listener) => listener !== callback));
+        };
+        this.notifyListeners = (eventName, event) => {
+            const listeners = this.eventMap.get(eventName) || [];
+            listeners.forEach((listener) => listener(event));
+        };
+        this.on = (eventName, callback) => {
+            this.addListener(eventName, callback);
+        };
+        this.off = (eventName, callback) => {
+            this.removeListener(eventName, callback);
+        };
+        this.emit = (eventName, event) => {
+            this.notifyListeners(eventName, event);
+        };
+        this.eventMap = new Map();
+    }
+    dispose() {
+        this.eventMap.clear();
+    }
+}

package/dist/esm/helpers.d.ts

@@ -0,0 +1,32 @@
+import { MeshSchema } from './schema';
+import { RoomClient } from './room-client';
+import { ParticipantToken } from './participant-token';
+import { WebSocketClientProtocol } from './protocol';
+export declare function validateSchemaName(name: string): void;
+export declare function deploySchema({ room, schema, name, overwrite }: {
+    room: RoomClient;
+    schema: MeshSchema;
+    name: string;
+    overwrite?: boolean;
+}): Promise<void>;
+export declare function meshagentBaseUrl(baseUrl?: string): string;
+export declare function websocketRoomUrl({ roomName, apiUrl }: {
+    roomName: string;
+    apiUrl?: string;
+}): string;
+export declare function participantToken({ participantName, roomName, role, projectId, apiKeyId, }: {
+    participantName: string;
+    roomName: string;
+    role?: string;
+    projectId: string;
+    apiKeyId: string;
+}): ParticipantToken;
+export declare function websocketProtocol({ participantName, roomName, role, projectId, apiKeyId, secret, apiUrl }: {
+    participantName: string;
+    roomName: string;
+    role?: string;
+    projectId: string;
+    apiKeyId: string;
+    secret: string;
+    apiUrl?: string;
+}): Promise<WebSocketClientProtocol>;

package/dist/esm/helpers.js

@@ -0,0 +1,46 @@
+import { MeshSchemaValidationException } from './schema';
+import { ParticipantToken } from './participant-token';
+import { WebSocketClientProtocol } from './protocol';
+export function validateSchemaName(name) {
+    if (name.includes('.')) {
+        throw new MeshSchemaValidationException("schema name cannot contain '.'");
+    }
+}
+export async function deploySchema({ room, schema, name, overwrite = true }) {
+    validateSchemaName(name);
+    const handle = await room.storage.open(`.schemas/${name}.json`, { overwrite });
+    const data = Buffer.from(JSON.stringify(schema.toJson()), 'utf-8');
+    await room.storage.write(handle, data);
+    await room.storage.close(handle);
+}
+export function meshagentBaseUrl(baseUrl) {
+    if (baseUrl) {
+        return baseUrl;
+    }
+    return 'https://api.meshagent.com';
+}
+export function websocketRoomUrl({ roomName, apiUrl }) {
+    const baseUrl = apiUrl || 'wss://api.meshagent.com';
+    let url = baseUrl;
+    if (baseUrl.startsWith('https:')) {
+        url = 'wss:' + baseUrl.substring('https:'.length);
+    }
+    else if (baseUrl.startsWith('http:')) {
+        url = 'ws:' + baseUrl.substring('http:'.length);
+    }
+    return `${url}/rooms/${roomName}`;
+}
+export function participantToken({ participantName, roomName, role, projectId, apiKeyId, }) {
+    const token = new ParticipantToken({ name: participantName, projectId, apiKeyId });
+    token.addRoomGrant(roomName);
+    if (role) {
+        token.addRoleGrant(role);
+    }
+    return token;
+}
+export async function websocketProtocol({ participantName, roomName, role, projectId, apiKeyId, secret, apiUrl }) {
+    const url = websocketRoomUrl({ roomName, apiUrl });
+    const token = participantToken({ participantName, roomName, role, projectId, apiKeyId });
+    const jwt = await token.toJwt({ token: secret });
+    return new WebSocketClientProtocol({ url, token: jwt });
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,25 @@
+export * from './agent';
+export * from './event-emitter';
+export * from './client';
+export * from './completer';
+export * from './data-types';
+export * from './database-client';
+export * from './developer-client';
+export * from './document';
+export * from './messaging-client';
+export * from './participant-token';
+export * from './participant';
+export * from './protocol';
+export * from './queues-client';
+export * from './requirement';
+export * from './response';
+export * from './room-client';
+export * from './room-event';
+export * from './room-server-client';
+export * from './runtime';
+export * from './schema';
+export * from './storage-client';
+export * from './stream-controller';
+export * from './sync-client';
+export * from './helpers';
+export * from './utils';

package/dist/esm/index.js

@@ -0,0 +1,25 @@
+export * from './agent';
+export * from './event-emitter';
+export * from './client';
+export * from './completer';
+export * from './data-types';
+export * from './database-client';
+export * from './developer-client';
+export * from './document';
+export * from './messaging-client';
+export * from './participant-token';
+export * from './participant';
+export * from './protocol';
+export * from './queues-client';
+export * from './requirement';
+export * from './response';
+export * from './room-client';
+export * from './room-event';
+export * from './room-server-client';
+export * from './runtime';
+export * from './schema';
+export * from './storage-client';
+export * from './stream-controller';
+export * from './sync-client';
+export * from './helpers';
+export * from './utils';

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

@@ -0,0 +1,76 @@
+import { EventEmitter } from "./event-emitter";
+import { RoomClient } from "./room-client";
+import { Participant, RemoteParticipant } from "./participant";
+import { RoomMessageEvent } from "./room-event";
+import { StreamController } from "./stream-controller";
+export declare class MessageStreamChunk {
+    header: Record<string, any>;
+    data?: Uint8Array;
+    constructor({ header, data }: {
+        header: Record<string, any>;
+        data?: Uint8Array;
+    });
+}
+export declare class MessagingClient extends EventEmitter<RoomMessageEvent> {
+    private client;
+    private _streamWriters;
+    private _streamReaders;
+    private _onStreamAcceptCallback?;
+    private _participants;
+    constructor({ room }: {
+        room: RoomClient;
+    });
+    createStream({ to, header }: {
+        to: Participant;
+        header: Record<string, any>;
+    }): Promise<MessageStreamWriter>;
+    sendMessage({ to, type, message, attachment }: {
+        to: Participant;
+        type: string;
+        message: Record<string, any>;
+        attachment?: Uint8Array;
+    }): Promise<void>;
+    enable(onStreamAccept?: (reader: MessageStreamReader) => void): Promise<void>;
+    disable(): Promise<void>;
+    broadcastMessage({ type, message, attachment }: {
+        type: string;
+        message: Record<string, any>;
+        attachment?: Uint8Array;
+    }): Promise<void>;
+    get remoteParticipants(): Iterable<RemoteParticipant>;
+    private _handleMessageSend;
+    private _onParticipantEnabled;
+    private _onParticipantAttributes;
+    private _onParticipantDisabled;
+    private _onMessagingEnabled;
+    private _onStreamOpen;
+    private _onStreamAccept;
+    private _onStreamReject;
+    private _onStreamChunk;
+    private _onStreamClose;
+    dispose(): void;
+}
+export declare class MessageStreamWriter {
+    private _streamId;
+    private _to;
+    private _client;
+    constructor({ streamId, to, client }: {
+        streamId: string;
+        to: Participant;
+        client: MessagingClient;
+    });
+    write(chunk: MessageStreamChunk): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class MessageStreamReader {
+    _streamId: string;
+    _to: Participant;
+    _client: MessagingClient;
+    _controller: StreamController<MessageStreamChunk>;
+    constructor({ streamId, to, client, controller }: {
+        streamId: string;
+        to: Participant;
+        client: MessagingClient;
+        controller: StreamController<MessageStreamChunk>;
+    });
+}

package/dist/esm/messaging-client.js

@@ -0,0 +1,241 @@
+import { v4 as uuidV4 } from "uuid";
+import { EventEmitter } from "./event-emitter";
+import { RemoteParticipant } from "./participant";
+import { RoomMessage } from "./room-event";
+import { splitMessageHeader, splitMessagePayload } from "./utils";
+import { StreamController } from "./stream-controller";
+import { Completer } from "./completer";
+export class MessageStreamChunk {
+    constructor({ header, data }) {
+        this.header = header;
+        this.data = data;
+    }
+}
+export class MessagingClient extends EventEmitter {
+    constructor({ room }) {
+        super();
+        this._streamWriters = {};
+        this._streamReaders = {};
+        this._participants = {};
+        this.client = room;
+        this.client.protocol.addHandler("messaging.send", this._handleMessageSend.bind(this));
+    }
+    async createStream({ to, header }) {
+        const streamId = uuidV4();
+        const completer = new Completer();
+        this._streamWriters[streamId] = completer;
+        await this.sendMessage({
+            to,
+            type: "stream.open",
+            message: { stream_id: streamId, header },
+        });
+        return completer.fut;
+    }
+    async sendMessage({ to, type, message, attachment }) {
+        await this.client.sendRequest("messaging.send", {
+            to_participant_id: to.id,
+            type,
+            message,
+        }, attachment);
+    }
+    async enable(onStreamAccept) {
+        await this.client.sendRequest("messaging.enable", {});
+        this._onStreamAcceptCallback = onStreamAccept;
+    }
+    async disable() {
+        await this.client.sendRequest("messaging.disable", {});
+    }
+    async broadcastMessage({ type, message, attachment }) {
+        await this.client.sendRequest("messaging.broadcast", { type, message }, attachment);
+    }
+    get remoteParticipants() {
+        return Object.values(this._participants);
+    }
+    async _handleMessageSend(protocol, messageId, type, bytes) {
+        const headerStr = splitMessageHeader(bytes || new Uint8Array());
+        const payload = splitMessagePayload(bytes || new Uint8Array());
+        const header = JSON.parse(headerStr);
+        const message = new RoomMessage({
+            fromParticipantId: header["from_participant_id"],
+            type: header["type"],
+            message: header["message"],
+            attachment: payload,
+        });
+        switch (message.type) {
+            case "messaging.enabled":
+                this._onMessagingEnabled(message);
+                break;
+            case "participant.attributes":
+                this._onParticipantAttributes(message);
+                break;
+            case "participant.enabled":
+                this._onParticipantEnabled(message);
+                break;
+            case "participant.disabled":
+                this._onParticipantDisabled(message);
+                break;
+            case "stream.open":
+                this._onStreamOpen(message);
+                break;
+            case "stream.accept":
+                this._onStreamAccept(message);
+                break;
+            case "stream.reject":
+                this._onStreamReject(message);
+                break;
+            case "stream.chunk":
+                this._onStreamChunk(message);
+                break;
+            case "stream.close":
+                this._onStreamClose(message);
+                break;
+        }
+        const messageEvent = { message };
+        this.client.emit(messageEvent);
+        this.emit("message", messageEvent);
+    }
+    _onParticipantEnabled(message) {
+        const data = message.message;
+        const p = new RemoteParticipant(this.client, data["id"], data["role"]);
+        for (const [k, v] of Object.entries(data["attributes"] || {})) {
+            p._attributes[k] = v;
+        }
+        this._participants[data["id"]] = p;
+        this.emit("participant_added", { message });
+    }
+    _onParticipantAttributes(message) {
+        const part = this._participants[message.fromParticipantId];
+        if (!part)
+            return;
+        const attrObj = message.message["attributes"];
+        for (const [k, v] of Object.entries(attrObj)) {
+            part._attributes[k] = v;
+        }
+        this.emit("participant_attributes_updated", { message });
+    }
+    _onParticipantDisabled(message) {
+        const part = this._participants[message.message["id"]];
+        if (part) {
+            delete this._participants[message.message["id"]];
+            this.emit("participant_removed", { message });
+        }
+    }
+    _onMessagingEnabled(message) {
+        const participants = message.message["participants"];
+        for (const data of participants) {
+            const rp = new RemoteParticipant(this.client, data["id"], data["role"]);
+            for (const [k, v] of Object.entries(data["attributes"] || {})) {
+                rp._attributes[k] = v;
+            }
+            this._participants[data["id"]] = rp;
+        }
+        this.emit("messaging_enabled", { message });
+    }
+    _onStreamOpen(message) {
+        const from = [...this.remoteParticipants]
+            .find((x) => x.id === message.fromParticipantId);
+        if (!from)
+            return;
+        const streamId = message.message["stream_id"];
+        const controller = new StreamController();
+        const reader = new MessageStreamReader({
+            streamId,
+            to: from,
+            client: this,
+            controller,
+        });
+        try {
+            if (!this._onStreamAcceptCallback) {
+                throw new Error("streams are not allowed by this client");
+            }
+            this._onStreamAcceptCallback(reader);
+            this.sendMessage({
+                to: from,
+                type: "stream.accept",
+                message: { stream_id: streamId },
+            });
+        }
+        catch (e) {
+            this.sendMessage({
+                to: from,
+                type: "stream.reject",
+                message: { stream_id: streamId, error: String(e) },
+            });
+        }
+        this._streamReaders[streamId] = reader;
+        this.emit("stream_opened", { message });
+    }
+    _onStreamAccept(message) {
+        const streamId = message.message["stream_id"];
+        const writerCompleter = this._streamWriters[streamId];
+        if (!writerCompleter)
+            return;
+        const from = [...this.remoteParticipants].find((x) => x.id === message.fromParticipantId);
+        if (!from)
+            return;
+        writerCompleter.complete(new MessageStreamWriter({
+            streamId,
+            to: from,
+            client: this,
+        }));
+    }
+    _onStreamReject(message) {
+        const streamId = message.message["stream_id"];
+        const writerCompleter = this._streamWriters[streamId];
+        if (!writerCompleter)
+            return;
+        writerCompleter.completeError(new Error("The stream was rejected by the remote client"));
+    }
+    _onStreamChunk(message) {
+        const streamId = message.message["stream_id"];
+        const reader = this._streamReaders[streamId];
+        if (!reader)
+            return;
+        reader._controller.add(new MessageStreamChunk({
+            header: message.message,
+            data: message.attachment,
+        }));
+    }
+    _onStreamClose(message) {
+        const streamId = message.message["stream_id"];
+        const reader = this._streamReaders[streamId];
+        if (!reader)
+            return;
+        reader._controller.close();
+        delete this._streamReaders[streamId];
+    }
+    dispose() {
+        super.dispose();
+        this.client.protocol.removeHandler("messaging.send");
+    }
+}
+export class MessageStreamWriter {
+    constructor({ streamId, to, client }) {
+        this._streamId = streamId;
+        this._to = to;
+        this._client = client;
+    }
+    async write(chunk) {
+        await this._client.sendMessage({
+            to: this._to,
+            type: "stream.chunk",
+            message: { stream_id: this._streamId, header: chunk.header },
+            attachment: chunk.data,
+        });
+    }
+    async close() {
+        await this._client.sendMessage({
+            to: this._to,
+            type: "stream.close",
+            message: { stream_id: this._streamId },
+        });
+    }
+}
+export class MessageStreamReader {
+    constructor({ streamId, to, client, controller }) {
+        this._streamId = streamId;
+        this._to = to;
+        this._client = client;
+        this._controller = controller;
+    }
+}

package/dist/esm/participant-token.d.ts

@@ -0,0 +1,36 @@
+export declare class ParticipantGrant {
+    name: string;
+    scope?: string;
+    constructor({ name, scope }: {
+        name: string;
+        scope?: string;
+    });
+    toJson(): Record<string, any>;
+    static fromJson(json: Record<string, any>): ParticipantGrant;
+}
+export declare class ParticipantToken {
+    name: string;
+    projectId?: string;
+    apiKeyId?: string;
+    grants: ParticipantGrant[];
+    extra?: Record<string, any>;
+    constructor({ name, projectId, apiKeyId, extra, grants, }: {
+        name: string;
+        projectId?: string;
+        apiKeyId?: string;
+        extra?: Record<string, any>;
+        grants?: ParticipantGrant[];
+    });
+    get isAgent(): boolean;
+    addRoleGrant(role: string): void;
+    addRoomGrant(roomName: string): void;
+    toJson(): Record<string, any>;
+    toJwt({ token }: {
+        token: string;
+    }): Promise<string>;
+    static fromJson(json: Record<string, any>): ParticipantToken;
+    static fromJwt(jwtStr: string, options: {
+        token: string;
+        verify?: boolean;
+    }): Promise<ParticipantToken>;
+}

package/dist/esm/participant-token.js

@@ -0,0 +1,91 @@
+import { decodeJwt, jwtVerify, SignJWT } from "jose";
+export class ParticipantGrant {
+    constructor({ name, scope }) {
+        this.name = name;
+        this.scope = scope;
+    }
+    toJson() {
+        return {
+            name: this.name,
+            scope: this.scope,
+        };
+    }
+    static fromJson(json) {
+        return new ParticipantGrant({
+            name: json["name"],
+            scope: json["scope"],
+        });
+    }
+}
+export class ParticipantToken {
+    constructor({ name, projectId, apiKeyId, extra, grants, }) {
+        this.name = name;
+        this.projectId = projectId;
+        this.apiKeyId = apiKeyId;
+        this.extra = extra ?? {};
+        this.grants = grants ?? [];
+    }
+    get isAgent() {
+        for (const grant of this.grants) {
+            if (grant.name === "role" && grant.scope === "agent") {
+                return true;
+            }
+        }
+        return false;
+    }
+    addRoleGrant(role) {
+        this.grants.push(new ParticipantGrant({ name: "role", scope: role }));
+    }
+    addRoomGrant(roomName) {
+        this.grants.push(new ParticipantGrant({ name: "room", scope: roomName }));
+    }
+    toJson() {
+        return {
+            name: this.name,
+            ...(this.projectId ? { sub: this.projectId } : {}),
+            ...(this.apiKeyId ? { kid: this.apiKeyId } : {}),
+            grants: this.grants.map((g) => g.toJson()),
+        };
+    }
+    async toJwt({ token }) {
+        const secretKey = new TextEncoder().encode(token);
+        const payload = {
+            ...this.toJson(),
+            ...this.extra,
+        };
+        const jwt = await new SignJWT(payload)
+            .setProtectedHeader({ alg: "HS256", typ: "JWT" })
+            .sign(secretKey);
+        return jwt;
+    }
+    static fromJson(json) {
+        const { name, sub, grants, kid, ...rest } = json;
+        const extra = { ...rest };
+        return new ParticipantToken({
+            name: name,
+            projectId: sub,
+            apiKeyId: kid,
+            grants: grants?.map((g) => ParticipantGrant.fromJson(g)),
+            extra,
+        });
+    }
+    static async fromJwt(jwtStr, options) {
+        const { token, verify = true } = options;
+        if (verify) {
+            const secretKey = new TextEncoder().encode(token);
+            const { payload } = await jwtVerify(jwtStr, secretKey, {
+                algorithms: ["HS256"],
+            });
+            return ParticipantToken.fromJson(payload);
+        }
+        else {
+            try {
+                const payload = decodeJwt(jwtStr);
+                return ParticipantToken.fromJson(payload);
+            }
+            catch (err) {
+                throw new Error("Failed to decode JWT");
+            }
+        }
+    }
+}

package/dist/esm/participant.d.ts

@@ -0,0 +1,18 @@
+import { RoomClient } from "./room-client";
+export declare abstract class Participant {
+    readonly id: string;
+    protected readonly client: RoomClient;
+    protected _attributes: Record<string, any>;
+    protected _connections: string[];
+    constructor(client: RoomClient, id: string);
+    get connections(): ReadonlyArray<string>;
+    getAttribute(name: string): any;
+}
+export declare class RemoteParticipant extends Participant {
+    readonly role: string;
+    constructor(client: RoomClient, id: string, role: string);
+}
+export declare class LocalParticipant extends Participant {
+    constructor(client: RoomClient, id: string);
+    setAttribute(name: string, value: any): Promise<void>;
+}

package/dist/esm/participant.js

@@ -0,0 +1,36 @@
+import { packMessage } from "./utils";
+export class Participant {
+    constructor(client, id) {
+        this._attributes = {};
+        this._connections = [];
+        this.client = client;
+        this.id = id;
+    }
+    get connections() {
+        return this._connections;
+    }
+    getAttribute(name) {
+        return this._attributes[name];
+    }
+}
+export class RemoteParticipant extends Participant {
+    constructor(client, id, role) {
+        super(client, id);
+        this.role = role;
+    }
+}
+export class LocalParticipant extends Participant {
+    constructor(client, id) {
+        super(client, id);
+    }
+    async setAttribute(name, value) {
+        this._attributes[name] = value;
+        try {
+            const payload = packMessage({ [name]: value });
+            await this.client.protocol.send("set_attributes", payload);
+        }
+        catch (err) {
+            console.warn("Unable to send attribute changes", err);
+        }
+    }
+}