@simplito/privmx-webendpoint 2.6.5 → 2.7.1

package/dist/webStreams/types/MediaServerWebSocketApiTypes.d.ts

@@ -0,0 +1,255 @@
+export type SessionId = string & {
+    _sessionId: never;
+};
+export type TransactionId = string & {
+    _transactionId: never;
+};
+export type PluginHandleId = number & {
+    _pluginHandleId: never;
+};
+export type PluginId = string & {
+    _pluginId: never;
+};
+export type UserToken = string & {
+    _userToken: never;
+};
+export type VideoRoomRequestStatus = string & {
+    _videoRoomStatus: never;
+};
+export type VideoRoomId = number & {
+    _videoRoomId: never;
+};
+export type VideoRoomParticipantId = number & {
+    _videoRoomParticipantId: never;
+};
+export type VideoRoomPublisherId = number & {
+    _videoRoomPublisherId: never;
+};
+export interface JanusSession {
+    id: SessionId;
+}
+export interface JanusStreamInfo {
+    type: "audio" | "video" | "data";
+    active: boolean;
+    mid: string;
+    mindex: number;
+    ready: boolean;
+    send: boolean;
+    source_ids: VideoRoomParticipantId[];
+    sources: number;
+}
+export interface JanusPluginHandle {
+    id: PluginHandleId;
+    pluginId: PluginId;
+}
+export interface VideoRoom {
+    room: VideoRoomId;
+    description: string;
+    pin_required: boolean;
+    is_private: boolean;
+    max_publishers: number;
+    bitrate: number;
+    bitrate_cap: number;
+    fir_freq: number;
+    require_pvtid: boolean;
+    require_e2ee: boolean;
+    dummy_publisher: boolean;
+    notify_joining: boolean;
+    audiocodec: string;
+    videocodec: string;
+    opus_fec: boolean;
+    opus_dtx: boolean;
+    record: boolean;
+    rec_dir: string;
+    lock_record: boolean;
+    num_participants: number;
+    audiolevel_ext: boolean;
+    audiolevel_event: boolean;
+    audio_active_packets: number;
+    audio_level_average: number;
+    videoorient_ext: boolean;
+    playoutdelay_ext: boolean;
+    transport_wide_cc_ext: boolean;
+}
+export interface PublisherInfo {
+    id: string;
+    display: string;
+    dummy: boolean;
+    streams: StreamInfo[];
+    talking: boolean;
+}
+export interface StreamInfo {
+    type: string;
+    mindex: string;
+    mid: string;
+    disabled: boolean;
+    codec: string;
+    description: string;
+    moderated: boolean;
+    simulcast: boolean;
+    svc: boolean;
+    talking: boolean;
+}
+export interface VideoRoomParticipant {
+    id: VideoRoomParticipantId;
+    display: string;
+    publisher: boolean;
+    talking: boolean;
+}
+export interface CreateRoomOptions {
+    room?: string;
+    permanent?: boolean;
+    description?: string;
+    secret?: string;
+    pin?: string;
+    is_private?: boolean;
+    allowed?: UserToken[];
+    publishers?: number;
+}
+export interface CreateRoomResult {
+    videoroom: "created";
+    room: VideoRoomId;
+    permanent: boolean;
+}
+export interface EditRoomOptions {
+    room: VideoRoomId;
+    new_description?: string;
+}
+export interface EditRoomResult {
+    videoroom: "edited";
+    room: VideoRoomId;
+    permanent: boolean;
+}
+export interface DestroyRoomOptions {
+    room: VideoRoomId;
+    secret?: string;
+    permanent?: boolean;
+}
+export interface DestroyRoomResult {
+    videoroom: "destroyed";
+    room: VideoRoomId;
+    permanent: boolean;
+}
+export interface RoomExistsOptions {
+    room: VideoRoomId;
+}
+export interface RoomExistsResult {
+    room: VideoRoomId;
+    exists: boolean;
+}
+export interface SetRoomRestrictedAccessOptions {
+    secret?: string;
+    action: "enable" | "disable";
+    room: VideoRoomId;
+}
+export interface SetRoomAccessAllowedOptions {
+    secret?: string;
+    action: "add" | "remove";
+    room: VideoRoomId;
+    allowed: string[];
+}
+export interface RoomAccessResult {
+    room: VideoRoomId;
+    allowed?: string[];
+}
+export interface RoomKickOptions {
+    secret?: string;
+    room: VideoRoomId;
+    id: VideoRoomParticipantId;
+}
+export interface RoomModerateOptions {
+    secret?: string;
+    room: VideoRoomId;
+    id: VideoRoomParticipantId;
+    mid: string;
+    mute: boolean;
+}
+export interface RoomListParticipantsOptions {
+    room: VideoRoomId;
+}
+export interface RoomListResult {
+    list: VideoRoom[];
+}
+export interface RoomListParticipantsResult {
+    room: VideoRoomId;
+    participants: VideoRoomParticipant[];
+}
+export interface RoomJoinAsPublisherOptions {
+    room: VideoRoomId;
+    id?: VideoRoomParticipantId;
+    display?: string;
+    token?: string;
+}
+export interface RoomJoinAsSubscriberOptions {
+    room: VideoRoomId;
+    use_msid?: boolean;
+    autoupdate?: boolean;
+    private_id?: string;
+    streams: RoomJoinStreamOptions[];
+    data: boolean;
+}
+export interface RoomJoinStreamOptions {
+    feed: number;
+    mid?: string;
+    crossrefid?: string;
+}
+export interface VideoRoomDescription {
+    mid: string;
+    description?: string;
+}
+export interface RoomPublishOptions {
+    videocodec?: string;
+    bitrate?: number;
+    record?: boolean;
+    filename?: string;
+    display?: string;
+    audio_level_average?: number;
+    audio_active_packets?: any;
+    descriptions?: VideoRoomDescription[];
+    e2ee?: boolean;
+    data: boolean;
+}
+export interface VideoRoomStreamTrack {
+    type: string;
+    codec: string;
+    mid: string;
+    mindex: number;
+}
+export interface NewPublisherEvent {
+    id: VideoRoomPublisherId;
+    video_codec: string;
+    streams: VideoRoomStreamTrack[];
+}
+export interface JoinedEvent {
+    room: VideoRoomId;
+    description: string;
+    id: number;
+    private_id: number;
+    publishers: NewPublisherEvent[];
+}
+export type MediaServerSignallingEvent = WebRTCMediaEvent | WebRTCSHangupEvent | WebRTCSlowLinkEvent | WebRTCUpEvent;
+export interface WebRTCUpEvent {
+    eventType: "webrtcup";
+    session_id: string;
+    sender: string;
+}
+export interface WebRTCMediaEvent {
+    eventType: "media";
+    session_id: string;
+    sender: string;
+    type: "audio" | "video" | "data";
+    receiving: boolean;
+}
+export interface WebRTCSlowLinkEvent {
+    eventType: "slowlink";
+    session_id: string;
+    sender: string;
+    uplink: boolean;
+    nacks: number;
+}
+export interface WebRTCSHangupEvent {
+    eventType: "hangup";
+    session_id: string;
+    sender: string;
+    reason: string;
+}

