homebridge 2.0.0-beta.6 → 2.0.0-beta.60

package/dist/matter/server.js

@@ -0,0 +1,1508 @@
+import { randomBytes } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { constants } from 'node:fs';
+import { access, writeFile } from 'node:fs/promises';
+import { homedir, release } from 'node:os';
+import { join, normalize, resolve } from 'node:path';
+import process from 'node:process';
+import { Endpoint, Environment, Logger as MatterLogger, LogLevel as MatterLogLevel, ServerNode, StorageService, VendorId, } from '@matter/main';
+import { BridgedDeviceBasicInformationServer } from '@matter/main/behaviors';
+import * as clusters from '@matter/main/clusters';
+import * as devices from '@matter/main/devices';
+import { AggregatorEndpoint } from '@matter/main/endpoints';
+import { PowerSourceServer } from '@matter/node/behaviors';
+import { ManualPairingCodeCodec, QrPairingCodeCodec } from '@matter/types/schema';
+import fse from 'fs-extra';
+import QRCode from 'qrcode-terminal';
+import { Logger } from '../logger.js';
+import getVersion from '../version.js';
+import { MatterAccessoryCache } from './accessoryCache.js';
+import { BehaviorRegistry } from './behaviors/BehaviorRegistry.js';
+import { HomebridgeColorControlServer } from './behaviors/ColorControlBehavior.js';
+import { HomebridgeDoorLockServer } from './behaviors/DoorLockBehavior.js';
+import { HomebridgeFanControlServer } from './behaviors/FanControlBehavior.js';
+import { HomebridgeIdentifyServer } from './behaviors/IdentifyBehavior.js';
+import { HomebridgeLevelControlServer } from './behaviors/LevelControlBehavior.js';
+import { HomebridgeOnOffServer } from './behaviors/OnOffBehavior.js';
+import { RegistryManager } from './behaviors/RegistryManager.js';
+import { HomebridgeRvcCleanModeServer } from './behaviors/RvcCleanModeBehavior.js';
+import { HomebridgeRvcOperationalStateServer } from './behaviors/RvcOperationalStateBehavior.js';
+import { HomebridgeRvcRunModeServer } from './behaviors/RvcRunModeBehavior.js';
+import { HomebridgeServiceAreaServer } from './behaviors/ServiceAreaBehavior.js';
+import { HomebridgeThermostatServer } from './behaviors/ThermostatBehavior.js';
+import { HomebridgeWindowCoveringServer } from './behaviors/WindowCoveringBehavior.js';
+import { sanitizeUniqueId, truncateString, validatePort } from './configValidator.js';
+import { errorHandler } from './errorHandler.js';
+import { createHomebridgeLogFormatter } from './logFormatter.js';
+import { applyWindowCoveringFeatures, CLUSTER_IDS, detectBehaviorFeatures, detectWindowCoveringFeatures, determineColorControlFeaturesFromHandlers, extractColorControlFeatures, extractThermostatFeatures, validateAccessoryRequiredFields, } from './serverHelpers.js';
+import { MatterStorageManager } from './storage.js';
+import { isDeviceType, withBehaviors, withFeatures } from './typeHelpers.js';
+import { deviceTypes, MatterDeviceError, } from './types.js';
+const log = Logger.withPrefix('Matter/Server');
+const DEFAULT_MATTER_PORT = 5540;
+const DEFAULT_VENDOR_ID = 0xFFF1;
+const DEFAULT_PRODUCT_ID = 0x8001;
+const MAX_DEVICES_PER_BRIDGE = 1000;
+const SERVER_READY_TIMEOUT_MS = 5000;
+const SERVER_READY_POLL_INTERVAL_MS = 100;
+const SERVER_INIT_DELAY_MS = 200;
+const MAX_PASSCODE_ATTEMPTS = 100;
+export class MatterServer extends EventEmitter {
+    config;
+    serverNode = null;
+    aggregator = null;
+    accessories = new Map();
+    behaviorRegistry;
+    isRunning = false;
+    MAX_DEVICES = MAX_DEVICES_PER_BRIDGE;
+    shutdownHandler = null;
+    static CLUSTER_BEHAVIOR_MAP = {
+        onOff: HomebridgeOnOffServer,
+        levelControl: HomebridgeLevelControlServer,
+        colorControl: HomebridgeColorControlServer,
+        windowCovering: HomebridgeWindowCoveringServer,
+        doorLock: HomebridgeDoorLockServer,
+        fanControl: HomebridgeFanControlServer,
+        thermostat: HomebridgeThermostatServer,
+        rvcOperationalState: HomebridgeRvcOperationalStateServer,
+        rvcRunMode: HomebridgeRvcRunModeServer,
+        rvcCleanMode: HomebridgeRvcCleanModeServer,
+        serviceArea: HomebridgeServiceAreaServer,
+        identify: HomebridgeIdentifyServer,
+    };
+    passcode = 0;
+    discriminator = 0;
+    vendorId;
+    productId;
+    commissioningInfo = {};
+    serialNumber;
+    cleanupHandlers = [];
+    storageManager = null;
+    matterStoragePath;
+    accessoryCache = null;
+    monitoringEnabled = false;
+    username;
+    bridgeName;
+    constructor(config) {
+        super();
+        this.config = this.validateAndSanitizeConfig(config);
+        const cleanId = this.config.uniqueId.replace(/[^A-F0-9]/gi, '');
+        this.username = cleanId.match(/.{1,2}/g)?.slice(0, 6).join(':').toUpperCase() || this.config.uniqueId;
+        this.bridgeName = this.config.serialNumber ? `Matter Bridge ${this.config.serialNumber}` : 'Matter Bridge';
+        if (this.config.debugModeEnabled) {
+            log.info('Matter debug mode enabled - verbose logging active');
+            MatterLogger.level = MatterLogLevel.DEBUG;
+        }
+        else {
+            MatterLogger.level = MatterLogLevel.NOTICE;
+        }
+        MatterLogger.format = createHomebridgeLogFormatter();
+        MatterLogger.destinations.default.write = (text) => {
+            if (text.trim() !== '') {
+                console.log(text);
+            }
+        };
+        this.vendorId = DEFAULT_VENDOR_ID;
+        this.productId = DEFAULT_PRODUCT_ID;
+        this.behaviorRegistry = new BehaviorRegistry(this.accessories, this);
+    }
+    validateAndSanitizeConfig(config) {
+        const errors = [];
+        const port = config.port || DEFAULT_MATTER_PORT;
+        const portValidation = validatePort(port, false);
+        if (!portValidation.valid) {
+            errors.push(`Invalid port: ${portValidation.error}`);
+        }
+        if (!config.uniqueId) {
+            errors.push('uniqueId is required for Matter server configuration');
+        }
+        const rawUniqueId = config.uniqueId || '';
+        const uniqueIdResult = sanitizeUniqueId(rawUniqueId);
+        const uniqueId = uniqueIdResult.value;
+        if (uniqueId.length === 0) {
+            errors.push('Invalid uniqueId: must be a non-empty string');
+        }
+        let storagePath = config.storagePath;
+        if (storagePath !== undefined) {
+            storagePath = resolve(storagePath);
+        }
+        let manufacturer = config.manufacturer;
+        if (manufacturer !== undefined) {
+            manufacturer = truncateString(manufacturer, 32, 'Manufacturer name').value;
+        }
+        let model = config.model;
+        if (model !== undefined) {
+            model = truncateString(model, 32, 'Model name').value;
+        }
+        let firmwareRevision = config.firmwareRevision;
+        if (firmwareRevision !== undefined) {
+            firmwareRevision = truncateString(firmwareRevision, 64, 'Firmware revision').value;
+        }
+        let serialNumber = config.serialNumber;
+        if (serialNumber !== undefined) {
+            serialNumber = truncateString(serialNumber, 32, 'Serial number').value;
+        }
+        const debugModeEnabled = config.debugModeEnabled || false;
+        const externalAccessory = config.externalAccessory || false;
+        if (errors.length > 0) {
+            throw new MatterDeviceError(`Matter configuration validation failed:\n${errors.map(e => `  - ${e}`).join('\n')}`);
+        }
+        return {
+            port,
+            uniqueId,
+            storagePath,
+            manufacturer,
+            model,
+            firmwareRevision,
+            serialNumber,
+            debugModeEnabled,
+            externalAccessory,
+        };
+    }
+    generateSecurePasscode() {
+        let passcode;
+        const maxAttempts = MAX_PASSCODE_ATTEMPTS;
+        let attempts = 0;
+        const invalidPasscodes = [
+            0,
+            11111111,
+            22222222,
+            33333333,
+            44444444,
+            55555555,
+            66666666,
+            77777777,
+            88888888,
+            99999999,
+            12345678,
+            87654321,
+        ];
+        do {
+            const randomValue = randomBytes(4).readUInt32BE(0);
+            passcode = (randomValue % 99999998) + 1;
+            attempts++;
+            if (attempts > maxAttempts) {
+                throw new Error('Failed to generate secure passcode after maximum attempts');
+            }
+        } while (invalidPasscodes.includes(passcode)
+            || !this.isValidPasscode(passcode));
+        return passcode;
+    }
+    isValidPasscode(passcode) {
+        if (passcode < 1 || passcode > 99999998) {
+            return false;
+        }
+        const passcodeStr = passcode.toString().padStart(8, '0');
+        let isSequential = true;
+        for (let i = 1; i < passcodeStr.length; i++) {
+            if (Number.parseInt(passcodeStr[i]) !== Number.parseInt(passcodeStr[i - 1]) + 1) {
+                isSequential = false;
+                break;
+            }
+        }
+        if (isSequential) {
+            return false;
+        }
+        let isReverseSequential = true;
+        for (let i = 1; i < passcodeStr.length; i++) {
+            if (Number.parseInt(passcodeStr[i]) !== Number.parseInt(passcodeStr[i - 1]) - 1) {
+                isReverseSequential = false;
+                break;
+            }
+        }
+        if (isReverseSequential) {
+            return false;
+        }
+        const digitCounts = new Map();
+        for (const digit of passcodeStr) {
+            digitCounts.set(digit, (digitCounts.get(digit) || 0) + 1);
+            const count = digitCounts.get(digit);
+            if (count !== undefined && count > 3) {
+                return false;
+            }
+        }
+        return true;
+    }
+    generateRandomDiscriminator() {
+        const discriminator = randomBytes(2).readUInt16BE(0) & 0x0FFF;
+        if (discriminator < 0 || discriminator > 4095) {
+            throw new Error(`Invalid discriminator generated: ${discriminator}`);
+        }
+        return discriminator;
+    }
+    async createServerNodeWithRecovery(nodeOptions, sanitizedId) {
+        try {
+            return await ServerNode.create(nodeOptions);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : '';
+            const causeMessage = error instanceof Error && error.cause instanceof Error ? error.cause.message : '';
+            const isStorageError = errorMessage.includes('Invalid public key encoding')
+                || errorMessage.includes('FabricManager unavailable')
+                || errorMessage.includes('key-input')
+                || causeMessage.includes('Invalid public key encoding');
+            if (!isStorageError) {
+                throw error;
+            }
+            log.warn('Detected corrupted Matter storage, attempting automatic recovery...');
+            const environment = Environment.default;
+            const storageService = environment.get(StorageService);
+            const storageLocation = storageService.location;
+            if (!storageLocation) {
+                throw new Error('Storage location not set, cannot recover from corrupted storage');
+            }
+            const serverNodeStorePath = join(storageLocation, sanitizedId);
+            const serverNodeStoreJsonFile = `${serverNodeStorePath}.json`;
+            try {
+                let removedSomething = false;
+                try {
+                    await fse.stat(serverNodeStorePath);
+                    log.info(`Removing corrupted ServerNodeStore directory: ${serverNodeStorePath}`);
+                    await fse.remove(serverNodeStorePath);
+                    removedSomething = true;
+                }
+                catch (err) {
+                    const code = err instanceof Error && 'code' in err ? err.code : undefined;
+                    if (code !== 'ENOENT') {
+                        throw err;
+                    }
+                }
+                try {
+                    await fse.stat(serverNodeStoreJsonFile);
+                    log.info(`Removing corrupted ServerNodeStore JSON file: ${serverNodeStoreJsonFile}`);
+                    await fse.remove(serverNodeStoreJsonFile);
+                    removedSomething = true;
+                }
+                catch (err) {
+                    const code = err instanceof Error && 'code' in err ? err.code : undefined;
+                    if (code !== 'ENOENT') {
+                        throw err;
+                    }
+                }
+                if (removedSomething) {
+                    log.info('Corrupted storage removed, retrying ServerNode creation...');
+                }
+                else {
+                    log.warn('No corrupted storage files found, corruption may be elsewhere');
+                }
+                const serverNode = await ServerNode.create(nodeOptions);
+                log.info('Successfully recovered from corrupted Matter storage');
+                return serverNode;
+            }
+            catch (retryError) {
+                log.error('Failed to recover from corrupted storage:', retryError);
+                log.error('Original error:', error);
+                throw new Error('Matter storage is corrupted and automatic recovery failed. '
+                    + `Please manually delete: ${serverNodeStorePath}`);
+            }
+        }
+    }
+    async start() {
+        if (this.isRunning) {
+            log.warn('Matter server is already running');
+            return;
+        }
+        try {
+            log.info('Starting Matter.js server...');
+            await this.setupStorage();
+            await this.loadOrGenerateCredentials();
+            log.info(`Configuration: Port=${this.config.port}, Passcode=${this.passcode}, Discriminator=${this.discriminator}`);
+            if (this.config.networkInterfaces && this.config.networkInterfaces.length > 0) {
+                const environment = Environment.default;
+                const interfaceConfig = {};
+                for (const interfaceName of this.config.networkInterfaces) {
+                    interfaceConfig[interfaceName] = { type: 2 };
+                }
+                environment.vars.set('network.interface', interfaceConfig);
+                log.info(`Configured Matter server to use network interfaces: ${this.config.networkInterfaces.join(', ')}`);
+            }
+            else {
+                log.debug('No network interfaces specified, using all available interfaces');
+            }
+            const commissioningOptions = {
+                passcode: this.passcode,
+                discriminator: this.discriminator,
+            };
+            log.info(`Using commissioning credentials: passcode=${this.passcode}, discriminator=${this.discriminator}`);
+            const displayName = this.config.externalAccessory
+                ? (this.config.model || 'Matter Device')
+                : 'Homebridge Matter Bridge';
+            const sanitizedId = this.config.uniqueId;
+            const nodeOptions = {
+                id: sanitizedId,
+                network: {
+                    port: this.config.port,
+                    ipv4: true,
+                },
+                commissioning: commissioningOptions,
+                basicInformation: {
+                    nodeLabel: displayName.slice(0, 32),
+                    vendorId: VendorId(this.vendorId),
+                    vendorName: (this.config.manufacturer || 'Homebridge').slice(0, 32),
+                    productId: this.productId,
+                    productName: displayName.slice(0, 32),
+                    productLabel: displayName.slice(0, 64),
+                    serialNumber: this.serialNumber = this.config.serialNumber || this.config.uniqueId,
+                    hardwareVersion: 1,
+                    hardwareVersionString: release(),
+                    softwareVersion: 1,
+                    softwareVersionString: this.config.firmwareRevision || getVersion(),
+                    reachable: true,
+                },
+            };
+            if (!this.config.externalAccessory) {
+                nodeOptions.productDescription = {
+                    name: displayName,
+                    deviceType: AggregatorEndpoint.deviceType,
+                };
+            }
+            this.serverNode = await this.createServerNodeWithRecovery(nodeOptions, sanitizedId);
+            this.setupCommissioningEventListeners();
+            if (!this.config.externalAccessory) {
+                this.aggregator = new Endpoint(AggregatorEndpoint, {
+                    id: 'homebridge-aggregator',
+                });
+                await this.serverNode.add(this.aggregator);
+                log.debug('Created aggregator endpoint for bridged mode');
+            }
+            else {
+                log.debug('External accessory mode - skipping aggregator creation');
+            }
+            await this.generateCommissioningInfo();
+            this.shutdownHandler = async () => {
+                log.info('Shutting down Matter server...');
+                await this.stop();
+            };
+            process.on('SIGINT', this.shutdownHandler);
+            process.on('SIGTERM', this.shutdownHandler);
+            if (!this.config.externalAccessory) {
+                this.serverNode.run().then(() => {
+                    log.info('Matter server stopped normally');
+                }, (error) => {
+                    log.error('Matter server stopped with error:', error);
+                    errorHandler.handleError(error, 'server-runtime');
+                });
+                await this.waitForServerReady();
+                if (this.accessoryCache) {
+                    const loaded = await this.accessoryCache.load();
+                    log.debug(`Matter cache loaded: ${loaded.size} accessories`);
+                }
+                else {
+                    log.debug('No accessory cache available');
+                }
+                this.updateCommissioningFile().catch((error) => {
+                    log.warn('Failed to update commissioning file on startup:', error);
+                });
+                this.isRunning = true;
+            }
+            else {
+                log.debug('Deferred start mode - server prepared but not running yet (will start after device registration)');
+            }
+            log.info(`Matter server started successfully on port ${this.config.port}`);
+            log.info('Plugins can now register Matter accessories via the API');
+        }
+        catch (error) {
+            log.error('Failed to start Matter server:', error);
+            await this.cleanup();
+            throw error;
+        }
+    }
+    async runServer() {
+        if (!this.serverNode) {
+            throw new MatterDeviceError('Server node not initialized - call start() first');
+        }
+        if (this.isRunning) {
+            log.warn('Matter server is already running');
+            return;
+        }
+        if (!this.config.externalAccessory) {
+            throw new MatterDeviceError('runServer() should only be called when externalAccessory mode is enabled');
+        }
+        log.debug('Running deferred server with device(s) already attached');
+        this.serverNode.run().then(() => {
+            log.info('Matter server stopped normally');
+        }, (error) => {
+            log.error('Matter server stopped with error:', error);
+            errorHandler.handleError(error, 'server-runtime');
+        });
+        await this.waitForServerReady();
+        if (this.accessoryCache) {
+            const loaded = await this.accessoryCache.load();
+            log.debug(`Matter cache loaded: ${loaded.size} accessories`);
+        }
+        else {
+            log.debug('No accessory cache available');
+        }
+        this.updateCommissioningFile().catch((error) => {
+            log.warn('Failed to update commissioning file on startup:', error);
+        });
+        this.isRunning = true;
+        log.info('Matter server is now running');
+    }
+    async setupStorage() {
+        if (!this.config.storagePath) {
+            throw new Error('Storage path is required for Matter server');
+        }
+        const storagePath = resolve(this.config.storagePath);
+        const normalizedPath = normalize(storagePath);
+        const allowedBasePaths = [
+            resolve(homedir(), '.homebridge'),
+            resolve(process.cwd()),
+            '/var/lib/homebridge',
+        ];
+        const isAllowed = allowedBasePaths.some(basePath => normalizedPath.startsWith(basePath));
+        if (!isAllowed || normalizedPath.includes('..')) {
+            throw new Error(`Storage path not allowed: ${normalizedPath}. Must be within homebridge directories.`);
+        }
+        try {
+            await fse.ensureDir(normalizedPath);
+            await access(normalizedPath, constants.R_OK | constants.W_OK);
+        }
+        catch (error) {
+            throw new Error(`Storage path not accessible: ${error}`);
+        }
+        const bridgeId = this.config.uniqueId || 'default';
+        this.matterStoragePath = join(normalizedPath, bridgeId);
+        await fse.ensureDir(this.matterStoragePath);
+        this.storageManager = new MatterStorageManager(this.matterStoragePath);
+        this.accessoryCache = new MatterAccessoryCache(normalizedPath, bridgeId);
+        const environment = Environment.default;
+        const storageService = environment.get(StorageService);
+        storageService.location = this.matterStoragePath;
+        storageService.factory = (namespace) => {
+            if (!this.storageManager) {
+                throw new Error('Storage manager not initialized');
+            }
+            const storage = this.storageManager.getStorage(namespace);
+            storage.initialize().catch((error) => {
+                log.error(`Failed to initialize storage namespace ${namespace}:`, error);
+            });
+            return storage;
+        };
+        this.cleanupHandlers.push(async () => {
+            if (this.storageManager) {
+                await this.storageManager.closeAll();
+            }
+        });
+        log.info(`Matter storage initialized at: ${this.matterStoragePath}`);
+    }
+    async loadOrGenerateCredentials() {
+        if (!this.storageManager) {
+            throw new Error('Storage manager not initialized');
+        }
+        const storage = this.storageManager.getStorage('credentials');
+        await storage.initialize();
+        const storedPasscode = storage.get([], 'passcode');
+        const storedDiscriminator = storage.get([], 'discriminator');
+        if (storedPasscode && storedDiscriminator) {
+            log.info('Loading existing commissioning credentials from storage');
+            this.passcode = storedPasscode;
+            this.discriminator = storedDiscriminator;
+        }
+        else {
+            log.info('Generating new commissioning credentials');
+            this.passcode = this.generateSecurePasscode();
+            this.discriminator = this.generateRandomDiscriminator();
+            storage.set([], 'passcode', this.passcode);
+            storage.set([], 'discriminator', this.discriminator);
+            log.info('Commissioning credentials saved to storage');
+        }
+    }
+    async generateCommissioningInfo() {
+        const passcode = this.passcode.toString().padStart(8, '0');
+        const discriminator = this.discriminator;
+        const vendorId = this.vendorId;
+        const productId = this.productId;
+        const manualCode = ManualPairingCodeCodec.encode({
+            discriminator,
+            passcode: this.passcode,
+        });
+        const manualPairingCode = `${manualCode.slice(0, 4)}-${manualCode.slice(4, 7)}-${manualCode.slice(7, 11)}`;
+        log.info(`Encoding QR code with: passcode=${this.passcode}, discriminator=${discriminator}, vendorId=${vendorId}, productId=${productId}`);
+        const qrCodePayload = QrPairingCodeCodec.encode([{
+                version: 0,
+                vendorId,
+                productId,
+                flowType: 0,
+                discoveryCapabilities: 4,
+                discriminator,
+                passcode: this.passcode,
+            }]);
+        log.info(`Generated QR code: ${qrCodePayload}`);
+        log.info(`Generated manual code: ${manualPairingCode}`);
+        this.commissioningInfo = {
+            qrCode: qrCodePayload,
+            manualPairingCode,
+        };
+        try {
+            if (!this.matterStoragePath) {
+                throw new Error('Matter storage path not initialized');
+            }
+            const commissioningFilePath = join(this.matterStoragePath, 'commissioning.json');
+            const commissioningData = {
+                qrCode: qrCodePayload,
+                manualPairingCode,
+                serialNumber: this.serialNumber,
+                passcode: this.passcode,
+                discriminator: this.discriminator,
+                commissioned: this.isCommissioned(),
+            };
+            await writeFile(commissioningFilePath, JSON.stringify(commissioningData, null, 2), 'utf-8');
+            log.debug(`Saved commissioning info to ${commissioningFilePath}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log.warn(`Failed to save commissioning info to disk: ${errorMessage}`);
+        }
+        log.info(`${'='.repeat(60)}`);
+        log.info('📱 MATTER COMMISSIONING INFORMATION');
+        log.info('='.repeat(60));
+        log.info(`Manual Pairing Code: ${manualPairingCode}`);
+        log.info(`Passcode: ${passcode}`);
+        log.info(`Discriminator: ${discriminator}`);
+        log.info('QR Code for commissioning:');
+        QRCode.generate(qrCodePayload, { small: true }, (qrcode) => {
+            console.log(qrcode);
+        });
+        log.info(`${'='.repeat(60)}`);
+    }
+    async waitForServerReady(maxWaitTime = SERVER_READY_TIMEOUT_MS) {
+        const startTime = Date.now();
+        while (!this.serverNode || (!this.config.externalAccessory && !this.aggregator)) {
+            if (Date.now() - startTime > maxWaitTime) {
+                throw new Error('Server failed to become ready within timeout');
+            }
+            await new Promise(resolve => setTimeout(resolve, SERVER_READY_POLL_INTERVAL_MS));
+        }
+        await new Promise(resolve => setTimeout(resolve, SERVER_INIT_DELAY_MS));
+    }
+    setupCommissioningEventListeners() {
+        if (!this.serverNode) {
+            log.warn('Cannot set up commissioning event listeners - serverNode not initialized');
+            return;
+        }
+        log.debug('Setting up commissioning event listeners');
+        try {
+            this.serverNode.events.commissioning.fabricsChanged.on((fabricIndex, action) => {
+                log.info(`Fabric ${action}: index ${fabricIndex}`);
+                this.updateCommissioningFile().catch((error) => {
+                    log.warn('Failed to update commissioning file after fabric change:', error);
+                });
+                const commissioned = this.isCommissioned();
+                const fabricCount = this.getCommissionedFabricCount();
+                this.emit('commissioning-status-changed', commissioned, fabricCount);
+            });
+            this.serverNode.events.commissioning.commissioned.on(() => {
+                log.info('Bridge commissioned');
+                this.updateCommissioningFile().catch((error) => {
+                    log.warn('Failed to update commissioning file after commissioning:', error);
+                });
+                const fabricCount = this.getCommissionedFabricCount();
+                this.emit('commissioning-status-changed', true, fabricCount);
+            });
+            this.serverNode.events.commissioning.decommissioned.on(() => {
+                log.info('Bridge decommissioned');
+                this.updateCommissioningFile().catch((error) => {
+                    log.warn('Failed to update commissioning file after decommissioning:', error);
+                });
+                this.emit('commissioning-status-changed', false, 0);
+            });
+            log.debug('Commissioning event listeners registered successfully');
+        }
+        catch (error) {
+            log.error('Failed to set up commissioning event listeners:', error);
+        }
+    }
+    async updateCommissioningFile() {
+        try {
+            if (!this.matterStoragePath) {
+                return;
+            }
+            const commissioningFilePath = join(this.matterStoragePath, 'commissioning.json');
+            const commissioningData = {
+                qrCode: this.commissioningInfo.qrCode,
+                manualPairingCode: this.commissioningInfo.manualPairingCode,
+                serialNumber: this.serialNumber,
+                passcode: this.passcode,
+                discriminator: this.discriminator,
+                commissioned: this.isCommissioned(),
+                fabricCount: this.getCommissionedFabricCount(),
+                fabrics: this.getFabricInfo(),
+            };
+            await writeFile(commissioningFilePath, JSON.stringify(commissioningData, null, 2), 'utf-8');
+            log.debug('Updated commissioning info file');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log.debug(`Failed to update commissioning info file: ${errorMessage}`);
+        }
+    }
+    async registerPlatformAccessories(pluginIdentifier, platformName, accessories) {
+        for (const accessory of accessories) {
+            await this.registerAccessory(pluginIdentifier, platformName, accessory);
+        }
+    }
+    async unregisterPlatformAccessories(pluginIdentifier, platformName, accessories) {
+        for (const accessory of accessories) {
+            await this.unregisterAccessory(accessory.UUID);
+        }
+    }
+    async updatePlatformAccessories(accessories) {
+        if (!this.accessoryCache) {
+            log.warn('Cannot update Matter platform accessories - cache not initialized');
+            return;
+        }
+        for (const accessory of accessories) {
+            const internal = accessory;
+            if (!this.accessories.has(accessory.UUID)) {
+                log.warn(`Cannot update Matter accessory ${accessory.UUID} - not registered in current session`);
+                continue;
+            }
+            if (!this.accessoryCache.hasCached(accessory.UUID)) {
+                log.warn(`Cannot update Matter accessory ${accessory.UUID} - not found in cache`);
+                continue;
+            }
+            this.accessories.set(accessory.UUID, internal);
+            log.debug(`Updated Matter accessory ${accessory.UUID} (${accessory.displayName})`);
+        }
+        this.accessoryCache.requestSave(this.accessories);
+    }
+    async registerAccessory(pluginIdentifier, platformName, accessory) {
+        if (!this.serverNode || (!this.config.externalAccessory && !this.aggregator)) {
+            throw new MatterDeviceError('Matter server not started');
+        }
+        validateAccessoryRequiredFields(accessory);
+        if (this.accessories.has(accessory.UUID)) {
+            const existing = this.accessories.get(accessory.UUID);
+            throw new MatterDeviceError(`Matter accessory with UUID "${accessory.UUID}" is already registered.\n`
+                + `Existing accessory: "${existing?.displayName}"\n`
+                + `New accessory: "${accessory.displayName}"\n`
+                + 'Each accessory must have a unique UUID. Use api.hap.uuid.generate() with a unique string.');
+        }
+        this.restoreCachedState(accessory);
+        if (this.accessories.size >= this.MAX_DEVICES) {
+            throw new MatterDeviceError(`Cannot register Matter accessory "${accessory.displayName}": `
+                + `Maximum device limit reached (${this.MAX_DEVICES} devices).\n`
+                + `Current registered devices: ${this.accessories.size}`);
+        }
+        try {
+            let deviceType = accessory.deviceType;
+            const windowCoveringFeatures = detectWindowCoveringFeatures(accessory);
+            if (windowCoveringFeatures.length > 0) {
+                deviceType = applyWindowCoveringFeatures(deviceType, accessory, windowCoveringFeatures);
+            }
+            const features = this.detectClusterFeatures(accessory, deviceType);
+            const customBehaviors = await this.buildCustomBehaviors(accessory, deviceType, features);
+            if (customBehaviors.length > 0) {
+                deviceType = withBehaviors(deviceType, customBehaviors);
+                log.info(`Applied ${customBehaviors.length} custom behavior(s) to device type`);
+            }
+            if (!this.config.externalAccessory) {
+                deviceType = withBehaviors(deviceType, [BridgedDeviceBasicInformationServer]);
+                log.debug(`Added BridgedDeviceBasicInformationServer to ${accessory.displayName}`);
+            }
+            const endpointOptions = this.createEndpointOptions(accessory);
+            const endpoint = new Endpoint(deviceType, endpointOptions);
+            if (this.config.debugModeEnabled) {
+                log.debug(`Created endpoint for ${accessory.displayName} with initial cluster states`);
+            }
+            if (this.config.externalAccessory) {
+                await this.serverNode.add(endpoint);
+                log.debug(`Added ${accessory.displayName} as external accessory to ServerNode`);
+            }
+            else {
+                await this.aggregator.add(endpoint);
+                if (this.config.debugModeEnabled) {
+                    log.debug(`Added endpoint for ${accessory.displayName} to aggregator`);
+                }
+            }
+            this.registerAccessoryHandlers(accessory);
+            const internalParts = await this.createAccessoryParts(accessory);
+            await this.finalizeAccessoryRegistration(accessory, endpoint, internalParts);
+        }
+        catch (error) {
+            log.error(`Failed to register Matter accessory ${accessory.displayName}:`, error);
+            throw new MatterDeviceError(`Failed to register accessory: ${error}`);
+        }
+    }
+    restoreCachedState(accessory) {
+        if (this.accessoryCache && this.accessoryCache.hasCached(accessory.UUID)) {
+            const cached = this.accessoryCache.getCached(accessory.UUID);
+            if (cached?.clusters && accessory.clusters) {
+                for (const [clusterName, cachedAttrs] of Object.entries(cached.clusters)) {
+                    if (!accessory.clusters[clusterName]) {
+                        accessory.clusters[clusterName] = cachedAttrs;
+                    }
+                    else {
+                        accessory.clusters[clusterName] = {
+                            ...accessory.clusters[clusterName],
+                            ...cachedAttrs,
+                        };
+                    }
+                }
+                if (cached.context) {
+                    accessory.context = cached.context;
+                }
+                log.info(`Restored cached state for Matter accessory: ${accessory.displayName}`);
+            }
+        }
+    }
+    detectClusterFeatures(accessory, deviceType) {
+        const windowCoveringFeatures = detectWindowCoveringFeatures(accessory);
+        let serviceAreaFeatures = null;
+        if (accessory.clusters?.serviceArea) {
+            const features = [];
+            if (accessory.clusters.serviceArea.supportedMaps) {
+                features.push('Maps');
+            }
+            if (accessory.clusters.serviceArea.progress !== undefined) {
+                features.push('ProgressReporting');
+            }
+            if (features.length > 0) {
+                serviceAreaFeatures = features;
+                log.info(`ServiceArea features will be enabled for ${accessory.displayName}: ${features.join(', ')}`);
+            }
+        }
+        let colorControlFeatures = null;
+        if (accessory.handlers?.colorControl) {
+            colorControlFeatures = detectBehaviorFeatures(deviceType, CLUSTER_IDS.COLOR_CONTROL, extractColorControlFeatures);
+            if (colorControlFeatures) {
+                colorControlFeatures = determineColorControlFeaturesFromHandlers(accessory.handlers.colorControl);
+            }
+        }
+        let thermostatFeatures = null;
+        if (accessory.handlers?.thermostat) {
+            thermostatFeatures = detectBehaviorFeatures(deviceType, CLUSTER_IDS.THERMOSTAT, extractThermostatFeatures);
+        }
+        return {
+            windowCoveringFeatures,
+            serviceAreaFeatures,
+            colorControlFeatures,
+            thermostatFeatures,
+        };
+    }
+    async buildCustomBehaviors(accessory, deviceType, features) {
+        const customBehaviors = [];
+        if (!accessory.handlers) {
+            return customBehaviors;
+        }
+        log.debug(`[${accessory.displayName}] Has handlers: ${Object.keys(accessory.handlers).join(', ')}`);
+        const behaviorMap = MatterServer.CLUSTER_BEHAVIOR_MAP;
+        if (isDeviceType(deviceType, devices.RoboticVacuumCleanerDevice)) {
+            const { RvcCleanModeServer, ServiceAreaServer } = devices.RoboticVacuumCleanerRequirements;
+            if (accessory.clusters?.rvcCleanMode) {
+                if (accessory.handlers?.rvcCleanMode) {
+                    const behaviorClass = HomebridgeRvcCleanModeServer;
+                    customBehaviors.push(behaviorClass);
+                    log.info('Adding custom RvcCleanMode behavior with handlers');
+                }
+                else {
+                    customBehaviors.push(RvcCleanModeServer);
+                    log.info('Adding base RvcCleanMode server');
+                }
+            }
+            if (accessory.clusters?.serviceArea) {
+                if (accessory.handlers?.serviceArea) {
+                    let behaviorClass = HomebridgeServiceAreaServer;
+                    if (features.serviceAreaFeatures && features.serviceAreaFeatures.length > 0) {
+                        behaviorClass = withFeatures(behaviorClass, features.serviceAreaFeatures);
+                        log.info(`ServiceArea custom behavior will have features: ${features.serviceAreaFeatures.join(', ')}`);
+                    }
+                    customBehaviors.push(behaviorClass);
+                    log.info('Adding custom ServiceArea behavior with handlers');
+                }
+                else {
+                    let behaviorClass = ServiceAreaServer;
+                    if (features.serviceAreaFeatures && features.serviceAreaFeatures.length > 0) {
+                        behaviorClass = withFeatures(behaviorClass, features.serviceAreaFeatures);
+                        log.info(`ServiceArea base server will have features: ${features.serviceAreaFeatures.join(', ')}`);
+                    }
+                    customBehaviors.push(behaviorClass);
+                    log.info('Adding base ServiceArea server');
+                }
+            }
+            if (accessory.clusters?.powerSource) {
+                const hasBattery = accessory.clusters.powerSource.batPercentRemaining !== undefined
+                    || accessory.clusters.powerSource.batChargeLevel !== undefined;
+                let powerSourceBehavior = PowerSourceServer;
+                if (hasBattery) {
+                    powerSourceBehavior = withFeatures(PowerSourceServer, ['Battery']);
+                    log.debug('Adding PowerSource server with battery feature');
+                }
+                else {
+                    log.debug('Adding base PowerSource server');
+                }
+                customBehaviors.push(powerSourceBehavior);
+            }
+        }
+        for (const clusterName of Object.keys(accessory.handlers || {})) {
+            const skipWindowCoveringBehavior = accessory.context?._skipWindowCoveringBehavior;
+            if (clusterName === 'windowCovering' && skipWindowCoveringBehavior) {
+                log.debug('Skipping custom WindowCovering behavior (using base server with features instead)');
+                continue;
+            }
+            if (clusterName === 'rvcCleanMode' || clusterName === 'serviceArea' || clusterName === 'powerSource') {
+                continue;
+            }
+            let behaviorClass = behaviorMap[clusterName];
+            if (clusterName === 'colorControl' && behaviorClass && features.colorControlFeatures && features.colorControlFeatures.length > 0) {
+                behaviorClass = withFeatures(behaviorClass, features.colorControlFeatures);
+                log.info(`ColorControl custom behavior will preserve features: ${features.colorControlFeatures.join(', ')}`);
+            }
+            if (clusterName === 'thermostat' && behaviorClass && features.thermostatFeatures && features.thermostatFeatures.length > 0) {
+                behaviorClass = withFeatures(behaviorClass, features.thermostatFeatures);
+                log.info(`Thermostat custom behavior will preserve features: ${features.thermostatFeatures.join(', ')}`);
+            }
+            if (clusterName === 'serviceArea' && behaviorClass && features.serviceAreaFeatures && features.serviceAreaFeatures.length > 0) {
+                behaviorClass = withFeatures(behaviorClass, features.serviceAreaFeatures);
+                log.info(`ServiceArea custom behavior will preserve features: ${features.serviceAreaFeatures.join(', ')}`);
+            }
+            if (clusterName === 'windowCovering') {
+                log.debug(`WindowCovering handler found: behaviorClass=${!!behaviorClass}, windowCoveringFeatures=${features.windowCoveringFeatures}, length=${features.windowCoveringFeatures?.length}`);
+                if (behaviorClass && features.windowCoveringFeatures && features.windowCoveringFeatures.length > 0) {
+                    behaviorClass = withFeatures(behaviorClass, features.windowCoveringFeatures);
+                    log.debug(`WindowCovering custom behavior will have features: ${features.windowCoveringFeatures.join(', ')}`);
+                }
+                else {
+                    log.debug(`Skipping WindowCovering feature application: behaviorClass=${!!behaviorClass}, features=${features.windowCoveringFeatures}`);
+                }
+            }
+            if (behaviorClass) {
+                customBehaviors.push(behaviorClass);
+                log.info(`Will use ${behaviorClass.name} for ${accessory.displayName}`);
+            }
+            else {
+                log.warn(`No custom behavior class available for cluster '${clusterName}' - handlers will be registered but may not be called`);
+            }
+        }
+        return customBehaviors;
+    }
+    createEndpointOptions(accessory) {
+        const endpointOptions = {
+            id: accessory.UUID,
+            ...accessory.clusters,
+        };
+        if (!this.config.externalAccessory) {
+            endpointOptions.bridgedDeviceBasicInformation = {
+                vendorName: accessory.manufacturer,
+                nodeLabel: accessory.displayName,
+                productName: accessory.model,
+                productLabel: accessory.displayName,
+                serialNumber: accessory.serialNumber,
+                reachable: true,
+            };
+        }
+        return endpointOptions;
+    }
+    registerAccessoryHandlers(accessory) {
+        if (!accessory.handlers) {
+            return;
+        }
+        log.info(`Setting up handlers for accessory ${accessory.UUID}`);
+        RegistryManager.registerEndpoint(accessory.UUID, this.behaviorRegistry);
+        for (const [clusterName, handlers] of Object.entries(accessory.handlers)) {
+            log.info(`  Processing cluster: ${clusterName}`);
+            for (const [commandName, handler] of Object.entries(handlers)) {
+                this.behaviorRegistry.registerHandler(accessory.UUID, clusterName, commandName, handler);
+            }
+        }
+    }
+    async createAccessoryParts(accessory) {
+        const internalParts = [];
+        if (!accessory.parts || accessory.parts.length === 0) {
+            return internalParts;
+        }
+        log.info(`Creating ${accessory.parts.length} child endpoint(s) for ${accessory.displayName}`);
+        for (const part of accessory.parts) {
+            const partEndpointId = `${accessory.UUID}-part-${part.id}`;
+            this.behaviorRegistry.registerPartEndpoint(partEndpointId, accessory.UUID, part.id);
+            let partDeviceType = part.deviceType;
+            const partCustomBehaviors = [];
+            if (part.handlers) {
+                const partBehaviorMap = MatterServer.CLUSTER_BEHAVIOR_MAP;
+                for (const clusterName of Object.keys(part.handlers)) {
+                    const behaviorClass = partBehaviorMap[clusterName];
+                    if (behaviorClass) {
+                        partCustomBehaviors.push(behaviorClass);
+                        log.info(`  Will use ${behaviorClass.name} for part ${part.id}`);
+                    }
+                    else {
+                        log.warn(`No custom behavior class available for cluster '${clusterName}' on part ${part.id}`);
+                    }
+                }
+                if (partCustomBehaviors.length > 0) {
+                    partDeviceType = withBehaviors(partDeviceType, partCustomBehaviors);
+                    log.info(`  Applied ${partCustomBehaviors.length} custom behavior(s) to part ${part.id}`);
+                }
+            }
+            if (!this.config.externalAccessory) {
+                partDeviceType = withBehaviors(partDeviceType, [BridgedDeviceBasicInformationServer]);
+            }
+            const partEndpointOptions = {
+                id: partEndpointId,
+                ...part.clusters,
+            };
+            if (!this.config.externalAccessory) {
+                partEndpointOptions.bridgedDeviceBasicInformation = {
+                    vendorName: accessory.manufacturer,
+                    nodeLabel: part.displayName || `${accessory.displayName} - ${part.id}`,
+                    productName: accessory.model,
+                    productLabel: part.displayName || part.id,
+                    serialNumber: `${accessory.serialNumber}-${part.id}`,
+                    reachable: true,
+                };
+            }
+            const partEndpoint = new Endpoint(partDeviceType, partEndpointOptions);
+            if (this.config.externalAccessory) {
+                await this.serverNode.add(partEndpoint);
+            }
+            else {
+                await this.aggregator.add(partEndpoint);
+            }
+            log.info(`  Created part endpoint: ${part.displayName || part.id} (${partEndpointId})`);
+            if (part.handlers) {
+                RegistryManager.registerEndpoint(partEndpointId, this.behaviorRegistry);
+                for (const [clusterName, handlers] of Object.entries(part.handlers)) {
+                    for (const [commandName, handler] of Object.entries(handlers)) {
+                        this.behaviorRegistry.registerHandler(partEndpointId, clusterName, commandName, handler);
+                    }
+                }
+                log.debug(`  Registered ${Object.keys(part.handlers).length} handler(s) for part ${part.id}`);
+            }
+            internalParts.push({
+                ...part,
+                endpoint: partEndpoint,
+            });
+        }
+        return internalParts;
+    }
+    async finalizeAccessoryRegistration(accessory, endpoint, internalParts) {
+        const internalAccessory = {
+            ...accessory,
+            endpoint,
+            registered: true,
+            _parts: internalParts.length > 0 ? internalParts : undefined,
+            _eventEmitter: new EventEmitter(),
+        };
+        this.accessories.set(accessory.UUID, internalAccessory);
+        log.info(`Registered Matter accessory: ${accessory.displayName} (${accessory.UUID})`);
+        if (this.config.debugModeEnabled) {
+            log.debug(`Total registered accessories: ${this.accessories.size}/${this.MAX_DEVICES}`);
+        }
+        await this.notifyPartsListChanged();
+        if (this.accessoryCache) {
+            this.accessoryCache.requestSave(this.accessories);
+        }
+        if (this.monitoringEnabled && process.send) {
+            const event = {
+                type: 'accessoryAdded',
+                data: { uuid: accessory.UUID },
+            };
+            process.send({
+                id: "matterEvent",
+                data: event,
+            });
+        }
+    }
+    async unregisterAccessory(uuid) {
+        const accessory = this.accessories.get(uuid);
+        if (!accessory) {
+            log.debug(`Accessory ${uuid} not found or not registered`);
+            if (this.accessoryCache && this.accessoryCache.getCached(uuid)) {
+                log.debug(`Removing ${uuid} from cache`);
+                this.accessoryCache.removeCached(uuid);
+                this.accessoryCache.requestSave(this.accessories);
+            }
+            return;
+        }
+        try {
+            if (accessory.endpoint && this.aggregator) {
+                await accessory.endpoint.close();
+                log.debug(`Removed endpoint for ${accessory.displayName}`);
+            }
+            this.accessories.delete(uuid);
+            log.info(`Unregistered Matter accessory: ${accessory.displayName} (${uuid})`);
+            await this.notifyPartsListChanged();
+            if (this.accessoryCache) {
+                this.accessoryCache.removeCached(uuid);
+                this.accessoryCache.requestSave(this.accessories);
+            }
+            if (this.monitoringEnabled && process.send) {
+                const event = {
+                    type: 'accessoryRemoved',
+                    data: { uuid },
+                };
+                process.send({
+                    id: "matterEvent",
+                    data: event,
+                });
+            }
+        }
+        catch (error) {
+            log.error(`Failed to unregister Matter accessory ${uuid}:`, error);
+            throw new MatterDeviceError(`Failed to unregister accessory: ${error}`);
+        }
+    }
+    async updateAccessoryState(uuid, cluster, attributes, partId) {
+        const accessory = this.accessories.get(uuid);
+        if (!accessory) {
+            throw new MatterDeviceError(`Accessory ${uuid} not found or not registered`);
+        }
+        let targetEndpoint;
+        let targetClusters;
+        let displayName;
+        if (partId) {
+            const part = accessory._parts?.find(p => p.id === partId);
+            if (!part || !part.endpoint) {
+                throw new MatterDeviceError(`Part ${partId} not found in accessory ${uuid}`);
+            }
+            targetEndpoint = part.endpoint;
+            targetClusters = part.clusters;
+            displayName = part.displayName || `${accessory.displayName} - ${partId}`;
+        }
+        else {
+            if (!accessory.endpoint) {
+                throw new MatterDeviceError(`Accessory ${uuid} not registered or missing endpoint`);
+            }
+            targetEndpoint = accessory.endpoint;
+            targetClusters = accessory.clusters;
+            displayName = accessory.displayName;
+        }
+        return new Promise((resolve, reject) => {
+            setImmediate(async () => {
+                try {
+                    const updateObject = { [cluster]: attributes };
+                    await targetEndpoint.set(updateObject);
+                    if (!targetClusters) {
+                        log.warn(`Target clusters undefined for ${displayName}, cannot cache state`);
+                    }
+                    else {
+                        if (!targetClusters[cluster]) {
+                            targetClusters[cluster] = {};
+                        }
+                        targetClusters[cluster] = {
+                            ...targetClusters[cluster],
+                            ...attributes,
+                        };
+                    }
+                    const partInfo = partId ? ` (part: ${partId})` : '';
+                    log.debug(`Updated ${cluster} state for ${displayName}${partInfo}:`, attributes);
+                    this.notifyStateChange(uuid, cluster, attributes, partId);
+                    resolve();
+                }
+                catch (error) {
+                    const partInfo = partId ? ` part ${partId}` : '';
+                    log.error(`Failed to update state for accessory ${uuid}${partInfo}:`, error);
+                    reject(new MatterDeviceError(`Failed to update accessory state: ${error}`));
+                }
+            });
+        });
+    }
+    async triggerCommand(uuid, cluster, command, args, partId) {
+        const accessory = this.accessories.get(uuid);
+        if (!accessory) {
+            throw new MatterDeviceError(`Accessory ${uuid} not found or not registered`);
+        }
+        let targetEndpoint;
+        let displayName;
+        if (partId) {
+            const part = accessory._parts?.find(p => p.id === partId);
+            if (!part || !part.endpoint) {
+                throw new MatterDeviceError(`Part ${partId} not found in accessory ${uuid}`);
+            }
+            targetEndpoint = part.endpoint;
+            displayName = part.displayName || `${accessory.displayName} - ${partId}`;
+        }
+        else {
+            if (!accessory.endpoint) {
+                throw new MatterDeviceError(`Accessory ${uuid} not registered or missing endpoint`);
+            }
+            targetEndpoint = accessory.endpoint;
+            displayName = accessory.displayName;
+        }
+        try {
+            const partInfo = partId ? ` (part: ${partId})` : '';
+            log.debug(`Triggering command ${cluster}.${command} for ${displayName}${partInfo}`, args);
+            await targetEndpoint.act((agent) => {
+                const clusterBehavior = agent[cluster];
+                if (!clusterBehavior) {
+                    throw new Error(`Cluster '${cluster}' not found on endpoint`);
+                }
+                if (typeof clusterBehavior[command] !== 'function') {
+                    throw new TypeError(`Command '${command}' not found on cluster '${cluster}'`);
+                }
+                if (args && Object.keys(args).length > 0) {
+                    return clusterBehavior[command](args);
+                }
+                else {
+                    return clusterBehavior[command]();
+                }
+            });
+            log.debug(`Command ${cluster}.${command} succeeded for ${displayName}${partInfo}`);
+        }
+        catch (error) {
+            const partInfo = partId ? ` part ${partId}` : '';
+            log.error(`Failed to trigger command for accessory ${uuid}${partInfo}:`, error);
+            throw new MatterDeviceError(`Failed to trigger command: ${error}`);
+        }
+    }
+    getAccessoryState(uuid, cluster, partId) {
+        const accessory = this.accessories.get(uuid);
+        if (!accessory) {
+            log.debug(`Accessory ${uuid} not found`);
+            return undefined;
+        }
+        let targetEndpoint;
+        let displayName;
+        if (partId) {
+            const part = accessory._parts?.find(p => p.id === partId);
+            if (!part || !part.endpoint) {
+                log.debug(`Part ${partId} not found in accessory ${uuid}`);
+                return undefined;
+            }
+            targetEndpoint = part.endpoint;
+            displayName = part.displayName || `${accessory.displayName} - ${partId}`;
+        }
+        else {
+            if (!accessory.endpoint) {
+                log.debug(`Accessory ${uuid} not registered or missing endpoint`);
+                return undefined;
+            }
+            targetEndpoint = accessory.endpoint;
+            displayName = accessory.displayName;
+        }
+        try {
+            if (!targetEndpoint.state) {
+                log.debug(`endpoint.state is undefined for ${displayName}`);
+                return undefined;
+            }
+            if (!targetEndpoint.state[cluster]) {
+                const availableClusters = Object.keys(targetEndpoint.state || {});
+                log.debug(`Cluster '${cluster}' not found on ${displayName}. Available: ${availableClusters.join(', ')}`);
+                return undefined;
+            }
+            const clusterState = targetEndpoint.state[cluster];
+            const result = {};
+            const allKeys = new Set([
+                ...Object.keys(clusterState),
+                ...Object.getOwnPropertyNames(clusterState),
+            ]);
+            for (const key of allKeys) {
+                try {
+                    if (key.startsWith('_') || key.startsWith('$')) {
+                        continue;
+                    }
+                    const value = clusterState[key];
+                    if (typeof value === 'function' || value === undefined) {
+                        continue;
+                    }
+                    result[key] = value;
+                }
+                catch (propError) {
+                    log.debug(`Could not read property ${key} from ${cluster}:`, propError);
+                }
+            }
+            if (Object.keys(result).length === 0) {
+                log.debug(`Cluster ${cluster} found but no readable properties on accessory ${accessory.displayName}`);
+                return undefined;
+            }
+            return result;
+        }
+        catch (error) {
+            log.error(`Failed to get state for accessory ${uuid}:`, error);
+            return undefined;
+        }
+    }
+    getAllCachedAccessories() {
+        if (!this.accessoryCache) {
+            log.debug('getAllCachedAccessories: No cache available');
+            return [];
+        }
+        const cached = Array.from(this.accessoryCache.getAllCached().values());
+        log.debug(`getAllCachedAccessories: Returning ${cached.length} accessories`);
+        return cached;
+    }
+    getAccessories() {
+        return Array.from(this.accessories.values()).map((acc) => {
+            const { endpoint, registered, ...publicAccessory } = acc;
+            return publicAccessory;
+        });
+    }
+    getAccessory(uuid) {
+        const accessory = this.accessories.get(uuid);
+        if (!accessory) {
+            return undefined;
+        }
+        const { endpoint, registered, ...publicAccessory } = accessory;
+        return publicAccessory;
+    }
+    async stop() {
+        if (!this.isRunning) {
+            log.debug('Matter server is not running');
+            return;
+        }
+        this.isRunning = false;
+        try {
+            if (this.accessoryCache && this.accessories.size > 0) {
+                await this.accessoryCache.save(this.accessories);
+                log.debug('Saved accessory cache before shutdown');
+            }
+            if (this.serverNode) {
+                await this.serverNode.close();
+                log.debug('ServerNode closed (all endpoints cleaned up)');
+            }
+            this.accessories.clear();
+            await this.cleanup();
+            log.info('Matter server stopped');
+        }
+        catch (error) {
+            log.error('Error stopping Matter server:', error);
+            await errorHandler.handleError(error, 'server-stop');
+            throw error;
+        }
+        finally {
+            this.isRunning = false;
+        }
+    }
+    async cleanup() {
+        if (this.shutdownHandler) {
+            process.off('SIGINT', this.shutdownHandler);
+            process.off('SIGTERM', this.shutdownHandler);
+            this.shutdownHandler = null;
+        }
+        for (const handler of this.cleanupHandlers) {
+            try {
+                await handler();
+            }
+            catch (error) {
+                log.debug('Error during cleanup handler:', error);
+            }
+        }
+        this.cleanupHandlers = [];
+        this.serverNode = null;
+        this.aggregator = null;
+        this.isRunning = false;
+        this.commissioningInfo = {};
+    }
+    getFabricInfo() {
+        try {
+            if (!this.storageManager) {
+                return [];
+            }
+            const storage = this.storageManager.getStorage(this.config.uniqueId);
+            const fabricsData = storage.get(['fabrics'], 'fabrics');
+            if (Array.isArray(fabricsData) && fabricsData.length > 0) {
+                return fabricsData.map(fabric => ({
+                    fabricIndex: fabric.fabricIndex || 0,
+                    fabricId: fabric.fabricId?.value?.toString() || '',
+                    nodeId: fabric.nodeId?.value?.toString() || '',
+                    rootVendorId: fabric.rootVendorId || 0,
+                    label: fabric.label || '',
+                }));
+            }
+            return [];
+        }
+        catch (error) {
+            log.debug('Failed to get fabric info from storage:', error);
+            return [];
+        }
+    }
+    isCommissioned() {
+        try {
+            if (!this.storageManager) {
+                return false;
+            }
+            const storage = this.storageManager.getStorage(this.config.uniqueId);
+            const commissioned = storage.get(['root', 'commissioning'], 'commissioned');
+            if (commissioned === true) {
+                return true;
+            }
+            const fabrics = this.getFabricInfo();
+            return fabrics.length > 0;
+        }
+        catch (error) {
+            log.debug('Failed to check commissioned status from storage:', error);
+            return false;
+        }
+    }
+    getCommissionedFabricCount() {
+        return this.getFabricInfo().length;
+    }
+    getServerInfo() {
+        return {
+            running: this.isRunning,
+            port: this.config.port || 5540,
+            deviceCount: this.accessories.size,
+            commissioned: this.isCommissioned(),
+            fabricCount: this.getCommissionedFabricCount(),
+            serialNumber: this.serialNumber,
+        };
+    }
+    getCommissioningInfo() {
+        return {
+            ...this.commissioningInfo,
+            serialNumber: this.serialNumber,
+            passcode: this.passcode,
+            discriminator: this.discriminator,
+            commissioned: this.isCommissioned(),
+        };
+    }
+    getStorageStats() {
+        if (!this.storageManager) {
+            return null;
+        }
+        return this.storageManager.getAllStats();
+    }
+    isServerRunning() {
+        return this.isRunning;
+    }
+    getDeviceTypes() {
+        return deviceTypes;
+    }
+    getClusters() {
+        return clusters;
+    }
+    async removeFabric(fabricIndex) {
+        if (!this.serverNode) {
+            throw new MatterDeviceError('Matter server not started');
+        }
+        try {
+            log.info(`Removing fabric ${fabricIndex}...`);
+            const serverState = this.serverNode;
+            const removeFabric = serverState?.state?.commissioning?.removeFabric;
+            if (typeof removeFabric !== 'function') {
+                throw new MatterDeviceError('Fabric removal not supported by Matter.js version');
+            }
+            await removeFabric(fabricIndex);
+            log.info(`Fabric ${fabricIndex} removed successfully`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log.error(`Failed to remove fabric ${fabricIndex}:`, error);
+            throw new MatterDeviceError(`Failed to remove fabric: ${errorMessage}`, {
+                originalError: error instanceof Error ? error : undefined,
+            });
+        }
+    }
+    hasFabric(fabricIndex) {
+        const fabrics = this.getFabricInfo();
+        return fabrics.some(f => f.fabricIndex === fabricIndex);
+    }
+    enableStateMonitoring() {
+        this.monitoringEnabled = true;
+        log.debug('Matter state monitoring enabled');
+    }
+    disableStateMonitoring() {
+        this.monitoringEnabled = false;
+        log.debug('Matter state monitoring disabled');
+    }
+    isMonitoringEnabled() {
+        return this.monitoringEnabled;
+    }
+    notifyStateChange(uuid, cluster, state, partId) {
+        if (!this.monitoringEnabled) {
+            log.debug(`State change NOT sent - monitoring disabled for ${uuid}.${cluster}`);
+            return;
+        }
+        log.debug(`Sending state change IPC for ${uuid}.${cluster}:`, state);
+        if (process.send) {
+            const event = {
+                type: 'accessoryUpdate',
+                data: {
+                    uuid,
+                    cluster,
+                    state,
+                    partId,
+                },
+            };
+            process.send({
+                id: "matterEvent",
+                data: event,
+            });
+        }
+        else {
+            log.warn('Cannot send state change - process.send not available');
+        }
+    }
+    getDeviceTypeName(deviceType) {
+        return deviceType.name || 'Unknown';
+    }
+    collectAccessories(bridgeUsername, bridgeType, bridgeName) {
+        const accessories = [];
+        for (const [uuid, accessory] of this.accessories.entries()) {
+            const transformed = {
+                uuid,
+                displayName: accessory.displayName,
+                deviceType: this.getDeviceTypeName(accessory.deviceType),
+                clusters: this.getCurrentState(uuid),
+                parts: accessory._parts?.map(part => ({
+                    id: part.id,
+                    displayName: part.displayName,
+                    deviceType: this.getDeviceTypeName(part.deviceType),
+                    clusters: this.getCurrentState(uuid, part.id),
+                })),
+                bridge: {
+                    username: bridgeUsername,
+                    type: bridgeType,
+                    name: bridgeName,
+                },
+            };
+            accessories.push(transformed);
+        }
+        return accessories;
+    }
+    getAccessoryInfo(uuid) {
+        const accessory = this.accessories.get(uuid);
+        if (!accessory) {
+            return undefined;
+        }
+        return {
+            uuid,
+            displayName: accessory.displayName,
+            deviceType: this.getDeviceTypeName(accessory.deviceType),
+            clusters: this.getCurrentState(uuid),
+            parts: accessory._parts?.map(part => ({
+                id: part.id,
+                displayName: part.displayName,
+                deviceType: this.getDeviceTypeName(part.deviceType),
+                clusters: this.getCurrentState(uuid, part.id),
+            })),
+        };
+    }
+    getCurrentState(uuid, partId) {
+        const accessory = this.accessories.get(uuid);
+        if (!accessory) {
+            return {};
+        }
+        if (partId) {
+            const part = accessory._parts?.find(p => p.id === partId);
+            return part?.clusters || {};
+        }
+        return accessory.clusters || {};
+    }
+    async notifyPartsListChanged() {
+        if (!this.aggregator || !this.isCommissioned()) {
+            return;
+        }
+        try {
+            const aggregatorState = this.aggregator;
+            if (aggregatorState.state?.descriptor) {
+                const partsList = aggregatorState.state.descriptor.partsList || [];
+                if (this.config.debugModeEnabled) {
+                    log.debug(`Parts list changed: ${partsList.length} devices (endpoints: ${partsList.join(', ')})`);
+                }
+                await this.aggregator.set({
+                    descriptor: {
+                        partsList,
+                    },
+                });
+                log.info(`Notified controllers of parts list change (${this.accessories.size} devices)`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log.warn(`Failed to notify controllers of parts list change: ${errorMessage}`);
+        }
+    }
+}
+//# sourceMappingURL=server.js.map