matterbridge 3.3.3 → 3.3.4-dev-20251020-df40d12

package/dist/utils/jestHelpers.js

@@ -1,68 +1,25 @@
-/**
- * @description This file contains the Jest helpers.
- * @file src/helpers.test.ts
- * @author Luca Liguori
- * @created 2025-09-03
- * @version 1.0.5
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import { rmSync } from 'node:fs';
 import { inspect } from 'node:util';
 import path from 'node:path';
-// Imports from Matterbridge
 import { jest } from '@jest/globals';
-import { DeviceTypeId, Endpoint, Environment, ServerNode, ServerNodeStore, VendorId, LogFormat as MatterLogFormat, LogLevel as MatterLogLevel, Lifecycle } from '@matter/main';
-import { AggregatorEndpoint, RootEndpoint } from '@matter/main/endpoints';
-import { MdnsService } from '@matter/main/protocol';
 import { AnsiLogger } from 'node-ansi-logger';
-// Imports from a plugin
-/*
-import { jest } from '@jest/globals';
-import { DeviceTypeId, Endpoint, Environment, MdnsService, ServerNode, ServerNodeStore, VendorId, LogFormat as MatterLogFormat, LogLevel as MatterLogLevel, Lifecycle } from 'matterbridge/matter';
-import { RootEndpoint, AggregatorEndpoint } from 'matterbridge/matter/endpoints';
-import { AnsiLogger } from 'matterbridge/logger';
-*/
+import '@matter/nodejs';
+import { LogFormat as MatterLogFormat, LogLevel as MatterLogLevel, Environment, Lifecycle } from '@matter/general';
+import { DeviceTypeId, VendorId } from '@matter/types';
+import { MdnsService } from '@matter/protocol';
+import { ServerNode, Endpoint, ServerNodeStore } from '@matter/node';
+import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
+import { RootEndpoint } from '@matter/node/endpoints/root';
 export let loggerLogSpy;
 export let consoleLogSpy;
 export let consoleDebugSpy;
 export let consoleInfoSpy;
 export let consoleWarnSpy;
 export let consoleErrorSpy;
