@fluxrtc/sdk 1.0.0

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@fluxrtc/sdk",
+  "version": "1.0.0",
+  "description": "FluxRTC Video SDK — add real-time video and audio to any web app",
+  "main": "src/index.js",
+  "files": [
+    "src/"
+  ],
+  "scripts": {
+    "test": "node -e \"const s = require('./src/index.js'); console.log('SDK exports:', Object.keys(s));\""
+  },
+  "keywords": [
+    "webrtc",
+    "video",
+    "audio",
+    "mediasoup",
+    "real-time",
+    "conferencing",
+    "fluxrtc"
+  ],
+  "author": "FluxRTC",
+  "license": "MIT",
+  "peerDependencies": {
+    "mediasoup-client": "^3.18.7",
+    "socket.io-client": "^4.8.3"
+  }
+}

package/src/VideoClient.js

@@ -0,0 +1,304 @@
+const { io } = require('socket.io-client');
+const { Device } = require('mediasoup-client');
+
+class VideoClient {
+  constructor(signalingUrl) {
+    if (!signalingUrl) {
+      throw new Error('signalingUrl is required — pass your FluxRTC server URL');
+    }
+    this.signalingUrl = signalingUrl;
+    this.socket = null;
+    this.device = null;
+    this.sendTransport = null;
+    this.recvTransport = null;
+    this.producers = new Map();
+    this.consumers = new Map();
+    this.localStream = null;
+    this.iceServers = [];
+    this.roomId = null;
+    this.token = null;
+    this._listeners = {};
+  }
+
+  on(event, fn) {
+    if (!this._listeners[event]) this._listeners[event] = [];
+    this._listeners[event].push(fn);
+  }
+
+  off(event, fn) {
+    if (!this._listeners[event]) return;
+    if (fn) {
+      this._listeners[event] = this._listeners[event].filter(f => f !== fn);
+    } else {
+      delete this._listeners[event];
+    }
+  }
+
+  _emit(event, ...args) {
+    (this._listeners[event] || []).forEach(fn => fn(...args));
+  }
+
+  connect(token) {
+    this.token = token;
+    return new Promise((resolve, reject) => {
+      this.socket = io(this.signalingUrl, {
+        transports: ['websocket'],
+        auth: { token },
+      });
+
+      this.socket.on('connect', () => {
+        this._emit('connected', { socketId: this.socket.id });
+        resolve();
+      });
+
+      this.socket.on('connect_error', (err) => {
+        this._emit('error', { type: 'connect', message: err.message });
+        reject(err);
+      });
+
+      this.socket.on('new-peer', (data) => {
+        this._emit('peerJoined', data);
+      });
+
+      this.socket.on('peer-left', (data) => {
+        this._emit('peerLeft', data);
+      });
+
+      this.socket.on('new-producer', (data) => {
+        this._emit('newProducer', data);
+      });
+
+      this.socket.on('disconnect', (reason) => {
+        this._emit('disconnected', { reason });
+      });
+    });
+  }
+
+  async fetchIceServers() {
+    return new Promise((resolve) => {
+      this.socket.emit('get-ice-servers', {}, (servers) => {
+        if (servers && servers.length) {
+          this.iceServers = servers;
+        } else {
+          this.iceServers = [{ urls: 'stun:stun.l.google.com:19302' }];
+        }
+        resolve(this.iceServers);
+      });
+    });
+  }
+
+  async joinRoom(roomId, token) {
+    this.roomId = roomId;
+    if (token) this.token = token;
+
+    return new Promise(async (resolve, reject) => {
+      try {
+        await this.fetchIceServers();
+
+        this.socket.emit('join-room', { roomId, token: this.token }, async (response) => {
+          try {
+            if (response.error) throw new Error(response.error);
+
+            this.device = new Device();
+            await this.device.load({ routerRtpCapabilities: response.rtpCapabilities });
+
+            await this._createSendTransport();
+            await this._createRecvTransport();
+
+            resolve({
+              peers: response.peers || [],
+              rtpCapabilities: response.rtpCapabilities,
+            });
+          } catch (err) {
+            reject(err);
+          }
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  async _createSendTransport() {
+    return new Promise((resolve, reject) => {
+      this.socket.emit('create-transport', { direction: 'send' }, (data) => {
+        if (data.error) return reject(new Error(data.error));
+
+        this.sendTransport = this.device.createSendTransport({
+          ...data,
+          iceServers: this.iceServers,
+        });
+
+        this.sendTransport.on('connect', ({ dtlsParameters }, callback, errback) => {
+          this.socket.emit('connect-transport', {
+            transportId: this.sendTransport.id,
+            dtlsParameters,
+          }, (res) => {
+            if (res.error) errback(new Error(res.error));
+            else callback();
+          });
+        });
+
+        this.sendTransport.on('produce', ({ kind, rtpParameters }, callback, errback) => {
+          this.socket.emit('produce', {
+            transportId: this.sendTransport.id,
+            kind,
+            rtpParameters,
+          }, (res) => {
+            if (res.error) errback(new Error(res.error));
+            else callback({ id: res.producerId });
+          });
+        });
+
+        resolve();
+      });
+    });
+  }
+
+  async _createRecvTransport() {
+    return new Promise((resolve, reject) => {
+      this.socket.emit('create-transport', { direction: 'recv' }, (data) => {
+        if (data.error) return reject(new Error(data.error));
+
+        this.recvTransport = this.device.createRecvTransport({
+          ...data,
+          iceServers: this.iceServers,
+        });
+
+        this.recvTransport.on('connect', ({ dtlsParameters }, callback, errback) => {
+          this.socket.emit('connect-transport', {
+            transportId: this.recvTransport.id,
+            dtlsParameters,
+          }, (res) => {
+            if (res.error) errback(new Error(res.error));
+            else callback();
+          });
+        });
+
+        resolve();
+      });
+    });
+  }
+
+  async enableMedia(constraints = { video: true, audio: true }) {
+    if (this.localStream) return this.localStream;
+
+    try {
+      this.localStream = await navigator.mediaDevices.getUserMedia(constraints);
+      return this.localStream;
+    } catch (err) {
+      if (constraints.video && (err.name === 'NotReadableError' || err.name === 'NotFoundError')) {
+        this.localStream = await navigator.mediaDevices.getUserMedia({ video: false, audio: true });
+        return this.localStream;
+      }
+      throw err;
+    }
+  }
+
+  async produce() {
+    if (!this.localStream || !this.sendTransport) {
+      throw new Error('Call enableMedia() and joinRoom() before produce()');
+    }
+
+    const producers = [];
+    for (const track of this.localStream.getTracks()) {
+      const producer = await this.sendTransport.produce({ track });
+      this.producers.set(producer.id, producer);
+      producers.push({ id: producer.id, kind: track.kind });
+    }
+    return producers;
+  }
+
+  async consume(producerId) {
+    return new Promise((resolve, reject) => {
+      this.socket.emit('consume', {
+        producerId,
+        rtpCapabilities: this.device.rtpCapabilities,
+      }, async (data) => {
+        try {
+          if (data.error) throw new Error(data.error);
+
+          const consumer = await this.recvTransport.consume({
+            id: data.consumerId,
+            producerId: data.producerId,
+            kind: data.kind,
+            rtpParameters: data.rtpParameters,
+          });
+
+          this.consumers.set(consumer.id, consumer);
+          resolve({ consumer, track: consumer.track, kind: data.kind });
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+  }
+
+  async consumeAll() {
+    return new Promise((resolve) => {
+      this.socket.emit('get-producers', {}, async (producers) => {
+        const results = [];
+        for (const p of producers) {
+          try {
+            const result = await this.consume(p.producerId);
+            results.push({ ...result, peerId: p.peerId, displayName: p.displayName });
+          } catch (_) {
+            // skip failed consumers
+          }
+        }
+        resolve(results);
+      });
+    });
+  }
+
+  async toggleVideo() {
+    if (!this.localStream) return false;
+    const videoTrack = this.localStream.getVideoTracks()[0];
+    if (videoTrack) {
+      videoTrack.enabled = !videoTrack.enabled;
+      return videoTrack.enabled;
+    }
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ video: true });
+      const newTrack = stream.getVideoTracks()[0];
+      this.localStream.addTrack(newTrack);
+      if (this.sendTransport) {
+        await this.sendTransport.produce({ track: newTrack });
+      }
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+
+  toggleAudio() {
+    if (!this.localStream) return false;
+    const audioTrack = this.localStream.getAudioTracks()[0];
+    if (audioTrack) {
+      audioTrack.enabled = !audioTrack.enabled;
+      return audioTrack.enabled;
+    }
+    return false;
+  }
+
+  disconnect() {
+    this.producers.forEach(p => p.close());
+    this.consumers.forEach(c => c.close());
+    if (this.sendTransport) this.sendTransport.close();
+    if (this.recvTransport) this.recvTransport.close();
+    if (this.localStream) {
+      this.localStream.getTracks().forEach(t => t.stop());
+    }
+    if (this.socket) this.socket.disconnect();
+    this.localStream = null;
+    this.sendTransport = null;
+    this.recvTransport = null;
+    this.producers.clear();
+    this.consumers.clear();
+    this.token = null;
+    this.roomId = null;
+    this._emit('disconnected', { reason: 'manual' });
+  }
+}
+
+module.exports = { VideoClient };

package/src/index.js

@@ -0,0 +1,4 @@
+const { VideoClient } = require('./VideoClient');
+const { generateMeetingId } = require('./utils');
+
+module.exports = { VideoClient, generateMeetingId };

package/src/utils.js

@@ -0,0 +1,7 @@
+function generateMeetingId() {
+  const chars = 'abcdefghijklmnopqrstuvwxyz';
+  const seg = (len) => Array.from({ length: len }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
+  return seg(3) + '-' + seg(4) + '-' + seg(3);
+}
+
+module.exports = { generateMeetingId };