@fastybird/smart-panel-backend 1.0.0-beta.3 → 1.1.0-alpha.1

package/dist/plugins/devices-homekit/services/homekit-actions.service.js

@@ -0,0 +1,92 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HomeKitActionsService = void 0;
+const common_1 = require("@nestjs/common");
+const logger_1 = require("../../../common/logger");
+const extension_action_registry_service_1 = require("../../../modules/extensions/services/extension-action-registry.service");
+const extension_action_interface_1 = require("../../../modules/extensions/services/extension-action.interface");
+const managed_service_manager_service_1 = require("../../../modules/extensions/services/managed-service-manager.service");
+const devices_homekit_constants_1 = require("../devices-homekit.constants");
+const homekit_bridge_service_1 = require("./homekit-bridge.service");
+let HomeKitActionsService = class HomeKitActionsService {
+    constructor(actionRegistry, bridgeService, managedServiceManager) {
+        this.actionRegistry = actionRegistry;
+        this.bridgeService = bridgeService;
+        this.managedServiceManager = managedServiceManager;
+        this.logger = (0, logger_1.createExtensionLogger)(devices_homekit_constants_1.DEVICES_HOMEKIT_PLUGIN_NAME, 'HomeKitActionsService');
+    }
+    onModuleInit() {
+        this.actionRegistry.register(devices_homekit_constants_1.DEVICES_HOMEKIT_PLUGIN_NAME, this.createRestartBridgeAction());
+        this.actionRegistry.register(devices_homekit_constants_1.DEVICES_HOMEKIT_PLUGIN_NAME, this.createResetPairingAction());
+    }
+    createRestartBridgeAction() {
+        return {
+            id: 'restart-bridge',
+            label: 'Restart Bridge',
+            description: 'Restarts the HomeKit bridge service and re-publishes mDNS advertisements.',
+            icon: 'mdi:restart',
+            category: extension_action_interface_1.ActionCategory.MAINTENANCE,
+            mode: 'immediate',
+            execute: async () => {
+                try {
+                    const restarted = await this.managedServiceManager.restartService(this.bridgeService.owner.kind, this.bridgeService.owner.type, this.bridgeService.serviceId);
+                    if (!restarted) {
+                        this.logger.warn('Failed to restart Apple HomeKit Bridge: service manager returned false');
+                        return {
+                            success: false,
+                            message: 'Failed to restart bridge. Ensure the plugin is enabled and bridge service is running.',
+                        };
+                    }
+                    return { success: true, message: 'Apple HomeKit Bridge restarted successfully.' };
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.logger.warn(`Failed to restart Apple HomeKit Bridge: ${message}`);
+                    return { success: false, message: `Failed to restart bridge: ${message}` };
+                }
+            },
+        };
+    }
+    createResetPairingAction() {
+        return {
+            id: 'reset-pairing',
+            label: 'Reset Pairing',
+            description: 'Clears all HomeKit pairing records and generates fresh bridge credentials. Existing paired Apple devices will need to be re-paired.',
+            icon: 'mdi:link-variant-off',
+            category: extension_action_interface_1.ActionCategory.MAINTENANCE,
+            mode: 'immediate',
+            dangerous: true,
+            execute: async () => {
+                try {
+                    await this.bridgeService.resetPairing();
+                    return {
+                        success: true,
+                        message: 'Apple HomeKit Bridge pairing reset successfully. New setup code generated.',
+                    };
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.logger.warn(`Failed to reset Apple HomeKit Bridge pairing: ${message}`);
+                    return { success: false, message: `Failed to reset pairing: ${message}` };
+                }
+            },
+        };
+    }
+};
+exports.HomeKitActionsService = HomeKitActionsService;
+exports.HomeKitActionsService = HomeKitActionsService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [extension_action_registry_service_1.ExtensionActionRegistryService,
+        homekit_bridge_service_1.HomeKitBridgeService,
+        managed_service_manager_service_1.ManagedServiceManagerService])
+], HomeKitActionsService);
+//# sourceMappingURL=homekit-actions.service.js.map

