yeelight-raw 1.0.0

package/README.md

@@ -0,0 +1,83 @@
+# yeelight-raw
+
+Reliable fire-and-forget Yeelight LAN control using raw TCP writes
+
+## Why this exists
+
+I have experienced two significant issues while using `yeelight-node`:
+
+1. **Listener accumulation** — `_sendCommand` registers new `data`/`error` listeners on every call, causing MaxListeners warnings and eventual command drops.
+2. **Premature connected flag** — `_connect()` sets `this.connected = true` synchronously before the TCP connection is established, causing double-connect and more listener accumulation on repeated calls.
+
+`yeelight-raw` bypasses all of that by writing raw JSON directly to a single persistent `net.Socket`. One socket, one set of listeners, no accumulation.
+
+## Install
+
+```
+npm install yeelight-raw
+```
+
+No dependencies, `yeelight-raw` uses only Node.js built-ins (`net`, `dgram`, `events`).
+
+## Quick start
+
+```javascript
+const { discover } = require('yeelight-raw');
+
+const disc = discover((device) => {
+  console.log(`Found: ${device.ip}:${device.port}`);
+
+  device.on('error', (err) => console.error('Error:', err));
+  device.on('close', () => console.log('Disconnected'));
+
+  device.send('set_power', ['on', 'smooth', 500, 0]);
+  device.send('set_bright', [80, 'smooth', 500]);
+  device.send('set_rgb',    [255 * 65536 + 128 * 256 + 0, 'smooth', 500]);
+});
+
+setTimeout(() => disc.stop(), 10_000);
+```
+
+## Known device (no discovery)
+
+```javascript
+const { YeelightDevice } = require('yeelight-raw');
+
+const device = new YeelightDevice({ ip: '192.168.1.100', port: 55443 });
+device.on('error', (err) => console.error(err));
+device.send('toggle', []);
+```
+
+## Common commands
+
+| Action | method | params |
+|---|---|---|
+| Power on | `set_power` | `['on', 'smooth', 500, 0]` |
+| Power off | `set_power` | `['off', 'smooth', 500, 0]` |
+| Brightness | `set_bright` | `[value_1_to_100, 'smooth', 500]` |
+| RGB colour | `set_rgb` | `[r*65536 + g*256 + b, 'smooth', 500]` |
+| Toggle | `toggle` | `[]` |
+| Set name | `set_name` | `['My Light']` |
+
+## API
+
+### `discover(callback?)` → `YeelightDiscovery`
+
+Starts SSDP discovery and calls `callback(device)` for each new device found. Returns the `YeelightDiscovery` instance.
+
+### `YeelightDiscovery`
+
+- `search()` — send another M-SEARCH multicast
+- `stop()` — close the UDP socket and stop discovery
+- Events: `device`, `error`
+
+### `YeelightDevice`
+
+- `send(method, params)` — fire-and-forget command; connects lazily on first call
+- `destroy()` — close the TCP socket
+- Properties: `id`, `ip`, `port`, `state` (`{ on, brightness, rgb }`)
+- Events: `error`, `close`
+
+## License
+
+MIT

package/example.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { discover } = require('.');
+
+// Optional: pass a command as CLI args, e.g.:
+//   node example.js set_power on smooth 500 0
+//   node example.js toggle
+//   node example.js set_bright 50 smooth 500
+const [,, method, ...rawParams] = process.argv;
+
+// Coerce numeric strings to numbers so params are typed correctly
+const params = rawParams.map(p => isNaN(p) ? p : Number(p));
+
+console.log('Searching for Yeelight devices (10s timeout)...\n');
+
+const disc = discover((device) => {
+  console.log(`Found device:`);
+  console.log(`  ID:         ${device.id}`);
+  console.log(`  IP:         ${device.ip}:${device.port}`);
+  console.log(`  Power:      ${device.state.on ? 'on' : 'off'}`);
+  console.log(`  Brightness: ${device.state.brightness}%`);
+  console.log(`  RGB:        ${device.state.rgb}`);
+
+  device.on('error', (err) => console.error(`  [error] ${err.message}`));
+  device.on('close', ()    => console.log(`  [close] ${device.ip} disconnected`));
+
+  if (method) {
+    console.log(`\n  -> Sending: ${method}(${params.join(', ')})`);
+    device.send(method, params);
+  }
+});
+
+disc.on('error', (err) => console.error('Discovery error:', err.message));
+
+setTimeout(() => {
+  disc.stop();
+  console.log('\nDone.');
+  process.exit(0);
+}, 10_000);

package/index.js

