@meshagent/meshagent 0.0.11 → 0.0.12

package/dist/node/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/node/event-emitter.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventEmitter = void 0;
+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();
+    }
+}
+exports.EventEmitter = EventEmitter;

package/dist/node/helpers.d.ts

@@ -0,0 +1,26 @@
+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, baseUrl }: {
+    roomName: string;
+    baseUrl?: string;
+}): string;
+export declare function participantToken({ participantName, roomName, role }: {
+    participantName: string;
+    roomName: string;
+    role?: string;
+}): ParticipantToken;
+export declare function websocketProtocol({ participantName, roomName, role }: {
+    participantName: string;
+    roomName: string;
+    role?: string;
+}): Promise<WebSocketClientProtocol>;

package/dist/node/helpers.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSchemaName = validateSchemaName;
+exports.deploySchema = deploySchema;
+exports.meshagentBaseUrl = meshagentBaseUrl;
+exports.websocketRoomUrl = websocketRoomUrl;
+exports.participantToken = participantToken;
+exports.websocketProtocol = websocketProtocol;
+const schema_1 = require("./schema");
+const participant_token_1 = require("./participant-token");
+const protocol_1 = require("./protocol");
+function validateSchemaName(name) {
+    if (name.includes('.')) {
+        throw new schema_1.MeshSchemaValidationException("schema name cannot contain '.'");
+    }
+}
+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);
+}
+function meshagentBaseUrl(baseUrl) {
+    if (baseUrl) {
+        return baseUrl;
+    }
+    return process.env.MESHAGENT_API_URL || 'https://api.meshagent.com';
+}
+function websocketRoomUrl({ roomName, baseUrl }) {
+    if (!baseUrl) {
+        const envApiUrl = process.env.MESHAGENT_API_URL;
+        if (!envApiUrl) {
+            baseUrl = 'wss://api.meshagent.com';
+        }
+        else {
+            if (envApiUrl.startsWith('https:')) {
+                baseUrl = 'wss:' + envApiUrl.substring('https:'.length);
+            }
+            else if (envApiUrl.startsWith('http:')) {
+                baseUrl = 'ws:' + envApiUrl.substring('http:'.length);
+            }
+            else {
+                baseUrl = envApiUrl;
+            }
+        }
+    }
+    return `${baseUrl}/rooms/${roomName}`;
+}
+function participantToken({ participantName, roomName, role }) {
+    const projectId = process.env.MESHAGENT_PROJECT_ID;
+    const apiKeyId = process.env.MESHAGENT_KEY_ID;
+    const secret = process.env.MESHAGENT_SECRET;
+    if (!projectId) {
+        throw new Error('MESHAGENT_PROJECT_ID must be set. You can find this in the Meshagent Studio under API keys.');
+    }
+    if (!apiKeyId) {
+        throw new Error('MESHAGENT_KEY_ID must be set. You can find this in the Meshagent Studio under API keys.');
+    }
+    if (!secret) {
+        throw new Error('MESHAGENT_SECRET must be set. You can find this in the Meshagent Studio under API keys.');
+    }
+    const token = new participant_token_1.ParticipantToken({ name: participantName, projectId, apiKeyId });
+    token.addRoomGrant(roomName);
+    if (role) {
+        token.addRoleGrant(role);
+    }
+    return token;
+}
+async function websocketProtocol({ participantName, roomName, role }) {
+    const url = websocketRoomUrl({ roomName });
+    const token = participantToken({ participantName, roomName, role });
+    const secret = process.env.MESHAGENT_SECRET;
+    if (!secret) {
+        throw new Error('MESHAGENT_SECRET must be set in the environment.');
+    }
+    const jwt = await token.toJwt({ token: secret });
+    return new protocol_1.WebSocketClientProtocol({ url, token: jwt });
+}

package/dist/node/index.d.ts

@@ -0,0 +1,24 @@
+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';

