@bobfrankston/lxlan 0.1.12 → 0.1.13

package/client.d.ts

@@ -13,6 +13,8 @@ export interface LxClientOptions {
     port?: number;
     /** Auto-discovery interval in ms (0 = manual only, default 0) */
     discoveryInterval?: number;
+    /** Enable client-to-client state broadcast for multi-client sync (default false) */
+    clientBroadcastEnabled?: boolean;
 }
 /**
  * LIFX LAN client for device discovery and control.
@@ -39,6 +41,7 @@ export declare class LxClient {
     private transport;
     private port;
     private discoveryTimer?;
+    private clientBroadcastEnabled;
     /** Cached devices by MAC address (lowercase) */
     devices: Map<string, LxDevice>;
     constructor(options: LxClientOptions);
@@ -76,5 +79,11 @@ export declare class LxClient {
     private handleMessage;
     /** Check if device info is complete and emit deviceInfo event */
     private checkDeviceInfoComplete;
+    /**
+     * Broadcast state message to other clients on the network
+     * Used for multi-client state synchronization
+     * @param stateMessage - Raw State message bytes from device
+     */
+    private broadcastState;
 }
 //# sourceMappingURL=client.d.ts.map

package/client.js

@@ -27,12 +27,14 @@ export class LxClient {
     transport;
     port;
     discoveryTimer; // NodeJS.Timeout in Node, number in browser
+    clientBroadcastEnabled;
     /** Cached devices by MAC address (lowercase) */
     devices = new Map();
     constructor(options) {
         this.emitter = options.eventEmitter;
         this.transport = options.transport;
         this.port = options.port ?? LIFX_PORT;
+        this.clientBroadcastEnabled = options.clientBroadcastEnabled ?? false;
         this.transport.onMessage((data, rinfo) => {
             // Ensure data is Uint8Array for protocol decoder
             const buf = data instanceof Uint8Array ? data : new Uint8Array(data);
@@ -183,6 +185,12 @@ export class LxClient {
                 device.markResponseReceived(MessageType.SetPower);
                 device.markResponseReceived(MessageType.SetColor);
                 this.emit('state', device);
+                // Multi-client state synchronization: broadcast to other clients
+                // Safe fail approach: only rebroadcast if from device IP
+                // If not from device.ip, assume it's a client broadcast - just update local state, don't rebroadcast
+                if (this.clientBroadcastEnabled && fromIp === device.ip) {
+                    this.broadcastState(data);
+                }
                 break;
             }
             case MessageType.StatePower: {
@@ -262,5 +270,21 @@ export class LxClient {
             this.emit('deviceInfo', device);
         }
     }
+    /**
+     * Broadcast state message to other clients on the network
+     * Used for multi-client state synchronization
+     * @param stateMessage - Raw State message bytes from device
+     */
+    broadcastState(stateMessage) {
+        try {
+            // Broadcast the State message so other clients can update their local state
+            // Using broadcast address on standard LIFX port (56700)
+            this.transport.send('255.255.255.255', this.port, stateMessage);
+        }
+        catch (err) {
+            // Don't emit error for broadcast failures - it's non-critical
+            console.warn('Failed to broadcast state to other clients:', err);
+        }
+    }
 }
 //# sourceMappingURL=client.js.map

package/device.js

@@ -125,7 +125,8 @@ export class LxDevice {
             type: MessageType.SetPower,
             target: this.mac,
             payload: encodeSetPower(on),
-            ackRequired: true
+            ackRequired: true,
+            resRequired: true // Get State response with full state
         });
         this.transport.send(this.ip, this.port, msg);
         // Track this request with a timeout
@@ -155,7 +156,8 @@ export class LxDevice {
             type: MessageType.SetColor,
             target: this.mac,
             payload: encodeSetColor(hsbk16, duration),
-            ackRequired: true
+            ackRequired: true,
+            resRequired: true // Get State response with full state
         });
         this.transport.send(this.ip, this.port, msg);
         // Track this request with a timeout

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/lxlan",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "LIFX LAN protocol library for device control via UDP",
   "type": "module",
   "main": "index.js",

package/protocol.d.ts

@@ -1,5 +1,16 @@
 import { HSBK16 } from '@bobfrankston/colorlib';
 import { LxMessage } from './types.js';
+/** LIFX protocol frame flags */
+export declare const FrameFlags: {
+    readonly ResRequired: 1;
+    readonly AckRequired: 2; /** Acknowledgement required from device */
+};
+/** LIFX protocol bits */
+export declare const ProtocolBits: {
+    readonly Tagged: 8192;
+    readonly Addressable: 4096;
+    readonly ProtocolMask: 4095; /** Protocol version mask */
+};
 /** Get next sequence number (0-255 wrapping) */
 export declare function nextSequence(): number;
 /** Get global source ID */

package/protocol.js

@@ -1,4 +1,15 @@
 import { HEADER_SIZE } from './types.js';
+/** LIFX protocol frame flags */
+export const FrameFlags = {
+    ResRequired: 0x01, /** Response required from device */
+    AckRequired: 0x02 /** Acknowledgement required from device */
+};
+/** LIFX protocol bits */
+export const ProtocolBits = {
+    Tagged: 0x2000, /** Message is tagged (broadcast) */
+    Addressable: 0x1000, /** Message is addressable */
+    ProtocolMask: 0xFFF /** Protocol version mask */
+};
 let globalSource = Math.floor(Math.random() * 0xFFFFFFFF);
 let sequenceCounter = 0;
 /** Get next sequence number (0-255 wrapping) */
@@ -80,12 +91,12 @@ export function encodeMessage(options) {
     const sequence = options.sequence ?? nextSequence();
     // Frame (8 bytes)
     writeUInt16LE(buf, size, 0);
-    const protocol = 1024 | (tagged ? 0x2000 : 0) | 0x1000;
+    const protocol = 1024 | (tagged ? ProtocolBits.Tagged : 0) | ProtocolBits.Addressable;
     writeUInt16LE(buf, protocol, 2);
     writeUInt32LE(buf, globalSource, 4);
     // Frame Address (16 bytes)
     buf.set(macToBuffer(target), 8);
-    const flags = (options.resRequired ? 0x01 : 0) | (options.ackRequired ? 0x02 : 0);
+    const flags = (options.resRequired ? FrameFlags.ResRequired : 0) | (options.ackRequired ? FrameFlags.AckRequired : 0);
     buf[22] = flags;
     buf[23] = sequence;
     // Protocol Header (12 bytes)
@@ -103,9 +114,9 @@ export function decodeMessage(buf) {
     }
     const size = readUInt16LE(buf, 0);
     const protocolBits = readUInt16LE(buf, 2);
-    const tagged = (protocolBits & 0x2000) !== 0;
-    const addressable = (protocolBits & 0x1000) !== 0;
-    const protocol = protocolBits & 0xFFF;
+    const tagged = (protocolBits & ProtocolBits.Tagged) !== 0;
+    const addressable = (protocolBits & ProtocolBits.Addressable) !== 0;
+    const protocol = protocolBits & ProtocolBits.ProtocolMask;
     const source = readUInt32LE(buf, 4);
     const target = bufferToMac(buf, 8);
     const flags = buf[22];
@@ -119,8 +130,8 @@ export function decodeMessage(buf) {
         tagged,
         source,
         target,
-        resRequired: (flags & 0x01) !== 0,
-        ackRequired: (flags & 0x02) !== 0,
+        resRequired: (flags & FrameFlags.ResRequired) !== 0,
+        ackRequired: (flags & FrameFlags.AckRequired) !== 0,
         sequence,
         type,
         payload