homebridge-openwrt-control 0.0.2-beta.8 → 0.0.2-beta.9

package/package.json

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

package/src/openwrt.js

@@ -1,110 +1,76 @@
-import EventEmitter from 'events';
-import axios from 'axios';
-import Functions from './functions.js';
-import ImpulseGenerator from './impulsegenerator.js';
+import EventEmitter from "events";
+import { exec } from "child_process";
+import Functions from "./functions.js";
+import ImpulseGenerator from "./impulsegenerator.js";
 
 class OpenWrt extends EventEmitter {
     constructor(config) {
         super();
 
-        this.user = config.auth?.user;
-        this.passwd = config.auth?.passwd;
+        this.host = config.host;
+        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'
-            }
-        });
 
         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;
         }
     }
 
-    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 }]
+    // --- Helper do wywołań SSH ---
+    async sshCall(command) {
+        return new Promise((resolve, reject) => {
+            const sshCmd = `ssh ${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}`));
+                }
+            });
         });
-
-        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 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];
+        const cmd = `ubus call ${service} ${method} '${JSON.stringify(params)}'`;
+        return await this.sshCall(cmd);
     }
 
+    // --- 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', `System info data: ${JSON.stringify(systemInfo, null, 2)}`);
+            const systemInfo = await this.ubusCall("system", "board");
+            if (this.logDebug) this.emit("debug", `[${this.host}] System info: ${JSON.stringify(systemInfo, 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 wirelessStatus = await this.ubusCall("network.wireless", "status");
+            if (this.logDebug) this.emit("debug", `[${this.host}] Wireless status: ${JSON.stringify(wirelessStatus, null, 2)}`);
 
             const wirelessRadios = Object.values(wirelessStatus.radios).map(radio => ({
                 name: radio.name,
@@ -117,13 +83,14 @@ 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;
             }
 
@@ -133,14 +100,44 @@ class OpenWrt extends EventEmitter {
             openWrtInfo.wirelessRadios = wirelessRadios;
             openWrtInfo.ssids = ssids;
 
-            if (this.logDebug) this.emit('debug', `OpenWrt Data: ${JSON.stringify(openWrtInfo, null, 2)}`);
+            if (this.logDebug) this.emit("debug", `[${this.host}] OpenWrt Data: ${JSON.stringify(openWrtInfo, null, 2)}`);
             return openWrtInfo;
         } catch (error) {
-            if (this.logError) this.emit('error', `Connect error: ${error.message}`);
+            if (this.logError) this.emit("error", `[${this.host}] Connect error: ${error.message}`);
             return openWrtInfo;
         }
     }
 
+    // --- Włączanie / wyłączanie SSID ---
+    async send(type, ssidName, state) {
+        switch (type) {
+            case "ssid":
+                await this.handleWithLock(async () => {
+                    if (this.logDebug) this.emit("debug", `[${this.host}] ${state ? "Enabling" : "Disabling"} SSID ${ssidName}`);
+
+                    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", {});
+
+                    if (this.logDebug) this.emit("debug", `[${this.host}] SSID ${ssidName} ${state ? "enabled" : "disabled"}`);
+                });
+                break;
+            case "switch":
+                break;
+        }
+    }
+
     async send(type, ssidName, state) {
         switch (type) {
             case 'ssid':