-/**
- * Setup the Jest environment:
- * - it will remove any existing home directory
- * - setup the spies for logging
- *
- * @param {string} name The name of the test suite.
- * @param {boolean} debug If true, the logging is not mocked.
- *
- * ```typescript
- * import { consoleDebugSpy, consoleErrorSpy, consoleInfoSpy, consoleLogSpy, consoleWarnSpy, loggerLogSpy, setDebug, setupTest } from './jestHelpers.js';
- *
- * // Setup the test environment
- * setupTest(NAME, false);
- *
- * ```
- */
 export function setupTest(name, debug = false) {
     expect(name).toBeDefined();
     expect(typeof name).toBe('string');
-    expect(name.length).toBeGreaterThanOrEqual(4); // avoid accidental deletion of short paths like "/" or "C:\"
-    // Cleanup any existing home directory
+    expect(name.length).toBeGreaterThanOrEqual(4);
     rmSync(path.join('jest', name), { recursive: true, force: true });
     if (debug) {
         loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
@@ -81,11 +38,6 @@ export function setupTest(name, debug = false) {
         consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
     }
 }
-/**
- * Set or unset the debug mode.
- *
- * @param {boolean} debug If true, the logging is not mocked.
- */
 export function setDebug(debug) {
     if (debug) {
         loggerLogSpy.mockRestore();
@@ -110,21 +62,11 @@ export function setDebug(debug) {
         consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
     }
 }
-/**
- * Create a matter Environment for testing:
- * - it will remove any existing home directory
- * - setup the matter environment with homeDir, debug logging and ANSI format
- *
- * @param {string} homeDir Home directory for the environment.
- * @returns {Environment}  The default matter environment.
- */
 export function createTestEnvironment(homeDir) {
     expect(homeDir).toBeDefined();
     expect(typeof homeDir).toBe('string');
-    expect(homeDir.length).toBeGreaterThanOrEqual(4); // avoid accidental deletion of short paths like "/" or "C:\"
-    // Cleanup any existing home directory
+    expect(homeDir.length).toBeGreaterThanOrEqual(4);
     rmSync(homeDir, { recursive: true, force: true });
-    // Setup the matter environment
     const environment = Environment.default;
     environment.vars.set('log.level', MatterLogLevel.DEBUG);
     environment.vars.set('log.format', MatterLogFormat.ANSI);
@@ -133,18 +75,6 @@ export function createTestEnvironment(homeDir) {
     environment.vars.set('runtime.exitcode', false);
     return environment;
 }
-/**
- * Advance the Node.js event loop deterministically to allow chained asynchronous work (Promises scheduled in
- * microtasks and follow‑up macrotasks) to complete inside tests without adding arbitrary long timeouts.
- *
- * NOTE: This does not guarantee OS level network IO completion—only JavaScript task queue progression inside the
- *       current process.
- *
- * @param {number} ticks       Number of macrotask (setImmediate) turns to yield (default 3).
- * @param {number} microTurns  Number of microtask drains (Promise.resolve chains) after macrotask yielding (default 10).
- * @param {number} pause       Final timer delay in ms; set 0 to disable (default 100ms).
- * @returns {Promise<void>}        Resolves after the requested event loop advancement has completed.
- */
 export async function flushAsync(ticks = 3, microTurns = 10, pause = 100) {
     for (let i = 0; i < ticks; i++)
         await new Promise((resolve) => setImmediate(resolve));
@@ -153,19 +83,6 @@ export async function flushAsync(ticks = 3, microTurns = 10, pause = 100) {
     if (pause)
         await new Promise((resolve) => setTimeout(resolve, pause));
 }
-/**
- * Flush (await) the lazy endpoint number persistence mechanism used by matter.js.
- *
- * Background:
- *  assignNumber() batches persistence (store.saveNumber + updating __nextNumber__) via an internal promise (#numbersPersisted).
- *  Calling endpointStores.close() waits for the current batch only. If new endpoints were added in the same macrotask
- *  cycle additional micro/macro turns might be needed to ensure the batch started. We defensively yield macrotasks
- *  (setImmediate) and then await close() multiple rounds.
- *
- * @param {ServerNode} targetServer  The server whose endpoint numbering persistence should be flushed.
- * @param {number} rounds Number of macrotask + close cycles to run (2 is usually sufficient; 1 often works).
- * @returns {Promise<void>}          Resolves when pending number persistence batches have completed.
- */
 export async function flushAllEndpointNumberPersistence(targetServer, rounds = 2) {
     const nodeStore = targetServer.env.get(ServerNodeStore);
     for (let i = 0; i < rounds; i++) {
@@ -173,12 +90,6 @@ export async function flushAllEndpointNumberPersistence(targetServer, rounds = 2
         await nodeStore.endpointStores.close();
     }
 }
-/**
- * Collect all endpoints in the server endpoint tree (root -> descendants).
- *
- * @param {Endpoint} root  Root endpoint (typically the ServerNode root endpoint cast as Endpoint).
- * @returns {Endpoint[]}   Flat array including the root and every descendant once.
- */
 function collectAllEndpoints(root) {
     const list = [];
     const walk = (ep) => {
@@ -192,26 +103,14 @@ function collectAllEndpoints(root) {
     walk(root);
     return list;
 }
-/**
- * Assert that every endpoint attached to the server has an assigned and (batch-)persisted endpoint number.
- *
- * This waits for any outstanding number persistence batch (endpointStores.close()), then traverses the endpoint
- * graph and asserts:
- *  - Root endpoint: number is 0 (allowing undefined to coerce to 0 via nullish coalescing check).
- *  - All other endpoints: number > 0.
- *
- * @param {ServerNode} targetServer The server whose endpoint numbers are verified.
- * @returns {Promise<void>}         Resolves when assertions complete.
- */
 export async function assertAllEndpointNumbersPersisted(targetServer) {
     const nodeStore = targetServer.env.get(ServerNodeStore);
-    // Ensure any pending persistence finished (flush any in-flight batch promise)
     await nodeStore.endpointStores.close();
     const all = collectAllEndpoints(targetServer);
     for (const ep of all) {
         const store = nodeStore.storeForEndpoint(ep);
         if (ep.maybeNumber === 0) {
-            expect(store.number ?? 0).toBe(0); // root
+            expect(store.number ?? 0).toBe(0);
         }
         else {
             expect(store.number).toBeGreaterThan(0);
@@ -219,15 +118,7 @@ export async function assertAllEndpointNumbersPersisted(targetServer) {
     }
     return all.length;
 }
-/**
- * Start a matter server node for testing.
- *
- * @param {string} name Name of the server (used for logging and product description).
- * @param {number} port TCP port to listen on.
- * @returns {Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>} Resolves to an array containing the created ServerNode and its AggregatorNode.
- */
 export async function startServerNode(name, port) {
-    // Create the server node
     const server = await ServerNode.create({
         id: name + 'ServerNode',
         productDescription: {
@@ -236,7 +127,6 @@ export async function startServerNode(name, port) {
             vendorId: VendorId(0xfff1),
             productId: 0x8000,
         },
-        // Provide defaults for the BasicInformation cluster on the Root endpoint
         basicInformation: {
             vendorId: VendorId(0xfff1),
             vendorName: 'Matterbridge',
@@ -253,26 +143,21 @@ export async function startServerNode(name, port) {
     });
     expect(server).toBeDefined();
     expect(server.lifecycle.isReady).toBeTruthy();
-    // Create the aggregator node
     const aggregator = new Endpoint(AggregatorEndpoint, {
         id: name + 'AggregatorNode',
     });
     expect(aggregator).toBeDefined();
-    // Add the aggregator to the server
     await server.add(aggregator);
     expect(server.parts.has(aggregator.id)).toBeTruthy();
     expect(server.parts.has(aggregator)).toBeTruthy();
     expect(aggregator.lifecycle.isReady).toBeTruthy();
-    // Run the server
     expect(server.lifecycle.isOnline).toBeFalsy();
-    // Wait for the server to be online
     await new Promise((resolve) => {
         server.lifecycle.online.on(async () => {
             resolve();
         });
         server.start();
     });
-    // Check if the server is online
     expect(server.lifecycle.isReady).toBeTruthy();
     expect(server.lifecycle.isOnline).toBeTruthy();
     expect(server.lifecycle.isCommissioned).toBeFalsy();
@@ -284,41 +169,21 @@ export async function startServerNode(name, port) {
     expect(aggregator.lifecycle.isPartsReady).toBeTruthy();
     expect(aggregator.lifecycle.hasId).toBeTruthy();
     expect(aggregator.lifecycle.hasNumber).toBeTruthy();
-    // Ensure the queue is empty and pause 100ms
     await flushAsync();
     return [server, aggregator];
 }
-/**
- * Stop a matter server node.
- *
- * @param {ServerNode<ServerNode.RootEndpoint>} server The server to stop.
- * @returns {Promise<void>} Resolves when the server has stopped.
- */
 export async function stopServerNode(server) {
-    // Flush any pending endpoint number persistence
     await flushAllEndpointNumberPersistence(server);
-    // Ensure all endpoint numbers are persisted
     await assertAllEndpointNumbersPersisted(server);
-    // Stop the server
     expect(server).toBeDefined();
     expect(server.lifecycle.isReady).toBeTruthy();
     expect(server.lifecycle.isOnline).toBeTruthy();
     await server.close();
     expect(server.lifecycle.isReady).toBeTruthy();
     expect(server.lifecycle.isOnline).toBeFalsy();
-    // stop the mDNS service
     await server.env.get(MdnsService)[Symbol.asyncDispose]();
-    // Ensure the queue is empty and pause 100ms
     await flushAsync();
 }
-/**
- * Add a device (endpoint) to a matter server node or an aggregator.
- *
- * @param {ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>} owner The server or aggregator to add the device to.
- * @param {Endpoint} device The device to add.
- * @param {number} pause The pause time in milliseconds after addition (default 10ms).
- * @returns {Promise<void>} Resolves when the device has been added and is ready.
- */
 export async function addDevice(owner, device, pause = 10) {
     expect(owner).toBeDefined();
     expect(device).toBeDefined();
@@ -331,7 +196,6 @@ export async function addDevice(owner, device, pause = 10) {
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : error;
         const errorInspect = inspect(error, { depth: 10 });
-        // eslint-disable-next-line no-console
         console.error(`Error adding device ${device.maybeId}.${device.maybeNumber}: ${errorMessage}\nstack: ${errorInspect}`);
         return false;
     }
@@ -345,14 +209,6 @@ export async function addDevice(owner, device, pause = 10) {
     await flushAsync(1, 1, pause);
     return true;
 }
-/**
- * Delete a device (endpoint) from a matter server node or an aggregator.
- *
- * @param {ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>} owner The server or aggregator to remove the device from.
- * @param {Endpoint} device The device to remove.
- * @param {number} pause The pause time in milliseconds after deletion (default 10ms).
- * @returns {Promise<void>} Resolves when the device has been removed and is no longer ready.
- */
 export async function deleteDevice(owner, device, pause = 10) {
     expect(owner).toBeDefined();
     expect(device).toBeDefined();
@@ -365,7 +221,6 @@ export async function deleteDevice(owner, device, pause = 10) {
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : error;
         const errorInspect = inspect(error, { depth: 10 });
-        // eslint-disable-next-line no-console
         console.error(`Error deleting device ${device.maybeId}.${device.maybeNumber}: ${errorMessage}\nstack: ${errorInspect}`);
         return false;
     }
@@ -379,4 +234,3 @@ export async function deleteDevice(owner, device, pause = 10) {
     await flushAsync(1, 1, pause);
     return true;
 }
-//# sourceMappingURL=jestHelpers.js.map

package/dist/utils/network.js

@@ -1,34 +1,5 @@
-/**
- * @description This file contains the network functions.
- * @file network.ts
- * @author Luca Liguori
- * @created 2024-02-17
- * @version 1.0.1
- * @license Apache-2.0
- *
- * Copyright 2024, 2025, 2026 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// Node.js modules
 import os from 'node:os';
-// AnsiLogger module
 import { AnsiLogger, BLUE, CYAN, nf } from 'node-ansi-logger';
-/**
- * Retrieves the first non-internal network interface details.
- *
- * @returns {os.NetworkInterfaceInfo | undefined} The details of the selected network interface, or undefined if not found.
- */
 export function getInterfaceDetails() {
     const result = { interfaceName: '', ipv4Address: undefined, ipv6Address: undefined, macAddress: undefined };
     for (const [interfaceName, interfaceDetails] of Object.entries(os.networkInterfaces())) {
@@ -50,11 +21,6 @@ export function getInterfaceDetails() {
     if (result.interfaceName)
         return result;
 }
-/**
- * Retrieves the first non-internal network interface name.
- *
- * @returns {string | undefined} The name of the selected network interface, or undefined if not found.
- */
 export function getInterfaceName() {
     for (const [interfaceName, interfaceDetails] of Object.entries(os.networkInterfaces())) {
         if (!interfaceName || !interfaceDetails || interfaceDetails.length === 0)
@@ -65,11 +31,6 @@ export function getInterfaceName() {
         }
     }
 }
-/**
- * Retrieves the IPv4 address of the first non-internal network interface.
- *
- * @returns {string | undefined} The IPv4 address of the selected network interface, or undefined if not found.
- */
 export function getIpv4InterfaceAddress() {
     for (const [interfaceName, interfaceDetails] of Object.entries(os.networkInterfaces())) {
         if (!interfaceName || !interfaceDetails || interfaceDetails.length === 0)
@@ -80,11 +41,6 @@ export function getIpv4InterfaceAddress() {
         }
     }
 }
-/**
- * Retrieves the IPv6 address of the first non-internal network interface.
- *
- * @returns {string | undefined} The IPv4 address of the selected network interface, or undefined if not found.
- */
 export function getIpv6InterfaceAddress() {
     for (const [interfaceName, interfaceDetails] of Object.entries(os.networkInterfaces())) {
         if (!interfaceName || !interfaceDetails || interfaceDetails.length === 0)
@@ -95,11 +51,6 @@ export function getIpv6InterfaceAddress() {
         }
     }
 }
-/**
- * Retrieves the mac address of the first non-internal network interface.
- *
- * @returns {string | undefined} The mac address, or undefined if not found.
- */
 export function getMacAddress() {
     for (const [interfaceName, interfaceDetails] of Object.entries(os.networkInterfaces())) {
         if (!interfaceName || !interfaceDetails || interfaceDetails.length === 0)
@@ -110,14 +61,9 @@ export function getMacAddress() {
         }
     }
 }
-/**
- * Logs the available network interfaces and their details.
- *
- * @returns {void}
- */
 export function logInterfaces() {
-    const log = new AnsiLogger({ logName: 'MatterbridgeUtils', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: "info" /* LogLevel.INFO */ });
-    log.logLevel = "info" /* LogLevel.INFO */;
+    const log = new AnsiLogger({ logName: 'MatterbridgeUtils', logTimestampFormat: 4, logLevel: "info" });
+    log.logLevel = "info";
     log.logName = 'LogInterfaces';
     log.info('Available Network Interfaces:');
     const availableAddresses = Object.entries(os.networkInterfaces());
@@ -131,36 +77,16 @@ export function logInterfaces() {
         }
     }
 }
-/**
- * Resolves the given hostname to an IP address.
- *
- * @param {string} hostname - The hostname to resolve.
- * @param {0 | 4 | 6} [family] - The address family to use (0 for any, 4 for IPv4, 6 for IPv6). Default is 4.
- * @returns {Promise<string | null>} - A promise that resolves to the IP address or null if not found.
- *
- * @remarks
- * This function uses DNS lookup to resolve the hostname, which can take some time to complete.
- */
 export async function resolveHostname(hostname, family = 4) {
     const dns = await import('node:dns');
     try {
-        const addresses = await dns.promises.lookup(hostname.toLowerCase() /* + '.local'*/, { family });
+        const addresses = await dns.promises.lookup(hostname.toLowerCase(), { family });
         return addresses.address;
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
     }
     catch (error) {
         return null;
     }
 }
-/**
- * Retrieves the version of an npm package from the npm registry.
- *
- * @param {string} packageName - The name of the npm package.
- * @param {string} [tag] - The tag of the package version to retrieve (default is 'latest').
- * @param {number} [timeout] - The timeout duration in milliseconds (default is 10000ms).
- * @returns {Promise<string>} A promise that resolves to the version string of the package.
- * @throws {Error} If the request fails or the tag is not found.
- */
 export async function getNpmPackageVersion(packageName, tag = 'latest', timeout = 10000) {
     const https = await import('node:https');
     return new Promise((resolve, reject) => {
@@ -174,7 +100,7 @@ export async function getNpmPackageVersion(packageName, tag = 'latest', timeout
             let data = '';
             if (res.statusCode !== 200) {
                 clearTimeout(timeoutId);
-                res.resume(); // Discard response data to close the socket properly
+                res.resume();
                 reject(new Error(`Failed to fetch data. Status code: ${res.statusCode}`));
                 return;
             }
@@ -185,7 +111,6 @@ export async function getNpmPackageVersion(packageName, tag = 'latest', timeout
                 clearTimeout(timeoutId);
                 try {
                     const jsonData = JSON.parse(data);
-                    // console.log(`Package ${packageName} tag ${tag}`, jsonData);
                     const version = jsonData['dist-tags']?.[tag];
                     if (version) {
                         resolve(version);
@@ -205,15 +130,6 @@ export async function getNpmPackageVersion(packageName, tag = 'latest', timeout
         });
     });
 }
-/**
- * Retrieves a file from the public directory of the Matterbridge GitHub repository.
- *
- * @param {string} branch - The branch from which to fetch the file.
- * @param {string} file - The file path to fetch.
- * @param {number} [timeout] - The timeout duration in milliseconds (default is 10000ms).
- * @returns {Promise<Record<string, boolean | string | number>>} A promise that resolves to the parsed JSON object from the file.
- * @throws {Error} If the request fails or the JSON parsing fails.
- */
 export async function getGitHubUpdate(branch, file, timeout = 10000) {
     const https = await import('node:https');
     return new Promise((resolve, reject) => {
@@ -227,7 +143,7 @@ export async function getGitHubUpdate(branch, file, timeout = 10000) {
             let data = '';
             if (res.statusCode !== 200) {
                 clearTimeout(timeoutId);
-                res.resume(); // Discard response data to close the socket properly
+                res.resume();
                 reject(new Error(`Failed to fetch data. Status code: ${res.statusCode}`));
                 return;
             }
@@ -245,18 +161,12 @@ export async function getGitHubUpdate(branch, file, timeout = 10000) {
                 }
             });
         });
-        // istanbul ignore next
         req.on('error', (error) => {
             clearTimeout(timeoutId);
             reject(new Error(`Request failed: ${error instanceof Error ? error.message : error}`));
         });
     });
 }
-/**
- * Retrieves the path to the global Node.js modules directory.
- *
- * @returns {Promise<string>} A promise that resolves to the path of the global Node.js modules directory.
- */
 export async function getGlobalNodeModules() {
     const { exec } = await import('node:child_process');
     return new Promise((resolve, reject) => {
@@ -270,42 +180,3 @@ export async function getGlobalNodeModules() {
         });
     });
 }
-/**
- * Function to format bytes to KB, MB, or GB
- *
- * @param {number} bytes - The number of bytes to format
- * @returns {string} The formatted memory usage string
- */
-export function formatMemoryUsage(bytes) {
-    if (bytes >= 1024 ** 3) {
-        return `${(bytes / 1024 ** 3).toFixed(2)} GB`;
-    }
-    else if (bytes >= 1024 ** 2) {
-        return `${(bytes / 1024 ** 2).toFixed(2)} MB`;
-    }
-    else {
-        return `${(bytes / 1024).toFixed(2)} KB`;
-    }
-}
-/**
- * Function to format system uptime with only the most significant unit
- *
- * @param {number} seconds - The number of seconds to format
- * @returns {string} The formatted uptime string
- */
-export function formatOsUpTime(seconds) {
-    if (seconds >= 86400) {
-        const days = Math.floor(seconds / 86400);
-        return `${days} day${days !== 1 ? 's' : ''}`;
-    }
-    if (seconds >= 3600) {
-        const hours = Math.floor(seconds / 3600);
-        return `${hours} hour${hours !== 1 ? 's' : ''}`;
-    }
-    if (seconds >= 60) {
-        const minutes = Math.floor(seconds / 60);
-        return `${minutes} minute${minutes !== 1 ? 's' : ''}`;
-    }
-    return `${seconds} second${seconds !== 1 ? 's' : ''}`;
-}
-//# sourceMappingURL=network.js.map

package/dist/utils/spawn.js

@@ -1,52 +1,12 @@
-/**
- * @description This file contains the spawn functions.
- * @file spawn.ts
- * @author Luca Liguori
- * @created 2025-02-16
- * @version 1.1.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import { hasParameter } from './commandLine.js';
-/**
- * Spawns a child process with the given command and arguments.
- *
- * @param {Matterbridge} matterbridge - The Matterbridge instance to use for logging and sending messages.
- * @param {string} command - The command to execute.
- * @param {string[]} args - The arguments to pass to the command (default: []).
- * @param {'install' | 'uninstall'} packageCommand - The package command being executed (e.g., 'install', 'uninstall').
- * @param {string} [packageName] - The name of the package being installed (optional).
- * @returns {Promise<boolean>} A promise that resolves when the child process exits successfully, or rejects if there is an error.
- */
 export async function spawnCommand(matterbridge, command, args, packageCommand, packageName) {
     const { spawn } = await import('node:child_process');
-    /*
-     *  npm > npm.cmd on windows
-     *  cmd.exe ['dir'] on windows
-     */
     const cmdLine = command + ' ' + args.join(' ');
     if (process.platform === 'win32' && command === 'npm') {
-        // Must be spawn('cmd.exe', ['/c', 'npm -g install <package>']);
         const argstring = 'npm ' + args.join(' ');
         args.splice(0, args.length, '/c', argstring);
         command = 'cmd.exe';
     }
-    // Decide when using sudo on linux and macOS
-    // When you need sudo: Spawn stderr: npm error Error: EACCES: permission denied
-    // When you don't need sudo: Failed to start child process "npm install -g matterbridge-eve-door": spawn sudo ENOENT
     if (hasParameter('sudo') || (process.platform !== 'win32' && command === 'npm' && !hasParameter('docker') && !hasParameter('nosudo'))) {
         args.unshift(command);
         command = 'sudo';
@@ -66,7 +26,6 @@ export async function spawnCommand(matterbridge, command, args, packageCommand,
             reject(err);
         });
         childProcess.on('close', (code, signal) => {
-            // matterbridge.frontend.wssSendLogMessage('spawn', matterbridge.log.now(), 'Matterbridge:spawn', `child process closed with code ${code} and signal ${signal}`);
             if (code === 0) {
                 matterbridge.log.debug(`Child process "${cmdLine}" closed with code ${code} and signal ${signal}`);
                 matterbridge.frontend.wssSendLogMessage('spawn', matterbridge.log.now(), 'Matterbridge:spawn-exit-success', 'Child process closed');
@@ -79,7 +38,6 @@ export async function spawnCommand(matterbridge, command, args, packageCommand,
             }
         });
         childProcess.on('exit', (code, signal) => {
-            // matterbridge.frontend.wssSendLogMessage('spawn', matterbridge.log.now(), 'Matterbridge:spawn', `child process exited with code ${code} and signal ${signal}`);
             if (code === 0) {
                 matterbridge.log.debug(`Child process "${cmdLine}" exited with code ${code} and signal ${signal}`);
                 matterbridge.frontend.wssSendLogMessage('spawn', matterbridge.log.now(), 'Matterbridge:spawn-exit-success', 'Child process exited');
@@ -104,20 +62,6 @@ export async function spawnCommand(matterbridge, command, args, packageCommand,
                     matterbridge.frontend.wssSendLogMessage('spawn', matterbridge.log.now(), 'Matterbridge:spawn', line);
                 }
             });
-            /*
-            childProcess.stdout.on('close', () => {
-              matterbridge.log.debug(`Spawn output (stdout): closed`);
-              resolve(true);
-            });
-            childProcess.stdout.on('end', () => {
-              matterbridge.log.debug(`Spawn output (stdout): ended`);
-              resolve(true);
-            });
-            childProcess.stdout.on('error', () => {
-              matterbridge.log.debug(`Spawn output (stdout): error`);
-              resolve(true);
-            });
-            */
         }
         if (childProcess.stderr) {
             childProcess.stderr.on('data', (data) => {
@@ -128,21 +72,6 @@ export async function spawnCommand(matterbridge, command, args, packageCommand,
                     matterbridge.frontend.wssSendLogMessage('spawn', matterbridge.log.now(), 'Matterbridge:spawn', line);
                 }
             });
-            /*
-            childProcess.stderr.on('close', () => {
-              matterbridge.log.debug(`Spawn verbose (stderr): closed`);
-              resolve(true);
-            });
-            childProcess.stderr.on('end', () => {
-              matterbridge.log.debug(`Spawn verbose (stderr): ended`);
-              resolve(true);
-            });
-            childProcess.stderr.on('error', () => {
-              matterbridge.log.debug(`Spawn verbose (stderr): error`);
-              resolve(true);
-            });
-            */
         }
     });
 }
-//# sourceMappingURL=spawn.js.map