@simplito/privmx-webendpoint 2.6.5 → 2.7.1

package/{service → dist/service}/ThreadApi.js

@@ -123,12 +123,7 @@ class ThreadApi extends BaseApi_1.BaseApi {
      * @returns {string} ID of the new message
      */
     async sendMessage(threadId, publicMeta, privateMeta, data) {
-        return this.native.sendMessage(this.servicePtr, [
-            threadId,
-            publicMeta,
-            privateMeta,
-            data,
-        ]);
+        return this.native.sendMessage(this.servicePtr, [threadId, publicMeta, privateMeta, data]);
     }
     /**
      * Deletes a message by given message ID.
@@ -205,7 +200,11 @@ class ThreadApi extends BaseApi_1.BaseApi {
      * @param {string} selectorId ID of the selector
      */
     async buildSubscriptionQuery(eventType, selectorType, selectorId) {
-        return this.native.buildSubscriptionQuery(this.servicePtr, [eventType, selectorType, selectorId]);
+        return this.native.buildSubscriptionQuery(this.servicePtr, [
+            eventType,
+            selectorType,
+            selectorId,
+        ]);
     }
 }
 exports.ThreadApi = ThreadApi;

package/{service → dist/service}/UserVerifierInterface.d.ts

@@ -5,7 +5,7 @@ import { VerificationRequest } from "../Types";
  *
  * @type {UserVerifierInterface}
  *
-*/
+ */
 export interface UserVerifierInterface {
     /**
      * Verifies whether the specified users are valid.
@@ -13,6 +13,6 @@ export interface UserVerifierInterface {
      *
      * @param request List of user data to verification
      * @returns List of verification results whose items correspond to the items in the input list
-    */
+     */
     verify(request: VerificationRequest[]): Promise<boolean[]>;
 }

package/dist/service/UserVerifierInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/service/WebRtcInterface.d.ts

@@ -0,0 +1,58 @@
+import { Key } from "../Types";
+import { ConnectionType } from "../webStreams/PeerConnectionsManager";
+import { StreamRoomId } from "../webStreams/types/ApiTypes";
+export declare class UpdateKeysModel {
+    streamRoomId: StreamRoomId;
+    keys: Key[];
+}
+export interface Jsep {
+    sdp: string;
+    type: string;
+}
+export interface SdpWithRoomModel extends Jsep {
+    roomId: StreamRoomId;
+}
+export interface RoomModel {
+    roomId: StreamRoomId;
+}
+export type CreateAnswerAndSetDescriptionsModel = SdpWithRoomModel;
+export type SetAnswerAndSetRemoteDescriptionModel = SdpWithRoomModel;
+export interface StreamsUpdatedData {
+    videoroom: "updated";
+    room: StreamRoomId;
+    streams: UpdatedStreamData[];
+    jsep?: Jsep;
+}
+export interface UpdatedStreamData {
+    type: "audio" | "video" | "data";
+    streamId: number;
+    streamMid: number;
+    stream_display: string;
+    mindex: number;
+    mid: string;
+    send: boolean;
+    ready: boolean;
+}
+export interface CurrentPublishersData {
+    room: StreamRoomId;
+    publishers: NewPublisherEvent[];
+}
+export interface NewPublisherEvent {
+    id: number;
+    video_codec: string;
+    streams: VideoRoomStreamTrack[];
+}
+export interface VideoRoomStreamTrack {
+    type: string;
+    codec: string;
+    mid: string;
+    mindex: number;
+}
+export interface WebRtcInterface {
+    createOfferAndSetLocalDescription(model: RoomModel): Promise<string>;
+    createAnswerAndSetDescriptions(model: CreateAnswerAndSetDescriptionsModel): Promise<string>;
+    setAnswerAndSetRemoteDescription(model: SetAnswerAndSetRemoteDescriptionModel): Promise<void>;
+    updateSessionId(roomId: StreamRoomId, sessionId: number, connectionType: ConnectionType): Promise<void>;
+    close(roomId: StreamRoomId): Promise<void>;
+    updateKeys(model: UpdateKeysModel): Promise<void>;
+}

