@ecobridge.xyz/devicemanager 3.0.2

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

@@ -0,0 +1,101 @@
+import * as plugins from '../plugins.js';
+import type { IHomeAssistantInstanceConfig, IHomeAssistantEntity, IHomeAssistantDiscoveredInstance, THomeAssistantDomain } from '../interfaces/homeassistant.interfaces.js';
+import { HomeAssistantProtocol } from '../protocols/protocol.homeassistant.js';
+/**
+ * mDNS service type for Home Assistant discovery
+ */
+declare const HA_SERVICE_TYPE = "_home-assistant._tcp";
+/**
+ * Home Assistant Discovery
+ * Discovers HA instances via mDNS and/or manual configuration,
+ * connects to them, and enumerates all entities
+ */
+export declare class HomeAssistantDiscovery extends plugins.events.EventEmitter {
+    private bonjour;
+    private browser;
+    private discoveredInstances;
+    private connectedProtocols;
+    private entityCache;
+    private enabledDomains;
+    private isRunning;
+    constructor(options?: {
+        enabledDomains?: THomeAssistantDomain[];
+    });
+    /**
+     * Check if discovery is running
+     */
+    get running(): boolean;
+    /**
+     * Get all discovered HA instances
+     */
+    getInstances(): IHomeAssistantDiscoveredInstance[];
+    /**
+     * Get connected protocol for an instance
+     */
+    getProtocol(instanceId: string): HomeAssistantProtocol | undefined;
+    /**
+     * Get all connected protocols
+     */
+    getProtocols(): Map<string, HomeAssistantProtocol>;
+    /**
+     * Get all cached entities
+     */
+    getEntities(): IHomeAssistantEntity[];
+    /**
+     * Get entities by domain
+     */
+    getEntitiesByDomain(domain: THomeAssistantDomain): IHomeAssistantEntity[];
+    /**
+     * Get entities for a specific instance
+     */
+    getEntitiesForInstance(instanceId: string): IHomeAssistantEntity[];
+    /**
+     * Start mDNS discovery for Home Assistant instances
+     */
+    startMdnsDiscovery(): Promise<void>;
+    /**
+     * Stop mDNS discovery
+     */
+    stopMdnsDiscovery(): Promise<void>;
+    /**
+     * Add a manually configured HA instance
+     */
+    addInstance(config: IHomeAssistantInstanceConfig): Promise<HomeAssistantProtocol>;
+    /**
+     * Remove an HA instance
+     */
+    removeInstance(instanceId: string): Promise<void>;
+    /**
+     * Stop all and cleanup
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle mDNS service found
+     */
+    private handleInstanceFound;
+    /**
+     * Handle mDNS service lost
+     */
+    private handleInstanceLost;
+    /**
+     * Set up event handlers for a protocol
+     */
+    private setupProtocolHandlers;
+    /**
+     * Check if entity domain is enabled
+     */
+    private isEnabledDomain;
+    /**
+     * Generate unique instance ID
+     */
+    private generateInstanceId;
+    /**
+     * Parse TXT records from mDNS service
+     */
+    private parseTxtRecords;
+    /**
+     * Probe if a host has Home Assistant running
+     */
+    static probe(host: string, port?: number, secure?: boolean, timeout?: number): Promise<boolean>;
+}
+export { HA_SERVICE_TYPE };

package/dist_ts/discovery/discovery.classes.homeassistant.js

