matterbridge-roborock-vacuum-plugin-regions 1.1.1-jb.1

package/dist/platform.js

@@ -0,0 +1,312 @@
+import { MatterbridgeDynamicPlatform } from 'matterbridge';
+import * as axios from 'axios';
+import crypto from 'node:crypto';
+import { debugStringify } from 'matterbridge/logger';
+import RoborockService from './roborockService.js';
+import { PLUGIN_NAME } from './settings.js';
+import ClientManager from './clientManager.js';
+import { getRoomMapFromDevice, isSupportedDevice } from './helper.js';
+import { PlatformRunner } from './platformRunner.js';
+import { RoborockVacuumCleaner } from './rvc.js';
+import { configurateBehavior } from './behaviorFactory.js';
+import { RoborockAuthenticateApi, RoborockIoTApi } from './roborockCommunication/index.js';
+import { getSupportedAreas, getSupportedScenes } from './initialData/index.js';
+import { createDefaultExperimentalFeatureSetting } from './model/ExperimentalFeatureSetting.js';
+import NodePersist from 'node-persist';
+import Path from 'node:path';
+export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
+    robots = new Map();
+    rvcInterval;
+    roborockService;
+    clientManager;
+    platformRunner;
+    devices = new Map();
+    cleanModeSettings;
+    enableExperimentalFeature;
+    persist;
+    rrHomeId;
+    constructor(matterbridge, log, config) {
+        super(matterbridge, log, config);
+        if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.3.6')) {
+            throw new Error(`This plugin requires Matterbridge version >= "3.3.6". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend.`);
+        }
+        this.log.info('Initializing platform:', this.config.name);
+        if (config.whiteList === undefined)
+            config.whiteList = [];
+        if (config.blackList === undefined)
+            config.blackList = [];
+        if (config.enableExperimental === undefined)
+            config.enableExperimental = createDefaultExperimentalFeatureSetting();
+        const persistDir = Path.join(this.matterbridge.matterbridgePluginDirectory, PLUGIN_NAME, 'persist');
+        this.persist = NodePersist.create({ dir: persistDir });
+        this.clientManager = new ClientManager(this.log);
+        this.devices = new Map();
+    }
+    async onStart(reason) {
+        this.log.notice('onStart called with reason:', reason ?? 'none');
+        await this.ready;
+        await this.clearSelect();
+        await this.persist.init();
+        if (this.config.username === undefined) {
+            this.log.error('"username" (email address) is required in the config');
+            return;
+        }
+        const axiosInstance = axios.default ?? axios;
+        this.enableExperimentalFeature = this.config.enableExperimental;
+        this.enableExperimentalFeature.advancedFeature.enableMultipleMap = false;
+        if (this.enableExperimentalFeature?.enableExperimentalFeature && this.enableExperimentalFeature?.cleanModeSettings?.enableCleanModeMapping) {
+            this.cleanModeSettings = this.enableExperimentalFeature.cleanModeSettings;
+            this.log.notice(`Experimental Feature has been enable`);
+            this.log.notice(`cleanModeSettings ${debugStringify(this.cleanModeSettings)}`);
+        }
+        this.platformRunner = new PlatformRunner(this);
+        let deviceId = (await this.persist.getItem('deviceId'));
+        if (!deviceId) {
+            deviceId = crypto.randomUUID();
+            await this.persist.setItem('deviceId', deviceId);
+            this.log.debug('Generated new deviceId:', deviceId);
+        }
+        else {
+            this.log.debug('Using cached deviceId:', deviceId);
+        }
+        const configRegion = this.config.region ?? undefined;
+        if (configRegion) {
+            this.log.notice(`Region configured: ${configRegion}`);
+        }
+        this.roborockService = new RoborockService(() => new RoborockAuthenticateApi(this.log, axiosInstance, deviceId, configRegion), (logger, ud) => new RoborockIoTApi(ud, logger), this.config.refreshInterval ?? 60, this.clientManager, this.log);
+        const username = this.config.username;
+        this.log.debug(`config: ${debugStringify(this.config)}`);
+        const authenticationPayload = this.config.authentication;
+        const password = authenticationPayload.password ?? '';
+        const verificationCode = authenticationPayload.verificationCode ?? '';
+        const authenticationMethod = authenticationPayload.authenticationMethod;
+        this.log.debug(`Authentication method: ${authenticationMethod}`);
+        this.log.debug(`Username: ${username}`);
+        this.log.debug(`Password provided: ${password !== ''}`);
+        this.log.debug(`Verification code provided: ${verificationCode !== ''}`);
+        let userData;
+        try {
+            if (authenticationMethod === 'VerificationCode') {
+                this.log.debug('Using verification code from config for authentication');
+                userData = await this.authenticate2FA(username, verificationCode);
+            }
+            else {
+                userData = await this.authenticateWithPassword(username, password);
+            }
+        }
+        catch (error) {
+            this.log.error(`Authentication failed: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        if (!userData) {
+            return;
+        }
+        this.log.debug('Initializing - userData:', debugStringify(userData));
+        const devices = await this.roborockService.listDevices(username);
+        this.log.notice('Initializing - devices: ', debugStringify(devices));
+        let vacuums = [];
+        if (this.config.whiteList.length > 0) {
+            const whiteList = (this.config.whiteList ?? []);
+            for (const item of whiteList) {
+                const duid = item.split('-')[1].trim();
+                const vacuum = devices.find((d) => d.duid === duid);
+                if (vacuum) {
+                    vacuums.push(vacuum);
+                }
+            }
+        }
+        else {
+            vacuums = devices.filter((d) => isSupportedDevice(d.data.model));
+        }
+        if (vacuums.length === 0) {
+            this.log.error('Initializing: No device found');
+            return;
+        }
+        if (!this.enableExperimentalFeature?.enableExperimentalFeature || !this.enableExperimentalFeature?.advancedFeature?.enableServerMode) {
+            vacuums = [vacuums[0]];
+        }
+        for (const vacuum of vacuums) {
+            await this.roborockService.initializeMessageClient(username, vacuum, userData);
+            this.devices.set(vacuum.serialNumber, vacuum);
+        }
+        await this.onConfigurateDevice();
+        this.log.notice('onStart finished');
+    }
+    async onConfigure() {
+        await super.onConfigure();
+        const self = this;
+        this.rvcInterval = setInterval(async () => {
+            self.platformRunner?.requestHomeData();
+        }, (this.config.refreshInterval ?? 60) * 1000 + 100);
+    }
+    async onConfigurateDevice() {
+        this.log.info('onConfigurateDevice start');
+        if (this.platformRunner === undefined || this.roborockService === undefined) {
+            this.log.error('Initializing: PlatformRunner or RoborockService is undefined');
+            return;
+        }
+        const username = this.config.username;
+        if (this.devices.size === 0 || !username) {
+            this.log.error('Initializing: No supported devices found');
+            return;
+        }
+        const self = this;
+        const configurateSuccess = new Map();
+        for (const vacuum of this.devices.values()) {
+            const success = await this.configurateDevice(vacuum);
+            configurateSuccess.set(vacuum.duid, success);
+            if (success) {
+                this.rrHomeId = vacuum.rrHomeId;
+            }
+        }
+        this.roborockService.setDeviceNotify(async function (messageSource, homeData) {
+            await self.platformRunner?.updateRobot(messageSource, homeData);
+        });
+        for (const [duid, robot] of this.robots.entries()) {
+            if (!configurateSuccess.get(duid)) {
+                continue;
+            }
+            this.roborockService.activateDeviceNotify(robot.device);
+        }
+        await this.platformRunner?.requestHomeData();
+        this.log.info('onConfigurateDevice finished');
+    }
+    async configurateDevice(vacuum) {
+        const username = this.config.username;
+        if (this.platformRunner === undefined || this.roborockService === undefined) {
+            this.log.error('Initializing: PlatformRunner or RoborockService is undefined');
+            return false;
+        }
+        const connectedToLocalNetwork = await this.roborockService.initializeMessageClientForLocal(vacuum);
+        if (!connectedToLocalNetwork) {
+            this.log.error(`Failed to connect to local network for device: ${vacuum.name} (${vacuum.duid})`);
+            return false;
+        }
+        if (vacuum.rooms === undefined || vacuum.rooms.length === 0) {
+            this.log.notice(`Fetching map information for device: ${vacuum.name} (${vacuum.duid}) to get rooms`);
+            const map_info = await this.roborockService.getMapInformation(vacuum.duid);
+            const rooms = map_info?.allRooms ?? [];
+            vacuum.rooms = rooms.map((room) => ({ id: room.globalId, name: room.displayName }));
+        }
+        const roomMap = await getRoomMapFromDevice(vacuum, this);
+        this.log.debug('Initializing - roomMap: ', debugStringify(roomMap));
+        const behaviorHandler = configurateBehavior(vacuum.data.model, vacuum.duid, this.roborockService, this.cleanModeSettings, this.enableExperimentalFeature?.advancedFeature?.forceRunAtDefault ?? false, this.log);
+        const enableMultipleMap = this.enableExperimentalFeature?.enableExperimentalFeature && this.enableExperimentalFeature.advancedFeature?.enableMultipleMap;
+        const { supportedAreas, roomIndexMap } = getSupportedAreas(vacuum.rooms, roomMap, enableMultipleMap, this.log);
+        this.roborockService.setSupportedAreas(vacuum.duid, supportedAreas);
+        this.roborockService.setSupportedAreaIndexMap(vacuum.duid, roomIndexMap);
+        let routineAsRoom = [];
+        if (this.enableExperimentalFeature?.enableExperimentalFeature && this.enableExperimentalFeature.advancedFeature?.showRoutinesAsRoom) {
+            routineAsRoom = getSupportedScenes(vacuum.scenes ?? [], this.log);
+            this.roborockService.setSupportedScenes(vacuum.duid, routineAsRoom);
+        }
+        const robot = new RoborockVacuumCleaner(username, vacuum, roomMap, routineAsRoom, this.enableExperimentalFeature, this.log);
+        robot.configurateHandler(behaviorHandler);
+        this.log.info('vacuum:', debugStringify(vacuum));
+        this.setSelectDevice(robot.serialNumber ?? '', robot.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(robot.deviceName ?? '')) {
+            await this.registerDevice(robot);
+        }
+        this.robots.set(robot.serialNumber ?? '', robot);
+        return true;
+    }
+    async onShutdown(reason) {
+        await super.onShutdown(reason);
+        this.log.notice('onShutdown called with reason:', reason ?? 'none');
+        if (this.rvcInterval)
+            clearInterval(this.rvcInterval);
+        if (this.roborockService)
+            this.roborockService.stopService();
+        if (this.config.unregisterOnShutdown === true)
+            await this.unregisterAllDevices(500);
+    }
+    async onChangeLoggerLevel(logLevel) {
+        this.log.notice(`Change ${PLUGIN_NAME} log level: ${logLevel} (was ${this.log.logLevel})`);
+        this.log.logLevel = logLevel;
+        return Promise.resolve();
+    }
+    async authenticateWithPassword(username, password) {
+        if (!this.roborockService) {
+            throw new Error('RoborockService is not initialized');
+        }
+        this.log.notice('Attempting login with password...');
+        const userData = await this.roborockService.loginWithPassword(username, password, async () => {
+            if (this.enableExperimentalFeature?.enableExperimentalFeature && this.enableExperimentalFeature.advancedFeature?.alwaysExecuteAuthentication) {
+                this.log.debug('Always execute authentication on startup');
+                return undefined;
+            }
+            const savedUserData = (await this.persist.getItem('userData'));
+            if (savedUserData) {
+                this.log.debug('Loading saved userData:', debugStringify(savedUserData));
+                return savedUserData;
+            }
+            return undefined;
+        }, async (userData) => {
+            await this.persist.setItem('userData', userData);
+        });
+        this.log.notice('Authentication successful!');
+        return userData;
+    }
+    async authenticate2FA(username, verificationCode) {
+        if (!this.roborockService) {
+            throw new Error('RoborockService is not initialized');
+        }
+        if (!this.enableExperimentalFeature?.advancedFeature?.alwaysExecuteAuthentication) {
+            const savedUserData = (await this.persist.getItem('userData'));
+            if (savedUserData) {
+                this.log.debug('Found saved userData, attempting to use cached token');
+                try {
+                    const userData = await this.roborockService.loginWithCachedToken(username, savedUserData);
+                    this.log.notice('Successfully authenticated with cached token');
+                    return userData;
+                }
+                catch (error) {
+                    this.log.warn(`Cached token invalid or expired: ${error instanceof Error ? error.message : String(error)}`);
+                    await this.persist.removeItem('userData');
+                }
+            }
+        }
+        if (!verificationCode || verificationCode.trim() === '') {
+            const authState = (await this.persist.getItem('authenticateFlowState'));
+            const now = Date.now();
+            const RATE_LIMIT_MS = 60000;
+            if (authState?.codeRequestedAt && now - authState.codeRequestedAt < RATE_LIMIT_MS) {
+                const waitSeconds = Math.ceil((RATE_LIMIT_MS - (now - authState.codeRequestedAt)) / 1000);
+                this.log.warn(`Please wait ${waitSeconds} seconds before requesting another code.`);
+                this.log.notice('============================================');
+                this.log.notice('ACTION REQUIRED: Enter verification code');
+                this.log.notice(`A verification code was previously sent to: ${username}`);
+                this.log.notice('Enter the 6-digit code in the plugin configuration');
+                this.log.notice('under the "verificationCode" field, then restart the plugin.');
+                this.log.notice('============================================');
+                return undefined;
+            }
+            try {
+                this.log.notice(`Requesting verification code for: ${username}`);
+                await this.roborockService.requestVerificationCode(username);
+                await this.persist.setItem('authenticateFlowState', {
+                    email: username,
+                    codeRequestedAt: now,
+                });
+                this.log.notice('============================================');
+                this.log.notice('ACTION REQUIRED: Enter verification code');
+                this.log.notice(`A verification code has been sent to: ${username}`);
+                this.log.notice('Enter the 6-digit code in the plugin configuration');
+                this.log.notice('under the "verificationCode" field, then restart the plugin.');
+                this.log.notice('============================================');
+            }
+            catch (error) {
+                this.log.error(`Failed to request verification code: ${error instanceof Error ? error.message : String(error)}`);
+                throw error;
+            }
+            return undefined;
+        }
+        this.log.notice('Attempting login with verification code...');
+        const userData = await this.roborockService.loginWithVerificationCode(username, verificationCode.trim(), async (data) => {
+            await this.persist.setItem('userData', data);
+            await this.persist.removeItem('authenticateFlowState');
+        });
+        this.log.notice('Authentication successful!');
+        return userData;
+    }
+}

package/dist/platformRunner.js

@@ -0,0 +1,90 @@
+import { PowerSource, RvcOperationalState } from 'matterbridge/matter/clusters';
+import { getBatteryStatus, getOperationalErrorState } from './initialData/index.js';
+import { NotifyMessageTypes } from './notifyMessageTypes.js';
+import { debugStringify } from 'matterbridge/logger';
+import { handleLocalMessage } from './runtimes/handleLocalMessage.js';
+import { handleCloudMessage } from './runtimes/handleCloudMessage.js';
+import { updateFromHomeData } from './runtimes/handleHomeDataMessage.js';
+export class PlatformRunner {
+    platform;
+    constructor(platform) {
+        this.platform = platform;
+    }
+    async updateRobot(messageSource, homeData) {
+        if (messageSource === NotifyMessageTypes.HomeData) {
+            updateFromHomeData(homeData, this.platform);
+        }
+        else {
+            await this.updateFromMQTTMessage(messageSource, homeData);
+        }
+    }
+    async requestHomeData() {
+        const platform = this.platform;
+        if (platform.robots.size === 0 || !platform.rrHomeId)
+            return;
+        if (platform.roborockService === undefined)
+            return;
+        const homeData = await platform.roborockService.getHomeDataForUpdating(platform.rrHomeId);
+        await this.updateRobot(NotifyMessageTypes.HomeData, homeData);
+    }
+    async updateFromMQTTMessage(messageSource, messageData, duid = '', tracked = false) {
+        const platform = this.platform;
+        duid = duid || messageData?.duid || '';
+        const robot = platform.robots.get(duid);
+        if (robot === undefined) {
+            platform.log.error(`Error1: Robot with DUID ${duid} not found`);
+            return;
+        }
+        const deviceData = robot.device.data;
+        if (deviceData === undefined) {
+            platform.log.error('Device data is undefined');
+            return;
+        }
+        if (!tracked) {
+            platform.log.debug(`Receive: ${messageSource} updateFromMQTTMessage: ${debugStringify(messageData)}`);
+        }
+        if (!robot.serialNumber) {
+            platform.log.error('Robot serial number is undefined');
+            return;
+        }
+        switch (messageSource) {
+            case NotifyMessageTypes.ErrorOccurred: {
+                const message = messageData;
+                const operationalStateId = getOperationalErrorState(message.errorCode);
+                if (operationalStateId) {
+                    platform.log.error(`Error occurred: ${message.errorCode}`);
+                    robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', operationalStateId, platform.log);
+                }
+                break;
+            }
+            case NotifyMessageTypes.BatteryUpdate: {
+                const message = messageData;
+                const batteryLevel = message.percentage;
+                if (batteryLevel) {
+                    robot.updateAttribute(PowerSource.Cluster.id, 'batPercentRemaining', batteryLevel * 2, platform.log);
+                    robot.updateAttribute(PowerSource.Cluster.id, 'batChargeLevel', getBatteryStatus(batteryLevel), platform.log);
+                }
+                break;
+            }
+            case NotifyMessageTypes.LocalMessage: {
+                const data = messageData;
+                const robot = platform.robots.get(duid);
+                if (robot && data) {
+                    await handleLocalMessage(data, platform, duid);
+                    return;
+                }
+                platform.log.error(`Error2: Robot with DUID ${duid} not found`);
+                break;
+            }
+            case NotifyMessageTypes.CloudMessage: {
+                const data = messageData;
+                if (!data)
+                    return;
+                await handleCloudMessage(data, platform, this, duid);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+}

package/dist/roborockCommunication/RESTAPI/roborockAuthenticateApi.js

@@ -0,0 +1,213 @@
+import axios from 'axios';
+import crypto from 'node:crypto';
+import { URLSearchParams } from 'node:url';
+import { AuthenticateResponseCode } from '../Zenum/authenticateResponseCode.js';
+export class RoborockAuthenticateApi {
+    logger;
+    axiosFactory;
+    deviceId;
+    username;
+    authToken;
+    cachedBaseUrl;
+    cachedCountry;
+    cachedCountryCode;
+    configRegion;
+    constructor(logger, axiosFactory = axios, deviceId, configRegion) {
+        this.deviceId = deviceId ?? crypto.randomUUID();
+        this.axiosFactory = axiosFactory;
+        this.logger = logger;
+        this.configRegion = configRegion;
+    }
+    async loginWithUserData(username, userData) {
+        this.loginWithAuthToken(username, userData.token);
+        return userData;
+    }
+    async loginWithPassword(username, password) {
+        const api = await this.getAPIFor(username);
+        const response = await api.post('api/v1/login', new URLSearchParams({
+            username: username,
+            password: password,
+            needtwostepauth: 'false',
+        }).toString());
+        return this.auth(username, response.data);
+    }
+    async requestCodeV4(email) {
+        const api = await this.getAPIFor(email);
+        const response = await api.post('api/v4/email/code/send', new URLSearchParams({
+            email: email,
+            type: 'login',
+            platform: '',
+        }), {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+        });
+        const apiResponse = response.data;
+        if (apiResponse.code === AuthenticateResponseCode.AccountNotFound) {
+            throw new Error(`Account not found for email: ${email}`);
+        }
+        if (apiResponse.code === AuthenticateResponseCode.RateLimited) {
+            throw new Error('Rate limited. Please wait before requesting another code.');
+        }
+        if (apiResponse.code !== AuthenticateResponseCode.Success && apiResponse.code !== undefined) {
+            throw new Error(`Failed to send verification code: ${apiResponse.msg} (code: ${apiResponse.code})`);
+        }
+        this.logger.debug('Verification code requested successfully');
+    }
+    async loginWithCodeV4(email, code) {
+        const api = await this.getAPIFor(email);
+        const xMercyKs = this.generateRandomString(16);
+        const xMercyK = await this.signKeyV3(api, xMercyKs);
+        const response = await api.post('api/v4/auth/email/login/code', null, {
+            params: {
+                email: email,
+                code: code,
+                country: this.cachedCountry ?? '',
+                countryCode: this.cachedCountryCode ?? '',
+                majorVersion: '14',
+                minorVersion: '0',
+            },
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'x-mercy-ks': xMercyKs,
+                'x-mercy-k': xMercyK,
+                header_appversion: '4.54.02',
+                header_phonesystem: 'iOS',
+                header_phonemodel: 'iPhone16,1',
+            },
+        });
+        return this.authV4(email, response.data);
+    }
+    async getHomeDetails() {
+        if (!this.username || !this.authToken) {
+            return undefined;
+        }
+        const api = await this.getAPIFor(this.username);
+        const response = await api.get('api/v1/getHomeDetail');
+        const apiResponse = response.data;
+        if (!apiResponse.data) {
+            throw new Error('Failed to retrieve the home details');
+        }
+        return apiResponse.data;
+    }
+    getCachedCountryInfo() {
+        return {
+            country: this.cachedCountry,
+            countryCode: this.cachedCountryCode,
+        };
+    }
+    async getAPIFor(username) {
+        let baseUrl;
+        if (this.configRegion) {
+            baseUrl = this.getBaseUrlForRegion(this.configRegion);
+            this.logger.info(`Using configured region: ${this.configRegion}`);
+        }
+        else {
+            baseUrl = await this.getBaseUrl(username);
+            this.logger.info(`Auto-detected region from email`);
+        }
+        return this.apiForUser(username, baseUrl);
+    }
+    async getBaseUrl(username) {
+        if (this.cachedBaseUrl && this.username === username) {
+            return this.cachedBaseUrl;
+        }
+        const api = await this.apiForUser(username);
+        const response = await api.post('api/v1/getUrlByEmail', new URLSearchParams({
+            email: username,
+            needtwostepauth: 'false',
+        }).toString());
+        const apiResponse = response.data;
+        if (!apiResponse.data) {
+            throw new Error('Failed to retrieve base URL: ' + apiResponse.msg);
+        }
+        this.cachedBaseUrl = apiResponse.data.url;
+        this.cachedCountry = apiResponse.data.country;
+        this.cachedCountryCode = apiResponse.data.countrycode;
+        this.username = username;
+        return apiResponse.data.url;
+    }
+    getBaseUrlForRegion(region) {
+        const regionUrls = {
+            'eu': 'https://euiot.roborock.com',
+            'us': 'https://usiot.roborock.com',
+            'cn': 'https://iotcn.roborock.com',
+        };
+        return regionUrls[region.toLowerCase()] || regionUrls['us'];
+    }
+    async apiForUser(username, baseUrl = 'https://usiot.roborock.com') {
+        const instance = this.axiosFactory.create({
+            baseURL: baseUrl,
+            headers: {
+                header_clientid: crypto.createHash('md5').update(username).update(this.deviceId).digest('base64'),
+                Authorization: this.authToken,
+                header_clientlang: 'en',
+            },
+        });
+        instance.interceptors.request.use((config) => {
+            this.logger.debug('=== HTTP Request ===');
+            this.logger.debug(`URL: ${config.baseURL}/${config.url}`);
+            this.logger.debug(`Method: ${config.method?.toUpperCase()}`);
+            this.logger.debug(`Params: ${JSON.stringify(config.params)}`);
+            this.logger.debug(`Data: ${JSON.stringify(config.data)}`);
+            this.logger.debug(`Headers: ${JSON.stringify(config.headers)}`);
+            return config;
+        });
+        instance.interceptors.response.use((response) => {
+            this.logger.debug('=== HTTP Response ===');
+            this.logger.debug(`Status: ${response.status}`);
+            this.logger.debug(`Data: ${JSON.stringify(response.data)}`);
+            return response;
+        }, (error) => {
+            this.logger.debug('=== HTTP Error ===');
+            this.logger.debug(`Error: ${JSON.stringify(error.response?.data ?? error.message)}`);
+            return Promise.reject(error);
+        });
+        return instance;
+    }
+    auth(username, response) {
+        const userdata = response.data;
+        if (!userdata || !userdata.token) {
+            throw new Error('Authentication failed: ' + response.msg + ' code: ' + response.code);
+        }
+        this.loginWithAuthToken(username, userdata.token);
+        return userdata;
+    }
+    authV4(email, response) {
+        if (response.code === AuthenticateResponseCode.InvalidCode) {
+            throw new Error('Invalid verification code. Please check and try again.');
+        }
+        if (response.code === AuthenticateResponseCode.RateLimited) {
+            throw new Error('Rate limited. Please wait before trying again.');
+        }
+        const userdata = response.data;
+        if (!userdata || !userdata.token) {
+            throw new Error('Authentication failed: ' + response.msg + ' code: ' + response.code);
+        }
+        this.loginWithAuthToken(email, userdata.token);
+        return userdata;
+    }
+    loginWithAuthToken(username, token) {
+        this.username = username;
+        this.authToken = token;
+    }
+    generateRandomString(length) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let result = '';
+        const randomBytes = crypto.randomBytes(length);
+        for (let i = 0; i < length; i++) {
+            result += chars[randomBytes[i] % chars.length];
+        }
+        return result;
+    }
+    async signKeyV3(api, s) {
+        const response = await api.post('api/v3/key/sign', null, {
+            params: { s },
+        });
+        const apiResponse = response.data;
+        if (!apiResponse.data?.k) {
+            throw new Error('Failed to sign key: ' + apiResponse.msg);
+        }
+        return apiResponse.data.k;
+    }
+}