homebridge-openwrt-control 0.0.1-beta.0

package/src/apdevice.js

@@ -0,0 +1,247 @@
+import EventEmitter from 'events';
+let Accessory, Characteristic, Service, Categories, AccessoryUUID;
+
+class AccessPointDevice extends EventEmitter {
+    constructor(api, config, openWrt, openWrtInfo) {
+        super();
+
+        Accessory = api.platformAccessory;
+        Characteristic = api.hap.Characteristic;
+        Service = api.hap.Service;
+        Categories = api.hap.Categories;
+        AccessoryUUID = api.hap.uuid;
+
+        //config
+        this.name = config.name;
+        this.accessPoint = config.accessPoint;
+        this.logInfo = config.log?.info || false;
+        this.logDebug = config.log?.debug || false;
+
+        //external integration
+        this.restFul = config.restFul || {};
+        this.restFulConnected = false;
+        this.mqtt = config.mqtt || {};
+        this.mqttConnected = false;
+
+        //openwrt
+        this.openWrt = openWrt;
+        this.openWrtInfo = openWrtInfo;
+        this.ssids = openWrtInfo.ssids;
+    };
+
+    async externalIntegrations() {
+        //RESTFul server
+        const restFulEnabled = this.restFul.enable || false;
+        if (restFulEnabled) {
+            try {
+                this.restFul1 = new RestFul({
+                    port: this.restFul.port || 3000,
+                    logWarn: this.logWarn,
+                    logDebug: this.logDebug
+                })
+                    .on('connected', (message) => {
+                        this.emit('success', message);
+                        this.restFulConnected = true;
+                    })
+                    .on('set', async (key, value) => {
+                        try {
+                            await this.setOverExternalIntegration('RESTFul', key, value);
+                        } catch (error) {
+                            this.emit('warn', `RESTFul set error: ${error}`);
+                        };
+                    })
+                    .on('debug', (debug) => this.emit('debug', debug))
+                    .on('warn', (warn) => this.emit('warn', warn))
+                    .on('error', (error) => this.emit('error', error));
+            } catch (error) {
+                this.emit('warn', `RESTFul integration start error: ${error}`);
+            };
+        }
+
+        //mqtt client
+        const mqttEnabled = this.mqtt.enable || false;
+        if (mqttEnabled) {
+            try {
+                this.mqtt1 = new Mqtt({
+                    host: this.mqtt.host,
+                    port: this.mqtt.port || 1883,
+                    clientId: this.mqtt.clientId ? `${this.savedInfo.manufacturer}_${this.mqtt.clientId}_${Math.random().toString(16).slice(3)}` : `${this.savedInfo.manufacturer}_${Math.random().toString(16).slice(3)}`,
+                    prefix: this.mqtt.prefix ? `${this.savedInfo.manufacturer}/${this.mqtt.prefix}/${this.name}` : `${this.savedInfo.manufacturer}/${this.name}`,
+                    user: this.mqtt.auth?.user,
+                    passwd: this.mqtt.auth?.passwd,
+                    logWarn: this.logWarn,
+                    logDebug: this.logDebug
+                })
+                    .on('connected', (message) => {
+                        this.emit('success', message);
+                        this.mqttConnected = true;
+                    })
+                    .on('subscribed', (message) => {
+                        this.emit('success', message);
+                    })
+                    .on('set', async (key, value) => {
+                        try {
+                            await this.setOverExternalIntegration('MQTT', key, value);
+                        } catch (error) {
+                            this.emit('warn', `MQTT set error: ${error}`);
+                        }
+                    })
+                    .on('debug', (debug) => this.emit('debug', debug))
+                    .on('warn', (warn) => this.emit('warn', warn))
+                    .on('error', (error) => this.emit('error', error));
+            } catch (error) {
+                this.emit('warn', `MQTT integration start error: ${error}`);
+            };
+        }
+
+        return true;
+    }
+
+    async setOverExternalIntegration(integration, key, value) {
+        try {
+            let set = false
+            switch (key) {
+                case 'Power':
+                    const powerState = value ? 'ON' : 'OFF';
+                    set = await this.openWrt.send('Power', powerState);
+                    break;
+                default:
+                    this.emit('warn', `${integration}, received key: ${key}, value: ${value}`);
+                    break;
+            }
+            return set;
+        } catch (error) {
+            throw new Error(`${integration} set key: ${key}, value: ${value}, error: ${error}`);
+        }
+    }
+
+    //prepare accessory
+    async prepareAccessory() {
+        try {
+            //prepare accessory
+            if (this.logDebug) this.emit('debug', `prepare accessory`);
+            const accessoryName = this.name;
+            const accessoryUUID = AccessoryUUID.generate(this.deviceUuid);
+            const accessoryCategory = Categories.AIRPORT;
+            const accessory = new Accessory(accessoryName, accessoryUUID, accessoryCategory);
+
+            //prepare information service
+            if (this.logDebug) this.emit('debug', `prepare information service`);
+            accessory.getService(Service.AccessoryInformation)
+                .setCharacteristic(Characteristic.Manufacturer, 'OpenWrt')
+                .setCharacteristic(Characteristic.Model, accessoryName)
+                .setCharacteristic(Characteristic.SerialNumber, this.networkId)
+                .setCharacteristic(Characteristic.FirmwareRevision, this.organizationId)
+                .setCharacteristic(Characteristic.ConfiguredName, accessoryName);
+
+            if (this.logDebug) this.emit('debug', `prepare service`);
+
+            //device
+            this.services = [];
+            for (const ssid of this.ssids) {
+                const ssidName = ssid.name;
+                if (this.logDebug) this.emit('debug', `prepare ssid: ${ssidName} service`);
+
+                const serviceName = this.accessPoint.namePrefix ? `${this.name} ${ssidName}` : ssidName;
+                const service = accessory.addService(Service.Switch, serviceName, `service${ssidName}`);
+                service.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                service.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                service.getCharacteristic(Characteristic.On)
+                    .onGet(async () => {
+                        const state = ssid.state;
+                        if (this.logInfo) this.emit('message', `SSID: ${ssidName}, state: ${state ? 'Enabled' : 'Disabled'}`);
+                        return state;
+                    })
+                    .onSet(async (state) => {
+                        try {
+                            state = state ? true : false;
+                            await this.openWrt.send('ssid', ssidName, state);
+                            if (this.logInfo) this.emit('message', `SSID: ${ssidName}, set State: ${state ? 'Enabled' : 'Disabled'}`);
+                        } catch (error) {
+                            this.emit('warn', `SSID: ${ssidName}, set state error: ${error}`);
+                        }
+                    });
+                this.services.push(service);
+
+                if (this.accessPoint.sensor) {
+                    if (this.logDebug) this.emit('debug', `prepare ssid: ${ssidName} sensor service`);
+
+                    this.sensorServices = [];
+                    const sensorService = accessory.addService(Service.ContactSensor, ssidName, `sensorService${ssidName}`);
+                    sensorService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                    sensorService.setCharacteristic(Characteristic.ConfiguredName, ssidName);
+                    sensorService.getCharacteristic(Characteristic.ContactSensorState)
+                        .onGet(async () => {
+                            const state = ssid.state;
+                            return state;
+                        });
+                    this.sensorServices.push(sensorService);
+                };
+            };
+
+            return accessory;
+        } catch (error) {
+            throw new Error(error);
+        };
+    };
+
+    //start
+    async start() {
+        try {
+            //start external integrations
+            if (this.restFul.enable || this.mqtt.enable) await this.externalIntegrations();
+
+            this.emit('devInfo', `-------- Access Point ${this.name} --------`);
+            this.emit('devInfo', `Name: ${this.openWrtInfo.systemInfo.hostname}`);
+            this.emit('devInfo', `Model: ${this.openWrtInfo.systemInfo.model}`);
+            this.emit('devInfo', `System: ${this.openWrtInfo.systemInfo.system}`);
+            this.emit('devInfo', `Release: ${this.openWrtInfo.systemInfo.release?.description}`);
+            this.emit('devInfo', `----------------------------------`);
+
+            //denon client
+            this.openWrt.on('systemInfo', (info) => {
+                this.informationService?.updateCharacteristic(Characteristic.FirmwareRevision, info.release?.version);
+            })
+                .on('wirelessStatus', async (status) => {
+                })
+                .on('wirelessRadios', async (radios) => {
+                })
+                .on('ssids', async (ssids) => {
+                    // sensors
+                    for (let i = 0; i < ssids.length; i++) {
+                        const ssid = ssids[i];
+
+                        const name = ssid[i].name;
+                        const state = ssid[i].state;
+                        const serviceName = this.accessPoint.namePrefix ? `${this.name} ${name}` : name;
+                        this.services?.[i]
+                            ?.setCharacteristic(Characteristic.ConfiguredName, serviceName)
+                            .updateCharacteristic(Characteristic.On, state);
+
+                        this.sensorServices?.[i]
+                            ?.setCharacteristic(Characteristic.ConfiguredName, name)
+                            .updateCharacteristic(Characteristic.ContactSensorState, state ? 0 : 1);
+
+                        if (this.logInfo) {
+                            this.emit('info', `SSID name: ${ssid.name}`);
+                            this.emit('info', `Name: ${ssid.state}`);
+                            this.emit('info', `Mode: ${ssid.mode}`);
+                        }
+                    }
+                })
+                .on('restFul', (path, data) => {
+                    if (this.restFulConnected) this.restFul1.update(path, data);
+                })
+                .on('mqtt', (topic, message) => {
+                    if (this.mqttConnected) this.mqtt1.emit('publish', topic, message);
+                });
+
+            //prepare accessory
+            const accessory = await this.prepareAccessory();
+            return accessory;
+        } catch (error) {
+            throw new Error(`Start error: ${error}`);
+        }
+    }
+};
+export default AccessPointDevice;