package/dist/plugins/devices-homekit/services/homekit-actions.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"homekit-actions.service.js","sourceRoot":"","sources":["../../../../src/plugins/devices-homekit/services/homekit-actions.service.ts"],"names":[],"mappings":"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"}

package/dist/plugins/devices-homekit/services/homekit-bridge.service.d.ts

@@ -0,0 +1,43 @@
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { ConfigService } from '../../../modules/config/services/config.service';
+import { DevicesService } from '../../../modules/devices/services/devices.service';
+import { ConfigChangeResult, IManagedExtensionService, ManagedServiceOwner, ServiceState } from '../../../modules/extensions/services/managed-extension-service.interface';
+import { ManagedServiceManagerService } from '../../../modules/extensions/services/managed-service-manager.service';
+import { HomeKitBridgeStatusModel } from '../models/bridge-status.model';
+import { HomeKitConfigModel } from '../models/config.model';
+import { HomeKitCommandDispatcher } from './homekit-command.dispatcher';
+import { HomeKitMapperRegistryService } from './homekit-mapper-registry.service';
+export declare class HomeKitBridgeService implements IManagedExtensionService {
+    private readonly configService;
+    private readonly devicesService;
+    private readonly mapperRegistry;
+    private readonly commandDispatcher;
+    private readonly eventEmitter;
+    private readonly managedServiceManager?;
+    private readonly logger;
+    readonly owner: ManagedServiceOwner;
+    readonly serviceId = "homekit-gateway";
+    private state;
+    private bridge;
+    private activeConfig;
+    private storageInitialized;
+    private lifecycleQueue;
+    constructor(configService: ConfigService, devicesService: DevicesService, mapperRegistry: HomeKitMapperRegistryService, commandDispatcher: HomeKitCommandDispatcher, eventEmitter: EventEmitter2, managedServiceManager?: ManagedServiceManagerService);
+    private emitBridgeStatusChanged;
+    private enqueueLifecycleOperation;
+    getConfig(): HomeKitConfigModel;
+    getState(): ServiceState;
+    private getStoragePath;
+    private initHapStorage;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    reconcileLatestMapping(): Promise<void>;
+    onConfigChanged(): Promise<ConfigChangeResult | void>;
+    private startUnlocked;
+    private stopUnlocked;
+    private reconcileLatestMappingUnlocked;
+    private populateBridgedAccessories;
+    getStatus(): Promise<HomeKitBridgeStatusModel>;
+    resetPairing(): Promise<void>;
+    updateMappedDevices(deviceIds: string[]): Promise<void>;
+}

package/dist/plugins/devices-homekit/services/homekit-bridge.service.js

