homebridge 2.0.0-beta.5 → 2.0.0-beta.50

package/dist/server.js

@@ -0,0 +1,732 @@
+import { existsSync, readFileSync } from 'node:fs';
+import process from 'node:process';
+import chalk from 'chalk';
+import qrcode from 'qrcode-terminal';
+import { HomebridgeAPI } from './api.js';
+import { BridgeService } from './bridgeService.js';
+import { ChildBridgeService } from './childBridgeService.js';
+import { ExternalPortService } from './externalPortService.js';
+import { IpcService } from './ipcService.js';
+import { Logger } from './logger.js';
+import { MatterBridgeManager, MatterConfigCollector } from './matter/index.js';
+import { PluginManager } from './pluginManager.js';
+import { User } from './user.js';
+import { validMacAddress } from './util/mac.js';
+const log = Logger.internal;
+const matterLogger = Logger.withPrefix('Matter/MainManager');
+export var ServerStatus;
+(function (ServerStatus) {
+    ServerStatus["PENDING"] = "pending";
+    ServerStatus["OK"] = "ok";
+    ServerStatus["DOWN"] = "down";
+})(ServerStatus || (ServerStatus = {}));
+export class Server {
+    options;
+    api;
+    pluginManager;
+    bridgeService;
+    ipcService;
+    externalPortService;
+    config;
+    childBridges = new Map();
+    matterManager;
+    externalMatterBridgeRegistry = new Map();
+    matterMonitoringActive = false;
+    matterMonitoringClients = 0;
+    serverStatus = "pending";
+    constructor(options = {}) {
+        this.options = options;
+        this.config = Server.loadConfig();
+        this.api = new HomebridgeAPI();
+        this.ipcService = new IpcService();
+        const configuredMatterPorts = MatterBridgeManager.collectConfiguredMatterPorts(this.config);
+        this.externalPortService = new ExternalPortService(this.config.ports, this.config.matterPorts, configuredMatterPorts);
+        this.setServerStatus("pending");
+        const pluginManagerOptions = {
+            activePlugins: this.config.plugins,
+            disabledPlugins: this.config.disabledPlugins,
+            customPluginPath: options.customPluginPath,
+            strictPluginResolution: options.strictPluginResolution,
+        };
+        this.pluginManager = new PluginManager(this.api, pluginManagerOptions);
+        const bridgeConfig = {
+            cachedAccessoriesDir: User.cachedAccessoryPath(),
+            cachedAccessoriesItemName: 'cachedAccessories',
+        };
+        Object.assign(bridgeConfig, this.options);
+        this.bridgeService = new BridgeService(this.api, this.pluginManager, this.externalPortService, bridgeConfig, this.config.bridge);
+        this.matterManager = new MatterBridgeManager(this.config, this.api, this.externalPortService, this.pluginManager, this.options, this);
+        this.api._setMatterManager(this.matterManager);
+        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");
+        });
+        this.bridgeService.bridge.on("paired", () => {
+            this.setServerStatus(this.serverStatus);
+        });
+        this.bridgeService.bridge.on("unpaired", () => {
+            this.setServerStatus(this.serverStatus);
+        });
+    }
+    setServerStatus(status) {
+        this.serverStatus = status;
+        const statusUpdate = {
+            status: this.serverStatus,
+            paired: this.bridgeService?.bridge?._accessoryInfo?.paired() ?? null,
+            setupUri: this.bridgeService?.bridge?.setupURI() ?? null,
+            name: this.config.bridge.name,
+            username: this.config.bridge.username,
+            pin: this.config.bridge.pin,
+            matter: this.matterManager?.getMatterStatus() ?? { enabled: false },
+        };
+        this.ipcService.sendMessage("serverStatusUpdate", statusUpdate);
+    }
+    async start() {
+        if (this.config.bridge.disableIpc !== true) {
+            this.initializeIpcEventHandlers();
+        }
+        const promises = [];
+        await this.bridgeService.loadCachedPlatformAccessoriesFromDisk();
+        await this.pluginManager.initializeInstalledPlugins();
+        await this.matterManager?.initialize();
+        if (this.config.platforms.length > 0) {
+            promises.push(...this.loadPlatforms());
+        }
+        if (this.config.accessories.length > 0) {
+            this.loadAccessories();
+        }
+        for (const childBridge of this.childBridges.values()) {
+            childBridge.start();
+        }
+        this.bridgeService.restoreCachedPlatformAccessories();
+        this.matterManager?.restoreCachedAccessories(this.options.keepOrphanedCachedAccessories ?? false);
+        this.api.signalFinished();
+        await Promise.all(promises);
+        await this.publishBridge();
+    }
+    async teardown() {
+        this.bridgeService.teardown();
+        await this.matterManager?.teardown();
+        this.setServerStatus("down");
+    }
+    publishBridge() {
+        this.bridgeService.publishBridge();
+        this.printSetupInfo(this.config.bridge.pin);
+    }
+    handlePublishExternalAccessories(accessories) {
+        log.info(`Publishing ${accessories.length} external accessories`);
+    }
+    handleRegisterPlatformAccessories(accessories) {
+        this.bridgeService.handleRegisterPlatformAccessories(accessories);
+    }
+    handleUnregisterPlatformAccessories(accessories) {
+        this.bridgeService.handleUnregisterPlatformAccessories(accessories);
+    }
+    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() {
+        const configPath = User.configPath();
+        const defaultBridge = {
+            name: 'Homebridge',
+            username: 'CC:22:3D:E3:CE:30',
+            pin: '031-45-154',
+        };
+        if (!existsSync(configPath)) {
+            log.warn('config.json (%s) not found.', configPath);
+            return {
+                bridge: defaultBridge,
+                accessories: [],
+                platforms: [],
+            };
+        }
+        let config;
+        try {
+            config = JSON.parse(readFileSync(configPath, { encoding: 'utf8' }));
+        }
+        catch (error) {
+            log.error('There was a problem reading your config.json file.');
+            log.error('Please try pasting your config.json file here to validate it: https://jsonlint.com');
+            log.error('');
+            throw error;
+        }
+        if (config.ports !== undefined) {
+            if (config.ports.start && config.ports.end) {
+                if (config.ports.start > config.ports.end) {
+                    log.error('Invalid port pool configuration. End should be greater than or equal to start.');
+                    config.ports = undefined;
+                }
+            }
+            else {
+                log.error('Invalid configuration for \'ports\'. Missing \'start\' and \'end\' properties! Ignoring it!');
+                config.ports = undefined;
+            }
+        }
+        MatterConfigCollector.validateMatterPortsPool(config);
+        const bridge = config.bridge || defaultBridge;
+        bridge.name = bridge.name || defaultBridge.name;
+        bridge.username = bridge.username || defaultBridge.username;
+        bridge.pin = bridge.pin || defaultBridge.pin;
+        config.bridge = bridge;
+        const username = config.bridge.username;
+        if (!validMacAddress(username)) {
+            throw new Error(`Not a valid username: ${username}. Must be 6 pairs of colon-separated hexadecimal chars (A-F 0-9), like a MAC address.`);
+        }
+        config.accessories = config.accessories || [];
+        config.platforms = config.platforms || [];
+        if (!Array.isArray(config.accessories)) {
+            log.error('Value provided for accessories must be an array[]');
+            config.accessories = [];
+        }
+        if (!Array.isArray(config.platforms)) {
+            log.error('Value provided for platforms must be an array[]');
+            config.platforms = [];
+        }
+        log.info('Loaded config.json with %s accessories and %s platforms.', config.accessories.length, config.platforms.length);
+        MatterConfigCollector.validateMatterConfig(config);
+        if (config.bridge.advertiser) {
+            if (![
+                "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.');
+            }
+        }
+        else {
+            config.bridge.advertiser = undefined;
+        }
+        return config;
+    }
+    loadAccessories() {
+        log.info(`Loading ${this.config.accessories.length} accessories...`);
+        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);
+                return;
+            }
+            const accessoryIdentifier = accessoryConfig.accessory;
+            const displayName = accessoryConfig.name;
+            if (!displayName) {
+                log.warn('Could not load accessory %s at position %d as it is missing the required \'name\' property!', accessoryIdentifier, index + 1);
+                return;
+            }
+            let plugin;
+            let constructor;
+            try {
+                plugin = this.pluginManager.getPluginForAccessory(accessoryIdentifier);
+            }
+            catch (error) {
+                log.error(error.message);
+                return;
+            }
+            if (plugin.disabled) {
+                log.warn(`Ignoring config for the accessory "${accessoryIdentifier}" in your config.json as the plugin "${plugin.getPluginIdentifier()}" has been disabled.`);
+                return;
+            }
+            try {
+                constructor = plugin.getAccessoryConstructor(accessoryIdentifier);
+            }
+            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);
+                return;
+            }
+            const logger = Logger.withPrefix(displayName);
+            logger('Initializing %s accessory...', accessoryIdentifier);
+            if (accessoryConfig._bridge) {
+                accessoryConfig._bridge.username = accessoryConfig._bridge.username.toUpperCase();
+                try {
+                    this.validateChildBridgeConfig("accessory", accessoryIdentifier, accessoryConfig._bridge);
+                }
+                catch (error) {
+                    log.error(error.message);
+                    return;
+                }
+                let childBridge;
+                if (this.childBridges.has(accessoryConfig._bridge.username)) {
+                    childBridge = this.childBridges.get(accessoryConfig._bridge.username);
+                    logger(`Adding to existing child bridge ${accessoryConfig._bridge.username}`);
+                }
+                else {
+                    logger(`Initializing child bridge ${accessoryConfig._bridge.username}`);
+                    childBridge = new ChildBridgeService("accessory", accessoryIdentifier, plugin, accessoryConfig._bridge, this.config, this.options, this.api, this.ipcService, this.externalPortService);
+                    childBridge.onExternalBridgeRegistered = this.registerExternalMatterBridge.bind(this);
+                    this.childBridges.set(accessoryConfig._bridge.username, childBridge);
+                }
+                childBridge.addConfig(accessoryConfig);
+                return;
+            }
+            const accessoryInstance = new constructor(logger, accessoryConfig, this.api);
+            const accessory = this.bridgeService.createHAPAccessory(plugin, accessoryInstance, displayName, accessoryIdentifier, accessoryConfig.uuid_base);
+            if (accessory) {
+                try {
+                    this.bridgeService.bridge.addBridgedAccessory(accessory);
+                }
+                catch (error) {
+                    logger.error(`Error loading the accessory "${accessoryIdentifier}" from "${plugin.getPluginIdentifier()}" requested in your config.json:`, error.message);
+                }
+            }
+            else {
+                logger.info('Accessory %s returned empty set of services; not adding it to the bridge.', accessoryIdentifier);
+            }
+        });
+    }
+    loadPlatforms() {
+        log.info(`Loading ${this.config.platforms.length} platforms...`);
+        const promises = [];
+        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);
+                return;
+            }
+            const platformIdentifier = platformConfig.platform;
+            const displayName = platformConfig.name || platformIdentifier;
+            let plugin;
+            let constructor;
+            if (platformIdentifier === 'config' && process.env.UIX_SERVICE_MODE === '1') {
+                return;
+            }
+            try {
+                plugin = this.pluginManager.getPluginForPlatform(platformIdentifier);
+            }
+            catch (error) {
+                log.error(error.message);
+                return;
+            }
+            if (plugin.disabled) {
+                log.warn(`Ignoring config for the platform "${platformIdentifier}" in your config.json as the plugin "${plugin.getPluginIdentifier()}" has been disabled.`);
+                return;
+            }
+            try {
+                constructor = plugin.getPlatformConstructor(platformIdentifier);
+            }
+            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);
+                return;
+            }
+            const logger = Logger.withPrefix(displayName);
+            logger('Initializing %s platform...', platformIdentifier);
+            if (platformConfig._bridge) {
+                platformConfig._bridge.username = platformConfig._bridge.username.toUpperCase();
+                try {
+                    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", platformIdentifier, plugin, platformConfig._bridge, this.config, this.options, this.api, this.ipcService, this.externalPortService);
+                childBridge.onExternalBridgeRegistered = this.registerExternalMatterBridge.bind(this);
+                this.childBridges.set(platformConfig._bridge.username, childBridge);
+                childBridge.addConfig(platformConfig);
+                return;
+            }
+            const platform = new constructor(logger, platformConfig, this.api);
+            if (HomebridgeAPI.isDynamicPlatformPlugin(platform)) {
+                plugin.assignDynamicPlatform(platformIdentifier, platform);
+            }
+            else if (HomebridgeAPI.isStaticPlatformPlugin(platform)) {
+                promises.push(this.bridgeService.loadPlatformAccessories(plugin, platform, platformIdentifier, logger));
+            }
+            else {
+            }
+        });
+        return promises;
+    }
+    validateChildBridgeConfig(type, identifier, bridgeConfig) {
+        if (!bridgeConfig.username) {
+            throw new Error(`Error loading the ${type} "${identifier}" requested in your config.json - `
+                + 'Missing required field "_bridge.username".');
+        }
+        if (!validMacAddress(bridgeConfig.username)) {
+            throw new Error(`Error loading the ${type} "${identifier}" requested in your config.json - `
+                + `not a valid username in _bridge.username: "${bridgeConfig.username}". Must be 6 pairs of colon-separated hexadecimal chars (A-F 0-9), like a MAC address.`);
+        }
+        if (this.childBridges.has(bridgeConfig.username)) {
+            const childBridge = this.childBridges.get(bridgeConfig.username);
+            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) {
+                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.`);
+            }
+        }
+        if (bridgeConfig.username === this.config.bridge.username.toUpperCase()) {
+            throw new Error(`Error loading the ${type} "${identifier}" requested in your config.json - `
+                + `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.`);
+        }
+    }
+    initializeIpcEventHandlers() {
+        this.ipcService.start();
+        this.ipcService.on("restartChildBridge", (username) => {
+            if (typeof username === 'string') {
+                const childBridge = this.childBridges.get(username.toUpperCase());
+                childBridge?.restartChildBridge();
+            }
+        });
+        this.ipcService.on("stopChildBridge", (username) => {
+            if (typeof username === 'string') {
+                const childBridge = this.childBridges.get(username.toUpperCase());
+                childBridge?.stopChildBridge();
+            }
+        });
+        this.ipcService.on("startChildBridge", (username) => {
+            if (typeof username === 'string') {
+                const childBridge = this.childBridges.get(username.toUpperCase());
+                childBridge?.startChildBridge();
+            }
+        });
+        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);
+        }
+    }
+    registerExternalMatterBridge(externalBridgeUsername, ownerUsername) {
+        const normalizedExternal = externalBridgeUsername.toUpperCase();
+        const normalizedOwner = ownerUsername.toUpperCase();
+        matterLogger.debug(`Registering external Matter bridge ${normalizedExternal} → owner: ${normalizedOwner}`);
+        this.externalMatterBridgeRegistry.set(normalizedExternal, normalizedOwner);
+    }
+    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);
+        }
+    }
+    async 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');
+            this.ipcService.sendMessage("matterEvent", {
+                type: 'accessoryControlResponse',
+                data: {
+                    success: false,
+                    error: 'Missing required parameters',
+                },
+            });
+            return;
+        }
+        if (data.bridgeUsername) {
+            const targetUsername = data.bridgeUsername.toUpperCase();
+            if (targetUsername === this.config.bridge.username.toUpperCase()) {
+                matterLogger.debug(`Routing to main bridge (${targetUsername})`);
+                try {
+                    await this.handleTriggerMatterCommand(data.uuid, data.cluster, data.attributes, data.partId);
+                    matterLogger.debug(`Main bridge successfully controlled accessory ${data.uuid}`);
+                    this.ipcService.sendMessage("matterEvent", {
+                        type: 'accessoryControlResponse',
+                        data: {
+                            success: true,
+                            uuid: data.uuid,
+                        },
+                    });
+                }
+                catch (error) {
+                    matterLogger.error(`Main bridge failed to control ${data.uuid}: ${error.message}`);
+                    this.ipcService.sendMessage("matterEvent", {
+                        type: 'accessoryControlResponse',
+                        data: {
+                            success: false,
+                            error: error.message,
+                            uuid: data.uuid,
+                        },
+                    });
+                }
+                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;
+                }
+            }
+            const ownerUsername = this.externalMatterBridgeRegistry.get(targetUsername);
+            if (ownerUsername) {
+                matterLogger.debug(`Found external bridge ${targetUsername} in registry, owned by ${ownerUsername}`);
+                if (ownerUsername === this.config.bridge.username.toUpperCase()) {
+                    matterLogger.debug(`Routing to main bridge's external accessories for ${data.uuid}`);
+                    try {
+                        await this.handleTriggerMatterCommand(data.uuid, data.cluster, data.attributes, data.partId);
+                        matterLogger.debug(`External accessory ${data.uuid} successfully controlled via main bridge`);
+                        this.ipcService.sendMessage("matterEvent", {
+                            type: 'accessoryControlResponse',
+                            data: {
+                                success: true,
+                                uuid: data.uuid,
+                            },
+                        });
+                    }
+                    catch (error) {
+                        matterLogger.error(`Main bridge failed to control external accessory ${data.uuid}: ${error.message}`);
+                        this.ipcService.sendMessage("matterEvent", {
+                            type: 'accessoryControlResponse',
+                            data: {
+                                success: false,
+                                error: error.message,
+                                uuid: data.uuid,
+                            },
+                        });
+                    }
+                }
+                else {
+                    const childBridge = this.childBridges.get(ownerUsername);
+                    if (childBridge) {
+                        matterLogger.debug(`Routing to child bridge ${childBridge.identifier} (${ownerUsername}) for external accessory ${data.uuid}`);
+                        childBridge.controlMatterAccessory(data);
+                    }
+                    else {
+                        matterLogger.error(`Owner bridge ${ownerUsername} not found for external bridge ${targetUsername}`);
+                        this.ipcService.sendMessage("matterEvent", {
+                            type: 'accessoryControlResponse',
+                            data: {
+                                success: false,
+                                error: `Owner bridge ${ownerUsername} not found`,
+                                uuid: data.uuid,
+                            },
+                        });
+                    }
+                }
+                return;
+            }
+            matterLogger.error(`Bridge ${targetUsername} not found in main/child bridges or registry`);
+            this.ipcService.sendMessage("matterEvent", {
+                type: 'accessoryControlResponse',
+                data: {
+                    success: false,
+                    error: `Bridge ${targetUsername} not found`,
+                    uuid: data.uuid,
+                },
+            });
+            return;
+        }
+        matterLogger.debug(`Broadcast mode: trying main bridge for accessory ${data.uuid}`);
+        try {
+            await this.handleTriggerMatterCommand(data.uuid, data.cluster, data.attributes, data.partId);
+            matterLogger.debug(`Main bridge successfully controlled accessory ${data.uuid}`);
+            this.ipcService.sendMessage("matterEvent", {
+                type: 'accessoryControlResponse',
+                data: {
+                    success: true,
+                    uuid: data.uuid,
+                },
+            });
+        }
+        catch (error) {
+            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`);
+                this.ipcService.sendMessage("matterEvent", {
+                    type: 'accessoryControlResponse',
+                    data: {
+                        success: false,
+                        error: 'Accessory not found',
+                        uuid: data.uuid,
+                    },
+                });
+            }
+        }
+    }
+    printSetupInfo(pin) {
+        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');
+            qrcode.generate(this.bridgeService.bridge.setupURI());
+            console.log('Or enter this code with your HomeKit app on your iOS device to pair with Homebridge:');
+        }
+        else {
+            console.log('Enter this code with your HomeKit app on your iOS device to pair with Homebridge:');
+        }
+        console.log(chalk.black.bgWhite('                       '));
+        console.log(chalk.black.bgWhite('    ┌────────────┐     '));
+        console.log(chalk.black.bgWhite(`    │ ${pin} │     `));
+        console.log(chalk.black.bgWhite('    └────────────┘     '));
+        console.log(chalk.black.bgWhite('                       '));
+    }
+}
+//# sourceMappingURL=server.js.map