@@ -0,0 +1,313 @@
+import * as plugins from '../plugins.js';
+import { HomeAssistantProtocol } from '../protocols/protocol.homeassistant.js';
+/**
+ * mDNS service type for Home Assistant discovery
+ */
+const HA_SERVICE_TYPE = '_home-assistant._tcp';
+/**
+ * Default domains to discover
+ */
+const DEFAULT_DOMAINS = [
+    'light',
+    'switch',
+    'sensor',
+    'binary_sensor',
+    'climate',
+    'fan',
+    'cover',
+    'lock',
+    'camera',
+    'media_player',
+];
+/**
+ * Home Assistant Discovery
+ * Discovers HA instances via mDNS and/or manual configuration,
+ * connects to them, and enumerates all entities
+ */
+export class HomeAssistantDiscovery extends plugins.events.EventEmitter {
+    bonjour = null;
+    browser = null;
+    discoveredInstances = new Map();
+    connectedProtocols = new Map();
+    entityCache = new Map();
+    enabledDomains;
+    isRunning = false;
+    constructor(options) {
+        super();
+        this.enabledDomains = options?.enabledDomains || DEFAULT_DOMAINS;
+    }
+    /**
+     * Check if discovery is running
+     */
+    get running() {
+        return this.isRunning;
+    }
+    /**
+     * Get all discovered HA instances
+     */
+    getInstances() {
+        return Array.from(this.discoveredInstances.values());
+    }
+    /**
+     * Get connected protocol for an instance
+     */
+    getProtocol(instanceId) {
+        return this.connectedProtocols.get(instanceId);
+    }
+    /**
+     * Get all connected protocols
+     */
+    getProtocols() {
+        return this.connectedProtocols;
+    }
+    /**
+     * Get all cached entities
+     */
+    getEntities() {
+        return Array.from(this.entityCache.values());
+    }
+    /**
+     * Get entities by domain
+     */
+    getEntitiesByDomain(domain) {
+        return this.getEntities().filter((e) => e.entity_id.startsWith(`${domain}.`));
+    }
+    /**
+     * Get entities for a specific instance
+     */
+    getEntitiesForInstance(instanceId) {
+        const protocol = this.connectedProtocols.get(instanceId);
+        if (!protocol)
+            return [];
+        return Array.from(protocol.entities.values());
+    }
+    /**
+     * Start mDNS discovery for Home Assistant instances
+     */
+    async startMdnsDiscovery() {
+        if (this.isRunning) {
+            return;
+        }
+        this.bonjour = new plugins.bonjourService.Bonjour();
+        this.isRunning = true;
+        this.browser = this.bonjour.find({ type: HA_SERVICE_TYPE }, (service) => {
+            this.handleInstanceFound(service);
+        });
+        this.browser.on('down', (service) => {
+            this.handleInstanceLost(service);
+        });
+    }
+    /**
+     * Stop mDNS discovery
+     */
+    async stopMdnsDiscovery() {
+        if (!this.isRunning) {
+            return;
+        }
+        if (this.browser) {
+            this.browser.stop();
+            this.browser = null;
+        }
+        if (this.bonjour) {
+            this.bonjour.destroy();
+            this.bonjour = null;
+        }
+        this.isRunning = false;
+    }
+    /**
+     * Add a manually configured HA instance
+     */
+    async addInstance(config) {
+        const instanceId = this.generateInstanceId(config.host, config.port || 8123);
+        // Check if already connected
+        if (this.connectedProtocols.has(instanceId)) {
+            return this.connectedProtocols.get(instanceId);
+        }
+        // Create protocol and connect
+        const protocol = new HomeAssistantProtocol(config);
+        // Set up event handlers
+        this.setupProtocolHandlers(protocol, instanceId);
+        // Connect
+        await protocol.connect();
+        // Subscribe to state changes
+        await protocol.subscribeToStateChanges();
+        // Cache entities
+        const entities = await protocol.getStates();
+        for (const entity of entities) {
+            if (this.isEnabledDomain(entity.entity_id)) {
+                const cacheKey = `${instanceId}:${entity.entity_id}`;
+                this.entityCache.set(cacheKey, entity);
+                this.emit('entity:found', entity);
+            }
+        }
+        // Store protocol
+        this.connectedProtocols.set(instanceId, protocol);
+        // Also store as discovered instance
+        this.discoveredInstances.set(instanceId, {
+            id: instanceId,
+            host: config.host,
+            port: config.port || 8123,
+            base_url: `http://${config.host}:${config.port || 8123}`,
+            txtRecords: {},
+            requires_api_password: true,
+            friendlyName: config.friendlyName,
+        });
+        return protocol;
+    }
+    /**
+     * Remove an HA instance
+     */
+    async removeInstance(instanceId) {
+        const protocol = this.connectedProtocols.get(instanceId);
+        if (protocol) {
+            await protocol.disconnect();
+            this.connectedProtocols.delete(instanceId);
+        }
+        this.discoveredInstances.delete(instanceId);
+        // Remove cached entities for this instance
+        for (const key of this.entityCache.keys()) {
+            if (key.startsWith(`${instanceId}:`)) {
+                this.entityCache.delete(key);
+            }
+        }
+        this.emit('instance:lost', instanceId);
+    }
+    /**
+     * Stop all and cleanup
+     */
+    async stop() {
+        await this.stopMdnsDiscovery();
+        // Disconnect all protocols
+        for (const [instanceId, protocol] of this.connectedProtocols) {
+            await protocol.disconnect();
+        }
+        this.connectedProtocols.clear();
+        this.discoveredInstances.clear();
+        this.entityCache.clear();
+    }
+    /**
+     * Handle mDNS service found
+     */
+    handleInstanceFound(service) {
+        const addresses = service.addresses ?? [];
+        const address = addresses.find((a) => !a.includes(':')) ?? addresses[0] ?? service.host;
+        if (!address) {
+            return;
+        }
+        const instanceId = this.generateInstanceId(address, service.port);
+        const txtRecords = this.parseTxtRecords(service.txt);
+        const instance = {
+            id: instanceId,
+            host: address,
+            port: service.port,
+            base_url: txtRecords['base_url'] || `http://${address}:${service.port}`,
+            txtRecords,
+            requires_api_password: txtRecords['requires_api_password'] === 'true',
+            friendlyName: service.name,
+        };
+        // Check if this is a new instance
+        const existing = this.discoveredInstances.get(instanceId);
+        if (!existing) {
+            this.discoveredInstances.set(instanceId, instance);
+            this.emit('instance:found', instance);
+        }
+    }
+    /**
+     * Handle mDNS service lost
+     */
+    handleInstanceLost(service) {
+        const addresses = service.addresses ?? [];
+        const address = addresses.find((a) => !a.includes(':')) ?? addresses[0] ?? service.host;
+        if (!address) {
+            return;
+        }
+        const instanceId = this.generateInstanceId(address, service.port);
+        if (this.discoveredInstances.has(instanceId)) {
+            // Don't remove if we have an active connection (manually added)
+            if (!this.connectedProtocols.has(instanceId)) {
+                this.discoveredInstances.delete(instanceId);
+            }
+            this.emit('instance:lost', instanceId);
+        }
+    }
+    /**
+     * Set up event handlers for a protocol
+     */
+    setupProtocolHandlers(protocol, instanceId) {
+        protocol.on('state:changed', (event) => {
+            const cacheKey = `${instanceId}:${event.entity_id}`;
+            if (event.new_state) {
+                if (this.isEnabledDomain(event.entity_id)) {
+                    const existing = this.entityCache.has(cacheKey);
+                    this.entityCache.set(cacheKey, event.new_state);
+                    if (existing) {
+                        this.emit('entity:updated', event.new_state);
+                    }
+                    else {
+                        this.emit('entity:found', event.new_state);
+                    }
+                }
+            }
+            else {
+                // Entity removed
+                if (this.entityCache.has(cacheKey)) {
+                    this.entityCache.delete(cacheKey);
+                    this.emit('entity:removed', event.entity_id);
+                }
+            }
+        });
+        protocol.on('disconnected', () => {
+            // Clear cached entities for this instance on disconnect
+            for (const key of this.entityCache.keys()) {
+                if (key.startsWith(`${instanceId}:`)) {
+                    this.entityCache.delete(key);
+                }
+            }
+        });
+        protocol.on('error', (error) => {
+            this.emit('error', error);
+        });
+    }
+    /**
+     * Check if entity domain is enabled
+     */
+    isEnabledDomain(entityId) {
+        const domain = entityId.split('.')[0];
+        return this.enabledDomains.includes(domain);
+    }
+    /**
+     * Generate unique instance ID
+     */
+    generateInstanceId(host, port) {
+        return `ha:${host}:${port}`;
+    }
+    /**
+     * Parse TXT records from mDNS service
+     */
+    parseTxtRecords(txt) {
+        const records = {};
+        if (!txt) {
+            return records;
+        }
+        for (const [key, value] of Object.entries(txt)) {
+            if (typeof value === 'string') {
+                records[key] = value;
+            }
+            else if (Buffer.isBuffer(value)) {
+                records[key] = value.toString('utf-8');
+            }
+            else if (value !== undefined && value !== null) {
+                records[key] = String(value);
+            }
+        }
+        return records;
+    }
+    /**
+     * Probe if a host has Home Assistant running
+     */
+    static async probe(host, port = 8123, secure = false, timeout = 5000) {
+        return HomeAssistantProtocol.probe(host, port, secure, timeout);
+    }
+}
+export { HA_SERVICE_TYPE };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"discovery.classes.homeassistant.js","sourceRoot":"","sources":["../../ts/discovery/discovery.classes.homeassistant.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,90 @@
+import * as plugins from '../plugins.js';
+import type { IDiscoveredDevice, IDiscoveryOptions } from '../interfaces/index.js';
+/**
+ * Service type definitions for mDNS discovery
+ */
+declare const SERVICE_TYPES: {
+    readonly ESCL: "_uscan._tcp";
+    readonly ESCL_SECURE: "_uscans._tcp";
+    readonly SANE: "_scanner._tcp";
+    readonly IPP: "_ipp._tcp";
+    readonly IPPS: "_ipps._tcp";
+    readonly PDL: "_pdl-datastream._tcp";
+    readonly AIRPLAY: "_airplay._tcp";
+    readonly RAOP: "_raop._tcp";
+    readonly SONOS: "_sonos._tcp";
+    readonly GOOGLECAST: "_googlecast._tcp";
+    readonly SPOTIFY: "_spotify-connect._tcp";
+};
+/**
+ * mDNS/Bonjour discovery service for network devices
+ */
+export declare class MdnsDiscovery extends plugins.events.EventEmitter {
+    private bonjour;
+    private browsers;
+    private discoveredDevices;
+    private options;
+    private isRunning;
+    constructor(options?: IDiscoveryOptions);
+    /**
+     * Check if discovery is currently running
+     */
+    get running(): boolean;
+    /**
+     * Get all discovered devices
+     */
+    getDevices(): IDiscoveredDevice[];
+    /**
+     * Get discovered scanners only
+     */
+    getScanners(): IDiscoveredDevice[];
+    /**
+     * Get discovered printers only
+     */
+    getPrinters(): IDiscoveredDevice[];
+    /**
+     * Start mDNS discovery
+     */
+    start(): Promise<void>;
+    /**
+     * Stop mDNS discovery
+     */
+    stop(): Promise<void>;
+    /**
+     * Clear discovered devices
+     */
+    clear(): void;
+    /**
+     * Browse for a specific service type
+     */
+    private browseService;
+    /**
+     * Handle discovered service
+     */
+    private handleServiceFound;
+    /**
+     * Handle lost service
+     */
+    private handleServiceLost;
+    /**
+     * Parse Bonjour service into device info
+     */
+    private parseService;
+    /**
+     * Generate unique device ID
+     */
+    private generateDeviceId;
+    /**
+     * Parse TXT records from service
+     */
+    private parseTxtRecords;
+    /**
+     * Determine device type from service type
+     */
+    private getDeviceType;
+    /**
+     * Determine protocol from service type
+     */
+    private getProtocol;
+}
+export { SERVICE_TYPES };