package/dist/webStreams/types/MediaServerWebSocketApiTypes.js

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

package/dist/webStreams/types/SignalingReceiverTypes.d.ts

@@ -0,0 +1,13 @@
+import { AppRequest } from "./BaseServerTypes";
+import { JanusPluginHandle, SessionId } from "./MediaServerWebSocketApiTypes";
+export interface AcceptOfferRequest extends AppRequest {
+    kind: "signaling.acceptOffer";
+    data: {
+        session_id: SessionId;
+        handle: JanusPluginHandle;
+        answer: any;
+    };
+}
+export interface CreateSessionRequest extends AppRequest {
+    kind: "signaling.createSession";
+}

package/dist/webStreams/types/SignalingReceiverTypes.js

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

package/dist/webStreams/types/SignalingSenderTypes.d.ts

@@ -0,0 +1,24 @@
+import { JanusPluginHandle, JanusStreamInfo, SessionId } from "./MediaServerWebSocketApiTypes";
+export type SignalingSenderEventType = "subscriberAttached" | "streamConfigured";
+export interface BaseEvent {
+    kind: "media-event" | "event";
+    type: SignalingSenderEventType;
+}
+export interface MediaEvent extends BaseEvent {
+    sub?: string;
+    data?: any;
+}
+export interface SubscriberAttached {
+    session_id: SessionId;
+    handle: JanusPluginHandle;
+    room: any;
+    streams: JanusStreamInfo[];
+    offer: any;
+}
+export interface StreamConfigured {
+    answer: any;
+}
+export interface SignalingSenderInterface {
+    onSubscriberAttached(model: SubscriberAttached): void;
+    onStreamConfigured(model: StreamConfigured): void;
+}

