@meshagent/meshagent 0.35.6 → 0.35.8

package/dist/esm/secrets-client.js

@@ -1,82 +1,281 @@
 import { BinaryContent, EmptyContent, FileContent, JsonContent } from "./response";
+import { RoomServerException } from "./room-server-client";
+import { unpackMessage } from "./utils";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 export class SecretsClient {
-    constructor({ room }) {
+    constructor({ room, oauthTokenRequestHandler, secretRequestHandler, }) {
+        this._oauthRequestHandler = this._handleClientOAuthTokenRequest.bind(this);
+        this._secretRequestHandler = this._handleClientSecretRequest.bind(this);
         this.client = room;
+        this.oauthTokenRequestHandler = oauthTokenRequestHandler;
+        this.secretRequestHandler = secretRequestHandler;
+        this.client.protocol.addHandler("secrets.request_oauth_token", this._oauthRequestHandler);
+        this.client.protocol.addHandler("secrets.request_secret", this._secretRequestHandler);
     }
     unexpectedResponse(operation) {
-        return new Error(`unexpected return type from secrets.${operation}`);
+        return new RoomServerException(`unexpected return type from secrets.${operation}`);
     }
-    async setSecret({ secretId, data, mimeType, name, delegatedTo, forIdentity, }) {
-        const response = await this.client.invoke({
+    async invoke(operation, input) {
+        return await this.client.invoke({
             toolkit: "secrets",
-            tool: "set_secret",
-            input: new BinaryContent({
-                data,
-                headers: {
-                    secret_id: secretId,
-                    type: mimeType ?? null,
-                    name: name ?? null,
-                    delegated_to: delegatedTo ?? null,
-                    for_identity: forIdentity ?? null,
-                    has_data: true,
-                },
-            }),
+            tool: operation,
+            input,
         });
-        if (response instanceof EmptyContent || response instanceof JsonContent) {
-            return;
+    }
+    serializeConnectorRef(connector) {
+        if (connector == null) {
+            return null;
         }
-        throw this.unexpectedResponse("set_secret");
+        return {
+            openai_connector_id: connector.openaiConnectorId ?? null,
+            server_url: connector.serverUrl ?? null,
+            client_secret_id: connector.clientSecretId ?? null,
+        };
     }
-    async getSecret({ secretId, delegatedTo, }) {
-        const req = {
-            secret_id: secretId,
-            type: null,
-            name: null,
-            delegated_to: delegatedTo ?? null,
+    serializeOAuthConfig(oauth) {
+        if (oauth == null) {
+            return null;
+        }
+        return {
+            client_id: oauth.client_id,
+            client_secret: oauth.client_secret ?? null,
+            authorization_endpoint: oauth.authorization_endpoint,
+            token_endpoint: oauth.token_endpoint,
+            no_pkce: oauth.no_pkce ?? null,
+            scopes: oauth.scopes ?? null,
         };
-        const response = await this.client.invoke({ toolkit: "secrets", tool: "get_secret", input: req });
-        if (response instanceof EmptyContent) {
+    }
+    parseAccessToken(operation, response) {
+        if (!(response instanceof JsonContent)) {
+            throw this.unexpectedResponse(operation);
+        }
+        const token = response.json["access_token"];
+        if (typeof token !== "string" || token.length === 0) {
             return null;
         }
-        if (response instanceof FileContent) {
-            return response;
+        return token;
+    }
+    parseSecretInfo(value) {
+        if (!isRecord(value) || typeof value["id"] !== "string" || typeof value["name"] !== "string" || typeof value["type"] !== "string") {
+            throw this.unexpectedResponse("list_secrets");
         }
-        throw this.unexpectedResponse("get_secret");
+        const delegatedTo = value["delegated_to"];
+        if (delegatedTo !== undefined && delegatedTo !== null && typeof delegatedTo !== "string") {
+            throw this.unexpectedResponse("list_secrets");
+        }
+        return {
+            id: value["id"],
+            name: value["name"],
+            type: value["type"],
+            delegatedTo: delegatedTo,
+        };
+    }
+    async _handleClientOAuthTokenRequest(protocol, messageId, type, bytes) {
+        void protocol;
+        void messageId;
+        void type;
+        if (bytes == null) {
+            throw new RoomServerException("invalid secrets.request_oauth_token payload");
+        }
+        if (this.oauthTokenRequestHandler == null) {
+            throw new RoomServerException("No oauth token handler registered");
+        }
+        const [request] = unpackMessage(bytes);
+        const requestId = request["request_id"];
+        const challenge = request["challenge"];
+        const requestPayload = request["request"];
+        if (typeof requestId !== "string" || !isRecord(requestPayload)) {
+            throw new RoomServerException("invalid secrets.request_oauth_token payload");
+        }
+        const oauth = requestPayload["oauth"];
+        if (!isRecord(oauth) || typeof oauth["authorization_endpoint"] !== "string" || typeof oauth["token_endpoint"] !== "string") {
+            throw new RoomServerException("invalid secrets.request_oauth_token payload");
+        }
+        const scopes = oauth["scopes"];
+        if (scopes !== undefined && scopes !== null && (!Array.isArray(scopes) || scopes.some((scope) => typeof scope !== "string"))) {
+            throw new RoomServerException("invalid secrets.request_oauth_token payload");
+        }
+        Promise.resolve(this.oauthTokenRequestHandler({
+            requestId,
+            authorizationEndpoint: oauth["authorization_endpoint"],
+            tokenEndpoint: oauth["token_endpoint"],
+            challenge: typeof challenge === "string" ? challenge : null,
+            scopes: scopes ?? null,
+            clientId: typeof oauth["client_id"] === "string" ? oauth["client_id"] : null,
+        })).catch((error) => {
+            console.warn("OAuth token request handler threw", error);
+        });
+    }
+    async _handleClientSecretRequest(protocol, messageId, type, bytes) {
+        void protocol;
+        void messageId;
+        void type;
+        if (bytes == null) {
+            throw new RoomServerException("invalid secrets.request_secret payload");
+        }
+        if (this.secretRequestHandler == null) {
+            throw new RoomServerException("No secret handler registered");
+        }
+        const [request] = unpackMessage(bytes);
+        const requestId = request["request_id"];
+        const requestPayload = request["request"];
+        if (typeof requestId !== "string" || !isRecord(requestPayload) || typeof requestPayload["url"] !== "string" || typeof requestPayload["type"] !== "string") {
+            throw new RoomServerException("invalid secrets.request_secret payload");
+        }
+        Promise.resolve(this.secretRequestHandler({
+            requestId,
+            url: requestPayload["url"],
+            type: requestPayload["type"],
+            delegateTo: typeof requestPayload["delegate_to"] === "string" ? requestPayload["delegate_to"] : null,
+        })).catch((error) => {
+            console.warn("Secret request handler threw", error);
+        });
+    }
+    async provideOAuthAuthorization({ requestId, code, }) {
+        const response = await this.invoke("provide_oauth_authorization", {
+            request_id: requestId,
+            code,
+            error: null,
+        });
+        if (response instanceof EmptyContent || response instanceof JsonContent) {
+            return;
+        }
+        throw this.unexpectedResponse("provide_oauth_authorization");
+    }
+    async rejectOAuthAuthorization({ requestId, error, }) {
+        const response = await this.invoke("provide_oauth_authorization", {
+            request_id: requestId,
+            code: null,
+            error,
+        });
+        if (response instanceof EmptyContent || response instanceof JsonContent) {
+            return;
+        }
+        throw this.unexpectedResponse("provide_oauth_authorization");
+    }
+    async provideSecret({ requestId, data, }) {
+        const response = await this.invoke("provide_secret", new BinaryContent({
+            data,
+            headers: {
+                request_id: requestId,
+                error: null,
+            },
+        }));
+        if (response instanceof EmptyContent || response instanceof JsonContent) {
+            return;
+        }
+        throw this.unexpectedResponse("provide_secret");
+    }
+    async rejectSecret({ requestId, error, }) {
+        const response = await this.invoke("provide_secret", new BinaryContent({
+            data: new Uint8Array(0),
+            headers: {
+                request_id: requestId,
+                error,
+            },
+        }));
+        if (response instanceof EmptyContent || response instanceof JsonContent) {
+            return;
+        }
+        throw this.unexpectedResponse("provide_secret");
+    }
+    async getOfflineOAuthToken({ connector, oauth, delegatedTo, delegatedBy, }) {
+        const response = await this.invoke("get_offline_oauth_token", {
+            connector: this.serializeConnectorRef(connector),
+            oauth: this.serializeOAuthConfig(oauth),
+            delegated_to: delegatedTo ?? null,
+            delegated_by: delegatedBy ?? null,
+        });
+        return this.parseAccessToken("get_offline_oauth_token", response);
+    }
+    async requestOAuthToken({ connector, oauth, timeout = 60 * 5, fromParticipantId, redirectUri, delegateTo, }) {
+        const response = await this.invoke("request_oauth_token", {
+            connector: this.serializeConnectorRef(connector),
+            oauth: this.serializeOAuthConfig(oauth),
+            redirect_uri: typeof redirectUri === "string" ? redirectUri : redirectUri.toString(),
+            timeout,
+            participant_id: fromParticipantId,
+            delegate_to: delegateTo ?? null,
+        });
+        return this.parseAccessToken("request_oauth_token", response);
     }
     async listSecrets() {
-        const response = await this.client.invoke({ toolkit: "secrets", tool: "list_secrets", input: {} });
+        const response = await this.invoke("list_secrets", {});
         if (!(response instanceof JsonContent)) {
             throw this.unexpectedResponse("list_secrets");
         }
-        const secrets = Array.isArray(response.json?.secrets) ? response.json.secrets : [];
-        return secrets.map((item) => ({
-            id: item.id,
-            name: item.name,
-            type: item.type,
-            delegatedTo: item.delegated_to,
-        }));
+        const secrets = response.json["secrets"];
+        if (!Array.isArray(secrets)) {
+            throw this.unexpectedResponse("list_secrets");
+        }
+        return secrets.map((item) => this.parseSecretInfo(item));
     }
     async deleteSecret({ secretId, delegatedTo, }) {
-        const req = {
+        const response = await this.invoke("delete_secret", {
             id: secretId,
             delegated_to: delegatedTo ?? null,
-        };
-        const response = await this.client.invoke({ toolkit: "secrets", tool: "delete_secret", input: req });
+        });
         if (response instanceof EmptyContent || response instanceof JsonContent) {
             return;
         }
         throw this.unexpectedResponse("delete_secret");
     }
     async deleteRequestedSecret({ url, type, delegatedTo, }) {
-        const req = {
+        const response = await this.invoke("delete_requested_secret", {
             url,
             type,
             delegated_to: delegatedTo ?? null,
-        };
-        const response = await this.client.invoke({ toolkit: "secrets", tool: "delete_requested_secret", input: req });
+        });
         if (response instanceof EmptyContent || response instanceof JsonContent) {
             return;
         }
         throw this.unexpectedResponse("delete_requested_secret");
     }
+    async requestSecret({ fromParticipantId, url, type, timeout = 60 * 5, delegateTo, }) {
+        const response = await this.invoke("request_secret", {
+            url,
+            type,
+            participant_id: fromParticipantId,
+            timeout,
+            delegate_to: delegateTo ?? null,
+        });
+        if (response instanceof FileContent) {
+            return response.data;
+        }
+        throw this.unexpectedResponse("request_secret");
+    }
+    async setSecret({ secretId, type, mimeType, name, delegatedTo, forIdentity, data, }) {
+        const response = await this.invoke("set_secret", new BinaryContent({
+            data,
+            headers: {
+                secret_id: secretId ?? null,
+                type: type ?? mimeType ?? null,
+                name: name ?? null,
+                delegated_to: delegatedTo ?? null,
+                for_identity: forIdentity ?? null,
+                has_data: true,
+            },
+        }));
+        if (response instanceof EmptyContent || response instanceof JsonContent) {
+            return;
+        }
+        throw this.unexpectedResponse("set_secret");
+    }
+    async getSecret({ secretId, type, name, delegatedTo, }) {
+        const response = await this.invoke("get_secret", {
+            secret_id: secretId ?? null,
+            type: type ?? null,
+            name: name ?? null,
+            delegated_to: delegatedTo ?? null,
+        });
+        if (response instanceof EmptyContent) {
+            return null;
+        }
+        if (response instanceof FileContent) {
+            return response;
+        }
+        throw this.unexpectedResponse("get_secret");
+    }
 }

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

@@ -1,37 +1,50 @@
 import { RoomClient } from "./room-client";
+import { Protocol } from "./protocol";
 import { RoomEvent } from "./room-event";
 import { BinaryContent, FileContent } from "./response";
 import { EventEmitter } from "./event-emitter";
+type StorageClientRoom = Pick<RoomClient, "invoke" | "invokeStream" | "emit"> & {
+    protocol: Pick<Protocol, "addHandler">;
+};
 export declare class FileHandle {
     id: number;
     constructor({ id }: {
         id: number;
     });
 }
-declare class StorageEntry {
+export declare class StorageEntry {
     name: string;
     isFolder: boolean;
     size: number | null;
-    constructor({ name, isFolder, size }: {
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    constructor({ name, isFolder, size, createdAt, updatedAt }: {
         name: string;
         isFolder: boolean;
         size?: number | null;
+        createdAt?: Date | null;
+        updatedAt?: Date | null;
     });
     nameWithoutExtension(): string;
 }
 export declare class StorageClient extends EventEmitter<RoomEvent> {
     private client;
     constructor({ room }: {
-        room: RoomClient;
+        room: StorageClientRoom;
     });
     private _handleFileUpdated;
     private _handleFileDeleted;
     private _unexpectedResponseError;
+    private _storageEntry;
     private _invoke;
     list(path: string): Promise<StorageEntry[]>;
-    delete(path: string): Promise<void>;
+    stat(path: string): Promise<StorageEntry | null>;
+    delete(path: string, { recursive, }?: {
+        recursive?: boolean | null;
+    }): Promise<void>;
     exists(path: string): Promise<boolean>;
     private _defaultUploadName;
+    private _defaultUploadMimeType;
     upload(path: string, bytes: Uint8Array, { overwrite, name, mimeType, }?: {
         overwrite?: boolean;
         name?: string | null;

package/dist/esm/storage-client.js

@@ -3,16 +3,68 @@ import { BinaryContent, ControlContent, ErrorContent, JsonContent, FileContent }
 import { unpackMessage } from "./utils";
 import { EventEmitter } from "./event-emitter";
 import { RoomServerException } from "./room-server-client";
+const _DEFAULT_UPLOAD_MIME_TYPE = "application/octet-stream";
+const _UPLOAD_MIME_TYPES_BY_SUFFIX = new Map([
+    [".tar.gz", "application/x-tar"],
+    [".tgz", "application/x-tar"],
+]);
+const _UPLOAD_MIME_TYPES_BY_EXTENSION = new Map([
+    [".bin", "application/octet-stream"],
+    [".css", "text/css"],
+    [".csv", "text/csv"],
+    [".gif", "image/gif"],
+    [".gz", "application/gzip"],
+    [".htm", "text/html"],
+    [".html", "text/html"],
+    [".jpeg", "image/jpeg"],
+    [".jpg", "image/jpeg"],
+    [".js", "text/javascript"],
+    [".json", "application/json"],
+    [".md", "text/markdown"],
+    [".mp3", "audio/mpeg"],
+    [".mp4", "video/mp4"],
+    [".pdf", "application/pdf"],
+    [".png", "image/png"],
+    [".svg", "image/svg+xml"],
+    [".tar", "application/x-tar"],
+    [".txt", "text/plain"],
+    [".ts", "text/typescript"],
+    [".tsx", "text/tsx"],
+    [".wasm", "application/wasm"],
+    [".webp", "image/webp"],
+    [".xml", "application/xml"],
+    [".yaml", "application/yaml"],
+    [".yml", "application/yaml"],
+    [".zip", "application/zip"],
+]);
+function _unexpectedStorageResponseError(operation) {
+    return new RoomServerException(`unexpected return type from storage.${operation}`);
+}
+function _parseStorageTimestamp(value, operation) {
+    if (value == null) {
+        return null;
+    }
+    if (typeof value !== "string") {
+        throw _unexpectedStorageResponseError(operation);
+    }
+    const timestamp = new Date(value);
+    if (Number.isNaN(timestamp.getTime())) {
+        throw _unexpectedStorageResponseError(operation);
+    }
+    return timestamp;
+}
 export class FileHandle {
     constructor({ id }) {
         this.id = id;
     }
 }
-class StorageEntry {
-    constructor({ name, isFolder, size = null }) {
+export class StorageEntry {
+    constructor({ name, isFolder, size = null, createdAt = null, updatedAt = null }) {
         this.name = name;
         this.isFolder = isFolder;
         this.size = size;
+        this.createdAt = createdAt;
+        this.updatedAt = updatedAt;
     }
     nameWithoutExtension() {
         const segments = this.name
@@ -32,18 +84,32 @@ export class StorageClient extends EventEmitter {
     }
     async _handleFileUpdated(protocol, messageId, type, bytes) {
         const [data, _] = unpackMessage(bytes || new Uint8Array());
-        const event = new FileUpdatedEvent({ path: data["path"] });
+        const event = new FileUpdatedEvent({ path: data["path"], participantId: data["participant_id"] });
         this.client.emit(event);
         this.emit('file.updated', event);
     }
     async _handleFileDeleted(protocol, messageId, type, bytes) {
         const [data, _] = unpackMessage(bytes || new Uint8Array());
-        const event = new FileDeletedEvent({ path: data["path"] });
+        const event = new FileDeletedEvent({ path: data["path"], participantId: data["participant_id"] });
         this.client.emit(event);
         this.emit('file.deleted', event);
     }
     _unexpectedResponseError(operation) {
-        return new RoomServerException(`unexpected return type from storage.${operation}`);
+        return _unexpectedStorageResponseError(operation);
+    }
+    _storageEntry(operation, value) {
+        if (typeof value["name"] !== "string" ||
+            typeof value["is_folder"] !== "boolean" ||
+            (value["size"] != null && typeof value["size"] !== "number")) {
+            throw this._unexpectedResponseError(operation);
+        }
+        return new StorageEntry({
+            name: value["name"],
+            isFolder: value["is_folder"],
+            size: typeof value["size"] === "number" ? value["size"] : null,
+            createdAt: _parseStorageTimestamp(value["created_at"], operation),
+            updatedAt: _parseStorageTimestamp(value["updated_at"], operation),
+        });
     }
     async _invoke(operation, input, callerContext) {
         return await this.client.invoke({
@@ -55,22 +121,26 @@ export class StorageClient extends EventEmitter {
     }
     async list(path) {
         const response = await this._invoke("list", { path });
-        if (!(response instanceof JsonContent)) {
+        if (!(response instanceof JsonContent) || !Array.isArray(response.json["files"])) {
             throw this._unexpectedResponseError("list");
         }
         const files = response.json["files"];
-        const entries = files.map((f) => {
-            return new StorageEntry({
-                name: f["name"],
-                isFolder: f["is_folder"],
-                size: typeof f["size"] === "number" ? f["size"] : null,
-            });
-        });
+        const entries = files.map((f) => this._storageEntry("list", f));
         entries.sort((a, b) => a.name.localeCompare(b.name));
         return entries;
     }
-    async delete(path) {
-        await this._invoke("delete", { path, recursive: null });
+    async stat(path) {
+        const response = await this._invoke("stat", { path });
+        if (!(response instanceof JsonContent) || typeof response.json["exists"] !== "boolean") {
+            throw this._unexpectedResponseError("stat");
+        }
+        if (!response.json["exists"]) {
+            return null;
+        }
+        return this._storageEntry("stat", response.json);
+    }
+    async delete(path, { recursive = null, } = {}) {
+        await this._invoke("delete", { path, recursive });
     }
     async exists(path) {
         const result = await this._invoke("exists", { path });
@@ -87,6 +157,22 @@ export class StorageClient extends EventEmitter {
         const lastSegment = segments.length > 0 ? segments[segments.length - 1] : undefined;
         return lastSegment ?? path;
     }
+    _defaultUploadMimeType(name, mimeType) {
+        if (typeof mimeType === "string" && mimeType.length > 0) {
+            return mimeType;
+        }
+        const lowerName = name.toLowerCase();
+        for (const [suffix, contentType] of _UPLOAD_MIME_TYPES_BY_SUFFIX.entries()) {
+            if (lowerName.endsWith(suffix)) {
+                return contentType;
+            }
+        }
+        const lastDot = lowerName.lastIndexOf(".");
+        if (lastDot >= 0) {
+            return _UPLOAD_MIME_TYPES_BY_EXTENSION.get(lowerName.slice(lastDot)) ?? _DEFAULT_UPLOAD_MIME_TYPE;
+        }
+        return _DEFAULT_UPLOAD_MIME_TYPE;
+    }
     async upload(path, bytes, { overwrite = false, name, mimeType = null, } = {}) {
         async function* singleChunk() {
             yield bytes;
@@ -100,6 +186,7 @@ export class StorageClient extends EventEmitter {
     }
     async uploadStream(path, chunks, { overwrite = false, chunkSize = 64 * 1024, size = null, name, mimeType = null, } = {}) {
         const resolvedName = this._defaultUploadName(path, name);
+        const resolvedMimeType = this._defaultUploadMimeType(resolvedName, mimeType);
         const input = new _StorageUploadInputStream({
             path,
             overwrite,
@@ -107,7 +194,7 @@ export class StorageClient extends EventEmitter {
             chunkSize,
             size,
             name: resolvedName,
-            mimeType,
+            mimeType: resolvedMimeType,
         });
         const response = await this.client.invokeStream({
             toolkit: "storage",