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

package/web-for-testing/package.json

@@ -0,0 +1,36 @@
+{
+    "name": "web",
+    "version": "1.0.0",
+    "description": "",
+    "main": "/src/app.ts",
+    "scripts": {
+        "copy-src": "cd src && rm -rf ext && cd .. && cpx '../src/**/!(*.test).ts' src/ext/",
+        "build": "rm -rf dist && tsc",
+        "start": "node dist/app.js",
+        "dev": "node watch.mjs",
+        "dont-run:dev:simple": "npm run build && node dist/app.js",
+        "dont-run:dev:watch": "while true; do npm run build && node dist/app.js; echo 'Restarting in 2 seconds...'; sleep 2; done",
+        "dont-run:dev:build": "nodemon --watch src --ext ts --exec \"npm run build && node dist/app.js\"",
+        "dont-run:dev:macos": "osascript -e 'tell application \"Terminal\" to do script \"cd /Users/rinnguyen/Data/vscode/matterbridge-roborock-vacuum-plugin/webui && npm run dev\"'"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "type": "module",
+    "dependencies": {
+        "binary-parser": "^2.2.1",
+        "ejs": "^3.1.10",
+        "express": "^5.1.0",
+        "matterbridge": "^3.1.8",
+        "node-ansi-logger": "^3.0.1"
+    },
+    "devDependencies": {
+        "@types/express": "^5.0.2",
+        "@types/node": "^22.15.21",
+        "cpx": "^1.5.0",
+        "nodemon": "^3.1.10",
+        "ts-node": "^10.9.2",
+        "tsx": "^4.19.4",
+        "typescript": "^5.8.3"
+    }
+}

package/web-for-testing/src/app.ts

@@ -0,0 +1,194 @@
+import express, { Request, Response } from 'express';
+import RoborockService from './ext/roborockService.js';
+import ClientManager from './ext/clientManager.js';
+import { AnsiLogger, LogLevel } from 'node-ansi-logger';
+import { Device, RequestMessage, RoborockAuthenticateApi, RoborockIoTApi, UserData } from './ext/roborockCommunication/index.js';
+import axios from 'axios';
+import { Socket } from 'net';
+import { getAccountStore } from './accountStore.js';
+
+// Handle unhandled promise rejections
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Promise Rejection at:', promise, 'reason:', reason);
+  // Application specific logging, throwing an error, or other logic here
+});
+
+// Handle uncaught exceptions
+process.on('uncaughtException', (error) => {
+  console.error('Uncaught Exception:', error);
+  // Application specific logging, throwing an error, or other logic here
+});
+
+const app = express();
+const port = 3000;
+const log = new AnsiLogger({ logName: 'Main', logLevel: LogLevel.DEBUG });
+
+var roborockService: RoborockService;
+var clientManager: ClientManager;
+var userData: UserData;
+const devices: Device[] = [];
+var usname: string;
+var connected = true;
+var connectedDUID = '';
+var isConnected = false;
+
+//--------------------------
+app.set('view engine', 'ejs');
+app.use(express.static('public'));
+app.use(express.json());
+
+app.get('/', (req: Request, res: Response) => {
+  res.render('index', { title: 'My Express WebUI' });
+});
+
+app.post('/login', async (req: Request, res: Response) => {
+  const { username, password } = req.body;
+  console.warn(`Login attempt with username: ${username}, password: ${password}`);
+  if (!username) {
+    res.json({ error: 'Username are required' });
+    return;
+  }
+  axios.interceptors.request.use((request: any) => {
+    log.notice('Axios Request:', {
+      method: request.method,
+      url: request.url,
+      data: request.data,
+      headers: request.headers,
+    });
+    return request;
+  });
+
+  axios.interceptors.response.use((response: any) => {
+    log.notice('Axios Response:', {
+      status: response.status,
+      data: response.data,
+      headers: response.headers,
+      url: response.config.url,
+    });
+    return response;
+  });
+
+  clientManager = new ClientManager(log);
+  roborockService = new RoborockService(
+    () => new RoborockAuthenticateApi(log, axios),
+    (logger, ud) => new RoborockIoTApi(ud, logger),
+    60,
+    clientManager,
+    log,
+  );
+
+  const userDataMap = getAccountStore();
+  const selectedUserData = userDataMap.get(username);
+  console.warn(`Selected user data for ${username}:`, JSON.stringify(selectedUserData));
+
+  try {
+    userData = await roborockService.loginWithPassword(
+      username,
+      password,
+      async () => {
+        return password.length > 0 ? undefined : selectedUserData;
+      },
+      async (userData) => {
+        console.warn('User data received:', JSON.stringify(userData));
+      },
+    );
+
+    const dvs = await roborockService.listDevices(username);
+
+    devices.push(...dvs);
+
+    isConnected = false;
+
+    if (userData) {
+      usname = username;
+      res.json({ success: true, devices: dvs, userData });
+    } else {
+      res.json({ success: false, error: 'Invalid username or password' });
+    }
+  } catch (error) {
+    res.json({ success: false, error });
+  }
+});
+
+app.post('/run', async (req: Request, res: Response) => {
+  const { duid, command, props, secure, userData1, device1 } = req.body;
+  if (!duid || !command) {
+    res.json({ error: 'Nothing to do' });
+    return;
+  }
+  let device = devices.find((x) => x.duid == duid);
+  if (!device) {
+    res.json({ result: `device not found` });
+    return;
+  }
+
+  if (!isConnected) {
+    if (connected && duid != connectedDUID && roborockService) {
+      roborockService.stopService();
+    }
+
+    await roborockService.initializeMessageClient(usname, device, userData);
+
+    roborockService.setDeviceNotify(async (messageSource, homeData) => {
+      console.warn(`${messageSource}: ${JSON.stringify(homeData)}`);
+    });
+    await roborockService.initializeMessageClientForLocal(device);
+
+    roborockService.activateDeviceNotify(device);
+
+    connected = true;
+    connectedDUID = duid;
+    isConnected = true;
+  }
+
+  // const map_info = await roborockService.getMapInformation(duid);
+  // const rooms = map_info?.maps?.[0]?.rooms ?? [];
+  // console.warn(`Rooms: ${JSON.stringify(rooms)}`);
+
+  //const xx = await roborockService.getRoomIdFromMap(duid);
+  //console.warn(`Room ID: ${xx}`);
+
+  const data = await roborockService.customGet(duid, new RequestMessage({ method: command, params: props, secure }));
+  res.json({ command, data, secure: false });
+});
+
+app.post('/try-connect', async (req: Request, res: Response) => {
+  const ip = req.body.ip ?? '192.168.202.65';
+  const port = 58867;
+  const socket = new Socket();
+  socket.on('connect', () => {
+    console.log(ip, 'Connected!');
+    setTimeout(() => socket.end(), 3000);
+  });
+  socket.on('error', (err) => {
+    console.error(ip, 'Error:', err);
+  });
+  socket.connect(port, ip);
+  res.json({ result: `ok` });
+});
+
+app.post('/disconnect', async (req: Request, resp: Response) => {
+  roborockService.stopService();
+
+  resp.json({
+    success: true,
+  });
+});
+
+app.post('/call-api', async (req: Request, resp: Response) => {
+  const { api } = req.body;
+  if (!api) {
+    resp.json({ error: 'API is required' });
+    return;
+  }
+
+  const result = await roborockService.getCustomAPI(api);
+  resp.json({
+    success: true,
+    result,
+  });
+});
+
+app.listen(port, () => {
+  console.log(`WebUI listening at http://localhost:${port}`);
+});

