@matterbridge/core 3.10.9-dev-20260908-a3f4064 → 3.10.9-dev-20260910-ca91bcb

package/dist/behaviors/clients.js

@@ -0,0 +1,33 @@
+import { ChimeClient } from '@matter/node/behaviors/chime';
+import { WebRtcTransportProviderClient } from '@matter/node/behaviors/web-rtc-transport-provider';
+import { WebRtcTransportRequestorClient } from '@matter/node/behaviors/web-rtc-transport-requestor';
+import { Chime } from '@matter/types/clusters/chime';
+import { WebRtcTransportProvider } from '@matter/types/clusters/web-rtc-transport-provider';
+import { WebRtcTransportRequestor } from '@matter/types/clusters/web-rtc-transport-requestor';
+import { MatterbridgeBindingServer } from './bindingServer.js';
+function addBindingClientListEntry(endpoint, clusterId) {
+    if (endpoint.behaviors.has(MatterbridgeBindingServer)) {
+        const existing = endpoint.behaviors.optionsFor(MatterbridgeBindingServer)?.clientList ?? [];
+        if (!existing.includes(clusterId)) {
+            endpoint.behaviors.inject(MatterbridgeBindingServer, { clientList: [...existing, clusterId] });
+        }
+    }
+    else {
+        endpoint.behaviors.require(MatterbridgeBindingServer, { clientList: [clusterId] });
+    }
+}
+export function addChimeClient(endpoint) {
+    addBindingClientListEntry(endpoint, Chime.id);
+    endpoint.type.clientClusters.chime ??= ChimeClient;
+    return endpoint;
+}
+export function addWebRtcTransportRequestorClient(endpoint) {
+    addBindingClientListEntry(endpoint, WebRtcTransportRequestor.id);
+    endpoint.type.clientClusters.webRtcTransportRequestor ??= WebRtcTransportRequestorClient;
+    return endpoint;
+}
+export function addWebRtcTransportProviderClient(endpoint) {
+    addBindingClientListEntry(endpoint, WebRtcTransportProvider.id);
+    endpoint.type.clientClusters.webRtcTransportProvider ??= WebRtcTransportProviderClient;
+    return endpoint;
+}

package/dist/behaviors/ffmpeg.d.ts

@@ -0,0 +1,4 @@
+import { type ChildProcess } from 'node:child_process';
+export declare function hasFfmpeg(): boolean;
+export declare function redactSource(source: string): string;
+export declare function runFfmpeg(args: string[]): ChildProcess;

package/dist/behaviors/ffmpeg.js

