@matterbridge/core 3.10.13-dev-20261003-ba58ee6 → 3.10.13-dev-20261005-49e0dbd

package/dist/behaviors/export.d.ts

@@ -6,6 +6,7 @@ export * from './deviceEnergyManagementModeServer.js';
 export * from './deviceEnergyManagementServer.js';
 export * from './doorLockServer.js';
 export * from './fanControlServer.js';
+export * from './ffmpeg.js';
 export * from './hepaFilterMonitoringServer.js';
 export * from './identifyServer.js';
 export * from './levelControlServer.js';

package/dist/behaviors/export.js

@@ -6,6 +6,7 @@ export * from './deviceEnergyManagementModeServer.js';
 export * from './deviceEnergyManagementServer.js';
 export * from './doorLockServer.js';
 export * from './fanControlServer.js';
+export * from './ffmpeg.js';
 export * from './hepaFilterMonitoringServer.js';
 export * from './identifyServer.js';
 export * from './levelControlServer.js';

package/dist/behaviors/ffmpeg.d.ts

@@ -2,3 +2,10 @@ 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;
+export declare function parseAvfoundationWebcams(output: string): string[];
+export declare function parseDshowWebcams(output: string): string[];
+export declare function parseV4l2Webcams(output: string): string[];
+export declare function listWebcams(): Promise<string[]>;
+export declare function getPlayWebcamArgs(videoSource: string, audioSource?: string): string[];
+export declare function playWebcam(videoSource: string, audioSource?: string): ChildProcess;
+export declare function installFfmpeg(): Promise<boolean>;

package/dist/behaviors/ffmpeg.js

@@ -2,6 +2,7 @@ import { spawn } from 'node:child_process';
 import { constants } from 'node:fs';
 import { access, readdir } from 'node:fs/promises';
 import path from 'node:path';
