homebridge 2.0.0-alpha.40 → 2.0.0-alpha.41

package/dist/matterService.js

@@ -1,677 +0,0 @@
-import * as crypto from 'node:crypto';
-import * as fs from 'fs-extra';
-import { Logger } from './logger.js';
-import { MatterConfigValidator } from './matterConfigValidator.js';
-import '@matter/main';
-const log = Logger.internal;
-/**
- * Matter service for publishing accessories via Matter protocol
- * This runs alongside the existing HAP bridge service
- */
-export class MatterService {
-    matterConfiguration;
-    pluginManager;
-    externalPortService;
-    api;
-    options;
-    matterServer = null;
-    commissioningServer = null;
-    storageManager = null;
-    isEnabled;
-    matterConfig;
-    publishedAccessories = new Map();
-    isInitialized = false;
-    isStarted = false;
-    constructor(matterConfiguration, pluginManager, externalPortService, api, options) {
-        this.matterConfiguration = matterConfiguration;
-        this.pluginManager = pluginManager;
-        this.externalPortService = externalPortService;
-        this.api = api;
-        this.options = options;
-        this.matterConfig = {
-            enabled: false,
-            port: 5540,
-            discriminator: 3840,
-            passcode: 20202021,
-            vendorId: 0xFFF1, // Test Vendor ID
-            productId: 0x8001, // Test Product ID
-            deviceName: 'Homebridge Matter Bridge',
-            deviceType: 0x0016, // Matter Bridge device type
-            storageDir: options.customStoragePath || './persist',
-            debugEnabled: false,
-            interfaceName: undefined,
-            announceInterval: 60,
-            commissioningTimeout: 900, // 15 minutes
-            ...matterConfiguration,
-        };
-        this.isEnabled = this.matterConfig.enabled || false;
-        this.validateConfiguration();
-        if (this.isEnabled) {
-            log.info('Matter service enabled');
-        }
-        else {
-            log.debug('Matter service disabled');
-        }
-    }
-    /**
-     * Validate Matter configuration parameters
-     */
-    validateConfiguration() {
-        if (!this.isEnabled) {
-            return;
-        }
-        const validationResult = MatterConfigValidator.validate(this.matterConfig);
-        if (!validationResult.isValid) {
-            const errorMessage = `Matter configuration validation failed:\n${validationResult.errors.join('\n')}`;
-            throw new Error(errorMessage);
-        }
-        if (validationResult.warnings.length > 0) {
-            log.warn('Matter configuration has warnings - see above for details');
-        }
-        log.info(`Matter configuration validated successfully: port=${this.matterConfig.port}, discriminator=${this.matterConfig.discriminator}`);
-    }
-    /**
-     * Initialize the Matter server if enabled
-     */
-    async initialize() {
-        if (!this.isEnabled || this.isInitialized) {
-            return;
-        }
-        try {
-            log.info('Initializing Matter server...');
-            // Initialize storage
-            await this.initializeStorage();
-            // Create and configure Matter server node
-            await this.createMatterServer();
-            // Setup commissioning server
-            await this.setupCommissioningServer();
-            this.isInitialized = true;
-            log.info('Matter server initialized successfully');
-            this.logCommissioningInfo();
-        }
-        catch (error) {
-            log.error('Failed to initialize Matter server:', error);
-            await this.cleanup();
-            throw error;
-        }
-    }
-    /**
-     * Initialize storage for Matter server
-     */
-    async initializeStorage() {
-        try {
-            // Create storage directory if it doesn't exist
-            const storageDir = `${this.matterConfig.storageDir}/matter`;
-            await fs.ensureDir(storageDir);
-            // Use placeholder storage manager for now
-            // In production, this would use proper Matter.js storage
-            this.storageManager = {
-                initialized: true,
-                async initialize() {
-                    return Promise.resolve();
-                },
-                async close() {
-                    return Promise.resolve();
-                },
-            };
-            await this.storageManager.initialize();
-            log.debug('Matter storage initialized');
-        }
-        catch (error) {
-            log.error('Failed to initialize Matter storage:', error);
-            throw error;
-        }
-    }
-    /**
-     * Create the Matter server node
-     */
-    async createMatterServer() {
-        if (!this.storageManager) {
-            throw new Error('Storage manager not initialized');
-        }
-        try {
-            // Create placeholder Matter server
-            // In production, this would be a real Matter.js ServerNode
-            this.matterServer = {
-                started: false,
-                devices: new Map(),
-                async start() {
-                    this.started = true;
-                    return Promise.resolve();
-                },
-                async stop() {
-                    this.started = false;
-                    return Promise.resolve();
-                },
-                async addDevice(device) {
-                    const id = crypto.randomUUID();
-                    this.devices.set(id, device);
-                    return { id, device };
-                },
-                async removeDevice(endpoint) {
-                    this.devices.delete(endpoint.id);
-                    return Promise.resolve();
-                },
-            };
-            log.debug('Matter server node created (placeholder implementation)');
-        }
-        catch (error) {
-            log.error('Failed to create Matter server node:', error);
-            throw error;
-        }
-    }
-    /**
-     * Setup commissioning server for device pairing
-     */
-    async setupCommissioningServer() {
-        if (!this.matterServer) {
-            throw new Error('Matter server not created');
-        }
-        try {
-            // Create placeholder commissioning server
-            // In production, this would be a real Matter.js CommissioningServer
-            this.commissioningServer = {
-                started: false,
-                async start() {
-                    this.started = true;
-                    return Promise.resolve();
-                },
-                async stop() {
-                    this.started = false;
-                    return Promise.resolve();
-                },
-            };
-            log.debug('Matter commissioning server configured (placeholder implementation)');
-        }
-        catch (error) {
-            log.error('Failed to setup commissioning server:', error);
-            throw error;
-        }
-    }
-    /**
-     * Generate a unique serial number for the Matter bridge
-     */
-    generateSerialNumber() {
-        // Use the HAP bridge username as base for consistency
-        const hapBridge = this.api.hap?.HAPStorage.storage()?.getItem('AccessoryInfo.CC:22:3D:E3:CE:30');
-        if (hapBridge && hapBridge.serialNumber) {
-            return `HB-${hapBridge.serialNumber}`;
-        }
-        // Fallback to generated serial
-        return `HB-${crypto.randomBytes(6).toString('hex').toUpperCase()}`;
-    }
-    /**
-     * Generate a unique identifier for the Matter bridge
-     */
-    generateUniqueId() {
-        // Use the HAP bridge ID as base for consistency
-        const hapBridge = this.api.hap?.HAPStorage.storage()?.getItem('AccessoryInfo.CC:22:3D:E3:CE:30');
-        if (hapBridge && hapBridge.id) {
-            return `homebridge-matter-${hapBridge.id}`;
-        }
-        // Fallback to generated ID
-        return `homebridge-matter-${crypto.randomUUID()}`;
-    }
-    /**
-     * Log commissioning information for users
-     */
-    logCommissioningInfo() {
-        try {
-            // Generate placeholder QR code info
-            // In production, this would use real Matter.js QrCode.encode()
-            const setupCode = `MT:${this.matterConfig.discriminator.toString().padStart(4, '0')}${this.matterConfig.passcode}`;
-            const qrCode = `https://dhrishi.github.io/connectedhomeip/qrcode.html?data=${setupCode}`;
-            log.info('Matter bridge is ready for commissioning:');
-            log.info(`  Setup Code: ${setupCode}`);
-            log.info(`  QR Code URL: ${qrCode}`);
-            log.info(`  Manual Pairing Code: ${this.formatPairingCode(this.matterConfig.passcode)}`);
-            log.info(`  Discriminator: ${this.matterConfig.discriminator}`);
-            log.info(`  Port: ${this.matterConfig.port}`);
-            log.info('  Note: This is a development implementation - QR codes may not work with all controllers');
-        }
-        catch (error) {
-            log.warn('Could not generate commissioning QR code:', error);
-            log.info(`Matter bridge ready - Manual setup: Passcode ${this.matterConfig.passcode}, Discriminator ${this.matterConfig.discriminator}`);
-        }
-    }
-    /**
-     * Format passcode for manual pairing
-     */
-    formatPairingCode(passcode) {
-        const code = passcode.toString().padStart(8, '0');
-        return `${code.slice(0, 3)}-${code.slice(3, 5)}-${code.slice(5)}`;
-    }
-    /**
-     * Start the Matter server
-     */
-    async start() {
-        if (!this.isEnabled || !this.matterServer || this.isStarted) {
-            return;
-        }
-        try {
-            log.info('Starting Matter server...');
-            // Start the Matter server node
-            await this.matterServer.start();
-            // Start commissioning
-            if (this.commissioningServer) {
-                await this.commissioningServer.start();
-            }
-            this.isStarted = true;
-            log.info(`Matter server started successfully on port ${this.matterConfig.port}`);
-        }
-        catch (error) {
-            log.error('Failed to start Matter server:', error);
-            this.isStarted = false;
-            throw error;
-        }
-    }
-    /**
-     * Stop the Matter server
-     */
-    async stop() {
-        if (!this.isStarted) {
-            return;
-        }
-        try {
-            log.info('Stopping Matter server...');
-            // Stop commissioning server
-            if (this.commissioningServer) {
-                await this.commissioningServer.stop();
-            }
-            // Stop Matter server
-            if (this.matterServer) {
-                await this.matterServer.stop();
-            }
-            await this.cleanup();
-            this.isStarted = false;
-            log.info('Matter server stopped successfully');
-        }
-        catch (error) {
-            log.error('Failed to stop Matter server:', error);
-            this.isStarted = false;
-        }
-    }
-    /**
-     * Clean up resources
-     */
-    async cleanup() {
-        try {
-            // Close storage
-            if (this.storageManager) {
-                await this.storageManager.close();
-                this.storageManager = null;
-            }
-            this.matterServer = null;
-            this.commissioningServer = null;
-            this.publishedAccessories.clear();
-            this.isInitialized = false;
-        }
-        catch (error) {
-            log.error('Error during Matter service cleanup:', error);
-        }
-    }
-    /**
-     * Publish a platform accessory via Matter protocol
-     */
-    async publishAccessory(accessory) {
-        if (!this.isEnabled || !this.matterServer || !this.isStarted) {
-            log.debug(`Cannot publish accessory "${accessory.displayName}" - Matter server not ready`);
-            return;
-        }
-        try {
-            log.debug(`Publishing accessory "${accessory.displayName}" via Matter...`);
-            // Convert HAP accessory to Matter device
-            const matterDevice = await this.convertToMatterDevice(accessory);
-            if (matterDevice) {
-                // Add the device to the Matter server as a bridged device
-                const endpoint = await this.matterServer.addDevice(matterDevice);
-                // Track the published accessory
-                this.publishedAccessories.set(accessory.UUID, {
-                    accessory,
-                    endpoint,
-                });
-                log.info(`Published accessory "${accessory.displayName}" via Matter successfully`);
-            }
-            else {
-                log.warn(`Could not convert accessory "${accessory.displayName}" to Matter device - unsupported services`);
-            }
-        }
-        catch (error) {
-            log.error(`Failed to publish accessory "${accessory.displayName}" via Matter:`, error);
-        }
-    }
-    /**
-     * Unpublish a platform accessory from Matter protocol
-     */
-    async unpublishAccessory(accessory) {
-        if (!this.isEnabled || !this.matterServer) {
-            return;
-        }
-        try {
-            const publishedDevice = this.publishedAccessories.get(accessory.UUID);
-            if (publishedDevice) {
-                // Remove the device from the Matter server
-                await this.matterServer.removeDevice(publishedDevice.endpoint);
-                // Remove from tracking
-                this.publishedAccessories.delete(accessory.UUID);
-                log.info(`Unpublished accessory "${accessory.displayName}" from Matter successfully`);
-            }
-            else {
-                log.debug(`Accessory "${accessory.displayName}" was not published via Matter`);
-            }
-        }
-        catch (error) {
-            log.error(`Failed to unpublish accessory "${accessory.displayName}" from Matter:`, error);
-        }
-    }
-    /**
-     * Convert HAP accessory to Matter device
-     * This maps HAP services and characteristics to appropriate Matter clusters and attributes
-     */
-    async convertToMatterDevice(accessory) {
-        try {
-            log.debug(`Converting accessory "${accessory.displayName}" to Matter device...`);
-            // Get the primary service (excluding AccessoryInformation and other utility services)
-            const primaryService = this.getPrimaryService(accessory);
-            if (!primaryService) {
-                log.warn(`No primary service found for accessory "${accessory.displayName}"`);
-                return null;
-            }
-            const serviceType = primaryService.constructor.name;
-            const characteristics = primaryService.characteristics.map(char => char.constructor.name);
-            log.debug(`Primary service: ${serviceType}, characteristics: ${characteristics.join(', ')}`);
-            // Determine the appropriate Matter device type and clusters
-            const deviceType = this.getMatterDeviceType(serviceType, characteristics);
-            if (!deviceType) {
-                log.warn(`Unsupported service type for Matter conversion: ${serviceType}`);
-                return null;
-            }
-            // Create the Matter device with appropriate clusters
-            const matterDevice = await this.createMatterDevice(deviceType, accessory, primaryService);
-            log.debug(`Successfully converted "${accessory.displayName}" to Matter ${deviceType} device`);
-            return matterDevice;
-        }
-        catch (error) {
-            log.error(`Error converting accessory "${accessory.displayName}" to Matter device:`, error);
-            return null;
-        }
-    }
-    /**
-     * Get the primary service from an accessory (excluding utility services)
-     */
-    getPrimaryService(accessory) {
-        const utilityServices = [
-            'AccessoryInformation',
-            'BridgingState',
-            'HAPProtocolInformation',
-            'Pairing',
-            'BridgeConfiguration',
-        ];
-        for (const service of accessory.services) {
-            const serviceType = service.constructor.name;
-            if (!utilityServices.includes(serviceType)) {
-                return service;
-            }
-        }
-        return null;
-    }
-    /**
-     * Determine the appropriate Matter device type for a HAP service
-     */
-    getMatterDeviceType(serviceType, characteristics) {
-        // Handle lighting services with specific capabilities
-        if (serviceType === 'Lightbulb') {
-            if (characteristics.includes('Hue') && characteristics.includes('Saturation')) {
-                return 'ExtendedColorLight';
-            }
-            else if (characteristics.includes('ColorTemperature')) {
-                return 'ColorTemperatureLight';
-            }
-            else if (characteristics.includes('Brightness')) {
-                return 'DimmableLight';
-            }
-            else {
-                return 'OnOffLight';
-            }
-        }
-        // Handle outlet services
-        if (serviceType === 'Outlet') {
-            if (characteristics.includes('Brightness')) {
-                return 'DimmablePlugInUnit';
-            }
-            else {
-                return 'OnOffPlugInUnit';
-            }
-        }
-        // Handle switch services
-        if (serviceType === 'Switch') {
-            if (characteristics.includes('Brightness')) {
-                return 'DimmerSwitch';
-            }
-            else {
-                return 'OnOffLightSwitch';
-            }
-        }
-        // Direct mapping for other services
-        const directMappings = {
-            TemperatureSensor: 'TemperatureSensor',
-            HumiditySensor: 'HumiditySensor',
-            LightSensor: 'LightSensor',
-            MotionSensor: 'OccupancySensor',
-            OccupancySensor: 'OccupancySensor',
-            ContactSensor: 'ContactSensor',
-            LeakSensor: 'WaterLeakDetector',
-            SmokeSensor: 'SmokeCoAlarm',
-            CarbonMonoxideSensor: 'SmokeCoAlarm',
-            LockManagement: 'DoorLock',
-            Thermostat: 'Thermostat',
-            Fan: 'Fan',
-            Fanv2: 'Fan',
-            WindowCovering: 'WindowCovering',
-            StatelessProgrammableSwitch: 'GenericSwitch',
-            Valve: 'WaterValve',
-        };
-        return directMappings[serviceType] || null;
-    }
-    /**
-     * Create a Matter device with the specified type and map characteristics
-     */
-    async createMatterDevice(deviceType, accessory, primaryService) {
-        log.debug(`Creating Matter device of type ${deviceType} (placeholder implementation)`);
-        // Create a placeholder Matter device
-        // In production, this would use real Matter.js device classes
-        const device = {
-            type: deviceType,
-            accessoryUUID: accessory.UUID,
-            displayName: accessory.displayName,
-            services: accessory.services.map((s) => ({
-                type: s.constructor.name,
-                characteristics: s.characteristics.map((c) => ({
-                    type: c.constructor.name,
-                    value: c.value,
-                })),
-            })),
-            // Placeholder clusters based on device type
-            clusters: this.getPlaceholderClusters(deviceType),
-        };
-        // Map characteristics to Matter attributes (placeholder)
-        await this.mapCharacteristicsToMatter(device, primaryService);
-        return device;
-    }
-    /**
-     * Get placeholder clusters for a device type
-     */
-    getPlaceholderClusters(deviceType) {
-        const clusterMappings = {
-            OnOffLight: ['OnOff', 'Identify'],
-            DimmableLight: ['OnOff', 'LevelControl', 'Identify'],
-            ExtendedColorLight: ['OnOff', 'LevelControl', 'ColorControl', 'Identify'],
-            TemperatureSensor: ['TemperatureMeasurement', 'Identify'],
-            HumiditySensor: ['RelativeHumidityMeasurement', 'Identify'],
-            ContactSensor: ['BooleanState', 'Identify'],
-            DoorLock: ['DoorLock', 'Identify'],
-            WindowCovering: ['WindowCovering', 'Identify'],
-            Thermostat: ['Thermostat', 'Identify'],
-            Fan: ['FanControl', 'Identify'],
-        };
-        return clusterMappings[deviceType] || ['Identify'];
-    }
-    /**
-     * Map HAP characteristics to Matter cluster attributes
-     */
-    async mapCharacteristicsToMatter(matterDevice, hapService) {
-        try {
-            log.debug(`Mapping characteristics for service ${hapService.constructor.name} (placeholder implementation)`);
-            // This is a placeholder implementation that tracks the mapping
-            // In production, this would actually sync values between HAP and Matter
-            matterDevice.characteristicMappings = [];
-            for (const characteristic of hapService.characteristics) {
-                const charType = characteristic.constructor.name;
-                const mapping = {
-                    hapCharacteristic: charType,
-                    hapValue: characteristic.value,
-                    matterCluster: this.getMatterClusterForCharacteristic(charType),
-                    matterAttribute: this.getMatterAttributeForCharacteristic(charType),
-                };
-                matterDevice.characteristicMappings.push(mapping);
-                log.debug(`Mapped ${charType} -> ${mapping.matterCluster}.${mapping.matterAttribute}`);
-            }
-        }
-        catch (error) {
-            log.error('Error mapping characteristics to Matter:', error);
-        }
-    }
-    /**
-     * Get the Matter cluster name for a HAP characteristic
-     */
-    getMatterClusterForCharacteristic(charType) {
-        const mappings = {
-            On: 'OnOff',
-            Brightness: 'LevelControl',
-            Hue: 'ColorControl',
-            Saturation: 'ColorControl',
-            ColorTemperature: 'ColorControl',
-            CurrentTemperature: 'TemperatureMeasurement',
-            CurrentRelativeHumidity: 'RelativeHumidityMeasurement',
-            ContactSensorState: 'BooleanState',
-            MotionDetected: 'OccupancySensing',
-            LockCurrentState: 'DoorLock',
-            CurrentPosition: 'WindowCovering',
-            CurrentHeatingCoolingState: 'Thermostat',
-            RotationSpeed: 'FanControl',
-        };
-        return mappings[charType] || 'Unknown';
-    }
-    /**
-     * Get the Matter attribute name for a HAP characteristic
-     */
-    getMatterAttributeForCharacteristic(charType) {
-        const mappings = {
-            On: 'OnOff',
-            Brightness: 'CurrentLevel',
-            Hue: 'CurrentHue',
-            Saturation: 'CurrentSaturation',
-            ColorTemperature: 'ColorTemperatureMireds',
-            CurrentTemperature: 'MeasuredValue',
-            CurrentRelativeHumidity: 'MeasuredValue',
-            ContactSensorState: 'StateValue',
-            MotionDetected: 'Occupancy',
-            LockCurrentState: 'LockState',
-            CurrentPosition: 'CurrentPositionLiftPercent100ths',
-            CurrentHeatingCoolingState: 'SystemMode',
-            RotationSpeed: 'PercentCurrent',
-        };
-        return mappings[charType] || 'Value';
-    }
-    /**
-     * Get Matter server status
-     */
-    getStatus() {
-        const status = {
-            enabled: this.isEnabled,
-            running: this.isStarted,
-            accessoryCount: this.publishedAccessories.size,
-        };
-        // Add commissioning info if server is running
-        if (this.isStarted && this.isEnabled) {
-            try {
-                const setupCode = `MT:${this.matterConfig.discriminator.toString().padStart(4, '0')}${this.matterConfig.passcode}`;
-                const qrCodeUrl = `https://dhrishi.github.io/connectedhomeip/qrcode.html?data=${setupCode}`;
-                return {
-                    ...status,
-                    qrCode: qrCodeUrl,
-                    setupCode,
-                };
-            }
-            catch (error) {
-                log.debug('Could not generate QR code for status:', error);
-            }
-        }
-        return status;
-    }
-    /**
-     * Get commissioning QR code for setup
-     */
-    getCommissioningQRCode() {
-        if (!this.isEnabled || !this.isStarted) {
-            return null;
-        }
-        try {
-            // Generate placeholder QR code
-            // In production, this would use real Matter.js QrCode.encode()
-            const setupCode = `MT:${this.matterConfig.discriminator.toString().padStart(4, '0')}${this.matterConfig.passcode}`;
-            return `https://dhrishi.github.io/connectedhomeip/qrcode.html?data=${setupCode}`;
-        }
-        catch (error) {
-            log.error('Failed to generate commissioning QR code:', error);
-            return null;
-        }
-    }
-    /**
-     * Get manual pairing code for setup
-     */
-    getManualPairingCode() {
-        if (!this.isEnabled || !this.isStarted) {
-            return null;
-        }
-        return this.formatPairingCode(this.matterConfig.passcode);
-    }
-    /**
-     * Get list of published accessories
-     */
-    getPublishedAccessories() {
-        return Array.from(this.publishedAccessories.values()).map(item => item.accessory);
-    }
-    /**
-     * Check if an accessory is published via Matter
-     */
-    isAccessoryPublished(accessory) {
-        return this.publishedAccessories.has(accessory.UUID);
-    }
-    /**
-     * Get Matter configuration (read-only)
-     */
-    getConfiguration() {
-        return { ...this.matterConfig };
-    }
-    /**
-     * Force restart the Matter server (for configuration changes)
-     */
-    async restart() {
-        if (!this.isEnabled) {
-            return;
-        }
-        log.info('Restarting Matter server...');
-        try {
-            await this.stop();
-            await this.initialize();
-            await this.start();
-            log.info('Matter server restarted successfully');
-        }
-        catch (error) {
-            log.error('Failed to restart Matter server:', error);
-            throw error;
-        }
-    }
-}
-//# sourceMappingURL=matterService.js.map