scrypted-kasa 1.3.0 → 1.3.2

package/src/shared/cipher.ts

@@ -1,49 +0,0 @@
-// XOR-AB autokey cipher used by all Kasa "smarthome" endpoints (UDP/9999 discovery,
-// the LINKIE2 control protocol). Initial key 0xAB; each output byte becomes the next key,
-// so encrypt and decrypt only differ in which side feeds the key forward (the cipher byte
-// in both cases — the same primitive, just different direction).
-
-export function xorEncrypt(plaintext: Buffer): Buffer {
-    const out = Buffer.allocUnsafe(plaintext.length);
-    let key = 0xab;
-    for (let i = 0; i < plaintext.length; i++) {
-        const c = key ^ plaintext[i];
-        out[i] = c;
-        key = c;
-    }
-    return out;
-}
-
-export function xorDecrypt(ciphertext: Buffer): Buffer {
-    const out = Buffer.allocUnsafe(ciphertext.length);
-    let key = 0xab;
-    for (let i = 0; i < ciphertext.length; i++) {
-        const c = ciphertext[i];
-        out[i] = key ^ c;
-        key = c;
-    }
-    return out;
-}
-
-// In-place variants — overwrite the input buffer instead of allocating a fresh one. Use
-// when the caller owns the input (e.g., a freshly-allocated Buffer.from(...) it's about
-// to throw away). Saves an allocation + copy on every encrypt/decrypt pair.
-export function xorEncryptInPlace(plaintext: Buffer): Buffer {
-    let key = 0xab;
-    for (let i = 0; i < plaintext.length; i++) {
-        const c = key ^ plaintext[i];
-        plaintext[i] = c;
-        key = c;
-    }
-    return plaintext;
-}
-
-export function xorDecryptInPlace(ciphertext: Buffer): Buffer {
-    let key = 0xab;
-    for (let i = 0; i < ciphertext.length; i++) {
-        const c = ciphertext[i];
-        ciphertext[i] = key ^ c;
-        key = c;
-    }
-    return ciphertext;
-}

package/src/shared/discovery.ts

