@encarnage7/local-meet 0.0.0-stage → 1.0.1

package/package.json

@@ -1,6 +1,46 @@
 {
   "name": "@encarnage7/local-meet",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "Zero-trust WebRTC P2P Mesh & Cloudflare Calls SFU client library with E2EE and resilient HTTPS signaling.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "browser": "./dist/local-meet.min.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node build.js",
+    "prepublishOnly": "node build.js"
+  },
+  "keywords": [
+    "webrtc",
+    "video-call",
+    "cloudflare-calls",
+    "p2p",
+    "mesh",
+    "e2ee",
+    "audio-call",
+    "screensharing",
+    "sdk"
+  ],
+  "author": "Local Meet Contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gambaru/local-meet.git"
+  }
+}

package/src/crypto.js

@@ -0,0 +1,92 @@
+/**
+ * Cifrado de paquetes de datos de sala con AES-GCM-256 usando Web Crypto API.
+ */
+
+const PBKDF2_ITERATIONS = 100000;
+const cachedAesKeys = new Map();
+
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+
+function base64ToBytes(base64) {
+  const binary = atob(base64);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    out[i] = binary.charCodeAt(i);
+  }
+  return out;
+}
+
+export async function deriveRoomAesKey(roomHash, extraSecret = "") {
+  const cleanHash = (roomHash || "").toLowerCase().trim();
+  const cacheKey = `${cleanHash}::${extraSecret}`;
+  if (cachedAesKeys.has(cacheKey)) {
+    return cachedAesKeys.get(cacheKey);
+  }
+
+  const salt = new TextEncoder().encode(`local-meet-salt-v1:${cleanHash}`);
+  const keyMaterial = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(`${cleanHash}:${extraSecret}`),
+    "PBKDF2",
+    false,
+    ["deriveKey"]
+  );
+
+  const aesKey = await crypto.subtle.deriveKey(
+    {
+      name: "PBKDF2",
+      salt,
+      iterations: PBKDF2_ITERATIONS,
+      hash: "SHA-256",
+    },
+    keyMaterial,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+
+  cachedAesKeys.set(cacheKey, aesKey);
+  return aesKey;
+}
+
+export async function encryptDataPacket(roomHash, plaintext, extraSecret = "") {
+  const aesKey = await deriveRoomAesKey(roomHash, extraSecret);
+  const iv = new Uint8Array(12);
+  crypto.getRandomValues(iv);
+  const encoded = new TextEncoder().encode(plaintext);
+  const ciphertext = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    aesKey,
+    encoded
+  );
+  return {
+    e2ee: "aes-gcm-256",
+    iv: bytesToBase64(iv),
+    ct: bytesToBase64(new Uint8Array(ciphertext)),
+  };
+}
+
+export async function decryptDataPacket(roomHash, packet, extraSecret = "") {
+  if (!packet || packet.e2ee !== "aes-gcm-256" || !packet.iv || !packet.ct) {
+    return null;
+  }
+  try {
+    const aesKey = await deriveRoomAesKey(roomHash, extraSecret);
+    const iv = base64ToBytes(packet.iv);
+    const ct = base64ToBytes(packet.ct);
+    const decryptedBuffer = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv },
+      aesKey,
+      ct
+    );
+    return new TextDecoder().decode(decryptedBuffer);
+  } catch {
+    return null;
+  }
+}

package/src/events.js

@@ -0,0 +1,38 @@
+/**
+ * Eventos emitidos por LocalMeetRoom
+ */
+export const RoomEvents = Object.freeze({
+  ParticipantConnected: "participantConnected",
+  ParticipantDisconnected: "participantDisconnected",
+  ParticipantMetadataChanged: "participantMetadataChanged",
+  ParticipantPermissionsChanged: "participantPermissionsChanged",
+  DataReceived: "dataReceived",
+  TrackSubscribed: "trackSubscribed",
+  TrackUnsubscribed: "trackUnsubscribed",
+  TrackUnpublished: "trackUnpublished",
+  LocalTrackPublished: "localTrackPublished",
+  LocalTrackUnpublished: "localTrackUnpublished",
+  TrackMuted: "trackMuted",
+  TrackUnmuted: "trackUnmuted",
+  ActiveSpeakersChanged: "activeSpeakersChanged",
+  Disconnected: "disconnected",
+  Error: "error",
+});
+
+export const TrackSources = Object.freeze({
+  Camera: "camera",
+  Microphone: "microphone",
+  ScreenShare: "screen_share",
+  ScreenShareAudio: "screen_share_audio",
+});
+
+export const TrackKinds = Object.freeze({
+  Audio: "audio",
+  Video: "video",
+});
+
+export const EngineModes = Object.freeze({
+  CloudflareCalls: "cf-calls",
+  P2PMesh: "p2p",
+  LiveKit: "livekit",
+});

package/src/index.js

