matterbridge-melcloud 1.0.0

package/dist/melcloudApi.js

@@ -0,0 +1,170 @@
+import axios from 'axios';
+const MELCLOUD_ENDPOINT = 'https://app.melcloud.com/Mitsubishi.Wifi.Client';
+export var MelCloudMode;
+(function (MelCloudMode) {
+    MelCloudMode[MelCloudMode["HEATING"] = 1] = "HEATING";
+    MelCloudMode[MelCloudMode["DRYING"] = 2] = "DRYING";
+    MelCloudMode[MelCloudMode["COOLING"] = 3] = "COOLING";
+    MelCloudMode[MelCloudMode["FAN"] = 7] = "FAN";
+    MelCloudMode[MelCloudMode["AUTO"] = 8] = "AUTO";
+})(MelCloudMode || (MelCloudMode = {}));
+export var MatterThermostatMode;
+(function (MatterThermostatMode) {
+    MatterThermostatMode[MatterThermostatMode["OFF"] = 0] = "OFF";
+    MatterThermostatMode[MatterThermostatMode["AUTO"] = 1] = "AUTO";
+    MatterThermostatMode[MatterThermostatMode["COOL"] = 3] = "COOL";
+    MatterThermostatMode[MatterThermostatMode["HEAT"] = 4] = "HEAT";
+})(MatterThermostatMode || (MatterThermostatMode = {}));
+export class MelCloudApi {
+    client;
+    contextKey = null;
+    username;
+    password;
+    constructor(username, password) {
+        this.username = username;
+        this.password = password;
+        this.client = axios.create({
+            baseURL: MELCLOUD_ENDPOINT,
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:73.0)',
+                Accept: 'application/json, text/javascript, */*; q=0.01',
+                'Accept-Language': 'en-US,en;q=0.5',
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    async connect() {
+        try {
+            const response = await this.client.post('/Login/ClientLogin', {
+                Email: this.username,
+                Password: this.password,
+                Language: 0,
+                AppVersion: '1.19.1.1',
+                Persist: true,
+                CaptchaResponse: null,
+            });
+            if (!response.data.ErrorId) {
+                this.contextKey = response.data.LoginData.ContextKey;
+                return true;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    isConnected() {
+        return this.contextKey !== null;
+    }
+    getAuthHeaders() {
+        return {
+            'X-MitsContextKey': this.contextKey,
+            'X-Requested-With': 'XMLHttpRequest',
+            Cookie: 'policyaccepted=true',
+        };
+    }
+    async loadDevices() {
+        if (!this.contextKey) {
+            throw new Error('Not connected to MelCloud');
+        }
+        const response = await this.client.get('/User/ListDevices', {
+            headers: this.getAuthHeaders(),
+        });
+        const devices = [];
+        for (const house of response.data) {
+            if (house.Structure?.Devices) {
+                devices.push(...house.Structure.Devices);
+            }
+            if (house.Structure?.Areas) {
+                for (const area of house.Structure.Areas) {
+                    if (area.Devices) {
+                        devices.push(...area.Devices);
+                    }
+                }
+            }
+            if (house.Structure?.Floors) {
+                for (const floor of house.Structure.Floors) {
+                    if (floor.Devices) {
+                        devices.push(...floor.Devices);
+                    }
+                    if (floor.Areas) {
+                        for (const area of floor.Areas) {
+                            if (area.Devices) {
+                                devices.push(...area.Devices);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return devices;
+    }
+    async getDeviceState(deviceId, buildingId) {
+        if (!this.contextKey) {
+            throw new Error('Not connected to MelCloud');
+        }
+        const response = await this.client.get('/Device/Get', {
+            params: { id: deviceId, buildingID: buildingId },
+            headers: this.getAuthHeaders(),
+        });
+        return response.data;
+    }
+    async setDeviceState(deviceId, buildingId, updates) {
+        if (!this.contextKey) {
+            throw new Error('Not connected to MelCloud');
+        }
+        const currentState = await this.getDeviceState(deviceId, buildingId);
+        const newState = {
+            ...currentState,
+            ...updates,
+            HasPendingCommand: true,
+        };
+        await this.client.post('/Device/SetAta', newState, {
+            headers: this.getAuthHeaders(),
+        });
+    }
+    async setPower(deviceId, buildingId, power) {
+        await this.setDeviceState(deviceId, buildingId, {
+            EffectiveFlags: 1,
+            Power: power,
+        });
+    }
+    async setTemperature(deviceId, buildingId, temperature) {
+        await this.setDeviceState(deviceId, buildingId, {
+            EffectiveFlags: 4,
+            SetTemperature: temperature,
+        });
+    }
+    async setOperationMode(deviceId, buildingId, mode) {
+        await this.setDeviceState(deviceId, buildingId, {
+            EffectiveFlags: 6,
+            OperationMode: mode,
+        });
+    }
+    static matterToMelCloudMode(matterMode) {
+        switch (matterMode) {
+            case MatterThermostatMode.HEAT:
+                return MelCloudMode.HEATING;
+            case MatterThermostatMode.COOL:
+                return MelCloudMode.COOLING;
+            case MatterThermostatMode.AUTO:
+                return MelCloudMode.AUTO;
+            default:
+                return MelCloudMode.AUTO;
+        }
+    }
+    static melCloudToMatterMode(melCloudMode) {
+        switch (melCloudMode) {
+            case MelCloudMode.HEATING:
+                return MatterThermostatMode.HEAT;
+            case MelCloudMode.COOLING:
+            case MelCloudMode.DRYING:
+                return MatterThermostatMode.COOL;
+            case MelCloudMode.AUTO:
+            case MelCloudMode.FAN:
+                return MatterThermostatMode.AUTO;
+            default:
+                return MatterThermostatMode.AUTO;
+        }
+    }
+}

package/dist/module.js

@@ -0,0 +1,264 @@
+import { MatterbridgeDynamicPlatform, MatterbridgeEndpoint, thermostatDevice } from 'matterbridge';
+import { MelCloudApi, MelCloudMode } from './melcloudApi.js';
+const SystemMode = {
+    Off: 0,
+    Auto: 1,
+    Cool: 3,
+    Heat: 4,
+    EmergencyHeat: 5,
+    Precooling: 6,
+    FanOnly: 7,
+    Dry: 8,
+    Sleep: 9,
+};
+const THERMOSTAT_CLUSTER = 'Thermostat';
+const ONOFF_CLUSTER = 'OnOff';
+export default function initializePlugin(matterbridge, log, config) {
+    return new MelCloudPlatform(matterbridge, log, config);
+}
+export class MelCloudPlatform extends MatterbridgeDynamicPlatform {
+    melCloudApi = null;
+    deviceMap = new Map();
+    pollingTimer = null;
+    config;
+    constructor(matterbridge, log, config) {
+        super(matterbridge, log, config);
+        this.config = config;
+        if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.4.0')) {
+            throw new Error(`This plugin requires Matterbridge version >= "3.4.0". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend."`);
+        }
+        this.log.info('Initializing MelCloud Platform...');
+    }
+    async onStart(reason) {
+        this.log.info(`onStart called with reason: ${reason ?? 'none'}`);
+        await this.ready;
+        await this.clearSelect();
+        if (!this.config.username || !this.config.password) {
+            this.log.error('MelCloud username and password are required. Please configure them in the plugin settings.');
+            return;
+        }
+        this.melCloudApi = new MelCloudApi(this.config.username, this.config.password);
+        const connected = await this.melCloudApi.connect();
+        if (!connected) {
+            this.log.error('Failed to connect to MelCloud. Please check your credentials.');
+            return;
+        }
+        this.log.info('Successfully connected to MelCloud');
+        await this.discoverDevices();
+        const interval = this.config.pollingInterval ?? 30000;
+        this.pollingTimer = setInterval(() => this.pollDevices(), interval);
+    }
+    async onConfigure() {
+        await super.onConfigure();
+        this.log.info('onConfigure called');
+        await this.pollDevices();
+    }
+    async onChangeLoggerLevel(logLevel) {
+        this.log.info(`onChangeLoggerLevel called with: ${logLevel}`);
+    }
+    async onShutdown(reason) {
+        await super.onShutdown(reason);
+        this.log.info(`onShutdown called with reason: ${reason ?? 'none'}`);
+        if (this.pollingTimer) {
+            clearInterval(this.pollingTimer);
+            this.pollingTimer = null;
+        }
+        if (this.config.unregisterOnShutdown === true) {
+            await this.unregisterAllDevices();
+        }
+    }
+    async discoverDevices() {
+        if (!this.melCloudApi) {
+            this.log.error('MelCloud API not initialized');
+            return;
+        }
+        this.log.info('Discovering MelCloud devices...');
+        try {
+            const devices = await this.melCloudApi.loadDevices();
+            this.log.info(`Found ${devices.length} MelCloud device(s)`);
+            for (const device of devices) {
+                if (device.Device?.DeviceType !== 0) {
+                    this.log.info(`Skipping device ${device.DeviceName} (unsupported type: ${device.Device?.DeviceType})`);
+                    continue;
+                }
+                await this.registerMelCloudDevice(device);
+            }
+        }
+        catch (error) {
+            this.log.error(`Failed to discover devices: ${error}`);
+        }
+    }
+    async registerMelCloudDevice(device) {
+        const deviceId = `melcloud-${device.DeviceID}`;
+        const serialNumber = `MC${device.DeviceID}`;
+        this.log.info(`Registering device: ${device.DeviceName} (ID: ${device.DeviceID})`);
+        let initialState;
+        try {
+            initialState = await this.melCloudApi.getDeviceState(device.DeviceID, device.BuildingID);
+        }
+        catch (error) {
+            this.log.error(`Failed to get initial state for ${device.DeviceName}: ${error}`);
+            return;
+        }
+        const minTemp = device.MinTemperature ?? 16;
+        const maxTemp = device.MaxTemperature ?? 31;
+        const currentTemp = initialState.RoomTemperature ?? 20;
+        const targetTemp = initialState.SetTemperature ?? 21;
+        const systemMode = initialState.Power
+            ? this.melCloudModeToMatterSystemMode(initialState.OperationMode)
+            : SystemMode.Off;
+        const thermostatEndpoint = new MatterbridgeEndpoint(thermostatDevice, { id: deviceId })
+            .createDefaultBridgedDeviceBasicInformationClusterServer(device.DeviceName, serialNumber, this.matterbridge.aggregatorVendorId, 'Mitsubishi Electric', 'MelCloud AC', device.DeviceID, '1.0.0')
+            .createDefaultPowerSourceWiredClusterServer()
+            .createDefaultOnOffClusterServer(initialState.Power)
+            .createDefaultThermostatClusterServer(currentTemp, targetTemp, targetTemp, 25, minTemp, maxTemp, minTemp, maxTemp);
+        thermostatEndpoint.addCommandHandler('setpointRaiseLower', async (data) => {
+            this.log.info(`setpointRaiseLower command: mode=${data.request.mode}, amount=${data.request.amount}`);
+            await this.handleSetpointRaiseLower(deviceId, data.request.mode, data.request.amount);
+        });
+        this.deviceMap.set(deviceId, {
+            deviceId: device.DeviceID,
+            buildingId: device.BuildingID,
+            endpoint: thermostatEndpoint,
+            minTemp,
+            maxTemp,
+        });
+        this.setSelectDevice(serialNumber, device.DeviceName);
+        const selected = this.validateDevice([device.DeviceName, serialNumber]);
+        if (selected) {
+            await this.registerDevice(thermostatEndpoint);
+            thermostatEndpoint.subscribeAttribute(THERMOSTAT_CLUSTER, 'systemMode', async (newValue) => {
+                await this.handleSystemModeChange(deviceId, newValue);
+            }, this.log);
+            thermostatEndpoint.subscribeAttribute(THERMOSTAT_CLUSTER, 'occupiedHeatingSetpoint', async (newValue) => {
+                await this.handleSetpointChange(deviceId, newValue);
+            }, this.log);
+            thermostatEndpoint.subscribeAttribute(THERMOSTAT_CLUSTER, 'occupiedCoolingSetpoint', async (newValue) => {
+                await this.handleSetpointChange(deviceId, newValue);
+            }, this.log);
+            thermostatEndpoint.subscribeAttribute(ONOFF_CLUSTER, 'onOff', async (newValue) => {
+                await this.handleOnOffChange(deviceId, newValue);
+            }, this.log);
+        }
+    }
+    melCloudModeToMatterSystemMode(melCloudMode) {
+        switch (melCloudMode) {
+            case MelCloudMode.HEATING:
+                return SystemMode.Heat;
+            case MelCloudMode.COOLING:
+                return SystemMode.Cool;
+            case MelCloudMode.DRYING:
+                return SystemMode.Dry;
+            case MelCloudMode.AUTO:
+                return SystemMode.Auto;
+            case MelCloudMode.FAN:
+                return SystemMode.FanOnly;
+            default:
+                return SystemMode.Auto;
+        }
+    }
+    matterSystemModeToMelCloud(systemMode) {
+        switch (systemMode) {
+            case SystemMode.Off:
+                return { power: false };
+            case SystemMode.Heat:
+                return { power: true, mode: MelCloudMode.HEATING };
+            case SystemMode.Cool:
+                return { power: true, mode: MelCloudMode.COOLING };
+            case SystemMode.Auto:
+                return { power: true, mode: MelCloudMode.AUTO };
+            case SystemMode.FanOnly:
+                return { power: true, mode: MelCloudMode.FAN };
+            case SystemMode.Dry:
+                return { power: true, mode: MelCloudMode.DRYING };
+            default:
+                return { power: true, mode: MelCloudMode.AUTO };
+        }
+    }
+    async handleOnOffChange(deviceId, onOff) {
+        const deviceInfo = this.deviceMap.get(deviceId);
+        if (!deviceInfo || !this.melCloudApi)
+            return;
+        this.log.info(`OnOff change for ${deviceId}: ${onOff}`);
+        try {
+            await this.melCloudApi.setPower(deviceInfo.deviceId, deviceInfo.buildingId, onOff);
+            if (!onOff) {
+                await deviceInfo.endpoint.setAttribute(THERMOSTAT_CLUSTER, 'systemMode', SystemMode.Off, this.log);
+            }
+        }
+        catch (error) {
+            this.log.error(`Failed to set power: ${error}`);
+        }
+    }
+    async handleSystemModeChange(deviceId, newMode) {
+        const deviceInfo = this.deviceMap.get(deviceId);
+        if (!deviceInfo || !this.melCloudApi)
+            return;
+        this.log.info(`System mode change for ${deviceId}: ${newMode}`);
+        const { power, mode } = this.matterSystemModeToMelCloud(newMode);
+        try {
+            await this.melCloudApi.setPower(deviceInfo.deviceId, deviceInfo.buildingId, power);
+            await deviceInfo.endpoint.setAttribute(ONOFF_CLUSTER, 'onOff', power, this.log);
+            if (power && mode !== undefined) {
+                await this.melCloudApi.setOperationMode(deviceInfo.deviceId, deviceInfo.buildingId, mode);
+            }
+        }
+        catch (error) {
+            this.log.error(`Failed to set system mode: ${error}`);
+        }
+    }
+    async handleSetpointChange(deviceId, newSetpoint) {
+        const deviceInfo = this.deviceMap.get(deviceId);
+        if (!deviceInfo || !this.melCloudApi)
+            return;
+        const temperature = newSetpoint / 100;
+        const clampedTemp = Math.max(deviceInfo.minTemp, Math.min(deviceInfo.maxTemp, temperature));
+        this.log.info(`Setpoint change for ${deviceId}: ${clampedTemp}°C`);
+        try {
+            await this.melCloudApi.setTemperature(deviceInfo.deviceId, deviceInfo.buildingId, clampedTemp);
+        }
+        catch (error) {
+            this.log.error(`Failed to set temperature: ${error}`);
+        }
+    }
+    async handleSetpointRaiseLower(deviceId, mode, amount) {
+        const deviceInfo = this.deviceMap.get(deviceId);
+        if (!deviceInfo || !this.melCloudApi)
+            return;
+        try {
+            const state = await this.melCloudApi.getDeviceState(deviceInfo.deviceId, deviceInfo.buildingId);
+            const currentSetpoint = state.SetTemperature;
+            const delta = amount / 10;
+            const newSetpoint = Math.max(deviceInfo.minTemp, Math.min(deviceInfo.maxTemp, currentSetpoint + delta));
+            await this.melCloudApi.setTemperature(deviceInfo.deviceId, deviceInfo.buildingId, newSetpoint);
+            await deviceInfo.endpoint.setAttribute(THERMOSTAT_CLUSTER, 'occupiedHeatingSetpoint', newSetpoint * 100, this.log);
+            await deviceInfo.endpoint.setAttribute(THERMOSTAT_CLUSTER, 'occupiedCoolingSetpoint', newSetpoint * 100, this.log);
+        }
+        catch (error) {
+            this.log.error(`Failed to raise/lower setpoint: ${error}`);
+        }
+    }
+    async pollDevices() {
+        if (!this.melCloudApi)
+            return;
+        for (const [deviceId, deviceInfo] of this.deviceMap) {
+            try {
+                const state = await this.melCloudApi.getDeviceState(deviceInfo.deviceId, deviceInfo.buildingId);
+                const localTemp = (state.RoomTemperature ?? 20) * 100;
+                await deviceInfo.endpoint.setAttribute(THERMOSTAT_CLUSTER, 'localTemperature', localTemp, this.log);
+                const setpoint = (state.SetTemperature ?? 21) * 100;
+                await deviceInfo.endpoint.setAttribute(THERMOSTAT_CLUSTER, 'occupiedHeatingSetpoint', setpoint, this.log);
+                await deviceInfo.endpoint.setAttribute(THERMOSTAT_CLUSTER, 'occupiedCoolingSetpoint', setpoint, this.log);
+                const polledSystemMode = state.Power
+                    ? this.melCloudModeToMatterSystemMode(state.OperationMode)
+                    : SystemMode.Off;
+                await deviceInfo.endpoint.setAttribute(THERMOSTAT_CLUSTER, 'systemMode', polledSystemMode, this.log);
+                await deviceInfo.endpoint.setAttribute(ONOFF_CLUSTER, 'onOff', state.Power, this.log);
+                this.log.debug?.(`Polled ${deviceId}: ${state.RoomTemperature}°C, setpoint: ${state.SetTemperature}°C, power: ${state.Power}, mode: ${polledSystemMode}`);
+            }
+            catch (error) {
+                this.log.error(`Failed to poll device ${deviceId}: ${error}`);
+            }
+        }
+    }
+}

package/matterbridge-melcloud.config.json

@@ -0,0 +1,11 @@
+{
+  "name": "matterbridge-melcloud",
+  "type": "DynamicPlatform",
+  "username": "",
+  "password": "",
+  "pollingInterval": 30000,
+  "whiteList": [],
+  "blackList": [],
+  "debug": false,
+  "unregisterOnShutdown": false
+}

package/matterbridge-melcloud.schema.json

@@ -0,0 +1,73 @@
+{
+  "title": "Matterbridge MelCloud Plugin",
+  "description": "matterbridge-melcloud - Mitsubishi Air Conditioning via MelCloud",
+  "type": "object",
+  "properties": {
+    "name": {
+      "title": "Plugin Name",
+      "description": "Plugin name",
+      "type": "string",
+      "readOnly": true,
+      "ui:widget": "hidden"
+    },
+    "type": {
+      "title": "Plugin Type",
+      "description": "Plugin type",
+      "type": "string",
+      "readOnly": true,
+      "ui:widget": "hidden"
+    },
+    "username": {
+      "title": "MelCloud Username",
+      "description": "Your MelCloud account email address",
+      "type": "string"
+    },
+    "password": {
+      "title": "MelCloud Password",
+      "description": "Your MelCloud account password",
+      "type": "string",
+      "ui:widget": "password"
+    },
+    "pollingInterval": {
+      "title": "Polling Interval (ms)",
+      "description": "How often to poll MelCloud for device state updates (in milliseconds). Default: 30000 (30 seconds)",
+      "type": "number",
+      "default": 30000,
+      "minimum": 10000,
+      "maximum": 300000
+    },
+    "whiteList": {
+      "title": "White List",
+      "description": "Only the devices in the list will be exposed. If the list is empty, all the devices will be exposed.",
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "uniqueItems": true,
+      "selectFrom": "name"
+    },
+    "blackList": {
+      "title": "Black List",
+      "description": "The devices in the list will not be exposed. If the list is empty, no devices will be excluded.",
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "uniqueItems": true,
+      "selectFrom": "name"
+    },
+    "debug": {
+      "title": "Enable Debug",
+      "description": "Enable debug mode for the plugin. Only for debugging purposes, not recommended for production use.",
+      "type": "boolean",
+      "default": false
+    },
+    "unregisterOnShutdown": {
+      "title": "Unregister On Shutdown",
+      "description": "Unregister all devices on shutdown. Only for debugging purposes, not recommended for production use.",
+      "type": "boolean",
+      "default": false
+    }
+  },
+  "required": ["username", "password"]
+}