wiim2mqtt 0.1.0

package/index.js

@@ -0,0 +1,386 @@
+#!/usr/bin/env node
+
+import os from 'node:os';
+import mqttLib from 'mqtt';
+import log from './lib/log.js';
+import {parseConfig} from './config.js';
+import pkg from './package.json' with {type: 'json'};
+import {parsePayload, StatusTracker} from './lib/payload.js';
+import {commandFor, OPTIONAL_PAYLOAD} from './lib/commands.js';
+import {buildDiscovery} from './lib/hadiscovery.js';
+import {HttpApi} from './lib/api.js';
+import {UpnpClient} from './lib/upnp.js';
+import {Device} from './lib/device.js';
+
+const config = parseConfig();
+
+if (config.install || config.uninstall) {
+    const {installService, uninstallService} = await import('./lib/install.js');
+    const plain = (...args) => console.log(...args);
+    try {
+        if (config.uninstall) {
+            uninstallService(config, plain);
+        } else {
+            installService(config, plain);
+        }
+        process.exit(0);
+    } catch (err) {
+        console.error('error:', err.message);
+        process.exit(1);
+    }
+}
+
+if (config.probe) {
+    const api = new HttpApi({baseUrl: config.apiUrl});
+    try {
+        const raw = await api.statusEx();
+        console.log(
+            JSON.stringify(
+                {
+                    name: raw.DeviceName,
+                    model: raw.project || raw.hardware,
+                    hardware: raw.hardware,
+                    firmware: raw.firmware,
+                    uuid: raw.uuid,
+                    mac: raw.MAC,
+                    ip: raw.eth0 && raw.eth0 !== '0.0.0.0' ? raw.eth0 : raw.apcli0,
+                    group: raw.group,
+                },
+                null,
+                2,
+            ),
+        );
+        process.exit(0);
+    } catch (err) {
+        console.error('error:', err.message);
+        process.exit(1);
+    }
+}
+
+const topicPrefix = config.name;
+const connectedTopic = topicPrefix + '/connected';
+
+let mqttConnected = false;
+let shuttingDown = false;
+const startedAt = Date.now();
+
+/** last known friendly values, also produces plain or {val, ts, lc} payloads */
+const status = new StatusTracker({json: config.jsonPayloads});
+
+/** items whose change requires a new discovery payload (options / device info) */
+const DISCOVERY_TRIGGERS = new Set(['source_list', 'preset_list', 'model', 'firmware', 'uuid', 'mac', 'ip']);
+/** internal items that are not published */
+const INTERNAL_ITEMS = new Set(['group_role_hint', 'track_source']);
+let discoveryDirty = true;
+
+log.setLevel(config.verbosity);
+
+log.info(pkg.name + ' ' + pkg.version + ' starting');
+log.info('mqtt trying to connect', config.mqttUrl);
+
+const mqtt = mqttLib.connect(config.mqttUrl, {
+    clientId: config.name + '_' + Math.random().toString(16).slice(2, 10),
+    username: config.mqttUsername,
+    password: config.mqttPassword,
+    will: {topic: connectedTopic, payload: '0', retain: true},
+});
+
+const api = new HttpApi({baseUrl: config.apiUrl, log});
+const upnp = config.upnp
+    ? new UpnpClient({
+          host: config.address,
+          port: config.upnpPort,
+          callbackHost: config.callbackHost,
+          callbackPort: config.callbackPort,
+          log,
+      })
+    : null;
+const device = new Device({
+    api,
+    upnp,
+    pollInterval: config.pollInterval,
+    positionInterval: config.positionInterval,
+    albumArtData: config.albumArtData,
+    log,
+});
+
+/*
+ * MQTT publishing
+ */
+
+function mqttPub(topic, payload, options) {
+    if (Buffer.isBuffer(payload)) {
+        log.debug('mqtt >', topic, `<${payload.length} bytes>`);
+        mqtt.publish(topic, payload, options);
+        return;
+    }
+    if (payload !== null && typeof payload === 'object') {
+        payload = JSON.stringify(payload);
+    }
+    log.debug('mqtt >', topic, payload);
+    mqtt.publish(topic, String(payload), options);
+}
+
+function publishConnected() {
+    if (!mqttConnected) {
+        return;
+    }
+    mqttPub(connectedTopic, device.connected ? '2' : '1', {retain: true});
+}
+
+/** Publish a friendly status item; tracks last values for discovery and json payloads. */
+function pubStatus(item, value, {retain = true} = {}) {
+    if (INTERNAL_ITEMS.has(item)) {
+        return;
+    }
+    if (item === 'album_art_data') {
+        if (mqttConnected) {
+            mqttPub(`${topicPrefix}/status/${item}`, value || Buffer.alloc(0), {retain: true});
+        }
+        return;
+    }
+    const {payload, changed} = status.update(item, value === null ? '' : value);
+    if (mqttConnected) {
+        mqttPub(`${topicPrefix}/status/${item}`, payload, {retain});
+    }
+    if (changed && DISCOVERY_TRIGGERS.has(item)) {
+        discoveryDirty = true;
+        publishDiscoveryIfDirty();
+    }
+    return changed;
+}
+
+/** Re-publish every known status (after an mqtt reconnect). */
+function republishStatus() {
+    for (const [item, entry] of status.state) {
+        if (item === 'position') {
+            continue;
+        }
+        mqttPub(`${topicPrefix}/status/${item}`, config.jsonPayloads ? entry : entry.val, {retain: true});
+    }
+}
+
+function publishInfo() {
+    if (!mqttConnected) {
+        return;
+    }
+    mqttPub(
+        `${topicPrefix}/info`,
+        {
+            name: pkg.name,
+            version: pkg.version,
+            node: process.version,
+            host: os.hostname(),
+            pid: process.pid,
+            started: new Date(startedAt).toISOString(),
+            uptime: Math.round((Date.now() - startedAt) / 1000),
+            address: config.address,
+            device: {
+                name: device.get('device_name'),
+                model: device.get('model'),
+                firmware: device.get('firmware'),
+                uuid: device.get('uuid'),
+                mac: device.get('mac'),
+                ip: device.get('ip'),
+                upnp: device.mode,
+            },
+        },
+        {retain: true},
+    );
+}
+
+function publishDiscoveryIfDirty() {
+    if (!config.haDiscovery || !discoveryDirty || !mqttConnected) {
+        return;
+    }
+    discoveryDirty = false;
+    const {topic, payload} = buildDiscovery({
+        name: config.name,
+        prefix: config.haPrefix,
+        get: (item) => status.get(item),
+        pkg,
+        jsonPayloads: config.jsonPayloads,
+        albumArtData: config.albumArtData,
+    });
+    log.info('mqtt publishing home assistant discovery', topic);
+    mqttPub(topic, payload, {retain: true});
+}
+
+function clearDiscovery() {
+    const {topic} = buildDiscovery({name: config.name, prefix: config.haPrefix, get: () => undefined, pkg});
+    mqttPub(topic, '', {retain: true});
+}
+
+mqtt.on('connect', () => {
+    const reconnect = mqttConnected;
+    mqttConnected = true;
+    log.info('mqtt connected', config.mqttUrl);
+    publishConnected();
+    publishInfo();
+
+    for (const topic of [topicPrefix + '/set/#', topicPrefix + '/get/#']) {
+        log.info('mqtt subscribe', topic);
+        mqtt.subscribe(topic);
+    }
+
+    if (config.haDiscovery) {
+        discoveryDirty = true;
+        publishDiscoveryIfDirty();
+    } else {
+        clearDiscovery();
+    }
+    if (reconnect || status.state.size > 0) {
+        republishStatus();
+    }
+});
+
+mqtt.on('close', () => {
+    if (mqttConnected) {
+        mqttConnected = false;
+        log.info('mqtt closed', config.mqttUrl);
+    }
+});
+
+mqtt.on('error', (err) => {
+    log.error('mqtt', err.message || err);
+});
+
+mqtt.on('message', (topic, payload) => {
+    payload = payload.toString();
+    log.debug('mqtt <', topic, payload);
+
+    const [prefix, action, ...parts] = topic.split('/');
+    if (prefix !== topicPrefix || !['set', 'get'].includes(action) || parts.length !== 1 || parts[0] === '') {
+        log.warn('mqtt ignoring unexpected topic', topic);
+        return;
+    }
+    const item = parts[0];
+    const value = parsePayload(payload);
+
+    if (action === 'get') {
+        handleGet(item).catch((err) => log.warn('get', item, 'failed:', err.message || err));
+        return;
+    }
+    handleSet(item, value, topic).catch((err) => {
+        log.warn('set', item, JSON.stringify(value), 'failed:', err.message || err);
+    });
+});
+
+const GET_MAP = {
+    status: 'status',
+    presets: 'presets',
+    preset_list: 'presets',
+    device: 'device',
+    group: 'group',
+    group_slaves: 'group',
+    metadata: 'metadata',
+};
+
+async function handleGet(item) {
+    const what = GET_MAP[item];
+    if (!what) {
+        log.warn('get', item, '- unknown (status, presets, device, group, metadata)');
+        return;
+    }
+    await device.refresh(what);
+}
+
+async function handleSet(item, value, topic) {
+    if (value === undefined && !OPTIONAL_PAYLOAD.has(item)) {
+        log.warn('mqtt ignoring empty payload on', topic);
+        return;
+    }
+    if (item === 'cmd' && !config.rawSet) {
+        log.warn('mqtt ignoring', topic, '(raw commands disabled, see --raw-set)');
+        return;
+    }
+    if (!device.connected) {
+        log.warn('set', item, '- device unreachable');
+        return;
+    }
+
+    let command;
+    try {
+        command = commandFor(item, value, (i) => device.get(i));
+    } catch (err) {
+        log.warn('set', item, JSON.stringify(value), '-', err.message);
+        return;
+    }
+    if (command.noop) {
+        return;
+    }
+
+    const before = Object.fromEntries((command.verify || []).map((i) => [i, device.get(i)]));
+    const result = await device.command(command.api, {target: command.target});
+    log.debug('set', item, '→', command.api, '=', typeof result === 'object' ? JSON.stringify(result) : result);
+    if (command.raw) {
+        pubStatus('cmd_result', typeof result === 'object' ? JSON.stringify(result) : String(result), {retain: false});
+        return;
+    }
+    if (typeof result === 'string' && !/^ok$/i.test(result) && result !== '') {
+        log.warn('set', item, '-', command.api, 'answered', result);
+    }
+    device.verify(command.verify, before);
+}
+
+/*
+ * device → mqtt
+ */
+
+device.on('connected', (connected) => {
+    publishConnected();
+    publishInfo();
+    if (!connected) {
+        pubStatus('play_state', 'stopped');
+    }
+});
+
+device.on('change', (item, value, {retain = true} = {}) => {
+    pubStatus(item, value, {retain});
+});
+
+device.on('upnp', () => publishInfo());
+
+const infoTimer = setInterval(publishInfo, 60000);
+
+device.start().catch((err) => {
+    log.error('device start failed:', err.message || err);
+});
+
+/*
+ * shutdown
+ */
+
+function shutdown(signal) {
+    if (shuttingDown) {
+        return;
+    }
+    shuttingDown = true;
+    log.info('received', signal, '- shutting down');
+    clearInterval(infoTimer);
+
+    const exit = () => process.exit(0);
+    const timer = setTimeout(exit, 3000);
+
+    device
+        .stop()
+        .catch(() => {})
+        .then(() => {
+            if (mqttConnected) {
+                mqtt.publish(connectedTopic, '0', {retain: true}, () => {
+                    mqtt.end(false, {}, () => {
+                        clearTimeout(timer);
+                        exit();
+                    });
+                });
+            } else {
+                mqtt.end(true, {}, () => {
+                    clearTimeout(timer);
+                    exit();
+                });
+            }
+        });
+}
+
+process.on('SIGINT', () => shutdown('SIGINT'));
+process.on('SIGTERM', () => shutdown('SIGTERM'));

