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

package/dist/plugins/devices-wled/services/wled.service.js

@@ -17,29 +17,44 @@ const config_service_1 = require("../../../modules/config/services/config.servic
 const devices_constants_1 = require("../../../modules/devices/devices.constants");
 const device_connectivity_service_1 = require("../../../modules/devices/services/device-connectivity.service");
 const devices_service_1 = require("../../../modules/devices/services/devices.service");
-const base_managed_plugin_service_1 = require("../../../modules/extensions/services/base-managed-plugin.service");
-const plugin_service_manager_service_1 = require("../../../modules/extensions/services/plugin-service-manager.service");
+const base_managed_extension_service_1 = require("../../../modules/extensions/services/base-managed-extension.service");
+const managed_service_manager_service_1 = require("../../../modules/extensions/services/managed-service-manager.service");
 const devices_wled_constants_1 = require("../devices-wled.constants");
+const devices_wled_exceptions_1 = require("../devices-wled.exceptions");
+const adoption_snapshot_service_1 = require("./adoption-snapshot.service");
 const device_mapper_service_1 = require("./device-mapper.service");
+const hardware_identity_service_1 = require("./hardware-identity.service");
 const wled_client_adapter_service_1 = require("./wled-client-adapter.service");
 const wled_mdns_discoverer_service_1 = require("./wled-mdns-discoverer.service");
-let WledService = class WledService extends base_managed_plugin_service_1.BaseManagedPluginService {
-    constructor(configService, wledAdapter, deviceMapper, devicesService, mdnsDiscoverer, deviceConnectivityService, pluginServiceManager) {
+let WledService = class WledService extends base_managed_extension_service_1.BaseManagedExtensionService {
+    constructor(configService, wledAdapter, deviceMapper, adoptionSnapshot, hardwareIdentity, devicesService, mdnsDiscoverer, deviceConnectivityService, managedServiceManager) {
         super();
         this.configService = configService;
         this.wledAdapter = wledAdapter;
         this.deviceMapper = deviceMapper;
+        this.adoptionSnapshot = adoptionSnapshot;
+        this.hardwareIdentity = hardwareIdentity;
         this.devicesService = devicesService;
         this.mdnsDiscoverer = mdnsDiscoverer;
         this.deviceConnectivityService = deviceConnectivityService;
-        this.pluginServiceManager = pluginServiceManager;
+        this.managedServiceManager = managedServiceManager;
         this.logger = (0, logger_1.createExtensionLogger)(devices_wled_constants_1.DEVICES_WLED_PLUGIN_NAME, 'WledService');
-        this.pluginName = devices_wled_constants_1.DEVICES_WLED_PLUGIN_NAME;
+        this.owner = { kind: 'plugin', type: devices_wled_constants_1.DEVICES_WLED_PLUGIN_NAME };
         this.serviceId = 'connector';
         this.pluginConfig = null;
         this.pollingInterval = null;
+        this.adoptionQueue = Promise.resolve();
         this.wledAdapter.setCallbacks({
-            onDeviceConnected: (event) => this.handleDeviceConnected(event),
+            onDeviceConnected: async (event) => {
+                try {
+                    await this.handleDeviceConnected(event);
+                }
+                catch (error) {
+                    this.logger.error(`Failed to process WLED connected event for ${event.host}`, {
+                        message: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            },
             onDeviceDisconnected: (event) => this.handleDeviceDisconnected(event),
             onDeviceStateChanged: (event) => this.handleDeviceStateChanged(event),
             onDeviceError: (event) => this.handleDeviceError(event),
@@ -48,6 +63,11 @@ let WledService = class WledService extends base_managed_plugin_service_1.BaseMa
             onDeviceDiscovered: (device) => this.handleMdnsDeviceDiscovered(device),
         });
     }
+    isHealthy() {
+        return Promise.resolve(this.state === 'started' &&
+            this.pollingInterval !== null &&
+            (!this.config.mdns.enabled || this.mdnsDiscoverer.isDiscoveryRunning()));
+    }
     async start() {
         await this.withLock(async () => {
             switch (this.state) {
@@ -114,7 +134,7 @@ let WledService = class WledService extends base_managed_plugin_service_1.BaseMa
         return Promise.resolve({ restartRequired: false });
     }
     async restart() {
-        const success = await this.pluginServiceManager.restartService(this.pluginName, this.serviceId);
+        const success = await this.managedServiceManager.restartService(this.owner.kind, this.owner.type, this.serviceId);
         if (!success) {
             this.logger.debug('Restart skipped (plugin may be disabled)');
         }
@@ -187,6 +207,12 @@ let WledService = class WledService extends base_managed_plugin_service_1.BaseMa
             await this.wledAdapter.connect(device.hostname, device.identifier, this.config.timeouts.connectionTimeout);
             const registeredDevice = this.wledAdapter.getDevice(device.hostname);
             if (registeredDevice?.context) {
+                const identityVerified = await this.persistHardwareIdentity(device, registeredDevice.context.info.mac);
+                if (!identityVerified) {
+                    this.wledAdapter.disconnect(device.hostname, false);
+                    await this.deviceMapper.setDeviceConnectionState(device.identifier, devices_constants_1.ConnectionState.DISCONNECTED);
+                    return;
+                }
                 await this.deviceMapper.updateDeviceState(device.identifier, registeredDevice.context.state);
             }
         }
@@ -201,9 +227,41 @@ let WledService = class WledService extends base_managed_plugin_service_1.BaseMa
         this.logger.log(`Device connected: ${event.host} (${event.info.name})`);
         const device = this.wledAdapter.getDevice(event.host);
         if (device) {
+            const storedDevice = await this.devicesService.findOneBy('identifier', device.identifier, devices_wled_constants_1.DEVICES_WLED_TYPE);
+            if (storedDevice) {
+                const identityVerified = await this.persistHardwareIdentity(storedDevice, event.info.mac);
+                if (!identityVerified) {
+                    this.wledAdapter.disconnect(event.host, false);
+                    await this.deviceMapper.setDeviceConnectionState(device.identifier, devices_constants_1.ConnectionState.DISCONNECTED);
+                    return;
+                }
+            }
             await this.deviceMapper.setDeviceConnectionState(device.identifier, devices_constants_1.ConnectionState.CONNECTED);
         }
     }
+    async persistHardwareIdentity(device, reportedMac) {
+        const mac = this.normalizeMac(reportedMac);
+        if (!mac) {
+            if (device.mac) {
+                this.logger.warn('WLED did not report a valid hardware identity for the configured device', {
+                    resource: device.id,
+                });
+                return false;
+            }
+            return true;
+        }
+        if (device.mac === mac) {
+            return true;
+        }
+        const result = await this.hardwareIdentity.persist(device, mac);
+        if (result === 'conflict') {
+            this.logger.warn(`WLED hardware identity ${mac} conflicts with the configured device`, {
+                resource: device.id,
+            });
+            return false;
+        }
+        return true;
+    }
     async handleDeviceDisconnected(event) {
         this.logger.log(`Device disconnected: ${event.host} (${event.reason || 'unknown reason'})`);
         await this.deviceMapper.setDeviceConnectionState(event.identifier, devices_constants_1.ConnectionState.DISCONNECTED);
@@ -279,12 +337,44 @@ let WledService = class WledService extends base_managed_plugin_service_1.BaseMa
     }
     async handleMdnsDeviceDiscovered(device) {
         this.logger.log(`mDNS discovered device: ${device.name} at ${device.host}`);
-        const devices = await this.devicesService.findAll(devices_wled_constants_1.DEVICES_WLED_TYPE);
-        const existingDevice = devices.find((d) => d.hostname === device.host);
+        const endpoint = this.discoveryEndpoint(device.host, device.port);
+        const advertisedMac = this.normalizeMac(device.mac) ? device.mac : undefined;
+        let devices;
+        try {
+            devices = await this.devicesService.findAll(devices_wled_constants_1.DEVICES_WLED_TYPE);
+        }
+        catch (error) {
+            this.mdnsDiscoverer.forgetDiscoveredDevice(device.host);
+            this.logger.error(`Could not inspect discovered WLED device at ${endpoint}`, {
+                message: error instanceof Error ? error.message : String(error),
+            });
+            return;
+        }
+        let identifiedDevice = { ...device, mac: advertisedMac };
+        let existingDevice = this.findExistingDevice(devices, endpoint, advertisedMac);
+        if (!existingDevice && !advertisedMac && !this.config.mdns.autoAdd) {
+            try {
+                const context = await this.wledAdapter.probe(endpoint, this.config.timeouts.connectionTimeout);
+                identifiedDevice = { ...device, mac: context.info.mac };
+                existingDevice = this.findExistingDevice(devices, endpoint, context.info.mac);
+            }
+            catch (error) {
+                this.mdnsDiscoverer.forgetDiscoveredDevice(device.host);
+                this.logger.debug(`Could not identify MAC-less WLED device at ${endpoint}`, {
+                    message: error instanceof Error ? error.message : String(error),
+                });
+                return;
+            }
+        }
         if (existingDevice) {
-            this.logger.debug(`Device at ${device.host} already exists in database`);
-            if (existingDevice.enabled && !this.wledAdapter.isConnected(device.host)) {
-                this.logger.debug(`Connecting to existing device at ${device.host}`);
+            this.logger.debug(`Device at ${endpoint} already exists in database`);
+            const identityUpgradeRequired = this.requiresCanonicalIdentity(existingDevice, endpoint, identifiedDevice.mac);
+            if (identityUpgradeRequired ||
+                (existingDevice.hostname && !this.endpointsEquivalent(existingDevice.hostname, endpoint))) {
+                await this.connectAndMapDiscoveredDevice(identifiedDevice);
+            }
+            else if (existingDevice.enabled && !this.wledAdapter.isConnected(endpoint)) {
+                this.logger.debug(`Connecting to existing device at ${endpoint}`);
                 await this.connectToDevice(existingDevice);
             }
             return;
@@ -298,30 +388,671 @@ let WledService = class WledService extends base_managed_plugin_service_1.BaseMa
         }
     }
     async connectAndMapDiscoveredDevice(device) {
-        const identifier = device.mac
-            ? `wled-${device.mac.replace(/:/g, '').toLowerCase()}`
-            : `wled-${device.host.replace(/\./g, '-')}`;
-        try {
-            await this.wledAdapter.connect(device.host, identifier, this.config.timeouts.connectionTimeout);
-            const registeredDevice = this.wledAdapter.getDevice(device.host);
-            if (registeredDevice?.context) {
-                await this.deviceMapper.mapDevice(device.host, registeredDevice.context, device.name, identifier);
+        await this.enqueueProvisioning(async () => {
+            try {
+                const endpoint = this.discoveryEndpoint(device.host, device.port);
+                const devices = await this.devicesService.findAll(devices_wled_constants_1.DEVICES_WLED_TYPE);
+                const existingDevice = this.findExistingDevice(devices, endpoint, device.mac);
+                if (existingDevice?.hostname &&
+                    this.endpointsEquivalent(existingDevice.hostname, endpoint) &&
+                    !this.requiresCanonicalIdentity(existingDevice, endpoint, device.mac)) {
+                    if (existingDevice.enabled && !this.wledAdapter.isConnected(endpoint)) {
+                        await this.connectToDevice(existingDevice);
+                    }
+                    return;
+                }
+                const [result] = await this.doAdoptDevices([
+                    {
+                        host: endpoint,
+                        name: existingDevice?.name ?? device.name,
+                        category: devices_constants_1.DeviceCategory.LIGHTING,
+                    },
+                ]);
+                if (!result || result.status === 'failed') {
+                    this.mdnsDiscoverer.forgetDiscoveredDevice(device.host);
+                    this.logger.warn(`Auto-add failed for discovered WLED device at ${endpoint}`, {
+                        message: result?.error ?? 'No adoption result was returned',
+                    });
+                }
+            }
+            catch (error) {
+                this.mdnsDiscoverer.forgetDiscoveredDevice(device.host);
+                this.logger.error(`Failed to connect to discovered device at ${device.host}`, {
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+    }
+    getDiscoveredDevices() {
+        return this.mdnsDiscoverer.getDiscoveredDevices();
+    }
+    async getDiscoveryInventory() {
+        const [discoveredDevices, databaseDevices] = await Promise.all([
+            Promise.resolve(this.mdnsDiscoverer.getDiscoveredDevices()),
+            this.devicesService.findAll(devices_wled_constants_1.DEVICES_WLED_TYPE),
+        ]);
+        return {
+            mdnsEnabled: this.config.mdns.enabled,
+            discoveryRunning: this.mdnsDiscoverer.isDiscoveryRunning(),
+            devices: discoveredDevices.map((device) => {
+                const discoveryEndpoint = this.discoveryEndpoint(device.host, device.port);
+                const existingDevice = this.findExistingDevice(databaseDevices, discoveryEndpoint, device.mac);
+                return {
+                    host: device.host,
+                    name: existingDevice?.name ?? device.name,
+                    mac: this.normalizeMac(device.mac),
+                    port: device.port,
+                    adoptedDeviceId: existingDevice?.id ?? null,
+                };
+            }),
+        };
+    }
+    async probeDevice(host) {
+        const normalizedHost = this.normalizeHost(host);
+        const context = await this.wledAdapter.probe(normalizedHost, this.config.timeouts.connectionTimeout);
+        const mac = this.normalizeMac(context.info.mac);
+        if (!mac) {
+            throw new devices_wled_exceptions_1.WledValidationException('WLED device did not report a valid MAC address');
+        }
+        const databaseDevices = await this.devicesService.findAll(devices_wled_constants_1.DEVICES_WLED_TYPE);
+        const existingDevice = this.findExistingDevice(databaseDevices, normalizedHost, mac);
+        return {
+            host: normalizedHost,
+            name: existingDevice?.name || context.info.name || `WLED ${mac}`,
+            mac,
+            port: this.portFromHost(normalizedHost),
+            adoptedDeviceId: existingDevice?.id ?? null,
+        };
+    }
+    async rescanDiscovery() {
+        this.mdnsDiscoverer.clearDiscoveredDevices();
+        if (this.config.mdns.enabled) {
+            this.mdnsDiscoverer.stop();
+            this.mdnsDiscoverer.start(this.config.mdns.interface ?? undefined);
+        }
+        return this.getDiscoveryInventory();
+    }
+    async adoptDevices(requests) {
+        return this.enqueueProvisioning(() => this.doAdoptDevices(requests));
+    }
+    async doAdoptDevices(requests) {
+        const results = requests.map(() => undefined);
+        const databaseDevices = await this.devicesService.findAll(devices_wled_constants_1.DEVICES_WLED_TYPE);
+        const failedSelectionHosts = new Set();
+        const plans = [];
+        const plannedIdentities = new Set();
+        for (const [index, request] of requests.entries()) {
+            let host = request.host.trim();
+            try {
+                host = this.normalizeHost(request.host);
+                const context = await this.wledAdapter.probe(host, this.config.timeouts.connectionTimeout);
+                const existingDevice = this.findExistingDevice(databaseDevices, host, context.info.mac);
+                const canonicalIdentity = this.identifierFromMac(context.info.mac);
+                const existingIdentifier = existingDevice?.identifier;
+                const identifier = existingIdentifier &&
+                    !this.legacyHostIdentifiers(existingDevice.hostname ?? host).has(existingIdentifier.toLowerCase()) &&
+                    existingIdentifier.toLowerCase() !== `wled-${canonicalIdentity.slice(-6)}`
+                    ? existingIdentifier
+                    : canonicalIdentity;
+                if (plannedIdentities.has(canonicalIdentity)) {
+                    results[index] = {
+                        host,
+                        name: request.name,
+                        status: 'failed',
+                        error: 'The same WLED controller was selected more than once',
+                        deviceId: existingDevice?.id ?? null,
+                    };
+                    continue;
+                }
+                plannedIdentities.add(canonicalIdentity);
+                plans.push({ index, request, host, context, existingDevice, identifier });
+            }
+            catch (error) {
+                failedSelectionHosts.add(host);
+                results[index] = {
+                    host,
+                    name: request.name,
+                    status: 'failed',
+                    error: error instanceof Error ? error.message : String(error),
+                    deviceId: null,
+                };
+            }
+        }
+        const plannedExistingDeviceIds = new Set(plans.flatMap(({ existingDevice }) => (existingDevice ? [existingDevice.id] : [])));
+        const selectedDeviceIds = plannedExistingDeviceIds;
+        const moveHostEdges = new Map();
+        for (const plan of plans) {
+            const sourceHost = plan.existingDevice?.hostname ? this.canonicalEndpoint(plan.existingDevice.hostname) : null;
+            const targetHost = this.canonicalEndpoint(plan.host);
+            if (!sourceHost || sourceHost === targetHost) {
+                continue;
+            }
+            const sourceEdges = moveHostEdges.get(sourceHost) ?? new Set();
+            sourceEdges.add(targetHost);
+            moveHostEdges.set(sourceHost, sourceEdges);
+            const targetEdges = moveHostEdges.get(targetHost) ?? new Set();
+            targetEdges.add(sourceHost);
+            moveHostEdges.set(targetHost, targetEdges);
+        }
+        const failedMoveHosts = new Set();
+        const pendingFailedHosts = [...failedSelectionHosts].map((host) => this.canonicalEndpoint(host));
+        while (pendingFailedHosts.length > 0) {
+            const currentHost = pendingFailedHosts.pop();
+            if (!currentHost || failedMoveHosts.has(currentHost)) {
+                continue;
             }
+            failedMoveHosts.add(currentHost);
+            pendingFailedHosts.push(...(moveHostEdges.get(currentHost) ?? []));
+        }
+        const blockedPlanIndices = new Set();
+        for (const plan of plans) {
+            if (failedMoveHosts.has(this.canonicalEndpoint(plan.host)) ||
+                (plan.existingDevice?.hostname !== null &&
+                    plan.existingDevice?.hostname !== undefined &&
+                    failedMoveHosts.has(this.canonicalEndpoint(plan.existingDevice.hostname)))) {
+                blockedPlanIndices.add(plan.index);
+                results[plan.index] = {
+                    host: plan.host,
+                    name: plan.request.name,
+                    status: 'failed',
+                    error: 'A related selected WLED controller could not be probed',
+                    deviceId: plan.existingDevice?.id ?? null,
+                };
+            }
+        }
+        const dependencyEdges = new Map();
+        for (const plan of plans.filter(({ index }) => !blockedPlanIndices.has(index))) {
+            const selectedTargetOwner = plans.find((candidate) => candidate.existingDevice?.hostname !== null &&
+                candidate.existingDevice?.hostname !== undefined &&
+                this.endpointsEquivalent(candidate.existingDevice.hostname, plan.host) &&
+                candidate.existingDevice.id !== plan.existingDevice?.id);
+            if (selectedTargetOwner) {
+                const planEdges = dependencyEdges.get(plan.index) ?? new Set();
+                planEdges.add(selectedTargetOwner.index);
+                dependencyEdges.set(plan.index, planEdges);
+                const ownerEdges = dependencyEdges.get(selectedTargetOwner.index) ?? new Set();
+                ownerEdges.add(plan.index);
+                dependencyEdges.set(selectedTargetOwner.index, ownerEdges);
+            }
+        }
+        const dependencyGroupByIndex = new Map();
+        for (const start of dependencyEdges.keys()) {
+            if (dependencyGroupByIndex.has(start)) {
+                continue;
+            }
+            const group = new Set();
+            const pending = [start];
+            while (pending.length > 0) {
+                const current = pending.pop();
+                if (current === undefined || group.has(current)) {
+                    continue;
+                }
+                group.add(current);
+                pending.push(...(dependencyEdges.get(current) ?? []));
+            }
+            for (const member of group) {
+                dependencyGroupByIndex.set(member, group);
+            }
+        }
+        const registrationSnapshotsByDependencyGroup = new Map();
+        for (const dependencyGroup of new Set(dependencyGroupByIndex.values())) {
+            const involvedHosts = plans
+                .filter((plan) => dependencyGroup.has(plan.index))
+                .flatMap((plan) => [plan.host, plan.existingDevice?.hostname].filter((host) => !!host));
+            const registrations = this.wledAdapter
+                .getRegisteredDevices()
+                .filter((registration) => involvedHosts.some((host) => this.endpointsEquivalent(registration.host, host)))
+                .map((registration) => ({ ...registration }));
+            registrationSnapshotsByDependencyGroup.set(dependencyGroup, registrations);
+        }
+        const retiredDeviceIds = new Set();
+        const failedDependencyGroups = new Map();
+        const createdDeviceIdsByPlan = new Map();
+        const structureSnapshotsByPlan = new Map();
+        const retiredStaleOwnersByDependencyGroup = new Map();
+        const deferredPruningByDependencyGroup = new Map();
+        for (const { index, request, host, context, existingDevice, identifier } of plans) {
+            if (blockedPlanIndices.has(index)) {
+                continue;
+            }
+            const dependencyGroup = dependencyGroupByIndex.get(index);
+            const dependencyFailure = dependencyGroup ? failedDependencyGroups.get(dependencyGroup) : undefined;
+            if (dependencyFailure) {
+                results[index] = {
+                    host,
+                    name: request.name,
+                    status: 'failed',
+                    error: dependencyFailure,
+                    deviceId: existingDevice?.id ?? null,
+                };
+                continue;
+            }
+            let mappedDevice = null;
+            let existingDeviceDisconnected = false;
+            let attemptedRegistrationCreated = false;
+            const retiredStaleOwners = [];
+            const disconnectedStaleOwners = [];
+            try {
+                if (existingDevice) {
+                    structureSnapshotsByPlan.set(index, await this.adoptionSnapshot.capture(existingDevice.id));
+                }
+                if (existingDevice && existingDevice.identifier !== identifier) {
+                    await this.devicesService.update(existingDevice.id, {
+                        type: devices_wled_constants_1.DEVICES_WLED_TYPE,
+                        identifier,
+                        hostname: host,
+                    });
+                }
+                const device = await this.deviceMapper.mapDevice(host, context, request.name, identifier, request.description, request.enabled);
+                mappedDevice = device;
+                if (!existingDevice) {
+                    createdDeviceIdsByPlan.set(index, device.id);
+                }
+                if (existingDevice?.hostname && existingDevice.hostname !== host) {
+                    const sourceRegistration = this.wledAdapter.getDevice(existingDevice.hostname);
+                    if (sourceRegistration?.identifier === existingDevice.identifier) {
+                        this.wledAdapter.disconnect(existingDevice.hostname, false);
+                        existingDeviceDisconnected = true;
+                    }
+                }
+                const staleHostOwners = databaseDevices.filter((device) => device.hostname !== null &&
+                    this.endpointsEquivalent(device.hostname, host) &&
+                    device.id !== existingDevice?.id);
+                const retiringHostOwners = staleHostOwners.filter((staleHostOwner) => !selectedDeviceIds.has(staleHostOwner.id) && !retiredDeviceIds.has(staleHostOwner.id));
+                if (dependencyGroup && retiringHostOwners.length > 0) {
+                    const groupOwners = retiredStaleOwnersByDependencyGroup.get(dependencyGroup) ?? new Map();
+                    for (const staleHostOwner of staleHostOwners) {
+                        groupOwners.set(staleHostOwner.id, staleHostOwner);
+                    }
+                    retiredStaleOwnersByDependencyGroup.set(dependencyGroup, groupOwners);
+                }
+                if (staleHostOwners.length > 0) {
+                    for (const staleHostOwner of retiringHostOwners) {
+                        if (!staleHostOwner.hostname) {
+                            continue;
+                        }
+                        const staleRegistration = this.wledAdapter.getDevice(staleHostOwner.hostname);
+                        if (staleRegistration?.identifier === staleHostOwner.identifier) {
+                            this.wledAdapter.disconnect(staleHostOwner.hostname, false);
+                            if (retiringHostOwners.some(({ id }) => id === staleHostOwner.id)) {
+                                disconnectedStaleOwners.push(staleHostOwner);
+                            }
+                        }
+                    }
+                }
+                for (const staleHostOwner of retiringHostOwners) {
+                    retiredStaleOwners.push(staleHostOwner);
+                    await this.devicesService.update(staleHostOwner.id, {
+                        type: devices_wled_constants_1.DEVICES_WLED_TYPE,
+                        enabled: false,
+                        hostname: null,
+                    });
+                    await this.deviceConnectivityService.setConnectionState(staleHostOwner.id, {
+                        state: devices_constants_1.ConnectionState.DISCONNECTED,
+                    });
+                    retiredDeviceIds.add(staleHostOwner.id);
+                }
+                let connectionState = devices_constants_1.ConnectionState.DISCONNECTED;
+                if (!device.enabled) {
+                    this.wledAdapter.disconnect(host, false);
+                    existingDeviceDisconnected = existingDevice !== null;
+                }
+                else {
+                    const registeredDevice = this.wledAdapter.getDevice(host);
+                    if (registeredDevice?.identifier === identifier && registeredDevice.connected) {
+                        registeredDevice.context = context;
+                        registeredDevice.lastSeen = new Date();
+                        connectionState = devices_constants_1.ConnectionState.CONNECTED;
+                    }
+                    else {
+                        try {
+                            this.wledAdapter.connectWithContext(host, identifier, context);
+                            attemptedRegistrationCreated = true;
+                            connectionState = devices_constants_1.ConnectionState.CONNECTED;
+                        }
+                        catch (error) {
+                            this.logger.warn(`WLED device ${identifier} was adopted but its live connection could not be registered`, {
+                                resource: device.id,
+                                message: error instanceof Error ? error.message : String(error),
+                            });
+                        }
+                    }
+                }
+                await this.deviceConnectivityService.setConnectionState(device.id, {
+                    state: connectionState,
+                });
+                if (dependencyGroup) {
+                    const deferredPruning = deferredPruningByDependencyGroup.get(dependencyGroup) ?? [];
+                    deferredPruning.push({ device, state: context.state });
+                    deferredPruningByDependencyGroup.set(dependencyGroup, deferredPruning);
+                }
+                else {
+                    await this.deviceMapper.pruneObsoleteSegmentChannels(device, context.state);
+                }
+                results[index] = {
+                    host,
+                    name: request.name,
+                    status: existingDevice ? 'updated' : 'created',
+                    error: null,
+                    deviceId: device.id,
+                };
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                if (dependencyGroup) {
+                    const dependentFailure = `A related WLED address move failed: ${reason}`;
+                    failedDependencyGroups.set(dependencyGroup, dependentFailure);
+                    const dependentPlans = plans.filter((plan) => dependencyGroup.has(plan.index));
+                    const involvedHosts = new Set(dependentPlans.flatMap((plan) => [plan.host, plan.existingDevice?.hostname].filter((item) => !!item)));
+                    for (const involvedHost of involvedHosts) {
+                        await this.tryRollback(`disconnect ${involvedHost}`, () => Promise.resolve(this.wledAdapter.disconnect(involvedHost, false)));
+                    }
+                    for (const dependentPlan of dependentPlans) {
+                        if (dependentPlan.existingDevice) {
+                            const original = dependentPlan.existingDevice;
+                            const structureSnapshot = structureSnapshotsByPlan.get(dependentPlan.index);
+                            if (structureSnapshot) {
+                                await this.tryRollback(`restore device structure ${original.id}`, () => this.adoptionSnapshot.restore(structureSnapshot));
+                            }
+                            await this.tryRollback(`restore device ${original.id}`, () => this.devicesService.update(original.id, {
+                                type: devices_wled_constants_1.DEVICES_WLED_TYPE,
+                                identifier: original.identifier,
+                                name: original.name,
+                                description: original.description,
+                                enabled: original.enabled,
+                                hostname: original.hostname,
+                            }));
+                            await this.tryRollback(`restore hardware identity ${original.id}`, () => this.hardwareIdentity.restore(original.id, original.mac));
+                        }
+                        else {
+                            const partialDevice = await this.tryRollback(`find partial device ${dependentPlan.identifier}`, () => this.devicesService.findOneBy('identifier', dependentPlan.identifier, devices_wled_constants_1.DEVICES_WLED_TYPE), null);
+                            const createdDeviceId = createdDeviceIdsByPlan.get(dependentPlan.index) ?? partialDevice?.id;
+                            if (createdDeviceId) {
+                                await this.tryRollback(`remove partial device ${createdDeviceId}`, () => this.devicesService.remove(createdDeviceId));
+                                createdDeviceIdsByPlan.delete(dependentPlan.index);
+                            }
+                        }
+                        results[dependentPlan.index] = {
+                            host: dependentPlan.host,
+                            name: dependentPlan.request.name,
+                            status: 'failed',
+                            error: dependentFailure,
+                            deviceId: dependentPlan.existingDevice?.id ?? null,
+                        };
+                    }
+                    for (const staleHostOwner of retiredStaleOwnersByDependencyGroup.get(dependencyGroup)?.values() ?? []) {
+                        await this.tryRollback(`restore stale owner ${staleHostOwner.id}`, () => this.devicesService.update(staleHostOwner.id, {
+                            type: devices_wled_constants_1.DEVICES_WLED_TYPE,
+                            identifier: staleHostOwner.identifier,
+                            name: staleHostOwner.name,
+                            description: staleHostOwner.description,
+                            enabled: staleHostOwner.enabled,
+                            hostname: staleHostOwner.hostname,
+                        }));
+                        await this.tryRollback(`restore stale owner hardware identity ${staleHostOwner.id}`, () => this.hardwareIdentity.restore(staleHostOwner.id, staleHostOwner.mac));
+                        retiredDeviceIds.delete(staleHostOwner.id);
+                    }
+                    const snapshotDevices = databaseDevices.filter((device) => {
+                        const deviceHost = device.hostname;
+                        return (deviceHost !== null &&
+                            [...involvedHosts].some((involvedHost) => this.endpointsEquivalent(deviceHost, involvedHost)));
+                    });
+                    await this.tryRollback('restore dependency group registrations', () => this.restoreDependencyGroupRegistrations(involvedHosts, registrationSnapshotsByDependencyGroup.get(dependencyGroup) ?? [], snapshotDevices));
+                }
+                else {
+                    if (attemptedRegistrationCreated) {
+                        await this.tryRollback(`disconnect ${host}`, () => Promise.resolve(this.wledAdapter.disconnect(host, false)));
+                    }
+                    const partialDevice = mappedDevice ??
+                        (await this.tryRollback(`find partial device ${identifier}`, () => this.devicesService.findOneBy('identifier', identifier, devices_wled_constants_1.DEVICES_WLED_TYPE), null));
+                    if (existingDevice) {
+                        const structureSnapshot = structureSnapshotsByPlan.get(index);
+                        if (structureSnapshot) {
+                            await this.tryRollback(`restore device structure ${existingDevice.id}`, () => this.adoptionSnapshot.restore(structureSnapshot));
+                        }
+                        await this.tryRollback(`restore device ${existingDevice.id}`, () => this.devicesService.update(existingDevice.id, {
+                            type: devices_wled_constants_1.DEVICES_WLED_TYPE,
+                            identifier: existingDevice.identifier,
+                            name: existingDevice.name,
+                            description: existingDevice.description,
+                            enabled: existingDevice.enabled,
+                            hostname: existingDevice.hostname,
+                        }));
+                        await this.tryRollback(`restore hardware identity ${existingDevice.id}`, () => this.hardwareIdentity.restore(existingDevice.id, existingDevice.mac));
+                        if (existingDeviceDisconnected || attemptedRegistrationCreated) {
+                            await this.tryRollback(`reconnect device ${existingDevice.id}`, () => this.restoreDeviceConnection(existingDevice));
+                        }
+                    }
+                    else if (partialDevice) {
+                        await this.tryRollback(`remove partial device ${partialDevice.id}`, () => this.devicesService.remove(partialDevice.id));
+                    }
+                    for (const staleHostOwner of retiredStaleOwners) {
+                        await this.tryRollback(`restore stale owner ${staleHostOwner.id}`, () => this.devicesService.update(staleHostOwner.id, {
+                            type: devices_wled_constants_1.DEVICES_WLED_TYPE,
+                            identifier: staleHostOwner.identifier,
+                            name: staleHostOwner.name,
+                            description: staleHostOwner.description,
+                            enabled: staleHostOwner.enabled,
+                            hostname: staleHostOwner.hostname,
+                        }));
+                        await this.tryRollback(`restore stale owner hardware identity ${staleHostOwner.id}`, () => this.hardwareIdentity.restore(staleHostOwner.id, staleHostOwner.mac));
+                        if (disconnectedStaleOwners.some(({ id }) => id === staleHostOwner.id)) {
+                            await this.tryRollback(`reconnect stale owner ${staleHostOwner.id}`, () => this.restoreDeviceConnection(staleHostOwner));
+                        }
+                    }
+                    results[index] = {
+                        host,
+                        name: request.name,
+                        status: 'failed',
+                        error: reason,
+                        deviceId: null,
+                    };
+                }
+            }
+        }
+        for (const [dependencyGroup, deferredPruning] of deferredPruningByDependencyGroup) {
+            if (failedDependencyGroups.has(dependencyGroup) ||
+                [...dependencyGroup].some((index) => results[index]?.status === 'failed')) {
+                continue;
+            }
+            for (const { device, state } of deferredPruning) {
+                await this.deviceMapper.pruneObsoleteSegmentChannels(device, state);
+            }
+        }
+        return results.filter((result) => result !== undefined);
+    }
+    enqueueProvisioning(operation) {
+        const result = this.adoptionQueue.then(operation);
+        this.adoptionQueue = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async tryRollback(description, operation, fallback) {
+        try {
+            return await operation();
         }
         catch (error) {
-            this.logger.error(`Failed to connect to discovered device at ${device.host}`, {
+            this.logger.error(`WLED adoption rollback could not ${description}`, {
                 message: error instanceof Error ? error.message : String(error),
             });
+            return fallback;
         }
     }
-    getDiscoveredDevices() {
-        return this.mdnsDiscoverer.getDiscoveredDevices();
+    async restoreDeviceConnection(device) {
+        let state = devices_constants_1.ConnectionState.DISCONNECTED;
+        if (device.enabled && device.hostname && device.identifier) {
+            try {
+                await this.wledAdapter.connect(device.hostname, device.identifier, this.config.timeouts.connectionTimeout);
+                state = devices_constants_1.ConnectionState.CONNECTED;
+            }
+            catch (error) {
+                this.logger.warn(`Could not restore the WLED connection for ${device.identifier}`, {
+                    resource: device.id,
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        await this.deviceConnectivityService.setConnectionState(device.id, { state });
+    }
+    async restoreDependencyGroupRegistrations(involvedHosts, registrations, devices) {
+        const belongsToGroup = (host) => [...involvedHosts].some((involvedHost) => this.endpointsEquivalent(host, involvedHost));
+        for (const registration of this.wledAdapter.getRegisteredDevices().filter(({ host }) => belongsToGroup(host))) {
+            this.wledAdapter.disconnect(registration.host, false);
+        }
+        for (const registration of registrations.filter(({ connected }) => connected)) {
+            if (registration.context) {
+                this.wledAdapter.connectWithContext(registration.host, registration.identifier, registration.context);
+            }
+            else {
+                await this.wledAdapter.connect(registration.host, registration.identifier, this.config.timeouts.connectionTimeout);
+            }
+            const restored = this.wledAdapter.getDevice(registration.host);
+            if (restored) {
+                restored.enabled = registration.enabled;
+                restored.lastSeen = registration.lastSeen;
+            }
+        }
+        const uniqueDevices = new Map(devices.map((device) => [device.id, device]));
+        for (const device of uniqueDevices.values()) {
+            const connected = registrations.some((registration) => registration.connected &&
+                registration.identifier === device.identifier &&
+                device.hostname !== null &&
+                this.endpointsEquivalent(registration.host, device.hostname));
+            await this.deviceConnectivityService.setConnectionState(device.id, {
+                state: connected ? devices_constants_1.ConnectionState.CONNECTED : devices_constants_1.ConnectionState.DISCONNECTED,
+            });
+        }
     }
     async getUnadedDiscoveredDevices() {
         const discoveredDevices = this.mdnsDiscoverer.getDiscoveredDevices();
         const databaseDevices = await this.devicesService.findAll(devices_wled_constants_1.DEVICES_WLED_TYPE);
         const existingHostnames = new Set(databaseDevices.map((d) => d.hostname));
-        return discoveredDevices.filter((device) => !existingHostnames.has(device.host));
+        return discoveredDevices.filter((device) => ![...existingHostnames].some((hostname) => hostname !== null && this.endpointsEquivalent(hostname, this.discoveryEndpoint(device.host, device.port))));
+    }
+    discoveryEndpoint(host, port) {
+        const normalizedHost = this.normalizeHost(host);
+        const hasExplicitPort = /^\[[^\]]+\]:\d+$/.test(normalizedHost) || /^[^:]+:\d+$/.test(normalizedHost);
+        return port === 80 || hasExplicitPort ? normalizedHost : `${normalizedHost}:${port}`;
+    }
+    normalizeHost(host) {
+        const trimmed = host.trim();
+        if (!trimmed) {
+            throw new devices_wled_exceptions_1.WledValidationException('WLED hostname or IP address is required');
+        }
+        if (/^https?:\/\//i.test(trimmed)) {
+            let url;
+            try {
+                url = new URL(trimmed);
+            }
+            catch {
+                throw new devices_wled_exceptions_1.WledValidationException('WLED address must be a valid hostname or IP address');
+            }
+            if (url.pathname !== '/' || url.search || url.hash) {
+                throw new devices_wled_exceptions_1.WledValidationException('WLED address must not include a path, query, or fragment');
+            }
+            return url.host;
+        }
+        if (trimmed.includes('/') || trimmed.includes('?') || trimmed.includes('#')) {
+            throw new devices_wled_exceptions_1.WledValidationException('WLED address must be a hostname or IP address');
+        }
+        if (!trimmed.startsWith('[') && (trimmed.match(/:/g)?.length ?? 0) > 1) {
+            return `[${trimmed}]`;
+        }
+        return trimmed;
+    }
+    identifierFromMac(mac) {
+        const normalizedMac = this.normalizeMac(mac);
+        if (!normalizedMac) {
+            throw new devices_wled_exceptions_1.WledValidationException('WLED device did not report a valid MAC address');
+        }
+        return `wled-${normalizedMac}`;
+    }
+    findExistingDevice(devices, host, mac) {
+        if (mac) {
+            const normalizedMac = this.normalizeMac(mac);
+            if (normalizedMac) {
+                const canonicalIdentifier = `wled-${normalizedMac}`;
+                const legacyIdentifier = `wled-${normalizedMac.slice(-6)}`;
+                const legacyHostIdentifiers = this.legacyHostIdentifiers(host);
+                const identityCompatible = (device) => !this.hasContradictoryIdentity(device, normalizedMac);
+                const legacyDevices = devices.filter((device) => device.identifier === legacyIdentifier && identityCompatible(device));
+                return (devices.find((device) => device.identifier === canonicalIdentifier) ??
+                    devices.find((device) => device.mac === normalizedMac) ??
+                    devices.find((device) => this.deviceSerialMac(device) === normalizedMac) ??
+                    legacyDevices.find((device) => device.hostname !== null && this.endpointsEquivalent(device.hostname, host)) ??
+                    devices.find((device) => identityCompatible(device) &&
+                        device.identifier !== null &&
+                        legacyHostIdentifiers.has(device.identifier.toLowerCase()) &&
+                        device.hostname !== null &&
+                        this.endpointsEquivalent(device.hostname, host)) ??
+                    devices.find((device) => identityCompatible(device) &&
+                        device.identifier === null &&
+                        device.hostname !== null &&
+                        this.endpointsEquivalent(device.hostname, host)));
+            }
+        }
+        return devices.find((device) => device.hostname !== null && this.endpointsEquivalent(device.hostname, host));
+    }
+    normalizeMac(mac) {
+        if (!mac) {
+            return null;
+        }
+        const normalized = mac.replace(/[^a-fA-F0-9]/g, '').toLowerCase();
+        return normalized.length === 12 ? normalized : null;
+    }
+    deviceSerialMac(device) {
+        const serial = device.channels
+            ?.find((channel) => channel.identifier === devices_wled_constants_1.WLED_CHANNEL_IDENTIFIERS.DEVICE_INFORMATION)
+            ?.properties?.find((property) => property.identifier === devices_wled_constants_1.WLED_DEVICE_INFO_PROPERTY_IDENTIFIERS.SERIAL_NUMBER)
+            ?.value?.value;
+        if (typeof serial !== 'string') {
+            return null;
+        }
+        return this.normalizeMac(serial);
+    }
+    hasContradictoryIdentity(device, reportedMac) {
+        const knownIdentities = [this.normalizeMac(device.mac), this.deviceSerialMac(device)].filter((identity) => identity !== null);
+        return knownIdentities.some((identity) => identity !== reportedMac);
+    }
+    requiresCanonicalIdentity(device, host, mac) {
+        if (!mac) {
+            return false;
+        }
+        const canonicalIdentifier = this.identifierFromMac(mac);
+        const identifier = device.identifier?.toLowerCase() ?? null;
+        return (identifier === null ||
+            identifier === `wled-${canonicalIdentifier.slice(-6)}` ||
+            this.legacyHostIdentifiers(device.hostname ?? host).has(identifier));
+    }
+    endpointsEquivalent(first, second) {
+        return this.canonicalEndpoint(first) === this.canonicalEndpoint(second);
+    }
+    canonicalEndpoint(endpoint) {
+        const trimmed = endpoint.trim().toLowerCase();
+        const urlHost = !trimmed.startsWith('[') && (trimmed.match(/:/g)?.length ?? 0) > 1 ? `[${trimmed}]` : trimmed;
+        try {
+            const url = new URL(`http://${urlHost}`);
+            return `${url.hostname.replace(/\.$/, '')}${url.port ? `:${url.port}` : ''}`;
+        }
+        catch {
+        }
+        const bracketedIpv6 = trimmed.match(/^\[([^\]]+)](?::(\d+))?$/);
+        if (bracketedIpv6) {
+            const [, address, port] = bracketedIpv6;
+            return port && port !== '80' ? `[${address}]:${port}` : `[${address}]`;
+        }
+        if ((trimmed.match(/:/g)?.length ?? 0) > 1) {
+            return `[${trimmed}]`;
+        }
+        return trimmed.replace(/\.(?=:\d+$|$)/, '').replace(/:80$/, '');
+    }
+    legacyHostIdentifiers(endpoint) {
+        const bracketedHost = endpoint.match(/^\[([^\]]+)](?::\d+)?$/)?.[1];
+        const rawHost = bracketedHost ?? endpoint.replace(/:\d+$/, '');
+        return new Set([endpoint, rawHost].map((host) => `wled-${host.replace(/\./g, '-')}`.toLowerCase()));
+    }
+    portFromHost(host) {
+        const port = Number(host.match(/:(\d+)$/)?.[1] ?? 80);
+        return Number.isInteger(port) && port > 0 && port <= 65535 ? port : 80;
     }
     get config() {
         if (!this.pluginConfig) {
@@ -354,9 +1085,11 @@ exports.WledService = WledService = __decorate([
     __metadata("design:paramtypes", [config_service_1.ConfigService,
         wled_client_adapter_service_1.WledClientAdapterService,
         device_mapper_service_1.WledDeviceMapperService,
+        adoption_snapshot_service_1.WledAdoptionSnapshotService,
+        hardware_identity_service_1.WledHardwareIdentityService,
         devices_service_1.DevicesService,
         wled_mdns_discoverer_service_1.WledMdnsDiscovererService,
         device_connectivity_service_1.DeviceConnectivityService,
-        plugin_service_manager_service_1.PluginServiceManagerService])
+        managed_service_manager_service_1.ManagedServiceManagerService])
 ], WledService);
 //# sourceMappingURL=wled.service.js.map