package/dist/webStreams/types/SignalingSenderTypes.js

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

package/dist/webStreams/types/StreamsApiTypes.d.ts

@@ -0,0 +1,144 @@
+import { AppRequest } from "./BaseServerTypes";
+import * as Types from "./ApiTypes";
+export interface StreamRoomCreateRequest extends AppRequest {
+    kind: "streams.streamRoomCreate";
+    data: {
+        contextId: string;
+        users: Types.UserWithPubKey[];
+        managers: Types.UserWithPubKey[];
+        privateMeta: Uint8Array;
+        publicMeta: Uint8Array;
+    };
+}
+export interface StreamRoomUpdateRequest extends AppRequest {
+    kind: "streams.streamRoomUpdate";
+    data: {
+        streamRoomId: Types.StreamRoomId;
+        users: Types.UserWithPubKey[];
+        managers: Types.UserWithPubKey[];
+        privateMeta: string;
+        publicMeta: string;
+    };
+}
+export interface StreamRoomGetRequest extends AppRequest {
+    kind: "streams.streamRoomGet";
+    data: {
+        streamRoomId: Types.StreamRoomId;
+    };
+}
+export interface StreamRoomListRequest extends AppRequest {
+    kind: "streams.streamRoomList";
+    data: {
+        contextId: string;
+        query: Types.ListQuery;
+    };
+}
+export interface StreamRoomDeleteRequest extends AppRequest {
+    kind: "streams.streamRoomDelete";
+    data: {
+        streamRoomId: Types.StreamRoomId;
+    };
+}
+export interface StreamCreateRequest extends AppRequest {
+    kind: "streams.streamCreate";
+    data: {
+        streamRoomId: Types.StreamRoomId;
+        meta?: Types.StreamCreateMeta;
+    };
+}
+export interface StreamUpdateRequest extends AppRequest {
+    kind: "streams.streamUpdate";
+    data: {
+        streamId: Types.StreamId;
+        meta: Types.StreamCreateMeta;
+    };
+}
+export interface StreamListRequest extends AppRequest {
+    kind: "streams.streamList";
+    data: {
+        streamRoomId: Types.StreamRoomId;
+        query: Types.ListQuery;
+    };
+}
+export interface StreamGetRequest extends AppRequest {
+    kind: "streams.streamGet";
+    data: {
+        streamRoomId: Types.StreamRoomId;
+        streamId: Types.StreamId;
+    };
+}
+export interface StreamDeleteRequest extends AppRequest {
+    kind: "streams.streamDelete";
+    data: {
+        streamRoomId: Types.StreamRoomId;
+        streamId: Types.StreamId;
+    };
+}
+export interface StreamDataTrackAddRequest extends AppRequest {
+    kind: "streams.streamDataTrackAdd";
+    data: {
+        streamRoomId: Types.StreamRoomId;
+        streamTrackId: Types.StreamTrackId;
+        streamId: Types.StreamId;
+        meta: Types.DataChannelMeta;
+    };
+}
+export interface StreamTrackRemoveRequest extends AppRequest {
+    kind: "streams.streamTrackRemove";
+    data: {
+        streamId: Types.StreamId;
+        streamRoomId: Types.StreamRoomId;
+        streamTrackId: Types.StreamTrackId;
+    };
+}
+export interface StreamTrackListRequest extends AppRequest {
+    kind: "streams.streamTrackList";
+    data: {
+        streamId: Types.StreamId;
+        streamRoomId: Types.StreamRoomId;
+    };
+}
+export interface StreamTrackSendDataRequest extends AppRequest {
+    kind: "streams.streamTrackSendData";
+    data: {
+        streamTrackId: Types.StreamTrackId;
+        data: Buffer;
+    };
+}
+export interface StreamPublishRequest extends AppRequest {
+    kind: "streams.streamPublish";
+    data: {
+        streamRoomId: Types.StreamRoomId;
+        streamId: Types.StreamId;
+        streamMeta?: Types.StreamCreateMeta;
+        peerConnectionOffer: any;
+    };
+}
+export interface StreamUnpublishRequest extends AppRequest {
+    kind: "streams.streamUnpublish";
+    data: {
+        streamRoomId: Types.StreamRoomId;
+        streamId: Types.StreamId;
+    };
+}
+export interface StreamJoinRequest extends AppRequest {
+    kind: "streams.streamJoin";
+    data: {
+        streamRoomId: Types.StreamRoomId;
+        streamToJoin: Types.StreamAndTracksSelector;
+    };
+}
+export interface StreamLeaveRequest extends AppRequest {
+    kind: "streams.streamLeave";
+    data: {
+        streamToLeave: Types.StreamAndTracksSelector;
+    };
+}
+export interface StreamDataChannelSendRequest extends AppRequest {
+    kind: "streams.dataChannelSend";
+    data: {
+        streamRoomId: Types.StreamRoomId;
+        streamId: Types.StreamId;
+        data: string;
+    };
+}