package/web-for-testing/tsconfig-ext.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "lib": [
+            "ESNext"
+        ],
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "esModuleInterop": true,
+        "moduleDetection": "force",
+        "forceConsistentCasingInFileNames": true,
+        "strict": true,
+        "skipLibCheck": true,
+        "outDir": "dist"
+    },
+    "include": [
+        "src/**/*.ts"
+    ]
+}

package/web-for-testing/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": [
+      "ESNext"
+    ],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "moduleDetection": "force",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "sourceMap": true,
+    "inlineSources": true,
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": [
+    "src/**/*.ts"
+  ]
+}

package/web-for-testing/views/index.ejs

@@ -0,0 +1,172 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <title>
+        <%= title %>
+    </title>
+    <link rel="stylesheet" href="/style.css">
+</head>
+
+<body>
+    <h1>
+        <%= title %>
+    </h1>
+
+    <!-- Login Section -->
+    <section id="loginSection">
+        <h2>Login</h2>
+        <input type="text" id="username" placeholder="Username" value="abc@gmail.com" />
+        <input type="text" id="password" placeholder="Password" value="abc" />
+        <button id="loginBtn">Login</button>
+        <span id="loginStatus"></span>
+        <br><br>
+
+    </section>
+    <section id="tryToConnect">
+        <h2>Socket test</h2>
+        <br>
+        <label for="tryConnectIp">IP to try connect:</label>
+        <input type="text" id="tryConnectIp" placeholder="192.168.202.65" />
+        <button id="tryConnectBtn">Try to Connect</button>
+        <br>
+    </section>
+
+    <!-- Search Section -->
+    <section id="execute-command">
+        <h2>Execute Command</h2>
+        <input type="text" id="duid" placeholder="duid" />
+        <input type="text" id="command" placeholder="command" value="get_prop" />
+        <input type="text" id="props" placeholder="props" value='["battery"]' />
+        <label for="secure">Secure?: </label>
+        <input type="checkbox" id="secure" />
+        <button id="executeCommand">Submit</button>
+        <button id="disconnectBtn" style="margin-left:10px;">Disconnect</button>
+        <br>
+    </section>
+
+    <section id="execute-api">
+        <h2>Execute API</h2>
+        <input type="text" id="api" placeholder="api" value="user/homes/yourHomeId" />
+        <button id="executeAPI">Submit</button>
+        <br>
+    </section>
+    <section id="result">
+        <pre id="resultId" style="background:#f5f5f5;padding:10px;"></pre>
+    </section>
+    <script>
+        document.getElementById('executeAPI').onclick = async function () {
+            // Show spinner and clear result
+            let resultArea = document.getElementById('resultId');
+            // Remove old spinner if exists
+            let oldSpinner = document.getElementById('submitSpinner');
+            if (oldSpinner) oldSpinner.remove();
+            // Insert spinner above resultArea
+            let spinner = document.createElement('div');
+            spinner.id = 'submitSpinner';
+            spinner.innerHTML = '🔄 Processing...';
+            resultArea.parentNode.insertBefore(spinner, resultArea);
+            resultArea.textContent = '';
+            const api = document.getElementById('api').value;
+
+            const response = await fetch('/call-api', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ api })
+            });
+            const data = await response.json();
+            spinner.remove();
+            resultArea.innerHTML =
+                'result = <pre>' + JSON.stringify(data, null, 2) + '</pre><br>';
+        };
+
+        // Login handler
+        document.getElementById('loginBtn').onclick = async function () {
+            // Clear previous result and show spinner
+            const loginResult = document.getElementById('resultId');
+            loginResult.textContent = '';
+            loginResult.innerHTML = '<span id="loginSpinner">🔄 Logging in...</span>';
+
+            const username = document.getElementById('username').value;
+            const password = document.getElementById('password').value;
+            const response = await fetch('/login', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ username, password })
+            });
+            const data = await response.json();
+            document.getElementById('loginStatus').textContent = data.success ? 'Login successful!' : (data.error || 'Login failed');
+
+            // Hide spinner and show result
+            if (data.success) {
+                loginResult.innerHTML =
+                    'devices = <pre>' + JSON.stringify(data.devices, null, 2) + '</pre><br>' +
+                    'userData = <pre>' + JSON.stringify(data.userData, null, 2) + '</pre>';
+            } else {
+                loginResult.innerHTML =
+                    'error = <pre>' + JSON.stringify(data.error, null, 2) + '</pre>';
+            }
+        };
+
+        // Search handler
+        document.getElementById('executeCommand').onclick = async function () {
+            // Show spinner and clear result
+            let resultArea = document.getElementById('resultId');
+            // Remove old spinner if exists
+            let oldSpinner = document.getElementById('submitSpinner');
+            if (oldSpinner) oldSpinner.remove();
+            // Insert spinner above resultArea
+            let spinner = document.createElement('div');
+            spinner.id = 'submitSpinner';
+            spinner.innerHTML = '🔄 Processing...';
+            resultArea.parentNode.insertBefore(spinner, resultArea);
+            resultArea.textContent = '';
+
+            const duid = document.getElementById('duid').value;
+            const command = document.getElementById('command').value;
+            const props = document.getElementById('props').value;
+            const secure = document.getElementById('secure').checked;
+            const userData = document.getElementById('userDataField') ? document.getElementById('userDataField').value : '';
+            const device = document.getElementById('deviceField') ? document.getElementById('deviceField').value : '';
+
+            const response = await fetch('/run', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ duid, command, props, secure, userData1: userData, device1: device })
+            });
+            const data = await response.json();
+            // Remove spinner after response
+            spinner.remove();
+            resultArea.innerHTML =
+                'command = ' + data.command + '</pre><br>' +
+                'secure = ' + data.secure + '</pre><br>' +
+                'result = <pre>' + JSON.stringify(data.data, null, 2) + '</pre><br>';
+        };
+
+        document.getElementById('disconnectBtn').onclick = async function () {
+            const response = await fetch('/disconnect', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' }
+            });
+            const data = await response.json();
+            document.getElementById('resultId').textContent = data.success ? 'Disconnected!' : 'Disconnect failed!';
+        };
+
+        document.getElementById('tryConnectBtn').onclick = async function () {
+            const ip = document.getElementById('tryConnectIp').value;
+            if (!ip) {
+                document.getElementById('resultId').textContent = 'Please enter an IP address!';
+                return;
+            }
+            const response = await fetch('/try-connect', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ ip })
+            });
+            const data = await response.json();
+            document.getElementById('resultId').textContent = data.result || data.error || '';
+        };
+    </script>
+</body>
+
+</html>