package/dist/service/WebRtcInterface.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateKeysModel = void 0;
+class UpdateKeysModel {
+    streamRoomId;
+    keys;
+}
+exports.UpdateKeysModel = UpdateKeysModel;

package/{service → dist/service}/index.d.ts

@@ -3,10 +3,11 @@ import { ThreadApi } from "./ThreadApi";
 import { StoreApi } from "./StoreApi";
 import { InboxApi } from "./InboxApi";
 import { KvdbApi } from "./KvdbApi";
+import { EventApi } from "./EventApi";
 import { CryptoApi } from "./CryptoApi";
+import { StreamApi } from "./StreamApi";
 import { Connection } from "./Connection";
 import { EventQueue } from "./EventQueue";
 import { BaseApi } from "./BaseApi";
 import { ExtKey } from "./ExtKey";
-import { EventApi } from "./EventApi";
-export { EndpointFactory, ThreadApi, StoreApi, InboxApi, KvdbApi, CryptoApi, Connection, EventQueue, BaseApi, ExtKey, EventApi };
+export { EndpointFactory, ThreadApi, StoreApi, InboxApi, KvdbApi, CryptoApi, StreamApi, Connection, EventQueue, BaseApi, ExtKey, EventApi, };

package/{service → dist/service}/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventApi = exports.ExtKey = exports.BaseApi = exports.EventQueue = exports.Connection = exports.CryptoApi = exports.KvdbApi = exports.InboxApi = exports.StoreApi = exports.ThreadApi = exports.EndpointFactory = void 0;
+exports.EventApi = exports.ExtKey = exports.BaseApi = exports.EventQueue = exports.Connection = exports.StreamApi = exports.CryptoApi = exports.KvdbApi = exports.InboxApi = exports.StoreApi = exports.ThreadApi = exports.EndpointFactory = void 0;
 const EndpointFactory_1 = require("./EndpointFactory");
 Object.defineProperty(exports, "EndpointFactory", { enumerable: true, get: function () { return EndpointFactory_1.EndpointFactory; } });
 const ThreadApi_1 = require("./ThreadApi");
@@ -11,8 +11,12 @@ const InboxApi_1 = require("./InboxApi");
 Object.defineProperty(exports, "InboxApi", { enumerable: true, get: function () { return InboxApi_1.InboxApi; } });
 const KvdbApi_1 = require("./KvdbApi");
 Object.defineProperty(exports, "KvdbApi", { enumerable: true, get: function () { return KvdbApi_1.KvdbApi; } });
+const EventApi_1 = require("./EventApi");
+Object.defineProperty(exports, "EventApi", { enumerable: true, get: function () { return EventApi_1.EventApi; } });
 const CryptoApi_1 = require("./CryptoApi");
 Object.defineProperty(exports, "CryptoApi", { enumerable: true, get: function () { return CryptoApi_1.CryptoApi; } });
+const StreamApi_1 = require("./StreamApi");
+Object.defineProperty(exports, "StreamApi", { enumerable: true, get: function () { return StreamApi_1.StreamApi; } });
 const Connection_1 = require("./Connection");
 Object.defineProperty(exports, "Connection", { enumerable: true, get: function () { return Connection_1.Connection; } });
 const EventQueue_1 = require("./EventQueue");
@@ -21,5 +25,3 @@ const BaseApi_1 = require("./BaseApi");
 Object.defineProperty(exports, "BaseApi", { enumerable: true, get: function () { return BaseApi_1.BaseApi; } });
 const ExtKey_1 = require("./ExtKey");
 Object.defineProperty(exports, "ExtKey", { enumerable: true, get: function () { return ExtKey_1.ExtKey; } });
-const EventApi_1 = require("./EventApi");
-Object.defineProperty(exports, "EventApi", { enumerable: true, get: function () { return EventApi_1.EventApi; } });

package/dist/webStreams/CryptoUtils.d.ts