package/dist/webStreams/types/StreamsApiTypes.js

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

package/dist/webStreams/worker/WorkerEvents.d.ts

@@ -0,0 +1,11 @@
+import { Key } from "../../Types";
+export interface WorkerBaseEvent {
+    operation: string;
+}
+export interface InitializeEvent extends WorkerBaseEvent {
+    operation: "initialize";
+}
+export interface SetKeysEvent extends WorkerBaseEvent {
+    operation: "setKeys";
+    keys: Key[];
+}

package/dist/webStreams/worker/WorkerEvents.js

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

package/dist/webStreams/worker/worker.d.ts

@@ -0,0 +1,13 @@
+import { KeyStore } from "../KeyStore";
+export interface TransformContext {
+    keyStore: KeyStore;
+    id?: string;
+    publisherId?: number;
+}
+export declare class EncryptTransform {
+    private keyStore;
+    constructor(keyStore: KeyStore);
+    private getHeaderSizeByType;
+    encryptFrame(encodedFrame: RTCEncodedAudioFrame | RTCEncodedVideoFrame, kind: string, controller: TransformStreamDefaultController<any>): Promise<void>;
+    decryptFrame(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, kind: string, controller: TransformStreamDefaultController<any>, receiverId?: string, publisherId?: number): Promise<void>;
+}

