@meshagent/meshagent 0.33.3 → 0.35.0

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

@@ -226,6 +226,29 @@ export interface KeysSecret extends BaseSecret {
     data: Record<string, string>;
 }
 export type SecretLike = PullSecret | KeysSecret;
+export interface ManagedSecretInfo {
+    id: string;
+    type: string;
+    name: string;
+    delegatedTo?: string | null;
+}
+export interface ManagedSecret extends ManagedSecretInfo {
+    dataBase64: string;
+    data: Uint8Array;
+}
+export interface ConnectorRef {
+    openaiConnectorId?: string | null;
+    serverUrl?: string | null;
+    clientSecretId?: string | null;
+}
+export interface ExternalOAuthClientRegistration {
+    id: string;
+    delegatedTo: string;
+    connector?: ConnectorRef | null;
+    oauth?: OAuthClientConfig | null;
+    clientId: string;
+    clientSecret?: string | null;
+}
 export declare class Meshagent {
     private readonly baseUrl;
     private readonly token?;
@@ -245,7 +268,13 @@ export declare class Meshagent {
     private parseBalance;
     private parseTransaction;
     private parseSecret;
+    private parseManagedSecretInfo;
+    private parseManagedSecret;
+    private parseSecretPayload;
     private toSecretPayload;
+    private parseConnectorRef;
+    private serializeConnectorRef;
+    private parseExternalOAuthClientRegistration;
     private parseOAuthClient;
     private parseRoomConnectionInfo;
     private encodePathComponent;
@@ -359,10 +388,121 @@ export declare class Meshagent {
     getService(projectId: string, serviceId: string): Promise<ServiceSpec>;
     listServices(projectId: string): Promise<ServiceSpec[]>;
     deleteService(projectId: string, serviceId: string): Promise<void>;
+    createProjectSecret(params: {
+        projectId: string;
+        name: string;
+        type: string;
+        data: Uint8Array | ArrayBuffer | Buffer;
+    }): Promise<string>;
+    updateProjectSecret(params: {
+        projectId: string;
+        secretId: string;
+        name: string;
+        type: string;
+        data: Uint8Array | ArrayBuffer | Buffer;
+    }): Promise<void>;
+    getProjectSecret(projectId: string, secretId: string): Promise<ManagedSecret>;
+    listProjectSecrets(projectId: string): Promise<ManagedSecretInfo[]>;
+    deleteProjectSecret(projectId: string, secretId: string): Promise<void>;
+    createRoomSecret(params: {
+        projectId: string;
+        roomName: string;
+        data: Uint8Array | ArrayBuffer | Buffer;
+        secretId?: string;
+        name?: string;
+        type?: string;
+        delegatedTo?: string;
+        forIdentity?: string;
+    }): Promise<string>;
+    updateRoomSecret(params: {
+        projectId: string;
+        roomName: string;
+        secretId: string;
+        data: Uint8Array | ArrayBuffer | Buffer;
+        name?: string;
+        type?: string;
+        delegatedTo?: string;
+        forIdentity?: string;
+    }): Promise<void>;
+    getRoomSecret(params: {
+        projectId: string;
+        roomName: string;
+        secretId: string;
+        delegatedTo?: string;
+        forIdentity?: string;
+    }): Promise<ManagedSecret>;
+    listRoomSecrets(params: {
+        projectId: string;
+        roomName: string;
+        forIdentity?: string;
+    }): Promise<ManagedSecretInfo[]>;
+    deleteRoomSecret(params: {
+        projectId: string;
+        roomName: string;
+        secretId: string;
+        delegatedTo?: string;
+        forIdentity?: string;
+    }): Promise<void>;
     createSecret(projectId: string, secret: SecretLike): Promise<void>;
     updateSecret(projectId: string, secret: SecretLike): Promise<void>;
     deleteSecret(projectId: string, secretId: string): Promise<void>;
     listSecrets(projectId: string): Promise<SecretLike[]>;
+    createProjectExternalOAuthRegistration(params: {
+        projectId: string;
+        oauth: OAuthClientConfig;
+        clientId: string;
+        clientSecret?: string | null;
+        delegatedTo?: string | null;
+        connector?: ConnectorRef | null;
+    }): Promise<string>;
+    updateProjectExternalOAuthRegistration(params: {
+        projectId: string;
+        registrationId: string;
+        oauth: OAuthClientConfig;
+        clientId: string;
+        clientSecret?: string | null;
+        delegatedTo?: string | null;
+        connector?: ConnectorRef | null;
+    }): Promise<void>;
+    listProjectExternalOAuthRegistrations(params: {
+        projectId: string;
+        delegatedTo?: string | null;
+    }): Promise<ExternalOAuthClientRegistration[]>;
+    deleteProjectExternalOAuthRegistration(params: {
+        projectId: string;
+        registrationId: string;
+        delegatedTo?: string | null;
+    }): Promise<void>;
+    createRoomExternalOAuthRegistration(params: {
+        projectId: string;
+        roomName: string;
+        oauth: OAuthClientConfig;
+        clientId: string;
+        clientSecret?: string | null;
+        delegatedTo?: string | null;
+        connector?: ConnectorRef | null;
+    }): Promise<string>;
+    updateRoomExternalOAuthRegistration(params: {
+        projectId: string;
+        roomName: string;
+        registrationId: string;
+        oauth: OAuthClientConfig;
+        clientId: string;
+        clientSecret?: string | null;
+        delegatedTo?: string | null;
+        connector?: ConnectorRef | null;
+    }): Promise<void>;
+    listRoomExternalOAuthRegistrations(params: {
+        projectId: string;
+        roomName: string;
+        delegatedTo?: string | null;
+    }): Promise<ExternalOAuthClientRegistration[]>;
+    deleteRoomExternalOAuthRegistration(params: {
+        projectId: string;
+        roomName: string;
+        registrationId: string;
+        delegatedTo?: string | null;
+    }): Promise<void>;
     createRoom(params: {
         projectId: string;
         name: string;

package/dist/esm/meshagent-client.js

@@ -1,6 +1,7 @@
 import { meshagentBaseUrl } from "./helpers";
 import { RoomException } from "./requirement";
 import { ApiScope } from "./participant-token";
+import { decoder, encoder } from "./utils";
 function pruneUndefinedValues(value) {
     if (Array.isArray(value)) {
         const prunedItems = value
@@ -41,6 +42,40 @@ function serializeServiceSpec(service) {
         agents,
     });
 }
+const globalScope = globalThis;
+function bytesToBase64(bytes) {
+    if (globalScope.Buffer) {
+        return globalScope.Buffer.from(bytes).toString("base64");
+    }
+    if (!globalScope.btoa) {
+        throw new Error("base64 encoding is not available in this runtime");
+    }
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return globalScope.btoa(binary);
+}
+function base64ToBytes(base64) {
+    if (globalScope.Buffer) {
+        return Uint8Array.from(globalScope.Buffer.from(base64, "base64"));
+    }
+    if (!globalScope.atob) {
+        throw new Error("base64 decoding is not available in this runtime");
+    }
+    const binary = globalScope.atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+}
+function normalizeBinary(data) {
+    if (data instanceof Uint8Array) {
+        return data;
+    }
+    return new Uint8Array(data);
+}
 export class Meshagent {
     constructor({ baseUrl, token } = {}) {
         const resolvedBaseUrl = meshagentBaseUrl(baseUrl).replace(/\/+$/, "");
@@ -324,6 +359,75 @@ export class Meshagent {
         }
         throw new RoomException(`Unknown secret type: ${type}`);
     }
+    parseManagedSecretInfo(data) {
+        if (!data || typeof data !== "object") {
+            throw new RoomException("Invalid managed secret payload");
+        }
+        const { id, type, name, delegated_to: delegatedToRaw, delegatedTo } = data;
+        if (typeof id !== "string" || typeof type !== "string" || typeof name !== "string") {
+            throw new RoomException("Invalid managed secret payload: missing id, type, or name");
+        }
+        const delegatedToValue = typeof delegatedTo === "string"
+            ? delegatedTo
+            : typeof delegatedToRaw === "string"
+                ? delegatedToRaw
+                : null;
+        return {
+            id,
+            type,
+            name,
+            delegatedTo: delegatedToValue,
+        };
+    }
+    parseManagedSecret(data) {
+        const secret = this.parseManagedSecretInfo(data);
+        const dataBase64 = data.data_base64 ?? data.dataBase64;
+        if (typeof dataBase64 !== "string") {
+            throw new RoomException("Invalid managed secret payload: missing data_base64");
+        }
+        return {
+            ...secret,
+            dataBase64,
+            data: base64ToBytes(dataBase64),
+        };
+    }
+    parseSecretPayload(secret, rawData) {
+        let payload;
+        try {
+            payload = JSON.parse(decoder.decode(rawData));
+        }
+        catch {
+            throw new RoomException(`Invalid secret payload for ${secret.id}`);
+        }
+        if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+            throw new RoomException(`Invalid secret payload for ${secret.id}`);
+        }
+        if (secret.type === "docker") {
+            const { server, username, password, email } = payload;
+            if (typeof server !== "string" || typeof username !== "string" || typeof password !== "string") {
+                throw new RoomException(`Invalid secret payload for ${secret.id}`);
+            }
+            return {
+                id: secret.id,
+                name: secret.name,
+                type: "docker",
+                server,
+                username,
+                password,
+                email: typeof email === "string" ? email : "none@example.com",
+            };
+        }
+        const entries = Object.entries(payload);
+        if (entries.some(([, value]) => typeof value !== "string")) {
+            throw new RoomException(`Invalid secret payload for ${secret.id}`);
+        }
+        return {
+            id: secret.id,
+            name: secret.name,
+            type: "keys",
+            data: Object.fromEntries(entries),
+        };
+    }
     toSecretPayload(secret) {
         if (secret.type === "docker") {
             return {
@@ -343,6 +447,68 @@ export class Meshagent {
             data: { ...secret.data },
         };
     }
+    parseConnectorRef(data) {
+        if (data == null) {
+            return null;
+        }
+        if (typeof data !== "object") {
+            throw new RoomException("Invalid connector payload");
+        }
+        const { openai_connector_id: openaiConnectorIdRaw, openaiConnectorId, server_url: serverUrlRaw, serverUrl, client_secret_id: clientSecretIdRaw, clientSecretId, } = data;
+        return {
+            openaiConnectorId: typeof openaiConnectorId === "string"
+                ? openaiConnectorId
+                : typeof openaiConnectorIdRaw === "string"
+                    ? openaiConnectorIdRaw
+                    : null,
+            serverUrl: typeof serverUrl === "string"
+                ? serverUrl
+                : typeof serverUrlRaw === "string"
+                    ? serverUrlRaw
+                    : null,
+            clientSecretId: typeof clientSecretId === "string"
+                ? clientSecretId
+                : typeof clientSecretIdRaw === "string"
+                    ? clientSecretIdRaw
+                    : null,
+        };
+    }
+    serializeConnectorRef(connector) {
+        if (connector == null) {
+            return null;
+        }
+        const payload = {};
+        if (connector.openaiConnectorId) {
+            payload.openai_connector_id = connector.openaiConnectorId;
+        }
+        if (connector.serverUrl) {
+            payload.server_url = connector.serverUrl;
+        }
+        if (connector.clientSecretId) {
+            payload.client_secret_id = connector.clientSecretId;
+        }
+        return payload;
+    }
+    parseExternalOAuthClientRegistration(data) {
+        if (!data || typeof data !== "object") {
+            throw new RoomException("Invalid external oauth registration payload");
+        }
+        const { id, delegated_to: delegatedToRaw, delegatedTo, connector, oauth, client_id: clientIdRaw, clientId, client_secret: clientSecretRaw, clientSecret, } = data;
+        const delegatedToValue = typeof delegatedTo === "string" ? delegatedTo : delegatedToRaw;
+        const clientIdValue = typeof clientId === "string" ? clientId : clientIdRaw;
+        const clientSecretValue = typeof clientSecret === "string" ? clientSecret : clientSecretRaw;
+        if (typeof id !== "string" || typeof delegatedToValue !== "string" || typeof clientIdValue !== "string") {
+            throw new RoomException("Invalid external oauth registration payload: missing fields");
+        }
+        return {
+            id,
+            delegatedTo: delegatedToValue,
+            connector: this.parseConnectorRef(connector),
+            oauth: oauth && typeof oauth === "object" ? oauth : null,
+            clientId: clientIdValue,
+            clientSecret: typeof clientSecretValue === "string" ? clientSecretValue : null,
+        };
+    }
     parseOAuthClient(data) {
         if (!data || typeof data !== "object") {
             throw new RoomException("Invalid OAuth client payload");
@@ -821,38 +987,263 @@ export class Meshagent {
             responseType: "void",
         });
     }
-    async createSecret(projectId, secret) {
-        await this.request(`/accounts/projects/${projectId}/secrets`, {
+    async createProjectSecret(params) {
+        const { projectId, name, type, data } = params;
+        const payload = await this.request(`/accounts/projects/${projectId}/secrets`, {
             method: "POST",
-            json: this.toSecretPayload(secret),
-            action: "create secret",
+            json: {
+                name,
+                type,
+                data_base64: bytesToBase64(normalizeBinary(data)),
+            },
+            action: "create project secret",
+        });
+        if (!payload || typeof payload !== "object" || typeof payload.id !== "string") {
+            throw new RoomException("Invalid create project secret response payload");
+        }
+        return payload.id;
+    }
+    async updateProjectSecret(params) {
+        const { projectId, secretId, name, type, data } = params;
+        await this.request(`/accounts/projects/${projectId}/secrets/${secretId}`, {
+            method: "PUT",
+            json: {
+                name,
+                type,
+                data_base64: bytesToBase64(normalizeBinary(data)),
+            },
+            action: "update project secret",
             responseType: "void",
         });
     }
+    async getProjectSecret(projectId, secretId) {
+        const data = await this.request(`/accounts/projects/${projectId}/secrets/${secretId}`, {
+            action: "fetch project secret",
+        });
+        return this.parseManagedSecret(data);
+    }
+    async listProjectSecrets(projectId) {
+        const data = await this.request(`/accounts/projects/${projectId}/secrets`, {
+            action: "list project secrets",
+        });
+        const secrets = Array.isArray(data?.secrets) ? data.secrets : [];
+        return secrets.map((item) => this.parseManagedSecretInfo(item));
+    }
+    async deleteProjectSecret(projectId, secretId) {
+        await this.request(`/accounts/projects/${projectId}/secrets/${secretId}`, {
+            method: "DELETE",
+            action: "delete project secret",
+            responseType: "void",
+        });
+    }
+    async createRoomSecret(params) {
+        const { projectId, roomName, data, secretId, name, type, delegatedTo, forIdentity } = params;
+        const payload = await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/secrets`, {
+            method: "POST",
+            json: {
+                data_base64: bytesToBase64(normalizeBinary(data)),
+                secret_id: secretId,
+                name,
+                type,
+                delegated_to: delegatedTo,
+                for_identity: forIdentity,
+            },
+            action: "create room secret",
+        });
+        if (!payload || typeof payload !== "object" || typeof payload.id !== "string") {
+            throw new RoomException("Invalid create room secret response payload");
+        }
+        return payload.id;
+    }
+    async updateRoomSecret(params) {
+        const { projectId, roomName, secretId, data, name, type, delegatedTo, forIdentity } = params;
+        await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/secrets/${secretId}`, {
+            method: "PUT",
+            json: {
+                data_base64: bytesToBase64(normalizeBinary(data)),
+                name,
+                type,
+                delegated_to: delegatedTo,
+                for_identity: forIdentity,
+            },
+            action: "update room secret",
+            responseType: "void",
+        });
+    }
+    async getRoomSecret(params) {
+        const { projectId, roomName, secretId, delegatedTo, forIdentity } = params;
+        const data = await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/secrets/${secretId}`, {
+            query: {
+                delegated_to: delegatedTo,
+                for_identity: forIdentity,
+            },
+            action: "fetch room secret",
+        });
+        return this.parseManagedSecret(data);
+    }
+    async listRoomSecrets(params) {
+        const { projectId, roomName, forIdentity } = params;
+        const data = await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/secrets`, {
+            query: {
+                for_identity: forIdentity,
+            },
+            action: "list room secrets",
+        });
+        const secrets = Array.isArray(data?.secrets) ? data.secrets : [];
+        return secrets.map((item) => this.parseManagedSecretInfo(item));
+    }
+    async deleteRoomSecret(params) {
+        const { projectId, roomName, secretId, delegatedTo, forIdentity } = params;
+        await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/secrets/${secretId}`, {
+            method: "DELETE",
+            query: {
+                delegated_to: delegatedTo,
+                for_identity: forIdentity,
+            },
+            action: "delete room secret",
+            responseType: "void",
+        });
+    }
+    async createSecret(projectId, secret) {
+        await this.createProjectSecret({
+            projectId,
+            name: secret.name,
+            type: secret.type,
+            data: encoder.encode(JSON.stringify(this.toSecretPayload(secret).data)),
+        });
+    }
     async updateSecret(projectId, secret) {
         if (!secret.id) {
             throw new RoomException("Secret id is required to update a secret");
         }
-        await this.request(`/accounts/projects/${projectId}/secrets/${secret.id}`, {
+        await this.updateProjectSecret({
+            projectId,
+            secretId: secret.id,
+            name: secret.name,
+            type: secret.type,
+            data: encoder.encode(JSON.stringify(this.toSecretPayload(secret).data)),
+        });
+    }
+    async deleteSecret(projectId, secretId) {
+        await this.deleteProjectSecret(projectId, secretId);
+    }
+    async listSecrets(projectId) {
+        const secretInfos = await this.listProjectSecrets(projectId);
+        const secrets = await Promise.all(secretInfos.map(async (secretInfo) => {
+            const secret = await this.getProjectSecret(projectId, secretInfo.id);
+            return this.parseSecretPayload(secret, secret.data);
+        }));
+        return secrets;
+    }
+    async createProjectExternalOAuthRegistration(params) {
+        const { projectId, oauth, clientId, clientSecret, delegatedTo, connector } = params;
+        const payload = await this.request(`/accounts/projects/${projectId}/external-oauth`, {
+            method: "POST",
+            json: {
+                oauth,
+                client_id: clientId,
+                client_secret: clientSecret,
+                delegated_to: delegatedTo,
+                connector: this.serializeConnectorRef(connector),
+            },
+            action: "create project external oauth registration",
+        });
+        if (!payload || typeof payload !== "object" || typeof payload.id !== "string") {
+            throw new RoomException("Invalid create project external oauth registration response payload");
+        }
+        return payload.id;
+    }
+    async updateProjectExternalOAuthRegistration(params) {
+        const { projectId, registrationId, oauth, clientId, clientSecret, delegatedTo, connector } = params;
+        await this.request(`/accounts/projects/${projectId}/external-oauth/${registrationId}`, {
             method: "PUT",
-            json: this.toSecretPayload(secret),
-            action: "update secret",
+            json: {
+                oauth,
+                client_id: clientId,
+                client_secret: clientSecret,
+                delegated_to: delegatedTo,
+                connector: this.serializeConnectorRef(connector),
+            },
+            action: "update project external oauth registration",
             responseType: "void",
         });
     }
-    async deleteSecret(projectId, secretId) {
-        await this.request(`/accounts/projects/${projectId}/secrets/${secretId}`, {
+    async listProjectExternalOAuthRegistrations(params) {
+        const { projectId, delegatedTo } = params;
+        const data = await this.request(`/accounts/projects/${projectId}/external-oauth`, {
+            query: {
+                delegated_to: delegatedTo,
+            },
+            action: "list project external oauth registrations",
+        });
+        const registrations = Array.isArray(data?.registrations) ? data.registrations : [];
+        return registrations.map((item) => this.parseExternalOAuthClientRegistration(item));
+    }
+    async deleteProjectExternalOAuthRegistration(params) {
+        const { projectId, registrationId, delegatedTo } = params;
+        await this.request(`/accounts/projects/${projectId}/external-oauth/${registrationId}`, {
             method: "DELETE",
-            action: "delete secret",
+            query: {
+                delegated_to: delegatedTo,
+            },
+            action: "delete project external oauth registration",
             responseType: "void",
         });
     }
-    async listSecrets(projectId) {
-        const data = await this.request(`/accounts/projects/${projectId}/secrets`, {
-            action: "list secrets",
+    async createRoomExternalOAuthRegistration(params) {
+        const { projectId, roomName, oauth, clientId, clientSecret, delegatedTo, connector } = params;
+        const payload = await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/external-oauth`, {
+            method: "POST",
+            json: {
+                oauth,
+                client_id: clientId,
+                client_secret: clientSecret,
+                delegated_to: delegatedTo,
+                connector: this.serializeConnectorRef(connector),
+            },
+            action: "create room external oauth registration",
+        });
+        if (!payload || typeof payload !== "object" || typeof payload.id !== "string") {
+            throw new RoomException("Invalid create room external oauth registration response payload");
+        }
+        return payload.id;
+    }
+    async updateRoomExternalOAuthRegistration(params) {
+        const { projectId, roomName, registrationId, oauth, clientId, clientSecret, delegatedTo, connector } = params;
+        await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/external-oauth/${registrationId}`, {
+            method: "PUT",
+            json: {
+                oauth,
+                client_id: clientId,
+                client_secret: clientSecret,
+                delegated_to: delegatedTo,
+                connector: this.serializeConnectorRef(connector),
+            },
+            action: "update room external oauth registration",
+            responseType: "void",
+        });
+    }
+    async listRoomExternalOAuthRegistrations(params) {
+        const { projectId, roomName, delegatedTo } = params;
+        const data = await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/external-oauth`, {
+            query: {
+                delegated_to: delegatedTo,
+            },
+            action: "list room external oauth registrations",
+        });
+        const registrations = Array.isArray(data?.registrations) ? data.registrations : [];
+        return registrations.map((item) => this.parseExternalOAuthClientRegistration(item));
+    }
+    async deleteRoomExternalOAuthRegistration(params) {
+        const { projectId, roomName, registrationId, delegatedTo } = params;
+        await this.request(`/accounts/projects/${projectId}/rooms/${roomName}/external-oauth/${registrationId}`, {
+            method: "DELETE",
+            query: {
+                delegated_to: delegatedTo,
+            },
+            action: "delete room external oauth registration",
+            responseType: "void",
         });
-        const secrets = Array.isArray(data?.secrets) ? data.secrets : [];
-        return secrets.map((item) => this.parseSecret(item));
     }
     async createRoom(params) {
         const { projectId, name, ifNotExists = false, metadata, annotations, permissions } = params;