@@ -0,0 +1,24 @@
+type BufferLike = ArrayBuffer | Uint8Array;
+interface EncryptionResult {
+    success: true;
+    data: Uint8Array;
+}
+interface EncryptionError {
+    success: false;
+    error: string;
+}
+type EncryptionResponse = EncryptionResult | EncryptionError;
+interface DecryptionResult {
+    success: true;
+    data: Uint8Array;
+}
+interface DecryptionError {
+    success: false;
+    error: string;
+}
+type DecryptionResponse = DecryptionResult | DecryptionError;
+declare function encryptWithAES256GCM(key: BufferLike, iv: BufferLike, data: BufferLike, header: BufferLike): Promise<EncryptionResponse>;
+declare function decryptWithAES256GCM(key: BufferLike, iv: BufferLike, encryptedData: BufferLike, header: BufferLike): Promise<DecryptionResponse>;
+declare function isEncryptionSuccess(result: EncryptionResponse): result is EncryptionResult;
+declare function isDecryptionSuccess(result: DecryptionResponse): result is DecryptionResult;
+export { encryptWithAES256GCM, decryptWithAES256GCM, isEncryptionSuccess, isDecryptionSuccess, type EncryptionResponse, type DecryptionResponse, type BufferLike, };

package/dist/webStreams/CryptoUtils.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encryptWithAES256GCM = encryptWithAES256GCM;
+exports.decryptWithAES256GCM = decryptWithAES256GCM;
+exports.isEncryptionSuccess = isEncryptionSuccess;
+exports.isDecryptionSuccess = isDecryptionSuccess;
+async function encryptWithAES256GCM(key, iv, data, header) {
+    try {
+        // Import the key for AES-GCM
+        const cryptoKey = await crypto.subtle.importKey("raw", key, { name: "AES-GCM" }, false, ["encrypt"]);
+        // Encrypt the data
+        const encrypted = await crypto.subtle.encrypt({
+            name: "AES-GCM",
+            iv: iv,
+            additionalData: header,
+            tagLength: 128, // 16 bytes * 8 = 128 bits (TAG_LEN equivalent)
+        }, cryptoKey, data);
+        // The encrypted result contains both ciphertext and authentication tag
+        return {
+            success: true,
+            data: new Uint8Array(encrypted),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: "EncryptionFailed",
+        };
+    }
+}
+async function decryptWithAES256GCM(key, iv, encryptedData, header) {
+    try {
+        const cryptoKey = await crypto.subtle.importKey("raw", key, { name: "AES-GCM" }, false, ["decrypt"]);
+        const decrypted = await crypto.subtle.decrypt({
+            name: "AES-GCM",
+            iv: iv,
+            additionalData: header,
+            tagLength: 128,
+        }, cryptoKey, encryptedData);
+        return {
+            success: true,
+            data: new Uint8Array(decrypted),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: "DecryptionFailed",
+        };
+    }
+}
+// Type guard functions for better type safety
+function isEncryptionSuccess(result) {
+    return result.success;
+}
+function isDecryptionSuccess(result) {
+    return result.success;
+}

package/dist/webStreams/KeyStore.d.ts

@@ -0,0 +1,9 @@
+import { Key } from "../Types";
+export declare class KeyStore {
+    private _keys;
+    private _encryptionKeyId;
+    setKeys(keys: Key[]): void;
+    getKey(keyId: string): Key;
+    hasKey(keyId: string): boolean;
+    getEncriptionKey(): Key;
+}

package/dist/webStreams/KeyStore.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyStore = void 0;
+class KeyStore {
+    _keys = new Map();
+    _encryptionKeyId = undefined;
+    setKeys(keys) {
+        this._keys.clear();
+        for (const k of keys) {
+            this._keys.set(k.keyId, k);
+            if (k.type === 0) {
+                this._encryptionKeyId = k.keyId;
+            }
+        }
+    }
+    getKey(keyId) {
+        return this._keys.get(keyId);
+    }
+    hasKey(keyId) {
+        return this._keys.has(keyId);
+    }
+    getEncriptionKey() {
+        if (!this._encryptionKeyId) {
+            throw new Error("No encryption key set.");
+        }
+        return this._keys.get(this._encryptionKeyId);
+    }
+}
+exports.KeyStore = KeyStore;

package/dist/webStreams/Logger.d.ts

@@ -0,0 +1,7 @@
+export type LoggerLevel = "debug" | "info" | "important-only";
+export declare class Logger {
+    private static instance;
+    private static logLevel;
+    static get(): Logger;
+    log(level: LoggerLevel, ...args: any[]): void;
+}

