homebridge 2.0.0-beta.44 → 2.0.0-beta.46

package/dist/server.js

@@ -13,20 +13,11 @@ import { PluginManager } from './pluginManager.js';
 import { User } from './user.js';
 import { validMacAddress } from './util/mac.js';
 const log = Logger.internal;
-// eslint-disable-next-line no-restricted-syntax
+const matterLogger = Logger.withPrefix('Matter/MainManager');
 export var ServerStatus;
 (function (ServerStatus) {
-    /**
-     * When the server is starting up
-     */
     ServerStatus["PENDING"] = "pending";
-    /**
-     * When the server is online and has published the main bridge
-     */
     ServerStatus["OK"] = "ok";
-    /**
-     * When the server is shutting down
-     */
     ServerStatus["DOWN"] = "down";
 })(ServerStatus || (ServerStatus = {}));
 export class Server {
@@ -37,26 +28,19 @@ export class Server {
     ipcService;
     externalPortService;
     config;
-    // used to keep track of child bridges
-    // Key is HAP username (MAC address)
     childBridges = new Map();
-    // Matter bridge manager (handles Matter server lifecycle)
-    // Made optional to handle initialization order - gets created in constructor after first setServerStatus call
     matterManager;
-    // current server status
-    serverStatus = "pending" /* ServerStatus.PENDING */;
+    matterMonitoringActive = false;
+    matterMonitoringClients = 0;
+    serverStatus = "pending";
     constructor(options = {}) {
         this.options = options;
         this.config = Server.loadConfig();
-        // object we feed to Plugins and BridgeService
         this.api = new HomebridgeAPI();
         this.ipcService = new IpcService();
-        // Collect all configured Matter ports to avoid conflicts
         const configuredMatterPorts = MatterBridgeManager.collectConfiguredMatterPorts(this.config);
         this.externalPortService = new ExternalPortService(this.config.ports, this.config.matterPorts, configuredMatterPorts);
-        // set status to pending
-        this.setServerStatus("pending" /* ServerStatus.PENDING */);
-        // create new plugin manager
+        this.setServerStatus("pending");
         const pluginManagerOptions = {
             activePlugins: this.config.plugins,
             disabledPlugins: this.config.disabledPlugins,
@@ -64,47 +48,27 @@ export class Server {
             strictPluginResolution: options.strictPluginResolution,
         };
         this.pluginManager = new PluginManager(this.api, pluginManagerOptions);
-        // create new bridge service
         const bridgeConfig = {
             cachedAccessoriesDir: User.cachedAccessoryPath(),
             cachedAccessoriesItemName: 'cachedAccessories',
         };
-        // shallow copy the homebridge options to the bridge options object
         Object.assign(bridgeConfig, this.options);
         this.bridgeService = new BridgeService(this.api, this.pluginManager, this.externalPortService, bridgeConfig, this.config.bridge);
-        // Create Matter bridge manager
         this.matterManager = new MatterBridgeManager(this.config, this.api, this.externalPortService, this.pluginManager, this.options);
-        // Set manager reference on API for getAccessoryState
         this.api._setMatterManager(this.matterManager);
-        // Handle platform accessory registration
-        this.api.on("registerPlatformAccessories" /* InternalAPIEvent.REGISTER_PLATFORM_ACCESSORIES */, this.handleRegisterPlatformAccessories.bind(this));
-        this.api.on("unregisterPlatformAccessories" /* InternalAPIEvent.UNREGISTER_PLATFORM_ACCESSORIES */, this.handleUnregisterPlatformAccessories.bind(this));
-        // Handle external accessories (cameras, etc.)
-        this.api.on("publishExternalAccessories" /* InternalAPIEvent.PUBLISH_EXTERNAL_ACCESSORIES */, this.handlePublishExternalAccessories.bind(this));
-        // Handle Matter accessory registration (matching HAP pattern)
-        this.api.on("publishExternalMatterAccessories" /* InternalAPIEvent.PUBLISH_EXTERNAL_MATTER_ACCESSORIES */, this.handlePublishExternalMatterAccessories.bind(this));
-        this.api.on("registerMatterPlatformAccessories" /* InternalAPIEvent.REGISTER_MATTER_PLATFORM_ACCESSORIES */, this.handleRegisterMatterPlatformAccessories.bind(this));
-        this.api.on("updateMatterPlatformAccessories" /* InternalAPIEvent.UPDATE_MATTER_PLATFORM_ACCESSORIES */, this.handleUpdateMatterPlatformAccessories.bind(this));
-        this.api.on("unregisterMatterPlatformAccessories" /* InternalAPIEvent.UNREGISTER_MATTER_PLATFORM_ACCESSORIES */, this.handleUnregisterMatterPlatformAccessories.bind(this));
-        this.api.on("unregisterExternalMatterAccessories" /* InternalAPIEvent.UNREGISTER_EXTERNAL_MATTER_ACCESSORIES */, this.handleUnregisterExternalMatterAccessories.bind(this));
-        this.api.on("updateMatterAccessoryState" /* InternalAPIEvent.UPDATE_MATTER_ACCESSORY_STATE */, this.handleUpdateMatterAccessoryState.bind(this));
-        // watch bridge events to check when server is online
-        this.bridgeService.bridge.on("advertised" /* AccessoryEventTypes.ADVERTISED */, () => {
-            this.setServerStatus("ok" /* ServerStatus.OK */);
+        this.api.on("registerPlatformAccessories", this.handleRegisterPlatformAccessories.bind(this));
+        this.api.on("unregisterPlatformAccessories", this.handleUnregisterPlatformAccessories.bind(this));
+        this.api.on("publishExternalAccessories", this.handlePublishExternalAccessories.bind(this));
+        this.bridgeService.bridge.on("advertised", () => {
+            this.setServerStatus("ok");
         });
-        // watch for the paired event to update the server status
-        this.bridgeService.bridge.on("paired" /* AccessoryEventTypes.PAIRED */, () => {
+        this.bridgeService.bridge.on("paired", () => {
             this.setServerStatus(this.serverStatus);
         });
-        // watch for the unpaired event to update the server status
-        this.bridgeService.bridge.on("unpaired" /* AccessoryEventTypes.UNPAIRED */, () => {
+        this.bridgeService.bridge.on("unpaired", () => {
             this.setServerStatus(this.serverStatus);
         });
     }
-    /**
-     * Set the current server status and update parent via IPC
-     * @param status
-     */
     setServerStatus(status) {
         this.serverStatus = status;
         const statusUpdate = {
@@ -116,18 +80,15 @@ export class Server {
             pin: this.config.bridge.pin,
             matter: this.matterManager?.getMatterStatus() ?? { enabled: false },
         };
-        this.ipcService.sendMessage("serverStatusUpdate" /* IpcOutgoingEvent.SERVER_STATUS_UPDATE */, statusUpdate);
+        this.ipcService.sendMessage("serverStatusUpdate", statusUpdate);
     }
     async start() {
         if (this.config.bridge.disableIpc !== true) {
             this.initializeIpcEventHandlers();
         }
         const promises = [];
-        // load the cached accessories
         await this.bridgeService.loadCachedPlatformAccessoriesFromDisk();
-        // initialize plugins
         await this.pluginManager.initializeInstalledPlugins();
-        // Initialize Matter server for main bridge if enabled
         await this.matterManager?.initialize();
         if (this.config.platforms.length > 0) {
             promises.push(...this.loadPlatforms());
@@ -135,78 +96,40 @@ export class Server {
         if (this.config.accessories.length > 0) {
             this.loadAccessories();
         }
-        // start child bridges
         for (const childBridge of this.childBridges.values()) {
             childBridge.start();
         }
-        // restore cached accessories
         this.bridgeService.restoreCachedPlatformAccessories();
         this.matterManager?.restoreCachedAccessories(this.options.keepOrphanedCachedAccessories ?? false);
         this.api.signalFinished();
-        // wait for all platforms to publish their accessories before we publish the bridge
         await Promise.all(promises)
             .then(() => this.publishBridge());
     }
     async teardown() {
         this.bridgeService.teardown();
-        // Teardown Matter servers (main bridge and external accessories)
         await this.matterManager?.teardown();
-        this.setServerStatus("down" /* ServerStatus.DOWN */);
+        this.setServerStatus("down");
     }
     publishBridge() {
         this.bridgeService.publishBridge();
         this.printSetupInfo(this.config.bridge.pin);
     }
     handlePublishExternalAccessories(accessories) {
-        // External accessories are published via HAP
-        // Plugins should use api.matter to register Matter accessories explicitly
         log.info(`Publishing ${accessories.length} external accessories`);
     }
-    /**
-     * Handle external Matter accessories - delegates to MatterBridgeManager
-     */
-    handlePublishExternalMatterAccessories(accessories, registrationId) {
-        this.matterManager?.handlePublishExternalAccessories(accessories, registrationId).catch((error) => {
-            log.error('Failed to publish external Matter accessories:', error);
-            // Make sure to resolve the registration even on error
-            this.api._resolveExternalRegistration(registrationId);
-        });
-    }
     handleRegisterPlatformAccessories(accessories) {
-        // Route to HAP bridge
         this.bridgeService.handleRegisterPlatformAccessories(accessories);
     }
     handleUnregisterPlatformAccessories(accessories) {
-        // Route to HAP bridge
         this.bridgeService.handleUnregisterPlatformAccessories(accessories);
     }
-    handleRegisterMatterPlatformAccessories(pluginIdentifier, platformName, accessories) {
-        this.matterManager?.handleRegisterPlatformAccessories(pluginIdentifier, platformName, accessories).catch((error) => {
-            log.error(`Failed to register Matter accessories for ${pluginIdentifier}:`, error);
-        });
-    }
-    handleUpdateMatterPlatformAccessories(accessories) {
-        this.matterManager?.handleUpdatePlatformAccessories(accessories).catch((error) => {
-            log.error('Failed to update Matter platform accessories:', error);
-        });
-    }
-    handleUnregisterMatterPlatformAccessories(pluginIdentifier, platformName, accessories) {
-        this.matterManager?.handleUnregisterPlatformAccessories(pluginIdentifier, platformName, accessories).catch((error) => {
-            log.error(`Failed to unregister Matter accessories for ${pluginIdentifier}:`, error);
-        });
-    }
-    handleUnregisterExternalMatterAccessories(accessories) {
-        this.matterManager?.handleUnregisterExternalAccessories(accessories).catch((error) => {
-            log.error('Failed to unregister external Matter accessories:', error);
-        });
-    }
-    handleUpdateMatterAccessoryState(uuid, cluster, attributes, partId) {
-        this.matterManager?.handleUpdateAccessoryState(uuid, cluster, attributes, partId).catch((error) => {
-            log.error(`Failed to update Matter accessory state for ${uuid}:`, error);
-        });
+    async handleTriggerMatterCommand(uuid, cluster, attributes, partId) {
+        if (!this.matterManager) {
+            throw new Error('Matter manager not initialized');
+        }
+        await this.matterManager.handleTriggerCommand(uuid, cluster, attributes, partId);
     }
     static loadConfig() {
-        // Look for the configuration file
         const configPath = User.configPath();
         const defaultBridge = {
             name: 'Homebridge',
@@ -243,18 +166,7 @@ export class Server {
                 config.ports = undefined;
             }
         }
-        if (config.matterPorts !== undefined) {
-            if (config.matterPorts.start && config.matterPorts.end) {
-                if (config.matterPorts.start > config.matterPorts.end) {
-                    log.error('Invalid Matter port pool configuration. End should be greater than or equal to start.');
-                    config.matterPorts = undefined;
-                }
-            }
-            else {
-                log.error('Invalid configuration for \'matterPorts\'. Missing \'start\' and \'end\' properties! Ignoring it!');
-                config.matterPorts = undefined;
-            }
-        }
+        MatterConfigCollector.validateMatterPortsPool(config);
         const bridge = config.bridge || defaultBridge;
         bridge.name = bridge.name || defaultBridge.name;
         bridge.username = bridge.username || defaultBridge.username;
@@ -275,14 +187,13 @@ export class Server {
             config.platforms = [];
         }
         log.info('Loaded config.json with %s accessories and %s platforms.', config.accessories.length, config.platforms.length);
-        // Validate Matter configuration for port conflicts
         MatterConfigCollector.validateMatterConfig(config);
         if (config.bridge.advertiser) {
             if (![
-                "bonjour-hap" /* MDNSAdvertiser.BONJOUR */,
-                "ciao" /* MDNSAdvertiser.CIAO */,
-                "avahi" /* MDNSAdvertiser.AVAHI */,
-                "resolved" /* MDNSAdvertiser.RESOLVED */,
+                "bonjour-hap",
+                "ciao",
+                "avahi",
+                "resolved",
             ].includes(config.bridge.advertiser)) {
                 config.bridge.advertiser = undefined;
                 log.error('Value provided in bridge.advertiser is not valid, reverting to platform default.');
@@ -298,7 +209,7 @@ export class Server {
         this.config.accessories.forEach((accessoryConfig, index) => {
             if (!accessoryConfig.accessory) {
                 log.warn('Your config.json contains an illegal accessory configuration object at position %d. '
-                    + 'Missing property \'accessory\'. Skipping entry...', index + 1); // we rather count from 1 for the normal people?
+                    + 'Missing property \'accessory\'. Skipping entry...', index + 1);
                 return;
             }
             const accessoryIdentifier = accessoryConfig.accessory;
@@ -316,7 +227,6 @@ export class Server {
                 log.error(error.message);
                 return;
             }
-            // check the plugin is not disabled
             if (plugin.disabled) {
                 log.warn(`Ignoring config for the accessory "${accessoryIdentifier}" in your config.json as the plugin "${plugin.getPluginIdentifier()}" has been disabled.`);
                 return;
@@ -326,16 +236,15 @@ export class Server {
             }
             catch (error) {
                 log.error(`Error loading the accessory "${accessoryIdentifier}" requested in your config.json at position ${index + 1} - this is likely an issue with the "${plugin.getPluginIdentifier()}" plugin.`);
-                log.error(error); // error message contains more information and full stack trace
+                log.error(error);
                 return;
             }
             const logger = Logger.withPrefix(displayName);
             logger('Initializing %s accessory...', accessoryIdentifier);
             if (accessoryConfig._bridge) {
-                // ensure the username is always uppercase
                 accessoryConfig._bridge.username = accessoryConfig._bridge.username.toUpperCase();
                 try {
-                    this.validateChildBridgeConfig("accessory" /* PluginType.ACCESSORY */, accessoryIdentifier, accessoryConfig._bridge);
+                    this.validateChildBridgeConfig("accessory", accessoryIdentifier, accessoryConfig._bridge);
                 }
                 catch (error) {
                     log.error(error.message);
@@ -348,15 +257,13 @@ export class Server {
                 }
                 else {
                     logger(`Initializing child bridge ${accessoryConfig._bridge.username}`);
-                    childBridge = new ChildBridgeService("accessory" /* PluginType.ACCESSORY */, accessoryIdentifier, plugin, accessoryConfig._bridge, this.config, this.options, this.api, this.ipcService, this.externalPortService);
+                    childBridge = new ChildBridgeService("accessory", accessoryIdentifier, plugin, accessoryConfig._bridge, this.config, this.options, this.api, this.ipcService, this.externalPortService);
                     this.childBridges.set(accessoryConfig._bridge.username, childBridge);
                 }
-                // add config to child bridge service
                 childBridge.addConfig(accessoryConfig);
                 return;
             }
             const accessoryInstance = new constructor(logger, accessoryConfig, this.api);
-            // pass accessoryIdentifier for UUID generation, and optional parameter uuid_base which can be used instead of displayName for UUID generation
             const accessory = this.bridgeService.createHAPAccessory(plugin, accessoryInstance, displayName, accessoryIdentifier, accessoryConfig.uuid_base);
             if (accessory) {
                 try {
@@ -377,14 +284,13 @@ export class Server {
         this.config.platforms.forEach((platformConfig, index) => {
             if (!platformConfig.platform) {
                 log.warn('Your config.json contains an illegal platform configuration object at position %d. '
-                    + 'Missing property \'platform\'. Skipping entry...', index + 1); // we rather count from 1 for the normal people?
+                    + 'Missing property \'platform\'. Skipping entry...', index + 1);
                 return;
             }
             const platformIdentifier = platformConfig.platform;
             const displayName = platformConfig.name || platformIdentifier;
             let plugin;
             let constructor;
-            // do not load homebridge-config-ui-x when running in service mode
             if (platformIdentifier === 'config' && process.env.UIX_SERVICE_MODE === '1') {
                 return;
             }
@@ -395,7 +301,6 @@ export class Server {
                 log.error(error.message);
                 return;
             }
-            // check the plugin is not disabled
             if (plugin.disabled) {
                 log.warn(`Ignoring config for the platform "${platformIdentifier}" in your config.json as the plugin "${plugin.getPluginIdentifier()}" has been disabled.`);
                 return;
@@ -405,25 +310,23 @@ export class Server {
             }
             catch (error) {
                 log.error(`Error loading the platform "${platformIdentifier}" requested in your config.json at position ${index + 1} - this is likely an issue with the "${plugin.getPluginIdentifier()}" plugin.`);
-                log.error(error); // error message contains more information and full stack trace
+                log.error(error);
                 return;
             }
             const logger = Logger.withPrefix(displayName);
             logger('Initializing %s platform...', platformIdentifier);
             if (platformConfig._bridge) {
-                // ensure the username is always uppercase
                 platformConfig._bridge.username = platformConfig._bridge.username.toUpperCase();
                 try {
-                    this.validateChildBridgeConfig("platform" /* PluginType.PLATFORM */, platformIdentifier, platformConfig._bridge);
+                    this.validateChildBridgeConfig("platform", platformIdentifier, platformConfig._bridge);
                 }
                 catch (error) {
                     log.error(error.message);
                     return;
                 }
                 logger(`Initializing child bridge ${platformConfig._bridge.username}`);
-                const childBridge = new ChildBridgeService("platform" /* PluginType.PLATFORM */, platformIdentifier, plugin, platformConfig._bridge, this.config, this.options, this.api, this.ipcService, this.externalPortService);
+                const childBridge = new ChildBridgeService("platform", platformIdentifier, plugin, platformConfig._bridge, this.config, this.options, this.api, this.ipcService, this.externalPortService);
                 this.childBridges.set(platformConfig._bridge.username, childBridge);
-                // add config to child bridge service
                 childBridge.addConfig(platformConfig);
                 return;
             }
@@ -431,21 +334,15 @@ export class Server {
             if (HomebridgeAPI.isDynamicPlatformPlugin(platform)) {
                 plugin.assignDynamicPlatform(platformIdentifier, platform);
             }
-            else if (HomebridgeAPI.isStaticPlatformPlugin(platform)) { // Plugin 1.0, load accessories
+            else if (HomebridgeAPI.isStaticPlatformPlugin(platform)) {
                 promises.push(this.bridgeService.loadPlatformAccessories(plugin, platform, platformIdentifier, logger));
             }
             else {
-                // otherwise it's a IndependentPlatformPlugin which doesn't expose any methods at all.
-                // We just call the constructor and let it be enabled.
             }
         });
         return promises;
     }
-    /**
-     * Validate an external bridge config
-     */
     validateChildBridgeConfig(type, identifier, bridgeConfig) {
-        // All child bridges require username
         if (!bridgeConfig.username) {
             throw new Error(`Error loading the ${type} "${identifier}" requested in your config.json - `
                 + 'Missing required field "_bridge.username".');
@@ -456,13 +353,11 @@ export class Server {
         }
         if (this.childBridges.has(bridgeConfig.username)) {
             const childBridge = this.childBridges.get(bridgeConfig.username);
-            if (type === "platform" /* PluginType.PLATFORM */) {
-                // only a single platform can exist on one child bridge
+            if (type === "platform") {
                 throw new Error(`Error loading the ${type} "${identifier}" requested in your config.json - `
                     + `Duplicate username found in _bridge.username: "${bridgeConfig.username}". Each platform child bridge must have it's own unique username.`);
             }
             else if (childBridge?.identifier !== identifier) {
-                // only accessories of the same type can be added to the same child bridge
                 throw new Error(`Error loading the ${type} "${identifier}" requested in your config.json - `
                     + `Duplicate username found in _bridge.username: "${bridgeConfig.username}". You can only group accessories of the same type in a child bridge.`);
             }
@@ -472,47 +367,304 @@ export class Server {
                 + `Username found in _bridge.username: "${bridgeConfig.username}" is the same as the main bridge. Each child bridge platform/accessory must have it's own unique username.`);
         }
     }
-    /**
-     * Takes care of the IPC Events sent to Homebridge
-     */
     initializeIpcEventHandlers() {
-        // start ipc service
         this.ipcService.start();
-        // handle restart child bridge event
-        this.ipcService.on("restartChildBridge" /* IpcIncomingEvent.RESTART_CHILD_BRIDGE */, (username) => {
-            // noinspection SuspiciousTypeOfGuard
+        this.ipcService.on("restartChildBridge", (username) => {
             if (typeof username === 'string') {
                 const childBridge = this.childBridges.get(username.toUpperCase());
                 childBridge?.restartChildBridge();
             }
         });
-        // handle stop child bridge event
-        this.ipcService.on("stopChildBridge" /* IpcIncomingEvent.STOP_CHILD_BRIDGE */, (username) => {
-            // noinspection SuspiciousTypeOfGuard
+        this.ipcService.on("stopChildBridge", (username) => {
             if (typeof username === 'string') {
                 const childBridge = this.childBridges.get(username.toUpperCase());
                 childBridge?.stopChildBridge();
             }
         });
-        // handle start child bridge event
-        this.ipcService.on("startChildBridge" /* IpcIncomingEvent.START_CHILD_BRIDGE */, (username) => {
-            // noinspection SuspiciousTypeOfGuard
+        this.ipcService.on("startChildBridge", (username) => {
             if (typeof username === 'string') {
                 const childBridge = this.childBridges.get(username.toUpperCase());
                 childBridge?.startChildBridge();
             }
         });
-        this.ipcService.on("childBridgeMetadataRequest" /* IpcIncomingEvent.CHILD_BRIDGE_METADATA_REQUEST */, () => {
-            this.ipcService.sendMessage("childBridgeMetadataResponse" /* IpcOutgoingEvent.CHILD_BRIDGE_METADATA_RESPONSE */, Array.from(this.childBridges.values()).map(x => x.getMetadata()));
+        this.ipcService.on("childBridgeMetadataRequest", () => {
+            this.ipcService.sendMessage("childBridgeMetadataResponse", Array.from(this.childBridges.values()).map(x => x.getMetadata()));
+        });
+        this.ipcService.on("startMatterMonitoring", () => {
+            this.handleStartMatterMonitoring();
+        });
+        this.ipcService.on("stopMatterMonitoring", () => {
+            this.handleStopMatterMonitoring();
+        });
+        this.ipcService.on("getMatterAccessories", (data) => {
+            this.handleGetMatterAccessories(data?.bridgeUsername);
+        });
+        this.ipcService.on("getMatterAccessoryInfo", (data) => {
+            this.handleGetMatterAccessoryInfo(data?.uuid);
+        });
+        this.ipcService.on("matterAccessoryControl", (data) => {
+            this.handleMatterAccessoryControl(data);
+        });
+    }
+    handleStartMatterMonitoring() {
+        this.matterMonitoringClients++;
+        if (this.matterMonitoringClients === 1) {
+            matterLogger.debug('Starting Matter accessory monitoring');
+            this.matterMonitoringActive = true;
+            this.matterManager?.enableStateMonitoring();
+            for (const childBridge of this.childBridges.values()) {
+                childBridge.startMatterMonitoring();
+            }
+            const event = {
+                type: 'monitoringStarted',
+                data: { success: true },
+            };
+            this.ipcService.sendMessage("matterEvent", event);
+        }
+        else {
+            const event = {
+                type: 'monitoringStarted',
+                data: { success: true, alreadyActive: true },
+            };
+            this.ipcService.sendMessage("matterEvent", event);
+        }
+    }
+    handleStopMatterMonitoring() {
+        this.matterMonitoringClients--;
+        if (this.matterMonitoringClients <= 0) {
+            matterLogger.debug('Stopping Matter accessory monitoring');
+            this.matterMonitoringClients = 0;
+            this.matterMonitoringActive = false;
+            this.matterManager?.disableStateMonitoring();
+            for (const childBridge of this.childBridges.values()) {
+                childBridge.stopMatterMonitoring();
+            }
+            const event = {
+                type: 'monitoringStopped',
+                data: { success: true },
+            };
+            this.ipcService.sendMessage("matterEvent", event);
+        }
+        else {
+            const event = {
+                type: 'monitoringStopped',
+                data: { success: true, othersActive: true },
+            };
+            this.ipcService.sendMessage("matterEvent", event);
+        }
+    }
+    async handleGetMatterAccessories(bridgeUsername) {
+        matterLogger.debug(`Getting Matter accessories${bridgeUsername ? ` for bridge ${bridgeUsername}` : ' for all bridges'}`);
+        if (!this.matterMonitoringActive) {
+            matterLogger.warn('Matter monitoring not active - cannot get accessories');
+            const event = {
+                type: 'accessoriesData',
+                data: {
+                    bridgeUsername,
+                    error: 'Matter monitoring not active',
+                },
+            };
+            this.ipcService.sendMessage("matterEvent", event);
+            return;
+        }
+        if (!this.api.isMatterEnabled() && this.childBridges.size === 0) {
+            matterLogger.debug('Matter not enabled and no child bridges');
+            const event = {
+                type: 'accessoriesData',
+                data: {
+                    bridgeUsername,
+                    accessories: [],
+                },
+            };
+            this.ipcService.sendMessage("matterEvent", event);
+            return;
+        }
+        try {
+            const allAccessories = this.matterManager?.collectAllAccessories(bridgeUsername) || [];
+            matterLogger.debug(`Collected ${allAccessories.length} accessories from main bridge`);
+            if (this.childBridges.size > 0) {
+                matterLogger.debug(`Requesting accessories from ${this.childBridges.size} child bridge(s)`);
+                for (const childBridge of this.childBridges.values()) {
+                    childBridge.lastMatterAccessoriesResponse = undefined;
+                }
+                for (const childBridge of this.childBridges.values()) {
+                    childBridge.getMatterAccessories();
+                }
+                await new Promise(resolve => setTimeout(resolve, 500));
+                let responsesCollected = 0;
+                for (const childBridge of this.childBridges.values()) {
+                    if (childBridge.lastMatterAccessoriesResponse?.accessories) {
+                        const accessories = childBridge.lastMatterAccessoriesResponse.accessories;
+                        allAccessories.push(...accessories);
+                        responsesCollected++;
+                    }
+                }
+                matterLogger.debug(`Collected responses from ${responsesCollected} of ${this.childBridges.size} child bridge(s)`);
+            }
+            matterLogger.debug(`Sending ${allAccessories.length} total Matter accessories`);
+            const event = {
+                type: 'accessoriesData',
+                data: {
+                    bridgeUsername: bridgeUsername || 'all',
+                    accessories: allAccessories,
+                },
+            };
+            this.ipcService.sendMessage("matterEvent", event);
+        }
+        catch (error) {
+            matterLogger.error('Failed to get Matter accessories:', error);
+            const event = {
+                type: 'accessoriesData',
+                data: {
+                    bridgeUsername,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                },
+            };
+            this.ipcService.sendMessage("matterEvent", event);
+        }
+    }
+    handleGetMatterAccessoryInfo(uuid) {
+        if (!uuid) {
+            const event = {
+                type: 'accessoryInfoData',
+                data: {
+                    error: 'UUID is required',
+                },
+            };
+            this.ipcService.sendMessage("matterEvent", event);
+            return;
+        }
+        try {
+            const accessoryInfo = this.matterManager?.getAccessoryInfo(uuid);
+            if (accessoryInfo) {
+                const event = {
+                    type: 'accessoryInfoData',
+                    data: accessoryInfo,
+                };
+                this.ipcService.sendMessage("matterEvent", event);
+                return;
+            }
+            for (const childBridge of this.childBridges.values()) {
+                if (childBridge.getMetadata().matterConfig) {
+                    childBridge.getMatterAccessoryInfo(uuid);
+                }
+            }
+        }
+        catch (error) {
+            matterLogger.error('Failed to get Matter accessory info:', error);
+            const event = {
+                type: 'accessoryInfoData',
+                data: {
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                },
+            };
+            this.ipcService.sendMessage("matterEvent", event);
+        }
+    }
+    handleMatterAccessoryControl(data) {
+        matterLogger.debug(`Matter control request: uuid=${data?.uuid}, cluster=${data?.cluster}, bridge=${data?.bridgeUsername || 'auto'}, part=${data?.partId || 'main'}`);
+        if (!data?.uuid || !data?.cluster || !data?.attributes) {
+            matterLogger.error('Missing required parameters for Matter control');
+            const event = {
+                type: 'accessoryControlResponse',
+                data: {
+                    success: false,
+                    error: 'Missing required parameters',
+                },
+            };
+            this.ipcService.sendMessage("matterEvent", event);
+            return;
+        }
+        if (data.bridgeUsername) {
+            const targetUsername = data.bridgeUsername.toUpperCase();
+            if (targetUsername === this.config.bridge.username.toUpperCase()) {
+                matterLogger.debug(`Routing to main bridge (${targetUsername})`);
+                this.handleTriggerMatterCommand(data.uuid, data.cluster, data.attributes, data.partId)
+                    .then(() => {
+                    matterLogger.debug(`Main bridge successfully controlled accessory ${data.uuid}`);
+                    const event = {
+                        type: 'accessoryControlResponse',
+                        data: {
+                            success: true,
+                            uuid: data.uuid,
+                        },
+                    };
+                    this.ipcService.sendMessage("matterEvent", event);
+                })
+                    .catch((error) => {
+                    matterLogger.error(`Main bridge failed to control ${data.uuid}: ${error.message}`);
+                    const event = {
+                        type: 'accessoryControlResponse',
+                        data: {
+                            success: false,
+                            error: error.message,
+                            uuid: data.uuid,
+                        },
+                    };
+                    this.ipcService.sendMessage("matterEvent", event);
+                });
+                return;
+            }
+            for (const childBridge of this.childBridges.values()) {
+                if (childBridge.getMetadata().username.toUpperCase() === targetUsername) {
+                    matterLogger.debug(`Routing to child bridge ${childBridge.identifier} (${targetUsername})`);
+                    childBridge.controlMatterAccessory(data);
+                    return;
+                }
+            }
+            matterLogger.warn(`Bridge ${targetUsername} not found`);
+            const event = {
+                type: 'accessoryControlResponse',
+                data: {
+                    success: false,
+                    error: `Bridge ${targetUsername} not found`,
+                    uuid: data.uuid,
+                },
+            };
+            this.ipcService.sendMessage("matterEvent", event);
+            return;
+        }
+        matterLogger.debug(`Broadcast mode: trying main bridge for accessory ${data.uuid}`);
+        this.handleTriggerMatterCommand(data.uuid, data.cluster, data.attributes, data.partId)
+            .then(() => {
+            matterLogger.debug(`Main bridge successfully controlled accessory ${data.uuid}`);
+            const event = {
+                type: 'accessoryControlResponse',
+                data: {
+                    success: true,
+                    uuid: data.uuid,
+                },
+            };
+            this.ipcService.sendMessage("matterEvent", event);
+        })
+            .catch(() => {
+            const matterChildBridges = Array.from(this.childBridges.values()).filter(bridge => bridge.getMetadata().matterConfig);
+            if (matterChildBridges.length > 0) {
+                matterLogger.debug(`Main bridge doesn't have accessory ${data.uuid}, forwarding to ${matterChildBridges.length} child bridge(s) with Matter enabled`);
+                for (const childBridge of matterChildBridges) {
+                    childBridge.controlMatterAccessory(data);
+                }
+            }
+            else {
+                matterLogger.warn(`Accessory ${data.uuid} not found - not on main bridge and no child bridges with Matter available`);
+                const event = {
+                    type: 'accessoryControlResponse',
+                    data: {
+                        success: false,
+                        error: 'Accessory not found',
+                        uuid: data.uuid,
+                    },
+                };
+                this.ipcService.sendMessage("matterEvent", event);
+            }
         });
     }
     printSetupInfo(pin) {
-        /* eslint-disable no-console */
         console.log('Setup Payload:');
         console.log(this.bridgeService.bridge.setupURI());
         if (!this.options.hideQRCode) {
             console.log('Scan this code with your HomeKit app on your iOS device to pair with Homebridge:');
-            qrcode.setErrorLevel('M'); // HAP specifies level M or higher for ECC
+            qrcode.setErrorLevel('M');
             qrcode.generate(this.bridgeService.bridge.setupURI());
             console.log('Or enter this code with your HomeKit app on your iOS device to pair with Homebridge:');
         }
@@ -524,7 +676,6 @@ export class Server {
         console.log(chalk.black.bgWhite(`    │ ${pin} │     `));
         console.log(chalk.black.bgWhite('    └────────────┘     '));
         console.log(chalk.black.bgWhite('                       '));
-        /* eslint-enable no-console */
     }
 }
 //# sourceMappingURL=server.js.map