node-red-contrib-tts-ultimate 3.1.1 → 3.2.1

package/ttsultimate/lib/dlna-player.js

@@ -0,0 +1,163 @@
+// Minimal native DLNA / UPnP MediaRenderer control client.
+// Unlike upnp-mediarenderer-client, it locates the AVTransport / RenderingControl
+// services anywhere in the device tree (root device OR embedded <deviceList> devices),
+// so it also works with renderers that nest a MediaRenderer sub-device (e.g. Sonos).
+//
+// It uses only the built-in http module (no XML parser dependency): the UPnP
+// description and SOAP responses are simple enough to read with focused regexes.
+const http = require("http");
+const { URL } = require("url");
+
+function httpRequest(options, body) {
+    return new Promise((resolve, reject) => {
+        const req = http.request(options, (res) => {
+            let data = "";
+            res.on("data", (c) => (data += c));
+            res.on("end", () => resolve({ statusCode: res.statusCode, body: data }));
+        });
+        req.on("error", reject);
+        req.on("timeout", () => { req.destroy(new Error("request timeout")); });
+        if (body) req.write(body);
+        req.end();
+    });
+}
+
+function getText(xml, tag) {
+    const m = xml.match(new RegExp("<" + tag + "[^>]*>([\\s\\S]*?)</" + tag + ">", "i"));
+    return m ? m[1].trim() : "";
+}
+
+function escapeXml(s) {
+    return String(s)
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+
+// Fetch the device description and resolve the (absolute) control URLs for
+// AVTransport and RenderingControl, scanning every <service> in the document.
+async function resolveServices(descriptionUrl) {
+    let u;
+    try {
+        u = new URL(descriptionUrl);
+    } catch (e) {
+        throw new Error('invalid DLNA renderer URL "' + descriptionUrl + '": use the full device description XML URL (e.g. http://192.168.1.50:49153/nmrDescription.xml), not just the IP address');
+    }
+    if (!/^https?:$/.test(u.protocol)) {
+        throw new Error('DLNA renderer URL must start with http:// (got "' + descriptionUrl + '")');
+    }
+    const res = await httpRequest({
+        hostname: u.hostname,
+        port: u.port || 80,
+        path: u.pathname + u.search,
+        method: "GET",
+        timeout: 5000
+    });
+    if (!res.body) throw new Error("empty device description");
+    const xml = res.body;
+    const urlBase = getText(xml, "URLBase");
+    const base = urlBase || descriptionUrl;
+
+    const services = {};
+    const svcRe = /<service>([\s\S]*?)<\/service>/g;
+    let m;
+    while ((m = svcRe.exec(xml)) !== null) {
+        const block = m[1];
+        const type = getText(block, "serviceType");
+        const ctrl = getText(block, "controlURL");
+        if (!type || !ctrl) continue;
+        const controlURL = new URL(ctrl, base).href;
+        // Match exact service ids; ":service:RenderingControl:" will not match "GroupRenderingControl".
+        if (/:service:AVTransport:\d/i.test(type) && !services.AVTransport) {
+            services.AVTransport = { type, controlURL };
+        } else if (/:service:RenderingControl:\d/i.test(type) && !services.RenderingControl) {
+            services.RenderingControl = { type, controlURL };
+        }
+    }
+    if (!services.AVTransport) throw new Error("AVTransport service not found in device description");
+    return services;
+}
+
+function soapAction(controlURL, serviceType, action, argsXml) {
+    const u = new URL(controlURL);
+    const body =
+        '<?xml version="1.0" encoding="utf-8"?>' +
+        '<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">' +
+        "<s:Body>" +
+        '<u:' + action + ' xmlns:u="' + serviceType + '">' + argsXml + "</u:" + action + ">" +
+        "</s:Body></s:Envelope>";
+    return httpRequest({
+        hostname: u.hostname,
+        port: u.port || 80,
+        path: u.pathname + u.search,
+        method: "POST",
+        timeout: 8000,
+        headers: {
+            "Content-Type": 'text/xml; charset="utf-8"',
+            "SOAPACTION": '"' + serviceType + "#" + action + '"',
+            "Content-Length": Buffer.byteLength(body)
+        }
+    }, body).then((res) => {
+        if (res.statusCode >= 400) {
+            const errCode = getText(res.body, "errorCode");
+            throw new Error("SOAP " + action + " failed: HTTP " + res.statusCode + (errCode ? " (UPnP error " + errCode + ")" : ""));
+        }
+        return res.body;
+    });
+}
+
+function buildDidl(url, contentType) {
+    const protocolInfo = "http-get:*:" + (contentType || "audio/mpeg") + ":*";
+    return (
+        '<DIDL-Lite xmlns="urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/" ' +
+        'xmlns:dc="http://purl.org/dc/elements/1.1/" ' +
+        'xmlns:upnp="urn:schemas-upnp-org:metadata-1-0/upnp/">' +
+        '<item id="0" parentID="-1" restricted="1">' +
+        "<dc:title>TTS</dc:title>" +
+        "<upnp:class>object.item.audioItem.musicTrack</upnp:class>" +
+        '<res protocolInfo="' + protocolInfo + '">' + escapeXml(url) + "</res>" +
+        "</item></DIDL-Lite>"
+    );
+}
+
+// createPlayer(descriptionUrl) -> { setVolume, setAVTransportURI, play, getTransportState }
+function createPlayer(descriptionUrl) {
+    let servicesPromise = null;
+    const getServices = () => {
+        if (!servicesPromise) servicesPromise = resolveServices(descriptionUrl);
+        return servicesPromise;
+    };
+
+    return {
+        async setVolume(volume0to100) {
+            const svc = await getServices();
+            if (!svc.RenderingControl) return; // not all renderers expose volume control
+            const args =
+                "<InstanceID>0</InstanceID><Channel>Master</Channel>" +
+                "<DesiredVolume>" + Math.max(0, Math.min(100, Math.round(volume0to100))) + "</DesiredVolume>";
+            return soapAction(svc.RenderingControl.controlURL, svc.RenderingControl.type, "SetVolume", args);
+        },
+        async setAVTransportURI(url, contentType) {
+            const svc = await getServices();
+            const didl = buildDidl(url, contentType);
+            const args =
+                "<InstanceID>0</InstanceID>" +
+                "<CurrentURI>" + escapeXml(url) + "</CurrentURI>" +
+                "<CurrentURIMetaData>" + escapeXml(didl) + "</CurrentURIMetaData>";
+            return soapAction(svc.AVTransport.controlURL, svc.AVTransport.type, "SetAVTransportURI", args);
+        },
+        async play() {
+            const svc = await getServices();
+            return soapAction(svc.AVTransport.controlURL, svc.AVTransport.type, "Play", "<InstanceID>0</InstanceID><Speed>1</Speed>");
+        },
+        async getTransportState() {
+            const svc = await getServices();
+            const bodyXml = await soapAction(svc.AVTransport.controlURL, svc.AVTransport.type, "GetTransportInfo", "<InstanceID>0</InstanceID>");
+            return getText(bodyXml, "CurrentTransportState");
+        }
+    };
+}
+
+module.exports = { createPlayer, resolveServices };

package/ttsultimate/lib/googlecast-discovery.js

@@ -0,0 +1,69 @@
+// Discover Google Cast devices (Chromecast / Google Nest) on the local network
+// via mDNS / DNS-SD (service "_googlecast._tcp.local").
+const mdns = require("multicast-dns");
+
+const SERVICE = "_googlecast._tcp.local";
+
+// discoverCastDevices({ timeoutMs }) -> Promise<[{ name, host }]>
+function discoverCastDevices(options) {
+    const opts = options || {};
+    const timeoutMs = Number(opts.timeoutMs) || 4000;
+
+    return new Promise((resolve) => {
+        let socket;
+        try {
+            socket = mdns();
+        } catch (error) {
+            resolve([]);
+            return;
+        }
+
+        const srvByName = new Map(); // service instance name -> target hostname
+        const fnByName = new Map();  // service instance name -> friendly name (TXT "fn=")
+        const ipByHost = new Map();  // hostname -> IPv4 address
+
+        const handleRecords = (records) => {
+            (records || []).forEach((r) => {
+                if (!r || !r.name) return;
+                if (r.type === "SRV" && /_googlecast\._tcp/i.test(r.name) && r.data) {
+                    srvByName.set(r.name, r.data.target);
+                } else if (r.type === "TXT" && /_googlecast\._tcp/i.test(r.name)) {
+                    const arr = Array.isArray(r.data) ? r.data : [r.data];
+                    arr.forEach((entry) => {
+                        const s = (entry || "").toString();
+                        if (/^fn=/i.test(s)) fnByName.set(r.name, s.slice(3));
+                    });
+                } else if (r.type === "A" && r.data) {
+                    ipByHost.set(r.name, r.data);
+                }
+            });
+        };
+
+        socket.on("response", (response) => {
+            handleRecords(response.answers);
+            handleRecords(response.additionals);
+        });
+
+        const query = () => {
+            try { socket.query({ questions: [{ name: SERVICE, type: "PTR" }] }); } catch (e) { }
+        };
+        query();
+        setTimeout(query, 800);
+
+        setTimeout(() => {
+            try { socket.destroy(); } catch (e) { }
+            const devices = [];
+            const seenIp = new Set();
+            srvByName.forEach((target, name) => {
+                const ip = ipByHost.get(target);
+                if (!ip || seenIp.has(ip)) return;
+                seenIp.add(ip);
+                const fn = fnByName.get(name) || name.split(".")[0];
+                devices.push({ name: fn, host: ip });
+            });
+            resolve(devices);
+        }, timeoutMs);
+    });
+}
+
+module.exports = { discoverCastDevices };

package/ttsultimate/lib/googletranslate.js

@@ -0,0 +1,140 @@
+// Native Google Translate TTS implementation.
+// Replaces the external "google-translate-tts" dependency.
+// Exposes the same public API: { synthesize, voices }.
+//
+// It performs an unauthenticated POST to the Google Translate web endpoint
+// (the same one the translate.google.com page uses for the "listen" button)
+// and decodes the base64 MP3 audio from the response.
+const https = require("https");
+
+// ---------------------------------------------------------------------------
+// Voices supported by Google Translate (free, unauthenticated) TTS.
+// ---------------------------------------------------------------------------
+const voices = (() => {
+    // prettier-ignore
+    const list = [
+        { code: "af-ZA",       name: "Afrikaans" },
+        { code: "sq",          name: "Albanian" },
+        { code: "ar-AE",       name: "Arabic" },
+        { code: "hy",          name: "Armenian" },
+        { code: "bn-BD",       name: "Bengali (Bangladesh)" },
+        { code: "bn-IN",       name: "Bengali (India)" },
+        { code: "bs",          name: "Bosnian" },
+        { code: "my",          name: "Burmese (Myanmar)" },
+        { code: "ca-ES",       name: "Catalan" },
+        { code: "cmn-Hant-TW", name: "Chinese" },
+        { code: "hr-HR",       name: "Croatian" },
+        { code: "cs-CZ",       name: "Czech" },
+        { code: "da-DK",       name: "Danish" },
+        { code: "nl-NL",       name: "Dutch" },
+        { code: "en-AU",       name: "English (Australia)" },
+        { code: "en-GB",       name: "English (United Kingdom)" },
+        { code: "en-US",       name: "English (United States)" },
+        { code: "eo",          name: "Esperanto" },
+        { code: "et",          name: "Estonian" },
+        { code: "fil-PH",      name: "Filipino" },
+        { code: "fi-FI",       name: "Finnish" },
+        { code: "fr-FR",       name: "French" },
+        { code: "fr-CA",       name: "French (Canada)" },
+        { code: "de-DE",       name: "German" },
+        { code: "el-GR",       name: "Greek" },
+        { code: "gu",          name: "Gujarati" },
+        { code: "hi-IN",       name: "Hindi" },
+        { code: "hu-HU",       name: "Hungarian" },
+        { code: "is-IS",       name: "Icelandic" },
+        { code: "id-ID",       name: "Indonesian" },
+        { code: "it-IT",       name: "Italian" },
+        { code: "ja-JP",       name: "Japanese (Japan)" },
+        { code: "kn",          name: "Kannada" },
+        { code: "km",          name: "Khmer" },
+        { code: "ko-KR",       name: "Korean" },
+        { code: "la",          name: "Latin" },
+        { code: "lv",          name: "Latvian" },
+        { code: "mk",          name: "Macedonian" },
+        { code: "ml",          name: "Malayalam" },
+        { code: "mr",          name: "Marathi" },
+        { code: "ne",          name: "Nepali" },
+        { code: "nb-NO",       name: "Norwegian" },
+        { code: "pl-PL",       name: "Polish" },
+        { code: "pt-BR",       name: "Portuguese" },
+        { code: "ro-RO",       name: "Romanian" },
+        { code: "ru-RU",       name: "Russian" },
+        { code: "sr-RS",       name: "Serbian" },
+        { code: "si",          name: "Sinhala" },
+        { code: "sk-SK",       name: "Slovak" },
+        { code: "es-MX",       name: "Spanish (Mexico)" },
+        { code: "es-ES",       name: "Spanish (Spain)" },
+        { code: "sw",          name: "Swahili" },
+        { code: "sv-SE",       name: "Swedish" },
+        { code: "ta",          name: "Tamil" },
+        { code: "te",          name: "Telugu" },
+        { code: "th-TH",       name: "Thai" },
+        { code: "tr-TR",       name: "Turkish" },
+        { code: "uk-UA",       name: "Ukrainian" },
+        { code: "ur",          name: "Urdu" },
+        { code: "vi-VN",       name: "Vietnamese" },
+        { code: "cy",          name: "Welsh" }
+    ];
+
+    list.findByCode = (code) => list.find((l) => l.code === code);
+    list.findByName = (name) => list.find((l) => l.name === name);
+
+    return list;
+})();
+
+// ---------------------------------------------------------------------------
+// synthesize({ text, voice, slow }) -> Promise<Buffer> (MP3 audio)
+// ---------------------------------------------------------------------------
+const requestOptions = {
+    headers: {
+        "content-type": "application/x-www-form-urlencoded",
+    },
+    hostname: "translate.google.com",
+    method: "POST",
+    path: "/_/TranslateWebserverUi/data/batchexecute",
+};
+
+// Builds the urlencoded "f.req" body expected by the batchexecute endpoint.
+const buildBody = ({ slow = false, text, voice }) => {
+    const values = JSON.stringify([text, voice, slow ? true : null, "null"]);
+    const data = JSON.stringify([[["jQ1olc", values, null, "generic"]]]);
+    const params = new URLSearchParams({ "f.req": data });
+    return params.toString();
+};
+
+const httpRequest = (opts) =>
+    new Promise((resolve, reject) => {
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => (data += chunk));
+            res.on("end", () => resolve(data));
+        });
+        req.on("error", reject);
+        req.write(buildBody(opts));
+        req.end();
+    });
+
+/* Response looks like:
+ *
+ *   )]}'
+ *
+ *   [["wrb.fr","jQ1olc","[\"<base 64 data>\"]"]]
+ *   ,["di",52]
+ *   ,["af.httprm",51,"8692744518077823928",2]
+ *   ]
+ */
+const toBuffer = (response) => {
+    const slice = response.split("\n").slice(1).join("");
+    const json = JSON.parse(slice);
+    const dataString = json[0][2];
+    const dataArray = JSON.parse(dataString);
+
+    if (dataArray === null)
+        throw new Error("Unable to parse audio data. Check your request params.");
+
+    return Buffer.from(dataArray[0], "base64");
+};
+
+const synthesize = (opts) => httpRequest(opts).then(toBuffer);
+
+module.exports = { synthesize, voices };