package/dist/webStreams/Logger.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+class Logger {
+    static instance;
+    static logLevel = "important-only";
+    static get() {
+        if (!this.instance) {
+            this.instance = new Logger();
+        }
+        return this.instance;
+    }
+    log(level, ...args) {
+        if (Logger.logLevel === "debug") {
+            console.log(...args);
+        }
+        else if (level === "info" && Logger.logLevel === "info") {
+            console.log(...args);
+        }
+        else if (level === "important-only" && Logger.logLevel === "important-only") {
+            console.log(...args);
+        }
+    }
+}
+exports.Logger = Logger;

package/dist/webStreams/PeerConnectionsManager.d.ts

@@ -0,0 +1,20 @@
+import { StreamRoomId } from "./types/ApiTypes";
+import { SessionId } from "./WebRtcClientTypes";
+export type ConnectionType = "publisher" | "subscriber";
+export interface JanusConnection {
+    pc: RTCPeerConnection;
+    sessionId: SessionId;
+    hasSubscriptions: boolean;
+    candidateQueue: RTCIceCandidate[];
+}
+export declare class PeerConnectionManager {
+    private createPeerConnection;
+    private onTrickle;
+    private connections;
+    constructor(createPeerConnection: (room: StreamRoomId) => RTCPeerConnection, onTrickle: (sessionId: SessionId, candidate: RTCIceCandidate) => void);
+    initialize(room: StreamRoomId, connectionType: ConnectionType, sessionId?: SessionId): void;
+    updateSessionForConnection(room: StreamRoomId, connectionType: ConnectionType, session: SessionId): void;
+    hasConnection(room: StreamRoomId, connectionType: ConnectionType): boolean;
+    getConnectionWithSession(room: StreamRoomId, connectionType: ConnectionType): JanusConnection;
+    closePeerConnectionBySessionIfExists(room: StreamRoomId, connectionType: ConnectionType): void;
+}

package/dist/webStreams/PeerConnectionsManager.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeerConnectionManager = void 0;
+class PeerConnectionManager {
+    createPeerConnection;
+    onTrickle;
+    connections = {};
+    constructor(createPeerConnection, onTrickle) {
+        this.createPeerConnection = createPeerConnection;
+        this.onTrickle = onTrickle;
+    }
+    initialize(room, connectionType, sessionId = -1) {
+        // Prevent re-initialization if it already exists
+        if (room in this.connections &&
+            connectionType in this.connections[room] &&
+            this.connections[room][connectionType]?.pc) {
+            return;
+        }
+        if (!(room in this.connections)) {
+            this.connections[room] = {};
+        }
+        // Create the RTCPeerConnection
+        const pc = this.createPeerConnection(room);
+        // Prepare the connection object immediately so we can access the queue in the listener
+        const newConnection = {
+            sessionId: sessionId,
+            hasSubscriptions: false,
+            pc,
+            candidateQueue: [],
+        };
+        // Assign immediately so the listener has access to the reference
+        this.connections[room][connectionType] = newConnection;
+        pc.addEventListener("icecandidate", (event) => {
+            if (!event.candidate) {
+                return;
+            }
+            const conn = this.connections[room][connectionType];
+            if (!conn)
+                return;
+            const currentSessionId = conn.sessionId;
+            if (currentSessionId && currentSessionId > -1) {
+                try {
+                    this.onTrickle(currentSessionId, event.candidate);
+                }
+                catch (err) {
+                    console.warn("Failed to trickle candidate", err);
+                }
+            }
+            else {
+                conn.candidateQueue.push(event.candidate);
+            }
+        });
+    }
+    updateSessionForConnection(room, connectionType, session) {
+        if (!(room in this.connections) || !(connectionType in this.connections[room])) {
+            this.initialize(room, connectionType);
+        }
+        const conn = this.connections[room][connectionType];
+        conn.sessionId = session;
+        if (conn.candidateQueue.length > 0) {
+            conn.candidateQueue.forEach((candidate) => {
+                try {
+                    this.onTrickle(session, candidate);
+                }
+                catch (err) {
+                    console.warn("Failed to trickle buffered candidate", err);
+                }
+            });
+            conn.candidateQueue = [];
+        }
+    }
+    hasConnection(room, connectionType) {
+        return !!(this.connections[room] && this.connections[room][connectionType]);
+    }
+    getConnectionWithSession(room, connectionType) {
+        if (!this.hasConnection(room, connectionType)) {
+            this.initialize(room, connectionType);
+        }
+        return this.connections[room][connectionType];
+    }
+    closePeerConnectionBySessionIfExists(room, connectionType) {
+        if (this.hasConnection(room, connectionType)) {
+            const conn = this.connections[room][connectionType];
+            if (conn?.pc) {
+                conn.pc.close();
+            }
+            // Optional: Clean up the reference to allow garbage collection
+            delete this.connections[room][connectionType];
+        }
+    }
+}
+exports.PeerConnectionManager = PeerConnectionManager;

