@ecobridge.xyz/devicemanager 3.0.2

package/ts/discovery/discovery.classes.ssdp.ts

@@ -0,0 +1,357 @@
+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 discovered device information
+ */
+export interface ISsdpDevice {
+  /** Unique service name (USN) */
+  usn: string;
+  /** Service type (ST) */
+  serviceType: string;
+  /** Location URL of device description */
+  location: string;
+  /** IP address */
+  address: string;
+  /** Port number */
+  port: number;
+  /** Device description (fetched from location) */
+  description?: ISsdpDeviceDescription;
+  /** Raw headers from SSDP response */
+  headers: Record<string, string>;
+}
+
+/**
+ * UPnP device description (from XML)
+ */
+export interface ISsdpDeviceDescription {
+  deviceType: string;
+  friendlyName: string;
+  manufacturer: string;
+  manufacturerURL?: string;
+  modelDescription?: string;
+  modelName: string;
+  modelNumber?: string;
+  modelURL?: string;
+  serialNumber?: string;
+  UDN: string;
+  services: ISsdpService[];
+  icons?: ISsdpIcon[];
+}
+
+export interface ISsdpService {
+  serviceType: string;
+  serviceId: string;
+  SCPDURL: string;
+  controlURL: string;
+  eventSubURL: string;
+}
+
+export interface ISsdpIcon {
+  mimetype: string;
+  width: number;
+  height: number;
+  depth: number;
+  url: string;
+}
+
+/**
+ * SSDP Discovery service using node-ssdp
+ */
+export class SsdpDiscovery extends plugins.events.EventEmitter {
+  private client: InstanceType<typeof plugins.nodeSsdp.Client> | null = null;
+  private devices: Map<string, ISsdpDevice> = new Map();
+  private running = false;
+  private searchInterval: NodeJS.Timeout | null = null;
+
+  constructor() {
+    super();
+  }
+
+  /**
+   * Start SSDP discovery
+   */
+  public async start(serviceTypes?: string[]): Promise<void> {
+    if (this.running) {
+      return;
+    }
+
+    this.running = true;
+    this.client = new plugins.nodeSsdp.Client();
+
+    // Handle SSDP responses
+    this.client.on('response', (headers: Record<string, string>, statusCode: number, rinfo: { address: string; port: number }) => {
+      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
+   */
+  public async stop(): Promise<void> {
+    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
+   */
+  public get isRunning(): boolean {
+    return this.running;
+  }
+
+  /**
+   * Get all discovered devices
+   */
+  public getDevices(): ISsdpDevice[] {
+    return Array.from(this.devices.values());
+  }
+
+  /**
+   * Get devices by service type
+   */
+  public getDevicesByType(serviceType: string): ISsdpDevice[] {
+    return this.getDevices().filter((d) => d.serviceType === serviceType);
+  }
+
+  /**
+   * Search for a specific service type
+   */
+  public search(serviceType: string): void {
+    if (this.client && this.running) {
+      this.client.search(serviceType);
+    }
+  }
+
+  /**
+   * Handle SSDP response
+   */
+  private handleSsdpResponse(
+    headers: Record<string, string>,
+    rinfo: { address: string; port: number }
+  ): void {
+    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: ISsdpDevice = {
+      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
+   */
+  private async fetchDeviceDescription(device: ISsdpDevice): Promise<void> {
+    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
+   */
+  private parseDeviceDescription(xml: string): ISsdpDeviceDescription {
+    const getTagContent = (tag: string, source: string = xml): string => {
+      const regex = new RegExp(`<${tag}[^>]*>([^<]*)</${tag}>`, 'i');
+      const match = source.match(regex);
+      return match?.[1]?.trim() ?? '';
+    };
+
+    const getTagBlock = (tag: string, source: string = xml): string => {
+      const regex = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, 'i');
+      const match = source.match(regex);
+      return match?.[1] ?? '';
+    };
+
+    // Parse services
+    const services: ISsdpService[] = [];
+    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: ISsdpIcon[] = [];
+    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
+   */
+  public async soapRequest(
+    controlUrl: string,
+    serviceType: string,
+    action: string,
+    args: Record<string, string | number> = {}
+  ): Promise<string> {
+    // 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();
+  }
+}