@andresaya/edge-tts 1.2.5 → 1.2.6

package/dist/cli/edge-tts.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { SynthesizeCommand } from '../commands/SynthesizeCommand';
+import { VoiceListCommand } from '../commands/VoiceListCommand';
+import { Command } from 'commander';
+const program = new Command();
+program
+    .version('1.2.6')
+    .addCommand(SynthesizeCommand)
+    .addCommand(VoiceListCommand);
+try {
+    program.parse();
+}
+catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+}

package/dist/commands/SynthesizeCommand.js

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+import { EdgeTTS } from '../services/EdgeTTS';
+export const SynthesizeCommand = new Command('synthesize')
+    .description('Edge TTS: synthesize text to audio')
+    .option('-t, --text <text>', 'Text to convert to audio')
+    .option('-v, --voice [voice]', 'Voice to use for the audio synthesis', 'en-US-AriaNeural')
+    .option('-r, --rate [rate]', 'Rate of speech', '0%')
+    .option('-l, --volume [volume]', 'Volume of speech', '0%')
+    .option('-p, --pitch [pitch]', 'Pitch of speech', '0Hz')
+    .option('-o, --output [output]', 'Output file name', `output_${Date.now()}`)
+    .action(async (options) => {
+    const { text, voice, pitch, rate, volume, output } = options;
+    if (!text) {
+        console.error('Text is required');
+        process.exit(1);
+    }
+    const tts = new EdgeTTS();
+    await tts.synthesize(text, voice, { pitch, rate, volume });
+    await tts.toFile(`${output}`);
+    console.log(`Audio file generated: ${output}.mp3`);
+});

package/dist/commands/VoiceListCommand.js

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+import { EdgeTTS } from '../services/EdgeTTS';
+export const VoiceListCommand = new Command('voice-list')
+    .description('Get the list of available voices')
+    .action(async () => {
+    const tts = new EdgeTTS();
+    const voices = await tts.getVoices();
+    console.log('Lista de voces disponibles:');
+    voices.forEach((voice) => {
+        console.log(` - ${voice.ShortName}`);
+    });
+});

package/dist/config/constants.js

@@ -0,0 +1,5 @@
+export const Constants = {
+    TRUSTED_CLIENT_TOKEN: '6A5AA1D4EAFF4E9FB37E23D68491D6F4',
+    WSS_URL: 'wss://speech.platform.bing.com/consumer/speech/synthesize/readaloud/edge/v1',
+    VOICES_URL: 'https://speech.platform.bing.com/consumer/speech/synthesize/readaloud/voices/list',
+};

package/dist/index.js

@@ -0,0 +1 @@
+export { EdgeTTS } from './services/EdgeTTS';

package/dist/services/EdgeTTS.js

