homebridge 2.0.0-alpha.40 → 2.0.0-alpha.42

package/dist/matter/matterServer.js

@@ -0,0 +1,824 @@
+/**
+ * Matter.js Server Implementation for Homebridge Plugin API
+ *
+ * This provides a Matter bridge that plugins can use to register
+ * Matter accessories via the Homebridge API.
+ */
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import { access } from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import process from 'node:process';
+import { Endpoint, Environment, ServerNode, StorageService, VendorId, } from '@matter/main';
+import { AggregatorEndpoint } from '@matter/main/endpoints';
+import { ManualPairingCodeCodec, QrPairingCodeCodec, } from '@matter/types/schema';
+import * as fse from 'fs-extra';
+import QRCode from 'qrcode-terminal';
+import { Logger } from '../logger.js';
+import getVersion from '../version.js';
+import { diagnostics } from './matterDiagnostics.js';
+import { errorHandler } from './matterErrorHandler.js';
+import { networkMonitor } from './matterNetworkMonitor.js';
+import { MatterStorageManager } from './matterStorage.js';
+import { clusters, deviceTypes, MatterDeviceError, } from './matterTypes.js';
+const log = Logger.withPrefix('Matter');
+// Constants for Matter server configuration
+const DEFAULT_MATTER_PORT = 5540;
+const DEFAULT_VENDOR_ID = 0xFFF1; // Test vendor ID from Matter spec
+const DEFAULT_PRODUCT_ID = 0x8001; // Test product ID
+const MAX_DEVICES_PER_BRIDGE = 1000; // Matter spec maximum devices per aggregator
+const SERVER_READY_TIMEOUT_MS = 5000;
+const SERVER_READY_POLL_INTERVAL_MS = 100;
+const SERVER_INIT_DELAY_MS = 200;
+const MAX_PASSCODE_ATTEMPTS = 100;
+/**
+ * Matter Server for Homebridge Plugin API
+ * Allows plugins to register Matter accessories explicitly
+ */
+export class MatterServer {
+    config;
+    serverNode = null;
+    aggregator = null;
+    accessories = new Map();
+    isRunning = false;
+    MAX_DEVICES = MAX_DEVICES_PER_BRIDGE;
+    shutdownHandler = null;
+    // Internal commissioning values (generated, not user-configurable)
+    passcode = 0;
+    discriminator = 0;
+    vendorId;
+    productId;
+    commissioningInfo = {};
+    serialNumber;
+    cleanupHandlers = [];
+    storageManager = null;
+    constructor(config = {}) {
+        this.config = config;
+        // Store the user config with defaults
+        this.config = {
+            port: config.port || DEFAULT_MATTER_PORT,
+            name: config.name || 'Homebridge Matter Bridge',
+            // Use a consistent uniqueId based on the name to ensure storage persistence
+            uniqueId: config.uniqueId || `homebridge-matter-${config.name?.replace(/[^a-z0-9]/gi, '-') || 'bridge'}`,
+            storagePath: config.storagePath,
+        };
+        // Initialize commissioning values (will be loaded from storage in start())
+        this.vendorId = DEFAULT_VENDOR_ID;
+        this.productId = DEFAULT_PRODUCT_ID;
+    }
+    /**
+     * Generate a secure random passcode
+     * According to Matter spec, passcode must be:
+     * - 8 digits (00000001 to 99999998)
+     * - Not in the invalid list
+     * - Not sequential or repeating patterns
+     */
+    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 {
+            // Use cryptographically secure random number generation
+            const randomBytes = crypto.randomBytes(4);
+            const randomValue = randomBytes.readUInt32BE(0);
+            // Generate a value between 1 and 99999998
+            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;
+    }
+    /**
+     * Validate a passcode according to Matter specifications
+     */
+    isValidPasscode(passcode) {
+        // Must be between 1 and 99999998
+        if (passcode < 1 || passcode > 99999998) {
+            return false;
+        }
+        // Convert to 8-digit string
+        const passcodeStr = passcode.toString().padStart(8, '0');
+        // Check for sequential patterns (12345678, 23456789, etc.)
+        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;
+        }
+        // Check for reverse sequential (87654321, 76543210, etc.)
+        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;
+        }
+        // Check for too many repeating digits (more than 3 of same digit)
+        const digitCounts = new Map();
+        for (const digit of passcodeStr) {
+            digitCounts.set(digit, (digitCounts.get(digit) || 0) + 1);
+            if (digitCounts.get(digit) > 3) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Generate a random discriminator
+     * According to Matter spec, discriminator must be:
+     * - 12 bits (0-4095)
+     * - Should be random for security
+     */
+    generateRandomDiscriminator() {
+        // Generate cryptographically secure random 12-bit discriminator (0-4095)
+        const randomBytes = crypto.randomBytes(2);
+        const discriminator = randomBytes.readUInt16BE(0) & 0x0FFF; // Mask to 12 bits
+        // Validate discriminator range
+        if (discriminator < 0 || discriminator > 4095) {
+            throw new Error(`Invalid discriminator generated: ${discriminator}`);
+        }
+        return discriminator;
+    }
+    /**
+     * Create ServerNode with automatic recovery from corrupted storage
+     * If ServerNode creation fails due to corrupted fabric data, automatically
+     * clean up the ServerNodeStore and retry once
+     */
+    async createServerNodeWithRecovery(nodeOptions, sanitizedId) {
+        try {
+            // First attempt to create ServerNode
+            return await ServerNode.create(nodeOptions);
+        }
+        catch (error) {
+            // Check if this is a storage corruption error
+            const isStorageError = error?.message?.includes('Invalid public key encoding')
+                || error?.message?.includes('FabricManager unavailable')
+                || error?.message?.includes('key-input')
+                || error?.cause?.message?.includes('Invalid public key encoding');
+            if (!isStorageError) {
+                // Not a storage error, rethrow
+                throw error;
+            }
+            // Storage is corrupted - clean up and retry
+            log.warn('Detected corrupted Matter storage, attempting automatic recovery...');
+            // The ServerNodeStore directory is inside our storage path with the same name as the bridge ID
+            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 = path.join(storageLocation, sanitizedId);
+            const serverNodeStoreJsonFile = `${serverNodeStorePath}.json`;
+            try {
+                let removedSomething = false;
+                // Delete the ServerNodeStore subdirectory
+                if (fs.existsSync(serverNodeStorePath)) {
+                    log.info(`Removing corrupted ServerNodeStore directory: ${serverNodeStorePath}`);
+                    await fse.remove(serverNodeStorePath);
+                    removedSomething = true;
+                }
+                // Delete the ServerNodeStore JSON file (contains fabric data)
+                if (fs.existsSync(serverNodeStoreJsonFile)) {
+                    log.info(`Removing corrupted ServerNodeStore JSON file: ${serverNodeStoreJsonFile}`);
+                    await fse.remove(serverNodeStoreJsonFile);
+                    removedSomething = true;
+                }
+                if (removedSomething) {
+                    log.info('Corrupted storage removed, retrying ServerNode creation...');
+                }
+                else {
+                    log.warn('No corrupted storage files found, corruption may be elsewhere');
+                }
+                // Retry ServerNode creation
+                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}`);
+            }
+        }
+    }
+    /**
+     * Start the Matter server
+     */
+    async start() {
+        if (this.isRunning) {
+            log.warn('Matter server is already running');
+            return;
+        }
+        try {
+            log.info('Starting Matter.js server...');
+            // IMPORTANT: Storage must be configured BEFORE any Matter.js operations
+            // This ensures persistent fabric data across restarts
+            await this.setupStorage();
+            // Load or generate commissioning credentials
+            await this.loadOrGenerateCredentials();
+            log.info(`Configuration: Port=${this.config.port}, Passcode=${this.passcode}, Discriminator=${this.discriminator}`);
+            // Start network monitoring
+            networkMonitor.startMonitoring();
+            this.cleanupHandlers.push(() => networkMonitor.stopMonitoring());
+            // Start diagnostics
+            diagnostics.startDiagnostics();
+            this.cleanupHandlers.push(() => diagnostics.stopDiagnostics());
+            // Create commissioning options
+            const commissioningOptions = {
+                passcode: this.passcode,
+                discriminator: this.discriminator,
+            };
+            log.info(`Using commissioning credentials: passcode=${this.passcode}, discriminator=${this.discriminator}`);
+            // Ensure we have a name for the bridge
+            const bridgeName = this.config.name || 'Homebridge Matter Bridge';
+            // Sanitize the uniqueId to ensure it's filesystem-safe
+            // Replace any characters that could cause issues (colons, slashes, etc.)
+            // Use only alphanumeric and hyphens, collapse multiple hyphens, trim leading/trailing hyphens
+            const sanitizedId = this.config.uniqueId.replace(/[^a-z0-9]/gi, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+            // Create node options with proper typing
+            const nodeOptions = {
+                id: sanitizedId,
+                network: {
+                    port: this.config.port,
+                    ipv4: true, // Always enable IPv4 for Matter
+                },
+                commissioning: commissioningOptions,
+                productDescription: {
+                    name: bridgeName,
+                    deviceType: AggregatorEndpoint.deviceType,
+                },
+                basicInformation: {
+                    nodeLabel: bridgeName.slice(0, 32), // Maximum 32 characters
+                    vendorId: VendorId(this.vendorId),
+                    vendorName: 'Homebridge'.slice(0, 32),
+                    productId: this.productId,
+                    productName: 'Homebridge Matter Bridge'.slice(0, 32),
+                    productLabel: bridgeName.slice(0, 64), // Maximum 64 characters
+                    serialNumber: this.serialNumber = this.generateSerialNumber(),
+                    hardwareVersion: 1,
+                    hardwareVersionString: os.release(),
+                    softwareVersion: 1,
+                    softwareVersionString: getVersion(),
+                    reachable: true,
+                },
+            };
+            // Create server node with automatic recovery from corrupted storage
+            this.serverNode = await this.createServerNodeWithRecovery(nodeOptions, sanitizedId);
+            // Create aggregator endpoint for bridge pattern
+            this.aggregator = new Endpoint(AggregatorEndpoint, {
+                id: 'homebridge-aggregator',
+            });
+            // Add aggregator to server
+            await this.serverNode.add(this.aggregator);
+            // Generate and display commissioning information
+            await this.generateCommissioningInfo();
+            // Set up graceful shutdown handler
+            this.shutdownHandler = async () => {
+                log.info('Shutting down Matter server...');
+                await this.stop();
+            };
+            // Register shutdown handlers
+            process.on('SIGINT', this.shutdownHandler);
+            process.on('SIGTERM', this.shutdownHandler);
+            // Start the server in a non-blocking way
+            this.serverNode.run().then(() => {
+                log.info('Matter server stopped normally');
+            }, (error) => {
+                log.error('Matter server stopped with error:', error);
+                errorHandler.handleError(error, 'server-runtime');
+            });
+            // Wait for server to be ready
+            await this.waitForServerReady();
+            this.isRunning = true;
+            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;
+        }
+    }
+    /**
+     * Set up and validate storage
+     */
+    async setupStorage() {
+        if (!this.config.storagePath) {
+            throw new Error('Storage path is required for Matter server');
+        }
+        // Resolve to absolute path and validate
+        const storagePath = path.resolve(this.config.storagePath);
+        const normalizedPath = path.normalize(storagePath);
+        // Ensure path is within allowed directories
+        const allowedBasePaths = [
+            path.resolve(os.homedir(), '.homebridge'),
+            path.resolve(process.cwd()),
+            '/var/lib/homebridge', // Common system location
+        ];
+        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.`);
+        }
+        // Ensure the storage directory exists with proper permissions
+        try {
+            await fse.ensureDir(normalizedPath);
+            await access(normalizedPath, fs.constants.R_OK | fs.constants.W_OK);
+        }
+        catch (error) {
+            throw new Error(`Storage path not accessible: ${error}`);
+        }
+        // Create bridge-specific storage directory
+        // Use only alphanumeric characters and hyphens for maximum compatibility
+        const bridgeId = this.config.uniqueId?.replace(/[^a-z0-9]/gi, '-').replace(/-+/g, '-').replace(/^-|-$/g, '') || 'default';
+        const matterStoragePath = path.join(normalizedPath, bridgeId);
+        await fse.ensureDir(matterStoragePath);
+        // Create storage manager
+        this.storageManager = new MatterStorageManager(matterStoragePath);
+        // Configure environment to use our custom storage
+        const environment = Environment.default;
+        const storageService = environment.get(StorageService);
+        storageService.location = matterStoragePath;
+        // CRITICAL: Override storage factory with custom implementation
+        // This ensures fabric data is properly persisted
+        storageService.factory = (namespace) => {
+            if (!this.storageManager) {
+                throw new Error('Storage manager not initialized');
+            }
+            const storage = this.storageManager.getStorage(namespace);
+            // Initialize asynchronously - Matter.js handles async storage properly
+            storage.initialize().catch((error) => {
+                log.error(`Failed to initialize storage namespace ${namespace}:`, error);
+            });
+            // Note: Cast to unknown first to satisfy TypeScript - our storage implements the required interface
+            return storage;
+        };
+        // Add cleanup handler for storage
+        this.cleanupHandlers.push(async () => {
+            if (this.storageManager) {
+                await this.storageManager.closeAll();
+            }
+        });
+        log.info(`Matter storage initialized at: ${matterStoragePath}`);
+    }
+    /**
+     * Load or generate commissioning credentials (passcode and discriminator)
+     * These must be persistent across restarts to maintain the same QR code
+     */
+    async loadOrGenerateCredentials() {
+        if (!this.storageManager) {
+            throw new Error('Storage manager not initialized');
+        }
+        const storage = this.storageManager.getStorage('commissioning');
+        // CRITICAL: Initialize storage before reading to avoid race condition
+        await storage.initialize();
+        // Try to load existing credentials
+        const storedPasscode = storage.get([], 'passcode');
+        const storedDiscriminator = storage.get([], 'discriminator');
+        if (storedPasscode && storedDiscriminator) {
+            // Use stored credentials
+            log.info('Loading existing commissioning credentials from storage');
+            this.passcode = storedPasscode;
+            this.discriminator = storedDiscriminator;
+        }
+        else {
+            // Generate new credentials and store them
+            log.info('Generating new commissioning credentials');
+            this.passcode = this.generateSecurePasscode();
+            this.discriminator = this.generateRandomDiscriminator();
+            // Store for future use
+            storage.set([], 'passcode', this.passcode);
+            storage.set([], 'discriminator', this.discriminator);
+            log.info('Commissioning credentials saved to storage');
+        }
+    }
+    /**
+     * Generate serial number for the bridge
+     */
+    generateSerialNumber() {
+        const timestamp = Date.now().toString(36).toUpperCase();
+        const random = crypto.randomBytes(2).toString('hex').toUpperCase();
+        return `HB-${timestamp}-${random}`;
+    }
+    /**
+     * Generate and display commissioning information
+     */
+    async generateCommissioningInfo() {
+        const passcode = this.passcode.toString().padStart(8, '0');
+        const discriminator = this.discriminator;
+        const vendorId = this.vendorId;
+        const productId = this.productId;
+        // Use Matter.js library to generate pairing codes properly
+        const manualCode = ManualPairingCodeCodec.encode({
+            discriminator,
+            passcode: this.passcode,
+        });
+        // Format as XXXX-XXX-XXXX for display
+        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, // Standard commissioning flow
+                discoveryCapabilities: 4, // OnNetwork=4
+                discriminator,
+                passcode: this.passcode,
+            }]);
+        log.info(`Generated QR code: ${qrCodePayload}`);
+        log.info(`Generated manual code: ${manualPairingCode}`);
+        // Store commissioning info
+        this.commissioningInfo = {
+            qrCode: qrCodePayload,
+            manualPairingCode,
+        };
+        // Display commissioning information
+        log.info(`\n${'='.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('\nQR Code for commissioning:');
+        // Generate and display QR code in terminal
+        QRCode.generate(qrCodePayload, { small: true }, (qrcode) => {
+            // eslint-disable-next-line no-console
+            console.log(qrcode);
+        });
+        log.info(`${'='.repeat(60)}\n`);
+    }
+    /**
+     * Wait for the server to be ready
+     */
+    async waitForServerReady(maxWaitTime = SERVER_READY_TIMEOUT_MS) {
+        const startTime = Date.now();
+        while (!this.serverNode || !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));
+        }
+        // Additional small delay to ensure everything is initialized
+        await new Promise(resolve => setTimeout(resolve, SERVER_INIT_DELAY_MS));
+    }
+    /**
+     * Register a Matter accessory (Plugin API)
+     */
+    async registerAccessory(accessory) {
+        if (!this.serverNode || !this.aggregator) {
+            throw new MatterDeviceError('Matter server not started');
+        }
+        // Validate required fields
+        if (!accessory.deviceType) {
+            throw new MatterDeviceError(`Missing deviceType for accessory "${accessory.displayName}". `
+                + 'Make sure you are using api.matterDeviceTypes (e.g., api.matterDeviceTypes.OnOffLight)');
+        }
+        if (!accessory.uuid) {
+            throw new MatterDeviceError('Accessory must have a uuid');
+        }
+        if (!accessory.displayName) {
+            throw new MatterDeviceError('Accessory must have a displayName');
+        }
+        if (!accessory.serialNumber) {
+            throw new MatterDeviceError(`Accessory "${accessory.displayName}" must have a serialNumber`);
+        }
+        if (!accessory.manufacturer) {
+            throw new MatterDeviceError(`Accessory "${accessory.displayName}" must have a manufacturer`);
+        }
+        if (!accessory.model) {
+            throw new MatterDeviceError(`Accessory "${accessory.displayName}" must have a model`);
+        }
+        if (!accessory.clusters || typeof accessory.clusters !== 'object') {
+            throw new MatterDeviceError(`Accessory "${accessory.displayName}" must have clusters defined`);
+        }
+        // Check if already registered
+        if (this.accessories.has(accessory.uuid)) {
+            throw new MatterDeviceError(`Accessory with UUID ${accessory.uuid} is already registered`);
+        }
+        // Check device limit
+        if (this.accessories.size >= this.MAX_DEVICES) {
+            throw new MatterDeviceError(`Maximum device limit (${this.MAX_DEVICES}) reached`);
+        }
+        try {
+            // Create endpoint with device type
+            const endpoint = new Endpoint(accessory.deviceType, {
+                id: accessory.uuid,
+            });
+            // Add to aggregator FIRST (required before we can configure it)
+            await this.aggregator.add(endpoint);
+            // NOW configure the endpoint
+            await this.configureEndpoint(endpoint, accessory);
+            // Store accessory
+            const internalAccessory = {
+                ...accessory,
+                endpoint,
+                registered: true,
+            };
+            this.accessories.set(accessory.uuid, internalAccessory);
+            log.info(`Registered Matter accessory: ${accessory.displayName} (${accessory.uuid})`);
+        }
+        catch (error) {
+            log.error(`Failed to register Matter accessory ${accessory.displayName}:`, error);
+            throw new MatterDeviceError(`Failed to register accessory: ${error}`);
+        }
+    }
+    /**
+     * Unregister a Matter accessory (Plugin API)
+     */
+    async unregisterAccessory(uuid) {
+        const accessory = this.accessories.get(uuid);
+        if (!accessory) {
+            log.debug(`Accessory ${uuid} not found, ignoring unregister request`);
+            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})`);
+        }
+        catch (error) {
+            log.error(`Failed to unregister Matter accessory ${uuid}:`, error);
+            throw new MatterDeviceError(`Failed to unregister accessory: ${error}`);
+        }
+    }
+    /**
+     * Update a Matter accessory's state (Plugin API)
+     */
+    async updateAccessoryState(uuid, cluster, attributes) {
+        const accessory = this.accessories.get(uuid);
+        if (!accessory || !accessory.endpoint) {
+            throw new MatterDeviceError(`Accessory ${uuid} not found or not registered`);
+        }
+        try {
+            // Update the endpoint's cluster state
+            // Note: Endpoint types from Matter.js don't expose state properly, needs runtime check
+            const endpoint = accessory.endpoint;
+            if (endpoint.state?.[cluster]) {
+                Object.assign(endpoint.state[cluster], attributes);
+                log.debug(`Updated ${cluster} state for ${accessory.displayName}:`, attributes);
+            }
+            else {
+                log.warn(`Cluster ${cluster} not found on accessory ${accessory.displayName}`);
+            }
+        }
+        catch (error) {
+            log.error(`Failed to update state for accessory ${uuid}:`, error);
+            throw new MatterDeviceError(`Failed to update accessory state: ${error}`);
+        }
+    }
+    /**
+     * Get all registered accessories (Plugin API)
+     */
+    getAccessories() {
+        return Array.from(this.accessories.values()).map((acc) => {
+            // Return copy without internal fields
+            // eslint-disable-next-line unused-imports/no-unused-vars
+            const { endpoint, registered, ...publicAccessory } = acc;
+            return publicAccessory;
+        });
+    }
+    /**
+     * Get a specific accessory by UUID (Plugin API)
+     */
+    getAccessory(uuid) {
+        const accessory = this.accessories.get(uuid);
+        if (!accessory) {
+            return undefined;
+        }
+        // Return copy without internal fields
+        // eslint-disable-next-line unused-imports/no-unused-vars
+        const { endpoint, registered, ...publicAccessory } = accessory;
+        return publicAccessory;
+    }
+    /**
+     * Configure a Matter endpoint after it's been added to the aggregator
+     */
+    async configureEndpoint(endpoint, accessory) {
+        // Note: bridgedDeviceBasicInformation is not available in Matter.js v0.15.4
+        // The BridgedDeviceBasicInformation cluster is automatically added to bridged devices
+        // but cannot be configured via endpoint.set() in this version
+        // Leaving this commented out to avoid error logs
+        // try {
+        //   await endpoint.set({
+        //     bridgedDeviceBasicInformation: {
+        //       nodeLabel: accessory.displayName.slice(0, 32),
+        //       vendorName: accessory.manufacturer.slice(0, 32),
+        //       vendorId: VendorId(this.vendorId),
+        //       productName: accessory.model.slice(0, 32),
+        //       productLabel: accessory.displayName.slice(0, 64),
+        //       serialNumber: accessory.serialNumber,
+        //       reachable: true,
+        //       ...(accessory.hardwareRevision && { hardwareVersionString: accessory.hardwareRevision }),
+        //       ...(accessory.softwareVersion && { softwareVersionString: accessory.softwareVersion }),
+        //     },
+        //   } as any)
+        // } catch (error) {
+        //   log.debug(`Could not set bridgedDeviceBasicInformation for ${accessory.displayName}: ${error}`)
+        // }
+        // Set up cluster states
+        for (const [clusterName, attributes] of Object.entries(accessory.clusters)) {
+            // Cast to any temporarily to work around Matter.js type limitations
+            await endpoint.set({ [clusterName]: attributes });
+        }
+        // Set up command handlers if provided
+        if (accessory.handlers) {
+            for (const [clusterName, handlers] of Object.entries(accessory.handlers)) {
+                for (const [commandName, handler] of Object.entries(handlers)) {
+                    const endpointWithEvents = endpoint;
+                    if (endpointWithEvents.events?.[clusterName]?.[`${commandName}$Action`]) {
+                        endpointWithEvents.events[clusterName][`${commandName}$Action`].on(handler);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Stop the Matter server
+     */
+    async stop() {
+        if (!this.isRunning) {
+            log.debug('Matter server is not running');
+            return;
+        }
+        this.isRunning = false;
+        // Stop monitoring
+        networkMonitor.stopMonitoring();
+        diagnostics.stopDiagnostics();
+        try {
+            // Clean up all accessories
+            for (const accessory of this.accessories.values()) {
+                try {
+                    if (accessory.endpoint) {
+                        await accessory.endpoint.close();
+                    }
+                }
+                catch (error) {
+                    log.error('Failed to clean up accessory:', error);
+                }
+            }
+            this.accessories.clear();
+            // Stop server
+            if (this.serverNode) {
+                await this.serverNode.close();
+            }
+            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;
+        }
+    }
+    /**
+     * Cleanup resources
+     */
+    async cleanup() {
+        // Remove signal handlers
+        if (this.shutdownHandler) {
+            process.off('SIGINT', this.shutdownHandler);
+            process.off('SIGTERM', this.shutdownHandler);
+            this.shutdownHandler = null;
+        }
+        // Run all cleanup handlers
+        for (const handler of this.cleanupHandlers) {
+            try {
+                await handler();
+            }
+            catch (error) {
+                log.debug('Error during cleanup handler:', error);
+            }
+        }
+        this.cleanupHandlers = [];
+        // Clear references
+        this.serverNode = null;
+        this.aggregator = null;
+        this.isRunning = false;
+        this.commissioningInfo = {};
+    }
+    /**
+     * Get fabric information for commissioned controllers
+     */
+    getFabricInfo() {
+        try {
+            if (!this.serverNode) {
+                return [];
+            }
+            const serverState = this.serverNode;
+            const fabrics = serverState?.state?.commissioning?.fabrics;
+            // Ensure fabrics is an array before mapping
+            if (!Array.isArray(fabrics)) {
+                return [];
+            }
+            return fabrics.map(fabric => ({
+                fabricIndex: fabric.fabricIndex,
+                fabricId: fabric.fabricId?.toString() || '',
+                nodeId: fabric.nodeId?.toString() || '',
+                rootVendorId: fabric.rootVendorId || 0,
+                label: fabric.label,
+            }));
+        }
+        catch (error) {
+            log.error('Failed to get fabric info:', error);
+            return [];
+        }
+    }
+    /**
+     * Check if the server is commissioned
+     */
+    isCommissioned() {
+        const fabrics = this.getFabricInfo();
+        return fabrics.length > 0;
+    }
+    /**
+     * Get the number of commissioned fabrics
+     */
+    getCommissionedFabricCount() {
+        return this.getFabricInfo().length;
+    }
+    /**
+     * Get server status information
+     */
+    getServerInfo() {
+        return {
+            running: this.isRunning,
+            port: this.config.port || 5540,
+            deviceCount: this.accessories.size,
+            commissioned: this.isCommissioned(),
+            fabricCount: this.getCommissionedFabricCount(),
+            serialNumber: this.serialNumber,
+        };
+    }
+    /**
+     * Get commissioning information
+     */
+    getCommissioningInfo() {
+        return {
+            ...this.commissioningInfo,
+            serialNumber: this.serialNumber,
+            passcode: this.passcode,
+            discriminator: this.discriminator,
+            commissioned: this.isCommissioned(),
+        };
+    }
+    /**
+     * Get storage statistics
+     */
+    getStorageStats() {
+        if (!this.storageManager) {
+            return null;
+        }
+        return this.storageManager.getAllStats();
+    }
+    /**
+     * Check if server is running
+     */
+    isServerRunning() {
+        return this.isRunning;
+    }
+    /**
+     * Get Matter device types available for plugin use
+     */
+    getDeviceTypes() {
+        return deviceTypes;
+    }
+    /**
+     * Get Matter clusters available for plugin use
+     */
+    getClusters() {
+        return clusters;
+    }
+}
+//# sourceMappingURL=matterServer.js.map