@meshagent/meshagent 0.35.6 → 0.35.8

package/dist/browser/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>;
 }

package/dist/browser/secrets-client.js

@@ -2,85 +2,284 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SecretsClient = void 0;
 const response_1 = require("./response");
+const room_server_client_1 = require("./room-server-client");
+const utils_1 = require("./utils");
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 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 room_server_client_1.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 response_1.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 response_1.EmptyContent || response instanceof response_1.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 response_1.EmptyContent) {
+    }
+    parseAccessToken(operation, response) {
+        if (!(response instanceof response_1.JsonContent)) {
+            throw this.unexpectedResponse(operation);
+        }
+        const token = response.json["access_token"];
+        if (typeof token !== "string" || token.length === 0) {
             return null;
         }
-        if (response instanceof response_1.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 room_server_client_1.RoomServerException("invalid secrets.request_oauth_token payload");
+        }
+        if (this.oauthTokenRequestHandler == null) {
+            throw new room_server_client_1.RoomServerException("No oauth token handler registered");
+        }
+        const [request] = (0, utils_1.unpackMessage)(bytes);
+        const requestId = request["request_id"];
+        const challenge = request["challenge"];
+        const requestPayload = request["request"];
+        if (typeof requestId !== "string" || !isRecord(requestPayload)) {
+            throw new room_server_client_1.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 room_server_client_1.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 room_server_client_1.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 room_server_client_1.RoomServerException("invalid secrets.request_secret payload");
+        }
+        if (this.secretRequestHandler == null) {
+            throw new room_server_client_1.RoomServerException("No secret handler registered");
+        }
+        const [request] = (0, utils_1.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 room_server_client_1.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 response_1.EmptyContent || response instanceof response_1.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 response_1.EmptyContent || response instanceof response_1.JsonContent) {
+            return;
+        }
+        throw this.unexpectedResponse("provide_oauth_authorization");
+    }
+    async provideSecret({ requestId, data, }) {
+        const response = await this.invoke("provide_secret", new response_1.BinaryContent({
+            data,
+            headers: {
+                request_id: requestId,
+                error: null,
+            },
+        }));
+        if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
+            return;
+        }
+        throw this.unexpectedResponse("provide_secret");
+    }
+    async rejectSecret({ requestId, error, }) {
+        const response = await this.invoke("provide_secret", new response_1.BinaryContent({
+            data: new Uint8Array(0),
+            headers: {
+                request_id: requestId,
+                error,
+            },
+        }));
+        if (response instanceof response_1.EmptyContent || response instanceof response_1.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 response_1.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 response_1.EmptyContent || response instanceof response_1.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 response_1.EmptyContent || response instanceof response_1.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 response_1.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 response_1.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 response_1.EmptyContent || response instanceof response_1.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 response_1.EmptyContent) {
+            return null;
+        }
+        if (response instanceof response_1.FileContent) {
+            return response;
+        }
+        throw this.unexpectedResponse("get_secret");
+    }
 }
 exports.SecretsClient = SecretsClient;

package/dist/browser/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;