@meshagent/meshagent 0.5.19 → 0.6.1

package/dist/browser/helpers.d.ts

@@ -14,19 +14,21 @@ export declare function websocketRoomUrl({ roomName, apiUrl }: {
     roomName: string;
     apiUrl?: string;
 }): string;
-export declare function participantToken({ participantName, roomName, role, projectId, apiKeyId, }: {
+export declare function participantToken({ participantName, roomName, role, projectId, apiKeyId, apiKey, }: {
     participantName: string;
     roomName: string;
     role?: string;
-    projectId: string;
-    apiKeyId: string;
+    projectId?: string;
+    apiKeyId?: string;
+    apiKey?: string;
 }): ParticipantToken;
-export declare function websocketProtocol({ participantName, roomName, role, projectId, apiKeyId, secret, apiUrl }: {
+export declare function websocketProtocol({ participantName, roomName, role, projectId, apiKeyId, apiKey, secret, apiUrl }: {
     participantName: string;
     roomName: string;
     role?: string;
-    projectId: string;
-    apiKeyId: string;
-    secret: string;
+    projectId?: string;
+    apiKeyId?: string;
+    secret?: string;
     apiUrl?: string;
+    apiKey?: string;
 }): Promise<WebSocketClientProtocol>;

package/dist/browser/helpers.js

@@ -9,6 +9,7 @@ exports.websocketProtocol = websocketProtocol;
 const schema_1 = require("./schema");
 const participant_token_1 = require("./participant-token");
 const protocol_1 = require("./protocol");
+const api_keys_1 = require("./api_keys");
 function validateSchemaName(name) {
     if (name.includes('.')) {
         throw new schema_1.MeshSchemaValidationException("schema name cannot contain '.'");
@@ -38,17 +39,29 @@ function websocketRoomUrl({ roomName, apiUrl }) {
     }
     return `${url}/rooms/${roomName}`;
 }
-function participantToken({ participantName, roomName, role, projectId, apiKeyId, }) {
-    const token = new participant_token_1.ParticipantToken({ name: participantName, projectId, apiKeyId });
+function participantToken({ participantName, roomName, role, projectId, apiKeyId, apiKey, }) {
+    let resolvedProjectId = projectId;
+    let resolvedApiKeyId = apiKeyId;
+    if (apiKey) {
+        const parsed = (0, api_keys_1.parseApiKey)(apiKey);
+        resolvedProjectId ?? (resolvedProjectId = parsed.projectId);
+        resolvedApiKeyId ?? (resolvedApiKeyId = parsed.id);
+    }
+    const token = new participant_token_1.ParticipantToken({
+        name: participantName,
+        projectId: resolvedProjectId,
+        apiKeyId: resolvedApiKeyId,
+    });
     token.addRoomGrant(roomName);
     if (role) {
         token.addRoleGrant(role);
     }
+    token.addApiGrant(participant_token_1.ApiScope.agentDefault());
     return token;
 }
-async function websocketProtocol({ participantName, roomName, role, projectId, apiKeyId, secret, apiUrl }) {
+async function websocketProtocol({ participantName, roomName, role, projectId, apiKeyId, apiKey, secret, apiUrl }) {
     const url = websocketRoomUrl({ roomName, apiUrl });
-    const token = participantToken({ participantName, roomName, role, projectId, apiKeyId });
-    const jwt = await token.toJwt({ token: secret });
+    const token = participantToken({ participantName, roomName, role, projectId, apiKeyId, apiKey });
+    const jwt = await token.toJwt({ token: secret, apiKey });
     return new protocol_1.WebSocketClientProtocol({ url, token: jwt });
 }

package/dist/browser/index.d.ts

@@ -1,4 +1,5 @@
 export * from './agent';
+export * from './agent-client';
 export * from './event-emitter';
 export * from './client';
 export * from './completer';
@@ -6,6 +7,7 @@ export * from './data-types';
 export * from './database-client';
 export * from './developer-client';
 export * from './document';
+export * from './meshagent-client';
 export * from './messaging-client';
 export * from './participant-token';
 export * from './participant';
@@ -21,5 +23,6 @@ export * from './schema';
 export * from './storage-client';
 export * from './stream-controller';
 export * from './sync-client';
+export * from './api_keys';
 export * from './helpers';
 export * from './utils';

package/dist/browser/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./agent"), exports);
+__exportStar(require("./agent-client"), exports);
 __exportStar(require("./event-emitter"), exports);
 __exportStar(require("./client"), exports);
 __exportStar(require("./completer"), exports);
@@ -22,6 +23,7 @@ __exportStar(require("./data-types"), exports);
 __exportStar(require("./database-client"), exports);
 __exportStar(require("./developer-client"), exports);
 __exportStar(require("./document"), exports);
+__exportStar(require("./meshagent-client"), exports);
 __exportStar(require("./messaging-client"), exports);
 __exportStar(require("./participant-token"), exports);
 __exportStar(require("./participant"), exports);
@@ -37,5 +39,6 @@ __exportStar(require("./schema"), exports);
 __exportStar(require("./storage-client"), exports);
 __exportStar(require("./stream-controller"), exports);
 __exportStar(require("./sync-client"), exports);
+__exportStar(require("./api_keys"), exports);
 __exportStar(require("./helpers"), exports);
 __exportStar(require("./utils"), exports);

package/dist/browser/lk-client.d.ts

@@ -0,0 +1,18 @@
+import { RoomClient } from './room-client';
+export declare class LivekitConnectionInfo {
+    url: string;
+    token: string;
+    constructor({ url, token }: {
+        url: string;
+        token: string;
+    });
+}
+export declare class LivekitClient {
+    room: RoomClient;
+    constructor({ room }: {
+        room: RoomClient;
+    });
+    getConnectionInfo({ breakoutRoom }: {
+        breakoutRoom?: string;
+    }): Promise<LivekitConnectionInfo>;
+}

package/dist/browser/lk-client.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LivekitClient = exports.LivekitConnectionInfo = void 0;
+class LivekitConnectionInfo {
+    constructor({ url, token }) {
+        this.url = url;
+        this.token = token;
+    }
+}
+exports.LivekitConnectionInfo = LivekitConnectionInfo;
+class LivekitClient {
+    constructor({ room }) {
+        this.room = room;
+    }
+    async getConnectionInfo({ breakoutRoom }) {
+        const response = (await this.room.sendRequest('livekit.connect', { breakout_room: breakoutRoom }));
+        if (!response || !response.json) {
+            throw new Error('Failed to get connection info');
+        }
+        const { url, token } = response.json;
+        return new LivekitConnectionInfo({ url, token });
+    }
+}
+exports.LivekitClient = LivekitClient;

package/dist/browser/lk-protocol.d.ts

@@ -0,0 +1,22 @@
+import type { ProtocolChannel } from './protocol';
+import type { Room, RemoteParticipant } from 'livekit-client';
+export type DataHandler = (data: Uint8Array) => void;
+export type StartOptions = {
+    onDone?: () => void;
+    onError?: (error: unknown) => void;
+};
+export declare class LivekitProtocolChannel implements ProtocolChannel {
+    private room;
+    private remote;
+    private topic;
+    private onDataReceived?;
+    private boundOnData?;
+    constructor({ room, remote, topic }: {
+        room: Room;
+        remote: RemoteParticipant;
+        topic: string;
+    });
+    start(onDataReceived: (data: Uint8Array) => void, _opts?: StartOptions): void;
+    sendData(data: Uint8Array): Promise<void>;
+    dispose(): void;
+}

package/dist/browser/lk-protocol.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LivekitProtocolChannel = void 0;
+const livekit_client_1 = require("livekit-client");
+class LivekitProtocolChannel {
+    constructor({ room, remote, topic }) {
+        this.room = room;
+        this.remote = remote;
+        this.topic = topic;
+    }
+    start(onDataReceived, _opts) {
+        this.onDataReceived = onDataReceived;
+        this.boundOnData = (payload, participant, ...rest) => {
+            const identityMatches = participant?.identity === this.remote.identity;
+            const topicArg = rest?.[rest.length - 1] ?? undefined;
+            if (topicArg === this.topic && identityMatches) {
+                this.onDataReceived?.(payload);
+            }
+        };
+        this.room.on(livekit_client_1.RoomEvent.DataReceived, this.boundOnData);
+    }
+    async sendData(data) {
+        await this.room.localParticipant.publishData(data, {
+            reliable: true,
+            topic: this.topic,
+            destinationIdentities: [this.remote.identity],
+        });
+    }
+    dispose() {
+        if (this.boundOnData) {
+            this.room.off(livekit_client_1.RoomEvent.DataReceived, this.boundOnData);
+        }
+        this.boundOnData = undefined;
+        this.onDataReceived = undefined;
+    }
+}
+exports.LivekitProtocolChannel = LivekitProtocolChannel;

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

@@ -0,0 +1,392 @@
+import { ApiScope } from "./participant-token";
+export type ProjectRole = "member" | "admin" | "developer";
+export interface RoomShare {
+    id: string;
+    projectId: string;
+    settings: Record<string, unknown>;
+}
+export interface RoomShareConnectionInfo {
+    jwt: string;
+    roomName: string;
+    projectId: string;
+    settings: Record<string, unknown>;
+    roomUrl: string;
+}
+export interface RoomConnectionInfo {
+    jwt: string;
+    roomName: string;
+    projectId: string;
+    roomUrl: string;
+}
+export interface RoomSession {
+    id: string;
+    roomId?: string | null;
+    roomName: string;
+    createdAt: Date;
+    isActive: boolean;
+    participants?: Record<string, number>;
+}
+export interface RoomInfo {
+    id: string;
+    name: string;
+    metadata: Record<string, unknown>;
+}
+export interface ProjectRoomGrant {
+    room: RoomInfo;
+    userId: string;
+    permissions: ApiScope;
+}
+export interface ProjectRoomGrantCount {
+    room: RoomInfo;
+    count: number;
+}
+export interface ProjectUserGrantCount {
+    userId: string;
+    count: number;
+    firstName?: string | null;
+    lastName?: string | null;
+    email: string;
+}
+export interface EnvironmentVariable {
+    name: string;
+    value: string;
+}
+export interface RoomStorageMountSpec {
+    path: string;
+    subpath?: string | null;
+    read_only?: boolean;
+}
+export interface ProjectStorageMountSpec {
+    path: string;
+    subpath?: string | null;
+    read_only?: boolean;
+}
+export interface ServiceStorageMountsSpec {
+    room?: RoomStorageMountSpec[];
+    project?: ProjectStorageMountSpec[];
+}
+export interface ServiceApiKeySpec {
+    role: "admin";
+    name: string;
+    auto_provision?: boolean | null;
+}
+export interface ServiceMetadata {
+    name: string;
+    description?: string | null;
+    repo?: string | null;
+    icon?: string | null;
+    annotations?: Record<string, string> | null;
+}
+export interface ContainerSpec {
+    command?: string | null;
+    image: string;
+    environment?: EnvironmentVariable[] | null;
+    secrets?: string[];
+    pull_secret?: string | null;
+    storage?: ServiceStorageMountsSpec;
+    api_key?: ServiceApiKeySpec;
+}
+export interface ExternalServiceSpec {
+    url: string;
+}
+export interface MeshagentEndpointSpec {
+    identity: string;
+    api?: ApiScope;
+}
+export interface AllowedMcpToolFilter {
+    tool_names?: string[] | null;
+    read_only?: boolean | null;
+}
+export interface OAuthClientConfig {
+    client_id: string;
+    client_secret?: string | null;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    no_pkce?: boolean | null;
+    scopes?: string[] | null;
+}
+export interface MCPEndpointSpec {
+    label: string;
+    description?: string | null;
+    allowed_tools?: AllowedMcpToolFilter[] | null;
+    headers?: Record<string, string> | null;
+    require_approval?: "always" | "never" | null;
+    oauth?: OAuthClientConfig | null;
+    openai_connector_id?: string | null;
+}
+export interface EndpointSpec {
+    path: string;
+    meshagent?: MeshagentEndpointSpec;
+    mcp?: MCPEndpointSpec;
+}
+export interface PortSpec {
+    num: "*" | number;
+    type?: "http" | "tcp" | null;
+    endpoints?: EndpointSpec[];
+    liveness?: string | null;
+}
+export interface ServiceSpec {
+    version: "v1";
+    kind: "Service";
+    id?: string | null;
+    metadata: ServiceMetadata;
+    ports?: PortSpec[];
+    container?: ContainerSpec | null;
+    external?: ExternalServiceSpec | null;
+}
+export interface Mailbox {
+    address: string;
+    room: string;
+    queue: string;
+}
+export interface Balance {
+    balance: number;
+    autoRechargeThreshold?: number | null;
+    autoRechargeAmount?: number | null;
+    lastRecharge?: Date | null;
+}
+export interface Transaction {
+    id: string;
+    amount: number;
+    reference?: string | null;
+    referenceType?: string | null;
+    description: string;
+    createdAt: Date;
+}
+export interface OAuthClient {
+    clientId: string;
+    clientSecret: string;
+    grantTypes: string[];
+    responseTypes: string[];
+    redirectUris: string[];
+    scope: string;
+    projectId: string;
+    metadata: Record<string, string>;
+}
+export interface BaseSecret {
+    id?: string;
+    name: string;
+    type: "docker" | "keys";
+}
+export interface PullSecret extends BaseSecret {
+    type: "docker";
+    server: string;
+    username: string;
+    password: string;
+    email?: string;
+}
+export interface KeysSecret extends BaseSecret {
+    type: "keys";
+    data: Record<string, string>;
+}
+export type SecretLike = PullSecret | KeysSecret;
+export declare class Meshagent {
+    private readonly baseUrl;
+    private readonly token?;
+    constructor({ baseUrl, token }?: {
+        baseUrl?: string;
+        token?: string;
+    });
+    private buildUrl;
+    private request;
+    private parseRoomShare;
+    private parseRoomShareConnectionInfo;
+    private parseRoomSession;
+    private parseRoom;
+    private parseProjectRoomGrant;
+    private parseProjectRoomGrantCount;
+    private parseProjectUserGrantCount;
+    private parseBalance;
+    private parseTransaction;
+    private parseSecret;
+    private toSecretPayload;
+    private parseOAuthClient;
+    private parseRoomConnectionInfo;
+    private encodePathComponent;
+    upload({ projectId, path, data }: {
+        projectId: string;
+        path: string;
+        data: ArrayBuffer | Uint8Array | Buffer;
+    }): Promise<void>;
+    download({ projectId, path }: {
+        projectId: string;
+        path: string;
+    }): Promise<Uint8Array>;
+    getProjectRole(projectId: string): Promise<ProjectRole>;
+    createShare(projectId: string, settings?: Record<string, unknown>): Promise<{
+        id: string;
+    }>;
+    deleteShare(projectId: string, shareId: string): Promise<void>;
+    updateShare(projectId: string, shareId: string, settings?: Record<string, unknown>): Promise<void>;
+    listShares(projectId: string): Promise<RoomShare[]>;
+    connectShare(shareId: string): Promise<RoomShareConnectionInfo>;
+    createProject(name: string, settings?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    addUserToProject(projectId: string, userId: string, options?: {
+        isAdmin?: boolean;
+        isDeveloper?: boolean;
+    }): Promise<Record<string, unknown>>;
+    removeUserFromProject(projectId: string, userId: string): Promise<Record<string, unknown>>;
+    updateProjectSettings(projectId: string, settings: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getUsersInProject(projectId: string): Promise<Record<string, unknown>>;
+    getUserProfile(userId: string): Promise<Record<string, unknown>>;
+    updateUserProfile(userId: string, firstName: string, lastName: string): Promise<Record<string, unknown>>;
+    listProjects(): Promise<Record<string, unknown>>;
+    getProject(projectId: string): Promise<Record<string, unknown>>;
+    createApiKey(projectId: string, name: string, description: string): Promise<Record<string, unknown>>;
+    deleteApiKey(projectId: string, id: string): Promise<void>;
+    listApiKeys(projectId: string): Promise<Record<string, unknown>>;
+    getPricing(): Promise<Record<string, unknown>>;
+    getStatus(projectId: string): Promise<boolean>;
+    getBalance(projectId: string): Promise<Balance>;
+    getRecentTransactions(projectId: string): Promise<Transaction[]>;
+    setAutoRecharge({ projectId, enabled, amount, threshold }: {
+        projectId: string;
+        enabled: boolean;
+        amount: number;
+        threshold: number;
+    }): Promise<void>;
+    getCheckoutUrl(projectId: string, { successUrl, cancelUrl }: {
+        successUrl: string;
+        cancelUrl: string;
+    }): Promise<string>;
+    getCreditsCheckoutUrl(projectId: string, { successUrl, cancelUrl, quantity }: {
+        successUrl: string;
+        cancelUrl: string;
+        quantity: number;
+    }): Promise<string>;
+    getSubscription(projectId: string): Promise<Record<string, unknown>>;
+    getUsage(projectId: string, options?: {
+        start?: Date;
+        end?: Date;
+        interval?: string;
+        report?: string;
+    }): Promise<Record<string, unknown>[]>;
+    getSession(projectId: string, sessionId: string): Promise<Record<string, unknown>>;
+    listActiveSessions(projectId: string): Promise<RoomSession[]>;
+    listRecentSessions(projectId: string): Promise<RoomSession[]>;
+    listSessionEvents(projectId: string, sessionId: string): Promise<Record<string, unknown>[]>;
+    terminateSession(projectId: string, sessionId: string): Promise<void>;
+    listSessionSpans(projectId: string, sessionId: string): Promise<Record<string, unknown>[]>;
+    listSessionMetrics(projectId: string, sessionId: string): Promise<Record<string, unknown>[]>;
+    createWebhook(projectId: string, params: {
+        name: string;
+        url: string;
+        events: string[];
+        description?: string;
+        action?: string;
+        payload?: Record<string, unknown> | null;
+    }): Promise<Record<string, unknown>>;
+    updateWebhook(projectId: string, webhookId: string, params: {
+        name: string;
+        url: string;
+        events: string[];
+        description?: string;
+        action?: string | null;
+        payload?: Record<string, unknown> | null;
+    }): Promise<Record<string, unknown>>;
+    listWebhooks(projectId: string): Promise<Record<string, unknown>>;
+    deleteWebhook(projectId: string, webhookId: string): Promise<void>;
+    createMailbox(params: {
+        projectId: string;
+        address: string;
+        room: string;
+        queue: string;
+    }): Promise<void>;
+    updateMailbox(params: {
+        projectId: string;
+        address: string;
+        room: string;
+        queue: string;
+    }): Promise<void>;
+    listMailboxes(projectId: string): Promise<Mailbox[]>;
+    deleteMailbox(projectId: string, address: string): Promise<void>;
+    createService(projectId: string, service: ServiceSpec): Promise<string>;
+    createRoomService(projectId: string, roomName: string, service: ServiceSpec): Promise<string>;
+    updateRoomService(projectId: string, roomName: string, serviceId: string, service: ServiceSpec): Promise<void>;
+    getRoomService(projectId: string, roomName: string, serviceId: string): Promise<ServiceSpec>;
+    listRoomServices(projectId: string, roomName: string): Promise<ServiceSpec[]>;
+    deleteRoomService(projectId: string, roomName: string, serviceId: string): Promise<void>;
+    updateService(projectId: string, serviceId: string, service: ServiceSpec): Promise<void>;
+    getService(projectId: string, serviceId: string): Promise<ServiceSpec>;
+    listServices(projectId: string): Promise<ServiceSpec[]>;
+    deleteService(projectId: string, serviceId: 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[]>;
+    createRoom(params: {
+        projectId: string;
+        name: string;
+        ifNotExists?: boolean;
+        metadata?: Record<string, unknown>;
+        permissions?: Record<string, ApiScope>;
+    }): Promise<RoomInfo>;
+    getRoom(projectId: string, name: string): Promise<RoomInfo>;
+    updateRoom(projectId: string, roomId: string, name: string): Promise<void>;
+    deleteRoom(projectId: string, roomId: string): Promise<void>;
+    connectRoom(projectId: string, room: string): Promise<RoomConnectionInfo>;
+    createRoomGrant(params: {
+        projectId: string;
+        roomId: string;
+        userId: string;
+        permissions: ApiScope;
+    }): Promise<void>;
+    createRoomGrantByEmail(params: {
+        projectId: string;
+        roomId: string;
+        email: string;
+        permissions: ApiScope;
+    }): Promise<void>;
+    updateRoomGrant(params: {
+        projectId: string;
+        roomId: string;
+        userId: string;
+        permissions: ApiScope;
+        grantId?: string;
+    }): Promise<void>;
+    deleteRoomGrant(projectId: string, roomId: string, userId: string): Promise<void>;
+    getRoomGrant(projectId: string, roomId: string, userId: string): Promise<ProjectRoomGrant>;
+    listRooms(projectId: string, options?: {
+        limit?: number;
+        offset?: number;
+        orderBy?: string;
+    }): Promise<RoomInfo[]>;
+    listRoomGrants(projectId: string, options?: {
+        limit?: number;
+        offset?: number;
+        orderBy?: string;
+    }): Promise<ProjectRoomGrant[]>;
+    listRoomGrantsByUser(projectId: string, userId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<ProjectRoomGrant[]>;
+    listRoomGrantsByRoom(projectId: string, roomId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<ProjectRoomGrant[]>;
+    listUniqueRoomsWithGrants(projectId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<ProjectRoomGrantCount[]>;
+    listUniqueUsersWithGrants(projectId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<ProjectUserGrantCount[]>;
+    createOAuthClient(projectId: string, params: {
+        grantTypes: string[];
+        responseTypes: string[];
+        redirectUris: string[];
+        scope: string;
+        metadata?: Record<string, any>;
+    }): Promise<OAuthClient>;
+    updateOAuthClient(projectId: string, clientId: string, params: {
+        grantTypes?: string[];
+        responseTypes?: string[];
+        redirectUris?: string[];
+        scope?: string;
+        metadata?: Record<string, any>;
+    }): Promise<Record<string, unknown>>;
+    listOAuthClients(projectId: string): Promise<OAuthClient[]>;
+    getOAuthClient(projectId: string, clientId: string): Promise<OAuthClient>;
+    deleteOAuthClient(projectId: string, clientId: string): Promise<void>;
+}