@evops/lightwaverf 1.0.3 → 1.0.5

package/.dist/LightwaveCommandQueue.d.ts

@@ -0,0 +1,39 @@
+import { Debugger } from "debug";
+export interface QueuedTransaction {
+    id: number;
+    originalMessage: string;
+    message: string;
+    resolve: (value: TransactionResponse) => void;
+    reject: (error: Error) => void;
+    timeoutId?: ReturnType<typeof setTimeout>;
+    retryTimeoutId?: ReturnType<typeof setTimeout>;
+    delay: number;
+    completed: boolean;
+}
+export interface TransactionResponse {
+    id: number;
+    [key: string]: unknown;
+}
+export interface LightwaveCommandQueueOptions {
+    debug: Debugger;
+    delay?: number;
+    timeout?: number;
+    onExecute: (message: string) => void;
+}
+export declare class LightwaveCommandQueue {
+    private queue;
+    private transactions;
+    private busy;
+    private debug;
+    private delay;
+    private timeout;
+    private onExecute;
+    constructor(options: LightwaveCommandQueueOptions);
+    send(message: string | Buffer): Promise<TransactionResponse>;
+    handleResponse(response: TransactionResponse): void;
+    handleRetryableError(transactionId: number): void;
+    destroy(): void;
+    private processQueue;
+    private completeTransaction;
+    private failTransaction;
+}

package/.dist/LightwaveCommandQueue.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightwaveCommandQueue = void 0;
+class LightwaveCommandQueue {
+    queue = [];
+    transactions = new Map();
+    busy = false;
+    debug;
+    delay;
+    timeout;
+    onExecute;
+    constructor(options) {
+        this.debug = options.debug.extend("queue");
+        this.delay = options.delay ?? 800;
+        this.timeout = options.timeout ?? 10000;
+        this.onExecute = options.onExecute;
+    }
+    send(message) {
+        const transactionId = Math.round(Math.random() * Math.pow(10, 8));
+        const messageStr = typeof message === "string" ? message : message.toString("utf-8");
+        const messageWithTransaction = `${transactionId},${messageStr}`;
+        this.debug("[%d] Queueing message: %s", Date.now(), messageWithTransaction);
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const transaction = {
+            id: transactionId,
+            originalMessage: messageStr,
+            message: messageWithTransaction,
+            resolve,
+            reject,
+            delay: this.delay,
+            completed: false,
+        };
+        this.queue.push(transaction);
+        this.transactions.set(transactionId, transaction);
+        this.processQueue();
+        return promise;
+    }
+    handleResponse(response) {
+        const transaction = this.transactions.get(response.id);
+        if (!transaction || transaction.completed) {
+            this.debug("No pending transaction found for id %d or already completed", response.id);
+            return;
+        }
+        this.debug("[%d] Transaction %d completed", Date.now(), response.id);
+        this.completeTransaction(transaction, response);
+    }
+    handleRetryableError(transactionId) {
+        const transaction = this.transactions.get(transactionId);
+        if (!transaction || transaction.completed) {
+            return;
+        }
+        // Clear existing timeout
+        if (transaction.timeoutId) {
+            clearTimeout(transaction.timeoutId);
+            transaction.timeoutId = undefined;
+        }
+        // Exponential backoff, max 10 seconds
+        transaction.delay = Math.min(transaction.delay * 2, 10000);
+        const retryMessage = `${transactionId},${transaction.originalMessage}`;
+        this.debug("Message errored, retrying: %s with delay: %d", retryMessage, transaction.delay);
+        // Set timeout for retry
+        transaction.timeoutId = setTimeout(() => {
+            if (transaction.completed)
+                return;
+            this.debug("Retry timeout expired for transaction %d", transactionId);
+            this.failTransaction(transaction, new Error(`Retry timeout expired ${transactionId}`));
+        }, 5000 + transaction.delay * 2);
+        // Schedule retry
+        transaction.retryTimeoutId = setTimeout(() => {
+            if (transaction.completed)
+                return;
+            this.onExecute(retryMessage);
+        }, Math.round(transaction.delay * 2));
+    }
+    destroy() {
+        for (const transaction of this.transactions.values()) {
+            if (transaction.timeoutId) {
+                clearTimeout(transaction.timeoutId);
+            }
+            if (transaction.retryTimeoutId) {
+                clearTimeout(transaction.retryTimeoutId);
+            }
+            if (!transaction.completed) {
+                transaction.reject(new Error("Queue destroyed"));
+                transaction.completed = true;
+            }
+        }
+        this.transactions.clear();
+        this.queue = [];
+        this.busy = false;
+    }
+    processQueue() {
+        if (this.busy) {
+            this.debug("Queue is busy, waiting to process");
+            return;
+        }
+        const transaction = this.queue.shift();
+        if (!transaction) {
+            return;
+        }
+        this.debug("Processing transaction: %d", transaction.id);
+        this.busy = true;
+        // Set timeout for response
+        transaction.timeoutId = setTimeout(() => {
+            if (transaction.completed)
+                return;
+            this.debug("Transaction %d timed out", transaction.id);
+            this.failTransaction(transaction, new Error(`Execution expired ${transaction.id}`));
+        }, this.timeout);
+        this.onExecute(transaction.message);
+    }
+    completeTransaction(transaction, response) {
+        if (transaction.completed)
+            return;
+        transaction.completed = true;
+        if (transaction.timeoutId) {
+            clearTimeout(transaction.timeoutId);
+        }
+        if (transaction.retryTimeoutId) {
+            clearTimeout(transaction.retryTimeoutId);
+        }
+        this.transactions.delete(transaction.id);
+        transaction.resolve(response);
+        this.debug("Transaction %d completed, scheduling next in %dms", transaction.id, this.delay);
+        setTimeout(() => {
+            this.busy = false;
+            this.processQueue();
+        }, this.delay);
+    }
+    failTransaction(transaction, error) {
+        if (transaction.completed)
+            return;
+        transaction.completed = true;
+        if (transaction.timeoutId) {
+            clearTimeout(transaction.timeoutId);
+        }
+        if (transaction.retryTimeoutId) {
+            clearTimeout(transaction.retryTimeoutId);
+        }
+        this.transactions.delete(transaction.id);
+        transaction.reject(error);
+        this.busy = false;
+        this.processQueue();
+    }
+}
+exports.LightwaveCommandQueue = LightwaveCommandQueue;