@@ -0,0 +1,103 @@
+import { spawn } from 'node:child_process';
+import { constants } from 'node:fs';
+import { access, readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { AnsiLogger, MAGENTA } from 'node-ansi-logger';
+const log = new AnsiLogger({ logName: 'Ffmpeg', logLevel: "debug", logNameColor: MAGENTA, logTimestampFormat: 4 });
+async function runProbe(command, args) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: 'ignore' });
+        child.once('error', reject);
+        child.once('exit', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`${command} exited with code ${code ?? -1}`));
+        });
+    });
+}
+async function isRunnable(command) {
+    for (const versionArg of ['--version', '-version']) {
+        try {
+            await runProbe(command, [versionArg]);
+            return true;
+        }
+        catch {
+        }
+    }
+    return false;
+}
+async function getWindowsCommandCandidates() {
+    if (process.platform !== 'win32')
+        return [];
+    const candidates = [];
+    if (process.env.LOCALAPPDATA) {
+        const wingetPackages = path.join(process.env.LOCALAPPDATA, 'Microsoft', 'WinGet', 'Packages');
+        try {
+            const packageDirs = await readdir(wingetPackages, { withFileTypes: true });
+            for (const packageDir of packageDirs) {
+                if (!packageDir.isDirectory() || !packageDir.name.startsWith('Gyan.FFmpeg_'))
+                    continue;
+                const packagePath = path.join(wingetPackages, packageDir.name);
+                try {
+                    const versionDirs = await readdir(packagePath, { withFileTypes: true });
+                    for (const versionDir of versionDirs) {
+                        if (versionDir.isDirectory() && versionDir.name.startsWith('ffmpeg-'))
+                            candidates.push(path.join(packagePath, versionDir.name, 'bin', 'ffmpeg.exe'));
+                    }
+                }
+                catch {
+                }
+            }
+        }
+        catch {
+        }
+    }
+    for (const programFiles of [process.env.ProgramFiles, process.env['ProgramFiles(x86)']]) {
+        if (!programFiles)
+            continue;
+        candidates.push(path.join(programFiles, 'ffmpeg', 'bin', 'ffmpeg.exe'), path.join(programFiles, 'Gyan', 'FFmpeg', 'bin', 'ffmpeg.exe'));
+    }
+    return candidates;
+}
+async function resolveFfmpeg() {
+    const candidates = ['ffmpeg', '/usr/bin/ffmpeg', '/bin/ffmpeg', '/usr/local/bin/ffmpeg', ...(await getWindowsCommandCandidates())];
+    log.debug(`Resolving ffmpeg: trying ${candidates.length} candidate(s)`);
+    for (const candidate of candidates) {
+        if (path.isAbsolute(candidate)) {
+            try {
+                await access(candidate, constants.X_OK);
+            }
+            catch {
+                log.debug(`Candidate ${candidate} is not accessible`);
+                continue;
+            }
+        }
+        if (await isRunnable(candidate)) {
+            log.debug(`Found ffmpeg in ${candidate}`);
+            return candidate;
+        }
+        log.debug(`Candidate ${candidate} did not run successfully`);
+    }
+    log.debug('Could not resolve ffmpeg');
+    return undefined;
+}
+const ffmpegCommand = await resolveFfmpeg();
+if (ffmpegCommand)
+    log.debug(`Using ffmpeg: ${ffmpegCommand}`);
+else
+    log.warn('ffmpeg could not be resolved on this host; ffmpeg-dependent features will not work');
+export function hasFfmpeg() {
+    return ffmpegCommand !== undefined;
+}
+export function redactSource(source) {
+    return source.replace(/^([a-z][a-z\d+.-]*:\/\/)[^/]*@/i, '$1***@');
+}
+export function runFfmpeg(args) {
+    if (!ffmpegCommand) {
+        throw new Error('Cannot run ffmpeg: not found on this host');
+    }
+    log.debug(`Spawning ffmpeg: ${ffmpegCommand} ${args.map(redactSource).join(' ')}`);
+    return spawn(ffmpegCommand, args);
+}

package/dist/behaviors/snapshot.d.ts

@@ -0,0 +1,15 @@
+export interface SnapshotRequest {
+    src: string;
+    width: number;
+    height: number;
+    maxBytes?: number;
+}
+export interface SnapshotResult {
+    data: Buffer;
+    byteLength: number;
+    width: number;
+    height: number;
+    quality: number;
+    downgraded: boolean;
+}
+export declare function captureSnapshot(request: SnapshotRequest): Promise<SnapshotResult>;

package/dist/behaviors/snapshot.js

