n8n-nodes-tts-bigboss 1.0.0

package/dist/TTSBigBoss.node.js

@@ -0,0 +1,423 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TTSBigBoss = void 0;
+const uuid_1 = require("uuid");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process = __importStar(require("child_process"));
+const ws_1 = __importDefault(require("ws"));
+const EDGE_URL = 'wss://speech.platform.bing.com/consumer/speech/synthesize/readaloud/edge/v1?TrustedClientToken=6A5AA1D4EAFF4E9FB37E23D68491D6F4';
+const EDGE_VOICES = [
+    { name: 'Arabic (Egypt) - Salma', value: 'ar-EG-SalmaNeural' },
+    { name: 'Arabic (Egypt) - Shakir', value: 'ar-EG-ShakirNeural' },
+    { name: 'Arabic (Saudi) - Hamed', value: 'ar-SA-HamedNeural' },
+    { name: 'Arabic (Saudi) - Zariyah', value: 'ar-SA-ZariyahNeural' },
+    { name: 'English (US) - Aria', value: 'en-US-AriaNeural' },
+    { name: 'English (US) - Guy', value: 'en-US-GuyNeural' },
+    { name: 'English (US) - Jenny', value: 'en-US-JennyNeural' },
+    { name: 'English (US) - Multilingual', value: 'en-US-AndrewMultilingualNeural' },
+    { name: 'English (UK) - Sonia', value: 'en-GB-SoniaNeural' },
+    { name: 'English (UK) - Ryan', value: 'en-GB-RyanNeural' },
+    { name: 'French (France) - Denise', value: 'fr-FR-DeniseNeural' },
+    { name: 'French (France) - Henri', value: 'fr-FR-HenriNeural' },
+    { name: 'Spanish (Spain) - Elvira', value: 'es-ES-ElviraNeural' },
+    { name: 'Spanish (Mexico) - Dalia', value: 'es-MX-DaliaNeural' },
+    { name: 'German (Germany) - Katja', value: 'de-DE-KatjaNeural' },
+    { name: 'German (Germany) - Conrad', value: 'de-DE-ConradNeural' },
+    { name: 'Chinese (Mandarin) - Xiaoxiao', value: 'zh-CN-XiaoxiaoNeural' },
+];
+class TTSBigBoss {
+    constructor() {
+        this.description = {
+            displayName: 'TTS BigBoss',
+            name: 'tTSBigBoss',
+            icon: 'fa:comment-dots',
+            group: ['transform'],
+            version: 1,
+            description: 'Advanced Text-to-Speech (Edge-TTS & System Clone)',
+            defaults: {
+                name: 'TTS BigBoss',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                {
+                    displayName: 'Engine',
+                    name: 'engine',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Edge TTS (Free Online)',
+                            value: 'edge',
+                            description: 'High quality, multilingual, supports Arabic & perfect subtitles. Requires internet.',
+                        },
+                        {
+                            name: 'System Command (Local/Clone)',
+                            value: 'system',
+                            description: 'Use locally installed tools (Piper, XTTS, Coqui) via command line.',
+                        },
+                    ],
+                    default: 'edge',
+                },
+                {
+                    displayName: 'Text',
+                    name: 'text',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'The text to convert to speech',
+                },
+                {
+                    displayName: 'Output Property (Audio)',
+                    name: 'audioProperty',
+                    type: 'string',
+                    default: 'audio',
+                    description: 'Name of the binary property to output the audio to',
+                },
+                {
+                    displayName: 'Output Property (SRT)',
+                    name: 'srtProperty',
+                    type: 'string',
+                    default: 'subtitle',
+                    description: 'Name of the binary property to output the SRT subtitles to',
+                },
+                {
+                    displayName: 'Voice',
+                    name: 'edgeVoice',
+                    type: 'options',
+                    options: [
+                        ...EDGE_VOICES,
+                        { name: 'Custom (Enter ID)', value: 'custom' },
+                    ],
+                    default: 'en-US-AriaNeural',
+                    displayOptions: {
+                        show: {
+                            engine: ['edge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Custom Voice ID',
+                    name: 'edgeVoiceCustom',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'e.g. it-IT-ElsaNeural',
+                    displayOptions: {
+                        show: {
+                            engine: ['edge'],
+                            edgeVoice: ['custom'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Rate',
+                    name: 'edgeRate',
+                    type: 'string',
+                    default: '+0%',
+                    description: 'Speed of speech (e.g. +10%, -20%)',
+                    displayOptions: {
+                        show: {
+                            engine: ['edge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Pitch',
+                    name: 'edgePitch',
+                    type: 'string',
+                    default: '+0Hz',
+                    description: 'Pitch adjustment (e.g. +5Hz, -5Hz)',
+                    displayOptions: {
+                        show: {
+                            engine: ['edge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Command',
+                    name: 'systemCommand',
+                    type: 'string',
+                    default: 'piper --model en_US-lessac-medium --output_file "{output_file}"',
+                    description: 'Command to execute. Use placeholders: "{text}" for input text, "{output_file}" for the temporary audio path.',
+                    displayOptions: {
+                        show: {
+                            engine: ['system'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Clone Audio Input',
+                    name: 'cloneInput',
+                    type: 'boolean',
+                    default: false,
+                    description: 'If true, allows using an input binary file as a voice cloning reference',
+                    displayOptions: {
+                        show: {
+                            engine: ['system'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Clone Input Property',
+                    name: 'cloneInputProperty',
+                    type: 'string',
+                    default: 'reference_audio',
+                    displayOptions: {
+                        show: {
+                            engine: ['system'],
+                            cloneInput: [true],
+                        },
+                    },
+                    description: 'Binary property name containing the reference audio for cloning. Use placeholder "{reference_audio}" in command.',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const tempDir = os.tmpdir();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const engine = this.getNodeParameter('engine', i);
+                const text = this.getNodeParameter('text', i);
+                const audioProp = this.getNodeParameter('audioProperty', i);
+                const srtProp = this.getNodeParameter('srtProperty', i);
+                let audioBuffer;
+                let srtBuffer;
+                if (engine === 'edge') {
+                    let voice = this.getNodeParameter('edgeVoice', i);
+                    if (voice === 'custom') {
+                        voice = this.getNodeParameter('edgeVoiceCustom', i);
+                    }
+                    const rate = this.getNodeParameter('edgeRate', i);
+                    const pitch = this.getNodeParameter('edgePitch', i);
+                    const result = await runEdgeTTS(text, voice, rate, pitch);
+                    audioBuffer = result.audio;
+                    srtBuffer = Buffer.from(result.srt, 'utf8');
+                }
+                else {
+                    const commandTpl = this.getNodeParameter('systemCommand', i);
+                    const useClone = this.getNodeParameter('cloneInput', i, false);
+                    const outFile = path.join(tempDir, `tts_out_${(0, uuid_1.v4)()}.wav`);
+                    let cmd = commandTpl
+                        .replace(/"{output_file}"/g, `"${outFile}"`)
+                        .replace(/{output_file}/g, `"${outFile}"`)
+                        .replace(/"{text}"/g, `"${text.replace(/"/g, '\\"')}"`)
+                        .replace(/{text}/g, `"${text.replace(/"/g, '\\"')}"`);
+                    if (useClone) {
+                        const cloneProp = this.getNodeParameter('cloneInputProperty', i);
+                        const cloneData = await this.helpers.getBinaryDataBuffer(i, cloneProp);
+                        const cloneFile = path.join(tempDir, `tts_ref_${(0, uuid_1.v4)()}.wav`);
+                        fs.writeFileSync(cloneFile, cloneData);
+                        cmd = cmd
+                            .replace(/"{reference_audio}"/g, `"${cloneFile}"`)
+                            .replace(/{reference_audio}/g, `"${cloneFile}"`);
+                    }
+                    await new Promise((resolve, reject) => {
+                        child_process.exec(cmd, (error, stdout, stderr) => {
+                            if (error) {
+                                reject(new Error(`System command failed: ${stderr || error.message}`));
+                            }
+                            else {
+                                resolve(stdout);
+                            }
+                        });
+                    });
+                    if (!fs.existsSync(outFile)) {
+                        throw new Error('System command did not produce output file at expected path');
+                    }
+                    audioBuffer = fs.readFileSync(outFile);
+                    srtBuffer = Buffer.from(generateHeuristicSRT(text, audioBuffer.length), 'utf8');
+                    if (fs.existsSync(outFile))
+                        fs.unlinkSync(outFile);
+                }
+                const newItem = {
+                    json: items[i].json,
+                    binary: {},
+                };
+                if (items[i].binary) {
+                    newItem.binary = { ...items[i].binary };
+                }
+                newItem.binary[audioProp] = await this.helpers.prepareBinaryData(audioBuffer, 'speech.mp3', 'audio/mpeg');
+                newItem.binary[srtProp] = await this.helpers.prepareBinaryData(srtBuffer, 'subtitles.srt', 'application/x-subrip');
+                returnData.push(newItem);
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message }, binary: {} });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.TTSBigBoss = TTSBigBoss;
+async function runEdgeTTS(text, voice, rate, pitch) {
+    return new Promise((resolve, reject) => {
+        const ws = new ws_1.default(EDGE_URL);
+        const requestId = (0, uuid_1.v4)().replace(/-/g, '');
+        const audioChunks = [];
+        const wordBoundaries = [];
+        ws.on('open', () => {
+            const configMsg = `X-Timestamp:${new Date().toISOString()}\r\nContent-Type:application/json; charset=utf-8\r\nPath:speech.config\r\n\r\n` +
+                JSON.stringify({
+                    context: {
+                        synthesis: {
+                            audio: {
+                                metadataOptions: {
+                                    sentenceBoundaryEnabled: 'false',
+                                    wordBoundaryEnabled: 'true',
+                                },
+                                outputFormat: 'audio-24khz-48kbitrate-mono-mp3',
+                            },
+                        },
+                    },
+                });
+            ws.send(configMsg);
+            const ssml = `<speak version='1.0' xmlns='http://www.w3.org/2001/10/synthesis' xml:lang='en-US'><voice name='${voice}'><prosody pitch='${pitch}' rate='${rate}'>${text}</prosody></voice></speak>`;
+            const ssmlMsg = `X-RequestId:${requestId}\r\nX-Timestamp:${new Date().toISOString()}\r\nContent-Type:application/ssml+xml\r\nPath:ssml\r\n\r\n` + ssml;
+            ws.send(ssmlMsg);
+        });
+        ws.on('message', (data, isBinary) => {
+            const textData = data.toString();
+            if (textData.includes('Path:turn.start')) {
+            }
+            else if (textData.includes('Path:turn.end')) {
+                ws.close();
+                const fullAudio = Buffer.concat(audioChunks);
+                const srt = buildSRT(wordBoundaries);
+                resolve({ audio: fullAudio, srt });
+            }
+            else if (textData.includes('Path:audio.metadata')) {
+                try {
+                    const parts = textData.split('\r\n\r\n');
+                    if (parts.length > 1) {
+                        const json = JSON.parse(parts[1]);
+                        if (json.Metadata && Array.isArray(json.Metadata)) {
+                            for (const meta of json.Metadata) {
+                                if (meta.Type === 'Word') {
+                                    wordBoundaries.push({
+                                        offset: meta.Offset,
+                                        duration: meta.Duration,
+                                        text: meta.Text,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                }
+            }
+            else if (isBinary || (data.length > 2 && data[0] === 0x00 && data[1] === 0x67)) {
+                const headerLen = data.readUInt16BE(0);
+                if (data.length > headerLen + 2) {
+                    const audioData = data.slice(headerLen + 2);
+                    audioChunks.push(audioData);
+                }
+            }
+        });
+        ws.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+function buildSRT(words) {
+    let srt = '';
+    let counter = 1;
+    let currentPhrase = [];
+    let currentLength = 0;
+    const flushPhrase = () => {
+        if (currentPhrase.length === 0)
+            return;
+        const startTick = currentPhrase[0].offset;
+        const endTick = currentPhrase[currentPhrase.length - 1].offset + currentPhrase[currentPhrase.length - 1].duration;
+        const startTime = ticksToTime(startTick);
+        const endTime = ticksToTime(endTick);
+        const text = currentPhrase.map(w => w.text).join(' ');
+        srt += `${counter++}\n${startTime} --> ${endTime}\n${text}\n\n`;
+        currentPhrase = [];
+        currentLength = 0;
+    };
+    for (let i = 0; i < words.length; i++) {
+        const w = words[i];
+        const prevW = i > 0 ? words[i - 1] : null;
+        if (prevW && (w.offset - (prevW.offset + prevW.duration) > 5000000)) {
+            flushPhrase();
+        }
+        currentPhrase.push(w);
+        currentLength += w.text.length;
+        if (currentLength > 40 || ['.', '?', '!'].includes(w.text.slice(-1))) {
+            flushPhrase();
+        }
+    }
+    flushPhrase();
+    return srt;
+}
+function ticksToTime(ticks) {
+    const ms = ticks / 10000;
+    const date = new Date(0, 0, 0, 0, 0, 0, ms);
+    const h = date.getHours().toString().padStart(2, '0');
+    const m = date.getMinutes().toString().padStart(2, '0');
+    const s = date.getSeconds().toString().padStart(2, '0');
+    const mili = date.getMilliseconds().toString().padStart(3, '0');
+    return `${h}:${m}:${s},${mili}`;
+}
+function generateHeuristicSRT(text, byteLength) {
+    const totalDurationSec = text.length / 15;
+    const sentences = text.match(/[^.!?]+[.!?]*/g) || [text];
+    let currentStartTime = 0;
+    let srt = '';
+    let counter = 1;
+    const msToSrt = (ms) => {
+        const date = new Date(0, 0, 0, 0, 0, 0, ms);
+        return `${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}:${date.getSeconds().toString().padStart(2, '0')},${date.getMilliseconds().toString().padStart(3, '0')}`;
+    };
+    for (const sentence of sentences) {
+        const sentenceDuration = (sentence.length / text.length) * (totalDurationSec * 1000);
+        const endTime = currentStartTime + sentenceDuration;
+        srt += `${counter++}\n${msToSrt(currentStartTime)} --> ${msToSrt(endTime)}\n${sentence.trim()}\n\n`;
+        currentStartTime = endTime;
+    }
+    return srt;
+}

package/gulpfile.js

@@ -0,0 +1,9 @@
+const { src, dest } = require('gulp');
+
+function copyIcons() {
+    return src('nodes/**/*.svg')
+        .pipe(dest('dist/nodes'));
+}
+
+exports['build:icons'] = copyIcons;
+exports.default = copyIcons;

package/nodes/TTSBigBoss/TTSBigBoss.node.ts

@@ -0,0 +1,505 @@
+import {
+    IExecuteFunctions,
+    INodeExecutionData,
+    INodeType,
+    INodeTypeDescription,
+} from 'n8n-workflow';
+import { v4 as uuidv4 } from 'uuid';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as child_process from 'child_process';
+import WebSocket from 'ws';
+
+// Edge TTS Constants
+const EDGE_URL = 'wss://speech.platform.bing.com/consumer/speech/synthesize/readaloud/edge/v1?TrustedClientToken=6A5AA1D4EAFF4E9FB37E23D68491D6F4';
+const EDGE_VOICES = [
+    // Arabic
+    { name: 'Arabic (Egypt) - Salma', value: 'ar-EG-SalmaNeural' },
+    { name: 'Arabic (Egypt) - Shakir', value: 'ar-EG-ShakirNeural' },
+    { name: 'Arabic (Saudi) - Hamed', value: 'ar-SA-HamedNeural' },
+    { name: 'Arabic (Saudi) - Zariyah', value: 'ar-SA-ZariyahNeural' },
+    // English
+    { name: 'English (US) - Aria', value: 'en-US-AriaNeural' },
+    { name: 'English (US) - Guy', value: 'en-US-GuyNeural' },
+    { name: 'English (US) - Jenny', value: 'en-US-JennyNeural' },
+    { name: 'English (US) - Multilingual', value: 'en-US-AndrewMultilingualNeural' },
+    { name: 'English (UK) - Sonia', value: 'en-GB-SoniaNeural' },
+    { name: 'English (UK) - Ryan', value: 'en-GB-RyanNeural' },
+    // French
+    { name: 'French (France) - Denise', value: 'fr-FR-DeniseNeural' },
+    { name: 'French (France) - Henri', value: 'fr-FR-HenriNeural' },
+    // Spanish
+    { name: 'Spanish (Spain) - Elvira', value: 'es-ES-ElviraNeural' },
+    { name: 'Spanish (Mexico) - Dalia', value: 'es-MX-DaliaNeural' },
+    // German
+    { name: 'German (Germany) - Katja', value: 'de-DE-KatjaNeural' },
+    { name: 'German (Germany) - Conrad', value: 'de-DE-ConradNeural' },
+    // Multi
+    { name: 'Chinese (Mandarin) - Xiaoxiao', value: 'zh-CN-XiaoxiaoNeural' },
+];
+
+interface WordBoundary {
+    offset: number;
+    duration: number;
+    text: string;
+}
+
+export class TTSBigBoss implements INodeType {
+    description: INodeTypeDescription = {
+        displayName: 'TTS BigBoss',
+        name: 'tTSBigBoss',
+        icon: 'fa:comment-dots',
+        group: ['transform'],
+        version: 1,
+        description: 'Advanced Text-to-Speech (Edge-TTS & System Clone)',
+        defaults: {
+            name: 'TTS BigBoss',
+        },
+        inputs: ['main'],
+        outputs: ['main'],
+        properties: [
+            {
+                displayName: 'Engine',
+                name: 'engine',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Edge TTS (Free Online)',
+                        value: 'edge',
+                        description: 'High quality, multilingual, supports Arabic & perfect subtitles. Requires internet.',
+                    },
+                    {
+                        name: 'System Command (Local/Clone)',
+                        value: 'system',
+                        description: 'Use locally installed tools (Piper, XTTS, Coqui) via command line.',
+                    },
+                ],
+                default: 'edge',
+            },
+            // ----------------------------------
+            // Common Settings
+            // ----------------------------------
+            {
+                displayName: 'Text',
+                name: 'text',
+                type: 'string',
+                default: '',
+                required: true,
+                description: 'The text to convert to speech',
+            },
+            {
+                displayName: 'Output Property (Audio)',
+                name: 'audioProperty',
+                type: 'string',
+                default: 'audio',
+                description: 'Name of the binary property to output the audio to',
+            },
+            {
+                displayName: 'Output Property (SRT)',
+                name: 'srtProperty',
+                type: 'string',
+                default: 'subtitle',
+                description: 'Name of the binary property to output the SRT subtitles to',
+            },
+            // ----------------------------------
+            // Edge TTS Settings
+            // ----------------------------------
+            {
+                displayName: 'Voice',
+                name: 'edgeVoice',
+                type: 'options',
+                options: [
+                    ...EDGE_VOICES,
+                    { name: 'Custom (Enter ID)', value: 'custom' },
+                ],
+                default: 'en-US-AriaNeural',
+                displayOptions: {
+                    show: {
+                        engine: ['edge'],
+                    },
+                },
+            },
+            {
+                displayName: 'Custom Voice ID',
+                name: 'edgeVoiceCustom',
+                type: 'string',
+                default: '',
+                placeholder: 'e.g. it-IT-ElsaNeural',
+                displayOptions: {
+                    show: {
+                        engine: ['edge'],
+                        edgeVoice: ['custom'],
+                    },
+                },
+            },
+            {
+                displayName: 'Rate',
+                name: 'edgeRate',
+                type: 'string',
+                default: '+0%',
+                description: 'Speed of speech (e.g. +10%, -20%)',
+                displayOptions: {
+                    show: {
+                        engine: ['edge'],
+                    },
+                },
+            },
+            {
+                displayName: 'Pitch',
+                name: 'edgePitch',
+                type: 'string',
+                default: '+0Hz',
+                description: 'Pitch adjustment (e.g. +5Hz, -5Hz)',
+                displayOptions: {
+                    show: {
+                        engine: ['edge'],
+                    },
+                },
+            },
+            // ----------------------------------
+            // System Command Settings
+            // ----------------------------------
+            {
+                displayName: 'Command',
+                name: 'systemCommand',
+                type: 'string',
+                default: 'piper --model en_US-lessac-medium --output_file "{output_file}"',
+                description: 'Command to execute. Use placeholders: "{text}" for input text, "{output_file}" for the temporary audio path.',
+                displayOptions: {
+                    show: {
+                        engine: ['system'],
+                    },
+                },
+            },
+            {
+                displayName: 'Clone Audio Input',
+                name: 'cloneInput',
+                type: 'boolean',
+                default: false,
+                description: 'If true, allows using an input binary file as a voice cloning reference',
+                displayOptions: {
+                    show: {
+                        engine: ['system'],
+                    },
+                },
+            },
+            {
+                displayName: 'Clone Input Property',
+                name: 'cloneInputProperty',
+                type: 'string',
+                default: 'reference_audio',
+                displayOptions: {
+                    show: {
+                        engine: ['system'],
+                        cloneInput: [true],
+                    },
+                },
+                description: 'Binary property name containing the reference audio for cloning. Use placeholder "{reference_audio}" in command.',
+            },
+        ],
+    };
+
+    async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+        const items = this.getInputData();
+        const returnData: INodeExecutionData[] = [];
+        const tempDir = os.tmpdir();
+
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const engine = this.getNodeParameter('engine', i) as string;
+                const text = this.getNodeParameter('text', i) as string;
+                const audioProp = this.getNodeParameter('audioProperty', i) as string;
+                const srtProp = this.getNodeParameter('srtProperty', i) as string;
+
+                let audioBuffer: Buffer;
+                let srtBuffer: Buffer;
+
+                if (engine === 'edge') {
+                    // ----------------------------------
+                    // EDGE TTS EXECUTION
+                    // ----------------------------------
+                    let voice = this.getNodeParameter('edgeVoice', i) as string;
+                    if (voice === 'custom') {
+                        voice = this.getNodeParameter('edgeVoiceCustom', i) as string;
+                    }
+                    const rate = this.getNodeParameter('edgeRate', i) as string;
+                    const pitch = this.getNodeParameter('edgePitch', i) as string;
+
+                    const result = await runEdgeTTS(text, voice, rate, pitch);
+                    audioBuffer = result.audio;
+                    srtBuffer = Buffer.from(result.srt, 'utf8');
+
+                } else {
+                    // ----------------------------------
+                    // SYSTEM COMMAND EXECUTION
+                    // ----------------------------------
+                    const commandTpl = this.getNodeParameter('systemCommand', i) as string;
+                    const useClone = this.getNodeParameter('cloneInput', i, false) as boolean;
+
+                    const outFile = path.join(tempDir, `tts_out_${uuidv4()}.wav`);
+                    let cmd = commandTpl
+                        .replace(/"{output_file}"/g, `"${outFile}"`)
+                        .replace(/{output_file}/g, `"${outFile}"`)
+                        .replace(/"{text}"/g, `"${text.replace(/"/g, '\\"')}"`) // Basic escape
+                        .replace(/{text}/g, `"${text.replace(/"/g, '\\"')}"`);
+
+                    // Handle Clone Input
+                    if (useClone) {
+                        const cloneProp = this.getNodeParameter('cloneInputProperty', i) as string;
+                        const cloneData = await this.helpers.getBinaryDataBuffer(i, cloneProp);
+                        const cloneFile = path.join(tempDir, `tts_ref_${uuidv4()}.wav`);
+                        fs.writeFileSync(cloneFile, cloneData);
+                        cmd = cmd
+                            .replace(/"{reference_audio}"/g, `"${cloneFile}"`)
+                            .replace(/{reference_audio}/g, `"${cloneFile}"`);
+                    }
+
+                    // Execute
+                    await new Promise((resolve, reject) => {
+                        child_process.exec(cmd, (error, stdout, stderr) => {
+                            if (error) {
+                                reject(new Error(`System command failed: ${stderr || error.message}`));
+                            } else {
+                                resolve(stdout);
+                            }
+                        });
+                    });
+
+                    if (!fs.existsSync(outFile)) {
+                        throw new Error('System command did not produce output file at expected path');
+                    }
+
+                    audioBuffer = fs.readFileSync(outFile);
+
+                    // Generate Heuristic SRT (Estimate timestamps)
+                    srtBuffer = Buffer.from(generateHeuristicSRT(text, audioBuffer.length), 'utf8');
+
+                    // Cleanup
+                    if (fs.existsSync(outFile)) fs.unlinkSync(outFile);
+                }
+
+                // ----------------------------------
+                // OUTPUT CONSTRUCTION
+                // ----------------------------------
+                const newItem: INodeExecutionData = {
+                    json: items[i].json,
+                    binary: {},
+                };
+
+                if (items[i].binary) {
+                    newItem.binary = { ...items[i].binary };
+                }
+
+                newItem.binary![audioProp] = await this.helpers.prepareBinaryData(
+                    audioBuffer,
+                    'speech.mp3', // Edge sends MP3, Piper usually WAV but generic naming is fine
+                    'audio/mpeg'
+                );
+
+                newItem.binary![srtProp] = await this.helpers.prepareBinaryData(
+                    srtBuffer,
+                    'subtitles.srt',
+                    'application/x-subrip'
+                );
+
+                returnData.push(newItem);
+
+            } catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message }, binary: {} });
+                    continue;
+                }
+                throw error;
+            }
+        }
+
+        return [returnData];
+    }
+}
+
+// --------------------------------------------------------------------------
+// EDGE TTS IMPLEMENTATION
+// --------------------------------------------------------------------------
+async function runEdgeTTS(text: string, voice: string, rate: string, pitch: string): Promise<{ audio: Buffer; srt: string }> {
+    return new Promise((resolve, reject) => {
+        const ws = new WebSocket(EDGE_URL);
+        const requestId = uuidv4().replace(/-/g, '');
+        const audioChunks: Buffer[] = [];
+        const wordBoundaries: WordBoundary[] = [];
+
+        ws.on('open', () => {
+            // 1. Send Config
+            const configMsg = `X-Timestamp:${new Date().toISOString()}\r\nContent-Type:application/json; charset=utf-8\r\nPath:speech.config\r\n\r\n` +
+                JSON.stringify({
+                    context: {
+                        synthesis: {
+                            audio: {
+                                metadataOptions: {
+                                    sentenceBoundaryEnabled: 'false',
+                                    wordBoundaryEnabled: 'true',
+                                },
+                                outputFormat: 'audio-24khz-48kbitrate-mono-mp3',
+                            },
+                        },
+                    },
+                });
+            ws.send(configMsg);
+
+            // 2. Send SSML
+            const ssml = `<speak version='1.0' xmlns='http://www.w3.org/2001/10/synthesis' xml:lang='en-US'><voice name='${voice}'><prosody pitch='${pitch}' rate='${rate}'>${text}</prosody></voice></speak>`;
+            const ssmlMsg = `X-RequestId:${requestId}\r\nX-Timestamp:${new Date().toISOString()}\r\nContent-Type:application/ssml+xml\r\nPath:ssml\r\n\r\n` + ssml;
+            ws.send(ssmlMsg);
+        });
+
+        ws.on('message', (data: Buffer, isBinary: boolean) => {
+            const textData = data.toString();
+
+            if (textData.includes('Path:turn.start')) {
+                // Start of turn
+            } else if (textData.includes('Path:turn.end')) {
+                // End of turn - Finish
+                ws.close();
+                const fullAudio = Buffer.concat(audioChunks);
+                const srt = buildSRT(wordBoundaries);
+                resolve({ audio: fullAudio, srt });
+            } else if (textData.includes('Path:audio.metadata')) {
+                // Parse Metadata (Word Boundaries)
+                try {
+                    const parts = textData.split('\r\n\r\n');
+                    if (parts.length > 1) {
+                        const json = JSON.parse(parts[1]);
+                        if (json.Metadata && Array.isArray(json.Metadata)) {
+                            for (const meta of json.Metadata) {
+                                if (meta.Type === 'Word') {
+                                    wordBoundaries.push({
+                                        offset: meta.Offset, // 100ns units
+                                        duration: meta.Duration,
+                                        text: meta.Text,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                } catch (e) {
+                    // Ignore parse errors
+                }
+            } else if (isBinary || (data.length > 2 && data[0] === 0x00 && data[1] === 0x67)) {
+                // Binary Audio Data
+                // The header is usually 2 bytes + requestID length + timestamp. 
+                // Edge TTS binary format: Header length (2B) + Header + Audio Data
+                // We need to strip the header to get clean MP3.
+                // Header format: "X-RequestId:...\r\nPath:audio\r\n..."
+
+                // Simple Strip: Look for "Path:audio\r\n\r\n" in the buffer?
+                // Binary messages have a specific binary header structure.
+                // Structure: 2 bytes (header length) + Header Text + Data
+                const headerLen = data.readUInt16BE(0);
+                if (data.length > headerLen + 2) {
+                    const audioData = data.slice(headerLen + 2);
+                    audioChunks.push(audioData);
+                }
+            }
+        });
+
+        ws.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+
+function buildSRT(words: WordBoundary[]): string {
+    let srt = '';
+    let counter = 1;
+    // Group words into reasonable chunks if they are close? 
+    // For now, Edge-TTS is word-level. Subtitles are usually sentence/phrase level.
+    // A simple heuristic: Combine 3-5 words or until pause.
+    // Wait, user asked for "perfect srt". Word-by-word SRT is annoying. 
+    // Let's group max 40 characters or pause > 500ms.
+
+    let currentPhrase: WordBoundary[] = [];
+    let currentLength = 0;
+
+    const flushPhrase = () => {
+        if (currentPhrase.length === 0) return;
+        const startTick = currentPhrase[0].offset;
+        const endTick = currentPhrase[currentPhrase.length - 1].offset + currentPhrase[currentPhrase.length - 1].duration;
+
+        const startTime = ticksToTime(startTick);
+        const endTime = ticksToTime(endTick);
+        const text = currentPhrase.map(w => w.text).join(' ');
+
+        srt += `${counter++}\n${startTime} --> ${endTime}\n${text}\n\n`;
+        currentPhrase = [];
+        currentLength = 0;
+    };
+
+    for (let i = 0; i < words.length; i++) {
+        const w = words[i];
+        const prevW = i > 0 ? words[i - 1] : null;
+
+        // Check for pause (gap > 300ms = 3,000,000 ticks)
+        // 100ns units -> 1ms = 10,000 ticks. 300ms = 3,000,000.
+        if (prevW && (w.offset - (prevW.offset + prevW.duration) > 5000000)) {
+            flushPhrase();
+        }
+
+        currentPhrase.push(w);
+        currentLength += w.text.length;
+
+        if (currentLength > 40 || ['.', '?', '!'].includes(w.text.slice(-1))) {
+            flushPhrase();
+        }
+    }
+    flushPhrase();
+
+    return srt;
+}
+
+function ticksToTime(ticks: number): string {
+    // 1 tick = 100ns = 0.0001ms
+    const ms = ticks / 10000;
+    const date = new Date(0, 0, 0, 0, 0, 0, ms);
+    const h = date.getHours().toString().padStart(2, '0');
+    const m = date.getMinutes().toString().padStart(2, '0');
+    const s = date.getSeconds().toString().padStart(2, '0');
+    const mili = date.getMilliseconds().toString().padStart(3, '0');
+    return `${h}:${m}:${s},${mili}`;
+}
+
+// --------------------------------------------------------------------------
+// HEURISTIC SRT IMPLEMENTATION (For System Command)
+// --------------------------------------------------------------------------
+function generateHeuristicSRT(text: string, byteLength: number): string {
+    // Estimate duration assuming typical MP3/WAV bitrate. 
+    // Actually, system command usually produces WAV (PCM). 
+    // Wrapper might produce MP3. Let's assume user command output.
+    // It is safer to assume ~15 chars per second reading speed if we don't know duration.
+    // Or assume 16000 bytes/sec for mono 16khz? Too unreliable.
+    // Let's use text length heuristic: Avg reading speed 150 wpm ~ 2.5 words/sec ~ 15 chars/sec?
+    // Let's try 15 chars / second.
+
+    const totalDurationSec = text.length / 15;
+    // Ideally we'd use 'ffprobe' to get exact duration, but let's stick to pure TS for now.
+    // If we really wanted to be robust, we'd add 'ffprobe' execution here.
+
+    const sentences = text.match(/[^.!?]+[.!?]*/g) || [text];
+    let currentStartTime = 0;
+    let srt = '';
+    let counter = 1;
+
+    const msToSrt = (ms: number) => {
+        const date = new Date(0, 0, 0, 0, 0, 0, ms);
+        return `${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}:${date.getSeconds().toString().padStart(2, '0')},${date.getMilliseconds().toString().padStart(3, '0')}`;
+    };
+
+    for (const sentence of sentences) {
+        const sentenceDuration = (sentence.length / text.length) * (totalDurationSec * 1000);
+        const endTime = currentStartTime + sentenceDuration;
+
+        srt += `${counter++}\n${msToSrt(currentStartTime)} --> ${msToSrt(endTime)}\n${sentence.trim()}\n\n`;
+        currentStartTime = endTime;
+    }
+
+    return srt;
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "n8n-nodes-tts-bigboss",
+  "version": "1.0.0",
+  "description": "BigBoss TTS node with multi-engine support and automatic SRT generation",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "tts",
+    "audio",
+    "srt",
+    "arabic",
+    "edge-tts",
+    "piper"
+  ],
+  "license": "MIT",
+  "author": "isemo007",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "lint": "tslint -p tsconfig.json -c tslint.json",
+    "format": "prettier nodes --write"
+  },
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/nodes/TTSBigBoss/TTSBigBoss.node.js"
+    ]
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "n8n-core": "^1.75.0",
+    "n8n-workflow": "^1.70.0",
+    "uuid": "^9.0.0",
+    "ws": "^8.13.0"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.14.195",
+    "@types/node": "^22.13.0",
+    "@types/uuid": "^9.0.0",
+    "@types/ws": "^8.5.5",
+    "copy-webpack-plugin": "^11.0.0",
+    "gulp": "^4.0.2",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.8.8",
+    "tslint": "^6.1.3",
+    "typescript": "^5.0.0",
+    "webpack": "^5.88.0",
+    "webpack-cli": "^5.1.4"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,39 @@
+{
+    "compilerOptions": {
+        "rootDirs": [
+            "nodes",
+            "credentials"
+        ],
+        "outDir": "dist",
+        "lib": [
+            "es2019",
+            "dom"
+        ],
+        "target": "es2019",
+        "module": "commonjs",
+        "moduleResolution": "node",
+        "baseUrl": "./",
+        "paths": {
+            "n8n-workflow": [
+                "node_modules/n8n-workflow"
+            ],
+            "n8n-core": [
+                "node_modules/n8n-core"
+            ]
+        },
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": true,
+        "removeComments": true,
+        "resolveJsonModule": true
+    },
+    "include": [
+        "nodes/**/*.ts",
+        "credentials/**/*.ts"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}