@@ -0,0 +1,497 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var HomeKitBridgeService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HomeKitBridgeService = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const qrcode_1 = __importDefault(require("qrcode"));
+const hap_nodejs_1 = require("@homebridge/hap-nodejs");
+const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const transform_utils_1 = require("../../../common/utils/transform.utils");
+const config_service_1 = require("../../../modules/config/services/config.service");
+const devices_service_1 = require("../../../modules/devices/services/devices.service");
+const managed_service_manager_service_1 = require("../../../modules/extensions/services/managed-service-manager.service");
+const devices_homekit_constants_1 = require("../devices-homekit.constants");
+const update_config_dto_1 = require("../dto/update-config.dto");
+const bridge_status_model_1 = require("../models/bridge-status.model");
+const config_model_1 = require("../models/config.model");
+const homekit_command_dispatcher_1 = require("./homekit-command.dispatcher");
+const homekit_mapper_registry_service_1 = require("./homekit-mapper-registry.service");
+let HomeKitBridgeService = HomeKitBridgeService_1 = class HomeKitBridgeService {
+    constructor(configService, devicesService, mapperRegistry, commandDispatcher, eventEmitter, managedServiceManager) {
+        this.configService = configService;
+        this.devicesService = devicesService;
+        this.mapperRegistry = mapperRegistry;
+        this.commandDispatcher = commandDispatcher;
+        this.eventEmitter = eventEmitter;
+        this.managedServiceManager = managedServiceManager;
+        this.logger = new common_1.Logger(HomeKitBridgeService_1.name);
+        this.owner = {
+            kind: 'plugin',
+            type: devices_homekit_constants_1.DEVICES_HOMEKIT_PLUGIN_NAME,
+        };
+        this.serviceId = 'homekit-gateway';
+        this.state = 'stopped';
+        this.bridge = null;
+        this.activeConfig = null;
+        this.storageInitialized = false;
+        this.lifecycleQueue = Promise.resolve();
+    }
+    async emitBridgeStatusChanged() {
+        try {
+            const status = await this.getStatus();
+            this.eventEmitter.emit(devices_homekit_constants_1.EventType.BRIDGE_STATUS_CHANGED, status);
+        }
+        catch (error) {
+            this.logger.warn(`Failed to emit bridge status event: ${error.message}`);
+        }
+    }
+    enqueueLifecycleOperation(operation) {
+        const next = this.lifecycleQueue.then(operation, operation);
+        this.lifecycleQueue = next;
+        return next;
+    }
+    getConfig() {
+        const config = this.configService.getPluginConfig(devices_homekit_constants_1.DEVICES_HOMEKIT_PLUGIN_NAME);
+        if (!config) {
+            const fallback = new config_model_1.HomeKitConfigModel();
+            fallback.type = devices_homekit_constants_1.DEVICES_HOMEKIT_PLUGIN_NAME;
+            fallback.enabled = false;
+            fallback.bridgeName = devices_homekit_constants_1.DEFAULT_HOMEKIT_BRIDGE_NAME;
+            fallback.port = devices_homekit_constants_1.DEFAULT_HOMEKIT_PORT;
+            fallback.pincode = (0, devices_homekit_constants_1.generateRandomHomeKitPin)();
+            fallback.username = (0, devices_homekit_constants_1.generateRandomMacAddress)();
+            fallback.setupId = (0, devices_homekit_constants_1.generateRandomSetupId)();
+            fallback.mappedDeviceIds = [];
+            try {
+                this.configService.setPluginConfig(devices_homekit_constants_1.DEVICES_HOMEKIT_PLUGIN_NAME, fallback);
+            }
+            catch (err) {
+                this.logger.warn(`Could not persist initial HomeKit configuration: ${err.message}`);
+            }
+            return fallback;
+        }
+        return config;
+    }
+    getState() {
+        return this.state;
+    }
+    getStoragePath() {
+        const baseDir = process.env.FB_CONFIG_PATH || path_1.default.resolve(process.cwd(), 'var/data');
+        const storageDir = path_1.default.join(baseDir, devices_homekit_constants_1.HOMEKIT_PAIRING_STORAGE_DIR);
+        if (!fs_1.default.existsSync(storageDir)) {
+            fs_1.default.mkdirSync(storageDir, { recursive: true, mode: 0o700 });
+        }
+        if (process.platform !== 'win32') {
+            try {
+                const stat = fs_1.default.statSync(storageDir);
+                if ((stat.mode & 0o777) !== 0o700) {
+                    fs_1.default.chmodSync(storageDir, 0o700);
+                }
+                const verifiedStat = fs_1.default.statSync(storageDir);
+                if ((verifiedStat.mode & 0o777) !== 0o700) {
+                    throw new Error(`HomeKit storage directory '${storageDir}' permissions could not be verified as 0700 (actual: 0${(verifiedStat.mode & 0o777).toString(8)}).`);
+                }
+                const files = fs_1.default.readdirSync(storageDir);
+                for (const file of files) {
+                    const fullPath = path_1.default.join(storageDir, file);
+                    try {
+                        const fileStat = fs_1.default.statSync(fullPath);
+                        if (fileStat.isFile() && (fileStat.mode & 0o077) !== 0) {
+                            fs_1.default.chmodSync(fullPath, 0o600);
+                        }
+                    }
+                    catch {
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.error(`Failed to secure HomeKit pairing storage directory '${storageDir}': ${error.message}`);
+                throw error;
+            }
+        }
+        return storageDir;
+    }
+    initHapStorage() {
+        if (this.storageInitialized) {
+            return;
+        }
+        const storagePath = this.getStoragePath();
+        this.logger.log(`Initializing HomeKit pairing storage at: ${storagePath}`);
+        hap_nodejs_1.HAPStorage.setCustomStoragePath(storagePath);
+        this.storageInitialized = true;
+    }
+    async start() {
+        return this.enqueueLifecycleOperation(() => this.startUnlocked());
+    }
+    async stop() {
+        return this.enqueueLifecycleOperation(() => this.stopUnlocked());
+    }
+    async reconcileLatestMapping() {
+        return this.enqueueLifecycleOperation(() => this.reconcileLatestMappingUnlocked());
+    }
+    async onConfigChanged() {
+        return this.enqueueLifecycleOperation(async () => {
+            const newConfig = this.getConfig();
+            if (!this.activeConfig || this.state !== 'started') {
+                return { restartRequired: false };
+            }
+            const coreChanged = this.activeConfig.bridgeName !== newConfig.bridgeName ||
+                this.activeConfig.port !== newConfig.port ||
+                this.activeConfig.pincode !== newConfig.pincode ||
+                this.activeConfig.username !== newConfig.username ||
+                this.activeConfig.setupId !== newConfig.setupId ||
+                this.activeConfig.enabled !== newConfig.enabled;
+            if (coreChanged) {
+                return { restartRequired: true };
+            }
+            await this.reconcileLatestMappingUnlocked();
+            return { restartRequired: false };
+        });
+    }
+    async startUnlocked() {
+        const config = this.getConfig();
+        if (!config.enabled) {
+            this.logger.log('HomeKit Gateway is disabled in plugin configuration.');
+            this.state = 'stopped';
+            return;
+        }
+        if (this.bridge !== null && this.state === 'started') {
+            this.logger.debug('HomeKit Gateway is already running with current configuration.');
+            return;
+        }
+        this.state = 'starting';
+        this.logger.log(`Starting HomeKit Gateway bridge '${config.bridgeName}' on port ${config.port}...`);
+        try {
+            if (this.bridge) {
+                await this.stopUnlocked();
+                if (this.bridge) {
+                    throw new Error('Could not stop the previous HomeKit Gateway bridge.');
+                }
+            }
+            this.initHapStorage();
+            const bridgeUuid = hap_nodejs_1.uuid.generate(`fastybird.smart-panel.homekit.bridge.${config.username}`);
+            this.bridge = new hap_nodejs_1.Bridge(config.bridgeName, bridgeUuid);
+            const infoService = this.bridge.getService(hap_nodejs_1.Service.AccessoryInformation) ?? this.bridge.addService(hap_nodejs_1.Service.AccessoryInformation);
+            infoService
+                .setCharacteristic(hap_nodejs_1.Characteristic.Name, config.bridgeName)
+                .setCharacteristic(hap_nodejs_1.Characteristic.Manufacturer, 'FastyBird')
+                .setCharacteristic(hap_nodejs_1.Characteristic.Model, 'Smart Panel HomeKit Bridge')
+                .setCharacteristic(hap_nodejs_1.Characteristic.SerialNumber, config.username)
+                .setCharacteristic(hap_nodejs_1.Characteristic.FirmwareRevision, '1.0.0');
+            this.bridge.on("paired", () => {
+                this.logger.log('HomeKit client paired with bridge');
+                void this.emitBridgeStatusChanged();
+            });
+            this.bridge.on("unpaired", () => {
+                this.logger.log('HomeKit client unpaired from bridge');
+                void this.emitBridgeStatusChanged();
+            });
+            await this.populateBridgedAccessories(config.mappedDeviceIds);
+            await this.bridge.publish({
+                username: config.username,
+                pincode: config.pincode,
+                port: config.port,
+                category: 2,
+                setupID: config.setupId,
+                advertiser: "ciao",
+            });
+            this.activeConfig = {
+                ...config,
+                mappedDeviceIds: [...config.mappedDeviceIds],
+            };
+            this.state = 'started';
+            this.logger.log(`HomeKit Bridge published successfully. Port: ${config.port}, Username: ${config.username}`);
+            await this.emitBridgeStatusChanged();
+        }
+        catch (error) {
+            this.state = 'error';
+            await this.emitBridgeStatusChanged();
+            const err = error;
+            this.logger.error(`Failed to start HomeKit Bridge: ${err.message}`, err.stack);
+            throw error;
+        }
+    }
+    async stopUnlocked() {
+        this.state = 'stopping';
+        this.logger.log('Stopping HomeKit Bridge...');
+        try {
+            if (this.bridge) {
+                await this.bridge.unpublish();
+                this.bridge = null;
+            }
+            this.mapperRegistry.clearAllBindings();
+            this.activeConfig = null;
+            this.state = 'stopped';
+            this.logger.log('HomeKit Bridge stopped cleanly.');
+            await this.emitBridgeStatusChanged();
+        }
+        catch (error) {
+            this.state = 'error';
+            await this.emitBridgeStatusChanged();
+            const err = error;
+            this.logger.error(`Error stopping HomeKit Bridge: ${err.message}`, err.stack);
+        }
+    }
+    async reconcileLatestMappingUnlocked() {
+        if (!this.bridge || this.state !== 'started') {
+            return;
+        }
+        const config = this.getConfig();
+        const targetDeviceIds = config.mappedDeviceIds ?? [];
+        const targetSet = new Set(targetDeviceIds);
+        const currentBridgedMap = new Map();
+        for (const acc of this.bridge.bridgedAccessories) {
+            const serial = acc
+                .getService(hap_nodejs_1.Service.AccessoryInformation)
+                ?.getCharacteristic(hap_nodejs_1.Characteristic.SerialNumber)?.value;
+            const serialStr = typeof serial === 'string' ? serial : '';
+            if (serialStr) {
+                currentBridgedMap.set(serialStr, acc);
+            }
+        }
+        const currentDeviceIds = new Set(currentBridgedMap.keys());
+        const toAddIds = targetDeviceIds.filter((id) => !currentDeviceIds.has(id));
+        const toRemoveSerials = Array.from(currentDeviceIds).filter((id) => !targetSet.has(id));
+        if (toAddIds.length === 0 && toRemoveSerials.length === 0) {
+            return;
+        }
+        this.logger.log(`Reconciling HomeKit bridged accessories: adding ${toAddIds.length}, removing ${toRemoveSerials.length}...`);
+        const stagedAccessories = [];
+        for (const deviceId of toAddIds) {
+            const device = await this.devicesService.findOne(deviceId);
+            if (!device) {
+                const msg = `Device ${deviceId} not found in database during reconciliation.`;
+                this.logger.error(msg);
+                throw new Error(msg);
+            }
+            let staged;
+            try {
+                staged = this.mapperRegistry.buildAccessory(device, this.commandDispatcher);
+            }
+            catch (err) {
+                const msg = `Failed to build accessory for device ${deviceId}: ${err.message}`;
+                this.logger.error(msg);
+                throw new Error(msg, { cause: err });
+            }
+            if (!staged) {
+                const msg = `Device ${deviceId} could not be mapped to any supported HomeKit accessory.`;
+                this.logger.error(msg);
+                throw new Error(msg);
+            }
+            stagedAccessories.push(staged);
+        }
+        const snapshot = this.mapperRegistry.getSnapshot();
+        const originalAccessories = [...this.bridge.bridgedAccessories];
+        const originalAccessoriesMap = new Map(originalAccessories.map((a) => [a.UUID, a]));
+        try {
+            for (const serial of toRemoveSerials) {
+                const acc = currentBridgedMap.get(serial);
+                if (acc) {
+                    this.bridge.removeBridgedAccessory(acc);
+                    this.mapperRegistry.clearDeviceBindings(serial);
+                }
+            }
+            for (const staged of stagedAccessories) {
+                this.bridge.addBridgedAccessory(staged.accessory);
+            }
+            for (const staged of stagedAccessories) {
+                this.mapperRegistry.commitStaged(staged);
+            }
+            if (this.activeConfig) {
+                this.activeConfig.mappedDeviceIds = [...targetDeviceIds];
+            }
+            this.logger.log(`Successfully reconciled accessories. Active count: ${this.bridge.bridgedAccessories.length}`);
+            await this.emitBridgeStatusChanged();
+        }
+        catch (mutationError) {
+            this.logger.error(`Failed to mutate bridged accessories, rolling back: ${mutationError.message}`);
+            let rollbackSuccess = true;
+            try {
+                const currentOnBridge = [...this.bridge.bridgedAccessories];
+                for (const acc of currentOnBridge) {
+                    if (!originalAccessoriesMap.has(acc.UUID)) {
+                        try {
+                            this.bridge.removeBridgedAccessory(acc);
+                        }
+                        catch (e) {
+                            rollbackSuccess = false;
+                            this.logger.warn(`Failed to remove accessory during rollback: ${e.message}`);
+                        }
+                    }
+                }
+                const remainingOnBridgeMap = new Map(this.bridge.bridgedAccessories.map((a) => [a.UUID, a]));
+                for (const acc of originalAccessories) {
+                    if (!remainingOnBridgeMap.has(acc.UUID)) {
+                        try {
+                            this.bridge.addBridgedAccessory(acc);
+                        }
+                        catch (e) {
+                            rollbackSuccess = false;
+                            this.logger.warn(`Failed to restore original accessory during rollback: ${e.message}`);
+                        }
+                    }
+                }
+                if (this.bridge.bridgedAccessories.length !== originalAccessories.length) {
+                    rollbackSuccess = false;
+                }
+            }
+            catch (rollbackError) {
+                rollbackSuccess = false;
+                this.logger.error(`Critical error during bridge rollback: ${rollbackError.message}`);
+            }
+            finally {
+                this.mapperRegistry.restoreSnapshot(snapshot);
+            }
+            if (!rollbackSuccess) {
+                this.state = 'error';
+                this.logger.error('HomeKit Bridge entered error state because bridge rollback could not be fully completed.');
+                await this.emitBridgeStatusChanged();
+            }
+            throw mutationError;
+        }
+    }
+    async populateBridgedAccessories(mappedDeviceIds) {
+        if (!this.bridge) {
+            return;
+        }
+        let addedCount = 0;
+        for (const deviceId of mappedDeviceIds) {
+            try {
+                const device = await this.devicesService.findOne(deviceId);
+                if (!device) {
+                    this.logger.warn(`Mapped device ID not found in database: ${deviceId}`);
+                    continue;
+                }
+                const staged = this.mapperRegistry.buildAccessory(device, this.commandDispatcher);
+                if (staged) {
+                    this.bridge.addBridgedAccessory(staged.accessory);
+                    this.mapperRegistry.commitStaged(staged);
+                    addedCount++;
+                }
+            }
+            catch (error) {
+                const err = error;
+                this.logger.warn(`Failed to bridge device ${deviceId}: ${err.message}`);
+            }
+        }
+        this.logger.log(`Bridged ${addedCount} accessories into HomeKit Bridge.`);
+    }
+    async getStatus() {
+        const config = this.getConfig();
+        const isRunning = this.state === 'started' && this.bridge !== null;
+        let isPaired = false;
+        let pairedClientsCount = 0;
+        let setupUri = '';
+        let qrCodeDataUri = '';
+        if (isRunning && this.bridge) {
+            try {
+                setupUri = this.bridge.setupURI();
+                if (setupUri) {
+                    qrCodeDataUri = await qrcode_1.default.toDataURL(setupUri, {
+                        margin: 1,
+                        width: 256,
+                        errorCorrectionLevel: 'M',
+                    });
+                }
+                const server = this.bridge._server;
+                if (server?.accessoryInfo) {
+                    isPaired = Boolean(server.accessoryInfo.paired());
+                    const pairings = server.accessoryInfo.listPairings();
+                    pairedClientsCount = Array.isArray(pairings) ? pairings.length : 0;
+                }
+            }
+            catch (err) {
+                this.logger.warn(`Could not extract pairing metadata: ${err.message}`);
+            }
+        }
+        const status = new bridge_status_model_1.HomeKitBridgeStatusModel();
+        status.running = isRunning;
+        status.paired = isPaired;
+        status.pairedClientsCount = pairedClientsCount;
+        status.bridgeName = config.bridgeName;
+        status.port = config.port;
+        status.pincode = config.pincode;
+        status.username = config.username;
+        status.setupUri = setupUri;
+        status.qrCodeDataUri = qrCodeDataUri;
+        status.exposedDevicesCount = this.bridge?.bridgedAccessories.length ?? config.mappedDeviceIds.length;
+        return status;
+    }
+    async resetPairing() {
+        await this.enqueueLifecycleOperation(async () => {
+            this.logger.log('Resetting HomeKit pairing credentials (Phase 1: destructive teardown)...');
+            const bridge = this.bridge;
+            await this.stopUnlocked();
+            if (bridge) {
+                await bridge.destroy();
+            }
+            const storagePath = this.getStoragePath();
+            try {
+                if (fs_1.default.existsSync(storagePath)) {
+                    const files = fs_1.default.readdirSync(storagePath);
+                    for (const file of files) {
+                        const fullPath = path_1.default.join(storagePath, file);
+                        fs_1.default.rmSync(fullPath, { recursive: true, force: true });
+                    }
+                    this.logger.log(`Cleared pairing storage files in: ${storagePath}`);
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Failed to delete pairing storage files: ${error.message}`);
+            }
+            this.mapperRegistry.clearAllBindings();
+        });
+        this.logger.log('Resetting HomeKit pairing credentials (Phase 2: rotating credentials)...');
+        const pincode = (0, devices_homekit_constants_1.generateRandomHomeKitPin)();
+        const username = (0, devices_homekit_constants_1.generateRandomMacAddress)();
+        const setup_id = (0, devices_homekit_constants_1.generateRandomSetupId)();
+        const updateDto = (0, transform_utils_1.toInstance)(update_config_dto_1.HomeKitUpdatePluginConfigDto, {
+            type: devices_homekit_constants_1.DEVICES_HOMEKIT_PLUGIN_NAME,
+            pincode,
+            username,
+            setup_id,
+        });
+        await this.configService.updatePluginConfig(devices_homekit_constants_1.DEVICES_HOMEKIT_PLUGIN_NAME, updateDto);
+        await this.enqueueLifecycleOperation(async () => {
+            this.logger.log('Resetting HomeKit pairing credentials (Phase 3: starting bridge)...');
+            await this.startUnlocked();
+        });
+    }
+    async updateMappedDevices(deviceIds) {
+        const updateDto = (0, transform_utils_1.toInstance)(update_config_dto_1.HomeKitUpdatePluginConfigDto, {
+            type: devices_homekit_constants_1.DEVICES_HOMEKIT_PLUGIN_NAME,
+            mapped_device_ids: deviceIds,
+        });
+        await this.configService.updatePluginConfig(devices_homekit_constants_1.DEVICES_HOMEKIT_PLUGIN_NAME, updateDto);
+        await this.reconcileLatestMapping();
+    }
+};
+exports.HomeKitBridgeService = HomeKitBridgeService;
+exports.HomeKitBridgeService = HomeKitBridgeService = HomeKitBridgeService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(5, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [config_service_1.ConfigService,
+        devices_service_1.DevicesService,
+        homekit_mapper_registry_service_1.HomeKitMapperRegistryService,
+        homekit_command_dispatcher_1.HomeKitCommandDispatcher,
+        event_emitter_1.EventEmitter2,
+        managed_service_manager_service_1.ManagedServiceManagerService])
+], HomeKitBridgeService);
+//# sourceMappingURL=homekit-bridge.service.js.map