@@ -0,0 +1,139 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { AnsiLogger, MAGENTA } from 'node-ansi-logger';
+import { hasFfmpeg, redactSource, runFfmpeg } from './ffmpeg.js';
+const MAX_BYTES = 64000;
+const QUALITIES = [6, 10, 14, 18, 24, 31];
+const FALLBACK_WIDTH = 640;
+const WEBCAM_WARMUP_SECONDS = 1;
+const CAPTURE_TIMEOUT_MS = 10_000;
+const TERMINATION_GRACE_MS = 1_000;
+const log = new AnsiLogger({ logName: 'Snapshot', logLevel: "debug", logNameColor: MAGENTA, logTimestampFormat: 4 });
+export async function captureSnapshot(request) {
+    const { src, width, height, maxBytes = MAX_BYTES } = request;
+    if (typeof src !== 'string' || src.trim().length === 0) {
+        throw new Error('Snapshot source must not be empty');
+    }
+    if (!Number.isFinite(width) || !Number.isInteger(width) || width <= 0) {
+        throw new Error(`Snapshot width must be a positive integer, got ${width}`);
+    }
+    if (!Number.isFinite(height) || !Number.isInteger(height) || height <= 0) {
+        throw new Error(`Snapshot height must be a positive integer, got ${height}`);
+    }
+    if (!Number.isFinite(maxBytes) || !Number.isInteger(maxBytes) || maxBytes <= 0) {
+        throw new Error(`Snapshot maxBytes must be a positive integer, got ${maxBytes}`);
+    }
+    const redactedSrc = redactSource(src);
+    log.debug(`Capturing snapshot from ${redactedSrc} at ${width}x${height}, maxBytes=${maxBytes}`);
+    let last = Buffer.alloc(0);
+    let lastQuality = QUALITIES[QUALITIES.length - 1];
+    log.debug(`Pass 1: trying ${width}x${height} at qualities [${QUALITIES.join(', ')}]`);
+    for (const q of QUALITIES) {
+        log.debug(`Pass 1: grabbing ${width}x${height} at quality ${q}`);
+        const buf = await grab(src, width, height, q);
+        log.debug(`Pass 1: grabbed ${buf.length}B at quality ${q} (maxBytes=${maxBytes})`);
+        last = buf;
+        lastQuality = q;
+        if (buf.length <= maxBytes) {
+            log.debug(`Pass 1: accepted ${buf.length}B at ${width}x${height}, quality ${q}`);
+            return { data: buf, byteLength: buf.length, width, height, quality: q, downgraded: false };
+        }
+    }
+    const fallbackWidth = Math.min(width, FALLBACK_WIDTH);
+    log.debug(`Pass 2: falling back to ${fallbackWidth}px wide at qualities [${QUALITIES.join(', ')}]`);
+    for (const q of QUALITIES) {
+        log.debug(`Pass 2: grabbing ${fallbackWidth}px wide at quality ${q}`);
+        const buf = await grab(src, fallbackWidth, -1, q);
+        log.debug(`Pass 2: grabbed ${buf.length}B at quality ${q} (maxBytes=${maxBytes})`);
+        last = buf;
+        lastQuality = q;
+        if (buf.length <= maxBytes) {
+            log.warn(`Snapshot downgraded to ${fallbackWidth}px to fit ${maxBytes}B (requested ${width}x${height})`);
+            return { data: buf, byteLength: buf.length, width: fallbackWidth, height: -1, quality: q, downgraded: true };
+        }
+    }
+    throw new Error(`Snapshot capture from ${redactedSrc} exceeds ${maxBytes}B at minimum quality/resolution (${last.length}B at quality ${lastQuality})`);
+}
+function buildInputArgs(src, width, height) {
+    if (src.startsWith('rtsp://')) {
+        return ['-rtsp_transport', 'tcp', '-i', src];
+    }
+    const warmup = ['-ss', String(WEBCAM_WARMUP_SECONDS)];
+    const videoSize = height === -1 ? [] : ['-video_size', `${width}x${height}`];
+    switch (process.platform) {
+        case 'linux':
+            return ['-f', 'v4l2', ...videoSize, '-i', src, ...warmup];
+        case 'darwin':
+            return ['-f', 'avfoundation', ...videoSize, '-i', src, ...warmup];
+        case 'win32':
+            return ['-f', 'dshow', ...videoSize, '-i', `video=${src}`, ...warmup];
+        default:
+            throw new Error(`Webcam capture via ffmpeg is not supported on platform "${process.platform}"`);
+    }
+}
+async function grab(src, width, height, q) {
+    if (!hasFfmpeg()) {
+        log.warn('Cannot capture snapshot: missing dependency ffmpeg');
+        throw new Error('Cannot capture snapshot: missing dependency ffmpeg');
+    }
+    return new Promise((resolve, reject) => {
+        const scaleExpr = height === -1 ? `scale=${width}:-1` : `scale=${width}:${height}`;
+        const args = ['-y', ...buildInputArgs(src, width, height), '-frames:v', '1', '-vf', scaleExpr, '-q:v', String(q), '-f', 'mjpeg', 'pipe:1'];
+        const proc = runFfmpeg(args);
+        const chunks = [];
+        let stderr = '';
+        let forceKillTimeout;
+        const timeout = setTimeout(() => {
+            proc.kill('SIGTERM');
+            forceKillTimeout = setTimeout(() => {
+                proc.kill('SIGKILL');
+            }, TERMINATION_GRACE_MS);
+            reject(new Error(`Snapshot capture from ${redactSource(src)} timed out after ${CAPTURE_TIMEOUT_MS}ms`));
+        }, CAPTURE_TIMEOUT_MS);
+        proc.stdout?.on('data', (d) => chunks.push(d));
+        proc.stderr?.on('data', (d) => {
+            stderr += d.toString();
+        });
+        proc.on('close', (code) => {
+            clearTimeout(timeout);
+            if (forceKillTimeout)
+                clearTimeout(forceKillTimeout);
+            if (code === 0) {
+                const data = Buffer.concat(chunks);
+                if (data.length === 0) {
+                    reject(new Error(`Snapshot capture from ${redactSource(src)} produced no data`));
+                    return;
+                }
+                log.debug(`ffmpeg exited 0, captured ${data.length}B`);
+                resolve(data);
+            }
+            else {
+                log.debug(`ffmpeg exited ${code}: ${stderr}`);
+                reject(new Error(`ffmpeg exited ${code}: ${stderr}`));
+            }
+        });
+        proc.on('error', (error) => {
+            clearTimeout(timeout);
+            if (forceKillTimeout)
+                clearTimeout(forceKillTimeout);
+            reject(error);
+        });
+    });
+}
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+    const src = process.argv[2] ?? 'Surface Camera Front';
+    const outputDir = path.join(process.cwd(), 'temp');
+    await mkdir(outputDir, { recursive: true });
+    const resolutions = [
+        { width: 640, height: 480 },
+        { width: 1280, height: 720 },
+        { width: 1920, height: 1080 },
+    ];
+    for (const { width, height } of resolutions) {
+        const result = await captureSnapshot({ src, width, height });
+        const outputFile = path.join(outputDir, `snapshot-${width}x${height}.jpeg`);
+        await writeFile(outputFile, result.data);
+        log.info(`Saved snapshot to ${outputFile} (${result.byteLength}B, ${result.width}x${result.height}, quality=${result.quality}, downgraded=${result.downgraded})`);
+    }
+}

