@ecobridge.xyz/devicemanager 3.0.2

package/dist_ts/discovery/discovery.classes.networkscanner.js

@@ -0,0 +1,535 @@
+import * as plugins from '../plugins.js';
+import { EsclProtocol } from '../protocols/index.js';
+import { cidrToIps, ipRangeToIps, isValidIp, } from '../helpers/helpers.iprange.js';
+/**
+ * Default ports to probe for device discovery
+ */
+const DEFAULT_PORTS = [
+    631, // IPP printers
+    80, // eSCL scanners (HTTP)
+    443, // eSCL scanners (HTTPS)
+    6566, // SANE scanners
+    9100, // JetDirect printers
+    7000, // AirPlay speakers
+    5000, // AirPlay control / RTSP
+    3689, // DAAP (iTunes/AirPlay 2)
+    1400, // Sonos speakers
+    8009, // Chromecast devices
+];
+/**
+ * Default scan options
+ */
+const DEFAULT_OPTIONS = {
+    concurrency: 50,
+    timeout: 2000,
+    ports: DEFAULT_PORTS,
+    probeEscl: true,
+    probeIpp: true,
+    probeSane: true,
+    probeAirplay: true,
+    probeSonos: true,
+    probeChromecast: true,
+};
+/**
+ * Simple concurrency limiter
+ */
+class ConcurrencyLimiter {
+    limit;
+    running = 0;
+    queue = [];
+    constructor(limit) {
+        this.limit = limit;
+    }
+    async run(fn) {
+        while (this.running >= this.limit) {
+            await new Promise((resolve) => this.queue.push(resolve));
+        }
+        this.running++;
+        try {
+            return await fn();
+        }
+        finally {
+            this.running--;
+            const next = this.queue.shift();
+            if (next)
+                next();
+        }
+    }
+}
+/**
+ * Network Scanner - scans IP ranges for scanners and printers
+ */
+export class NetworkScanner extends plugins.events.EventEmitter {
+    cancelled = false;
+    scanning = false;
+    /**
+     * Check if a scan is currently in progress
+     */
+    get isScanning() {
+        return this.scanning;
+    }
+    /**
+     * Scan a network range for devices
+     */
+    async scan(options) {
+        if (this.scanning) {
+            throw new Error('A scan is already in progress');
+        }
+        this.cancelled = false;
+        this.scanning = true;
+        const opts = { ...DEFAULT_OPTIONS, ...options };
+        const results = [];
+        try {
+            // Get list of IPs to scan
+            const ips = this.resolveIps(options);
+            if (ips.length === 0) {
+                throw new Error('No IPs to scan. Provide ipRange, or startIp and endIp.');
+            }
+            const limiter = new ConcurrencyLimiter(opts.concurrency);
+            let scanned = 0;
+            // Progress tracking
+            const emitProgress = (currentIp) => {
+                const progress = {
+                    total: ips.length,
+                    scanned,
+                    percentage: Math.round((scanned / ips.length) * 100),
+                    currentIp,
+                    devicesFound: results.reduce((sum, r) => sum + r.devices.length, 0),
+                };
+                this.emit('progress', progress);
+            };
+            emitProgress();
+            // Scan all IPs with concurrency limit
+            const scanPromises = ips.map((ip) => limiter.run(async () => {
+                if (this.cancelled)
+                    return;
+                const devices = await this.probeIp(ip, opts);
+                scanned++;
+                if (devices.length > 0) {
+                    const result = { address: ip, devices };
+                    results.push(result);
+                    this.emit('device:found', result);
+                }
+                emitProgress(ip);
+            }));
+            await Promise.all(scanPromises);
+            if (this.cancelled) {
+                this.emit('cancelled');
+            }
+            else {
+                this.emit('complete', results);
+            }
+            return results;
+        }
+        finally {
+            this.scanning = false;
+        }
+    }
+    /**
+     * Cancel an ongoing scan
+     */
+    async cancel() {
+        if (this.scanning) {
+            this.cancelled = true;
+        }
+    }
+    /**
+     * Resolve IPs from options (CIDR or start/end range)
+     */
+    resolveIps(options) {
+        if (options.ipRange) {
+            return cidrToIps(options.ipRange);
+        }
+        if (options.startIp && options.endIp) {
+            return ipRangeToIps(options.startIp, options.endIp);
+        }
+        if (options.startIp && !options.endIp) {
+            // Single IP
+            if (isValidIp(options.startIp)) {
+                return [options.startIp];
+            }
+        }
+        return [];
+    }
+    /**
+     * Probe a single IP address for devices
+     */
+    async probeIp(ip, opts) {
+        const devices = [];
+        const timeout = opts.timeout;
+        // First, do a quick port scan to see which ports are open
+        const openPorts = await this.scanPorts(ip, opts.ports, timeout / 2);
+        if (openPorts.length === 0 || this.cancelled) {
+            return devices;
+        }
+        // Probe each open port for specific protocols
+        const probePromises = [];
+        for (const port of openPorts) {
+            // IPP probe (port 631)
+            if (opts.probeIpp && port === 631) {
+                probePromises.push(this.probeIpp(ip, port, timeout).then((device) => {
+                    if (device)
+                        devices.push(device);
+                }));
+            }
+            // eSCL probe (ports 80, 443)
+            if (opts.probeEscl && (port === 80 || port === 443)) {
+                probePromises.push(this.probeEscl(ip, port, timeout).then((device) => {
+                    if (device)
+                        devices.push(device);
+                }));
+            }
+            // SANE probe (port 6566)
+            if (opts.probeSane && port === 6566) {
+                probePromises.push(this.probeSane(ip, port, timeout).then((device) => {
+                    if (device)
+                        devices.push(device);
+                }));
+            }
+            // JetDirect probe (port 9100) - just mark as raw printer
+            if (port === 9100) {
+                devices.push({
+                    type: 'printer',
+                    protocol: 'jetdirect',
+                    port: 9100,
+                    name: `Raw Printer at ${ip}`,
+                });
+            }
+            // AirPlay probe (port 7000) - try HTTP endpoints
+            if (opts.probeAirplay && port === 7000) {
+                probePromises.push(this.probeAirplay(ip, port, timeout).then((device) => {
+                    if (device)
+                        devices.push(device);
+                }));
+            }
+            // AirPlay ports 5000 (RTSP) and 3689 (DAAP) - if open, it's likely an AirPlay device
+            if (opts.probeAirplay && (port === 5000 || port === 3689)) {
+                devices.push({
+                    type: 'speaker',
+                    protocol: 'airplay',
+                    port,
+                    name: `AirPlay Device at ${ip}`,
+                });
+            }
+            // Sonos probe (port 1400)
+            if (opts.probeSonos && port === 1400) {
+                probePromises.push(this.probeSonos(ip, port, timeout).then((device) => {
+                    if (device)
+                        devices.push(device);
+                }));
+            }
+            // Chromecast probe (port 8009)
+            if (opts.probeChromecast && port === 8009) {
+                probePromises.push(this.probeChromecast(ip, port, timeout).then((device) => {
+                    if (device)
+                        devices.push(device);
+                }));
+            }
+        }
+        await Promise.all(probePromises);
+        return devices;
+    }
+    /**
+     * Quick TCP port scan
+     */
+    async scanPorts(ip, ports, timeout) {
+        const openPorts = [];
+        const scanPromises = ports.map(async (port) => {
+            const isOpen = await this.isPortOpen(ip, port, timeout);
+            if (isOpen) {
+                openPorts.push(port);
+            }
+        });
+        await Promise.all(scanPromises);
+        return openPorts;
+    }
+    /**
+     * Check if a TCP port is open
+     */
+    isPortOpen(ip, port, timeout) {
+        return new Promise((resolve) => {
+            const socket = new plugins.net.Socket();
+            const timer = setTimeout(() => {
+                socket.destroy();
+                resolve(false);
+            }, timeout);
+            socket.on('connect', () => {
+                clearTimeout(timer);
+                socket.destroy();
+                resolve(true);
+            });
+            socket.on('error', () => {
+                clearTimeout(timer);
+                socket.destroy();
+                resolve(false);
+            });
+            socket.connect(port, ip);
+        });
+    }
+    /**
+     * Probe for IPP printer using a simple HTTP check
+     * We avoid using the full ipp library for probing since it can hang and produce noisy output
+     */
+    async probeIpp(ip, port, timeout) {
+        try {
+            // Use a simple HTTP OPTIONS or POST to check if IPP endpoint exists
+            // IPP uses HTTP POST to /ipp/print or /ipp/printer
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            try {
+                const response = await fetch(`http://${ip}:${port}/ipp/print`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/ipp',
+                    },
+                    body: Buffer.from([
+                        // Minimal IPP Get-Printer-Attributes request
+                        0x01, 0x01, // IPP version 1.1
+                        0x00, 0x0b, // operation-id: Get-Printer-Attributes
+                        0x00, 0x00, 0x00, 0x01, // request-id: 1
+                        0x01, // operation-attributes-tag
+                        0x47, // charset
+                        0x00, 0x12, // name-length: 18
+                        ...Buffer.from('attributes-charset'),
+                        0x00, 0x05, // value-length: 5
+                        ...Buffer.from('utf-8'),
+                        0x48, // naturalLanguage
+                        0x00, 0x1b, // name-length: 27
+                        ...Buffer.from('attributes-natural-language'),
+                        0x00, 0x05, // value-length: 5
+                        ...Buffer.from('en-us'),
+                        0x03, // end-of-attributes-tag
+                    ]),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                // If we get a response with application/ipp content type, it's likely an IPP printer
+                const contentType = response.headers.get('content-type') || '';
+                if (response.ok || contentType.includes('application/ipp')) {
+                    return {
+                        type: 'printer',
+                        protocol: 'ipp',
+                        port,
+                        name: `IPP Printer at ${ip}`,
+                        model: undefined,
+                    };
+                }
+            }
+            catch (fetchErr) {
+                clearTimeout(timeoutId);
+                // Fetch failed or was aborted
+            }
+        }
+        catch {
+            // Not an IPP printer
+        }
+        return null;
+    }
+    /**
+     * Probe for eSCL scanner
+     */
+    async probeEscl(ip, port, timeout) {
+        try {
+            const secure = port === 443;
+            const escl = new EsclProtocol(ip, port, secure);
+            const caps = await Promise.race([
+                escl.getCapabilities(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), timeout)),
+            ]);
+            if (caps) {
+                return {
+                    type: 'scanner',
+                    protocol: 'escl',
+                    port,
+                    name: caps.makeAndModel || `eSCL Scanner at ${ip}`,
+                    model: caps.makeAndModel,
+                };
+            }
+        }
+        catch {
+            // Not an eSCL scanner
+        }
+        return null;
+    }
+    /**
+     * Probe for SANE scanner (quick check)
+     */
+    async probeSane(ip, port, timeout) {
+        // SANE probing requires full protocol implementation
+        // For now, just check if port is open and assume it's SANE
+        // A more thorough implementation would send SANE_NET_INIT
+        try {
+            const isOpen = await this.isPortOpen(ip, port, timeout);
+            if (isOpen) {
+                return {
+                    type: 'scanner',
+                    protocol: 'sane',
+                    port,
+                    name: `SANE Scanner at ${ip}`,
+                };
+            }
+        }
+        catch {
+            // Not a SANE scanner
+        }
+        return null;
+    }
+    /**
+     * Probe for AirPlay speaker on port 7000
+     * Tries HTTP endpoints to identify the device. If no HTTP response,
+     * but port 7000 is open, it's still likely an AirPlay device.
+     */
+    async probeAirplay(ip, port, timeout) {
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            // Try /server-info first (older AirPlay devices)
+            try {
+                const response = await fetch(`http://${ip}:${port}/server-info`, {
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (response.ok) {
+                    const text = await response.text();
+                    // Parse model from plist if available
+                    const modelMatch = text.match(/<key>model<\/key>\s*<string>([^<]+)<\/string>/);
+                    const model = modelMatch?.[1];
+                    return {
+                        type: 'speaker',
+                        protocol: 'airplay',
+                        port,
+                        name: model || `AirPlay Speaker at ${ip}`,
+                        model,
+                    };
+                }
+            }
+            catch {
+                clearTimeout(timeoutId);
+            }
+            // Try /info endpoint (some AirPlay 2 devices)
+            const controller2 = new AbortController();
+            const timeoutId2 = setTimeout(() => controller2.abort(), timeout);
+            try {
+                const response = await fetch(`http://${ip}:${port}/info`, {
+                    signal: controller2.signal,
+                });
+                clearTimeout(timeoutId2);
+                if (response.ok) {
+                    const text = await response.text();
+                    // Try to parse model info
+                    const modelMatch = text.match(/<key>model<\/key>\s*<string>([^<]+)<\/string>/);
+                    const nameMatch = text.match(/<key>name<\/key>\s*<string>([^<]+)<\/string>/);
+                    const model = modelMatch?.[1];
+                    const name = nameMatch?.[1];
+                    return {
+                        type: 'speaker',
+                        protocol: 'airplay',
+                        port,
+                        name: name || model || `AirPlay Speaker at ${ip}`,
+                        model,
+                    };
+                }
+            }
+            catch {
+                clearTimeout(timeoutId2);
+            }
+            // Port 7000 is open but no HTTP endpoints responded
+            // Still likely an AirPlay device (AirPlay 2 / HomePod)
+            return {
+                type: 'speaker',
+                protocol: 'airplay',
+                port,
+                name: `AirPlay Device at ${ip}`,
+            };
+        }
+        catch {
+            // Not an AirPlay speaker
+        }
+        return null;
+    }
+    /**
+     * Probe for Sonos speaker
+     */
+    async probeSonos(ip, port, timeout) {
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            try {
+                // Sonos devices respond to device description requests
+                const response = await fetch(`http://${ip}:${port}/xml/device_description.xml`, {
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (response.ok) {
+                    const text = await response.text();
+                    // Check if it's actually a Sonos device
+                    if (text.includes('Sonos') || text.includes('schemas-upnp-org')) {
+                        // Parse friendly name and model
+                        const nameMatch = text.match(/<friendlyName>([^<]+)<\/friendlyName>/);
+                        const modelMatch = text.match(/<modelName>([^<]+)<\/modelName>/);
+                        return {
+                            type: 'speaker',
+                            protocol: 'sonos',
+                            port,
+                            name: nameMatch?.[1] || `Sonos Speaker at ${ip}`,
+                            model: modelMatch?.[1],
+                        };
+                    }
+                }
+            }
+            catch {
+                clearTimeout(timeoutId);
+            }
+        }
+        catch {
+            // Not a Sonos speaker
+        }
+        return null;
+    }
+    /**
+     * Probe for Chromecast device
+     */
+    async probeChromecast(ip, port, timeout) {
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            try {
+                // Chromecast devices have an info endpoint on port 8008 (HTTP)
+                // Port 8009 is the Cast protocol port (TLS)
+                // Try fetching the eureka_info endpoint
+                const response = await fetch(`http://${ip}:8008/setup/eureka_info`, {
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (response.ok) {
+                    const data = await response.json();
+                    return {
+                        type: 'speaker',
+                        protocol: 'chromecast',
+                        port,
+                        name: data.name || `Chromecast at ${ip}`,
+                        model: data.cast_build_revision || data.model_name,
+                    };
+                }
+            }
+            catch {
+                clearTimeout(timeoutId);
+            }
+            // Alternative: just check if port 8009 is open (Cast protocol)
+            const isOpen = await this.isPortOpen(ip, port, timeout);
+            if (isOpen) {
+                return {
+                    type: 'speaker',
+                    protocol: 'chromecast',
+                    port,
+                    name: `Chromecast at ${ip}`,
+                };
+            }
+        }
+        catch {
+            // Not a Chromecast
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"discovery.classes.networkscanner.js","sourceRoot":"","sources":["../../ts/discovery/discovery.classes.networkscanner.ts"],"names":[],"mappings":"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"}

package/dist_ts/discovery/discovery.classes.ssdp.d.ts

@@ -0,0 +1,112 @@
+import * as plugins from '../plugins.js';
+/**
+ * SSDP service types for device discovery
+ */
+export declare const SSDP_SERVICE_TYPES: {
+    ROOT: string;
+    MEDIA_RENDERER: string;
+    MEDIA_SERVER: string;
+    SONOS_ZONE_PLAYER: string;
+    BASIC_DEVICE: string;
+    INTERNET_GATEWAY: string;
+};
+/**
+ * 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 declare class SsdpDiscovery extends plugins.events.EventEmitter {
+    private client;
+    private devices;
+    private running;
+    private searchInterval;
+    constructor();
+    /**
+     * Start SSDP discovery
+     */
+    start(serviceTypes?: string[]): Promise<void>;
+    /**
+     * Stop SSDP discovery
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if discovery is running
+     */
+    get isRunning(): boolean;
+    /**
+     * Get all discovered devices
+     */
+    getDevices(): ISsdpDevice[];
+    /**
+     * Get devices by service type
+     */
+    getDevicesByType(serviceType: string): ISsdpDevice[];
+    /**
+     * Search for a specific service type
+     */
+    search(serviceType: string): void;
+    /**
+     * Handle SSDP response
+     */
+    private handleSsdpResponse;
+    /**
+     * Fetch and parse device description XML
+     */
+    private fetchDeviceDescription;
+    /**
+     * Parse UPnP device description XML
+     */
+    private parseDeviceDescription;
+    /**
+     * Make a UPnP SOAP request
+     */
+    soapRequest(controlUrl: string, serviceType: string, action: string, args?: Record<string, string | number>): Promise<string>;
+}