@@ -0,0 +1,150 @@
+import {
+  LocalMeetRoom,
+  HybridTrack,
+  HybridPublication,
+  HybridParticipant,
+} from "./room.js";
+import { RoomEvents, TrackSources, TrackKinds, EngineModes } from "./events.js";
+import { encryptDataPacket, decryptDataPacket } from "./crypto.js";
+
+/**
+ * Cliente principal estilo Axios para inicializar llamadas con 1 sola línea de código.
+ */
+export const LocalMeet = {
+  RoomEvents,
+  TrackSources,
+  TrackKinds,
+  EngineModes,
+  LocalMeetRoom,
+  HybridTrack,
+  HybridPublication,
+  HybridParticipant,
+
+  /**
+   * Crea una sala nueva como anfitrión en el backend y devuelve una instancia lista de LocalMeetRoom.
+   *
+   * @param {Object} options
+   * @param {string} options.serverUrl - URL del Worker o servidor de señalización (ej: "https://mi-meet.workers.dev")
+   * @param {string} [options.hostName="Anfitrión"] - Nombre a mostrar del anfitrión
+   * @param {string} [options.title=""] - Título de la reunión
+   * @param {string} [options.engine="cf-calls"] - "cf-calls" | "p2p" | "livekit"
+   * @param {string} [options.accessKey=""] - Clave HOST_ACCESS_KEY si el servidor la requiere
+   * @param {string} [options.customHash=""] - Hash de sala a reutilizar si ya eres el anfitrión
+   * @param {string} [options.hostSecret=""] - Secreto de anfitrión previo
+   * @returns {Promise<LocalMeetRoom>}
+   */
+  async createRoom(options = {}) {
+    const {
+      serverUrl = typeof window !== "undefined" ? window.location.origin : "",
+      hostName = "Anfitrión",
+      title = "",
+      engine = EngineModes.CloudflareCalls,
+      accessKey = "",
+      customHash = "",
+      hostSecret = "",
+      debug = false,
+    } = options;
+
+    const cleanServer = (serverUrl || "").replace(/\/+$/, "");
+    const res = await fetch(`${cleanServer}/api/host-join`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        host_name: hostName,
+        title,
+        engine,
+        access_key: accessKey,
+        room_hash: customHash,
+        host_secret: hostSecret,
+      }),
+    });
+
+    const data = await res.json();
+    if (!res.ok) {
+      throw new Error(data?.detail || `Error al crear sala (${res.status})`);
+    }
+
+    const room = new LocalMeetRoom({
+      serverUrl: cleanServer,
+      roomHash: data.room_hash,
+      title: data.title || title,
+      identity: data.identity,
+      displayName: data.host_name || hostName,
+      isHost: true,
+      hostSecret: data.host_secret,
+      engine: data.engine || engine,
+      cfCallsReady: Boolean(data.cf_calls_ready),
+      iceServers: data.ice_servers,
+      startInWaitingRoom: false,
+      debug,
+    });
+
+    return room;
+  },
+
+  /**
+   * Se une a una sala existente como invitado.
+   *
+   * @param {Object} options
+   * @param {string} options.serverUrl - URL del Worker o servidor
+   * @param {string} options.roomHash - Hash de la sala (ej: "c4f2-9k81-m3n2")
+   * @param {string} [options.guestName="Invitado"] - Nombre del participante
+   * @returns {Promise<LocalMeetRoom>}
+   */
+  async join(options = {}) {
+    const {
+      serverUrl = typeof window !== "undefined" ? window.location.origin : "",
+      roomHash = "",
+      guestName = "Invitado",
+      debug = false,
+    } = options;
+
+    const cleanServer = (serverUrl || "").replace(/\/+$/, "");
+    const cleanHash = (roomHash || "").toLowerCase().trim();
+
+    const res = await fetch(`${cleanServer}/api/guest-join`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        room_hash: cleanHash,
+        guest_name: guestName,
+      }),
+    });
+
+    const data = await res.json();
+    if (!res.ok) {
+      throw new Error(data?.detail || `Error al unirse a sala (${res.status})`);
+    }
+
+    const room = new LocalMeetRoom({
+      serverUrl: cleanServer,
+      roomHash: data.room_hash,
+      title: `Sala ${data.room_hash}`,
+      identity: data.identity,
+      displayName: data.guest_name || guestName,
+      isHost: false,
+      engine: data.engine || EngineModes.CloudflareCalls,
+      cfCallsReady: Boolean(data.cf_calls_ready),
+      iceServers: data.ice_servers,
+      startInWaitingRoom: true,
+      debug,
+    });
+
+    return room;
+  },
+};
+
+export {
+  LocalMeetRoom,
+  HybridTrack,
+  HybridPublication,
+  HybridParticipant,
+  RoomEvents,
+  TrackSources,
+  TrackKinds,
+  EngineModes,
+  encryptDataPacket,
+  decryptDataPacket,
+};
+
+export default LocalMeet;