matterbridge-valetudo 1.0.2

package/dist/valetudo-client.js

@@ -0,0 +1,391 @@
+import * as http from 'node:http';
+export class ValetudoClient {
+    baseUrl;
+    log;
+    constructor(ip, log) {
+        this.baseUrl = `http://${ip}`;
+        this.log = log;
+    }
+    async getInfo() {
+        try {
+            const url = `${this.baseUrl}/api/v2/valetudo`;
+            this.log.debug(`Fetching Valetudo info from: ${url}`);
+            const data = await this.httpGet(url);
+            this.log.debug(`Valetudo info received: ${JSON.stringify(data)}`);
+            return data;
+        }
+        catch (error) {
+            this.log.error(`Error fetching Valetudo info: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    async getRobotInfo() {
+        try {
+            const data = await this.httpGet(`${this.baseUrl}/api/v2/robot`);
+            return data;
+        }
+        catch (error) {
+            this.log.error(`Error fetching robot info: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    async getCapabilities() {
+        try {
+            const data = await this.httpGet(`${this.baseUrl}/api/v2/robot/capabilities`);
+            return data;
+        }
+        catch (error) {
+            this.log.error(`Error fetching capabilities: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    async getStateAttributes() {
+        try {
+            const data = await this.httpGet(`${this.baseUrl}/api/v2/robot/state/attributes`);
+            return data;
+        }
+        catch (error) {
+            this.log.error(`Error fetching state attributes: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    async executeBasicControl(action) {
+        try {
+            const result = await this.httpPut(`${this.baseUrl}/api/v2/robot/capabilities/BasicControlCapability`, {
+                action,
+            });
+            return result !== null;
+        }
+        catch (error) {
+            this.log.error(`Error executing basic control (${action}): ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    async start() {
+        return this.executeBasicControl('start');
+    }
+    async stop() {
+        return this.executeBasicControl('stop');
+    }
+    async pause() {
+        return this.executeBasicControl('pause');
+    }
+    async home() {
+        return this.executeBasicControl('home');
+    }
+    async startCleaning() {
+        return this.start();
+    }
+    async stopCleaning() {
+        return this.stop();
+    }
+    async pauseCleaning() {
+        return this.pause();
+    }
+    async returnHome() {
+        return this.home();
+    }
+    async getFanSpeedPresets() {
+        try {
+            const data = await this.httpGet(`${this.baseUrl}/api/v2/robot/capabilities/FanSpeedControlCapability/presets`);
+            return data;
+        }
+        catch (error) {
+            this.log.error(`Error fetching fan speed presets: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    async setFanSpeed(preset) {
+        try {
+            const result = await this.httpPut(`${this.baseUrl}/api/v2/robot/capabilities/FanSpeedControlCapability/preset`, {
+                name: preset,
+            });
+            return result !== null;
+        }
+        catch (error) {
+            this.log.error(`Error setting fan speed: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    async getWaterUsagePresets() {
+        try {
+            const data = await this.httpGet(`${this.baseUrl}/api/v2/robot/capabilities/WaterUsageControlCapability/presets`);
+            return data;
+        }
+        catch (error) {
+            this.log.error(`Error fetching water usage presets: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    async setWaterUsage(preset) {
+        try {
+            const result = await this.httpPut(`${this.baseUrl}/api/v2/robot/capabilities/WaterUsageControlCapability/preset`, {
+                name: preset,
+            });
+            return result !== null;
+        }
+        catch (error) {
+            this.log.error(`Error setting water usage: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    async getOperationModePresets() {
+        try {
+            const data = await this.httpGet(`${this.baseUrl}/api/v2/robot/capabilities/OperationModeControlCapability/presets`);
+            return data;
+        }
+        catch (error) {
+            this.log.error(`Error fetching operation mode presets: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    async setOperationMode(preset) {
+        try {
+            const result = await this.httpPut(`${this.baseUrl}/api/v2/robot/capabilities/OperationModeControlCapability/preset`, {
+                name: preset,
+            });
+            return result !== null;
+        }
+        catch (error) {
+            this.log.error(`Error setting operation mode: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    async getMapSegments() {
+        try {
+            const data = await this.httpGet(`${this.baseUrl}/api/v2/robot/capabilities/MapSegmentationCapability`);
+            return data;
+        }
+        catch (error) {
+            this.log.error(`Error fetching map segments: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    async getMapSegmentationProperties() {
+        try {
+            const data = await this.httpGet(`${this.baseUrl}/api/v2/robot/capabilities/MapSegmentationCapability/properties`);
+            return data;
+        }
+        catch (error) {
+            this.log.error(`Error fetching map segmentation properties: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    async cleanSegments(segmentIds, iterations = 1, customOrder = false) {
+        try {
+            const payload = {
+                action: 'start_segment_action',
+                segment_ids: segmentIds,
+                iterations,
+                customOrder,
+            };
+            this.log.debug(`cleanSegments: ${JSON.stringify(payload)}`);
+            const result = await this.httpPut(`${this.baseUrl}/api/v2/robot/capabilities/MapSegmentationCapability`, payload);
+            return result !== null;
+        }
+        catch (error) {
+            this.log.error(`Error cleaning segments: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    async getMapDataWithTimeout(timeoutMs) {
+        try {
+            const data = await this.httpGet(`${this.baseUrl}/api/v2/robot/state/map`, timeoutMs);
+            return data;
+        }
+        catch (error) {
+            this.log.error(`Error fetching map data: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    async getMapPositionData() {
+        try {
+            const data = await this.httpGet(`${this.baseUrl}/api/v2/robot/state/map`);
+            const mapData = data;
+            return {
+                entities: mapData.entities,
+                metaData: mapData.metaData,
+            };
+        }
+        catch (error) {
+            this.log.error(`Error fetching position data: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    findSegmentAtPositionCached(cachedLayers, x, y) {
+        const segments = cachedLayers.layers.filter((layer) => layer.type === 'segment');
+        const matchingSegments = [];
+        for (const segment of segments) {
+            const dims = segment.dimensions;
+            const inBounds = x >= dims.x.min && x <= dims.x.max && y >= dims.y.min && y <= dims.y.max;
+            if (inBounds) {
+                const distanceFromMid = Math.sqrt(Math.pow(x - dims.x.mid, 2) + Math.pow(y - dims.y.mid, 2));
+                matchingSegments.push({ segment, distance: distanceFromMid });
+            }
+        }
+        if (matchingSegments.length === 0) {
+            return null;
+        }
+        if (matchingSegments.length === 1) {
+            return matchingSegments[0].segment;
+        }
+        matchingSegments.sort((a, b) => a.distance - b.distance);
+        const closest = matchingSegments[0];
+        this.log.debug(`Multiple segments at (${x}, ${y}) - selected "${closest.segment.metaData.segmentId}" (closest midpoint, distance: ${closest.distance.toFixed(1)})`);
+        return closest.segment;
+    }
+    createCachedLayers(mapData) {
+        return {
+            layers: mapData.layers,
+            size: mapData.size,
+            pixelSize: mapData.pixelSize,
+            timestamp: Date.now(),
+            version: mapData.metaData.version,
+        };
+    }
+    async locate() {
+        try {
+            const result = await this.httpPut(`${this.baseUrl}/api/v2/robot/capabilities/LocateCapability`, {
+                action: 'locate',
+            });
+            return result !== null;
+        }
+        catch (error) {
+            this.log.error(`Error locating robot: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    async getConsumables() {
+        try {
+            const data = await this.httpGet(`${this.baseUrl}/api/v2/robot/capabilities/ConsumableMonitoringCapability`);
+            return data;
+        }
+        catch (error) {
+            this.log.error(`Error fetching consumables: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    async httpGet(url, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const timeout = timeoutMs ?? 10000;
+            let timeoutId = null;
+            const req = http
+                .get(url, { headers: { accept: 'application/json' } }, (res) => {
+                let data = '';
+                if (res.statusCode !== 200) {
+                    const error = new Error(`HTTP GET failed with status code: ${res.statusCode} for ${url}`);
+                    this.log.error(error.message);
+                    reject(error);
+                    return;
+                }
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('end', () => {
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                    try {
+                        const parsed = JSON.parse(data);
+                        resolve(parsed);
+                    }
+                    catch (error) {
+                        const parseError = new Error(`Failed to parse JSON response: ${error instanceof Error ? error.message : String(error)}`);
+                        this.log.error(parseError.message);
+                        reject(parseError);
+                    }
+                });
+            })
+                .on('error', (error) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                this.log.error(`HTTP GET error: ${error.message}`);
+                reject(error);
+            });
+            timeoutId = setTimeout(() => {
+                req.destroy();
+                const timeoutError = new Error(`HTTP GET request timed out after ${timeout}ms for ${url}`);
+                this.log.error(timeoutError.message);
+                reject(timeoutError);
+            }, timeout);
+        });
+    }
+    async httpPut(url, body) {
+        return new Promise((resolve, reject) => {
+            const timeout = 10000;
+            let timeoutId = null;
+            const bodyString = JSON.stringify(body);
+            const urlObj = new URL(url);
+            const options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port || 80,
+                path: urlObj.pathname,
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(bodyString),
+                    'Accept': 'application/json',
+                },
+            };
+            const req = http.request(options, (res) => {
+                let data = '';
+                if (res.statusCode !== 200) {
+                    const error = new Error(`HTTP PUT failed with status code: ${res.statusCode} for ${url}`);
+                    this.log.error(error.message);
+                    reject(error);
+                    return;
+                }
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('end', () => {
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                    try {
+                        if (data) {
+                            try {
+                                const parsed = JSON.parse(data);
+                                resolve(parsed);
+                            }
+                            catch {
+                                if (data.trim() === 'OK' || data.trim() === 'ok') {
+                                    resolve({ success: true });
+                                }
+                                else {
+                                    const parseError = new Error(`Failed to parse JSON response: ${data}`);
+                                    this.log.error(parseError.message);
+                                    reject(parseError);
+                                }
+                            }
+                        }
+                        else {
+                            resolve({});
+                        }
+                    }
+                    catch (error) {
+                        const handleError = new Error(`Failed to handle response: ${error instanceof Error ? error.message : String(error)}`);
+                        this.log.error(handleError.message);
+                        reject(handleError);
+                    }
+                });
+            });
+            req.on('error', (error) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                this.log.error(`HTTP PUT error: ${error.message}`);
+                reject(error);
+            });
+            timeoutId = setTimeout(() => {
+                req.destroy();
+                const timeoutError = new Error(`HTTP PUT request timed out after ${timeout}ms for ${url}`);
+                this.log.error(timeoutError.message);
+                reject(timeoutError);
+            }, timeout);
+            req.write(bodyString);
+            req.end();
+        });
+    }
+    async testConnection() {
+        const info = await this.getInfo();
+        return info !== null;
+    }
+}

package/dist/valetudo-discovery.js

@@ -0,0 +1,164 @@
+import multicastdns from 'multicast-dns';
+export class ValetudoDiscovery {
+    mdns = null;
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    async discover(timeoutMs = 5000) {
+        return new Promise((resolve, reject) => {
+            const discovered = new Map();
+            const instanceNames = new Set();
+            const allRecords = {
+                srv: [],
+                a: [],
+                txt: [],
+            };
+            let queryTimeout;
+            try {
+                this.mdns = multicastdns();
+                this.mdns.on('response', (response) => {
+                    try {
+                        const httpPtrRecords = response.answers.filter((answer) => answer.type === 'PTR' && answer.name === '_http._tcp.local');
+                        for (const ptrRecord of httpPtrRecords) {
+                            if ('data' in ptrRecord && typeof ptrRecord.data === 'string') {
+                                const instanceName = ptrRecord.data;
+                                if (!instanceNames.has(instanceName)) {
+                                    instanceNames.add(instanceName);
+                                    this.log.debug(`Found HTTP service: ${instanceName}`);
+                                    if (this.mdns) {
+                                        this.mdns.query({
+                                            questions: [
+                                                { name: instanceName, type: 'SRV' },
+                                                { name: instanceName, type: 'TXT' },
+                                                { name: instanceName, type: 'A' },
+                                            ],
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                        const srvRecords = response.answers.filter((answer) => answer.type === 'SRV');
+                        if (srvRecords.length > 0) {
+                            for (const srvRecord of srvRecords) {
+                                if ('data' in srvRecord && srvRecord.data) {
+                                    const srvData = srvRecord.data;
+                                    if (srvData.target && this.mdns) {
+                                        this.mdns.query({
+                                            questions: [{ name: srvData.target, type: 'A' }],
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                        allRecords.srv.push(...srvRecords);
+                        const aRecords = response.answers.filter((answer) => answer.type === 'A');
+                        allRecords.a.push(...aRecords);
+                        const txtRecords = response.answers.filter((answer) => answer.type === 'TXT');
+                        allRecords.txt.push(...txtRecords);
+                    }
+                    catch (error) {
+                        this.log.error(`Error processing mDNS response: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                });
+                this.mdns.on('error', (error) => {
+                    this.log.error(`mDNS error: ${error.message}`);
+                });
+                this.log.info('Querying for _http._tcp.local services...');
+                this.mdns.query({
+                    questions: [
+                        {
+                            name: '_http._tcp.local',
+                            type: 'PTR',
+                        },
+                    ],
+                });
+                this.log.info(`mDNS query sent, waiting ${timeoutMs}ms for responses...`);
+                queryTimeout = setTimeout(() => {
+                    this.log.debug(`Discovery timeout reached, processing ${instanceNames.size} collected service(s)`);
+                    for (const instanceName of instanceNames) {
+                        try {
+                            const srvRecord = allRecords.srv.find((r) => r.name === instanceName);
+                            if (!srvRecord) {
+                                this.log.debug(`No SRV record found for ${instanceName}`);
+                                continue;
+                            }
+                            const srvData = srvRecord.data;
+                            const port = srvData?.port || 80;
+                            const targetHostname = srvData?.target || '';
+                            let ip = '';
+                            const aRecord = allRecords.a.find((r) => r.name === targetHostname);
+                            if (aRecord && 'data' in aRecord) {
+                                ip = aRecord.data;
+                            }
+                            if (!ip) {
+                                this.log.debug(`No IP found for ${instanceName}`);
+                                continue;
+                            }
+                            const txtRecord = allRecords.txt.find((r) => r.name === instanceName);
+                            const txt = {};
+                            if (txtRecord && 'data' in txtRecord) {
+                                const txtData = txtRecord.data;
+                                if (Array.isArray(txtData)) {
+                                    for (const entry of txtData) {
+                                        if (Buffer.isBuffer(entry)) {
+                                            const str = entry.toString('utf8');
+                                            const [key, ...valueParts] = str.split('=');
+                                            if (key) {
+                                                txt[key] = valueParts.join('=') || '';
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            if (!txt.id) {
+                                this.log.debug(`Skipping ${instanceName} - no Valetudo 'id' field`);
+                                continue;
+                            }
+                            const hasValetudoFields = txt.model || txt.manufacturer || txt.version;
+                            if (!hasValetudoFields) {
+                                this.log.debug(`Skipping ${instanceName} - missing Valetudo metadata`);
+                                continue;
+                            }
+                            if (!discovered.has(ip)) {
+                                const hostname = instanceName.replace(/\._http\._tcp\.local$/, '').replace(/\.local$/, '');
+                                discovered.set(ip, {
+                                    ip,
+                                    port,
+                                    hostname,
+                                    txt: Object.keys(txt).length > 0 ? txt : undefined,
+                                });
+                                this.log.info(`Discovered Valetudo vacuum at ${ip}:${port} (${hostname}, id: ${txt.id}, model: ${txt.model || 'unknown'})`);
+                            }
+                        }
+                        catch (error) {
+                            this.log.error(`Error processing instance ${instanceName}: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                    this.cleanup();
+                    resolve(Array.from(discovered.values()));
+                }, timeoutMs);
+            }
+            catch (error) {
+                if (queryTimeout)
+                    clearTimeout(queryTimeout);
+                this.cleanup();
+                reject(error);
+            }
+        });
+    }
+    destroy() {
+        this.cleanup();
+    }
+    cleanup() {
+        if (this.mdns) {
+            try {
+                this.mdns.destroy();
+            }
+            catch (error) {
+                this.log.debug(`Error destroying mDNS: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            this.mdns = null;
+        }
+    }
+}