@@ -0,0 +1,147 @@
+'use strict';
+
+const net    = require('net');
+const dgram  = require('dgram');
+const { EventEmitter } = require('events');
+
+const MULTICAST_ADDR = '239.255.255.250';
+const MULTICAST_PORT = 1982;
+const SEARCH_MSG = Buffer.from(
+  'M-SEARCH * HTTP/1.1\r\n' +
+  `HOST: ${MULTICAST_ADDR}:${MULTICAST_PORT}\r\n` +
+  'MAN: "ssdp:discover"\r\n' +
+  'ST: wifi_bulb'
+);
+
+class YeelightDevice extends EventEmitter {
+  constructor({ id, ip, port, state = {} }) {
+    super();
+    this.id    = id;
+    this.ip    = ip;
+    this.port  = Number(port);
+    this.state = state;
+
+    this._connected = false;
+    this._queue     = [];
+
+    this._socket = new net.Socket();
+    this._socket.setEncoding('utf8');
+    this._socket.setKeepAlive(true, 10000);
+    this._socket.on('connect', () => {
+      this._connected = true;
+      for (const payload of this._queue) this._socket.write(payload);
+      this._queue = [];
+    });
+    this._socket.on('error', (err) => this.emit('error', err));
+    this._socket.on('close', () => {
+      this._connected = false;
+      this.emit('close');
+    });
+  }
+
+  _connectIfNeeded() {
+    if (!this._connected && !this._socket.connecting) {
+      this._socket.connect(this.port, this.ip);
+    }
+  }
+
+  // Fire-and-forget. Connects lazily on first call; queues the write until
+  // the TCP connection is established.
+  send(method, params) {
+    const payload = JSON.stringify({ id: 1, method, params }) + '\r\n';
+    if (this._connected) {
+      this._socket.write(payload);
+    } else {
+      this._queue.push(payload);
+      this._connectIfNeeded();
+    }
+  }
+
+  destroy() {
+    this._socket.destroy();
+  }
+}
+
+class YeelightDiscovery extends EventEmitter {
+  constructor() {
+    super();
+    this._known  = new Set();
+    this._socket = null;
+    this._bind();
+  }
+
+  _bind() {
+    const socket = dgram.createSocket({ type: 'udp4', reuseAddr: true });
+
+    socket.on('message', (msg) => {
+      const data = this._parse(msg.toString());
+      if (!data['id'] || !data['Location']) return;
+
+      const id = parseInt(data['id'], 16);
+      if (isNaN(id) || this._known.has(id)) return;
+      this._known.add(id);
+
+      const m = data['Location'].match(/yeelight:\/\/([\d.]+):(\d+)/);
+      if (!m) return;
+
+      const device = new YeelightDevice({
+        id,
+        ip:   m[1],
+        port: m[2],
+        state: {
+          on:         data['power'] === 'on',
+          brightness: parseInt(data['bright'], 10) || 0,
+          rgb:        data['rgb'] || '0',
+        },
+      });
+      this.emit('device', device);
+    });
+
+    socket.on('error', (err) => {
+      this.emit('error', err);
+      socket.close();
+      setTimeout(() => this._bind(), 2000);
+    });
+
+    socket.on('listening', () => {
+      socket.addMembership(MULTICAST_ADDR);
+      this.search();
+    });
+
+    socket.bind(MULTICAST_PORT);
+    this._socket = socket;
+  }
+
+  // Send an SSDP M-SEARCH multicast. Safe to call multiple times.
+  search() {
+    if (!this._socket) return;
+    try {
+      this._socket.send(SEARCH_MSG, 0, SEARCH_MSG.length, MULTICAST_PORT, MULTICAST_ADDR);
+    } catch (_) {}
+  }
+
+  // Close the UDP socket and stop discovery.
+  stop() {
+    if (this._socket) {
+      try { this._socket.close(); } catch (_) {}
+      this._socket = null;
+    }
+  }
+
+  _parse(message) {
+    const result = {};
+    for (const line of message.split('\r\n')) {
+      const i = line.indexOf(': ');
+      if (i !== -1) result[line.slice(0, i)] = line.slice(i + 2);
+    }
+    return result;
+  }
+}
+
+function discover(callback) {
+  const disc = new YeelightDiscovery();
+  if (typeof callback === 'function') disc.on('device', callback);
+  return disc;
+}
+
+module.exports = { YeelightDevice, YeelightDiscovery, discover };

package/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "yeelight-raw",
+  "version": "1.0.0",
+  "description": "Reliable fire-and-forget Yeelight LAN control — raw TCP writes, no listener accumulation",
+  "main": "index.js",
+  "keywords": ["yeelight", "xiaomi", "smart-light", "iot", "lan-control"],
+  "license": "MIT",
+  "engines": { "node": ">=14" },
+  "repository": { "type": "git", "url": "" }
+}