package/ttsultimate/ttsultimate-config copy.js

@@ -13,7 +13,7 @@ module.exports = function (RED) {
     // Setting up the engines
     const AWS = require('aws-sdk');
     const GoogleTTS = require('@google-cloud/text-to-speech');
-    const GoogleTranslate = require('google-translate-tts'); // TTS without credentials, limited to 200 chars per row.
+    const GoogleTranslate = require('./lib/googletranslate'); // Native TTS without credentials, limited to 200 chars per row.
     const microsoftAzureTTS = require("microsoft-cognitiveservices-speech-sdk"); // 12/10/2021
     const elevenlabsTTS = require("elevenlabs-node"); // 03/08/2023
     const ElevenLabsClient = require("elevenlabs").ElevenLabsClient;

package/ttsultimate/ttsultimate-config.html

@@ -218,8 +218,8 @@
 # TTS Service node
 Here you can set all parameters you need. All nodes will refer to this config node, so you need to set it only once.<br/> 
 IF YOU RUN NODE-RED BEHIND DOCKER OR SOMETHING ELSE, BE AWARE: <br/>
-PORT USED BY THE NODE ARE 1980 (DEFAULT) AND 1400 (FOR SONOS DISCOVER). <br/>
-PLEASE ALLOW MDNS AND UDP AS WELL
+PORT USED BY THE NODE ARE 1980 (DEFAULT, HTTP FILE SERVER) AND 1400 (FOR SONOS DISCOVER). <br/>
+PLEASE ALLOW MDNS AND UDP AS WELL (USED TO DISCOVER SONOS, GOOGLE CAST AND DLNA/UPNP DEVICES)
 
 	**TTS Service**<br/>
 	You can choose between Google (without credentials), Google TTS (require credentials and registration to google), ElevenLabs or Voice.ai TTS engines.<br/>
@@ -262,7 +262,7 @@ PLEASE ALLOW MDNS AND UDP AS WELL
 set IP of your node-red machine. Write **AUTODISCOVER** to allow the node to auto discover your IP.
 
 **Host Port**<br/>
-Sonos will connect to this port in order to play TTS. Default 1980. Choose a free port. Do not use 1880 or any other port already in use on your computer.
+The players (Sonos, Google Cast, DLNA/UPnP renderers) will connect to this port to fetch the TTS audio. Default 1980. Choose a free port. Do not use 1880 or any other port already in use on your computer. The port must be reachable from the players on your network.
 
 **TTS Cache**
 <br/>

package/ttsultimate/ttsultimate-config.js

@@ -11,7 +11,7 @@ module.exports = function (RED) {
 
     // Setting up the engines
     const GoogleTTS = require('@google-cloud/text-to-speech');
-    const GoogleTranslate = require('google-translate-tts'); // TTS without credentials, limited to 200 chars per row.
+    const GoogleTranslate = require('./lib/googletranslate'); // Native TTS without credentials, limited to 200 chars per row.
     const elevenlabsTTS = require("elevenlabs-node"); // 03/08/2023
     const ElevenLabsClient = require("elevenlabs").ElevenLabsClient;
 
@@ -20,6 +20,8 @@ module.exports = function (RED) {
     var formidable = require('formidable');
     const oOS = require('os');
     const sonos = require('sonos');
+    const dlnaDiscovery = require('./lib/dlna-discovery'); // 06/2026 SSDP discovery of DLNA/UPnP renderers
+    const castDiscovery = require('./lib/googlecast-discovery'); // 06/2026 mDNS discovery of Google Cast devices
 
     const VOICEAI_API_BASE_URL = "https://dev.voice.ai/api/v1/tts";
 
@@ -326,6 +328,38 @@ module.exports = function (RED) {
         });
 
 
+        // 06/2026 Discover DLNA/UPnP MediaRenderers on the network (for the "dlna" player type)
+        RED.httpAdmin.get("/ttsultimateDiscoverDLNA", RED.auth.needsPermission('TTSConfigNode.read'), function (req, res) {
+            dlnaDiscovery.discoverRenderers({ timeoutMs: 4000 }).then((devices) => {
+                // Same shape as sonosgetAllGroups: { name, host }. For DLNA the "host" is the description URL.
+                const list = devices.map((d) => ({
+                    name: d.name || "Renderer",
+                    host: d.location
+                }));
+                res.json(list);
+            }).catch((error) => {
+                RED.log.warn('ttsultimate-config ' + node.id + ': Error discovering DLNA renderers ' + error.message);
+                res.json("ERRORDISCOVERY");
+            });
+        });
+
+
+        // 06/2026 Discover Google Cast devices (Chromecast / Nest) on the network (for the "googlecast" player type)
+        RED.httpAdmin.get("/ttsultimateDiscoverCast", RED.auth.needsPermission('TTSConfigNode.read'), function (req, res) {
+            castDiscovery.discoverCastDevices({ timeoutMs: 4000 }).then((devices) => {
+                // Same shape as sonosgetAllGroups: { name, host }
+                const list = devices.map((d) => ({
+                    name: d.name,
+                    host: d.host
+                }));
+                res.json(list);
+            }).catch((error) => {
+                RED.log.warn('ttsultimate-config ' + node.id + ': Error discovering Google Cast devices ' + error.message);
+                res.json("ERRORDISCOVERY");
+            });
+        });
+
+
         // 09/03/2020 Get list of filenames in hailing folder
         RED.httpAdmin.get("/getHailingFilesList", RED.auth.needsPermission('TTSConfigNode.read'), function (req, res) {
             var jListOwnFiles = [];
@@ -680,45 +714,81 @@ module.exports = function (RED) {
                 var url_parts = url.parse(req.url, true);
                 var query = url_parts.query;
 
-                res.setHeader('Content-Disposition', 'attachment; filename=tts.mp3')
                 if (!query || query.f === undefined || query.f === null) {
-                    res.write("File not specified");
-                    res.end();
+                    res.statusCode = 400;
+                    res.end("File not specified");
                     return;
                 }
 
                 const requestedPath = query.f.toString();
-                if (fs.existsSync(requestedPath)) {
-                    // Security check: allow only mp3 files under the configured storage folder.
-                    const resolvedRequested = path.resolve(requestedPath);
-                    const resolvedAllowedRoot = path.resolve(node.TTSRootFolderPath);
-                    const isInsideRoot =
-                        resolvedRequested === resolvedAllowedRoot || resolvedRequested.startsWith(resolvedAllowedRoot + path.sep);
-
-                    if (path.extname(resolvedRequested) === ".mp3" && isInsideRoot) {
-                        var readStream = fs.createReadStream(resolvedRequested);
-                        readStream.on("error", function (error) {
-                            RED.log.error("ttsultimate-config " + node.id + ": Playsonos error opening stream : " + resolvedRequested + ' : ' + error);
-                            res.end();
-                            return;
-                        });
-                        readStream.pipe(res);
-                    } else {
-                        res.write("NOT ALLOWED");
-                        res.end();
-                    }
+                if (!fs.existsSync(requestedPath)) {
+                    RED.log.error("ttsultimate-config " + node.id + ": Playsonos RED.httpAdmin file not found: " + query.f);
+                    res.statusCode = 404;
+                    res.end("File not found");
+                    return;
+                }
 
-                    // http://localhost:1980/tts?f=/etc/passwd                 
+                // Security check: allow only mp3 files under the configured storage folder.
+                // http://localhost:1980/tts?f=/etc/passwd
+                const resolvedRequested = path.resolve(requestedPath);
+                const resolvedAllowedRoot = path.resolve(node.TTSRootFolderPath);
+                const isInsideRoot =
+                    resolvedRequested === resolvedAllowedRoot || resolvedRequested.startsWith(resolvedAllowedRoot + path.sep);
+                if (path.extname(resolvedRequested) !== ".mp3" || !isInsideRoot) {
+                    res.statusCode = 403;
+                    res.end("NOT ALLOWED");
+                    return;
+                }
 
-                } else {
-                    RED.log.error("ttsultimate-config " + node.id + ": Playsonos RED.httpAdmin file not found: " + query.f);
-                    res.write("File not found");
+                // Serve as a proper streaming media response. Strict DLNA renderers (e.g. some TVs)
+                // require Content-Type, Content-Length, byte-range support and DLNA headers to start playing.
+                const total = fs.statSync(resolvedRequested).size;
+                res.setHeader('Content-Type', 'audio/mpeg');
+                res.setHeader('Content-Disposition', 'inline; filename="tts.mp3"');
+                res.setHeader('Accept-Ranges', 'bytes');
+                res.setHeader('transferMode.dlna.org', 'Streaming');
+                res.setHeader('contentFeatures.dlna.org', 'DLNA.ORG_OP=01;DLNA.ORG_CI=0;DLNA.ORG_FLAGS=01700000000000000000000000000000');
+
+                // HEAD: headers only (many DLNA renderers probe with HEAD before playing).
+                if (req.method === 'HEAD') {
+                    res.setHeader('Content-Length', total);
+                    res.statusCode = 200;
                     res.end();
+                    return;
                 }
 
+                let readStream;
+                const range = req.headers.range;
+                if (range) {
+                    const m = /bytes=(\d*)-(\d*)/.exec(range);
+                    let start = m && m[1] ? parseInt(m[1], 10) : 0;
+                    let end = m && m[2] ? parseInt(m[2], 10) : total - 1;
+                    if (isNaN(start)) start = 0;
+                    if (isNaN(end) || end >= total) end = total - 1;
+                    if (start > end || start >= total) {
+                        res.statusCode = 416;
+                        res.setHeader('Content-Range', 'bytes */' + total);
+                        res.end();
+                        return;
+                    }
+                    res.statusCode = 206;
+                    res.setHeader('Content-Range', 'bytes ' + start + '-' + end + '/' + total);
+                    res.setHeader('Content-Length', (end - start) + 1);
+                    readStream = fs.createReadStream(resolvedRequested, { start: start, end: end });
+                } else {
+                    res.statusCode = 200;
+                    res.setHeader('Content-Length', total);
+                    readStream = fs.createReadStream(resolvedRequested);
+                }
+                readStream.on("error", function (error) {
+                    RED.log.error("ttsultimate-config " + node.id + ": Playsonos error opening stream : " + resolvedRequested + ' : ' + error);
+                    try { res.end(); } catch (e) { }
+                });
+                readStream.pipe(res);
+
             } catch (error) {
                 RED.log.error("ttsultimate-config " + node.id + ": Playsonos RED.httpAdmin error: " + error);
-                res.end();
+                try { res.end(); } catch (e) { }
             }
 
         }