@@ -0,0 +1,157 @@
+import WebSocket, {} from 'ws';
+import { Constants } from '../config/constants';
+import { writeFile } from 'fs/promises';
+import { Buffer } from 'buffer';
+function ensureBuffer(data) {
+    if (Buffer.isBuffer(data)) {
+        return data;
+    }
+    if (data instanceof ArrayBuffer) {
+        return Buffer.from(data);
+    }
+    if (Array.isArray(data)) {
+        return Buffer.concat(data);
+    }
+    if (typeof data === 'string') {
+        return Buffer.from(data, 'utf-8');
+    }
+    throw new Error(`Unsupported RawData type: ${typeof data}`);
+}
+export class EdgeTTS {
+    audio_stream = [];
+    audio_format = 'mp3';
+    ws;
+    async getVoices() {
+        const response = await fetch(`${Constants.VOICES_URL}?trustedclienttoken=${Constants.TRUSTED_CLIENT_TOKEN}`);
+        const data = await response.json();
+        return data.map((voice) => {
+            delete voice.VoiceTag;
+            delete voice.SuggestedCodec;
+            delete voice.Status;
+            return voice;
+        });
+    }
+    generateUUID() {
+        return 'xxxxxxxx-xxxx-xxxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            const r = Math.random() * 16 | 0;
+            const v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+    validatePitch(pitch) {
+        if (typeof pitch === 'number') {
+            return (pitch >= 0 ? `+${pitch}Hz` : `${pitch}Hz`);
+        }
+        if (!/^[+-]?\d{1,3}(?:\.\d+)?Hz$/.test(pitch)) {
+            throw new Error("Invalid pitch format. Expected format: '-100Hz to +100Hz' or a number.");
+        }
+        return pitch;
+    }
+    validateRate(rate) {
+        let rateValue;
+        if (typeof rate === 'string') {
+            rateValue = parseFloat(rate.replace('%', ''));
+            if (isNaN(rateValue))
+                throw new Error("Invalid rate format.");
+        }
+        else {
+            rateValue = rate;
+        }
+        if (rateValue >= 0) {
+            return `+${rateValue}%`;
+        }
+        return `${rateValue}%`;
+    }
+    validateVolume(volume) {
+        let volumeValue;
+        if (typeof volume === 'string') {
+            volumeValue = parseInt(volume.replace('%', ''), 10);
+            if (isNaN(volumeValue))
+                throw new Error("Invalid volume format.");
+        }
+        else {
+            volumeValue = volume;
+        }
+        if (volumeValue < -100 || volumeValue > 100) {
+            throw new Error("Volume cannot be negative. Expected a value from -100% to 100% (or more).");
+        }
+        return `${volumeValue}%`;
+    }
+    async synthesize(text, voice = 'en-US-AnaNeural', options = {}) {
+        return new Promise((resolve, reject) => {
+            this.audio_stream = [];
+            const req_id = this.generateUUID();
+            this.ws = new WebSocket(`${Constants.WSS_URL}?trustedclienttoken=${Constants.TRUSTED_CLIENT_TOKEN}&ConnectionId=${req_id}`);
+            const SSML_text = this.getSSML(text, voice, options);
+            const timeout = setTimeout(() => {
+                if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                    this.ws.close();
+                }
+                reject(new Error("Synthesis timeout"));
+            }, 30000);
+            this.ws.on('open', () => {
+                const message = this.buildTTSConfigMessage();
+                this.ws.send(message);
+                const speechMessage = `X-RequestId:${req_id}\r\nContent-Type:application/ssml+xml\r\nX-Timestamp:${new Date().toISOString()}Z\r\nPath:ssml\r\n\r\n${SSML_text}`;
+                this.ws.send(speechMessage);
+            });
+            this.ws.on('message', (data) => {
+                this.processAudioData(data);
+            });
+            this.ws.on('error', (err) => {
+                clearTimeout(timeout);
+                if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                    this.ws.close();
+                }
+                reject(err);
+            });
+            this.ws.on('close', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    }
+    getSSML(text, voice, options = {}) {
+        if (typeof options.pitch === 'string') {
+            options.pitch = options.pitch.replace('hz', 'Hz');
+        }
+        const pitch = this.validatePitch(options.pitch ?? 0);
+        const rate = this.validateRate(options.rate ?? 0);
+        const volume = this.validateVolume(options.volume ?? 0);
+        return `<speak version='1.0' xml:lang='en-US'><voice name='${voice}'><prosody pitch='${pitch}' rate='${rate}' volume='${volume}'>${text}</prosody></voice></speak>`;
+    }
+    buildTTSConfigMessage() {
+        return `X-Timestamp:${new Date().toISOString()}Z\r\nContent-Type:application/json; charset=utf-8\r\nPath:speech.config\r\n\r\n` +
+            `{"context":{"synthesis":{"audio":{"metadataoptions":{"sentenceBoundaryEnabled":false,"wordBoundaryEnabled":true},"outputFormat":"audio-24khz-48kbitrate-mono-mp3"}}}}`;
+    }
+    processAudioData(data) {
+        const buffer = ensureBuffer(data);
+        const needle = Buffer.from("Path:audio\r\n");
+        const audioStartIndex = buffer.indexOf(new Uint8Array(needle));
+        if (audioStartIndex !== -1) {
+            const audioChunk = buffer.subarray(audioStartIndex + needle.length);
+            this.audio_stream.push(new Uint8Array(audioChunk));
+        }
+        if (buffer.toString().includes("Path:turn.end")) {
+            this.ws?.close();
+        }
+    }
+    async toFile(outputPath) {
+        const audioBuffer = this.toBuffer();
+        const finalPath = `${outputPath}.${this.audio_format}`;
+        await writeFile(finalPath, new Uint8Array(audioBuffer));
+        return finalPath;
+    }
+    toRaw() {
+        return this.toBase64();
+    }
+    toBase64() {
+        return this.toBuffer().toString('base64');
+    }
+    toBuffer() {
+        if (this.audio_stream.length === 0) {
+            throw new Error("No audio data available. Did you run synthesize() first?");
+        }
+        return Buffer.concat(this.audio_stream);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andresaya/edge-tts",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "Edge TTS is a package that allows access to the online text-to-speech service used by Microsoft Edge without the need for Microsoft Edge, Windows, or an API key.",
   "main": "dist/index.js",
   "keywords": [
@@ -23,6 +23,7 @@
   },
   "devDependencies": {
     "@types/bun": "latest",
+    "@types/ws": "^8.18.1",
     "typescript": "^5.6.2"
   },
   "dependencies": {
@@ -44,4 +45,4 @@
   "engines": {
     "bun": ">=0.5.0"
   }
-}
+}