package/.dist/LightwaveRFClient.d.ts

@@ -1,6 +1,6 @@
 import { Debugger } from "debug";
 import events from "events";
-import { LightwaveTransaction } from "./LightwaveTransaction";
+import { TransactionResponse } from "./LightwaveCommandQueue";
 declare interface LightwaveRFClientInterface {
     on(event: "ready", listener: (client: LightwaveRFClient) => void): this;
     on(event: "deviceTurnedOn", listener: (room: number, device: number) => void): this;
@@ -15,19 +15,20 @@ export declare class LightwaveRFClient extends events.EventEmitter implements Li
     private commandQueue;
     private messageProcessors;
     private debug;
-    private transactionListeners;
     delay: number;
     serial?: string;
     mac?: string;
     model?: string;
     uptime?: number;
     version?: string;
-    constructor(debug: Debugger, ip?: string);
+    discoverLinkIp: boolean;
+    constructor(debug: Debugger, ip?: string, { discoverLinkIp }?: {
+        discoverLinkIp?: boolean;
+    });
     connect(): Promise<void>;
     disconnect(): Promise<[void, void]>;
     private checkRegistration;
-    send(message: string | Buffer, callback?: (transaction: LightwaveTransaction | null, error: Error) => void): void;
-    private processSendQueue;
+    send(message: string | Buffer): Promise<TransactionResponse>;
     private exec;
     private processRawMessage;
     private processLightwaveMessage;

package/.dist/LightwaveRFClient.js

@@ -6,33 +6,39 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LightwaveRFClient = void 0;
 const dgram_1 = __importDefault(require("dgram"));
 const events_1 = __importDefault(require("events"));
+const LightwaveCommandQueue_1 = require("./LightwaveCommandQueue");
 const LightwaveMessageProcessorForJson_1 = require("./LightwaveMessageProcessorForJson");
 const LightwaveMessageProcessorForText_1 = __importDefault(require("./LightwaveMessageProcessorForText"));
-const Queue_1 = require("./Queue");
 const LIGHTWAVE_LINK_SEND_PORT = 9760;
 const LIGHTWAVE_LINK_RECEIVE_PORT = 9761;
 class LightwaveRFClient extends events_1.default.EventEmitter {
     ip;
     senderSocket;
     receiverSocket;
-    commandQueue = new Queue_1.Queue();
+    commandQueue;
     messageProcessors = [];
     debug;
-    transactionListeners = new Map();
-    delay = 125;
+    delay = 800;
     serial;
     mac;
     model;
     uptime;
     version;
-    constructor(debug, ip = "255.255.255.255") {
+    discoverLinkIp;
+    constructor(debug, ip = "255.255.255.255", { discoverLinkIp = true } = {}) {
         super();
         this.ip = ip;
+        this.discoverLinkIp = discoverLinkIp;
         this.debug = debug.extend("client");
         this.senderSocket = dgram_1.default.createSocket("udp4");
         this.senderSocket.unref();
         this.receiverSocket = dgram_1.default.createSocket("udp4");
         this.receiverSocket.unref();
+        this.commandQueue = new LightwaveCommandQueue_1.LightwaveCommandQueue({
+            debug: this.debug,
+            delay: this.delay,
+            onExecute: (message) => this.exec(message),
+        });
         this.messageProcessors.push(new LightwaveMessageProcessorForJson_1.LightwaveMessageProcessorForJson(this.debug));
         this.messageProcessors.push(new LightwaveMessageProcessorForText_1.default(this.debug));
     }
@@ -61,69 +67,26 @@ class LightwaveRFClient extends events_1.default.EventEmitter {
     async disconnect() {
         this.receiverSocket.removeAllListeners();
         this.senderSocket.removeAllListeners();
+        this.commandQueue.destroy();
         const { promise: senderPromise, resolve: senderResolve } = Promise.withResolvers();
         const { promise: receiverPromise, resolve: receiverResolve } = Promise.withResolvers();
         this.senderSocket.close(senderResolve);
         this.receiverSocket.close(receiverResolve);
         return Promise.all([senderPromise, receiverPromise]);
     }
-    checkRegistration() {
+    async checkRegistration() {
         this.debug("Checking registration");
-        this.send("@H", (transaction, error) => {
-            if (error) {
-                this.debug("Error: %o", error);
-            }
+        try {
+            const transaction = await this.send("@H");
             this.debug(transaction);
-            this.emit("ready", this);
-        });
-    }
-    send(message, callback) {
-        const transaction = Math.round(Math.random() * Math.pow(10, 8));
-        const messageWithTransaction = `${transaction},${message}`;
-        const transactionDebug = this.debug.extend("tx:" + transaction);
-        this.transactionListeners.set(transaction, {
-            message: message,
-            debug: transactionDebug,
-            delay: this.delay,
-            callback: callback,
-        });
-        this.debug("Queueing message: %s", messageWithTransaction);
-        this.commandQueue.add({
-            id: transaction,
-            message: messageWithTransaction,
-            debug: transactionDebug,
-            callback,
-        });
-        this.processSendQueue();
-    }
-    async processSendQueue() {
-        if (this.commandQueue.busy) {
-            setTimeout(this.processSendQueue.bind(this), this.delay);
-            return;
         }
-        const command = this.commandQueue.next();
-        if (!command)
-            return;
-        this.commandQueue.busy = true;
-        const transactionListener = this.transactionListeners.get(command.id);
-        const originalCallback = transactionListener.callback;
-        transactionListener.callback = (transaction, error) => {
-            this.commandQueue.busy = false;
-            originalCallback?.(transaction, error);
-            setTimeout(this.processSendQueue.bind(this), this.delay);
-        };
-        // If we didn't hear back within the timeout
-        setTimeout(() => {
-            const listener = this.transactionListeners.get(command.id);
-            if (!listener)
-                return;
-            originalCallback?.(null, new Error("Execution expired"));
-            this.transactionListeners.delete(command.id);
-            this.processSendQueue();
-        }, 5000);
-        const transactionDebug = this.debug.extend(`transaction:${command?.id}`);
-        transactionDebug("Starting new transaction");
-        this.exec(command.message);
+        catch (error) {
+            this.debug("Error: %o", error);
+        }
+        this.emit("ready", this);
+    }
+    send(message) {
+        return this.commandQueue.send(message);
     }
     exec(message) {
         if (message === undefined)
@@ -144,15 +107,14 @@ class LightwaveRFClient extends events_1.default.EventEmitter {
             if (messageProcessor.canProcess(message)) {
                 this.debug("Message can be processed by %s", messageProcessor.constructor.name);
                 const lightwaveMessage = messageProcessor.process(message);
-                this.processLightwaveMessage(lightwaveMessage);
+                this.processLightwaveMessage(lightwaveMessage, remoteInfo);
                 return;
             }
         }
         throw "Message cannot be processed";
     }
-    processLightwaveMessage(lightwaveMessage) {
+    processLightwaveMessage(lightwaveMessage, remoteInfo) {
         this.debug("Processing lightwave message: %o", lightwaveMessage);
-        this.debug("Current listeners: %o", this.transactionListeners);
         this.debug("Link response fn", lightwaveMessage.fn);
         // update info from link
         if (lightwaveMessage.serial) {
@@ -167,8 +129,9 @@ class LightwaveRFClient extends events_1.default.EventEmitter {
         if (lightwaveMessage.uptime) {
             this.uptime = lightwaveMessage.uptime;
         }
-        if (lightwaveMessage.ip) {
-            this.ip = lightwaveMessage.ip;
+        if (this.discoverLinkIp) {
+            this.debug(`Updating link ip to ${remoteInfo.address}`);
+            this.ip = remoteInfo.address;
         }
         if (lightwaveMessage.fw) {
             this.version ??= lightwaveMessage.fw;
@@ -190,27 +153,14 @@ class LightwaveRFClient extends events_1.default.EventEmitter {
         if (lightwaveMessage.fn === "dim") {
             this.emit("deviceDimmed", lightwaveMessage.room, lightwaveMessage.dev, Math.round((lightwaveMessage.param / 32) * 100));
         }
-        const listener = this.transactionListeners.get(lightwaveMessage.id);
-        if (!listener)
-            return;
+        // Handle retryable errors (ERR,6 = device busy)
         if (lightwaveMessage.error?.match(/^ERR,6,/)) {
-            listener.delay = listener.delay * 2;
-            const msg = `${lightwaveMessage.id},!${listener.message}`;
-            this.debug("message errorred, retrying: %o, %o with delay: %o", msg, listener, listener.delay);
-            setTimeout(() => {
-                this.exec(msg);
-            }, Math.round(listener.delay));
+            this.commandQueue.handleRetryableError(lightwaveMessage.id);
             return;
         }
-        this.commandQueue.busy = false;
-        if (listener) {
-            listener.debug("Found transaction listener");
-            listener.callback(lightwaveMessage, null);
-            listener.debug("Transaction completed, removing listener");
-            this.transactionListeners.delete(lightwaveMessage.id);
-        }
-        else {
-            this.debug("Listener not found for message: %o", lightwaveMessage);
+        // Pass successful response to the queue
+        if (lightwaveMessage.id !== undefined) {
+            this.commandQueue.handleResponse(lightwaveMessage);
         }
     }
 }

package/.dist/index.d.ts

@@ -12,6 +12,8 @@ declare class LightwaveRFConfiguration {
     host?: any;
     email?: any;
     pin?: any;
+    linkDisplayUpdates?: boolean;
+    discoverLinkIp?: boolean;
 }
 declare interface ILightwaveRF {
     on(event: "deviceTurnedOn", listener: (roomId: number, deviceId: number) => void): this;
@@ -42,7 +44,8 @@ export default class LightwaveRF extends EventEmitter<LightwaveEvents> implement
     lwClient: LightwaveRFClient;
     lwAccount: LightwaveAccount;
     debug: debug.Debugger;
-    constructor({ email, pin, ip, timeout }: LightwaveRFConfiguration);
+    private linkDisplayUpdates;
+    constructor({ email, pin, ip, timeout, linkDisplayUpdates, discoverLinkIp, }: LightwaveRFConfiguration);
     get serial(): string | undefined;
     get mac(): string | undefined;
     get uptime(): number | undefined;

package/.dist/index.js

@@ -17,6 +17,8 @@ class LightwaveRFConfiguration {
     host;
     email;
     pin;
+    linkDisplayUpdates;
+    discoverLinkIp;
 }
 /** * LightwaveRF API
  *
@@ -37,12 +39,16 @@ class LightwaveRF extends events_1.EventEmitter {
     lwClient;
     lwAccount;
     debug;
-    constructor({ email, pin, ip, timeout }) {
+    linkDisplayUpdates;
+    constructor({ email, pin, ip, timeout, linkDisplayUpdates = true, discoverLinkIp = true, }) {
         super();
         this.setMaxListeners(255);
         this.debug = (0, debug_1.default)("lightwave");
+        this.linkDisplayUpdates = linkDisplayUpdates;
         this.debug("Initialising LightwaveRF Client");
-        this.lwClient = new LightwaveRFClient_1.LightwaveRFClient(this.debug, ip);
+        this.lwClient = new LightwaveRFClient_1.LightwaveRFClient(this.debug, ip, {
+            discoverLinkIp,
+        });
         this.lwClient.once("ready", () => {
             this.debug("LightwaveRF ready");
         });
@@ -83,36 +89,41 @@ class LightwaveRF extends events_1.EventEmitter {
         }));
     }
     async turnOn({ roomId, deviceId, roomName, deviceName }) {
-        this.lwClient.send(`!F1R${roomId}D${deviceId}|${roomName} ${deviceName}|Turn on|`);
+        const linkDisplayUpdate = this.linkDisplayUpdates
+            ? `|${roomName} ${deviceName}|Turn on|`
+            : "";
+        await this.lwClient.send(`!F1R${roomId}D${deviceId}${linkDisplayUpdate}`);
     }
     async turnOff({ roomId, deviceId, roomName, deviceName }) {
-        this.lwClient.send(`!F0R${roomId}D${deviceId}|${roomName} ${deviceName}|Turn off|`);
+        const linkDisplayUpdate = this.linkDisplayUpdates
+            ? `|${roomName} ${deviceName}|Turn off|`
+            : "";
+        await this.lwClient.send(`!F0R${roomId}D${deviceId}${linkDisplayUpdate}`);
     }
     async dim({ roomId, deviceId, roomName, deviceName }, percentage) {
         const lwDim = Math.round(percentage * 0.32);
-        this.lwClient.send(`!FdP${lwDim}R${roomId}D${deviceId}|${roomName} ${deviceName}|Dim to ${percentage}%|`);
+        const linkDisplayUpdate = this.linkDisplayUpdates
+            ? `|${roomName} ${deviceName}|Dim to ${percentage}%|`
+            : "";
+        await this.lwClient.send(`!FdP${lwDim}R${roomId}D${deviceId}${linkDisplayUpdate}`);
     }
     async connect() {
         return this.lwClient.connect();
     }
     async isRegistered() {
-        return new Promise((resolve) => {
-            const user = process.env.USER;
-            this.lwClient.send(`@H|Check registration|user:${user}|`, (response) => {
-                return resolve(!response?.error);
-            });
-        });
+        const user = process.env.USER;
+        const response = await this.lwClient.send(`@H|Check registration|user:${user}|`);
+        return !response?.error;
     }
     async ensureRegistration() {
+        const user = process.env.USER;
+        const response = await this.lwClient.send(`@H|Check registration|user:${user}|`);
+        if (!response?.error) {
+            return;
+        }
+        this.debug("We are not registered with the hub");
+        await this.lwClient.send("!F*p");
         return new Promise((resolve) => {
-            const user = process.env.USER;
-            this.lwClient.send(`@H|Check registration|user:${user}|`, (response) => {
-                if (!response?.error) {
-                    return resolve();
-                }
-                this.debug("We are not registered with the hub");
-                this.lwClient.send("!F*p");
-            });
             this.lwClient.on("registered", resolve);
         });
     }

package/.dist/index.test.js

@@ -7,6 +7,7 @@ const fetch_vcr_1 = __importDefault(require("fetch-vcr"));
 const vitest_1 = require("vitest");
 const _1 = __importDefault(require("."));
 (0, vitest_1.describe)("LightwaveRF", () => {
+    let lw;
     (0, vitest_1.beforeAll)(() => {
         fetch_vcr_1.default.configure({
             fixturePath: __dirname + "/.fixtures",
@@ -14,30 +15,44 @@ const _1 = __importDefault(require("."));
         });
         global.fetch = fetch_vcr_1.default;
     });
+    (0, vitest_1.afterEach)(async () => {
+        await lw.lwClient.disconnect();
+    });
     (0, vitest_1.it)("should allow device linking", async () => {
-        const lw = new _1.default({
+        lw = new _1.default({
             email: "some@user.com",
             pin: "1234",
         });
         // const devices = await lw.getDevices();
         await lw.connect();
         await lw.ensureRegistration();
+        await lw.lwClient.disconnect();
     });
     (0, vitest_1.it)("should turn device on", async () => {
-        const lw = new _1.default({
+        lw = new _1.default({
             email: "some@user.com",
             pin: "1234",
+            // Disabling link display updates as they cause buffer issues in the link
+            // device
+            linkDisplayUpdates: true,
         });
         // const devices = await lw.getDevices();
         await lw.connect();
         // await lw.ensureRegistration();
         const devices = await lw.getDevices();
-        const wallLamps = devices?.find((d) => {
-            return d.deviceName === "Wall lamps";
+        const roomToInteractWith = "TV Room";
+        const lightToInteractWith = "Lights";
+        const light = devices?.find((d) => {
+            return (d.roomName === roomToInteractWith &&
+                d.deviceName === lightToInteractWith);
         });
-        if (!wallLamps) {
-            throw new Error("Could not find wall lamps in the config");
+        if (!light) {
+            throw new Error(`Could not find ${lightToInteractWith} in the config`);
         }
-        lw.turnOff(wallLamps);
-    });
+        for (let i = 0; i < 5; i++) {
+            console.debug("Turning device on and off", i);
+            await lw.turnOn(light);
+            await lw.turnOff(light);
+        }
+    }, 30000);
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@evops/lightwaverf",
   "description": "Lightwave RF client library",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "exports": {
     ".": {
       "types": "./.dist/index.d.ts",

package/vitest.config.ts

@@ -6,7 +6,7 @@ export default defineConfig({
     environment: "node",
     printConsoleTrace: true,
     env: {
-      // DEBUG: "lightwave*",
+      DEBUG: "lightwave*",
     },
   },
 });