@@ -1,232 +0,0 @@
-import dgram from 'dgram';
-import { networkInterfaces } from 'os';
-import { xorDecryptInPlace, xorEncryptInPlace } from './cipher';
-
-export const KASA_DISCOVERY_PORT = 9999;
-const KASA_DISCOVERY_PROBE = '{"system":{"get_sysinfo":{}}}';
-
-// Encrypted probe payload built once at module load and reused across every discovery
-// sweep. dgram.send only reads from the buffer (never mutates), so sharing is safe.
-const KASA_DISCOVERY_PROBE_BUFFER = xorEncryptInPlace(Buffer.from(KASA_DISCOVERY_PROBE, 'utf8'));
-// Inbound UDP datagrams are owned by us (dgram allocates a fresh buffer per packet) and
-// not retained anywhere after the message handler returns, so in-place is safe.
-const xorDecryptToString = (b: Buffer) => xorDecryptInPlace(b).toString('utf8');
-
-export interface KasaSysInfo {
-    deviceId?: string;
-    alias?: string;
-    model?: string;
-    mac?: string;
-    mic_mac?: string;
-    type?: string;
-    mic_type?: string;
-    sw_ver?: string;
-    hw_ver?: string;
-    [key: string]: unknown;
-}
-
-export interface KasaDiscoveredDevice {
-    address: string;
-    deviceId: string;
-    alias: string;
-    model: string;
-    mac: string;
-    type: string;
-    sysinfo: KasaSysInfo;
-}
-
-// Compute IPv4 broadcast addresses of every non-loopback interface so the probe reaches every
-// LAN even on hosts with multiple NICs. Falls back to the global 255.255.255.255 always.
-function broadcastAddresses(): string[] {
-    const addrs = new Set<string>(['255.255.255.255']);
-    const ifaces = networkInterfaces();
-    for (const name of Object.keys(ifaces)) {
-        for (const info of ifaces[name] || []) {
-            if (info.family !== 'IPv4' || info.internal) continue;
-            const ip = info.address.split('.').map(Number);
-            const mask = info.netmask.split('.').map(Number);
-            if (ip.length !== 4 || mask.length !== 4) continue;
-            const broadcast = ip.map((b, i) => (b & mask[i]) | (~mask[i] & 0xff));
-            addrs.add(broadcast.join('.'));
-        }
-    }
-    return [...addrs];
-}
-
-// All host IPs in each local /24 we're attached to (excluding our own). Used for paced UDP
-// unicast sweeps when broadcast misses devices. Networks that aren't exactly /24 are skipped
-// — sweeping a /23 or larger would flood, and treating a /25 or smaller as /24 would send
-// probes outside the actual subnet (wasted traffic + neighbor confusion).
-function* localSubnetIps(): Generator<string> {
-    // De-dupe across interfaces — multi-homed hosts (Wi-Fi + Ethernet on the same /24,
-    // VPN tunnels, etc.) would otherwise yield the same address twice and burn ~750 ms
-    // resending probes that have already been sent. Generator avoids materializing the full
-    // list (254 IPs per /24) when the caller pauses 3 ms between sends.
-    const seen = new Set<string>();
-    const ifaces = networkInterfaces();
-    for (const name of Object.keys(ifaces)) {
-        for (const info of ifaces[name] || []) {
-            if (info.family !== 'IPv4' || info.internal) continue;
-            const mask = info.netmask.split('.').map(Number);
-            // Require exact /24 (255.255.255.0). The mask[3] === 0 check rejects /25 etc.
-            if (mask.length !== 4 || mask[0] !== 255 || mask[1] !== 255 || mask[2] !== 255 || mask[3] !== 0) continue;
-            const ip = info.address.split('.').map(Number);
-            if (ip.length !== 4) continue;
-            const prefix = `${ip[0]}.${ip[1]}.${ip[2]}.`;
-            for (let host = 1; host < 255; host++) {
-                if (host === ip[3]) continue;
-                const addr = prefix + host;
-                if (seen.has(addr)) continue;
-                seen.add(addr);
-                yield addr;
-            }
-        }
-    }
-}
-
-// Best-effort extraction of sysinfo-like fields from a JSON response. Different Kasa device
-// families nest the same data under different keys (system.get_sysinfo for plugs, smartlife
-// .iot.IPCamera.* for cameras, etc.), so walk the tree and pick up whatever looks right.
-function extractSysInfo(json: any): KasaSysInfo | undefined {
-    if (!json || typeof json !== 'object') return;
-    const candidates: any[] = [];
-    const walk = (node: any, depth: number) => {
-        if (!node || typeof node !== 'object' || depth > 4) return;
-        if (
-            typeof node.model === 'string' ||
-            typeof node.alias === 'string' ||
-            typeof node.deviceId === 'string' ||
-            typeof node.dev_id === 'string'
-        )
-            candidates.push(node);
-        for (const v of Object.values(node)) walk(v, depth + 1);
-    };
-    walk(json, 0);
-    if (!candidates.length) return;
-    // Prefer the candidate with the most identifying fields populated.
-    candidates.sort((a, b) => fieldCount(b) - fieldCount(a));
-    const best = candidates[0];
-    return {
-        deviceId: best.deviceId || best.dev_id,
-        alias: best.alias,
-        model: best.model || best.hwId || best.hw_id,
-        mac: best.mic_mac || best.mac,
-        type: best.type || best.mic_type || best.deviceType,
-        ...best,
-    };
-}
-
-function fieldCount(o: any): number {
-    let n = 0;
-    if (o.model) n++;
-    if (o.alias) n++;
-    if (o.deviceId || o.dev_id) n++;
-    if (o.mac || o.mic_mac) n++;
-    if (o.type || o.mic_type) n++;
-    return n;
-}
-
-// One-shot UDP discovery: send a broadcast, then a paced unicast probe at every IP on the
-// local /24, all on a single socket while listening for replies. Cameras that ignore
-// broadcast (newer KC420WS firmware does) still answer the unicast hit. Pacing the unicast
-// sends a few ms apart prevents the network/kernel from dropping the burst — sending 250
-// packets back-to-back was the reason the earlier UDP-only attempt missed cameras.
-export async function discoverKasa(durationMs: number = 2500, console?: Console): Promise<KasaDiscoveredDevice[]> {
-    const found = new Map<string, KasaDiscoveredDevice>();
-    const probe = KASA_DISCOVERY_PROBE_BUFFER;
-    const socket = dgram.createSocket({ type: 'udp4', reuseAddr: true });
-
-    return new Promise((resolve, reject) => {
-        let done = false;
-        const finish = () => {
-            if (done) return;
-            done = true;
-            try {
-                socket.close();
-            } catch {}
-            resolve([...found.values()]);
-        };
-
-        socket.on('error', e => {
-            if (done) return;
-            done = true;
-            try {
-                socket.close();
-            } catch {}
-            reject(e);
-        });
-
-        socket.on('message', (msg, rinfo) => {
-            try {
-                const json = JSON.parse(xorDecryptToString(msg));
-                const sys = extractSysInfo(json);
-                if (!sys) return;
-                const deviceId = sys.deviceId || sys.mic_mac || sys.mac;
-                if (!deviceId) return;
-                if (found.has(deviceId)) return;
-                // Slim the retained sysinfo to fields actually consumed by adoption
-                // (classifyKasa, isDimmer, bulbCapabilities, firmware tag). Full sysinfo
-                // contains ~20 fields, most unused (oemId, latitude/longitude, c_opt, etc.).
-                // Cached entries live up to 5 minutes per device, so dropping the rest noticeably
-                // shrinks retained heap when many devices are on the LAN.
-                const slim: KasaSysInfo = {
-                    deviceId: sys.deviceId,
-                    alias: sys.alias,
-                    model: sys.model,
-                    mac: sys.mac,
-                    mic_mac: sys.mic_mac,
-                    type: sys.type,
-                    mic_type: sys.mic_type,
-                    sw_ver: sys.sw_ver,
-                    hw_ver: sys.hw_ver,
-                    dev_name: (sys as any).dev_name,
-                    feature: (sys as any).feature,
-                    brightness: (sys as any).brightness,
-                    is_color: (sys as any).is_color,
-                    is_variable_color_temp: (sys as any).is_variable_color_temp,
-                    children: (sys as any).children,
-                };
-                found.set(deviceId, {
-                    address: rinfo.address,
-                    deviceId,
-                    alias: sys.alias || '',
-                    model: sys.model || '',
-                    mac: (sys.mic_mac || sys.mac || '').toString(),
-                    type: (sys.type || sys.mic_type || '').toString(),
-                    sysinfo: slim,
-                });
-            } catch (e) {
-                console?.warn('kasa discovery: failed to parse reply from', rinfo.address, e);
-            }
-        });
-
-        socket.bind(0, async () => {
-            socket.setBroadcast(true);
-            // Hard deadline starts now; unicast pacing happens during the same window.
-            setTimeout(finish, durationMs);
-
-            // socket.send throws synchronously (ERR_SOCKET_DGRAM_NOT_RUNNING) if the
-            // deadline timer fires and closes the socket mid-sweep. Wrap both loops so
-            // that race can't crash the discovery promise — we just stop sending.
-            try {
-                for (const addr of broadcastAddresses()) socket.send(probe, KASA_DISCOVERY_PORT, addr);
-            } catch {
-                return;
-            }
-
-            // Paced unicast — ~3 ms between sends keeps a /24 sweep under 1 s of network
-            // traffic without flooding. Suppress per-target send errors (EHOSTDOWN spam from
-            // dead IPs is uninteresting and would dominate the log).
-            for (const addr of localSubnetIps()) {
-                if (done) break;
-                try {
-                    socket.send(probe, KASA_DISCOVERY_PORT, addr, () => {});
-                } catch {
-                    // Socket was closed (deadline elapsed) — stop sending.
-                    break;
-                }
-                await new Promise(r => setTimeout(r, 3));
-            }
-        });
-    });
-}