+import { getErrorMessage } from '@matterbridge/utils';
 import { AnsiLogger, MAGENTA } from 'node-ansi-logger';
 const log = new AnsiLogger({ logName: 'Ffmpeg', logLevel: "debug", logNameColor: MAGENTA, logTimestampFormat: 4 });
 async function runProbe(command, args) {
@@ -83,7 +84,7 @@ async function resolveFfmpeg() {
     log.debug('Could not resolve ffmpeg');
     return undefined;
 }
-const ffmpegCommand = await resolveFfmpeg();
+let ffmpegCommand = await resolveFfmpeg();
 if (ffmpegCommand)
     log.debug(`Using ffmpeg: ${ffmpegCommand}`);
 else
@@ -101,3 +102,107 @@ export function runFfmpeg(args) {
     log.debug(`Spawning ffmpeg: ${ffmpegCommand} ${args.map(redactSource).join(' ')}`);
     return spawn(ffmpegCommand, args);
 }
+async function ffmpegOutput(args) {
+    return new Promise((resolve, reject) => {
+        const child = runFfmpeg(args);
+        let output = '';
+        child.stdout?.on('data', (data) => (output += data.toString()));
+        child.stderr?.on('data', (data) => (output += data.toString()));
+        child.on('error', reject);
+        child.on('close', () => resolve(output));
+    });
+}
+export function parseAvfoundationWebcams(output) {
+    const webcams = [];
+    let video = false;
+    for (const line of output.split(/\r?\n/)) {
+        if (line.includes('AVFoundation video devices'))
+            video = true;
+        else if (line.includes('AVFoundation audio devices'))
+            video = false;
+        else if (video) {
+            const name = /\]\s+\[\d+\]\s+(.+?)\s*$/.exec(line)?.[1];
+            if (name && !name.startsWith('Capture screen'))
+                webcams.push(name);
+        }
+    }
+    return webcams;
+}
+export function parseDshowWebcams(output) {
+    const webcams = [];
+    let video = false;
+    for (const line of output.split(/\r?\n/)) {
+        if (line.includes('DirectShow video devices'))
+            video = true;
+        else if (line.includes('DirectShow audio devices'))
+            video = false;
+        const match = /"(.+?)"(?:\s+\((video|audio|none)(?:,\s*(?:video|audio|none))*\))?\s*$/.exec(line);
+        if (match && (match[2] === 'video' || (match[2] === undefined && video)))
+            webcams.push(match[1]);
+    }
+    return webcams;
+}
+export function parseV4l2Webcams(output) {
+    const cameras = new Map();
+    for (const line of output.split(/\r?\n/)) {
+        const match = /^\s*\/dev\/video(\d+)\s+\[(.+)\]/.exec(line);
+        if (!match)
+            continue;
+        const node = Number(match[1]);
+        cameras.set(match[2], Math.min(node, cameras.get(match[2]) ?? node));
+    }
+    return [...cameras.values()].toSorted((a, b) => a - b).map((node) => `/dev/video${node}`);
+}
+export async function listWebcams() {
+    if (process.platform === 'darwin')
+        return parseAvfoundationWebcams(await ffmpegOutput(['-hide_banner', '-f', 'avfoundation', '-list_devices', 'true', '-i', '']));
+    if (process.platform === 'win32')
+        return parseDshowWebcams(await ffmpegOutput(['-hide_banner', '-list_devices', 'true', '-f', 'dshow', '-i', 'dummy']));
+    return parseV4l2Webcams(await ffmpegOutput(['-hide_banner', '-sources', 'v4l2']));
+}
+export function getPlayWebcamArgs(videoSource, audioSource) {
+    if (process.platform === 'darwin')
+        return ['-hide_banner', '-window_title', videoSource, '-f', 'avfoundation', '-framerate', '30', '-i', audioSource ? `${videoSource}:${audioSource}` : videoSource];
+    if (process.platform === 'win32')
+        return ['-hide_banner', '-window_title', videoSource, '-f', 'dshow', '-i', audioSource ? `video=${videoSource}:audio=${audioSource}` : `video=${videoSource}`];
+    return ['-hide_banner', '-window_title', videoSource, '-f', 'v4l2', '-i', videoSource];
+}
+export function playWebcam(videoSource, audioSource) {
+    if (!ffmpegCommand) {
+        throw new Error('Cannot play the webcam: ffmpeg not found on this host');
+    }
+    const ffplayCommand = path.isAbsolute(ffmpegCommand) ? path.join(path.dirname(ffmpegCommand), path.basename(ffmpegCommand).replace(/^ffmpeg/i, 'ffplay')) : 'ffplay';
+    const args = getPlayWebcamArgs(videoSource, audioSource);
+    log.debug(`Spawning ffplay: ${ffplayCommand} ${args.map(redactSource).join(' ')}`);
+    return spawn(ffplayCommand, args);
+}
+export async function installFfmpeg() {
+    if (process.platform !== 'linux') {
+        log.warn(`Cannot install ffmpeg: unsupported platform ${process.platform}`);
+        return false;
+    }
+    if (process.getuid?.() !== 0) {
+        log.warn('Cannot install ffmpeg: root privileges are required');
+        return false;
+    }
+    try {
+        if (await isRunnable('apk')) {
+            await runProbe('apk', ['add', '--no-cache', 'ffmpeg']);
+        }
+        else if (await isRunnable('apt-get')) {
+            await runProbe('apt-get', ['update']);
+            await runProbe('env', ['DEBIAN_FRONTEND=noninteractive', 'apt-get', 'install', '-y', '--no-install-recommends', 'ffmpeg']);
+        }
+        else {
+            log.warn('Cannot install ffmpeg: no supported package manager found (apk, apt-get)');
+            return false;
+        }
+    }
+    catch (error) {
+        log.error(`Failed to install ffmpeg: ${getErrorMessage(error)}`);
+        return false;
+    }
+    ffmpegCommand = await resolveFfmpeg();
+    log.info(ffmpegCommand ? `Installed ffmpeg: ${ffmpegCommand}` : 'ffmpeg was installed but could not be resolved');
+    return ffmpegCommand !== undefined;
+}

package/dist/frontend.d.ts

