@west7014/lifx-lan 1.0.2

package/LICENSE

@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.

package/README.md

@@ -0,0 +1,143 @@
+# lifx-lan
+
+Control LIFX lights directly over your local network using the [LIFX LAN protocol](https://lan.developer.lifx.com/). No cloud required for most features.
+
+## Installation
+
+```bash
+npm install lifx-lan axios
+```
+
+If you want to load your LIFX auth token from a `.env` file rather than hard-coding it:
+
+```bash
+npm install dotenv@16.4.5
+```
+
+## Quick Start
+
+```js
+const LifxLAN = require('lifx-lan');
+
+const light = new LifxLAN('192.168.1.42');
+
+light.on();
+light.setColorHex(0xff6600);
+light.setBrightnessPercent(80);
+light.off(2000); // fade out over 2 seconds
+```
+
+## Authentication
+
+Some features (effects, fetching light metadata) use the [LIFX HTTP API](https://api.developer.lifx.com/) and require a personal access token from [cloud.lifx.com](https://cloud.lifx.com).
+
+**Option A — hard-code it:**
+```js
+const AUTH = 'your-lifx-token-here';
+await light.setEffect('flame', AUTH);
+```
+
+**Option B — load from `.env` (requires `dotenv@16.4.5`):**
+```
+# .env
+LIFX_TOKEN=your-lifx-token-here
+```
+```js
+require('dotenv').config();
+const AUTH = process.env.LIFX_TOKEN;
+await light.setEffect('flame', AUTH);
+```
+
+All LAN-only methods (`on`, `off`, `setColor*`, `setBrightness*`, `setZones*`, `setTile*`) work without any token.
+
+## API
+
+### Constructor
+
+```js
+new LifxLAN(ip, port = 56700)
+```
+
+### Power
+
+| Method | Description |
+|---|---|
+| `on(duration?)` | Turn light on |
+| `off(duration?)` | Turn light off |
+| `setPower(level, duration?)` | Raw power — `0` = off, `65535` = on |
+
+### Color
+
+| Method | Description |
+|---|---|
+| `setColor(hue, sat, bri, kelvin?, duration?)` | Set HSBK values directly (all 0–65535) |
+| `setColorRGB(r, g, b, kelvin?, duration?)` | Set color from RGB (0–255 each) |
+| `setColorHex(hex, kelvin?, duration?)` | Set color from hex e.g. `0xff6600` |
+
+### Brightness
+
+| Method | Description |
+|---|---|
+| `setBrightness(value, duration?)` | `0.0–1.0` or `0–65535` |
+| `setBrightnessPercent(percent, duration?)` | `0–100` |
+| `fadeBrightness(target, seconds)` | Smooth fade to brightness value |
+| `fadeBrightnessPercent(percent, seconds)` | Smooth fade to brightness percent |
+
+### Zones (multi-zone strips)
+
+| Method | Description |
+|---|---|
+| `setZones(start, end, h, s, b, kelvin?, duration?, apply?)` | Set zone range by HSBK |
+| `setZonesHex(start, end, hex, kelvin?, duration?, apply?)` | Set zone range by hex color |
+
+### Tile / Matrix (LIFX Ceiling)
+
+| Method | Description |
+|---|---|
+| `setTileState64(index, colors, duration?, x?, y?, width?)` | Set full 8×8 grid with an array of 64 HSBK objects |
+| `setTileSolid(index, h, s, b, kelvin?, duration?)` | Fill a tile with a solid HSBK color |
+| `setTileSolidHex(index, hex, kelvin?, duration?)` | Fill a tile with a solid hex color |
+
+### LIFX Ceiling — High-Level API
+
+The ceiling has an 8×8 grid: 6 rows of 8 downlight zones, with uplight strips on the top and bottom edges.
+
+| Method | Description |
+|---|---|
+| `setAll(colors, kelvin?, duration?, mode?)` | Set entire ceiling — downlight + uplight |
+| `setDownlight(colors, kelvin?, duration?, mode?)` | Set downlight zones only |
+| `setUplight(color, kelvin?, duration?)` | Set uplight strips only |
+| `setZonesCustom(zoneColors, kelvin?, duration?)` | Set all 8 zones individually — array of 8 hex colors |
+
+`mode` can be `'solid'` (default), `'gradient'`, or `'palette'`. For `gradient` and `palette`, pass an array of hex colors.
+
+### HTTP API (requires auth token)
+
+| Method | Description |
+|---|---|
+| `getLightData(auth)` | Fetch light metadata from the LIFX cloud API |
+| `setEffect(fxName, auth, options?)` | Start an effect: `'pulse'`, `'breathe'`, `'move'`, `'morph'`, `'flame'` |
+| `stopEffect(auth)` | Stop any running effect |
+
+### Utilities
+
+| Method | Description |
+|---|---|
+| `rgbToHsbk(r, g, b, kelvin?)` | Convert RGB to a LIFX HSBK object |
+| `close()` | Close the underlying UDP socket |
+
+### Duration
+
+All `duration` parameters are in **milliseconds** unless the method name says `seconds` (e.g. `fadeBrightness`).
+
+## TypeScript
+
+Type declarations are included. No additional setup required.
+
+```ts
+import LifxLAN, { HSBK, EffectName } from 'lifx-lan';
+```
+
+## License
+
+See [LICENSE](./LICENSE).

package/index.d.ts

@@ -0,0 +1,111 @@
+interface HSBK {
+    hue: number;
+    saturation: number;
+    brightness: number;
+    kelvin: number;
+}
+interface LightData {
+    id: string;
+    label: string;
+    connected: boolean;
+    power: 'on' | 'off';
+    color: {
+        hue: number;
+        saturation: number;
+        kelvin: number;
+    };
+    brightness: number;
+    group: {
+        id: string;
+        name: string;
+    };
+    location: {
+        id: string;
+        name: string;
+    };
+    [key: string]: unknown;
+}
+type EffectName = 'pulse' | 'breathe' | 'move' | 'morph' | 'flame';
+type DisplayMode = 'solid' | 'gradient' | 'palette';
+type MoveDirection = 'forward' | 'backward';
+interface PulseEffectOptions {
+    color?: string;
+    from_color?: string | null;
+    period?: number;
+    cycles?: number;
+    persist?: boolean;
+    power_on?: boolean;
+    peak?: number;
+}
+interface BreatheEffectOptions extends PulseEffectOptions {
+}
+interface MoveEffectOptions {
+    direction?: MoveDirection;
+    period?: number;
+    cycles?: number;
+    power_on?: boolean;
+}
+interface MorphEffectOptions {
+    period?: number;
+    duration?: number | null;
+    palette?: string[];
+    power_on?: boolean;
+}
+interface FlameEffectOptions {
+    period?: number;
+    duration?: number | null;
+    power_on?: boolean;
+}
+type EffectOptions = PulseEffectOptions | BreatheEffectOptions | MoveEffectOptions | MorphEffectOptions | FlameEffectOptions;
+declare class LifxLAN {
+    private readonly ip;
+    private readonly port;
+    private readonly socket;
+    private readonly source;
+    private sequence;
+    constructor(ip: string, port?: number);
+    private buildHeader;
+    private send;
+    rgbToHsbk(r: number, g: number, b: number, kelvin?: number): HSBK;
+    private hexToHSBK;
+    setPower(level: number, duration?: number): void;
+    on(duration?: number): void;
+    off(duration?: number): void;
+    setColor(hue: number, saturation: number, brightness: number, kelvin?: number, duration?: number): void;
+    setColorRGB(r: number, g: number, b: number, kelvin?: number, duration?: number): void;
+    setColorHex(hex: number, kelvin?: number, duration?: number): void;
+    /**
+     * Set brightness without changing the current hue/saturation.
+     * @param brightness - Value from 0.0–1.0 or 0–65535
+     */
+    setBrightness(brightness: number, duration?: number): void;
+    /** @param percent - 0–100 */
+    setBrightnessPercent(percent: number, duration?: number): void;
+    fadeBrightness(targetBrightness: number, seconds: number): void;
+    fadeBrightnessPercent(targetPercent: number, seconds: number): void;
+    setZones(startZone: number, endZone: number, hue: number, saturation: number, brightness: number, kelvin?: number, duration?: number, apply?: number): void;
+    setZonesHex(startZone: number, endZone: number, hex: number, kelvin?: number, duration?: number, apply?: number): void;
+    setTileState64(tileIndex: number, colors: HSBK[], duration?: number, x?: number, y?: number, width?: number): void;
+    setTileSolid(tileIndex: number, hue: number, saturation: number, brightness: number, kelvin?: number, duration?: number): void;
+    setTileSolidHex(tileIndex: number, hex: number, kelvin?: number, duration?: number): void;
+    /**
+     * Grid layout for LIFX Ceiling (8×8):
+     *   Row 0: [off,off, up, up, up, up,off,off]  ← uplight top
+     *   Rows 1–6: [z1,z2,z3,z4,z5,z6,z7,z8]      ← downlight zones
+     *   Row 7: [off,off, up, up, up, up,off,off]  ← uplight bottom
+     */
+    private createCeilingGrid;
+    private createHorizontalGradient;
+    private createPalettePattern;
+    setAll(colors: number | number[], kelvin?: number, duration?: number, mode?: DisplayMode): void;
+    setDownlight(colors: number | number[], kelvin?: number, duration?: number, mode?: DisplayMode): void;
+    setUplight(color: number | number[], kelvin?: number, duration?: number): void;
+    /** @param zoneColors - Array of 8 hex colors, one per zone (left→right) */
+    setZonesCustom(zoneColors: number[], kelvin?: number, duration?: number): void;
+    getLightData(auth: string): Promise<LightData>;
+    setEffect(fxName: EffectName, auth: string, options?: EffectOptions): Promise<unknown>;
+    stopEffect(auth: string): Promise<unknown>;
+    close(): void;
+}
+
+export { type BreatheEffectOptions, type DisplayMode, type EffectName, type EffectOptions, type FlameEffectOptions, type HSBK, LifxLAN, type LightData, type MorphEffectOptions, type MoveDirection, type MoveEffectOptions, type PulseEffectOptions, LifxLAN as default };

package/index.js

@@ -0,0 +1,619 @@
+const dgram = require('dgram');
+const axios = require('axios');
+
+class LifxLAN {
+  constructor(ip, port = 56700) {
+    this.ip = ip;
+    this.port = port;
+    this.socket = dgram.createSocket('udp4');
+    this.source = Math.floor(Math.random() * 0xFFFFFFFF); // Random source ID
+    this.sequence = 0;
+  }
+
+  // Build LIFX protocol header
+  buildHeader(messageType, size = 36, target = '000000000000', ackRequired = false, resRequired = false) {
+    const header = Buffer.alloc(36);
+    
+    // Frame
+    header.writeUInt16LE(size, 0); // Size
+    header.writeUInt16LE(0x3400, 2); // Protocol (0x3400 = 1024 with tagged, addressable, protocol bits)
+    header.writeUInt32LE(this.source, 4); // Source
+    
+    // Frame address
+    const targetBytes = Buffer.from(target, 'hex');
+    targetBytes.copy(header, 8); // Target (8 bytes)
+    header.fill(0, 16, 22); // Reserved
+    header.writeUInt8((resRequired ? 0x01 : 0x00) | (ackRequired ? 0x02 : 0x00), 22); // Ack/Res flags
+    header.writeUInt8(this.sequence++, 23); // Sequence
+    
+    // Protocol header
+    header.fill(0, 24, 32); // Reserved
+    header.writeUInt16LE(messageType, 32); // Message type
+    header.fill(0, 34, 36); // Reserved
+    
+    return header;
+  }
+
+  // Convert RGB to HSBK for LIFX
+  rgbToHsbk(r, g, b, kelvin = 3500) {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const delta = max - min;
+    
+    let h = 0;
+    let s = max === 0 ? 0 : delta / max;
+    let br = max;
+    
+    if (delta !== 0) {
+      if (max === r) {
+        h = ((g - b) / delta + (g < b ? 6 : 0)) / 6;
+      } else if (max === g) {
+        h = ((b - r) / delta + 2) / 6;
+      } else {
+        h = ((r - g) / delta + 4) / 6;
+      }
+    }
+    
+    return {
+      hue: Math.round(h * 65535),        // 0-65535
+      saturation: Math.round(s * 65535), // 0-65535
+      brightness: Math.round(br * 65535),// 0-65535
+      kelvin: kelvin                     // 2500-9000
+    };
+  }
+
+  // Set light color (message type 102)
+  setColor(hue, saturation, brightness, kelvin = 3500, duration = 0) {
+    const header = this.buildHeader(102, 49);
+    const payload = Buffer.alloc(13);
+    
+    payload.writeUInt8(0, 0); // Reserved
+    payload.writeUInt16LE(hue, 1);
+    payload.writeUInt16LE(saturation, 3);
+    payload.writeUInt16LE(brightness, 5);
+    payload.writeUInt16LE(kelvin, 7);
+    payload.writeUInt32LE(duration, 9); // Duration in milliseconds
+    
+    const packet = Buffer.concat([header, payload]);
+    
+    this.socket.send(packet, 0, packet.length, this.port, this.ip, (err) => {
+      if (err) console.error('Error sending packet:', err);
+      else console.log(`Color set to H:${hue} S:${saturation} B:${brightness} K:${kelvin}`);
+    });
+  }
+
+  // Set light color from RGB
+  setColorRGB(r, g, b, kelvin = 3500, duration = 0) {
+    const hsbk = this.rgbToHsbk(r, g, b, kelvin);
+    this.setColor(hsbk.hue, hsbk.saturation, hsbk.brightness, hsbk.kelvin, duration);
+  }
+
+  // Set light color from hex (0xRRGGBB)
+  setColorHex(hex, kelvin = 3500, duration = 0) {
+    const r = (hex >> 16) & 0xFF;
+    const g = (hex >> 8) & 0xFF;
+    const b = hex & 0xFF;
+    this.setColorRGB(r, g, b, kelvin, duration);
+  }
+
+  // Set power state (message type 117)
+  setPower(level, duration = 0) {
+    const header = this.buildHeader(117, 42);
+    const payload = Buffer.alloc(6);
+    
+    payload.writeUInt16LE(level, 0); // 0 = off, 65535 = on
+    payload.writeUInt32LE(duration, 2); // Duration in milliseconds
+    
+    const packet = Buffer.concat([header, payload]);
+    
+    this.socket.send(packet, 0, packet.length, this.port, this.ip, (err) => {
+      if (err) console.error('Error sending packet:', err);
+      else console.log(`Power set to ${level > 0 ? 'ON' : 'OFF'}`);
+    });
+  }
+
+  // Turn light on
+  on(duration = 0) {
+    this.setPower(65535, duration);
+  }
+
+  // Turn light off
+  off(duration = 0) {
+    this.setPower(0, duration);
+  }
+
+  // Set brightness (0.0 to 1.0 or 0 to 65535)
+  // This adjusts brightness without changing color
+  setBrightness(brightness, duration = 0) {
+    // Normalize brightness to 0-65535 range
+    const brightnessValue = brightness <= 1 ? Math.round(brightness * 65535) : brightness;
+    
+    // Use SetLightPower with level for instant brightness change
+    // Or use SetColor with duration for smooth transition
+    // We'll use message type 102 (SetColor) with reserved byte 0x01 to maintain current color
+    const header = this.buildHeader(102, 49);
+    const payload = Buffer.alloc(13);
+    
+    payload.writeUInt8(0x01, 0); // Reserved = 0x01 means "use current hue/saturation"
+    payload.writeUInt16LE(0, 1); // Hue (ignored when reserved = 0x01)
+    payload.writeUInt16LE(0, 3); // Saturation (ignored when reserved = 0x01)
+    payload.writeUInt16LE(brightnessValue, 5); // Brightness
+    payload.writeUInt16LE(0, 7); // Kelvin (0 means use current)
+    payload.writeUInt32LE(duration, 9); // Duration in milliseconds
+    
+    const packet = Buffer.concat([header, payload]);
+    
+    this.socket.send(packet, 0, packet.length, this.port, this.ip, (err) => {
+      if (err) console.error('Error sending packet:', err);
+      else console.log(`Brightness set to ${Math.round((brightnessValue/65535)*100)}% over ${duration}ms`);
+    });
+  }
+
+  // Convenience method: Set brightness as percentage (0-100)
+  setBrightnessPercent(percent, duration = 0) {
+    const brightness = Math.max(0, Math.min(100, percent)) / 100;
+    this.setBrightness(brightness, duration);
+  }
+
+  // Fade brightness over time (in seconds)
+  fadeBrightness(targetBrightness, seconds) {
+    const duration = seconds * 1000; // Convert to milliseconds
+    this.setBrightness(targetBrightness, duration);
+  }
+
+  // Fade brightness as percentage over time (in seconds)
+  fadeBrightnessPercent(targetPercent, seconds) {
+    const brightness = Math.max(0, Math.min(100, targetPercent)) / 100;
+    const duration = seconds * 1000;
+    this.setBrightness(brightness, duration);
+  }
+
+  // Set zones for multi-zone lights (message type 501)
+  setZones(startZone, endZone, hue, saturation, brightness, kelvin = 3500, duration = 0, apply = 1) {
+    const header = this.buildHeader(501, 49);
+    const payload = Buffer.alloc(15);
+    
+    payload.writeUInt8(startZone, 0);
+    payload.writeUInt8(endZone, 1);
+    payload.writeUInt16LE(hue, 2);
+    payload.writeUInt16LE(saturation, 4);
+    payload.writeUInt16LE(brightness, 6);
+    payload.writeUInt16LE(kelvin, 8);
+    payload.writeUInt32LE(duration, 10);
+    payload.writeUInt8(apply, 14); // 0 = NO_APPLY, 1 = APPLY, 2 = APPLY_ONLY
+    
+    const packet = Buffer.concat([header, payload]);
+    
+    this.socket.send(packet, 0, packet.length, this.port, this.ip, (err) => {
+      if (err) console.error('Error sending packet:', err);
+      else console.log(`Zones ${startZone}-${endZone} set`);
+    });
+  }
+
+  // Set zones with hex color
+  setZonesHex(startZone, endZone, hex, kelvin = 3500, duration = 0, apply = 1) {
+    const r = (hex >> 16) & 0xFF;
+    const g = (hex >> 8) & 0xFF;
+    const b = hex & 0xFF;
+    const hsbk = this.rgbToHsbk(r, g, b, kelvin);
+    this.setZones(startZone, endZone, hsbk.hue, hsbk.saturation, hsbk.brightness, kelvin, duration, apply);
+  }
+
+  // Set tile state for matrix devices (message type 715)
+  // tileIndex: which tile/segment (0-based)
+  // colors: array of 64 HSBK objects for 8x8 grid
+  setTileState64(tileIndex, colors, duration = 0, x = 0, y = 0, width = 8) {
+    // Payload structure:
+    // tile_index: 1, length: 1, reserved: 1, x: 1, y: 1, width: 1, duration: 4 = 10 bytes
+    // colors: 64 * 8 bytes = 512 bytes
+    // Total: 522 bytes
+    const payloadSize = 10 + (64 * 8); // 522 bytes
+    const totalSize = 36 + payloadSize; // 558 bytes total
+    const header = this.buildHeader(715, totalSize);
+    const payload = Buffer.alloc(payloadSize);
+    
+    payload.writeUInt8(tileIndex, 0);
+    payload.writeUInt8(1, 1); // Length (1 tile)
+    payload.writeUInt8(0, 2); // Reserved
+    payload.writeUInt8(x, 3); // X position
+    payload.writeUInt8(y, 4); // Y position
+    payload.writeUInt8(width, 5); // Width
+    payload.writeUInt32LE(duration, 6); // Duration at offset 6-9
+    
+    // Write 64 colors (8x8 grid) starting at offset 10
+    for (let i = 0; i < 64; i++) {
+      const offset = 10 + (i * 8);
+      const color = colors[i] || { hue: 0, saturation: 0, brightness: 0, kelvin: 3500 };
+      payload.writeUInt16LE(color.hue, offset);
+      payload.writeUInt16LE(color.saturation, offset + 2);
+      payload.writeUInt16LE(color.brightness, offset + 4);
+      payload.writeUInt16LE(color.kelvin, offset + 6);
+    }
+    
+    const packet = Buffer.concat([header, payload]);
+    
+    this.socket.send(packet, 0, packet.length, this.port, this.ip, (err) => {
+      if (err) console.error('Error sending packet:', err);
+      else console.log(`Tile ${tileIndex} state set`);
+    });
+  }
+
+  // Helper: Set a single tile to one color
+  setTileSolid(tileIndex, hue, saturation, brightness, kelvin = 3500, duration = 0) {
+    const color = { hue, saturation, brightness, kelvin };
+    const colors = new Array(64).fill(color);
+    this.setTileState64(tileIndex, colors, duration);
+  }
+
+  // Helper: Set a single tile to one hex color
+  setTileSolidHex(tileIndex, hex, kelvin = 3500, duration = 0) {
+    const r = (hex >> 16) & 0xFF;
+    const g = (hex >> 8) & 0xFF;
+    const b = hex & 0xFF;
+    const hsbk = this.rgbToHsbk(r, g, b, kelvin);
+    this.setTileSolid(tileIndex, hsbk.hue, hsbk.saturation, hsbk.brightness, kelvin, duration);
+  }
+
+  // LIFX Ceiling specific methods
+  // The ceiling has an 8x8 grid where zones are arranged as shown in your app
+  
+  // Set all zones (downlight + uplight)
+  setAll(colors, kelvin = 3500, duration = 0, mode = 'solid') {
+    // Mode can be: 'solid', 'gradient', 'blend', 'palette'
+    if (mode === 'solid') {
+      // Single color for everything
+      const color = Array.isArray(colors) ? colors[0] : colors;
+      this.setColorHex(color, kelvin, duration);
+    } else if (mode === 'gradient') {
+      // Gradient across entire light
+      const colorArray = Array.isArray(colors) ? colors : [colors];
+      const gridColors = this.createHorizontalGradient(colorArray, colorArray[0], kelvin);
+      this.setTileState64(0, gridColors, duration);
+    } else if (mode === 'palette') {
+      // Palette pattern across entire light
+      const colorArray = Array.isArray(colors) ? colors : [colors];
+      const gridColors = this.createPalettePattern(colorArray, colorArray, kelvin);
+      this.setTileState64(0, gridColors, duration);
+    }
+  }
+
+  // Set downlight only (all 8 zones in the middle rows)
+  setDownlight(colors, kelvin = 3500, duration = 0, mode = 'solid') {
+    const colorArray = Array.isArray(colors) ? colors : [colors];
+    
+    if (mode === 'solid') {
+      // Set all downlight zones to the same color
+      const gridColors = this.createCeilingGrid(colorArray[0], null, colorArray);
+      this.setTileState64(0, gridColors, duration);
+    } else {
+      // Apply pattern to downlight zones
+      const gridColors = this.createCeilingGridPattern(colorArray, null, mode, kelvin);
+      this.setTileState64(0, gridColors, duration);
+    }
+  }
+
+  // Set uplight only (top and bottom rows with null edges)
+  setUplight(color, kelvin = 3500, duration = 0, mode = 'solid') {
+    const colorArray = Array.isArray(color) ? color : [color];
+    
+    if (mode === 'solid') {
+      const gridColors = this.createCeilingGrid(null, colorArray[0], null);
+      this.setTileState64(0, gridColors, duration);
+    } else {
+      // Palette mode for uplight
+      const gridColors = this.createCeilingGridPattern(null, colorArray, mode, kelvin);
+      this.setTileState64(0, gridColors, duration);
+    }
+  }
+
+  // Set specific zones (1-8, left to right)
+  // zoneColors: array of 8 hex colors, one for each zone
+  setZonesCustom(zoneColors, kelvin = 3500, duration = 0) {
+    const gridColors = this.createCeilingGrid(null, null, zoneColors, kelvin);
+    this.setTileState64(0, gridColors, duration);
+  }
+
+  // Helper: Create the 8x8 grid for LIFX Ceiling
+  // Layout: [null,null,1,2,3,4,null,null] (uplight top)
+  //         [1,2,3,4,5,6,7,8] (zones x6)
+  //         [null,null,1,2,3,4,null,null] (uplight bottom)
+  createCeilingGrid(downlightColor = null, uplightColor = null, zoneColors = null, kelvin = 3500) {
+    const grid = [];
+    const black = { hue: 0, saturation: 0, brightness: 0, kelvin };
+    
+    // Convert hex colors to HSBK
+    const getHSBK = (hex) => {
+      if (hex === null || hex === undefined) return black;
+      const r = (hex >> 16) & 0xFF;
+      const g = (hex >> 8) & 0xFF;
+      const b = hex & 0xFF;
+      return this.rgbToHsbk(r, g, b, kelvin);
+    };
+
+    // Row 0: Uplight top [null,null,1,2,3,4,null,null]
+    for (let i = 0; i < 8; i++) {
+      if (i < 2 || i > 5) {
+        grid.push(black);
+      } else {
+        grid.push(uplightColor !== null ? getHSBK(uplightColor) : black);
+      }
+    }
+
+    // Rows 1-6: Downlight zones [1,2,3,4,5,6,7,8]
+    for (let row = 1; row <= 6; row++) {
+      for (let zone = 0; zone < 8; zone++) {
+        if (zoneColors && Array.isArray(zoneColors)) {
+          grid.push(getHSBK(zoneColors[zone]));
+        } else if (downlightColor !== null) {
+          grid.push(getHSBK(downlightColor));
+        } else {
+          grid.push(black);
+        }
+      }
+    }
+
+    // Row 7: Uplight bottom [null,null,1,2,3,4,null,null]
+    for (let i = 0; i < 8; i++) {
+      if (i < 2 || i > 5) {
+        grid.push(black);
+      } else {
+        grid.push(uplightColor !== null ? getHSBK(uplightColor) : black);
+      }
+    }
+
+    return grid;
+  }
+
+  // Helper: Create gradient/blend/palette patterns
+  createCeilingGridPattern(downlightColors, uplightColors, mode, kelvin = 3500) {
+    const grid = [];
+    const black = { hue: 0, saturation: 0, brightness: 0, kelvin };
+    
+    const getHSBK = (hex) => {
+      if (hex === null || hex === undefined) return black;
+      const r = (hex >> 16) & 0xFF;
+      const g = (hex >> 8) & 0xFF;
+      const b = hex & 0xFF;
+      return this.rgbToHsbk(r, g, b, kelvin);
+    };
+
+    // For now, implementing basic gradient/palette
+    // You can expand this based on how the app implements these modes
+    
+    if (mode === 'gradient' && downlightColors && downlightColors.length >= 2) {
+      // Horizontal gradient across zones
+      return this.createHorizontalGradient(downlightColors, uplightColors, kelvin);
+    } else if (mode === 'palette' && downlightColors) {
+      // Distribute palette colors across zones
+      return this.createPalettePattern(downlightColors, uplightColors, kelvin);
+    }
+    
+    // Default to solid
+    return this.createCeilingGrid(
+      downlightColors ? downlightColors[0] : null,
+      uplightColors ? uplightColors[0] : null,
+      null,
+      kelvin
+    );
+  }
+
+  // Create horizontal gradient
+  createHorizontalGradient(colors, uplightColor = null, kelvin = 3500) {
+    const grid = [];
+    const black = { hue: 0, saturation: 0, brightness: 0, kelvin };
+    
+    const getHSBK = (hex) => {
+      if (hex === null || hex === undefined) return black;
+      const r = (hex >> 16) & 0xFF;
+      const g = (hex >> 8) & 0xFF;
+      const b = hex & 0xFF;
+      return this.rgbToHsbk(r, g, b, kelvin);
+    };
+
+    const uplightHSBK = uplightColor ? getHSBK(uplightColor) : black;
+
+    // Row 0: Uplight
+    for (let i = 0; i < 8; i++) {
+      grid.push(i < 2 || i > 5 ? black : uplightHSBK);
+    }
+
+    // Rows 1-6: Gradient across 8 zones
+    for (let row = 1; row <= 6; row++) {
+      for (let zone = 0; zone < 8; zone++) {
+        // Interpolate between colors based on zone position
+        const colorIndex = Math.floor((zone / 7) * (colors.length - 1));
+        const nextIndex = Math.min(colorIndex + 1, colors.length - 1);
+        const t = ((zone / 7) * (colors.length - 1)) - colorIndex;
+        
+        const c1 = getHSBK(colors[colorIndex]);
+        const c2 = getHSBK(colors[nextIndex]);
+        
+        // Linear interpolation
+        grid.push({
+          hue: Math.round(c1.hue + (c2.hue - c1.hue) * t),
+          saturation: Math.round(c1.saturation + (c2.saturation - c1.saturation) * t),
+          brightness: Math.round(c1.brightness + (c2.brightness - c1.brightness) * t),
+          kelvin
+        });
+      }
+    }
+
+    // Row 7: Uplight
+    for (let i = 0; i < 8; i++) {
+      grid.push(i < 2 || i > 5 ? black : uplightHSBK);
+    }
+
+    return grid;
+  }
+
+  // Create palette pattern (distribute colors across zones)
+  createPalettePattern(colors, uplightColors = null, kelvin = 3500) {
+    const grid = [];
+    const black = { hue: 0, saturation: 0, brightness: 0, kelvin };
+    
+    const getHSBK = (hex) => {
+      if (hex === null || hex === undefined) return black;
+      const r = (hex >> 16) & 0xFF;
+      const g = (hex >> 8) & 0xFF;
+      const b = hex & 0xFF;
+      return this.rgbToHsbk(r, g, b, kelvin);
+    };
+
+    const uplightHSBK = uplightColors && uplightColors.length > 0 ? getHSBK(uplightColors[0]) : black;
+
+    // Row 0: Uplight
+    for (let i = 0; i < 8; i++) {
+      grid.push(i < 2 || i > 5 ? black : uplightHSBK);
+    }
+
+    // Rows 1-6: Palette distributed across zones
+    for (let row = 1; row <= 6; row++) {
+      for (let zone = 0; zone < 8; zone++) {
+        const colorIndex = zone % colors.length;
+        grid.push(getHSBK(colors[colorIndex]));
+      }
+    }
+
+    // Row 7: Uplight
+    for (let i = 0; i < 8; i++) {
+      grid.push(i < 2 || i > 5 ? black : uplightHSBK);
+    }
+
+    return grid;
+  }
+
+  // Web API Methods - Require authentication token
+  
+  // Get light data from LIFX HTTP API
+  async getLightData(auth) {
+    const options = {
+      method: 'GET',
+      url: 'https://api.lifx.com/v1/lights',
+      headers: {
+        accept: 'application/json',
+        Authorization: `Bearer ${auth}`
+      }
+    };
+    
+    try {
+      const response = await axios.request(options);
+      // Find the light matching this IP address
+      const light = response.data.find(l => 
+        l.group && l.group.id && this.ip
+      ) || response.data[0];
+      
+      return light;
+    } catch (error) {
+      console.error('Error fetching light data:', error.response ? error.response.data : error.message);
+      throw error;
+    }
+  }
+
+  // Set effect using LIFX HTTP API
+  // Available effects: pulse, breathe, move, morph, flame
+  async setEffect(fxName, auth, options = {}) {
+    try {
+      // First get the light ID
+      const lightData = await this.getLightData(auth);
+      const lightId = lightData.id;
+      
+      // Default options for each effect
+      const defaultOptions = {
+        pulse: {
+          color: 'blue',
+          from_color: null,
+          period: 1,
+          cycles: 5,
+          persist: false,
+          power_on: true,
+          peak: 0.5
+        },
+        breathe: {
+          color: 'blue',
+          from_color: null,
+          period: 1,
+          cycles: 5,
+          persist: false,
+          power_on: true,
+          peak: 0.5
+        },
+        move: {
+          direction: 'forward',
+          period: 1,
+          cycles: 5,
+          power_on: true
+        },
+        morph: {
+          period: 5,
+          duration: null,
+          palette: ['red', 'green', 'blue'],
+          power_on: true
+        },
+        flame: {
+          period: 5,
+          duration: null,
+          power_on: true
+        }
+      };
+
+      // Merge user options with defaults
+      const effectOptions = {
+        ...defaultOptions[fxName],
+        ...options
+      };
+
+      const requestOptions = {
+        method: 'POST',
+        url: `https://api.lifx.com/v1/lights/${lightId}/effects/${fxName}`,
+        headers: {
+          accept: 'application/json',
+          Authorization: `Bearer ${auth}`,
+          'content-type': 'application/json'
+        },
+        data: effectOptions
+      };
+
+      const response = await axios.request(requestOptions);
+      console.log(`Effect '${fxName}' applied successfully`);
+      return response.data;
+    } catch (error) {
+      console.error('Error applying effect:', error.response ? error.response.data : error.message);
+      throw error;
+    }
+  }
+
+  // Stop any running effect
+  async stopEffect(auth) {
+    try {
+      const lightData = await this.getLightData(auth);
+      const lightId = lightData.id;
+
+      const options = {
+        method: 'POST',
+        url: `https://api.lifx.com/v1/lights/${lightId}/effects/off`,
+        headers: {
+          accept: 'application/json',
+          Authorization: `Bearer ${auth}`
+        }
+      };
+
+      const response = await axios.request(options);
+      console.log('Effect stopped');
+      return response.data;
+    } catch (error) {
+      console.error('Error stopping effect:', error.response ? error.response.data : error.message);
+      throw error;
+    }
+  }
+
+  // Close socket
+  close() {
+    this.socket.close();
+  }
+}
+
+module.exports = LifxLAN;

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@west7014/lifx-lan",
+  "version": "1.0.2",
+  "description": "a simple package that aims to bring all available features to LIFX devices over LAN with some API-based features as well",
+  "keywords": [
+    "lifx",
+    "lan",
+    "smart-light",
+    "iot",
+    "home-automation"
+  ],
+  "author": {
+    "email": "west701497@gmail.com",
+    "name": "Katt",
+    "url": "https://github.com/thatWest7014"
+  },
+  "contributors": [
+    "simplyKit (https://github.com/simplyKit)"
+  ],
+  "files": [
+    "./index.js",
+    "./index.d.ts",
+    "LICENSE",
+    "./README.md"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thatWest7014/LIFX-LAN-Client-Node.git"
+  },
+  "type": "commonjs",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "peerDependencies": {
+    "axios": ">=1.0.0",
+    "dotenv": "16.4.5"
+  },
+  "peerDependenciesMeta": {
+    "dotenv": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}