package/src/shared/readme.ts

@@ -1,20 +0,0 @@
-// Shared formatting helpers for the per-device + plugin-level Readme tabs. Scrypted's
-// markdown renderer is plain CommonMark — it doesn't recognize GFM pipe tables, so we
-// render tabular data inside fenced code blocks with manual column padding.
-
-// Format a hex MAC (e.g. "F0090D49721F") with colon separators (e.g. "F0:09:0D:49:72:1F").
-// Returns the input unchanged if it isn't a 12-character hex string — Kasa devices
-// occasionally surface MACs in already-colon-formatted form, and we don't want to mangle
-// either case.
-export function formatKasaMac(mac: string | undefined): string {
-    if (!mac) return '?';
-    if (!/^[0-9A-Fa-f]{12}$/.test(mac)) return mac;
-    return mac.match(/.{2}/g)!.join(':').toUpperCase();
-}
-
-// Render a list of [label, value] pairs as a left-padded plain-text block. Caller is
-// expected to wrap the output in triple-backtick fences so monospace alignment renders.
-export function renderKv(rows: [string, string][]): string {
-    const labelWidth = Math.max(...rows.map(([k]) => k.length));
-    return rows.map(([k, v]) => `${k.padEnd(labelWidth)}  ${v}`).join('\n');
-}

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-    "compilerOptions": {
-        "rootDir": "src",
-        "outDir": "build",
-        "module": "Node16",
-        "target": "ES2021",
-        "resolveJsonModule": true,
-        "moduleResolution": "Node16",
-        "esModuleInterop": true,
-        "sourceMap": true
-    },
-    "include": [
-        "src/**/*"
-    ]
-}