@@ -27,6 +27,7 @@ export declare class Frontend extends EventEmitter<FrontendEvents> {
     private serverFetchTimeout;
     private readonly debug;
     private readonly verbose;
+    private readonly diagnostic;
     readonly readOnly: boolean;
     readonly shellyBoard: boolean;
     shellySysUpdate: boolean;

package/dist/frontend.js

@@ -22,6 +22,7 @@ import { BroadcastServer } from '@matterbridge/thread/server';
 import { MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_DIAGNOSTIC_FILE, MATTERBRIDGE_HISTORY_FILE, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, } from '@matterbridge/types';
 import { isBun } from '@matterbridge/utils/bun';
 import { getParameter, hasParameter } from '@matterbridge/utils/cli';
+import { writeDiagnostic } from '@matterbridge/utils/diagnostic';
 import { getEnumDescription } from '@matterbridge/utils/enum';
 import { getErrorMessage, inspectError, logError } from '@matterbridge/utils/error';
 import { formatBytes, formatPercent, formatUptime } from '@matterbridge/utils/format';
@@ -50,6 +51,7 @@ export class Frontend extends EventEmitter {
     serverFetchTimeout = 2000;
     debug = hasParameter('debug') || hasParameter('verbose');
     verbose = hasParameter('verbose');
+    diagnostic = hasParameter('diagnostic');
     readOnly = hasParameter('readonly') || hasParameter('shelly');
     shellyBoard = hasParameter('shelly');
     shellySysUpdate = false;
@@ -1780,13 +1782,24 @@ export class Frontend extends EventEmitter {
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: matter });
             }
             else if (data.method === '/api/settings') {
-                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: this.getApiSettings() });
+                const start = performance.now();
+                const settings = this.getApiSettings();
+                if (this.diagnostic)
+                    writeDiagnostic(`Frontend:${data.sender}`, `getApiSettings() took ${(performance.now() - start).toFixed(2)} ms`);
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: settings });
             }
             else if (data.method === '/api/plugins') {
-                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: this.getApiPlugins() });
+                const start = performance.now();
+                const plugins = this.getApiPlugins();
+                if (this.diagnostic)
+                    writeDiagnostic(`Frontend:${data.sender}`, `getApiPlugins() took ${(performance.now() - start).toFixed(2)} ms`);
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: plugins });
             }
             else if (data.method === '/api/devices') {
+                const start = performance.now();
                 const devices = this.getApiDevices(isValidString(data.params.pluginName) ? data.params.pluginName : undefined);
+                if (this.diagnostic)
+                    writeDiagnostic(`Frontend:${data.sender}`, `getApiDevices() took ${(performance.now() - start).toFixed(2)} ms`);
                 sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: devices });
             }
             else if (data.method === '/api/clusters') {
@@ -1798,15 +1811,18 @@ export class Frontend extends EventEmitter {
                     sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Wrong parameter endpoint in /api/clusters' });
                     return;
                 }
-                const response = this.getClusters(data.params.plugin, data.params.endpoint, data.params.serialNumber, data.params.uniqueId);
-                if (response) {
+                const start = performance.now();
+                const clusters = this.getClusters(data.params.plugin, data.params.endpoint, data.params.serialNumber, data.params.uniqueId);
+                if (this.diagnostic)
+                    writeDiagnostic(`Frontend:${data.sender}`, `getClusters() took ${(performance.now() - start).toFixed(2)} ms`);
+                if (clusters) {
                     sendResponse({
                         id: data.id,
                         method: data.method,
                         src: 'Matterbridge',
                         dst: data.src,
                         success: true,
-                        response,
+                        response: clusters,
                     });
                 }
                 else {
@@ -1823,8 +1839,11 @@ export class Frontend extends EventEmitter {
                     sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Plugin not found in /api/select/devices' });
                     return;
                 }
-                const selectDeviceValues = !plugin.platform ? [] : plugin.platform.getSelectDevices().toSorted((keyA, keyB) => keyA.name.localeCompare(keyB.name));
-                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: selectDeviceValues });
+                const start = performance.now();
+                const selectDevices = !plugin.platform ? [] : plugin.platform.getSelectDevices().toSorted((keyA, keyB) => keyA.name.localeCompare(keyB.name));
+                if (this.diagnostic)
+                    writeDiagnostic(`Frontend:${data.sender}`, `getSelectDevices() took ${(performance.now() - start).toFixed(2)} ms`);
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: selectDevices });
             }
             else if (data.method === '/api/select/entities') {
                 if (!isValidString(data.params.plugin, 10)) {
@@ -1836,8 +1855,11 @@ export class Frontend extends EventEmitter {
                     sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, error: 'Plugin not found in /api/select/entities' });
                     return;
                 }
-                const selectEntityValues = !plugin.platform ? [] : plugin.platform.getSelectEntities().toSorted((keyA, keyB) => keyA.name.localeCompare(keyB.name));
-                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: selectEntityValues });
+                const start = performance.now();
+                const selectEntities = !plugin.platform ? [] : plugin.platform.getSelectEntities().toSorted((keyA, keyB) => keyA.name.localeCompare(keyB.name));
+                if (this.diagnostic)
+                    writeDiagnostic(`Frontend:${data.sender}`, `getSelectEntities() took ${(performance.now() - start).toFixed(2)} ms`);
+                sendResponse({ id: data.id, method: data.method, src: 'Matterbridge', dst: data.src, success: true, response: selectEntities });
             }
             else if (data.method === '/api/action') {
                 const localData = data;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.13-dev-20261003-ba58ee6",
+  "version": "3.10.13-dev-20261005-49e0dbd",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -136,10 +136,10 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/dgram": "3.10.13-dev-20261003-ba58ee6",
-    "@matterbridge/thread": "3.10.13-dev-20261003-ba58ee6",
-    "@matterbridge/types": "3.10.13-dev-20261003-ba58ee6",
-    "@matterbridge/utils": "3.10.13-dev-20261003-ba58ee6",
+    "@matterbridge/dgram": "3.10.13-dev-20261005-49e0dbd",
+    "@matterbridge/thread": "3.10.13-dev-20261005-49e0dbd",
+    "@matterbridge/types": "3.10.13-dev-20261005-49e0dbd",
+    "@matterbridge/utils": "3.10.13-dev-20261005-49e0dbd",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.7.0",