package/src/constants.js

@@ -0,0 +1,6 @@
+export const PlatformName = "OpenWrt";
+export const PluginName = "homebridge-openwrt-control";
+
+export const ApiUrls = {
+
+}

package/src/functions.js

@@ -0,0 +1,81 @@
+import { promises as fsPromises } from 'fs';
+import { DiacriticsMap } from './constants.js';
+
+class Functions {
+    constructor() {
+    }
+
+    async saveData(path, data, stringify = true) {
+        try {
+            data = stringify ? JSON.stringify(data, null, 2) : data;
+            await fsPromises.writeFile(path, data);
+            return true;
+        } catch (error) {
+            throw new Error(`Save data error: ${error}`);
+        }
+    }
+
+    async readData(path, parseJson = false) {
+        try {
+            const data = await fsPromises.readFile(path, 'utf8');
+
+            if (parseJson) {
+                if (!data.trim()) {
+                    // Empty file when expecting JSON
+                    return null;
+                }
+                try {
+                    return JSON.parse(data);
+                } catch (jsonError) {
+                    throw new Error(`JSON parse error in file "${path}": ${jsonError.message}`);
+                }
+            }
+
+            // For non-JSON, just return file content (can be empty string)
+            return data;
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                // File does not exist
+                return null;
+            }
+            // Preserve original error details
+            const wrappedError = new Error(`Read data error for "${path}": ${error.message}`);
+            wrappedError.original = error;
+            throw wrappedError;
+        }
+    }
+
+    async sanitizeString(str) {
+        if (!str) return '';
+
+        // Replace diacritics using map
+        str = str.replace(/[^\u0000-\u007E]/g, ch => DiacriticsMap[ch] || ch);
+
+        // Replace separators between words with space
+        str = str.replace(/(\w)[.:;+\-\/]+(\w)/g, '$1 $2');
+
+        // Replace remaining standalone separators with space
+        str = str.replace(/[.:;+\-\/]/g, ' ');
+
+        // Remove remaining invalid characters (keep letters, digits, space, apostrophe)
+        str = str.replace(/[^A-Za-z0-9 ']/g, ' ');
+
+        // Collapse multiple spaces
+        str = str.replace(/\s+/g, ' ');
+
+        // Trim
+        return str.trim();
+    }
+
+    async findIfaceBySsid(status, targetSsid) {
+        for (const radio of Object.values(status.radios)) {
+            for (const iface of Object.values(radio.interfaces)) {
+                if (iface.ssid === targetSsid) {
+                    return iface;
+                }
+            }
+        }
+        return null;
+    }
+}
+export default Functions

package/src/impulsegenerator.js

@@ -0,0 +1,41 @@
+import EventEmitter from 'events';
+
+class ImpulseGenerator extends EventEmitter {
+    constructor() {
+        super();
+        this.timersState = false;
+        this.timers = [];
+    }
+
+    async state(state, timers = []) {
+        // Stop current timers before new start
+        if (this.timersState && state) {
+            await this.state(false);
+        }
+
+        if (state) {
+            if (!Array.isArray(timers)) throw new Error('Timers must be an array');
+
+            for (const { name, sampling } of timers) {
+                if (!name || !sampling) continue;
+
+                this.emit(name);
+
+                const interval = setInterval(() => {
+                    this.emit(name);
+                }, sampling);
+
+                this.timers.push(interval);
+            }
+        } else {
+            this.timers.forEach(clearInterval);
+            this.timers = [];
+        }
+
+        this.timersState = state;
+        this.emit('state', state);
+        return true;
+    }
+}
+
+export default ImpulseGenerator;

package/src/openwrt.js

@@ -0,0 +1,173 @@
+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.name = config.name;
+        this.host = config.host;
+        this.user = config.user;
+        this.passwd = config.passwd;
+        this.logDebug = config.logDebug;
+
+        //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: `${config.host}/ubus`,
+            timeout: 5000,
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+
+        this.impulseGenerator = new ImpulseGenerator()
+            .on("connect", () => this.handleWithLock(async () => {
+                await this.connect();
+            }))
+            .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}`
+            );
+        } 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 }]
+        });
+
+        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;
+    }
+
+    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];
+    }
+
+    async connect() {
+        const openWrtInfo = { state: false, systemInfo: {}, wirelessStatus: {}, wirelessRadios: [], ssids: [] }
+        const systemInfo = await this.ubusCall("system", "board");
+        const wirelessStatus = await this.ubusCall("network.wireless", "status");
+        if (this.logDebug) this.emit("debug", `Status data: ${JSON.stringify(wirelessStatus, null, 2)}`);
+
+        const wirelessRadios = Object.values(status.radios).map(radio => ({
+            name: radio.name,
+            state: radio.up === true,
+            interfaces: Object.values(radio.interfaces).map(i => ({
+                name: i.ssid,
+                state: i.up === true,
+                mode: i.mode
+            }))
+        }));
+
+        const ssids = openWrtInfo.wirelessRadios.flatMap(radio => radio.interfaces);
+        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.firstRun = false;
+        }
+
+        openWrtInfo.state = true;
+        openWrtInfo.systemInfo = systemInfo;
+        openWrtInfo.wirelessStatus = wirelessStatus;
+        openWrtInfo.wirelessRadios = wirelessRadios;
+        openWrtInfo.ssids = ssids;
+
+        if (this.logDebug) this.emit("debug", `OpenWrt Data: ${JSON.stringify(openWrtInfo, null, 2)}`);
+        return openWrtInfo;
+    }
+
+    async send(type, ssidName, state) {
+        switch (type) {
+            case 'ssid':
+                await this.handleWithLock(async () => {
+                    if (this.logDebug) this.emit("debug", `${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", {});
+
+                    this.emit("success", `SSID ${ssidName} ${state ? "enabled" : "disabled"}`);
+                });
+                break;
+            case 'switch':
+                break;
+        }
+    }
+}
+
+export default OpenWrt;
+