package/lib/api.js

@@ -0,0 +1,249 @@
+/**
+ * WiiM / LinkPlay HTTP API client: https://<ip>/httpapi.asp?command=<cmd>
+ *
+ * - GET only (also for setters), self-signed certificate → TLS verification off.
+ * - Getters answer JSON with every number as a string, setters mostly a bare "OK",
+ *   some commands {"status":"OK"|"Failed"} or plain words.
+ * - Title/Artist/Album in getPlayerStatus are hex-encoded UTF-8.
+ * - Requests are serialised per device (one socket, one in flight).
+ */
+
+import http from 'node:http';
+import https from 'node:https';
+
+export class ApiError extends Error {
+    constructor(code, message, extra = {}) {
+        super(message);
+        this.name = 'ApiError';
+        this.code = code;
+        Object.assign(this, extra);
+    }
+}
+
+/** Decode a LinkPlay hex string (UTF-8); returns the input when it is not hex. */
+export function decodeHex(value) {
+    if (typeof value !== 'string' || value.length === 0 || value.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(value)) {
+        return value;
+    }
+    try {
+        const decoded = Buffer.from(value, 'hex').toString('utf8');
+        return decoded.includes('�') ? value : decoded;
+    } catch {
+        return value;
+    }
+}
+
+/** Encode a string as LinkPlay hex (for hex_playlist and friends). */
+export function encodeHex(value) {
+    return Buffer.from(String(value), 'utf8').toString('hex');
+}
+
+/** Normalise a raw response body: JSON when it looks like JSON, otherwise the trimmed string. */
+export function parseResponse(body) {
+    const text = String(body).trim();
+    if (text.startsWith('{') || text.startsWith('[')) {
+        try {
+            return JSON.parse(text);
+        } catch {
+            return text;
+        }
+    }
+    return text;
+}
+
+function num(value, fallback = 0) {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : fallback;
+}
+
+/** Normalise getPlayerStatus: numbers as numbers, hex strings decoded. */
+export function normalizePlayerStatus(raw) {
+    if (!raw || typeof raw !== 'object') {
+        throw new ApiError('EFORMAT', 'getPlayerStatus: unexpected response ' + JSON.stringify(raw));
+    }
+    return {
+        status: String(raw.status || ''),
+        mode: num(raw.mode),
+        loop: num(raw.loop),
+        eq: num(raw.eq),
+        curpos: num(raw.curpos),
+        totlen: num(raw.totlen),
+        plicount: num(raw.plicount),
+        plicurr: num(raw.plicurr),
+        vol: num(raw.vol),
+        mute: num(raw.mute) === 1,
+        type: num(raw.type),
+        title: raw.Title === undefined ? undefined : decodeHex(String(raw.Title)),
+        artist: raw.Artist === undefined ? undefined : decodeHex(String(raw.Artist)),
+        album: raw.Album === undefined ? undefined : decodeHex(String(raw.Album)),
+    };
+}
+
+/** Normalise getMetaInfo: returns null when the device has no metadata. */
+export function normalizeMetaInfo(raw) {
+    const meta = raw && typeof raw === 'object' && raw.metaData;
+    if (!meta || typeof meta !== 'object') {
+        return null;
+    }
+    const str = (v) => (v === undefined || v === null || v === 'unknow' || v === 'unknown' ? '' : String(v));
+    const int = (v) => (v === undefined || v === null || v === '' || v === 'unknow' ? null : num(v, null));
+    return {
+        title: str(meta.title),
+        artist: str(meta.artist),
+        album: str(meta.album),
+        albumArt: str(meta.albumArtURI),
+        sampleRate: int(meta.sampleRate),
+        bitDepth: int(meta.bitDepth),
+        bitrate: int(meta.bitRate),
+    };
+}
+
+function unknow(value) {
+    return value === undefined || value === null || value === 'unknow' || value === 'unknown' ? '' : String(value);
+}
+
+/** Normalise getPresetInfo → [{number, name, url, source, pic}] */
+export function normalizePresetInfo(raw) {
+    const list = raw && Array.isArray(raw.preset_list) ? raw.preset_list : [];
+    return list
+        .map((p) => ({
+            number: num(p.number),
+            name: String(p.name || ''),
+            url: unknow(p.url),
+            source: String(p.source || ''),
+            pic: unknow(p.picurl),
+        }))
+        .filter((p) => p.number > 0);
+}
+
+/** Normalise multiroom:getSlaveList → [{name, ip, uuid, version}] */
+export function normalizeSlaveList(raw) {
+    const list = raw && Array.isArray(raw.slave_list) ? raw.slave_list : [];
+    return list.map((s) => ({
+        name: decodeHex(String(s.name || '')),
+        ip: String(s.ip || ''),
+        uuid: String(s.uuid || ''),
+        version: String(s.version || ''),
+    }));
+}
+
+export class HttpApi {
+    /**
+     * @param {object} options
+     * @param {string} options.baseUrl e.g. https://192.168.1.30 (http:// for non-WiiM LinkPlay devices)
+     * @param {number} [options.timeout] per request, ms
+     * @param {object} [options.log] logger with debug()
+     */
+    constructor({baseUrl, timeout = 10000, log}) {
+        this.baseUrl = String(baseUrl).replace(/\/+$/, '');
+        this.timeout = timeout;
+        this.log = log;
+        const secure = this.baseUrl.startsWith('https:');
+        this.transport = secure ? https : http;
+        this.agent = new this.transport.Agent({
+            keepAlive: true,
+            maxSockets: 1,
+            ...(secure && {rejectUnauthorized: false}),
+        });
+        this.queue = Promise.resolve();
+    }
+
+    /** Send one raw command; resolves with the normalised response (string or object). */
+    command(cmd) {
+        const run = () => this.request(cmd);
+        const result = this.queue.then(run, run);
+        this.queue = result.catch(() => {});
+        return result;
+    }
+
+    request(cmd) {
+        const url = `${this.baseUrl}/httpapi.asp?command=${encodeURIComponent(cmd)}`;
+        if (this.log) {
+            this.log.debug('api >', cmd);
+        }
+        return new Promise((resolve, reject) => {
+            const req = this.transport.get(url, {agent: this.agent, timeout: this.timeout}, (res) => {
+                const chunks = [];
+                res.on('data', (c) => chunks.push(c));
+                res.on('end', () => {
+                    const body = Buffer.concat(chunks).toString('utf8');
+                    if (this.log) {
+                        this.log.debug('api <', cmd, body.length > 500 ? body.slice(0, 500) + '…' : body);
+                    }
+                    if (res.statusCode !== 200) {
+                        reject(new ApiError('EHTTP', `${cmd}: http ${res.statusCode}`, {statusCode: res.statusCode}));
+                        return;
+                    }
+                    const parsed = parseResponse(body);
+                    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed) && parsed.status === 'Failed') {
+                        reject(new ApiError('EFAILED', `${cmd}: device answered "Failed"`, {response: parsed}));
+                        return;
+                    }
+                    if (parsed === 'unknown command' || parsed === 'Unknown command') {
+                        reject(new ApiError('EUNKNOWN', `${cmd}: unknown command`, {response: parsed}));
+                        return;
+                    }
+                    resolve(parsed);
+                });
+                res.on('error', (err) => reject(wrap(cmd, err)));
+            });
+            req.on('timeout', () => {
+                req.destroy(new ApiError('ETIMEDOUT', `${cmd}: timeout after ${this.timeout} ms`));
+            });
+            req.on('error', (err) => reject(wrap(cmd, err)));
+        });
+    }
+
+    async playerStatus() {
+        return normalizePlayerStatus(await this.command('getPlayerStatus'));
+    }
+
+    async statusEx() {
+        const raw = await this.command('getStatusEx');
+        if (!raw || typeof raw !== 'object') {
+            throw new ApiError('EFORMAT', 'getStatusEx: unexpected response ' + JSON.stringify(raw));
+        }
+        return raw;
+    }
+
+    async metaInfo() {
+        try {
+            return normalizeMetaInfo(await this.command('getMetaInfo'));
+        } catch (err) {
+            if (err.code === 'EUNKNOWN' || err.code === 'EFAILED') {
+                return null;
+            }
+            throw err;
+        }
+    }
+
+    async presetInfo() {
+        return normalizePresetInfo(await this.command('getPresetInfo'));
+    }
+
+    async slaveList() {
+        return normalizeSlaveList(await this.command('multiroom:getSlaveList'));
+    }
+
+    setPlayerCmd(...parts) {
+        return this.command(['setPlayerCmd', ...parts].join(':'));
+    }
+
+    close() {
+        this.agent.destroy();
+    }
+}
+
+function wrap(cmd, err) {
+    if (err instanceof ApiError) {
+        return err;
+    }
+    const code = ['ECONNREFUSED', 'EHOSTUNREACH', 'ENETUNREACH', 'ENOTFOUND', 'ECONNRESET', 'EAI_AGAIN'].includes(
+        err.code,
+    )
+        ? 'ECONNFAILED'
+        : err.code === 'ETIMEDOUT'
+          ? 'ETIMEDOUT'
+          : 'EREQUEST';
+    return new ApiError(code, `${cmd}: ${err.message}`, {cause: err});
+}