@diveflo/matterbridge-mova 0.1.18

package/dist/platform.d.ts

@@ -0,0 +1,22 @@
+import { MatterbridgeDynamicPlatform, type PlatformMatterbridge, PlatformConfig } from 'matterbridge';
+import { AnsiLogger, LogLevel } from 'matterbridge/logger';
+export declare class MovaPlatform extends MatterbridgeDynamicPlatform {
+    private cloud;
+    private devices;
+    private cloudDevices;
+    private statusInterval;
+    private devicePollingTimers;
+    private refreshInterval;
+    private lastDeviceState;
+    constructor(matterbridge: PlatformMatterbridge, log: AnsiLogger, config: PlatformConfig);
+    onStart(reason?: string): Promise<void>;
+    onConfigure(): Promise<void>;
+    onChangeLoggerLevel(logLevel: LogLevel): Promise<void>;
+    onShutdown(reason?: string): Promise<void>;
+    private loadCachedRooms;
+    private saveCachedRooms;
+    private discoverDevices;
+    private startStatusPolling;
+    private scheduleDevicePoll;
+    private handleDeviceStatus;
+}

package/dist/platform.js

@@ -0,0 +1,246 @@
+import { MatterbridgeDynamicPlatform } from 'matterbridge';
+import { MovaCloudProtocol } from './movaCloud.js';
+import { discoverAndRegisterDevices } from './mova.js';
+import { MovaState } from './types.js';
+const STORAGE_KEYS = {
+    rooms: (did) => `rooms_${did}`,
+};
+const POLLING_INTERVALS = {
+    active: 15,
+    idle: 120,
+};
+const ACTIVE_STATES = new Set([
+    MovaState.Cleaning,
+    MovaState.Mopping,
+    MovaState.GoCharging,
+    MovaState.Returning,
+    MovaState.Washing,
+    MovaState.Drying,
+    MovaState.Defecating,
+    MovaState.Building,
+    MovaState.ManualCleaning,
+    MovaState.ZonedCleaning,
+    MovaState.SpotCleaning,
+    MovaState.FastMapping,
+    MovaState.SecondCleaning,
+    MovaState.StationCleaning,
+    MovaState.Emptying,
+    MovaState.ReturningAutoEmpty,
+    MovaState.CleaningAutoEmpty,
+]);
+export class MovaPlatform extends MatterbridgeDynamicPlatform {
+    cloud;
+    devices = new Map();
+    cloudDevices = new Map();
+    statusInterval = null;
+    devicePollingTimers = new Map();
+    refreshInterval;
+    lastDeviceState = new Map();
+    constructor(matterbridge, log, config) {
+        super(matterbridge, log, 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.`);
+        }
+        this.cloud = new MovaCloudProtocol(log);
+        this.refreshInterval = config.refreshInterval ?? 120;
+        if (this.refreshInterval < 30) {
+            this.refreshInterval = 30;
+            this.log.warn('Refresh interval too low, setting to 30 seconds');
+        }
+        this.log.info('Mova Platform initialized');
+    }
+    async onStart(reason) {
+        this.log.info(`onStart called with reason: ${reason ?? 'none'}`);
+        await this.ready;
+        const config = this.config;
+        if (!config.username || !config.password) {
+            this.log.error('Missing username or password in configuration');
+            return;
+        }
+        if (!config.country) {
+            this.log.error('Missing country/region in configuration');
+            return;
+        }
+        const loginResult = await this.cloud.login(config.username, config.password, config.country);
+        if (!loginResult.success) {
+            this.log.error(`Failed to login to Mova Cloud: ${loginResult.error}`);
+            return;
+        }
+        await this.discoverDevices();
+    }
+    async onConfigure() {
+        await super.onConfigure();
+        this.log.info('onConfigure called');
+        this.startStatusPolling();
+        for (const [did, device] of this.devices) {
+            this.log.info(`Configuring device: ${device.name} (${did})`);
+            const cloudDevice = this.cloudDevices.get(did);
+            if (cloudDevice) {
+                const mqttConnected = await this.cloud.connectMqtt(cloudDevice);
+                if (mqttConnected) {
+                    this.log.info(`MQTT connected for ${device.name}`);
+                }
+                else {
+                    this.log.info(`Using cloud polling for ${device.name}`);
+                }
+            }
+            this.cloud.onDeviceStatus(did, (status) => {
+                this.handleDeviceStatus(did, status);
+            });
+            this.cloud.onRoomUpdate(did, (rooms) => {
+                this.log.info(`Received ${rooms.length} rooms via MQTT for ${device.name}`);
+                device.updateRooms(rooms);
+                this.saveCachedRooms(did, rooms).catch((err) => this.log.debug(`Failed to save rooms: ${err}`));
+            });
+        }
+    }
+    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.statusInterval) {
+            clearInterval(this.statusInterval);
+            this.statusInterval = null;
+        }
+        for (const [did, timer] of this.devicePollingTimers) {
+            clearTimeout(timer);
+            this.log.debug(`Stopped polling timer for ${did}`);
+        }
+        this.devicePollingTimers.clear();
+        this.lastDeviceState.clear();
+        await this.cloud.disconnect();
+        if (this.config.unregisterOnShutdown === true) {
+            await this.unregisterAllDevices();
+        }
+    }
+    async loadCachedRooms(did) {
+        try {
+            if (!this.context) {
+                return [];
+            }
+            const key = STORAGE_KEYS.rooms(did);
+            const cached = await this.context.get(key);
+            if (cached && Array.isArray(cached) && cached.length > 0) {
+                this.log.info(`Loaded ${cached.length} cached rooms from storage for ${did}`);
+                return cached;
+            }
+        }
+        catch (error) {
+            this.log.debug(`Failed to load cached rooms: ${error}`);
+        }
+        return [];
+    }
+    async saveCachedRooms(did, rooms) {
+        try {
+            if (!this.context || rooms.length === 0) {
+                return;
+            }
+            const key = STORAGE_KEYS.rooms(did);
+            await this.context.set(key, rooms);
+            this.log.info(`Saved ${rooms.length} rooms to storage for ${did}`);
+        }
+        catch (error) {
+            this.log.debug(`Failed to save cached rooms: ${error}`);
+        }
+    }
+    async discoverDevices() {
+        this.log.info('Discovering Mova vacuums...');
+        const cloudDevices = await this.cloud.getDevices();
+        if (cloudDevices.length === 0) {
+            this.log.warn('No Mova vacuums found');
+            return;
+        }
+        for (const cloudDevice of cloudDevices) {
+            try {
+                this.log.info(`Found vacuum: ${cloudDevice.name} (${cloudDevice.model})`);
+                let rooms = await this.cloud.getRoomInfo(cloudDevice.did);
+                if (rooms.length === 0) {
+                    this.log.info(`No cached rooms, trying proactive cloud storage fetch for ${cloudDevice.name}...`);
+                    const fetchedRooms = await this.cloud.tryFetchMapOnStartup(cloudDevice.did);
+                    if (fetchedRooms) {
+                        rooms = this.cloud.getCachedRooms(cloudDevice.did);
+                    }
+                }
+                if (rooms.length === 0) {
+                    this.log.info(`Trying to load rooms from persistent storage for ${cloudDevice.name}...`);
+                    rooms = await this.loadCachedRooms(cloudDevice.did);
+                }
+                if (rooms.length === 0) {
+                    this.log.warn(`No rooms found for ${cloudDevice.name}. Device may be sleeping.`);
+                    this.log.warn('Tip: Start a cleaning cycle to wake the device and fetch room data.');
+                }
+                else {
+                    await this.saveCachedRooms(cloudDevice.did, rooms);
+                }
+                this.log.info(`Found ${rooms.length} rooms for ${cloudDevice.name}`);
+                const status = await this.cloud.getDeviceProperties(cloudDevice.did);
+                const device = await discoverAndRegisterDevices(this, this.cloud, cloudDevice, rooms, status);
+                if (device) {
+                    this.devices.set(cloudDevice.did, device);
+                    this.cloudDevices.set(cloudDevice.did, cloudDevice);
+                }
+            }
+            catch (error) {
+                this.log.error(`Failed to register device ${cloudDevice.name}: ${error}`);
+            }
+        }
+        this.log.info(`Registered ${this.devices.size} Mova vacuum(s)`);
+    }
+    startStatusPolling() {
+        if (this.statusInterval) {
+            return;
+        }
+        this.log.info('Starting adaptive status polling');
+        for (const [did] of this.devices) {
+            this.scheduleDevicePoll(did, POLLING_INTERVALS.idle);
+        }
+        this.statusInterval = setInterval(async () => {
+            for (const [did] of this.devices) {
+                if (!this.devicePollingTimers.has(did)) {
+                    this.scheduleDevicePoll(did, POLLING_INTERVALS.idle);
+                }
+            }
+        }, this.refreshInterval * 1000);
+    }
+    scheduleDevicePoll(did, intervalSeconds) {
+        const existingTimer = this.devicePollingTimers.get(did);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+        }
+        const timer = setTimeout(async () => {
+            this.devicePollingTimers.delete(did);
+            try {
+                const status = await this.cloud.getDeviceProperties(did);
+                if (status) {
+                    this.handleDeviceStatus(did, status);
+                    const isActive = ACTIVE_STATES.has(status.state);
+                    const nextInterval = isActive ? POLLING_INTERVALS.active : Math.max(this.refreshInterval, POLLING_INTERVALS.idle);
+                    const lastState = this.lastDeviceState.get(did);
+                    if (lastState !== undefined && ACTIVE_STATES.has(lastState) !== isActive) {
+                        this.log.info(`Device ${did} state changed: polling interval now ${nextInterval}s (${isActive ? 'active' : 'idle'})`);
+                    }
+                    this.lastDeviceState.set(did, status.state);
+                    this.scheduleDevicePoll(did, nextInterval);
+                }
+                else {
+                    this.scheduleDevicePoll(did, Math.max(this.refreshInterval, POLLING_INTERVALS.idle));
+                }
+            }
+            catch (error) {
+                this.log.error(`Failed to get status for ${did}: ${error}`);
+                this.scheduleDevicePoll(did, Math.max(this.refreshInterval, POLLING_INTERVALS.idle));
+            }
+        }, intervalSeconds * 1000);
+        this.devicePollingTimers.set(did, timer);
+    }
+    handleDeviceStatus(did, status) {
+        const device = this.devices.get(did);
+        if (!device) {
+            return;
+        }
+        this.log.debug(`Status update for ${device.name}: state=${status.state}, status=${status.status}, battery=${status.battery}%`);
+        device.updateStatus(status);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,247 @@
+export interface MovaConfig {
+    username: string;
+    password: string;
+    country: MovaCountry;
+    refreshInterval?: number;
+    unregisterOnShutdown?: boolean;
+    suctionLevel?: MovaSuctionLevelName;
+    vacuumAndMopMode?: MovaVacuumAndMopMode;
+}
+export type MovaCountry = 'cn' | 'eu' | 'us' | 'sg' | 'ru';
+export type MovaSuctionLevelName = 'quiet' | 'standard' | 'strong' | 'turbo';
+export type MovaVacuumAndMopMode = 'vac-mop' | 'vac-then-mop';
+export interface AuthResult {
+    success: boolean;
+    token?: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    userId?: string;
+    error?: string;
+}
+export interface CloudSession {
+    token: string;
+    refreshToken: string;
+    expiresAt: number;
+    userId: string;
+    country: MovaCountry;
+    mqttKey?: string;
+}
+export interface MovaDevice {
+    did: string;
+    name: string;
+    model: string;
+    mac: string;
+    localIp?: string;
+    token?: string;
+    online: boolean;
+    ownerId: string;
+    bindDomain?: string;
+    property?: string;
+}
+export interface DeviceStatus {
+    state: MovaState;
+    status: MovaStatus;
+    battery: number;
+    fanSpeed: MovaFanSpeed;
+    waterFlow: MovaWaterFlow;
+    cleaningMode?: MovaCleaningMode;
+    errorCode: MovaErrorCode;
+    currentArea?: number;
+    cleaningTime?: number;
+    cleanedArea?: number;
+    waterTankInstalled?: boolean;
+    mopPadInstalled?: boolean;
+    dustCollectionStatus?: number;
+    cleanWaterTankStatus?: number;
+    dirtyWaterTankStatus?: number;
+}
+export interface RoomInfo {
+    id: number;
+    name: string;
+    floorId?: number;
+    icon?: string;
+}
+export declare enum MovaState {
+    Unknown = -1,
+    Idle = 0,
+    Paused = 1,
+    Cleaning = 2,
+    GoCharging = 3,
+    Error = 4,
+    Mopping = 5,
+    Charging = 6,
+    Drying = 7,
+    Dormant = 8,
+    Washing = 9,
+    Returning = 10,
+    Defecating = 11,
+    Building = 12,
+    ManualCleaning = 13,
+    Sleeping = 14,
+    WaitingForTask = 15,
+    StationPaused = 16,
+    ManualPaused = 17,
+    ZonedPaused = 18,
+    ZonedCleaning = 19,
+    SpotCleaning = 20,
+    FastMapping = 21,
+    CruiseWaiting = 22,
+    CruiseRunning = 23,
+    SecondCleaning = 24,
+    HumanFollowing = 25,
+    SpotCleaningPaused = 26,
+    ReturningAutoEmpty = 27,
+    CleaningAutoEmpty = 28,
+    StationCleaning = 29,
+    ReturningToDrain = 30,
+    Draining = 31,
+    AutoWaterDraining = 32,
+    Emptying = 33,
+    DustBagDrying = 34,
+    DustBagDryingPaused = 35,
+    HeadingToExtraCleaning = 36,
+    ExtraCleaning = 37,
+    FindingPetPaused = 95,
+    FindingPet = 96,
+    Shortcut = 97,
+    Monitoring = 98,
+    MonitoringPaused = 99,
+    InitialDeepCleaning = 101,
+    InitialDeepCleaningPaused = 102,
+    Sanitizing = 103,
+    SanitizingWithDry = 104
+}
+export declare enum MovaStatus {
+    Unknown = -1,
+    Idle = 0,
+    Paused = 1,
+    Cleaning = 2,
+    BackHome = 3,
+    PartCleaning = 4,
+    FollowWall = 5,
+    Charging = 6,
+    OTA = 7,
+    FCT = 8,
+    WifiSet = 9,
+    PowerOff = 10,
+    Factory = 11,
+    Error = 12,
+    RemoteControl = 13,
+    Sleeping = 14,
+    SelfRepair = 15,
+    FactoryTest = 16,
+    Standby = 17,
+    SegmentCleaning = 18,
+    ZoneCleaning = 19,
+    SpotCleaning = 20,
+    FastMapping = 21,
+    CruisingPath = 22,
+    CruisingPoint = 23,
+    SummonClean = 24,
+    Shortcut = 25,
+    PersonFollow = 26,
+    WaterCheck = 27,
+    Sweeping = 101,
+    Mopping = 102,
+    SweepingAndMopping = 103,
+    Drying = 104,
+    Washing = 105,
+    ReturningWashing = 106,
+    Building = 107,
+    ChargingComplete = 108,
+    Upgrading = 109,
+    CleanSummarizing = 110,
+    StationReset = 111,
+    ReturningDrain = 112,
+    SelfRepairing = 113,
+    SelfWashing = 114,
+    BackWashing = 115,
+    SelfRefresh = 116,
+    SelfDrying = 117,
+    WaterCheckStart = 118,
+    WaterDraining = 119,
+    DryingStart = 120,
+    AutoEmptying = 121,
+    FillingWater = 122
+}
+export declare enum MovaFanSpeed {
+    Quiet = 0,
+    Standard = 1,
+    Strong = 2,
+    Turbo = 3
+}
+export declare enum MovaWaterFlow {
+    Low = 1,
+    Medium = 2,
+    High = 3
+}
+export declare enum MovaCleaningMode {
+    Sweeping = 0,
+    Mopping = 1,
+    SweepingAndMopping = 2,
+    MoppingAfterSweeping = 3
+}
+export declare enum MovaErrorCode {
+    None = 0,
+    Drop = 1,
+    Cliff = 2,
+    Bumper = 3,
+    Gesture = 4,
+    BumperRepeat = 5,
+    DropRepeat = 6,
+    OpticalFlow = 7,
+    NoBox = 8,
+    NoTankBox = 9,
+    WaterBoxEmpty = 10,
+    BoxFull = 11,
+    Brush = 12,
+    SideBrush = 13,
+    Fan = 14,
+    LeftWheelMotor = 15,
+    RightWheelMotor = 16,
+    TurnSuffocate = 17,
+    ForwardSuffocate = 18,
+    ChargerGet = 19,
+    BatteryLow = 20,
+    ChargeFault = 21,
+    BatteryPercentage = 22,
+    Heart = 23,
+    CameraOcclusion = 24,
+    CameraFault = 25,
+    EventBattery = 26,
+    ForwardLooking = 27,
+    Gyroscope = 28,
+    WheelJammed = 29,
+    DirtyTankFull = 30,
+    DirtyTankMissing = 31,
+    WaterTankLidOpen = 32,
+    MopPadMissing = 33,
+    FilterBlocked = 34,
+    StationDisconnected = 35,
+    NavigationBlocked = 36,
+    CannotReachArea = 37,
+    DustBagFull = 38,
+    DustBagMissing = 39,
+    WaterPump = 40,
+    CleanTankMissing = 41,
+    LidarBlocked = 42,
+    RouteBlocked = 100,
+    MainBrushJammed = 101,
+    SideBrushJammed = 102,
+    FilterClogged = 103,
+    DustBinNotInstalled = 104,
+    StationWaterEmpty = 105,
+    StationWaterDirty = 106,
+    StationDustFull = 107,
+    ReturnFailed = 1000
+}
+export interface MiotProperty {
+    siid: number;
+    piid: number;
+    value?: unknown;
+}
+export interface MiotAction {
+    siid: number;
+    aiid: number;
+    in?: unknown[];
+}