@matterbridge/core 3.10.9-dev-20260907-5fcc59a → 3.10.9-dev-20260910-ca91bcb

package/dist/behaviors/webRtcTransportProviderServer.js

@@ -0,0 +1,422 @@
+import { Node } from '@matter/main';
+import { WebRtcTransportProviderServer } from '@matter/node/behaviors/web-rtc-transport-provider';
+import { WebRtcTransportRequestorClient } from '@matter/node/behaviors/web-rtc-transport-requestor';
+import { EndpointNumber, FabricIndex, NodeId, StreamUsage, Status, StatusResponseError } from '@matter/types';
+import { WebRtcTransportDefinitions } from '@matter/types/clusters/web-rtc-transport-definitions';
+import { emitCommand } from '../matterbridgeEndpointHelpers.js';
+import { MatterbridgeCameraAvStreamManagementServer } from './cameraAvStreamManagementServer.js';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+import { WeriftWebRtcSession } from './weriftSession.js';
+const DEFERRED_INVOKE_DELAY_MS = 250;
+const ICE_CANDIDATE_APPLY_TIMEOUT_MS = 5000;
+const MAX_WEB_RTC_SESSION_ID = 0xfffe;
+const MAX_CONCURRENT_SESSIONS = 5;
+export function allocateWebRtcSessionId(nextCandidate, activeSessionIds) {
+    const firstCandidate = nextCandidate;
+    let candidate = firstCandidate;
+    do {
+        const followingCandidate = candidate === MAX_WEB_RTC_SESSION_ID ? 0 : candidate + 1;
+        if (!activeSessionIds.has(candidate))
+            return { webRtcSessionId: candidate, nextCandidate: followingCandidate };
+        candidate = followingCandidate;
+    } while (candidate !== firstCandidate);
+    throw new StatusResponseError('No WebRTC session identifier is available', Status.ResourceExhausted);
+}
+export class MatterbridgeWebRtcTransportProviderServer extends WebRtcTransportProviderServer {
+    #invokeDeferred(action, description) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const endpointLabel = `${this.endpoint.maybeId}.${this.endpoint.maybeNumber}`;
+        setTimeout(() => {
+            Promise.resolve(action()).catch((error) => {
+                device.log.error(`MatterbridgeWebRtcTransportProviderServer: failed to invoke ${description} on the peer's WebRtcTransportRequestor: ${error instanceof Error ? error.message : String(error)} (endpoint ${endpointLabel})`);
+            });
+        }, DEFERRED_INVOKE_DELAY_MS);
+    }
+    async #resolvePeerRequestorEndpoint(peerNodeId, fabricIndex, peerEndpointId) {
+        try {
+            const serverNode = Node.forEndpoint(this.endpoint);
+            const peerNode = await serverNode.peers.forAddress({ nodeId: peerNodeId, fabricIndex });
+            const peerEndpoint = peerNode.endpoints.require(peerEndpointId);
+            peerEndpoint.behaviors.require(WebRtcTransportRequestorClient);
+            return peerEndpoint;
+        }
+        catch (error) {
+            this.endpoint
+                .stateOf(MatterbridgeServer)
+                .log.debug(`MatterbridgeWebRtcTransportProviderServer: could not resolve peer WebRtcTransportRequestor endpoint (peerNodeId=${peerNodeId}, fabricIndex=${fabricIndex}, peerEndpointId=${peerEndpointId}): ${error instanceof Error ? error.message : String(error)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            return undefined;
+        }
+    }
+    #getPeerInfo() {
+        const session = this.context.session;
+        return {
+            peerNodeId: session?.peerNodeId ?? NodeId(0),
+            fabricIndex: session?.fabric?.fabricIndex ?? FabricIndex(1),
+        };
+    }
+    #allocateWebRtcSessionId() {
+        const activeSessionIds = new Set(this.state.currentSessions.map((session) => session.id));
+        const allocation = allocateWebRtcSessionId(this.internal.nextWebRtcSessionId, activeSessionIds);
+        this.internal.nextWebRtcSessionId = allocation.nextCandidate;
+        return allocation.webRtcSessionId;
+    }
+    #resolveStreamLists(request) {
+        return {
+            videoStreams: request.videoStreams ?? (request.videoStreamId !== undefined && request.videoStreamId !== null ? [request.videoStreamId] : undefined),
+            audioStreams: request.audioStreams ?? (request.audioStreamId !== undefined && request.audioStreamId !== null ? [request.audioStreamId] : undefined),
+        };
+    }
+    #hasNoStreamFields(request) {
+        return request.videoStreams === undefined && request.audioStreams === undefined && request.videoStreamId === undefined && request.audioStreamId === undefined;
+    }
+    #validateNoConflictingStreamFields(request) {
+        if ((request.videoStreams !== undefined && request.videoStreamId !== undefined) || (request.audioStreams !== undefined && request.audioStreamId !== undefined)) {
+            throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer: videoStreams/audioStreams and the deprecated videoStreamId/audioStreamId fields are mutually exclusive (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidCommand);
+        }
+    }
+    #isStrictWebRtcTransport() {
+        return process.env.MATTERBRIDGE_STRICT_WEBRTCTRANSPORT === '1';
+    }
+    #resolveVideoResolution(videoStreams) {
+        const videoStreamId = videoStreams?.[0];
+        if (videoStreamId === undefined)
+            return undefined;
+        if (!this.endpoint.behaviors.has(MatterbridgeCameraAvStreamManagementServer))
+            return undefined;
+        const { allocatedVideoStreams } = this.endpoint.stateOf(MatterbridgeCameraAvStreamManagementServer);
+        const stream = allocatedVideoStreams.find((allocatedStream) => allocatedStream.videoStreamId === videoStreamId);
+        if (!stream)
+            return undefined;
+        return `${stream.maxResolution.width}x${stream.maxResolution.height}`;
+    }
+    #selectExistingVideoStreamId(streamUsage) {
+        const allocatedVideoStreams = [...this.endpoint.stateOf(MatterbridgeCameraAvStreamManagementServer).allocatedVideoStreams];
+        return (allocatedVideoStreams.find((stream) => stream.streamUsage === streamUsage) ?? allocatedVideoStreams[0])?.videoStreamId;
+    }
+    #selectExistingAudioStreamId(streamUsage) {
+        const allocatedAudioStreams = [...this.endpoint.stateOf(MatterbridgeCameraAvStreamManagementServer).allocatedAudioStreams];
+        return (allocatedAudioStreams.find((stream) => stream.streamUsage === streamUsage) ?? allocatedAudioStreams[0])?.audioStreamId;
+    }
+    async #autoAssignStreams(streamUsage) {
+        if (!this.endpoint.behaviors.has(MatterbridgeCameraAvStreamManagementServer))
+            return {};
+        const state = this.endpoint.stateOf(MatterbridgeCameraAvStreamManagementServer);
+        let videoStreamId = this.#selectExistingVideoStreamId(streamUsage);
+        if (videoStreamId === undefined && state.rateDistortionTradeOffPoints.length > 0) {
+            let largestTradeOffPoint = state.rateDistortionTradeOffPoints[0];
+            for (const point of state.rateDistortionTradeOffPoints) {
+                if (point.resolution.width * point.resolution.height > largestTradeOffPoint.resolution.width * largestTradeOffPoint.resolution.height)
+                    largestTradeOffPoint = point;
+            }
+            const { codec, resolution, minBitRate } = largestTradeOffPoint;
+            ({ videoStreamId } = await this.endpoint.act((agent) => agent.get(MatterbridgeCameraAvStreamManagementServer).videoStreamAllocate({
+                streamUsage,
+                videoCodec: codec,
+                minFrameRate: 1,
+                maxFrameRate: state.videoSensorParams.maxFps,
+                minResolution: state.minViewportResolution,
+                maxResolution: resolution,
+                minBitRate,
+                maxBitRate: minBitRate * 4,
+                keyFrameInterval: 4000,
+            })));
+        }
+        let audioStreamId = this.#selectExistingAudioStreamId(streamUsage);
+        if (audioStreamId === undefined && state.microphoneCapabilities.supportedCodecs.length > 0) {
+            const { microphoneCapabilities } = state;
+            ({ audioStreamId } = await this.endpoint.act((agent) => agent.get(MatterbridgeCameraAvStreamManagementServer).audioStreamAllocate({
+                streamUsage,
+                audioCodec: microphoneCapabilities.supportedCodecs[0],
+                channelCount: microphoneCapabilities.maxNumberOfChannels,
+                sampleRate: microphoneCapabilities.supportedSampleRates[0],
+                bitRate: 32_000,
+                bitDepth: microphoneCapabilities.supportedBitDepths[0],
+            })));
+        }
+        return {
+            videoStreams: videoStreamId === undefined ? undefined : [videoStreamId],
+            audioStreams: audioStreamId === undefined ? undefined : [audioStreamId],
+        };
+    }
+    #validateAllocatedStreamIds(kind, ids) {
+        const state = this.endpoint.stateOf(MatterbridgeCameraAvStreamManagementServer);
+        const attributeName = kind === 'video' ? 'AllocatedVideoStreams' : 'AllocatedAudioStreams';
+        const allocatedIds = kind === 'video' ? state.allocatedVideoStreams.map((stream) => stream.videoStreamId) : state.allocatedAudioStreams.map((stream) => stream.audioStreamId);
+        if (allocatedIds.length === 0) {
+            throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer: no ${kind} stream is allocated (${attributeName} is empty) (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidInState);
+        }
+        if (new Set(ids).size !== ids.length) {
+            throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer: duplicate ${kind} stream id in the request (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.AlreadyExists);
+        }
+        for (const id of ids) {
+            if (!allocatedIds.includes(id)) {
+                throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer: ${kind} stream ${id} is not present in ${attributeName} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.DynamicConstraintError);
+            }
+        }
+    }
+    #validateStreamUsage(streamUsage) {
+        const streamUsagePriorities = this.endpoint.behaviors.has(MatterbridgeCameraAvStreamManagementServer)
+            ? this.endpoint.stateOf(MatterbridgeCameraAvStreamManagementServer).streamUsagePriorities
+            : [];
+        if (!streamUsagePriorities.includes(streamUsage)) {
+            throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer: stream usage ${streamUsage} is not present in streamUsagePriorities (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.DynamicConstraintError);
+        }
+    }
+    #resolveStrictStreamLists(request, streamUsage) {
+        let videoStreams;
+        if (request.videoStreams !== undefined) {
+            videoStreams = request.videoStreams;
+        }
+        else if (request.videoStreamId === null) {
+            const selected = this.#selectExistingVideoStreamId(streamUsage);
+            videoStreams = selected === undefined ? [] : [selected];
+        }
+        else if (request.videoStreamId !== undefined) {
+            videoStreams = [request.videoStreamId];
+        }
+        if (videoStreams !== undefined)
+            this.#validateAllocatedStreamIds('video', videoStreams);
+        let audioStreams;
+        if (request.audioStreams !== undefined) {
+            audioStreams = request.audioStreams;
+        }
+        else if (request.audioStreamId === null) {
+            const selected = this.#selectExistingAudioStreamId(streamUsage);
+            audioStreams = selected === undefined ? [] : [selected];
+        }
+        else if (request.audioStreamId !== undefined) {
+            audioStreams = [request.audioStreamId];
+        }
+        if (audioStreams !== undefined)
+            this.#validateAllocatedStreamIds('audio', audioStreams);
+        return { videoStreams, audioStreams };
+    }
+    #echoDeprecatedStreamIds(request, videoStreams, audioStreams) {
+        return {
+            videoStreamId: request.videoStreamId === undefined ? undefined : (videoStreams?.[0] ?? null),
+            audioStreamId: request.audioStreamId === undefined ? undefined : (audioStreams?.[0] ?? null),
+        };
+    }
+    #evictIfOverCapacity(webRtcSessionId, requestorEndpoint) {
+        if (this.state.currentSessions.length <= MAX_CONCURRENT_SESSIONS)
+            return false;
+        this.state.currentSessions = this.state.currentSessions.filter((session) => session.id !== webRtcSessionId);
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.notice(`MatterbridgeWebRtcTransportProviderServer: session ${webRtcSessionId} exceeds MAX_CONCURRENT_SESSIONS (${MAX_CONCURRENT_SESSIONS}); evicting with WebRtcEndReason.OutOfResources (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (requestorEndpoint) {
+            this.#invokeDeferred(async () => requestorEndpoint.commandsOf(WebRtcTransportRequestorClient).end({ webRtcSessionId, reason: WebRtcTransportDefinitions.WebRtcEndReason.OutOfResources }), `End (OutOfResources) for session ${webRtcSessionId}`);
+        }
+        return true;
+    }
+    async solicitOffer(request) {
+        this.#validateNoConflictingStreamFields(request);
+        let videoStreams;
+        let audioStreams;
+        if (this.#isStrictWebRtcTransport()) {
+            if (this.#hasNoStreamFields(request)) {
+                throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer.solicitOffer: requires at least one of videoStreams, audioStreams, videoStreamId or audioStreamId to be present (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidCommand);
+            }
+            this.#validateStreamUsage(request.streamUsage);
+            ({ videoStreams, audioStreams } = this.#resolveStrictStreamLists(request, request.streamUsage));
+        }
+        else {
+            ({ videoStreams, audioStreams } = this.#resolveStreamLists(request));
+            if (!videoStreams?.length && !audioStreams?.length) {
+                ({ videoStreams, audioStreams } = await this.#autoAssignStreams(request.streamUsage));
+            }
+        }
+        if (!videoStreams?.length && !audioStreams?.length) {
+            throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer.solicitOffer: requires at least one of videoStreams or audioStreams; the camera has no video or audio stream to assign automatically (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const webRtcSessionId = this.#allocateWebRtcSessionId();
+        const { peerNodeId, fabricIndex } = this.#getPeerInfo();
+        this.state.currentSessions = [
+            ...this.state.currentSessions,
+            {
+                id: webRtcSessionId,
+                peerNodeId,
+                peerEndpointId: request.originatingEndpointId,
+                streamUsage: request.streamUsage,
+                metadataEnabled: request.metadataEnabled ?? false,
+                videoStreams,
+                audioStreams,
+                videoStreamId: videoStreams?.[0] ?? null,
+                audioStreamId: audioStreams?.[0] ?? null,
+                fabricIndex,
+            },
+        ];
+        device.log.info(`MatterbridgeWebRtcTransportProviderServer.solicitOffer: solicited a WebRTC offer for session ${webRtcSessionId} (stream usage ${request.streamUsage}) (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        const requestorEndpoint = await this.#resolvePeerRequestorEndpoint(peerNodeId, fabricIndex, request.originatingEndpointId);
+        if (this.#evictIfOverCapacity(webRtcSessionId, requestorEndpoint)) {
+            emitCommand(this.endpoint, WebRtcTransportProviderServer.id, 'solicitOffer', request, this.context);
+            return { webRtcSessionId, deferredOffer: false, ...this.#echoDeprecatedStreamIds(request, videoStreams, audioStreams) };
+        }
+        const webRtcPeer = new WeriftWebRtcSession(webRtcSessionId, this.state.weriftOfferOptions);
+        this.internal.sessions.set(webRtcSessionId, webRtcPeer);
+        const sdp = await webRtcPeer.createOffer({
+            video: !!videoStreams?.length,
+            audio: !!audioStreams?.length,
+            videoResolution: this.state.weriftOfferOptions.videoResolution ?? this.#resolveVideoResolution(videoStreams),
+        });
+        if (requestorEndpoint) {
+            this.#invokeDeferred(async () => requestorEndpoint.commandsOf(WebRtcTransportRequestorClient).offer({ webRtcSessionId, sdp }), `Offer for session ${webRtcSessionId}`);
+            device.log.info(`MatterbridgeWebRtcTransportProviderServer.solicitOffer: invoking Offer on the peer's WebRtcTransportRequestor for session ${webRtcSessionId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        }
+        else {
+            device.log.info(`MatterbridgeWebRtcTransportProviderServer.solicitOffer: could not reach the peer's WebRtcTransportRequestor; the Offer for session ${webRtcSessionId} was not sent (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        }
+        emitCommand(this.endpoint, WebRtcTransportProviderServer.id, 'solicitOffer', request, this.context);
+        return { webRtcSessionId, deferredOffer: false, ...this.#echoDeprecatedStreamIds(request, videoStreams, audioStreams) };
+    }
+    async provideOffer(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        let webRtcSessionId = request.webRtcSessionId;
+        if (webRtcSessionId === null) {
+            this.#validateNoConflictingStreamFields(request);
+            let videoStreams;
+            let audioStreams;
+            if (this.#isStrictWebRtcTransport()) {
+                if (this.#hasNoStreamFields(request)) {
+                    throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer.provideOffer: requires at least one of videoStreams, audioStreams, videoStreamId or audioStreamId to be present (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidCommand);
+                }
+                this.#validateStreamUsage(request.streamUsage ?? StreamUsage.LiveView);
+                ({ videoStreams, audioStreams } = this.#resolveStrictStreamLists(request, request.streamUsage ?? StreamUsage.LiveView));
+            }
+            else {
+                ({ videoStreams, audioStreams } = this.#resolveStreamLists(request));
+                if (!videoStreams?.length && !audioStreams?.length) {
+                    ({ videoStreams, audioStreams } = await this.#autoAssignStreams(request.streamUsage ?? StreamUsage.LiveView));
+                }
+            }
+            if (!videoStreams?.length && !audioStreams?.length) {
+                throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer.provideOffer: requires at least one of videoStreams or audioStreams; the camera has no video or audio stream to assign automatically (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+            }
+            webRtcSessionId = this.#allocateWebRtcSessionId();
+            const { peerNodeId, fabricIndex } = this.#getPeerInfo();
+            this.state.currentSessions = [
+                ...this.state.currentSessions,
+                {
+                    id: webRtcSessionId,
+                    peerNodeId,
+                    peerEndpointId: request.originatingEndpointId ?? EndpointNumber(0),
+                    streamUsage: request.streamUsage ?? StreamUsage.LiveView,
+                    metadataEnabled: request.metadataEnabled ?? false,
+                    videoStreams,
+                    audioStreams,
+                    videoStreamId: videoStreams?.[0] ?? null,
+                    audioStreamId: audioStreams?.[0] ?? null,
+                    fabricIndex,
+                },
+            ];
+            const requestorEndpointForCapacityCheck = await this.#resolvePeerRequestorEndpoint(peerNodeId, fabricIndex, request.originatingEndpointId ?? EndpointNumber(0));
+            if (this.#evictIfOverCapacity(webRtcSessionId, requestorEndpointForCapacityCheck)) {
+                emitCommand(this.endpoint, WebRtcTransportProviderServer.id, 'provideOffer', request, this.context);
+                return { webRtcSessionId, ...this.#echoDeprecatedStreamIds(request, videoStreams, audioStreams) };
+            }
+        }
+        else if (!this.state.currentSessions.some((session) => session.id === webRtcSessionId)) {
+            throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer.provideOffer: webRTC session ${webRtcSessionId} is not present in currentSessions (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
+        }
+        device.log.info(`MatterbridgeWebRtcTransportProviderServer.provideOffer: received an SDP offer for session ${webRtcSessionId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.debug(`MatterbridgeWebRtcTransportProviderServer.provideOffer: received an SDP offer for session ${webRtcSessionId}:\n${request.sdp}\n(endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        const session = this.state.currentSessions.find((s) => s.id === webRtcSessionId);
+        const webRtcPeer = this.internal.sessions.get(webRtcSessionId) ?? new WeriftWebRtcSession(webRtcSessionId, this.state.weriftOfferOptions);
+        this.internal.sessions.set(webRtcSessionId, webRtcPeer);
+        const sdp = await webRtcPeer.createAnswer(request.sdp, {
+            video: !!session.videoStreams?.length,
+            audio: !!session.audioStreams?.length,
+            videoResolution: this.state.weriftOfferOptions.videoResolution ?? this.#resolveVideoResolution(session.videoStreams),
+        });
+        const requestorEndpoint = await this.#resolvePeerRequestorEndpoint(session.peerNodeId, session.fabricIndex, session.peerEndpointId);
+        if (requestorEndpoint) {
+            this.#invokeDeferred(async () => requestorEndpoint.commandsOf(WebRtcTransportRequestorClient).answer({ webRtcSessionId, sdp }), `Answer for session ${webRtcSessionId}`);
+            device.log.info(`MatterbridgeWebRtcTransportProviderServer.provideOffer: invoking Answer on the peer's WebRtcTransportRequestor for session ${webRtcSessionId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        }
+        else {
+            device.log.info(`MatterbridgeWebRtcTransportProviderServer.provideOffer: could not reach the peer's WebRtcTransportRequestor; the Answer for session ${webRtcSessionId} was not sent (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        }
+        emitCommand(this.endpoint, WebRtcTransportProviderServer.id, 'provideOffer', request, this.context);
+        return { webRtcSessionId, ...this.#echoDeprecatedStreamIds(request, session.videoStreams && [...session.videoStreams], session.audioStreams && [...session.audioStreams]) };
+    }
+    async provideAnswer(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (!this.state.currentSessions.some((session) => session.id === request.webRtcSessionId)) {
+            throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer.provideAnswer: webRTC session ${request.webRtcSessionId} is not present in currentSessions (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
+        }
+        device.log.info(`MatterbridgeWebRtcTransportProviderServer.provideAnswer: received an SDP answer for session ${request.webRtcSessionId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.debug(`MatterbridgeWebRtcTransportProviderServer.provideAnswer: received SDP answer for session ${request.webRtcSessionId}:\n${request.sdp}\n(endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        const webRtcPeer = this.internal.sessions.get(request.webRtcSessionId);
+        if (webRtcPeer) {
+            await webRtcPeer.applyAnswer(request.sdp);
+        }
+        emitCommand(this.endpoint, WebRtcTransportProviderServer.id, 'provideAnswer', request, this.context);
+    }
+    async provideIceCandidates(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (!this.state.currentSessions.some((session) => session.id === request.webRtcSessionId)) {
+            throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer.provideIceCandidates: webRTC session ${request.webRtcSessionId} is not present in currentSessions (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
+        }
+        const endpointLabel = `${this.endpoint.maybeId}.${this.endpoint.maybeNumber}`;
+        device.log.info(`MatterbridgeWebRtcTransportProviderServer.provideIceCandidates: received ${request.iceCandidates.length} ICE candidate(s) for session ${request.webRtcSessionId} (endpoint ${endpointLabel})`);
+        const webRtcPeer = this.internal.sessions.get(request.webRtcSessionId);
+        if (webRtcPeer) {
+            void Promise.allSettled(request.iceCandidates.map(async (candidate, index) => {
+                const startedAt = Date.now();
+                device.log.debug(`MatterbridgeWebRtcTransportProviderServer.provideIceCandidates: applying ICE candidate ${index + 1}/${request.iceCandidates.length} for session ${request.webRtcSessionId} ` +
+                    `(mid=${candidate.sdpMid ?? 'null'}, mLine=${candidate.sdpmLineIndex ?? 'null'}, endOfCandidates=${candidate.candidate.trim() === ''}) ` +
+                    `(endpoint ${endpointLabel})`);
+                try {
+                    let timeout;
+                    try {
+                        await Promise.race([
+                            webRtcPeer.addIceCandidate(candidate.candidate, candidate.sdpMid, candidate.sdpmLineIndex),
+                            new Promise((resolve, reject) => {
+                                timeout = setTimeout(() => reject(new Error(`MatterbridgeWebRtcTransportProviderServer.provideIceCandidates: timed out applying an ICE candidate after ${ICE_CANDIDATE_APPLY_TIMEOUT_MS}ms`)), ICE_CANDIDATE_APPLY_TIMEOUT_MS);
+                            }),
+                        ]);
+                    }
+                    finally {
+                        clearTimeout(timeout);
+                    }
+                    device.log.debug(`MatterbridgeWebRtcTransportProviderServer.provideIceCandidates: applied ICE candidate ${index + 1}/${request.iceCandidates.length} for session ${request.webRtcSessionId} ` +
+                        `in ${Date.now() - startedAt}ms (endpoint ${endpointLabel})`);
+                }
+                catch (error) {
+                    device.log.warn(`MatterbridgeWebRtcTransportProviderServer.provideIceCandidates: failed ICE candidate ${index + 1}/${request.iceCandidates.length} for session ${request.webRtcSessionId} after ${Date.now() - startedAt}ms ` +
+                        `with ${String(error)} (endpoint ${endpointLabel})`);
+                }
+            }));
+        }
+        emitCommand(this.endpoint, WebRtcTransportProviderServer.id, 'provideIceCandidates', request, this.context);
+    }
+    async endSession(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (!this.state.currentSessions.some((session) => session.id === request.webRtcSessionId)) {
+            throw new StatusResponseError(`MatterbridgeWebRtcTransportProviderServer.endSession: webRTC session ${request.webRtcSessionId} is not present in currentSessions (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
+        }
+        this.state.currentSessions = this.state.currentSessions.filter((session) => session.id !== request.webRtcSessionId);
+        const webRtcPeer = this.internal.sessions.get(request.webRtcSessionId);
+        if (webRtcPeer) {
+            this.internal.sessions.delete(request.webRtcSessionId);
+            await webRtcPeer.close();
+        }
+        device.log.info(`MatterbridgeWebRtcTransportProviderServer.endSession: ended webRTC session ${request.webRtcSessionId} (reason ${request.reason}) (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        emitCommand(this.endpoint, WebRtcTransportProviderServer.id, 'endSession', request, this.context);
+    }
+}
+(function (MatterbridgeWebRtcTransportProviderServer) {
+    class State extends WebRtcTransportProviderServer.State {
+        weriftOfferOptions = { video: true, audio: true, videoSource: 'none', audioSource: 'none' };
+    }
+    MatterbridgeWebRtcTransportProviderServer.State = State;
+    class Internal {
+        nextWebRtcSessionId = 0;
+        sessions = new Map();
+    }
+    MatterbridgeWebRtcTransportProviderServer.Internal = Internal;
+})(MatterbridgeWebRtcTransportProviderServer || (MatterbridgeWebRtcTransportProviderServer = {}));
+export function createDefaultWebRtcTransportProviderClusterServer(endpoint, weriftOfferOptions = { video: true, audio: true, videoSource: 'none', audioSource: 'none' }) {
+    endpoint.behaviors.require(MatterbridgeWebRtcTransportProviderServer, { currentSessions: [], weriftOfferOptions });
+    return endpoint;
+}

package/dist/behaviors/webRtcTransportRequestorServer.d.ts

@@ -0,0 +1,10 @@
+import { WebRtcTransportRequestorServer } from '@matter/node/behaviors/web-rtc-transport-requestor';
+import type { WebRtcTransportRequestor } from '@matter/types/clusters/web-rtc-transport-requestor';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class MatterbridgeWebRtcTransportRequestorServer extends WebRtcTransportRequestorServer {
+    offer(request: WebRtcTransportRequestor.OfferRequest): Promise<void>;
+    answer(request: WebRtcTransportRequestor.AnswerRequest): Promise<void>;
+    iceCandidates(request: WebRtcTransportRequestor.IceCandidatesRequest): Promise<void>;
+    end(request: WebRtcTransportRequestor.EndRequest): Promise<void>;
+}
+export declare function createDefaultWebRtcTransportRequestorClusterServer(endpoint: MatterbridgeEndpoint): MatterbridgeEndpoint;

package/dist/behaviors/webRtcTransportRequestorServer.js

@@ -0,0 +1,24 @@
+import { WebRtcTransportRequestorServer } from '@matter/node/behaviors/web-rtc-transport-requestor';
+import { emitCommand } from '../matterbridgeEndpointHelpers.js';
+export class MatterbridgeWebRtcTransportRequestorServer extends WebRtcTransportRequestorServer {
+    async offer(request) {
+        await super.offer(request);
+        emitCommand(this.endpoint, WebRtcTransportRequestorServer.id, 'offer', request, this.context);
+    }
+    async answer(request) {
+        await super.answer(request);
+        emitCommand(this.endpoint, WebRtcTransportRequestorServer.id, 'answer', request, this.context);
+    }
+    async iceCandidates(request) {
+        await super.iceCandidates(request);
+        emitCommand(this.endpoint, WebRtcTransportRequestorServer.id, 'iceCandidates', request, this.context);
+    }
+    async end(request) {
+        await super.end(request);
+        emitCommand(this.endpoint, WebRtcTransportRequestorServer.id, 'end', request, this.context);
+    }
+}
+export function createDefaultWebRtcTransportRequestorClusterServer(endpoint) {
+    endpoint.behaviors.require(MatterbridgeWebRtcTransportRequestorServer, { currentSessions: [] });
+    return endpoint;
+}

package/dist/behaviors/weriftSession.d.ts

@@ -0,0 +1,63 @@
+import { RTCPeerConnection } from 'werift';
+type VideoSource = 'none' | 'test' | 'webcam' | 'rtsp';
+type AudioSource = 'none' | 'test' | 'microphone' | 'rtsp';
+export interface WeriftOfferOptions {
+    video: boolean;
+    audio: boolean;
+    videoSource: VideoSource;
+    videoSourceDevice?: string;
+    videoResolution?: string;
+    videoBitrate?: number;
+    audioSource: AudioSource;
+    audioSourceDevice?: string;
+}
+export type WeriftOfferOverrides = Partial<WeriftOfferOptions>;
+export declare class WeriftWebRtcSession {
+    private static readonly activeSessions;
+    private static exitHandlerRegistered;
+    readonly peerConnection: RTCPeerConnection;
+    private readonly log;
+    private readonly webRtcSessionId;
+    private readonly options;
+    private testVideoGenerator?;
+    private testVideoUdpDisposer?;
+    private testVideoAttached;
+    private testAudioGenerator?;
+    private testAudioUdpDisposer?;
+    private testAudioAttached;
+    private diagnosticsInterval?;
+    private static readonly DIAGNOSTICS_INTERVAL_MS;
+    private lastDiagnosticsCounters?;
+    private readonly dtlsTransportsWithStateLogging;
+    constructor(webRtcSessionId: number, options: WeriftOfferOptions);
+    private summarizeSdp;
+    private getFreeUdpPort;
+    private getPreferredInjectableVideoCodec;
+    private getPreferredInjectableAudioCodec;
+    private static readonly SUPPORTED_VIDEO_RESOLUTIONS;
+    private static readonly DEFAULT_BITRATE_KBPS;
+    private getConfiguredVideoBitrate;
+    private getConfiguredVideoResolution;
+    private getConfiguredVideoSource;
+    private buildFfmpegVideoInputArgs;
+    private generateVideoTrack;
+    private preferVideoCodecOnTransceivers;
+    private preferAudioCodecOnTransceivers;
+    private static readonly TEST_VOICE_PATH;
+    private getConfiguredAudioSource;
+    private buildFfmpegAudioInputArgs;
+    private generateAudioTrack;
+    private cleanupTestVideoArtifacts;
+    private cleanupTestAudioArtifacts;
+    private applyOptionOverrides;
+    createOffer(overrides?: WeriftOfferOverrides): Promise<string>;
+    createAnswer(offerSdp: string, overrides?: WeriftOfferOverrides): Promise<string>;
+    applyAnswer(answerSdp: string): Promise<void>;
+    addIceCandidate(candidate: string, sdpMid: string | null, sdpMLineIndex: number | null): Promise<void>;
+    private closing;
+    private logDtlsTransportStateChanges;
+    private logDiagnosticsSnapshot;
+    close(): Promise<void>;
+    static closeAll(): Promise<void>;
+}
+export {};