package/dist/node/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./agent"), exports);
+__exportStar(require("./event-emitter"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./completer"), exports);
+__exportStar(require("./data-types"), exports);
+__exportStar(require("./database-client"), exports);
+__exportStar(require("./developer-client"), exports);
+__exportStar(require("./document"), exports);
+__exportStar(require("./messaging-client"), exports);
+__exportStar(require("./participant-token"), exports);
+__exportStar(require("./participant"), exports);
+__exportStar(require("./protocol"), exports);
+__exportStar(require("./queues-client"), exports);
+__exportStar(require("./requirement"), exports);
+__exportStar(require("./response"), exports);
+__exportStar(require("./room-client"), exports);
+__exportStar(require("./room-event"), exports);
+__exportStar(require("./room-server-client"), exports);
+__exportStar(require("./runtime"), exports);
+__exportStar(require("./schema"), exports);
+__exportStar(require("./storage-client"), exports);
+__exportStar(require("./stream-controller"), exports);
+__exportStar(require("./sync-client"), exports);
+__exportStar(require("./helpers"), exports);

package/dist/node/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/node/messaging-client.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageStreamReader = exports.MessageStreamWriter = exports.MessagingClient = exports.MessageStreamChunk = void 0;
+const uuid_1 = require("uuid");
+const event_emitter_1 = require("./event-emitter");
+const participant_1 = require("./participant");
+const room_event_1 = require("./room-event");
+const utils_1 = require("./utils");
+const stream_controller_1 = require("./stream-controller");
+const completer_1 = require("./completer");
+class MessageStreamChunk {
+    constructor({ header, data }) {
+        this.header = header;
+        this.data = data;
+    }
+}
+exports.MessageStreamChunk = MessageStreamChunk;
+class MessagingClient extends event_emitter_1.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 = (0, uuid_1.v4)();
+        const completer = new completer_1.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 = (0, utils_1.splitMessageHeader)(bytes || new Uint8Array());
+        const payload = (0, utils_1.splitMessagePayload)(bytes || new Uint8Array());
+        const header = JSON.parse(headerStr);
+        const message = new room_event_1.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 participant_1.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 participant_1.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 stream_controller_1.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");
+    }
+}
+exports.MessagingClient = MessagingClient;
+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 },
+        });
+    }
+}
+exports.MessageStreamWriter = MessageStreamWriter;
+class MessageStreamReader {
+    constructor({ streamId, to, client, controller }) {
+        this._streamId = streamId;
+        this._to = to;
+        this._client = client;
+        this._controller = controller;
+    }
+}
+exports.MessageStreamReader = MessageStreamReader;

package/dist/node/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/node/participant-token.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticipantToken = exports.ParticipantGrant = void 0;
+const jose_1 = require("jose");
+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"],
+        });
+    }
+}
+exports.ParticipantGrant = ParticipantGrant;
+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 secret = token || process.env.MESHAGENT_SECRET;
+        if (!secret) {
+            throw new Error("No secret provided. Provide `token` or set MESHAGENT_SECRET in environment.");
+        }
+        const secretKey = new TextEncoder().encode(secret);
+        const payload = {
+            ...this.toJson(),
+            ...this.extra,
+        };
+        const jwt = await new jose_1.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 secret = token || process.env.MESHAGENT_SECRET;
+            if (!secret) {
+                throw new Error("No secret provided to verify JWT. Provide `token` or set MESHAGENT_SECRET");
+            }
+            const secretKey = new TextEncoder().encode(secret);
+            const { payload } = await (0, jose_1.jwtVerify)(jwtStr, secretKey, {
+                algorithms: ["HS256"],
+            });
+            return ParticipantToken.fromJson(payload);
+        }
+        else {
+            try {
+                const payload = (0, jose_1.decodeJwt)(jwtStr);
+                return ParticipantToken.fromJson(payload);
+            }
+            catch (err) {
+                throw new Error("Failed to decode JWT");
+            }
+        }
+    }
+}
+exports.ParticipantToken = ParticipantToken;