@ecobridge.xyz/devicemanager 3.0.2

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

@@ -0,0 +1,255 @@
+import * as plugins from '../plugins.js';
+/**
+ * SSDP service types for device discovery
+ */
+export const SSDP_SERVICE_TYPES = {
+    // Root device
+    ROOT: 'upnp:rootdevice',
+    // DLNA/UPnP AV
+    MEDIA_RENDERER: 'urn:schemas-upnp-org:device:MediaRenderer:1',
+    MEDIA_SERVER: 'urn:schemas-upnp-org:device:MediaServer:1',
+    // Sonos
+    SONOS_ZONE_PLAYER: 'urn:schemas-upnp-org:device:ZonePlayer:1',
+    // Generic
+    BASIC_DEVICE: 'urn:schemas-upnp-org:device:Basic:1',
+    INTERNET_GATEWAY: 'urn:schemas-upnp-org:device:InternetGatewayDevice:1',
+};
+/**
+ * SSDP Discovery service using node-ssdp
+ */
+export class SsdpDiscovery extends plugins.events.EventEmitter {
+    client = null;
+    devices = new Map();
+    running = false;
+    searchInterval = null;
+    constructor() {
+        super();
+    }
+    /**
+     * Start SSDP discovery
+     */
+    async start(serviceTypes) {
+        if (this.running) {
+            return;
+        }
+        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);
+                }
+            }
+        }, 30000);
+        this.emit('started');
+    }
+    /**
+     * 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');
+    }
+    /**
+     * Check if discovery is running
+     */
+    get isRunning() {
+        return this.running;
+    }
+    /**
+     * Get all discovered devices
+     */
+    getDevices() {
+        return Array.from(this.devices.values());
+    }
+    /**
+     * Get devices by service type
+     */
+    getDevicesByType(serviceType) {
+        return this.getDevices().filter((d) => d.serviceType === serviceType);
+    }
+    /**
+     * Search for a specific service type
+     */
+    search(serviceType) {
+        if (this.client && this.running) {
+            this.client.search(serviceType);
+        }
+    }
+    /**
+     * 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) {
+            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);
+        }
+        catch {
+            // Keep rinfo address
+        }
+        const device = {
+            usn,
+            serviceType: st || 'unknown',
+            location,
+            address,
+            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);
+            });
+        }
+        else {
+            this.emit('device:updated', device);
+        }
+    }
+    /**
+     * Fetch and parse device description XML
+     */
+    async fetchDeviceDescription(device) {
+        try {
+            const response = await fetch(device.location, {
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!response.ok) {
+                return;
+            }
+            const xml = await response.text();
+            device.description = this.parseDeviceDescription(xml);
+        }
+        catch {
+            // Ignore fetch errors
+        }
+    }
+    /**
+     * Parse UPnP device description XML
+     */
+    parseDeviceDescription(xml) {
+        const getTagContent = (tag, source = xml) => {
+            const regex = new RegExp(`<${tag}[^>]*>([^<]*)</${tag}>`, 'i');
+            const match = source.match(regex);
+            return match?.[1]?.trim() ?? '';
+        };
+        const getTagBlock = (tag, source = xml) => {
+            const regex = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, 'i');
+            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) || [];
+        for (const serviceXml of serviceMatches) {
+            services.push({
+                serviceType: getTagContent('serviceType', serviceXml),
+                serviceId: getTagContent('serviceId', serviceXml),
+                SCPDURL: getTagContent('SCPDURL', serviceXml),
+                controlURL: getTagContent('controlURL', serviceXml),
+                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,
+                url: getTagContent('url', iconXml),
+            });
+        }
+        return {
+            deviceType: getTagContent('deviceType'),
+            friendlyName: getTagContent('friendlyName'),
+            manufacturer: getTagContent('manufacturer'),
+            manufacturerURL: getTagContent('manufacturerURL') || undefined,
+            modelDescription: getTagContent('modelDescription') || undefined,
+            modelName: getTagContent('modelName'),
+            modelNumber: getTagContent('modelNumber') || undefined,
+            modelURL: getTagContent('modelURL') || undefined,
+            serialNumber: getTagContent('serialNumber') || undefined,
+            UDN: getTagContent('UDN'),
+            services,
+            icons: icons.length > 0 ? icons : undefined,
+        };
+    }
+    /**
+     * 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}>`;
+        }
+        const soapBody = `<?xml version="1.0" encoding="utf-8"?>
+<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
+  <s:Body>
+    <u:${action} xmlns:u="${serviceType}">
+      ${argsXml}
+    </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}`);
+        }
+        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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"}

package/dist_ts/factories/index.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Device Factory Functions
+ * Create UniversalDevice instances with appropriate features
+ */
+import { UniversalDevice } from '../device/device.classes.device.js';
+import { ScanFeature } from '../features/feature.scan.js';
+import { PrintFeature } from '../features/feature.print.js';
+import { PlaybackFeature } from '../features/feature.playback.js';
+import { VolumeFeature } from '../features/feature.volume.js';
+import { PowerFeature } from '../features/feature.power.js';
+import { SnmpFeature } from '../features/feature.snmp.js';
+import type { TScannerProtocol, IRetryOptions } from '../interfaces/index.js';
+export interface IScannerDiscoveryInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    protocol: TScannerProtocol | 'ipp';
+    txtRecords: Record<string, string>;
+}
+/**
+ * Create a scanner device (UniversalDevice with ScanFeature)
+ */
+export declare function createScanner(info: IScannerDiscoveryInfo, retryOptions?: IRetryOptions): UniversalDevice;
+export interface IPrinterDiscoveryInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    txtRecords: Record<string, string>;
+}
+/**
+ * Create a printer device (UniversalDevice with PrintFeature)
+ */
+export declare function createPrinter(info: IPrinterDiscoveryInfo, retryOptions?: IRetryOptions): UniversalDevice;
+export interface ISnmpDiscoveryInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    community?: string;
+}
+/**
+ * Create an SNMP device (UniversalDevice with SnmpFeature)
+ */
+export declare function createSnmpDevice(info: ISnmpDiscoveryInfo, retryOptions?: IRetryOptions): UniversalDevice;
+export interface IUpsDiscoveryInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    protocol: 'nut' | 'snmp';
+    upsName?: string;
+    community?: string;
+}
+/**
+ * Create a UPS device (UniversalDevice with PowerFeature)
+ */
+export declare function createUpsDevice(info: IUpsDiscoveryInfo, retryOptions?: IRetryOptions): UniversalDevice;
+export interface ISpeakerDiscoveryInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    protocol: 'sonos' | 'airplay' | 'chromecast' | 'dlna';
+    roomName?: string;
+    modelName?: string;
+    features?: number;
+    deviceId?: string;
+    friendlyName?: string;
+}
+/**
+ * Create a speaker device (UniversalDevice with PlaybackFeature and VolumeFeature)
+ */
+export declare function createSpeaker(info: ISpeakerDiscoveryInfo, retryOptions?: IRetryOptions): UniversalDevice;
+export interface IDlnaRendererDiscoveryInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    controlUrl: string;
+    friendlyName: string;
+    modelName?: string;
+    manufacturer?: string;
+}
+/**
+ * Create a DLNA renderer device (UniversalDevice with PlaybackFeature)
+ */
+export declare function createDlnaRenderer(info: IDlnaRendererDiscoveryInfo, retryOptions?: IRetryOptions): UniversalDevice;
+import { SwitchFeature } from '../features/feature.switch.js';
+import { SensorFeature } from '../features/feature.sensor.js';
+import { LightFeature } from '../features/feature.light.js';
+import { CoverFeature } from '../features/feature.cover.js';
+import { LockFeature } from '../features/feature.lock.js';
+import { FanFeature } from '../features/feature.fan.js';
+import { ClimateFeature } from '../features/feature.climate.js';
+import { CameraFeature } from '../features/feature.camera.js';
+import type { TSwitchProtocol, TSensorProtocol, TLightProtocol, TCoverProtocol, TLockProtocol, TFanProtocol, TClimateProtocol, TCameraProtocol, ISwitchProtocolClient, ISensorProtocolClient, ILightProtocolClient, ICoverProtocolClient, ILockProtocolClient, IFanProtocolClient, IClimateProtocolClient, ICameraProtocolClient, ILightCapabilities, ICoverCapabilities, IFanCapabilities, IClimateCapabilities, ICameraCapabilities, TSensorDeviceClass, TSensorStateClass, TCoverDeviceClass } from '../interfaces/smarthome.interfaces.js';
+export interface ISmartSwitchDiscoveryInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    entityId: string;
+    protocol: TSwitchProtocol;
+    protocolClient: ISwitchProtocolClient;
+    deviceClass?: 'outlet' | 'switch';
+}
+export declare function createSmartSwitch(info: ISmartSwitchDiscoveryInfo, retryOptions?: IRetryOptions): UniversalDevice;
+export interface ISmartSensorDiscoveryInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    entityId: string;
+    protocol: TSensorProtocol;
+    protocolClient: ISensorProtocolClient;
+    deviceClass?: TSensorDeviceClass;
+    stateClass?: TSensorStateClass;
+    unit?: string;
+}
+export declare function createSmartSensor(info: ISmartSensorDiscoveryInfo, retryOptions?: IRetryOptions): UniversalDevice;
+export interface ISmartLightDiscoveryInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    entityId: string;
+    protocol: TLightProtocol;
+    protocolClient: ILightProtocolClient;
+    capabilities?: Partial<ILightCapabilities>;
+}
+export declare function createSmartLight(info: ISmartLightDiscoveryInfo, retryOptions?: IRetryOptions): UniversalDevice;
+export interface ISmartCoverDiscoveryInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    entityId: string;
+    protocol: TCoverProtocol;
+    protocolClient: ICoverProtocolClient;
+    deviceClass?: TCoverDeviceClass;
+    capabilities?: Partial<ICoverCapabilities>;
+}
+export declare function createSmartCover(info: ISmartCoverDiscoveryInfo, retryOptions?: IRetryOptions): UniversalDevice;
+export interface ISmartLockDiscoveryInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    entityId: string;
+    protocol: TLockProtocol;
+    protocolClient: ILockProtocolClient;
+    supportsOpen?: boolean;
+}
+export declare function createSmartLock(info: ISmartLockDiscoveryInfo, retryOptions?: IRetryOptions): UniversalDevice;
+export interface ISmartFanDiscoveryInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    entityId: string;
+    protocol: TFanProtocol;
+    protocolClient: IFanProtocolClient;
+    capabilities?: Partial<IFanCapabilities>;
+}
+export declare function createSmartFan(info: ISmartFanDiscoveryInfo, retryOptions?: IRetryOptions): UniversalDevice;
+export interface ISmartClimateDiscoveryInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    entityId: string;
+    protocol: TClimateProtocol;
+    protocolClient: IClimateProtocolClient;
+    capabilities?: Partial<IClimateCapabilities>;
+}
+export declare function createSmartClimate(info: ISmartClimateDiscoveryInfo, retryOptions?: IRetryOptions): UniversalDevice;
+export interface ISmartCameraDiscoveryInfo {
+    id: string;
+    name: string;
+    address: string;
+    port: number;
+    entityId: string;
+    protocol: TCameraProtocol;
+    protocolClient: ICameraProtocolClient;
+    capabilities?: Partial<ICameraCapabilities>;
+}
+export declare function createSmartCamera(info: ISmartCameraDiscoveryInfo, retryOptions?: IRetryOptions): UniversalDevice;
+export { UniversalDevice, ScanFeature, PrintFeature, PlaybackFeature, VolumeFeature, PowerFeature, SnmpFeature, SwitchFeature, SensorFeature, LightFeature, CoverFeature, LockFeature, FanFeature, ClimateFeature, CameraFeature, };