@ecobridge.xyz/devicemanager 3.1.0 → 3.2.0

package/dist_ts/discovery/discovery.classes.ssdp.js

@@ -1,4 +1,10 @@
 import * as plugins from '../plugins.js';
+const SSDP_ADDRESS = '239.255.255.250';
+const SSDP_PORT = 1900;
+const SSDP_MULTICAST_TTL = 4;
+const SEARCH_INTERVAL_MS = 30000;
+const DESCRIPTION_TIMEOUT_MS = 5000;
+const SOAP_TIMEOUT_MS = 10000;
 /**
  * SSDP service types for device discovery
  */
@@ -14,160 +20,380 @@ export const SSDP_SERVICE_TYPES = {
     BASIC_DEVICE: 'urn:schemas-upnp-org:device:Basic:1',
     INTERNET_GATEWAY: 'urn:schemas-upnp-org:device:InternetGatewayDevice:1',
 };
+const DEFAULT_SERVICE_TYPES = [
+    SSDP_SERVICE_TYPES.ROOT,
+    SSDP_SERVICE_TYPES.MEDIA_RENDERER,
+    SSDP_SERVICE_TYPES.MEDIA_SERVER,
+    SSDP_SERVICE_TYPES.SONOS_ZONE_PLAYER,
+];
 /**
- * SSDP Discovery service using node-ssdp
+ * Focused SSDP discovery client backed by native Node.js UDP sockets.
  */
 export class SsdpDiscovery extends plugins.events.EventEmitter {
-    client = null;
+    dependencies;
     devices = new Map();
-    running = false;
+    foundUsns = new Set();
+    pendingDescriptions = new Map();
+    sockets = [];
+    lifecycleState = 'stopped';
+    lifecycleTail = Promise.resolve();
+    generation = 0;
+    startupError = null;
     searchInterval = null;
-    constructor() {
+    serviceTypes = [...DEFAULT_SERVICE_TYPES];
+    constructor(dependencies = {}) {
         super();
+        this.dependencies = {
+            createSocket: dependencies.createSocket ?? (() => plugins.dgram.createSocket({
+                type: 'udp4',
+                reuseAddr: true,
+            })),
+            networkInterfaces: dependencies.networkInterfaces ?? plugins.os.networkInterfaces,
+            fetch: dependencies.fetch ?? globalThis.fetch,
+            setInterval: dependencies.setInterval ?? globalThis.setInterval,
+            clearInterval: dependencies.clearInterval ?? globalThis.clearInterval,
+            setTimeout: dependencies.setTimeout ?? globalThis.setTimeout,
+            clearTimeout: dependencies.clearTimeout ?? globalThis.clearTimeout,
+        };
     }
     /**
-     * Start SSDP discovery
+     * Start SSDP discovery.
      */
     async start(serviceTypes) {
-        if (this.running) {
-            return;
+        const typesToSearch = [...(serviceTypes ?? DEFAULT_SERVICE_TYPES)];
+        for (const serviceType of typesToSearch) {
+            this.validateServiceType(serviceType);
         }
-        this.running = true;
-        this.client = new plugins.nodeSsdp.Client();
-        // Handle SSDP responses
-        this.client.on('response', (headers, statusCode, rinfo) => {
-            this.handleSsdpResponse(headers, rinfo);
-        });
-        // Search for devices
-        const typesToSearch = serviceTypes ?? [
-            SSDP_SERVICE_TYPES.ROOT,
-            SSDP_SERVICE_TYPES.MEDIA_RENDERER,
-            SSDP_SERVICE_TYPES.MEDIA_SERVER,
-            SSDP_SERVICE_TYPES.SONOS_ZONE_PLAYER,
-        ];
-        // Initial search
-        for (const st of typesToSearch) {
-            this.client.search(st);
-        }
-        // Periodic re-search (every 30 seconds)
-        this.searchInterval = setInterval(() => {
-            if (this.client) {
-                for (const st of typesToSearch) {
-                    this.client.search(st);
-                }
+        return this.queueLifecycle(async () => {
+            if (this.lifecycleState === 'running') {
+                return;
             }
-        }, 30000);
-        this.emit('started');
+            await this.startInternal(typesToSearch);
+        });
     }
     /**
-     * Stop SSDP discovery
+     * Stop SSDP discovery.
      */
     async stop() {
-        if (!this.running) {
-            return;
-        }
-        this.running = false;
-        if (this.searchInterval) {
-            clearInterval(this.searchInterval);
-            this.searchInterval = null;
-        }
-        if (this.client) {
-            this.client.stop();
-            this.client = null;
-        }
-        this.emit('stopped');
+        return this.queueLifecycle(async () => {
+            if (this.lifecycleState === 'stopped') {
+                return;
+            }
+            const shouldEmitStopped = this.lifecycleState === 'running';
+            await this.cleanupResources();
+            if (shouldEmitStopped) {
+                this.emit('stopped');
+            }
+        });
     }
     /**
-     * Check if discovery is running
+     * Check if discovery is running.
      */
     get isRunning() {
-        return this.running;
+        return this.lifecycleState === 'running';
     }
     /**
-     * Get all discovered devices
+     * Get all discovered devices.
      */
     getDevices() {
         return Array.from(this.devices.values());
     }
     /**
-     * Get devices by service type
+     * Get devices by service type.
      */
     getDevicesByType(serviceType) {
-        return this.getDevices().filter((d) => d.serviceType === serviceType);
+        return this.getDevices().filter((device) => device.serviceType === serviceType);
     }
     /**
-     * Search for a specific service type
+     * Search for a specific service type.
      */
     search(serviceType) {
-        if (this.client && this.running) {
-            this.client.search(serviceType);
+        this.validateServiceType(serviceType);
+        if (this.lifecycleState !== 'running') {
+            return;
         }
+        const activeGeneration = this.generation;
+        void this.sendSearches([serviceType], activeGeneration).catch((error) => {
+            this.handleRuntimeError(this.toError(error), activeGeneration);
+        });
     }
-    /**
-     * Handle SSDP response
-     */
-    handleSsdpResponse(headers, rinfo) {
-        const usn = headers['USN'] || headers['usn'];
-        const location = headers['LOCATION'] || headers['location'];
-        const st = headers['ST'] || headers['st'];
-        if (!usn || !location) {
+    queueLifecycle(operation) {
+        const result = this.lifecycleTail.then(operation);
+        this.lifecycleTail = result.catch(() => { });
+        return result;
+    }
+    async startInternal(typesToSearch) {
+        this.lifecycleState = 'starting';
+        this.startupError = null;
+        const activeGeneration = ++this.generation;
+        try {
+            const addresses = this.getInterfaceAddresses();
+            if (addresses.length === 0) {
+                throw new Error('No non-internal IPv4 interfaces available for SSDP discovery.');
+            }
+            for (const address of addresses) {
+                const resource = this.createSocketResource(address, activeGeneration);
+                this.sockets.push(resource);
+                await this.bindSocket(resource);
+            }
+            await this.sendSearches(typesToSearch, activeGeneration);
+            if (this.startupError) {
+                throw this.startupError;
+            }
+            this.serviceTypes = typesToSearch;
+            this.lifecycleState = 'running';
+            this.searchInterval = this.dependencies.setInterval(() => {
+                const intervalGeneration = this.generation;
+                void this.sendSearches(this.serviceTypes, intervalGeneration).catch((error) => {
+                    this.handleRuntimeError(this.toError(error), intervalGeneration);
+                });
+            }, SEARCH_INTERVAL_MS);
+            this.unrefTimer(this.searchInterval);
+            this.emit('started');
+        }
+        catch (error) {
+            await this.cleanupResources();
+            throw error;
+        }
+    }
+    getInterfaceAddresses() {
+        const addresses = new Set();
+        const interfaces = this.dependencies.networkInterfaces();
+        for (const [, interfaceInfos] of Object.entries(interfaces).sort(([a], [b]) => a.localeCompare(b))) {
+            for (const interfaceInfo of interfaceInfos ?? []) {
+                if (!interfaceInfo.internal && interfaceInfo.family === 'IPv4') {
+                    addresses.add(interfaceInfo.address);
+                }
+            }
+        }
+        return Array.from(addresses).sort((a, b) => a.localeCompare(b));
+    }
+    createSocketResource(address, activeGeneration) {
+        const socket = this.dependencies.createSocket();
+        const onMessage = (message, rinfo) => {
+            if (this.lifecycleState === 'running' && this.generation === activeGeneration) {
+                this.handleSsdpMessage(message, rinfo, activeGeneration);
+            }
+        };
+        const onError = (error) => {
+            if (this.lifecycleState === 'starting' && this.generation === activeGeneration) {
+                this.startupError ??= error;
+                return;
+            }
+            this.handleRuntimeError(error, activeGeneration);
+        };
+        socket.on('message', onMessage);
+        socket.on('error', onError);
+        return { address, socket, onMessage, onError };
+    }
+    async bindSocket(resource) {
+        const { address, socket } = resource;
+        await new Promise((resolve, reject) => {
+            const cleanupBindListeners = () => {
+                socket.off('listening', onListening);
+                socket.off('error', onBindError);
+            };
+            const onListening = () => {
+                cleanupBindListeners();
+                resolve();
+            };
+            const onBindError = (error) => {
+                cleanupBindListeners();
+                reject(error);
+            };
+            socket.once('listening', onListening);
+            socket.once('error', onBindError);
+            try {
+                socket.bind({ port: 0, address, exclusive: true });
+            }
+            catch (error) {
+                cleanupBindListeners();
+                reject(error);
+            }
+        });
+        if (this.startupError) {
+            throw this.startupError;
+        }
+        socket.setMulticastInterface(address);
+        socket.setMulticastTTL(SSDP_MULTICAST_TTL);
+        // M-SEARCH responses are unicast to this bound socket, so membership is not needed.
+        socket.unref();
+    }
+    async sendSearches(serviceTypes, activeGeneration) {
+        if (this.generation !== activeGeneration ||
+            (this.lifecycleState !== 'starting' && this.lifecycleState !== 'running')) {
             return;
         }
-        // Parse location URL
-        let address = rinfo.address;
-        let port = 80;
-        try {
-            const url = new URL(location);
-            address = url.hostname;
-            port = parseInt(url.port) || (url.protocol === 'https:' ? 443 : 80);
+        const sends = [];
+        for (const serviceType of serviceTypes) {
+            const packet = this.createSearchPacket(serviceType);
+            for (const resource of this.sockets) {
+                sends.push(this.sendPacket(resource.socket, packet));
+            }
         }
-        catch {
-            // Keep rinfo address
+        const results = await Promise.allSettled(sends);
+        const failure = results.find((result) => result.status === 'rejected');
+        if (failure) {
+            throw failure.reason;
+        }
+    }
+    createSearchPacket(serviceType) {
+        return Buffer.from([
+            'M-SEARCH * HTTP/1.1',
+            `HOST: ${SSDP_ADDRESS}:${SSDP_PORT}`,
+            'MAN: "ssdp:discover"',
+            'MX: 3',
+            `ST: ${serviceType}`,
+            '',
+            '',
+        ].join('\r\n'), 'ascii');
+    }
+    async sendPacket(socket, packet) {
+        await new Promise((resolve, reject) => {
+            try {
+                socket.send(packet, SSDP_PORT, SSDP_ADDRESS, (error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    handleRuntimeError(error, activeGeneration) {
+        if (this.lifecycleState !== 'running' || this.generation !== activeGeneration) {
+            return;
+        }
+        void this.stop();
+        if (this.listenerCount('error') > 0) {
+            this.emit('error', error);
+        }
+    }
+    handleSsdpMessage(message, rinfo, activeGeneration) {
+        const response = this.parseSsdpResponse(message);
+        if (!response || response.statusCode !== 200) {
+            return;
+        }
+        this.handleSsdpResponse(response.headers, rinfo, activeGeneration);
+    }
+    parseSsdpResponse(message) {
+        const lines = message.toString('utf8').split(/\r?\n/);
+        const statusLine = lines.shift()?.trim() ?? '';
+        const statusMatch = statusLine.match(/^HTTP\/\d\.\d\s+(\d{3})(?:\s|$)/i);
+        if (!statusMatch) {
+            return null;
+        }
+        const headers = {};
+        for (const line of lines) {
+            if (line.trim() === '') {
+                break;
+            }
+            const separatorIndex = line.indexOf(':');
+            if (separatorIndex <= 0) {
+                continue;
+            }
+            const name = line.slice(0, separatorIndex).trim().toUpperCase();
+            if (name) {
+                headers[name] = line.slice(separatorIndex + 1).trim();
+            }
+        }
+        return {
+            statusCode: Number.parseInt(statusMatch[1], 10),
+            headers,
+        };
+    }
+    handleSsdpResponse(headers, rinfo, activeGeneration) {
+        const usn = headers.USN;
+        const location = headers.LOCATION;
+        if (!usn || !location) {
+            return;
+        }
+        const locationInfo = this.parseLocation(location, rinfo.address);
+        const existing = this.devices.get(usn);
+        if (existing) {
+            existing.serviceType = headers.ST || 'unknown';
+            existing.location = location;
+            existing.address = locationInfo.address;
+            existing.port = locationInfo.port;
+            existing.headers = { ...headers };
+            if (this.foundUsns.has(usn)) {
+                this.emit('device:updated', existing);
+            }
+            return;
         }
         const device = {
             usn,
-            serviceType: st || 'unknown',
+            serviceType: headers.ST || 'unknown',
             location,
-            address,
-            port,
+            address: locationInfo.address,
+            port: locationInfo.port,
             headers: { ...headers },
         };
-        const isNew = !this.devices.has(usn);
         this.devices.set(usn, device);
-        if (isNew) {
-            // Fetch device description
-            this.fetchDeviceDescription(device).then(() => {
-                this.emit('device:found', device);
-            }).catch(() => {
-                // Still emit even without description
-                this.emit('device:found', device);
-            });
+        this.startDescriptionFetch(device, activeGeneration);
+    }
+    parseLocation(location, fallbackAddress) {
+        try {
+            const url = new URL(location);
+            return {
+                address: url.hostname,
+                port: Number.parseInt(url.port, 10) || (url.protocol === 'https:' ? 443 : 80),
+            };
         }
-        else {
-            this.emit('device:updated', device);
+        catch {
+            return { address: fallbackAddress, port: 80 };
         }
     }
-    /**
-     * Fetch and parse device description XML
-     */
-    async fetchDeviceDescription(device) {
+    startDescriptionFetch(device, activeGeneration) {
+        const abortController = new AbortController();
+        const timeout = this.dependencies.setTimeout(() => {
+            abortController.abort();
+        }, DESCRIPTION_TIMEOUT_MS);
+        this.unrefTimer(timeout);
+        const pending = {
+            device,
+            abortController,
+            timeout,
+            promise: Promise.resolve(),
+        };
+        pending.promise = (async () => {
+            await this.fetchDeviceDescription(device, abortController.signal);
+            if (this.lifecycleState === 'running' &&
+                this.generation === activeGeneration &&
+                this.devices.get(device.usn) === device &&
+                !this.foundUsns.has(device.usn)) {
+                this.foundUsns.add(device.usn);
+                this.emit('device:found', device);
+            }
+        })().finally(() => {
+            this.dependencies.clearTimeout(timeout);
+            if (this.pendingDescriptions.get(device.usn) === pending) {
+                this.pendingDescriptions.delete(device.usn);
+            }
+        });
+        this.pendingDescriptions.set(device.usn, pending);
+    }
+    async fetchDeviceDescription(device, signal) {
         try {
-            const response = await fetch(device.location, {
-                signal: AbortSignal.timeout(5000),
-            });
+            const response = await this.dependencies.fetch(device.location, { signal });
             if (!response.ok) {
+                await this.cancelResponseBody(response);
                 return;
             }
             const xml = await response.text();
-            device.description = this.parseDeviceDescription(xml);
+            if (!signal.aborted) {
+                device.description = this.parseDeviceDescription(xml);
+            }
         }
         catch {
-            // Ignore fetch errors
+            // Devices without a reachable description are still valid SSDP results.
         }
     }
-    /**
-     * Parse UPnP device description XML
-     */
     parseDeviceDescription(xml) {
         const getTagContent = (tag, source = xml) => {
             const regex = new RegExp(`<${tag}[^>]*>([^<]*)</${tag}>`, 'i');
@@ -179,7 +405,6 @@ export class SsdpDiscovery extends plugins.events.EventEmitter {
             const match = source.match(regex);
             return match?.[1] ?? '';
         };
-        // Parse services
         const services = [];
         const serviceListBlock = getTagBlock('serviceList');
         const serviceMatches = serviceListBlock.match(/<service>[\s\S]*?<\/service>/gi) || [];
@@ -192,16 +417,15 @@ export class SsdpDiscovery extends plugins.events.EventEmitter {
                 eventSubURL: getTagContent('eventSubURL', serviceXml),
             });
         }
-        // Parse icons
         const icons = [];
         const iconListBlock = getTagBlock('iconList');
         const iconMatches = iconListBlock.match(/<icon>[\s\S]*?<\/icon>/gi) || [];
         for (const iconXml of iconMatches) {
             icons.push({
                 mimetype: getTagContent('mimetype', iconXml),
-                width: parseInt(getTagContent('width', iconXml)) || 0,
-                height: parseInt(getTagContent('height', iconXml)) || 0,
-                depth: parseInt(getTagContent('depth', iconXml)) || 0,
+                width: Number.parseInt(getTagContent('width', iconXml), 10) || 0,
+                height: Number.parseInt(getTagContent('height', iconXml), 10) || 0,
+                depth: Number.parseInt(getTagContent('depth', iconXml), 10) || 0,
                 url: getTagContent('url', iconXml),
             });
         }
@@ -220,11 +444,66 @@ export class SsdpDiscovery extends plugins.events.EventEmitter {
             icons: icons.length > 0 ? icons : undefined,
         };
     }
+    async cleanupResources() {
+        this.lifecycleState = 'stopping';
+        ++this.generation;
+        if (this.searchInterval) {
+            this.dependencies.clearInterval(this.searchInterval);
+            this.searchInterval = null;
+        }
+        const pendingDescriptions = Array.from(this.pendingDescriptions.values());
+        for (const pending of pendingDescriptions) {
+            this.dependencies.clearTimeout(pending.timeout);
+            pending.abortController.abort();
+        }
+        await Promise.allSettled(pendingDescriptions.map((pending) => pending.promise));
+        for (const pending of pendingDescriptions) {
+            if (!this.foundUsns.has(pending.device.usn) && this.devices.get(pending.device.usn) === pending.device) {
+                this.devices.delete(pending.device.usn);
+            }
+        }
+        this.pendingDescriptions.clear();
+        const sockets = this.sockets;
+        this.sockets = [];
+        await Promise.all(sockets.map(async (resource) => {
+            resource.socket.off('message', resource.onMessage);
+            resource.socket.off('error', resource.onError);
+            await new Promise((resolve) => {
+                try {
+                    resource.socket.close(resolve);
+                }
+                catch {
+                    resolve();
+                }
+            });
+        }));
+        this.startupError = null;
+        this.lifecycleState = 'stopped';
+    }
+    validateServiceType(serviceType) {
+        if (!serviceType || /[\r\n]/.test(serviceType)) {
+            throw new Error('SSDP service type must be non-empty and cannot contain line breaks.');
+        }
+    }
+    unrefTimer(timer) {
+        const unref = timer.unref;
+        unref?.call(timer);
+    }
+    toError(error) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    async cancelResponseBody(response) {
+        try {
+            await response.body?.cancel();
+        }
+        catch {
+            // The fetch timeout/abort remains the final cleanup path for a failed body.
+        }
+    }
     /**
-     * Make a UPnP SOAP request
+     * Make a UPnP SOAP request.
      */
     async soapRequest(controlUrl, serviceType, action, args = {}) {
-        // Build SOAP body
         let argsXml = '';
         for (const [key, value] of Object.entries(args)) {
             argsXml += `<${key}>${value}</${key}>`;
@@ -237,19 +516,30 @@ export class SsdpDiscovery extends plugins.events.EventEmitter {
     </u:${action}>
   </s:Body>
 </s:Envelope>`;
-        const response = await fetch(controlUrl, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'text/xml; charset=utf-8',
-                'SOAPACTION': `"${serviceType}#${action}"`,
-            },
-            body: soapBody,
-            signal: AbortSignal.timeout(10000),
-        });
-        if (!response.ok) {
-            throw new Error(`SOAP request failed: ${response.status}`);
+        const abortController = new AbortController();
+        const timeout = this.dependencies.setTimeout(() => {
+            abortController.abort();
+        }, SOAP_TIMEOUT_MS);
+        this.unrefTimer(timeout);
+        try {
+            const response = await this.dependencies.fetch(controlUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'text/xml; charset=utf-8',
+                    'SOAPACTION': `"${serviceType}#${action}"`,
+                },
+                body: soapBody,
+                signal: abortController.signal,
+            });
+            if (!response.ok) {
+                await this.cancelResponseBody(response);
+                throw new Error(`SOAP request failed: ${response.status}`);
+            }
+            return await response.text();
+        }
+        finally {
+            this.dependencies.clearTimeout(timeout);
         }
-        return response.text();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"discovery.classes.ssdp.js","sourceRoot":"","sources":["../../ts/discovery/discovery.classes.ssdp.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"discovery.classes.ssdp.js","sourceRoot":"","sources":["../../ts/discovery/discovery.classes.ssdp.ts"],"names":[],"mappings":"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"}