package/dist/webStreams/worker/worker.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptTransform = void 0;
+const Utils_1 = require("../Utils");
+const CryptoUtils_1 = require("../CryptoUtils");
+const KeyStore_1 = require("../KeyStore");
+const NUM_AS_UINT8_SIZE = 1;
+const DEBUG = false;
+const sessions = new Map();
+const pipelines = new Map();
+let lastRMS = -99;
+let recvRMS = -99;
+let recvRMSTimestamp = Date.now();
+class EncryptTransform {
+    keyStore;
+    constructor(keyStore) {
+        this.keyStore = keyStore;
+    }
+    getHeaderSizeByType(type) {
+        if (type === "key")
+            return 10;
+        if (type === "delta")
+            return 3;
+        if (type === "empty")
+            return 1;
+        return 0;
+    }
+    async encryptFrame(encodedFrame, kind, controller) {
+        const headerLen = kind === "video" ? this.getHeaderSizeByType(encodedFrame.type) : 1;
+        const frameHeader = new Uint8Array(encodedFrame.data, 0, headerLen);
+        const frameBody = new Uint8Array(encodedFrame.data, headerLen);
+        const iv = Utils_1.Utils.genIvAsBuffer();
+        const keyEntry = this.keyStore.getEncriptionKey();
+        const cryptoResult = await (0, CryptoUtils_1.encryptWithAES256GCM)(keyEntry.key, iv, frameBody, frameHeader);
+        if (!(0, CryptoUtils_1.isEncryptionSuccess)(cryptoResult)) {
+            throw new Error("Cannot encrypt frame");
+        }
+        const keyIdAsUint8 = new TextEncoder().encode(keyEntry.keyId);
+        const posOfCipher = frameHeader.byteLength;
+        const posOfIv = posOfCipher + cryptoResult.data.byteLength;
+        const posOfIvSize = posOfIv + iv.byteLength;
+        const posOfKeyId = posOfIvSize + NUM_AS_UINT8_SIZE;
+        const posOfKeyIdSize = posOfKeyId + keyIdAsUint8.byteLength;
+        const posOfRMS = posOfKeyIdSize + NUM_AS_UINT8_SIZE;
+        const result = new ArrayBuffer(posOfRMS + NUM_AS_UINT8_SIZE);
+        const resultUint8 = new Uint8Array(result);
+        resultUint8.set(frameHeader);
+        resultUint8.set(new Uint8Array(cryptoResult.data), posOfCipher);
+        resultUint8.set(iv, posOfIv);
+        resultUint8.set(Utils_1.Utils.numAsOneByteUint(iv.byteLength), posOfIvSize);
+        resultUint8.set(keyIdAsUint8, posOfKeyId);
+        resultUint8.set(Utils_1.Utils.numAsOneByteUint(keyIdAsUint8.byteLength), posOfKeyIdSize);
+        resultUint8.set(Utils_1.Utils.numAsOneByteUint(lastRMS + 100), posOfRMS);
+        encodedFrame.data = result;
+        controller.enqueue(encodedFrame);
+    }
+    async decryptFrame(encodedFrame, kind, controller, receiverId, publisherId) {
+        const headerLen = kind === "video"
+            ? this.getHeaderSizeByType(encodedFrame.type)
+            : 1;
+        const data = encodedFrame.data;
+        if (data.byteLength < headerLen + 5) {
+            // Sanity check for minimum metadata size
+            controller.enqueue(encodedFrame);
+            return;
+        }
+        const frameHeader = new Uint8Array(data, 0, headerLen);
+        const rmsPos = data.byteLength - 1;
+        recvRMS = new Uint8Array(data, rmsPos, 1)[0] - 100;
+        const currTime = Date.now();
+        if (recvRMSTimestamp + 100 < currTime) {
+            recvRMSTimestamp = currTime;
+            self.postMessage({ type: "rms", rms: recvRMS, receiverId, publisherId });
+        }
+        const keyIdLenPos = rmsPos - 1;
+        const keyIdLen = new Uint8Array(data, keyIdLenPos, 1)[0];
+        const keyIdPos = keyIdLenPos - keyIdLen;
+        const keyId = new TextDecoder().decode(new Uint8Array(data, keyIdPos, keyIdLen));
+        const ivLenPos = keyIdPos - 1;
+        const ivLen = new Uint8Array(data, ivLenPos, 1)[0];
+        const ivPos = ivLenPos - ivLen;
+        const iv = new Uint8Array(data, ivPos, ivLen);
+        const payloadPos = headerLen;
+        const payloadLen = ivPos - headerLen;
+        const payload = data.slice(payloadPos, payloadPos + payloadLen);
+        try {
+            if (!this.keyStore.hasKey(keyId)) {
+                controller.enqueue(encodedFrame);
+                return;
+            }
+            const keyEntry = this.keyStore.getKey(keyId);
+            const decryptionResult = await (0, CryptoUtils_1.decryptWithAES256GCM)(keyEntry.key, iv, payload, frameHeader);
+            if (!(0, CryptoUtils_1.isDecryptionSuccess)(decryptionResult)) {
+                controller.enqueue(encodedFrame);
+                return;
+            }
+            const plain = decryptionResult.data;
+            const result = new ArrayBuffer(frameHeader.byteLength + plain.byteLength);
+            const writableResult = new Uint8Array(result);
+            writableResult.set(frameHeader);
+            writableResult.set(new Uint8Array(plain), frameHeader.byteLength);
+            encodedFrame.data = result;
+            controller.enqueue(encodedFrame);
+        }
+        catch (e) {
+            logError(e);
+            controller.enqueue(encodedFrame);
+        }
+    }
+}
+exports.EncryptTransform = EncryptTransform;
+self.keyStore = new KeyStore_1.KeyStore();
+const getKeyStore = () => self.keyStore;
+self.onmessage = async (event) => {
+    const { operation, kind } = event.data;
+    if (operation === "initialize") {
+        logDebug("worker initialize call");
+    }
+    else if (operation === "init-pipeline") {
+        pipelines.set(event.data.id, { ready: false });
+        self.postMessage({ operation: "init-pipeline", id: event.data.id });
+    }
+    else if (operation === "encode" || operation === "decode") {
+        const { readableStream, writableStream, id, publisherId } = event.data;
+        const context = { keyStore: getKeyStore(), id, publisherId };
+        handleTransform(context, operation, kind, readableStream, writableStream);
+    }
+    else if (operation === "setKeys") {
+        const data = event.data;
+        getKeyStore().setKeys(data.keys);
+    }
+    else if (operation === "rms") {
+        lastRMS = Math.round(event.data.rms);
+    }
+};
+function createSenderTransform(keyStore, kind) {
+    const encrypter = new EncryptTransform(keyStore);
+    return new TransformStream({
+        async transform(encodedFrame, controller) {
+            await encrypter.encryptFrame(encodedFrame, kind, controller);
+        },
+    });
+}
+function createReceiverTransform(context, kind) {
+    const encrypter = new EncryptTransform(context.keyStore);
+    return new TransformStream({
+        async transform(encodedFrame, controller) {
+            await encrypter.decryptFrame(encodedFrame, kind, controller, context.id, context.publisherId);
+        },
+    });
+}
+function handleTransform(context, operation, kind, readableStream, writableStream) {
+    let transformStream;
+    logDebug("handleTransform: " + JSON.stringify({ operation, context }));
+    if (operation === "encode") {
+        transformStream = createSenderTransform(context.keyStore, kind);
+        readableStream.pipeThrough(transformStream).pipeTo(writableStream);
+    }
+    else if (operation === "decode") {
+        transformStream = createReceiverTransform(context, kind);
+        const pipeline = readableStream
+            .pipeThrough(transformStream)
+            .pipeTo(writableStream)
+            .catch((err) => {
+            if (!String(err).includes("Destination stream closed")) {
+                console.error("pipeline error", err);
+            }
+        });
+        if (context.id) {
+            sessions.set(context.id, { pipeline });
+        }
+    }
+}
+if (self.RTCTransformEvent) {
+    self.onrtctransform = (event) => {
+        const transformer = event.transformer;
+        const options = transformer.options;
+        if (!options) {
+            logError("onrtctransform: options is undefined");
+            return;
+        }
+        const { operation, kind, id, publisherId } = options;
+        const context = {
+            keyStore: getKeyStore(),
+            id,
+            publisherId,
+        };
+        handleTransform(context, operation, kind, transformer.readable, transformer.writable);
+    };
+}
+/**
+ * LOGGING UTILS
+ */
+function logDebug(msg) {
+    if (!DEBUG)
+        return;
+    self.postMessage({ type: "debug", data: msg });
+}
+function logError(msg) {
+    self.postMessage({ type: "error", data: msg });
+}
+logDebug("Worker Initialized");