@maravilla-labs/platform 0.1.26 → 0.1.28

package/dist/index.js

@@ -1,3 +1,55 @@
+// src/media.ts
+var RemoteMediaService = class {
+  constructor(baseUrl, headers) {
+    this.baseUrl = baseUrl;
+    this.headers = headers;
+  }
+  baseUrl;
+  headers;
+  async fetch(url, options = {}) {
+    const response = await fetch(url, {
+      ...options,
+      headers: { ...this.headers, ...options.headers }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Media API error: ${response.status} - ${error}`);
+    }
+    return response;
+  }
+  async createRoom(roomId, settings = {}) {
+    const response = await this.fetch(`${this.baseUrl}/api/media/rooms`, {
+      method: "POST",
+      body: JSON.stringify({ roomId, settings })
+    });
+    return response.json();
+  }
+  async deleteRoom(roomId) {
+    await this.fetch(`${this.baseUrl}/api/media/rooms/${encodeURIComponent(roomId)}`, {
+      method: "DELETE"
+    });
+  }
+  async listRooms() {
+    const response = await this.fetch(`${this.baseUrl}/api/media/rooms`);
+    return response.json();
+  }
+  async generateToken(roomId, participant) {
+    const response = await this.fetch(
+      `${this.baseUrl}/api/media/rooms/${encodeURIComponent(roomId)}/token`,
+      {
+        method: "POST",
+        body: JSON.stringify(participant)
+      }
+    );
+    return response.json();
+  }
+  async mediaUrl() {
+    const response = await this.fetch(`${this.baseUrl}/api/media/url`);
+    const data = await response.json();
+    return data.url;
+  }
+};
+
 // src/remote-client.ts
 var RemoteKvNamespace = class {
   constructor(baseUrl, namespace, headers) {
@@ -5,6 +57,9 @@ var RemoteKvNamespace = class {
     this.namespace = namespace;
     this.headers = headers;
   }
+  baseUrl;
+  namespace;
+  headers;
   /**
    * Internal method for making HTTP requests to the dev server.
    * Handles error responses and authentication headers.
@@ -61,6 +116,8 @@ var RemoteDatabase = class {
     this.baseUrl = baseUrl;
     this.headers = headers;
   }
+  baseUrl;
+  headers;
   /**
    * Internal method for making HTTP requests to the dev server.
    * Handles error responses and authentication headers.
@@ -124,6 +181,8 @@ var RemoteStorage = class _RemoteStorage {
     this.baseUrl = baseUrl;
     this.headers = headers;
   }
+  baseUrl;
+  headers;
   /**
    * Internal method for making HTTP requests to the dev server.
    * Handles error responses and authentication headers.
@@ -276,12 +335,14 @@ function createRemoteClient(baseUrl, tenant) {
   });
   const db = new RemoteDatabase(baseUrl, headers);
   const storage = new RemoteStorage(baseUrl, headers);
+  const media = new RemoteMediaService(baseUrl, headers);
   return {
     env: {
       KV: kvProxy,
       DB: db,
       STORAGE: storage
-    }
+    },
+    media
   };
 }
 
@@ -373,6 +434,12 @@ var RenClient = class {
       "runtime.snapshot.ready",
       "runtime.worker.started",
       "runtime.worker.stopped",
+      // Realtime channel events
+      "realtime.message",
+      // Presence events
+      "presence.join",
+      "presence.leave",
+      "presence.update",
       // Meta events
       "ren.meta"
     ];
@@ -450,6 +517,467 @@ async function storageDelete(path, clientId) {
   return res.json().catch(() => ({}));
 }
 
+// src/realtime.ts
+var RealtimeClient = class {
+  wsEndpoint;
+  clientId;
+  ws = null;
+  closed = false;
+  attempt = 0;
+  autoReconnect;
+  maxBackoff;
+  debug;
+  channelListeners = /* @__PURE__ */ new Map();
+  globalListeners = /* @__PURE__ */ new Set();
+  presenceListeners = /* @__PURE__ */ new Map();
+  subscribedChannels = /* @__PURE__ */ new Set();
+  pendingMessages = [];
+  constructor(opts = {}) {
+    this.wsEndpoint = opts.wsEndpoint || this.detectEndpoint();
+    this.clientId = opts.clientId || getOrCreateClientId();
+    this.autoReconnect = opts.autoReconnect !== false;
+    this.maxBackoff = opts.maxBackoffMs ?? 15e3;
+    this.debug = !!opts.debug;
+  }
+  detectEndpoint() {
+    if (typeof window !== "undefined") {
+      const proto = window.location.protocol === "https:" ? "wss:" : "ws:";
+      if (window.location.port === "5173") {
+        return `ws://${window.location.hostname}:3001/_rt/ws`;
+      }
+      return `${proto}//${window.location.host}/_rt/ws`;
+    }
+    return "ws://localhost:3001/_rt/ws";
+  }
+  log(...args) {
+    if (this.debug) console.debug("[RealtimeClient]", ...args);
+  }
+  /** Connect to the realtime WebSocket server */
+  connect() {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) return;
+    const url = `${this.wsEndpoint}?cid=${encodeURIComponent(this.clientId)}`;
+    this.log("connecting", url);
+    this.closed = false;
+    try {
+      this.ws = new WebSocket(url);
+    } catch (e) {
+      this.log("WebSocket constructor failed", e);
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws.onopen = () => {
+      this.attempt = 0;
+      this.log("connected");
+      for (const ch of this.subscribedChannels) {
+        this.sendRaw({ action: "subscribe", channel: ch });
+      }
+      for (const msg of this.pendingMessages) {
+        this.ws?.send(msg);
+      }
+      this.pendingMessages = [];
+    };
+    this.ws.onmessage = (ev) => {
+      try {
+        const event = JSON.parse(ev.data);
+        this.log("received", event);
+        this.dispatch(event);
+      } catch (e) {
+        this.log("malformed message", ev.data, e);
+      }
+    };
+    this.ws.onerror = (ev) => {
+      this.log("error", ev);
+    };
+    this.ws.onclose = () => {
+      this.log("disconnected");
+      this.ws = null;
+      if (!this.closed && this.autoReconnect) {
+        this.scheduleReconnect();
+      }
+    };
+  }
+  scheduleReconnect() {
+    const delay = Math.min(1e3 * Math.pow(2, this.attempt++), this.maxBackoff);
+    this.log("reconnecting in", delay, "ms");
+    setTimeout(() => this.connect(), delay);
+  }
+  sendRaw(msg) {
+    const json = JSON.stringify(msg);
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(json);
+    } else {
+      this.pendingMessages.push(json);
+    }
+  }
+  dispatch(event) {
+    this.globalListeners.forEach((cb) => cb(event));
+    if (event.channel) {
+      const listeners = this.channelListeners.get(event.channel);
+      if (listeners) {
+        listeners.forEach((cb) => cb(event));
+      }
+    }
+    if (event.event === "presence:join" || event.event === "presence:leave") {
+      const presenceSet = this.presenceListeners.get(event.channel);
+      if (presenceSet) {
+        const member = {
+          userId: event.userId || "",
+          metadata: event.metadata,
+          lastSeen: event.ts
+        };
+        if (event.event === "presence:join") {
+          presenceSet.onJoin.forEach((cb) => cb(member));
+        } else {
+          presenceSet.onLeave.forEach((cb) => cb(member));
+        }
+      }
+    }
+  }
+  /** Subscribe to messages on a channel */
+  subscribe(channel, callback, options) {
+    if (!this.channelListeners.has(channel)) {
+      this.channelListeners.set(channel, /* @__PURE__ */ new Set());
+    }
+    this.channelListeners.get(channel).add(callback);
+    if (!this.subscribedChannels.has(channel)) {
+      this.subscribedChannels.add(channel);
+      const msg = { action: "subscribe", channel };
+      if (options?.token) {
+        msg.token = options.token;
+      }
+      this.sendRaw(msg);
+    }
+    return () => {
+      const listeners = this.channelListeners.get(channel);
+      if (listeners) {
+        listeners.delete(callback);
+        if (listeners.size === 0) {
+          this.channelListeners.delete(channel);
+          this.subscribedChannels.delete(channel);
+          this.sendRaw({ action: "unsubscribe", channel });
+        }
+      }
+    };
+  }
+  /** Listen to all events across all channels */
+  onAny(callback) {
+    this.globalListeners.add(callback);
+    return () => {
+      this.globalListeners.delete(callback);
+    };
+  }
+  /** Publish a message to a channel */
+  publish(channel, data, options) {
+    this.sendRaw({
+      action: "publish",
+      channel,
+      data,
+      userId: options?.userId
+    });
+  }
+  /** Get a presence handle for a channel */
+  presence(channel) {
+    if (!this.presenceListeners.has(channel)) {
+      this.presenceListeners.set(channel, {
+        onJoin: /* @__PURE__ */ new Set(),
+        onLeave: /* @__PURE__ */ new Set()
+      });
+    }
+    const listeners = this.presenceListeners.get(channel);
+    return {
+      /** Join the channel with presence */
+      join: (userId, metadata) => {
+        this.sendRaw({
+          action: "presence:join",
+          channel,
+          userId,
+          metadata
+        });
+      },
+      /** Leave the channel */
+      leave: () => {
+        this.sendRaw({ action: "presence:leave", channel });
+      },
+      /** Listen for users joining */
+      onJoin: (callback) => {
+        listeners.onJoin.add(callback);
+        return () => {
+          listeners.onJoin.delete(callback);
+        };
+      },
+      /** Listen for users leaving */
+      onLeave: (callback) => {
+        listeners.onLeave.add(callback);
+        return () => {
+          listeners.onLeave.delete(callback);
+        };
+      }
+    };
+  }
+  /** Get current client ID */
+  getClientId() {
+    return this.clientId;
+  }
+  /** Check if connected */
+  isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  /** Disconnect and stop reconnecting */
+  disconnect() {
+    this.closed = true;
+    this.ws?.close();
+    this.ws = null;
+    this.pendingMessages = [];
+    this.log("disconnected (manual)");
+  }
+};
+
+// src/media-room.ts
+import {
+  Room,
+  RoomEvent,
+  Track,
+  ConnectionState
+} from "livekit-client";
+var MediaRoomEvent = /* @__PURE__ */ ((MediaRoomEvent2) => {
+  MediaRoomEvent2["Connected"] = "connected";
+  MediaRoomEvent2["Reconnecting"] = "reconnecting";
+  MediaRoomEvent2["Reconnected"] = "reconnected";
+  MediaRoomEvent2["Disconnected"] = "disconnected";
+  MediaRoomEvent2["ParticipantJoined"] = "participantJoined";
+  MediaRoomEvent2["ParticipantLeft"] = "participantLeft";
+  MediaRoomEvent2["TrackSubscribed"] = "trackSubscribed";
+  MediaRoomEvent2["TrackUnsubscribed"] = "trackUnsubscribed";
+  MediaRoomEvent2["TrackMuted"] = "trackMuted";
+  MediaRoomEvent2["TrackUnmuted"] = "trackUnmuted";
+  MediaRoomEvent2["ActiveSpeakersChanged"] = "activeSpeakersChanged";
+  MediaRoomEvent2["DataReceived"] = "dataReceived";
+  MediaRoomEvent2["RecordingStatusChanged"] = "recordingStatusChanged";
+  MediaRoomEvent2["MediaDevicesChanged"] = "mediaDevicesChanged";
+  return MediaRoomEvent2;
+})(MediaRoomEvent || {});
+function mapSource(source) {
+  switch (source) {
+    case Track.Source.Camera:
+      return "camera";
+    case Track.Source.Microphone:
+      return "microphone";
+    case Track.Source.ScreenShare:
+      return "screen_share";
+    case Track.Source.ScreenShareAudio:
+      return "screen_share_audio";
+    default:
+      return "camera";
+  }
+}
+function mapParticipant(p) {
+  const tracks = [];
+  p.trackPublications.forEach((pub) => {
+    tracks.push({
+      trackSid: pub.trackSid,
+      source: mapSource(pub.source),
+      kind: pub.kind === Track.Kind.Video ? "video" : "audio",
+      muted: pub.isMuted,
+      track: pub.track?.mediaStreamTrack
+    });
+  });
+  return {
+    identity: p.identity,
+    name: p.name,
+    metadata: p.metadata,
+    isSpeaking: p.isSpeaking,
+    audioLevel: p.audioLevel,
+    tracks
+  };
+}
+function attachTrack(track, element) {
+  const stream = new MediaStream([track]);
+  element.srcObject = stream;
+  if (element instanceof HTMLVideoElement) {
+    element.playsInline = true;
+  }
+  element.play().catch(() => {
+  });
+}
+function detachTrack(element) {
+  element.srcObject = null;
+}
+var MediaLocalParticipant = class {
+  lp;
+  /** @internal */
+  constructor(lp) {
+    this.lp = lp;
+  }
+  get identity() {
+    return this.lp.identity;
+  }
+  get name() {
+    return this.lp.name;
+  }
+  get metadata() {
+    return this.lp.metadata;
+  }
+  get isSpeaking() {
+    return this.lp.isSpeaking;
+  }
+  get audioLevel() {
+    return this.lp.audioLevel;
+  }
+  get tracks() {
+    return mapParticipant(this.lp).tracks;
+  }
+  // Camera
+  get isCameraEnabled() {
+    return !!this.lp.getTrackPublication(Track.Source.Camera)?.track && !this.lp.getTrackPublication(Track.Source.Camera)?.isMuted;
+  }
+  async enableCamera(options) {
+    await this.lp.setCameraEnabled(true, {
+      deviceId: options?.deviceId,
+      resolution: options?.resolution ? { width: options.resolution.width, height: options.resolution.height, frameRate: options.resolution.frameRate } : void 0
+    });
+  }
+  async disableCamera() {
+    await this.lp.setCameraEnabled(false);
+  }
+  // Microphone
+  get isMicrophoneEnabled() {
+    return !!this.lp.getTrackPublication(Track.Source.Microphone)?.track && !this.lp.getTrackPublication(Track.Source.Microphone)?.isMuted;
+  }
+  async enableMicrophone(options) {
+    await this.lp.setMicrophoneEnabled(true, { deviceId: options?.deviceId });
+  }
+  async disableMicrophone() {
+    await this.lp.setMicrophoneEnabled(false);
+  }
+  // Screen share
+  get isScreenShareEnabled() {
+    return !!this.lp.getTrackPublication(Track.Source.ScreenShare)?.track;
+  }
+  async enableScreenShare(options) {
+    await this.lp.setScreenShareEnabled(true, { audio: options?.audio });
+  }
+  async disableScreenShare() {
+    await this.lp.setScreenShareEnabled(false);
+  }
+  // Metadata
+  async setName(name) {
+    await this.lp.setName(name);
+  }
+  async setMetadata(metadata) {
+    await this.lp.setMetadata(metadata);
+  }
+  // Data
+  async sendData(data, options) {
+    await this.lp.publishData(data, { reliable: options?.reliable ?? true });
+  }
+};
+var MediaRoom = class _MediaRoom {
+  room;
+  listeners = /* @__PURE__ */ new Map();
+  _localParticipant;
+  constructor() {
+    this.room = new Room();
+  }
+  async connect(url, token, options) {
+    const opts = {};
+    if (options?.autoSubscribe !== void 0) opts.autoSubscribe = options.autoSubscribe;
+    this.room.options.adaptiveStream = options?.adaptiveStream ?? true;
+    this.room.options.dynacast = options?.dynacast ?? true;
+    this.wireEvents();
+    await this.room.connect(url, token, opts);
+    this._localParticipant = new MediaLocalParticipant(this.room.localParticipant);
+  }
+  async disconnect() {
+    await this.room.disconnect();
+  }
+  get state() {
+    switch (this.room.state) {
+      case ConnectionState.Connected:
+        return "connected";
+      case ConnectionState.Connecting:
+        return "connecting";
+      case ConnectionState.Reconnecting:
+        return "reconnecting";
+      default:
+        return "disconnected";
+    }
+  }
+  get localParticipant() {
+    return this._localParticipant;
+  }
+  get participants() {
+    const map = /* @__PURE__ */ new Map();
+    this.room.remoteParticipants.forEach((p, id) => map.set(id, mapParticipant(p)));
+    return map;
+  }
+  get activeSpeakers() {
+    return this.room.activeSpeakers.map(mapParticipant);
+  }
+  get name() {
+    return this.room.name;
+  }
+  get numParticipants() {
+    return this.room.numParticipants;
+  }
+  get isRecording() {
+    return this.room.isRecording;
+  }
+  // Events
+  on(event, callback) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(callback);
+    return this;
+  }
+  off(event, callback) {
+    this.listeners.get(event)?.delete(callback);
+    return this;
+  }
+  emit(event, ...args) {
+    this.listeners.get(event)?.forEach((cb) => cb(...args));
+  }
+  // Device switching
+  async switchCamera(deviceId) {
+    await this.room.switchActiveDevice("videoinput", deviceId);
+  }
+  async switchMicrophone(deviceId) {
+    await this.room.switchActiveDevice("audioinput", deviceId);
+  }
+  async switchSpeaker(deviceId) {
+    await this.room.switchActiveDevice("audiooutput", deviceId);
+  }
+  // Static device enumeration
+  static async getDevices() {
+    return navigator.mediaDevices.enumerateDevices();
+  }
+  static async getCameras() {
+    return (await _MediaRoom.getDevices()).filter((d) => d.kind === "videoinput");
+  }
+  static async getMicrophones() {
+    return (await _MediaRoom.getDevices()).filter((d) => d.kind === "audioinput");
+  }
+  static async getSpeakers() {
+    return (await _MediaRoom.getDevices()).filter((d) => d.kind === "audiooutput");
+  }
+  // ─── Event wiring (LiveKit → MediaRoom) ───
+  wireEvents() {
+    const r = this.room;
+    r.on(RoomEvent.Connected, () => this.emit("connected" /* Connected */));
+    r.on(RoomEvent.Reconnecting, () => this.emit("reconnecting" /* Reconnecting */));
+    r.on(RoomEvent.Reconnected, () => this.emit("reconnected" /* Reconnected */));
+    r.on(RoomEvent.Disconnected, (reason) => this.emit("disconnected" /* Disconnected */, reason));
+    r.on(RoomEvent.MediaDevicesChanged, () => this.emit("mediaDevicesChanged" /* MediaDevicesChanged */));
+    r.on(RoomEvent.RecordingStatusChanged, (recording) => this.emit("recordingStatusChanged" /* RecordingStatusChanged */, recording));
+    r.on(RoomEvent.ParticipantConnected, (p) => this.emit("participantJoined" /* ParticipantJoined */, mapParticipant(p)));
+    r.on(RoomEvent.ParticipantDisconnected, (p) => this.emit("participantLeft" /* ParticipantLeft */, mapParticipant(p)));
+    r.on(RoomEvent.TrackSubscribed, (track, pub, p) => this.emit("trackSubscribed" /* TrackSubscribed */, track.mediaStreamTrack, mapParticipant(p)));
+    r.on(RoomEvent.TrackUnsubscribed, (track, pub, p) => this.emit("trackUnsubscribed" /* TrackUnsubscribed */, track.mediaStreamTrack, mapParticipant(p)));
+    r.on(RoomEvent.TrackMuted, (pub, p) => this.emit("trackMuted" /* TrackMuted */, mapParticipant(p)));
+    r.on(RoomEvent.TrackUnmuted, (pub, p) => this.emit("trackUnmuted" /* TrackUnmuted */, mapParticipant(p)));
+    r.on(RoomEvent.ActiveSpeakersChanged, (speakers) => this.emit("activeSpeakersChanged" /* ActiveSpeakersChanged */, speakers.map(mapParticipant)));
+    r.on(RoomEvent.DataReceived, (data, p) => this.emit("dataReceived" /* DataReceived */, data, p ? mapParticipant(p) : void 0));
+  }
+};
+
 // src/index.ts
 var cachedPlatform = null;
 function getPlatform(options) {
@@ -484,8 +1012,15 @@ function clearPlatformCache() {
   }
 }
 export {
+  MediaLocalParticipant,
+  MediaRoom,
+  MediaRoomEvent,
+  RealtimeClient,
+  RemoteMediaService,
   RenClient,
+  attachTrack,
   clearPlatformCache,
+  detachTrack,
   getOrCreateClientId,
   getPlatform,
   renFetch,