homebridge-openwrt-control 0.0.2-beta.10 → 0.0.2-beta.12

package/config.schema.json

@@ -4,7 +4,7 @@
   "singular": true,
   "fixArrays": true,
   "strictValidation": true,
-  "headerDisplay": "This plugin works with OpenWrt Devices based on Dashboard API. Devices are exposed to HomeKit as separate accessories and each needs to be manually paired.",
+  "headerDisplay": "This plugin works with OpenWrt flashed devices. Devices are exposed to HomeKit as separate accessories and each needs to be manually paired.",
   "footerDisplay": "For documentation please see [GitHub repository](https://github.com/grzegorz914/homebridge-openwrt-control).",
   "schema": {
     "type": "object",

package/package.json

@@ -1,7 +1,7 @@
 {
     "displayName": "OpenWrt Control",
     "name": "homebridge-openwrt-control",
-    "version": "0.0.2-beta.10",
+    "version": "0.0.2-beta.12",
     "description": "Homebridge plugin to control OpenWrt flashed devices.",
     "license": "MIT",
     "author": "grzegorz914",

package/src/openwrt.js

@@ -1,76 +1,111 @@
-import EventEmitter from "events";
-import { exec } from "child_process";
-import Functions from "./functions.js";
-import ImpulseGenerator from "./impulsegenerator.js";
+import EventEmitter from 'events';
+import axios from 'axios';
+import Functions from './functions.js';
+import ImpulseGenerator from './impulsegenerator.js';
 
 class OpenWrt extends EventEmitter {
     constructor(config) {
         super();
 
-        this.host = config.host;
-        this.user = config.auth?.user || "root";
-        this.passwd = config.auth?.passwd || "";
-
+        this.user = config.auth?.user || 'root';
+        this.passwd = config.auth?.passwd;
         this.logError = config.log?.error;
         this.logDebug = config.log?.debug;
 
+        //external integration
+        this.restFulEnabled = config.restFul?.enable || false;
+        this.mqttEnabled = config.mqtt?.enable || false;
+
         this.firstRun = true;
         this.lock = false;
 
+        this.sessionId = null;
+        this.sessionExpiresAt = 0;
+
         this.functions = new Functions();
+        this.axiosInstance = axios.create({
+            baseURL: `http://${config.host}/ubus`,
+            timeout: 5000,
+            headers: {
+                "Content-Type": "application/json",
+                "Accept": "application/json"
+            }
+        });
 
         this.impulseGenerator = new ImpulseGenerator()
-            .on("connect", () => this.handleWithLock(async () => {
+            .on('connect', () => this.handleWithLock(async () => {
                 await this.connect();
             }))
-            .on("state", (state) => {
-                this.emit(state ? "success" : "warn", `Impulse generator ${state ? "started" : "stopped"}`);
+            .on('state', (state) => {
+                this.emit(state ? 'success' : 'warn', `Impulse generator ${state ? 'started' : 'stopped'}`);
             });
     }
 
     async handleWithLock(fn) {
         if (this.lock) return;
         this.lock = true;
+
         try {
             await fn();
         } catch (error) {
-            this.emit("error", `Impulse generator error: ${error.message}`);
+            this.emit('error', `Impulse generator error: ${error.message}`
+            );
         } finally {
             this.lock = false;
         }
     }
 
-    // --- Helper do wywołań SSH z wyłączeniem StrictHostKeyChecking ---
-    async sshCall(command) {
-        return new Promise((resolve, reject) => {
-            const sshCmd = `ssh -o StrictHostKeyChecking=no ${this.user}@${this.host} '${command.replace(/'/g, `'\\''`)}'`;
-            exec(sshCmd, (error, stdout, stderr) => {
-                if (error) return reject(new Error(stderr || error.message));
-                try {
-                    const json = JSON.parse(stdout);
-                    resolve(json);
-                } catch (parseError) {
-                    reject(new Error(`Invalid JSON from SSH: ${parseError.message}`));
-                }
-            });
+    async login() {
+        const now = Date.now();
+        if (this.sessionId && now < this.sessionExpiresAt) {
+            return this.sessionId;
+        }
+
+        const response = await this.axiosInstance.post('', {
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'call',
+            params: ['00000000000000000000000000000000', 'session', 'login', { username: this.user, password: this.passwd }]
         });
+
+        const result = response.data?.result?.[1];
+        if (!result?.ubus_rpc_session) {
+            throw new Error('ubus login failed');
+        }
+
+        this.sessionId = result.ubus_rpc_session;
+        this.sessionExpiresAt = now + 240_000;
+
+        if (this.logDebug) this.emit('debug', `Ubus login OK`);
+        return this.sessionId;
     }
 
-    // --- ubus call przez SSH ---
     async ubusCall(service, method, params = {}) {
-        const cmd = `ubus call ${service} ${method} '${JSON.stringify(params)}'`;
-        return await this.sshCall(cmd);
+        const session = await this.login();
+
+        const response = await this.axiosInstance.post('', {
+            jsonrpc: '2.0',
+            id: 2,
+            method: 'call',
+            params: [session, service, method, params]
+        });
+
+        if (response.data?.error) {
+            throw new Error(response.data.error.message || 'ubus call error');
+        }
+
+        return response.data.result[1];
     }
 
-    // --- Pobranie info i statusu ---
     async connect() {
-        const openWrtInfo = { state: false, systemInfo: {}, wirelessStatus: {}, wirelessRadios: [], ssids: [] };
+        const openWrtInfo = { state: false, systemInfo: {}, wirelessStatus: {}, wirelessRadios: [], ssids: [] }
+
         try {
-            const systemInfo = await this.ubusCall("system", "board");
-            if (this.logDebug) this.emit("debug", `[${this.host}] System info: ${JSON.stringify(systemInfo, null, 2)}`);
+            const systemInfo = await this.ubusCall('system', 'board');
+            if (this.logDebug) this.emit('debug', `System info data: ${JSON.stringify(systemInfo, null, 2)}`);
 
-            const wirelessStatus = await this.ubusCall("network.wireless", "status");
-            if (this.logDebug) this.emit("debug", `[${this.host}] Wireless status: ${JSON.stringify(wirelessStatus, null, 2)}`);
+            const wirelessStatus = await this.ubusCall('network.wireless', 'status');
+            if (this.logDebug) this.emit('debug', `Wireless status data: ${JSON.stringify(wirelessStatus, null, 2)}`);
 
             const wirelessRadios = Object.values(wirelessStatus.radios).map(radio => ({
                 name: radio.name,
@@ -83,14 +118,13 @@ class OpenWrt extends EventEmitter {
             }));
 
             const ssids = wirelessRadios.flatMap(radio => radio.interfaces);
-
-            this.emit("systemInfo", systemInfo);
-            this.emit("wirelessStatus", wirelessStatus);
-            this.emit("wirelessRadios", wirelessRadios);
-            this.emit("ssids", ssids);
+            this.emit('systemInfo', systemInfo);
+            this.emit('wirelessStatus', wirelessStatus);
+            this.emit('wirelessRadios', wirelessRadios);
+            this.emit('ssids', ssids);
 
             if (this.firstRun) {
-                this.emit("success", `Connect success`);
+                this.emit('success', `Connect success`);
                 this.firstRun = false;
             }
 
@@ -100,40 +134,44 @@ class OpenWrt extends EventEmitter {
             openWrtInfo.wirelessRadios = wirelessRadios;
             openWrtInfo.ssids = ssids;
 
-            if (this.logDebug) this.emit("debug", `[${this.host}] OpenWrt Data: ${JSON.stringify(openWrtInfo, null, 2)}`);
+            if (this.logDebug) this.emit('debug', `OpenWrt Data: ${JSON.stringify(openWrtInfo, null, 2)}`);
             return openWrtInfo;
         } catch (error) {
-            if (this.logError) this.emit("error", `[${this.host}] Connect error: ${error.message}`);
+            if (this.logError) this.emit('error', `Connect error: ${error.message}`);
             return openWrtInfo;
         }
     }
 
-    // --- Włączanie / wyłączanie SSID ---
     async send(type, ssidName, state) {
         switch (type) {
-            case "ssid":
+            case 'ssid':
                 await this.handleWithLock(async () => {
-                    if (this.logDebug) this.emit("debug", `[${this.host}] ${state ? "Enabling" : "Disabling"} SSID ${ssidName}`);
+                    if (this.logDebug) this.emit('debug', `${state ? 'Enabling' : 'Disabling'} SSID ${ssidName}`);
 
-                    const status = await this.ubusCall("network.wireless", "status");
+                    const status = await this.ubusCall('network.wireless', 'status');
                     const iface = await this.functions.findIfaceBySsid(status, ssidName);
                     if (!iface) throw new Error(`SSID ${ssidName} not found`);
 
                     const section = iface.section;
                     if (!section) throw new Error(`No UCI section for SSID ${ssidName}`);
 
-                    await this.ubusCall("uci", "set", {
-                        config: "wireless",
-                        section: section,
-                        values: { disabled: state ? "0" : "1" }
-                    });
-                    await this.ubusCall("uci", "commit", { config: "wireless" });
-                    await this.ubusCall("network.wireless", "reload", {});
+                    await this.ubusCall('uci', 'set',
+                        {
+                            config: 'wireless',
+                            section: section,
+                            values: {
+                                disabled: state ? '0' : '1'
+                            }
+                        }
+                    );
 
-                    if (this.logDebug) this.emit("debug", `[${this.host}] SSID ${ssidName} ${state ? "enabled" : "disabled"}`);
+                    await this.ubusCall('uci', 'commit', { config: 'wireless' });
+                    await this.ubusCall('network.wireless', 'reload', {});
+
+                    if (this.logDebug) this.emit('debug', `Send SSID ${ssidName} ${state ? 'enabled' : 'disabled'}`);
                 });
                 break;
-            case "switch":
+            case 'switch':
                 break;
         }
     }
@@ -141,4 +179,3 @@ class OpenWrt extends EventEmitter {
 
 export default OpenWrt;
 
-