homebridge 2.0.0-beta.3 → 2.0.0-beta.31

package/dist/server.js

@@ -0,0 +1,811 @@
+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 { MatterConfigValidator, MatterServer } from './matter/index.js';
+import { PluginManager } from './pluginManager.js';
+import { User } from './user.js';
+import { generate, validMacAddress } from './util/mac.js';
+const log = Logger.internal;
+// eslint-disable-next-line no-restricted-syntax
+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 {
+    options;
+    api;
+    pluginManager;
+    bridgeService;
+    ipcService;
+    externalPortService;
+    config;
+    // used to keep track of child bridges
+    // Key is HAP username (MAC address)
+    childBridges = new Map();
+    // Matter server instance for main bridge (if enabled)
+    matterServer;
+    // External Matter servers for accessories that need their own bridge
+    // Key is accessory UUID, value is MatterServer instance
+    externalMatterServers = new Map();
+    // current server status
+    serverStatus = "pending" /* 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();
+        this.externalPortService = new ExternalPortService(this.config.ports, this.config.matterPorts);
+        // set status to pending
+        this.setServerStatus("pending" /* ServerStatus.PENDING */);
+        // create new plugin manager
+        const pluginManagerOptions = {
+            activePlugins: this.config.plugins,
+            disabledPlugins: this.config.disabledPlugins,
+            customPluginPath: options.customPluginPath,
+            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);
+        // 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("unregisterMatterPlatformAccessories" /* InternalAPIEvent.UNREGISTER_MATTER_PLATFORM_ACCESSORIES */, this.handleUnregisterMatterPlatformAccessories.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 */);
+        });
+        // watch for the paired event to update the server status
+        this.bridgeService.bridge.on("paired" /* AccessoryEventTypes.PAIRED */, () => {
+            this.setServerStatus(this.serverStatus);
+        });
+        // watch for the unpaired event to update the server status
+        this.bridgeService.bridge.on("unpaired" /* AccessoryEventTypes.UNPAIRED */, () => {
+            this.setServerStatus(this.serverStatus);
+        });
+    }
+    /**
+     * Set the current server status and update parent via IPC
+     * @param status
+     */
+    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: {
+                enabled: false,
+            },
+        };
+        // Include Matter commissioning info if Matter is enabled
+        if (this.matterServer) {
+            const commissioningInfo = this.matterServer.getCommissioningInfo();
+            statusUpdate.matter = {
+                enabled: true,
+                port: this.config.bridge.matter?.port,
+                setupUri: commissioningInfo.qrCode,
+                pin: commissioningInfo.manualPairingCode,
+                serialNumber: commissioningInfo.serialNumber,
+                commissioned: commissioningInfo.commissioned || false,
+                deviceCount: this.matterServer.getAccessories().length,
+            };
+        }
+        else if (this.config.bridge.matter) {
+            // Matter is configured but not yet started (or failed to start)
+            statusUpdate.matter = {
+                enabled: false,
+                port: this.config.bridge.matter?.port,
+            };
+        }
+        this.ipcService.sendMessage("serverStatusUpdate" /* IpcOutgoingEvent.SERVER_STATUS_UPDATE */, 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.initializeMatterServer();
+        if (this.config.platforms.length > 0) {
+            promises.push(...this.loadPlatforms());
+        }
+        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.restoreCachedMatterAccessories();
+        this.api.signalFinished();
+        // wait for all platforms to publish their accessories before we publish the bridge
+        await Promise.all(promises)
+            .then(() => this.publishBridge());
+    }
+    /**
+     * Initialize Matter server for main bridge if enabled
+     */
+    async initializeMatterServer() {
+        // Check if main bridge has matter configuration
+        if (!this.config.bridge.matter) {
+            return;
+        }
+        // Declare matterPort outside try block so it's accessible in catch
+        let matterPort;
+        try {
+            log.info('Initializing Matter server for main bridge...');
+            // Allocate port from pool if not explicitly configured
+            matterPort = this.config.bridge.matter.port;
+            if (!matterPort) {
+                matterPort = await this.externalPortService.requestPort(`${this.config.bridge.username}:MATTER`);
+                if (!matterPort) {
+                    matterPort = 5540; // Default Matter port
+                    log.warn('No port available from pool for main Matter bridge, using default port 5540');
+                }
+                else {
+                    log.info(`Allocated port ${matterPort} from pool for main Matter bridge`);
+                }
+            }
+            // Create Matter server instance with config inheritance from main bridge
+            const serialNumber = this.config.bridge.username.replace(/:/g, '');
+            // Normalize bind config to array format
+            const networkInterfaces = this.config.bridge.bind
+                ? Array.isArray(this.config.bridge.bind)
+                    ? this.config.bridge.bind
+                    : [this.config.bridge.bind]
+                : undefined;
+            this.matterServer = new MatterServer({
+                storagePath: User.matterPath(),
+                port: matterPort,
+                uniqueId: serialNumber,
+                manufacturer: this.config.bridge.manufacturer,
+                model: this.config.bridge.model,
+                firmwareRevision: this.config.bridge.firmwareRevision,
+                serialNumber,
+                debugModeEnabled: this.options.debugModeEnabled,
+                networkInterfaces,
+            });
+            // Start the Matter server
+            await this.matterServer.start();
+            log.info('Matter server initialized for main bridge');
+            // Inform the API that Matter is enabled
+            this.api._setMatterEnabled(true);
+            // Set the Matter server reference for API methods like getAccessoryState
+            this.api._setMatterServer(this.matterServer);
+            // Listen for Matter commissioning events to update status
+            this.matterServer.on('commissioning-changed', (commissioned, fabricCount) => {
+                log.info(`Matter commissioning state changed: commissioned=${commissioned}, fabricCount=${fabricCount}`);
+                this.setServerStatus(this.serverStatus);
+            });
+        }
+        catch (error) {
+            log.error('Failed to initialize Matter server for main bridge:', error);
+            // Provide user-friendly guidance for common errors
+            if (error.message && error.message.includes('corrupted')) {
+                log.error('');
+                log.error('╔════════════════════════════════════════════════════════════════════════════╗');
+                log.error('║  MATTER STORAGE CORRUPTED                                                  ║');
+                log.error('╠════════════════════════════════════════════════════════════════════════════╣');
+                log.error('║  Your Matter storage has become corrupted. This can happen when:          ║');
+                log.error('║  • Matter.js library version changes                                       ║');
+                log.error('║  • Storage format upgrades occur                                           ║');
+                log.error('║  • Incomplete writes during shutdown                                       ║');
+                log.error('║                                                                            ║');
+                log.error('║  To fix this, delete the corrupted storage directory:                     ║');
+                log.error(`║  rm -rf ~/.homebridge/matter/${this.config.bridge.username}                                   ║`);
+                log.error('║                                                                            ║');
+                log.error('║  Note: You will need to re-pair your Matter devices after deletion.       ║');
+                log.error('╚════════════════════════════════════════════════════════════════════════════╝');
+                log.error('');
+            }
+            else if (error.code === 'EADDRINUSE' || (error.message && error.message.includes('address already in use'))) {
+                log.error('');
+                log.error('╔════════════════════════════════════════════════════════════════════════════╗');
+                log.error('║  MATTER PORT ALREADY IN USE                                                ║');
+                log.error('╠════════════════════════════════════════════════════════════════════════════╣');
+                log.error(`║  Port ${matterPort} is already in use by another application.                    ║`);
+                log.error('║                                                                            ║');
+                log.error('║  To fix this:                                                              ║');
+                log.error('║  1. Stop the application using this port, or                              ║');
+                log.error('║  2. Configure a different port in your config.json:                       ║');
+                log.error('║     "bridge": {                                                            ║');
+                log.error('║       "matter": {                                                          ║');
+                log.error('║         "port": <different-port>                                           ║');
+                log.error('║       }                                                                    ║');
+                log.error('║     }                                                                      ║');
+                log.error('╚════════════════════════════════════════════════════════════════════════════╝');
+                log.error('');
+            }
+        }
+    }
+    async teardown() {
+        this.bridgeService.teardown();
+        // Stop main Matter server if running
+        if (this.matterServer) {
+            try {
+                await this.matterServer.stop();
+            }
+            catch (error) {
+                log.error('Failed to stop Matter server:', error);
+            }
+        }
+        // Stop all external Matter servers
+        for (const [uuid, matterServer] of this.externalMatterServers) {
+            try {
+                await matterServer.stop();
+                log.debug(`Stopped external Matter server for ${uuid}`);
+            }
+            catch (error) {
+                log.error(`Failed to stop external Matter server for ${uuid}:`, error);
+            }
+        }
+        this.externalMatterServers.clear();
+        // Child bridge Matter servers are stopped by their own forked processes
+        this.setServerStatus("down" /* ServerStatus.DOWN */);
+    }
+    publishBridge() {
+        this.bridgeService.publishBridge();
+        this.printSetupInfo(this.config.bridge.pin);
+    }
+    handlePublishExternalAccessories(accessories) {
+        log.info(`Publishing ${accessories.length} external accessories`);
+        // External accessories are published via HAP
+        // Plugins should use api.matter to register Matter accessories explicitly
+    }
+    /**
+     * Handle external Matter accessories - each gets its own dedicated Matter server
+     * This is required for devices like Robotic Vacuum Cleaners that Apple Home
+     * requires to be on their own bridge.
+     */
+    async handlePublishExternalMatterAccessories(accessories) {
+        log.info(`Publishing ${accessories.length} external Matter accessor${accessories.length === 1 ? 'y' : 'ies'}`);
+        for (const accessory of accessories) {
+            try {
+                // Validate accessory has required fields
+                if (!accessory.uuid) {
+                    log.error('External Matter accessory missing UUID - skipping');
+                    continue;
+                }
+                if (!accessory.displayName) {
+                    log.error(`External Matter accessory ${accessory.uuid} missing displayName - skipping`);
+                    continue;
+                }
+                // Check if already published
+                if (this.externalMatterServers.has(accessory.uuid)) {
+                    log.warn(`External Matter accessory ${accessory.displayName} (${accessory.uuid}) is already published`);
+                    continue;
+                }
+                // Generate deterministic MAC address from UUID (same pattern as HAP external accessories)
+                const advertiseAddress = generate(accessory.uuid);
+                // For Matter, use the MAC without colons as uniqueId
+                const uniqueId = advertiseAddress.replace(/:/g, '');
+                // Allocate Matter port for the external Matter server
+                const port = await this.externalPortService.requestMatterPort(uniqueId);
+                if (!port) {
+                    log.error(`Failed to allocate Matter port for external Matter accessory ${accessory.displayName}`);
+                    log.error('Please configure matterPorts in config.json or free up ports in the default range (5530-5541)');
+                    continue;
+                }
+                log.info(`Allocated port ${port} for external Matter accessory: ${accessory.displayName}`);
+                // Normalize bind config to array format (inherit from main bridge)
+                const networkInterfaces = this.config.bridge.bind
+                    ? Array.isArray(this.config.bridge.bind)
+                        ? this.config.bridge.bind
+                        : [this.config.bridge.bind]
+                    : undefined;
+                // Create dedicated Matter server for this accessory
+                const matterServer = new MatterServer({
+                    port,
+                    uniqueId,
+                    storagePath: User.matterPath(),
+                    manufacturer: accessory.manufacturer,
+                    model: accessory.model,
+                    firmwareRevision: accessory.firmwareRevision,
+                    serialNumber: accessory.serialNumber || uniqueId, // use uniqueId as fallback serial number
+                    debugModeEnabled: this.options.debugModeEnabled,
+                    externalAccessory: true, // external accessory, added before server runs
+                    networkInterfaces,
+                });
+                // Start the Matter server (but don't run it yet due to externalAccessory mode)
+                await matterServer.start();
+                // Get plugin identifier from accessory
+                const pluginIdentifier = accessory._associatedPlugin || 'unknown';
+                // Register the accessory to this dedicated server
+                await matterServer.registerPlatformAccessories(pluginIdentifier, 'ExternalMatter', [accessory]);
+                // Now run the server with the device already attached (required for external accessories)
+                await matterServer.runServer();
+                // Store the server instance
+                this.externalMatterServers.set(accessory.uuid, matterServer);
+                log.info(`✓ External Matter accessory published: ${accessory.displayName} on port ${port}`);
+                // Log commissioning info
+                const commissioningInfo = matterServer.getCommissioningInfo();
+                if (commissioningInfo.qrCode && commissioningInfo.manualPairingCode) {
+                    log.info(`📱 Commissioning codes for ${accessory.displayName}:`);
+                    log.info(`   QR Code: ${commissioningInfo.qrCode}`);
+                    log.info(`   Manual Code: ${commissioningInfo.manualPairingCode}`);
+                }
+            }
+            catch (error) {
+                log.error(`Failed to publish external Matter accessory ${accessory.displayName}:`, error);
+            }
+        }
+    }
+    handleRegisterPlatformAccessories(accessories) {
+        // Route to HAP bridge
+        this.bridgeService.handleRegisterPlatformAccessories(accessories);
+    }
+    handleUnregisterPlatformAccessories(accessories) {
+        // Route to HAP bridge
+        this.bridgeService.handleUnregisterPlatformAccessories(accessories);
+    }
+    handleRegisterMatterPlatformAccessories(pluginIdentifier, platformName, accessories) {
+        if (!this.matterServer) {
+            log.warn('Cannot register Matter accessories - Matter server is not running');
+            return;
+        }
+        this.matterServer.registerPlatformAccessories(pluginIdentifier, platformName, accessories).catch((error) => {
+            log.error(`Failed to register Matter accessories for ${pluginIdentifier}:`, error);
+        });
+    }
+    handleUnregisterMatterPlatformAccessories(pluginIdentifier, platformName, accessories) {
+        if (!this.matterServer) {
+            log.warn('Cannot unregister Matter accessories - Matter server is not running');
+            return;
+        }
+        this.matterServer.unregisterPlatformAccessories(pluginIdentifier, platformName, accessories).catch((error) => {
+            log.error(`Failed to unregister Matter accessories for ${pluginIdentifier}:`, error);
+        });
+    }
+    handleUpdateMatterAccessoryState(uuid, cluster, attributes, partId) {
+        if (!this.matterServer) {
+            log.warn('Cannot update Matter accessory state - Matter server is not running');
+            return;
+        }
+        this.matterServer.updateAccessoryState(uuid, cluster, attributes, partId).catch((error) => {
+            log.error(`Failed to update Matter accessory state for ${uuid}:`, error);
+        });
+    }
+    /**
+     * Restore cached Matter accessories (matching HAP pattern)
+     */
+    restoreCachedMatterAccessories() {
+        if (!this.matterServer) {
+            log.debug('Matter server not available for restoring cached accessories');
+            return;
+        }
+        const cachedAccessories = this.matterServer.getAllCachedAccessories();
+        log.debug(`Restoring ${cachedAccessories.length} cached Matter accessories`);
+        for (const cachedAccessory of cachedAccessories) {
+            let plugin = this.pluginManager.getPlugin(cachedAccessory.plugin);
+            if (!plugin) {
+                try {
+                    // Try to find plugin by platform name (handles plugin renames)
+                    plugin = this.pluginManager.getPluginByActiveDynamicPlatform(cachedAccessory.platform);
+                    if (plugin) {
+                        log.info(`When searching for the associated plugin of the Matter accessory '${cachedAccessory.displayName}' `
+                            + `it seems like the plugin name changed from '${cachedAccessory.plugin}' to '${plugin.getPluginIdentifier()}'. Plugin association is now being transformed!`);
+                    }
+                }
+                catch (error) {
+                    log.warn(`Could not find the associated plugin for the Matter accessory '${cachedAccessory.displayName}'. `
+                        + `Tried to find the plugin by the platform name but ${error.message}`);
+                }
+            }
+            const platformPlugin = plugin && plugin.getActiveDynamicPlatform(cachedAccessory.platform);
+            if (!platformPlugin) {
+                log.warn(`Failed to find plugin to handle Matter accessory ${cachedAccessory.displayName} (plugin: ${cachedAccessory.plugin}, platform: ${cachedAccessory.platform})`);
+                // Note: Matter accessories are not added to the bridge here - they're registered via plugin's didFinishLaunching
+                // The plugin can check if this accessory still exists and re-register or remove it
+            }
+            else {
+                // Call configureMatterAccessory if the plugin implements it
+                if (platformPlugin.configureMatterAccessory) {
+                    log.debug(`Calling configureMatterAccessory for ${cachedAccessory.displayName}`);
+                    platformPlugin.configureMatterAccessory(cachedAccessory);
+                }
+                else {
+                    log.debug(`Platform ${cachedAccessory.platform} does not implement configureMatterAccessory`);
+                }
+            }
+        }
+    }
+    static loadConfig() {
+        // Look for the configuration file
+        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;
+            }
+        }
+        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;
+            }
+        }
+        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);
+        // Validate Matter configuration for port conflicts
+        if (config.bridge.matter || config.platforms.some((p) => p._bridge?.matter) || config.accessories.some((a) => a._bridge?.matter)) {
+            // Validate main bridge Matter config
+            if (config.bridge.matter) {
+                const validation = MatterConfigValidator.validate(config.bridge.matter);
+                if (!validation.isValid) {
+                    log.error('Main bridge Matter configuration is invalid. Matter will not be enabled for the main bridge.');
+                    delete config.bridge.matter;
+                }
+            }
+            // Validate all child bridge Matter configs and check for port conflicts
+            const childMatterValidation = MatterConfigValidator.validateAllChildMatterConfigs(config.platforms, config.accessories);
+            if (!childMatterValidation.isValid) {
+                log.error('Some child bridge Matter configurations are invalid. Check the errors above.');
+            }
+            // Additionally, check for conflicts between main bridge Matter port and child bridge ports
+            if (config.bridge.matter?.port) {
+                const mainMatterPort = config.bridge.matter.port;
+                const childMatterPorts = [];
+                for (const platform of config.platforms) {
+                    if (platform._bridge?.matter?.port) {
+                        childMatterPorts.push(platform._bridge.matter.port);
+                    }
+                }
+                for (const accessory of config.accessories) {
+                    if (accessory._bridge?.matter?.port) {
+                        childMatterPorts.push(accessory._bridge.matter.port);
+                    }
+                }
+                if (childMatterPorts.includes(mainMatterPort)) {
+                    log.error(`Main bridge Matter port ${mainMatterPort} conflicts with a child bridge Matter port. Please use unique ports.`);
+                }
+                // Check for conflict with main bridge HAP port
+                if (config.bridge.port && Math.abs(config.bridge.port - mainMatterPort) < 10) {
+                    log.warn(`Main bridge HAP port ${config.bridge.port} and Matter port ${mainMatterPort} are very close. Consider spacing them further apart.`);
+                }
+            }
+        }
+        if (config.bridge.advertiser) {
+            if (![
+                "bonjour-hap" /* MDNSAdvertiser.BONJOUR */,
+                "ciao" /* MDNSAdvertiser.CIAO */,
+                "avahi" /* MDNSAdvertiser.AVAHI */,
+                "resolved" /* MDNSAdvertiser.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); // we rather count from 1 for the normal people?
+                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;
+            }
+            // 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;
+            }
+            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); // error message contains more information and full stack trace
+                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);
+                }
+                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" /* PluginType.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 {
+                    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); // we rather count from 1 for the normal people?
+                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;
+            }
+            try {
+                plugin = this.pluginManager.getPluginForPlatform(platformIdentifier);
+            }
+            catch (error) {
+                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;
+            }
+            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); // error message contains more information and full stack trace
+                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);
+                }
+                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);
+                this.childBridges.set(platformConfig._bridge.username, childBridge);
+                // add config to child bridge service
+                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)) { // Plugin 1.0, load accessories
+                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".');
+        }
+        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" /* PluginType.PLATFORM */) {
+                // only a single platform can exist on one child bridge
+                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.`);
+            }
+        }
+        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.`);
+        }
+    }
+    /**
+     * 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
+            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
+            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
+            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()));
+        });
+    }
+    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.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('                       '));
+        /* eslint-enable no-console */
+    }
+}
+//# sourceMappingURL=server.js.map