@meshagent/meshagent 0.35.6 → 0.35.8

package/dist/esm/messaging-client.js

@@ -1,11 +1,9 @@
-import { v4 as uuidV4 } from "uuid";
 import { EventEmitter } from "./event-emitter";
+import { Completer } from "./completer";
 import { RemoteParticipant } from "./participant";
 import { RoomMessage, RoomMessageEvent } from "./room-event";
 import { RoomServerException } from "./room-server-client";
 import { splitMessageHeader, splitMessagePayload } from "./utils";
-import { StreamController } from "./stream-controller";
-import { Completer } from "./completer";
 const globalScope = globalThis;
 function bytesToBase64(bytes) {
     if (globalScope.Buffer) {
@@ -20,20 +18,18 @@ function bytesToBase64(bytes) {
     }
     return globalScope.btoa(binary);
 }
-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._messageHandler = this._handleMessageSend.bind(this);
         this._participants = {};
+        this._messageQueue = [];
+        this._messageQueued = null;
+        this._sendTask = null;
+        this._messageQueueClosed = false;
+        this._enabled = false;
         this.client = room;
-        this.client.protocol.addHandler("messaging.send", this._handleMessageSend.bind(this));
+        this.client.protocol.addHandler("messaging.send", this._messageHandler);
     }
     _messageInput(params) {
         const input = {
@@ -48,6 +44,16 @@ export class MessagingClient extends EventEmitter {
         }
         return input;
     }
+    _syntheticMessageEvent(params) {
+        return new RoomMessageEvent({
+            message: new RoomMessage({
+                fromParticipantId: params.fromParticipantId,
+                type: params.type,
+                message: params.message,
+                local: true,
+            }),
+        });
+    }
     _removeParticipant(participantId) {
         const participant = this._participants[participantId];
         if (participant === undefined) {
@@ -55,15 +61,24 @@ export class MessagingClient extends EventEmitter {
         }
         participant._setOnline(false);
         delete this._participants[participantId];
-        for (const [streamId, reader] of Object.entries(this._streamReaders)) {
-            if (reader._to.id !== participant.id) {
-                continue;
-            }
-            reader._controller.close();
-            delete this._streamReaders[streamId];
-        }
         return participant;
     }
+    _markParticipantOffline(participant) {
+        if (!(participant instanceof RemoteParticipant)) {
+            return;
+        }
+        participant._setOnline(false);
+        const current = this._participants[participant.id];
+        if (current === undefined) {
+            return;
+        }
+        this._removeParticipant(participant.id);
+        this.emit("participant_removed", this._syntheticMessageEvent({
+            fromParticipantId: participant.id,
+            type: "participant.disabled",
+            message: { id: participant.id },
+        }));
+    }
     _resolveMessageRecipient(to) {
         if (!(to instanceof RemoteParticipant)) {
             return to;
@@ -73,46 +88,131 @@ export class MessagingClient extends EventEmitter {
         }
         return this._participants[to.id] ?? null;
     }
-    _participantNotFound(ignoreOffline) {
-        if (ignoreOffline) {
-            return null;
+    _queueMessage(message) {
+        if (this._sendTask === null) {
+            throw new RoomServerException("Cannot send messages because messaging has not been started");
+        }
+        this._messageQueue.push(message);
+        const waiter = this._messageQueued;
+        if (waiter !== null) {
+            this._messageQueued = null;
+            waiter.complete();
+        }
+    }
+    _rejectQueuedMessages(error) {
+        while (this._messageQueue.length > 0) {
+            const message = this._messageQueue.shift();
+            message?.completer?.completeError(error);
+        }
+    }
+    _isParticipantNotFound(error) {
+        return error instanceof RoomServerException && error.message === "the participant was not found";
+    }
+    async _nextQueuedMessage() {
+        while (this._messageQueue.length === 0) {
+            if (this._messageQueueClosed) {
+                return null;
+            }
+            if (this._messageQueued === null) {
+                this._messageQueued = new Completer();
+            }
+            await this._messageQueued.fut;
+        }
+        return this._messageQueue.shift() ?? null;
+    }
+    async _sendMessages() {
+        while (true) {
+            const queued = await this._nextQueuedMessage();
+            if (queued === null) {
+                return;
+            }
+            const resolvedTo = this._resolveMessageRecipient(queued.to);
+            if (resolvedTo === null) {
+                const error = new RoomServerException("the participant was not found");
+                if (queued.dropIfOffline) {
+                    queued.completer?.complete();
+                }
+                else {
+                    queued.completer?.completeError(error);
+                }
+                continue;
+            }
+            try {
+                await this.client.invoke({
+                    toolkit: "messaging",
+                    tool: "send",
+                    input: this._messageInput({
+                        toParticipantId: resolvedTo.id,
+                        type: queued.type,
+                        message: queued.message,
+                        attachment: queued.attachment,
+                    }),
+                });
+                queued.completer?.complete();
+            }
+            catch (error) {
+                if (this._isParticipantNotFound(error)) {
+                    this._markParticipantOffline(queued.to);
+                    if (queued.dropIfOffline) {
+                        queued.completer?.complete();
+                        continue;
+                    }
+                }
+                queued.completer?.completeError(error);
+            }
         }
-        throw new RoomServerException("the participant was not found");
     }
-    async createStream({ to, header }) {
-        const streamId = uuidV4();
+    async start() {
+        if (this._sendTask !== null) {
+            return;
+        }
+        this._messageQueueClosed = false;
+        this._sendTask = this._sendMessages();
+    }
+    async stop() {
+        if (this._sendTask === null) {
+            this._enabled = false;
+            return;
+        }
+        this._messageQueueClosed = true;
+        const waiter = this._messageQueued;
+        if (waiter !== null) {
+            this._messageQueued = null;
+            waiter.complete();
+        }
+        const sendTask = this._sendTask;
+        this._sendTask = null;
+        await sendTask;
+        this._enabled = false;
+    }
+    async sendMessage({ to, type, message, attachment, ignoreOffline = false }) {
         const completer = new Completer();
-        this._streamWriters[streamId] = completer;
-        await this.sendMessage({
+        this._queueMessage({
             to,
-            type: "stream.open",
-            message: { stream_id: streamId, header },
+            type,
+            message,
+            attachment,
+            dropIfOffline: ignoreOffline,
+            completer,
         });
-        return completer.fut;
+        await completer.fut;
     }
-    async sendMessage({ to, type, message, attachment, ignoreOffline = false }) {
-        const resolvedTo = this._resolveMessageRecipient(to) ?? this._participantNotFound(ignoreOffline);
-        if (resolvedTo === null) {
-            return;
-        }
-        await this.client.invoke({
-            toolkit: "messaging",
-            tool: "send",
-            input: this._messageInput({
-                toParticipantId: resolvedTo.id,
-                type,
-                message,
-                attachment,
-            }),
+    sendMessageNowait({ to, type, message, attachment }) {
+        this._queueMessage({
+            to,
+            type,
+            message,
+            attachment,
+            dropIfOffline: true,
         });
     }
-    async enable(onStreamAccept) {
+    async enable() {
         await this.client.invoke({
             toolkit: "messaging",
             tool: "enable",
             input: {},
         });
-        this._onStreamAcceptCallback = onStreamAccept;
+        this._enabled = true;
     }
     async disable() {
         await this.client.invoke({
@@ -120,6 +220,7 @@ export class MessagingClient extends EventEmitter {
             tool: "disable",
             input: {},
         });
+        this._enabled = false;
     }
     async broadcastMessage({ type, message, attachment }) {
         await this.client.invoke({
@@ -131,6 +232,23 @@ export class MessagingClient extends EventEmitter {
     get remoteParticipants() {
         return Object.values(this._participants);
     }
+    get isEnabled() {
+        return this._enabled;
+    }
+    getParticipants() {
+        return this.remoteParticipants;
+    }
+    getParticipant(id) {
+        return this._participants[id] ?? null;
+    }
+    getParticipantByName(name) {
+        for (const participant of this.remoteParticipants) {
+            if (participant.getAttribute("name") === name) {
+                return participant;
+            }
+        }
+        return null;
+    }
     async _handleMessageSend(protocol, messageId, type, bytes) {
         const headerStr = splitMessageHeader(bytes || new Uint8Array());
         const payload = splitMessagePayload(bytes || new Uint8Array());
@@ -154,21 +272,6 @@ export class MessagingClient extends EventEmitter {
             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 = new RoomMessageEvent({ message });
         this.client.emit(messageEvent);
@@ -177,20 +280,17 @@ export class MessagingClient extends EventEmitter {
     _onParticipantEnabled(message) {
         const data = message.message;
         const p = new RemoteParticipant(this.client, data["id"], data["role"], true);
-        for (const [k, v] of Object.entries(data["attributes"] || {})) {
-            p._attributes[k] = v;
-        }
+        p._setAttributes(data["attributes"] ?? {});
         this._participants[data["id"]] = p;
         this.emit("participant_added", { message });
     }
     _onParticipantAttributes(message) {
         const part = this._participants[message.fromParticipantId];
-        if (!part)
+        if (!part) {
             return;
-        const attrObj = message.message["attributes"];
-        for (const [k, v] of Object.entries(attrObj)) {
-            part._attributes[k] = v;
         }
+        const attrObj = message.message["attributes"];
+        part._setAttributes(attrObj);
         this.emit("participant_attributes_updated", { message });
     }
     _onParticipantDisabled(message) {
@@ -203,124 +303,23 @@ export class MessagingClient extends EventEmitter {
         const participants = message.message["participants"];
         for (const data of participants) {
             const rp = new RemoteParticipant(this.client, data["id"], data["role"], true);
-            for (const [k, v] of Object.entries(data["attributes"] || {})) {
-                rp._attributes[k] = v;
-            }
+            rp._setAttributes(data["attributes"] ?? {});
             this._participants[data["id"]] = rp;
         }
+        this._enabled = true;
         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);
-            void this.sendMessage({
-                to: from,
-                type: "stream.accept",
-                message: { stream_id: streamId },
-                ignoreOffline: true,
-            }).catch((error) => {
-                console.warn("unable to send stream response", error);
-            });
-        }
-        catch (e) {
-            void this.sendMessage({
-                to: from,
-                type: "stream.reject",
-                message: { stream_id: streamId, error: String(e) },
-                ignoreOffline: true,
-            }).catch((error) => {
-                console.warn("unable to send stream response", error);
-            });
-        }
-        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() {
+        const error = new RoomServerException("messaging client disposed");
+        this._messageQueueClosed = true;
+        this._enabled = false;
+        this._rejectQueuedMessages(error);
+        const waiter = this._messageQueued;
+        if (waiter !== null) {
+            this._messageQueued = null;
+            waiter.complete();
+        }
         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.d.ts

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

package/dist/esm/participant.js

@@ -12,6 +12,14 @@ export class Participant {
     getAttribute(name) {
         return this._attributes[name];
     }
+    _setAttribute(name, value) {
+        this._attributes[name] = value;
+    }
+    _setAttributes(attributes) {
+        for (const [name, value] of Object.entries(attributes)) {
+            this._setAttribute(name, value);
+        }
+    }
 }
 export class RemoteParticipant extends Participant {
     constructor(client, id, role, online) {
@@ -28,7 +36,7 @@ export class LocalParticipant extends Participant {
         super(client, id);
     }
     async setAttribute(name, value) {
-        this._attributes[name] = value;
+        this._setAttribute(name, value);
         try {
             const payload = packMessage({ [name]: value });
             await this.client.protocol.send("set_attributes", payload);

package/dist/esm/room-client.js

@@ -46,6 +46,7 @@ export class RoomClient {
         return this._ready.fut;
     }
     async start({ onDone, onError } = {}) {
+        await this.messaging.start();
         this.sync.start({ onDone, onError });
         await this.ready;
     }
@@ -55,6 +56,7 @@ export class RoomClient {
             pr?.reject(new Error("Disposed"));
             this._pendingRequests.delete(prKey);
         }
+        this.messaging.dispose();
         this.sync.dispose();
         for (const stream of this._toolCallStreams.values()) {
             stream.close();

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

@@ -34,16 +34,20 @@ export declare class FileCreatedEvent extends RoomEvent {
 }
 export declare class FileDeletedEvent extends RoomEvent {
     path: string;
-    constructor({ path }: {
+    participantId: string;
+    constructor({ path, participantId }: {
         path: string;
+        participantId: string;
     });
     get name(): string;
     get description(): string;
 }
 export declare class FileUpdatedEvent extends RoomEvent {
     path: string;
-    constructor({ path }: {
+    participantId: string;
+    constructor({ path, participantId }: {
         path: string;
+        participantId: string;
     });
     get name(): string;
     get description(): string;

package/dist/esm/room-event.js

@@ -34,9 +34,10 @@ export class FileCreatedEvent extends RoomEvent {
     }
 }
 export class FileDeletedEvent extends RoomEvent {
-    constructor({ path }) {
+    constructor({ path, participantId }) {
         super();
         this.path = path;
+        this.participantId = participantId;
     }
     get name() {
         return "file deleted";
@@ -46,9 +47,10 @@ export class FileDeletedEvent extends RoomEvent {
     }
 }
 export class FileUpdatedEvent extends RoomEvent {
-    constructor({ path }) {
+    constructor({ path, participantId }) {
         super();
         this.path = path;
+        this.participantId = participantId;
     }
     get name() {
         return "file updated";

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

@@ -1,37 +1,107 @@
-import { RoomClient } from "./room-client";
+import type { ConnectorRef, OAuthClientConfig } from "./meshagent-client";
 import { FileContent } from "./response";
+import { RoomClient } from "./room-client";
 export interface SecretInfo {
     id: string;
     name: string;
-    type?: string;
+    type: string;
     delegatedTo?: string | null;
 }
+export interface OAuthTokenRequest {
+    requestId: string;
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+    challenge?: string | null;
+    scopes?: string[] | null;
+    clientId?: string | null;
+}
+export type OAuthTokenRequestHandler = (request: OAuthTokenRequest) => Promise<void> | void;
+export interface SecretRequest {
+    requestId: string;
+    url: string;
+    type: string;
+    delegateTo?: string | null;
+}
+export type SecretRequestHandler = (request: SecretRequest) => Promise<void> | void;
 export declare class SecretsClient {
-    private client;
-    constructor({ room }: {
+    private readonly client;
+    private readonly oauthTokenRequestHandler?;
+    private readonly secretRequestHandler?;
+    private readonly _oauthRequestHandler;
+    private readonly _secretRequestHandler;
+    constructor({ room, oauthTokenRequestHandler, secretRequestHandler, }: {
         room: RoomClient;
+        oauthTokenRequestHandler?: OAuthTokenRequestHandler;
+        secretRequestHandler?: SecretRequestHandler;
     });
     private unexpectedResponse;
-    setSecret({ secretId, data, mimeType, name, delegatedTo, forIdentity, }: {
-        secretId: string;
+    private invoke;
+    private serializeConnectorRef;
+    private serializeOAuthConfig;
+    private parseAccessToken;
+    private parseSecretInfo;
+    private _handleClientOAuthTokenRequest;
+    private _handleClientSecretRequest;
+    provideOAuthAuthorization({ requestId, code, }: {
+        requestId: string;
+        code: string;
+    }): Promise<void>;
+    rejectOAuthAuthorization({ requestId, error, }: {
+        requestId: string;
+        error: string;
+    }): Promise<void>;
+    provideSecret({ requestId, data, }: {
+        requestId: string;
         data: Uint8Array;
-        mimeType?: string;
-        name?: string;
-        delegatedTo?: string;
-        forIdentity?: string;
     }): Promise<void>;
-    getSecret({ secretId, delegatedTo, }: {
-        secretId: string;
-        delegatedTo?: string;
-    }): Promise<FileContent | null>;
+    rejectSecret({ requestId, error, }: {
+        requestId: string;
+        error: string;
+    }): Promise<void>;
+    getOfflineOAuthToken({ connector, oauth, delegatedTo, delegatedBy, }: {
+        connector?: ConnectorRef | null;
+        oauth?: OAuthClientConfig | null;
+        delegatedTo?: string | null;
+        delegatedBy?: string | null;
+    }): Promise<string | null>;
+    requestOAuthToken({ connector, oauth, timeout, fromParticipantId, redirectUri, delegateTo, }: {
+        connector?: ConnectorRef | null;
+        oauth?: OAuthClientConfig | null;
+        timeout?: number;
+        fromParticipantId: string;
+        redirectUri: string | URL;
+        delegateTo?: string | null;
+    }): Promise<string | null>;
     listSecrets(): Promise<SecretInfo[]>;
     deleteSecret({ secretId, delegatedTo, }: {
         secretId: string;
-        delegatedTo?: string;
+        delegatedTo?: string | null;
     }): Promise<void>;
     deleteRequestedSecret({ url, type, delegatedTo, }: {
         url: string;
         type: string;
-        delegatedTo?: string;
+        delegatedTo?: string | null;
     }): Promise<void>;
+    requestSecret({ fromParticipantId, url, type, timeout, delegateTo, }: {
+        fromParticipantId: string;
+        url: string;
+        type: string;
+        timeout?: number;
+        delegateTo?: string | null;
+    }): Promise<Uint8Array>;
+    setSecret({ secretId, type, mimeType, name, delegatedTo, forIdentity, data, }: {
+        secretId?: string | null;
+        type?: string | null;
+        mimeType?: string | null;
+        name?: string | null;
+        delegatedTo?: string | null;
+        forIdentity?: string | null;
+        data: Uint8Array;
+    }): Promise<void>;
+    getSecret({ secretId, type, name, delegatedTo, }: {
+        secretId?: string | null;
+        type?: string | null;
+        name?: string | null;
+        delegatedTo?: string | null;
+    }): Promise<FileContent | null>;
 }