package/dist/behaviors/webRtcTransportProviderServer.d.ts

@@ -0,0 +1,28 @@
+import { WebRtcTransportProviderServer } from '@matter/node/behaviors/web-rtc-transport-provider';
+import type { WebRtcTransportProvider } from '@matter/types/clusters/web-rtc-transport-provider';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { type WeriftOfferOptions, WeriftWebRtcSession } from './weriftSession.js';
+export declare function allocateWebRtcSessionId(nextCandidate: number, activeSessionIds: ReadonlySet<number>): {
+    webRtcSessionId: number;
+    nextCandidate: number;
+};
+export declare class MatterbridgeWebRtcTransportProviderServer extends WebRtcTransportProviderServer {
+    #private;
+    state: MatterbridgeWebRtcTransportProviderServer.State;
+    internal: MatterbridgeWebRtcTransportProviderServer.Internal;
+    solicitOffer(request: WebRtcTransportProvider.SolicitOfferRequest): Promise<WebRtcTransportProvider.SolicitOfferResponse>;
+    provideOffer(request: WebRtcTransportProvider.ProvideOfferRequest): Promise<WebRtcTransportProvider.ProvideOfferResponse>;
+    provideAnswer(request: WebRtcTransportProvider.ProvideAnswerRequest): Promise<void>;
+    provideIceCandidates(request: WebRtcTransportProvider.ProvideIceCandidatesRequest): Promise<void>;
+    endSession(request: WebRtcTransportProvider.EndSessionRequest): Promise<void>;
+}
+export declare namespace MatterbridgeWebRtcTransportProviderServer {
+    class State extends WebRtcTransportProviderServer.State {
+        weriftOfferOptions: WeriftOfferOptions;
+    }
+    class Internal {
+        nextWebRtcSessionId: number;
+        sessions: Map<number, WeriftWebRtcSession>;
+    }
+}
+export declare function createDefaultWebRtcTransportProviderClusterServer(endpoint: MatterbridgeEndpoint, weriftOfferOptions?: WeriftOfferOptions): MatterbridgeEndpoint;