package/web-for-testing/watch.mjs

@@ -0,0 +1,93 @@
+import { spawn } from 'child_process';
+import { watch } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+let isBuilding = false;
+let currentProcess = null;
+
+function debounce(func, wait) {
+  let timeout;
+  return function executedFunction(...args) {
+    const later = () => {
+      clearTimeout(timeout);
+      func(...args);
+    };
+    clearTimeout(timeout);
+    timeout = setTimeout(later, wait);
+  };
+}
+
+function killCurrentProcess() {
+  if (currentProcess && !currentProcess.killed) {
+    currentProcess.kill('SIGINT');
+    currentProcess = null;
+  }
+}
+
+function buildAndRun() {
+  if (isBuilding) return;
+
+  isBuilding = true;
+  killCurrentProcess();
+
+  console.log('\n🔄 Building...');
+
+  const buildProcess = spawn('npm', ['run', 'build'], {
+    cwd: __dirname,
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  buildProcess.on('close', (code) => {
+    isBuilding = false;
+    if (code === 0) {
+      console.log('✅ Build successful, starting app...');
+      currentProcess = spawn('node', ['dist/app.js'], {
+        cwd: __dirname,
+        stdio: 'inherit',
+        shell: true,
+      });
+
+      currentProcess.on('close', (appCode) => {
+        if (appCode !== 0 && appCode !== null) {
+          console.log(`❌ App exited with code ${appCode}`);
+        }
+      });
+    } else {
+      console.log(`❌ Build failed with code ${code}`);
+    }
+  });
+}
+
+// Initial build and run
+buildAndRun();
+
+// Watch for file changes
+const debouncedBuildAndRun = debounce(buildAndRun, 500);
+
+console.log('👀 Watching src/ directory for changes...');
+
+const watcher = watch(path.join(__dirname, 'src'), { recursive: true }, (eventType, filename) => {
+  if (filename && filename.endsWith('.ts')) {
+    console.log(`📝 File changed: ${filename}`);
+    debouncedBuildAndRun();
+  }
+});
+
+// Handle process termination
+process.on('SIGINT', () => {
+  console.log('\n🛑 Stopping watcher...');
+  watcher.close();
+  killCurrentProcess();
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  console.log('\n🛑 Stopping watcher...');
+  watcher.close();
+  killCurrentProcess();
+  process.exit(0);
+});