node-red-contrib-tts-ultimate 3.0.7 → 3.2.0

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 [![Donate via PayPal](https://img.shields.io/badge/Donate-PayPal-blue.svg?style=flat-square)](https://www.paypal.me/techtoday)
 
+<b>Version 3.2.0</b> June 2026<br/>
+
+- NEW: **Google Cast** player (Chromecast / Google Nest). Devices are discovered via mDNS (press "Discover" in the node), with multi-room playback on the main device + additional players.<br/>
+- NEW: **DLNA / UPnP renderer** player (smart TVs, AV receivers, etc.). Devices are discovered via SSDP. A native UPnP client locates the AVTransport/RenderingControl services anywhere in the device tree, so it also works with renderers that nest a MediaRenderer sub-device (e.g. Sonos).<br/>
+- NEW: the "Additional players" list now works for Google Cast and DLNA too (not only Sonos), to play the announcement on several devices at once.<br/>
+- FIX: the built-in HTTP file server now serves the TTS audio with proper streaming headers (Content-Type, Content-Length, byte-range support and DLNA headers), so strict DLNA renderers (some TVs) start playing correctly.<br/>
+- CHORE: removed the "upnp-mediarenderer-client" dependency (replaced by a native UPnP client); added "castv2-client" and "multicast-dns".<br/>
+</p>
+
+<p>
+<b>Version 3.1.2</b> June 2026<br/>
+
+- CHORE: removed the external "google-translate-tts" dependency, replaced by a native built-in implementation (same voices and behaviour).<br/>
+- CHORE: removed the redundant "path" dependency (Node.js built-in module is used instead).<br/>
+</p>
+
+<p>
+<b>Version 3.1.1</b> June 2026<br/>
+
+- NEW: voice option fields (ElevenLabs Stability/Similarity/Style/Speed and Google Rate/Pitch) are now sliders showing the current value live.<br/>
+</p>
+
+<p>
+<b>Version 3.1.0</b> June 2026<br/>
+
+- NEW: refresh icon next to the "Voice" field to reload the voices list on demand.<br/>
+- NEW: ElevenLabs models are now read dynamically from the API (with a refresh icon), so new models appear automatically. Model-specific options (Style Exaggeration, Speaker boost) are enabled/disabled based on the capabilities reported by ElevenLabs.<br/>
+- NEW: ElevenLabs "Speed" option (0.7 - 1.2, default 1.0) for the v2 engine.<br/>
+</p>
+
+<p>
 <b>Version 3.0.7</b> March 2026<br/>
 
 - CHORE: fixed some issues with voice.ai.<br/>

package/README.md

@@ -161,7 +161,7 @@
 
 ## DESCRIPTION
 
-This node transforms a text into a speech audio that you can hear natively via <b>SONOS</b> speakers, but you can also simply create an audio file, without using SONOS at all.<br/>
+This node transforms a text into a speech audio that you can hear natively via <b>Sonos</b> speakers, <b>Google Cast</b> devices (Chromecast / Google Nest) and generic <b>DLNA/UPnP</b> renderers (smart TVs, AV receivers, etc.), but you can also simply create an audio file, without using any player at all.<br/>
 You can also generate an audio file for bluetooth speakers, web pages, etc.<br/>
 You can also use it with **your own audio file** as well and it can be used **totally offline** even without the use of TTS, without internet connection.<br/>
 The node can also create a **_TTS file (without the use of any Sonos device)_**, to be read by third parties nodes.<br/>
@@ -193,10 +193,12 @@ This is a major **_upgrade from the previously popular node SonosPollyTTS_** (So
 ## FEATURES
 
 - **Native Sonos support**: hear the TTS audio directly via Sonos. You can also group speakers, set an hailing sound, choose the volume of each speaker etc.
-- **Output audio file**: the node can just create the TTS file to be used by other nodes. In this case, you doesn't need to use Sonos as player.
+- **Google Cast support** (Chromecast / Google Nest): play the TTS directly on your Cast devices, with multi-room playback on several devices at once.
+- **DLNA / UPnP renderer support**: play the TTS on generic UPnP renderers (smart TVs, AV receivers, etc.). It also works with renderers that nest a MediaRenderer sub-device (e.g. Sonos).
+- **Output audio file**: the node can just create the TTS file to be used by other nodes. In this case, you don't need to use any player.
 - **Google Translate Voices, Google TTS Voices, ElevenLabs voices and Voice.ai voices** are supported.
-- **Automatic grouping** is supported. You can group all players you want to play your announcements.
-- **Automatic discovery** of your players.
+- **Automatic grouping / multi-room** is supported on Sonos, Google Cast and DLNA. You can add additional players to play your announcements on all of them at once.
+- **Automatic discovery** of your players: Sonos and DLNA/UPnP renderers via SSDP, Google Cast devices via mDNS. A "Discover" button in the node lists the devices found on your network.
 - **Automatic resume of music** queue (including radio stations, but here, some users reports problem resuming **_radio stations_** and, because of lack of Sonos API documentation, the issue cannot currently be fixed), at exact track, at exact time. **Be aware that this could not work with all music queues**.
 - **TTS caching**. ElevenLabs and Google paid service charge you for a high rate of text-to-speech requests. TTS-Ultimate caches the TTS files: it downloads each generated audio only once, and then reads it from cache. The cache is resilient (survives reboots and updates).
 - **Can work offline**. You can use your own audio files (with OwnFile node) to make the node works offline.
@@ -224,7 +226,7 @@ This is a major **_upgrade from the previously popular node SonosPollyTTS_** (So
 
 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/>
+PORT USED BY THE NODE ARE 1980 (DEFAULT, HTTP FILE SERVER) AND 1400 (FOR SONOS DISCOVER). <br/>
 PLEASE ALLOW MDNS AND UDP AS WELL
 
 **TTS Service**<br/>
@@ -265,7 +267,7 @@ For Google TTS Engine, you can choose pitch and speed rate of the voice.
 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.
 
 Note: if you use multiple `ttsultimate-config` nodes, each one now keeps its own TTS cache folder; the “purge on restart/deploy” option only affects that config node’s cache.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-red-contrib-tts-ultimate",
-  "version": "3.0.7",
-  "description": "Transforms the text in speech and hear it using Sonos player or generate an audio file to be used with third parties nodes. Works with voices from Google (without credentials as well), Google TTS, ElevenLabs.io TTS, Voice.ai TTS or your own voice. You can also only create a TTS file to be read by third party nodes. Update of the popular SonosPollyTTS node.",
+  "version": "3.2.0",
+  "description": "Transforms the text in speech and hear it using Sonos, Google Cast (Chromecast / Nest) or DLNA/UPnP players, or generate an audio file to be used with third parties nodes. Works with voices from Google (without credentials as well), Google TTS, ElevenLabs.io TTS, Voice.ai TTS or your own voice. You can also only create a TTS file to be read by third party nodes. Update of the popular SonosPollyTTS node.",
   "main": "index.js",
   "scripts": {
     "test": "test",
@@ -39,13 +39,13 @@
   },
   "homepage": "https://github.com/Supergiovane/node-red-contrib-tts-ultimate",
   "dependencies": {
-    "sonos": "1.14.1",
-    "formidable": "1.2.2",
-    "path": ">=0.12.7",
     "@google-cloud/text-to-speech": "4.2.2",
-    "google-translate-tts": ">=0.3.0",
+    "castv2-client": "^1.2.0",
+    "elevenlabs": "0.18.0",
     "elevenlabs-node": "1.1.3",
-    "elevenlabs": "0.18.0"
+    "formidable": "1.2.2",
+    "multicast-dns": "^7.2.5",
+    "sonos": "1.14.1"
   },
   "devDependencies": {
     "eslint": ">=4.18.2",
@@ -54,4 +54,4 @@
   "engines": {
     "node": ">=22.0.0"
   }
-}
+}

package/scripts/discover-dlna.js

@@ -0,0 +1,44 @@
+// Discover DLNA / UPnP MediaRenderer devices on the local network.
+// Prints the device description XML URL (LOCATION) to paste into the
+// tts-ultimate "DLNA / UPnP renderer" player configuration.
+//
+// Usage:
+//   node scripts/discover-dlna.js            (search ~5s)
+//   node scripts/discover-dlna.js --timeout 8000
+const { discoverRenderers } = require("../ttsultimate/lib/dlna-discovery");
+
+const argValue = (name, fallback) => {
+  const idx = process.argv.indexOf(name);
+  if (idx === -1) return fallback;
+  const value = process.argv[idx + 1];
+  return value && !value.startsWith("--") ? value : fallback;
+};
+
+const timeoutMs = Number(argValue("--timeout", 5000)) || 5000;
+
+(async () => {
+  // eslint-disable-next-line no-console
+  console.log(`Searching for DLNA/UPnP MediaRenderers for ${timeoutMs} ms...\n`);
+  const devices = await discoverRenderers({ timeoutMs });
+  if (devices.length === 0) {
+    // eslint-disable-next-line no-console
+    console.log("No MediaRenderer devices found. Make sure a renderer is on and on the same subnet.");
+    process.exit(0);
+  }
+  // eslint-disable-next-line no-console
+  console.log(`Found ${devices.length} renderer(s):\n`);
+  for (const dev of devices) {
+    // eslint-disable-next-line no-console
+    console.log("  " + (dev.name || "(unknown name)"));
+    // eslint-disable-next-line no-console
+    console.log("    Description URL (paste this in the node): " + dev.location);
+    if (dev.server) console.log("    Server: " + dev.server);
+    // eslint-disable-next-line no-console
+    console.log("");
+  }
+  process.exit(0);
+})().catch((err) => {
+  // eslint-disable-next-line no-console
+  console.error(err);
+  process.exit(1);
+});

package/scripts/verify-googletranslate-split.js

@@ -1,6 +1,6 @@
 const fs = require("fs");
 const path = require("path");
-const GoogleTranslate = require("google-translate-tts");
+const GoogleTranslate = require("../ttsultimate/lib/googletranslate");
 
 const GOOGLE_TRANSLATE_MAX_CHARS = 200;
 

package/ttsultimate/lib/dlna-discovery.js

@@ -0,0 +1,98 @@
+// Discover DLNA / UPnP MediaRenderer devices on the local network via SSDP.
+// No external dependencies: built-in dgram (UDP multicast) + http only.
+const dgram = require("dgram");
+const http = require("http");
+const { URL } = require("url");
+
+const SSDP_ADDR = "239.255.255.250";
+const SSDP_PORT = 1900;
+const SEARCH_TARGET = "urn:schemas-upnp-org:device:MediaRenderer:1";
+
+// Reads the <friendlyName> from a device description XML URL (best-effort).
+function fetchFriendlyName(location) {
+    return new Promise((resolve) => {
+        try {
+            const u = new URL(location);
+            const req = http.get(
+                { hostname: u.hostname, port: u.port || 80, path: u.pathname + u.search, timeout: 3000 },
+                (res) => {
+                    let body = "";
+                    res.on("data", (c) => (body += c));
+                    res.on("end", () => {
+                        const m = body.match(/<friendlyName>([^<]+)<\/friendlyName>/i);
+                        resolve(m ? m[1].trim() : "");
+                    });
+                }
+            );
+            req.on("error", () => resolve(""));
+            req.on("timeout", () => { req.destroy(); resolve(""); });
+        } catch (e) {
+            resolve("");
+        }
+    });
+}
+
+// discoverRenderers({ timeoutMs }) -> Promise<[{ name, location, server }]>
+function discoverRenderers(options) {
+    const opts = options || {};
+    const timeoutMs = Number(opts.timeoutMs) || 5000;
+    const withNames = opts.withNames !== false; // resolve friendlyName by default
+
+    return new Promise((resolve, reject) => {
+        const found = new Map(); // location -> { location, server }
+        const mSearch = Buffer.from(
+            "M-SEARCH * HTTP/1.1\r\n" +
+            `HOST: ${SSDP_ADDR}:${SSDP_PORT}\r\n` +
+            'MAN: "ssdp:discover"\r\n' +
+            "MX: 2\r\n" +
+            `ST: ${SEARCH_TARGET}\r\n` +
+            "\r\n"
+        );
+
+        let socket;
+        try {
+            socket = dgram.createSocket({ type: "udp4", reuseAddr: true });
+        } catch (error) {
+            reject(error);
+            return;
+        }
+
+        socket.on("message", (msg) => {
+            const text = msg.toString();
+            // Keep only genuine MediaRenderer responses (some non-compliant devices,
+            // e.g. Hue bridges, answer any M-SEARCH; their ST/USN won't mention it).
+            if (!/MediaRenderer/i.test(text)) return;
+            const locationMatch = text.match(/LOCATION:\s*(.+)\r/i);
+            if (!locationMatch) return;
+            const location = locationMatch[1].trim();
+            if (found.has(location)) return;
+            const serverMatch = text.match(/SERVER:\s*(.+)\r/i);
+            found.set(location, { location, server: serverMatch ? serverMatch[1].trim() : "" });
+        });
+
+        socket.on("error", (err) => {
+            try { socket.close(); } catch (e) { }
+            reject(err);
+        });
+
+        socket.bind(() => {
+            try { socket.setBroadcast(true); } catch (e) { }
+            const send = () => { try { socket.send(mSearch, 0, mSearch.length, SSDP_PORT, SSDP_ADDR); } catch (e) { } };
+            send();
+            setTimeout(send, 500);
+            setTimeout(send, 1500);
+
+            setTimeout(async () => {
+                try { socket.close(); } catch (e) { }
+                const devices = Array.from(found.values());
+                if (!withNames) { resolve(devices); return; }
+                for (const dev of devices) {
+                    dev.name = (await fetchFriendlyName(dev.location)) || "";
+                }
+                resolve(devices);
+            }, timeoutMs);
+        });
+    });
+}
+
+module.exports = { discoverRenderers, fetchFriendlyName };

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;