package/dist/webStreams/Queue.d.ts

@@ -0,0 +1,19 @@
+export interface QueueTask<T> {
+    func(item: T): Promise<void>;
+}
+export declare class Queue<T> implements Iterable<T> {
+    private items;
+    private func;
+    private processing;
+    enqueue(item: T): void;
+    dequeue(): T | undefined;
+    peek(): T | undefined;
+    get size(): number;
+    isEmpty(): boolean;
+    clear(): void;
+    toArray(): T[];
+    assignProcessorFunc(func: (item: T) => Promise<void>): void;
+    processAll(): Promise<void>;
+    awaiter(): Promise<void>;
+    [Symbol.iterator](): Iterator<T>;
+}

package/dist/webStreams/Queue.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+class Queue {
+    items = [];
+    func;
+    processing = false;
+    enqueue(item) {
+        this.items.push(item);
+    }
+    dequeue() {
+        return this.items.shift();
+    }
+    peek() {
+        return this.items[0];
+    }
+    get size() {
+        return this.items.length;
+    }
+    isEmpty() {
+        return this.items.length === 0;
+    }
+    clear() {
+        this.items.length = 0;
+    }
+    toArray() {
+        return this.items.slice();
+    }
+    assignProcessorFunc(func) {
+        this.func = func;
+    }
+    async processAll() {
+        if (this.processing) {
+            return;
+        }
+        if (!this.func) {
+            throw new Error("No task processor function assigned");
+        }
+        this.processing = true;
+        while (this.items.length > 0) {
+            const item = this.items.shift();
+            if (!item)
+                continue;
+            const randId = Math.random();
+            try {
+                await this.func(item);
+                await this.awaiter();
+            }
+            catch (err) {
+                console.error("Error while processing queue item", randId, err);
+            }
+        }
+        this.processing = false;
+    }
+    async awaiter() {
+        return new Promise((resolve) => setTimeout(() => resolve(), 5000));
+    }
+    [Symbol.iterator]() {
+        let idx = 0;
+        const arr = this.items;
+        return {
+            next() {
+                if (idx < arr.length)
+                    return { value: arr[idx++], done: false };
+                return { value: undefined, done: true };
+            },
+        };
+    }
+}
+exports.Queue = Queue;

package/dist/webStreams/Utils.d.ts

@@ -0,0 +1,20 @@
+export declare class Utils {
+    static generateNumericId(): number;
+    static getRandomString(size: number): string;
+    static encryptSymmetric(plaintext: Uint8Array | string, key: string, iv: string): Promise<{
+        ciphertext: Buffer;
+        iv: string;
+    }>;
+    static decryptSymmetricBuffer(ciphertext: Buffer, iv: Buffer, key: Buffer): Promise<Buffer<ArrayBuffer>>;
+    static decryptSymmetric(ciphertext: string, iv: string, key: string): Promise<string>;
+    static genKey(): string;
+    static genIv(): string;
+    static genIvAsBuffer(): Uint8Array<ArrayBuffer>;
+    static base64abc: string[];
+    static base64codes: number[];
+    static bytesToBase64(bytes: Uint8Array): string;
+    static isBitOn(byte: number, index: number): boolean;
+    static getBits(data: Uint8Array, bitOffset: number, numBits: number): number;
+    static numAsOneByteUint(num: number): Uint8Array<ArrayBuffer>;
+    static oneByteUint8AsNum(arr: Uint8Array): number;
+}