echogarden 0.11.12 → 0.11.13

package/src/server/Client.ts

@@ -0,0 +1,297 @@
+import { WebSocket } from 'ws'
+import { encode as encodeMsgPack, decode as decodeMsgPack } from 'msgpack-lite'
+import { RequestVoiceListResult, SynthesisOptions, SynthesisSegmentEvent, SynthesisResult, VoiceListRequestOptions } from "../api/Synthesis.js"
+import { SynthesisResponseMessage, SynthesisSegmentEventMessage, SynthesisSentenceEventMessage, VoiceListRequestMessage, WorkerRequestMessage, VoiceListResponseMessage, AlignmentRequestMessage, AlignmentResponseMessage, RecognitionRequestMessage, RecognitionResponseMessage, SpeechTranslationRequestMessage, SpeechTranslationResponseMessage, SpeechLanguageDetectionRequestMessage, SpeechLanguageDetectionResponseMessage, TextLanguageDetectionResponseMessage, TextLanguageDetectionRequestMessage, SynthesisRequestMessage } from './Worker.js'
+import { getRandomHexString, logToStderr } from '../utilities/Utilities.js'
+import { OpenPromise } from '../utilities/OpenPromise.js'
+import { AudioSourceParam, RawAudio } from '../audio/AudioUtilities.js'
+import { AlignmentOptions, AlignmentResult } from '../api/Alignment.js'
+import { RecognitionOptions, RecognitionResult } from '../api/Recognition.js'
+import { SpeechTranslationOptions, SpeechTranslationResult } from '../api/Translation.js'
+import { Worker as WorkerThread } from 'node:worker_threads'
+import { SpeechLanguageDetectionOptions, SpeechLanguageDetectionResult, TextLanguageDetectionOptions, TextLanguageDetectionResult } from '../api/LanguageDetection.js'
+
+const log = logToStderr
+
+export class Client {
+	sendMessage: (message: any) => void
+
+	responseListeners = new Map<string, (message: string) => void>()
+
+	constructor(sourceChannel: WebSocket | WorkerThread) {
+		if (sourceChannel instanceof WebSocket) {
+			sourceChannel.on("message", (messageData, isBinary) => {
+				if (!isBinary) {
+					log(`Received an unexpected string WebSocket message: '${(messageData as Buffer).toString("utf-8")}'`)
+					return
+				}
+
+				let incomingMessage: any
+
+				try {
+					incomingMessage = decodeMsgPack(messageData as Buffer)
+				} catch (e) {
+					log(`Failed to decode incoming message. Reason: ${e}`)
+					return
+				}
+
+				this.onMessage(incomingMessage)
+			})
+
+			this.sendMessage = (outgoingMessage) => {
+				const encodedMessage = encodeMsgPack(outgoingMessage)
+
+				sourceChannel.send(encodedMessage)
+			}
+		} else if (sourceChannel instanceof WorkerThread) {
+			sourceChannel.on("message", (message) => {
+				this.onMessage(message)
+			})
+
+			sourceChannel.on("error", (e) => {
+				throw e
+			})
+
+			this.sendMessage = (outgoingMessage) => {
+				sourceChannel.postMessage(outgoingMessage)
+			}
+		} else {
+			throw new Error(`Invalid source: not a WebSocket or WorkerThread object`)
+		}
+	}
+
+	async synthesize(input: string | string[], options: SynthesisOptions, onSegment?: SynthesisSegmentEvent, onSentence?: SynthesisSegmentEvent): Promise<SynthesisResult> {
+		const requestOpenPromise = new OpenPromise<SynthesisResult>()
+
+		const requestMessage: SynthesisRequestMessage = {
+			messageType: "SynthesisRequest",
+			input,
+			options
+		}
+
+		function onResponse(responseMessage: SynthesisResponseMessage | SynthesisSegmentEventMessage | SynthesisSentenceEventMessage) {
+			if (responseMessage.messageType == "SynthesisResponse") {
+				requestOpenPromise.resolve(responseMessage)
+			} else if (responseMessage.messageType == "SynthesisSegmentEvent" && onSegment) {
+				onSegment(responseMessage)
+			} else if (responseMessage.messageType == "SynthesisSentenceEvent" && onSentence) {
+				onSentence(responseMessage)
+			}
+		}
+
+		function onError(e: any) {
+			requestOpenPromise.reject(e)
+		}
+
+		try {
+			this.sendRequest(requestMessage, onResponse, onError)
+		} catch (e) {
+			onError(e)
+		}
+
+		return requestOpenPromise.promise
+	}
+
+	async requestVoiceList(options: VoiceListRequestOptions): Promise<RequestVoiceListResult> {
+		const requestOpenPromise = new OpenPromise<RequestVoiceListResult>()
+
+		const requestMessage: VoiceListRequestMessage = {
+			messageType: "VoiceListRequest",
+			options
+		}
+
+		function onResponse(responseMessage: VoiceListResponseMessage) {
+			if (responseMessage.messageType == "VoiceListResponse") {
+				requestOpenPromise.resolve(responseMessage)
+			}
+		}
+
+		function onError(e: any) {
+			requestOpenPromise.reject(e)
+		}
+
+		try {
+			this.sendRequest(requestMessage, onResponse, onError)
+		} catch (e) {
+			onError(e)
+		}
+
+		return requestOpenPromise.promise
+	}
+
+	async recognize(input: AudioSourceParam, options: RecognitionOptions): Promise<RecognitionResult> {
+		const requestOpenPromise = new OpenPromise<RecognitionResult>()
+
+		const requestMessage: RecognitionRequestMessage = {
+			messageType: "RecognitionRequest",
+			input,
+			options
+		}
+
+		function onResponse(responseMessage: RecognitionResponseMessage) {
+			if (responseMessage.messageType == "RecognitionResponse") {
+				requestOpenPromise.resolve(responseMessage)
+			}
+		}
+
+		function onError(e: any) {
+			requestOpenPromise.reject(e)
+		}
+
+		try {
+			this.sendRequest(requestMessage, onResponse, onError)
+		} catch (e) {
+			onError(e)
+		}
+		return requestOpenPromise.promise
+	}
+
+	async align(input: AudioSourceParam, transcript: string, options: AlignmentOptions): Promise<AlignmentResult> {
+		const requestOpenPromise = new OpenPromise<AlignmentResult>()
+
+		const requestMessage: AlignmentRequestMessage = {
+			messageType: "AlignmentRequest",
+			input,
+			transcript,
+			options
+		}
+
+		function onResponse(responseMessage: AlignmentResponseMessage) {
+			if (responseMessage.messageType == "AlignmentResponse") {
+				requestOpenPromise.resolve(responseMessage)
+			}
+		}
+
+		function onError(e: any) {
+			requestOpenPromise.reject(e)
+		}
+
+		try {
+			this.sendRequest(requestMessage, onResponse, onError)
+		} catch (e) {
+			onError(e)
+		}
+
+		return requestOpenPromise.promise
+	}
+
+	async translateSpeech(input: string | Buffer | Uint8Array |RawAudio, options: SpeechTranslationOptions): Promise<SpeechTranslationResult> {
+		const requestOpenPromise = new OpenPromise<SpeechTranslationResult>()
+
+		const requestMessage: SpeechTranslationRequestMessage = {
+			messageType: "SpeechTranslationRequest",
+			input,
+			options
+		}
+
+		function onResponse(responseMessage: SpeechTranslationResponseMessage) {
+			if (responseMessage.messageType == "SpeechTranslationResponse") {
+				requestOpenPromise.resolve(responseMessage)
+			}
+		}
+
+		function onError(e: any) {
+			requestOpenPromise.reject(e)
+		}
+
+		try {
+			this.sendRequest(requestMessage, onResponse, onError)
+		} catch (e) {
+			onError(e)
+		}
+
+		return requestOpenPromise.promise
+	}
+
+	async detectSpeechLanguage(input: AudioSourceParam, options: SpeechLanguageDetectionOptions): Promise<SpeechLanguageDetectionResult> {
+		const requestOpenPromise = new OpenPromise<SpeechLanguageDetectionResult>()
+
+		const requestMessage: SpeechLanguageDetectionRequestMessage = {
+			messageType: "SpeechLanguageDetectionRequest",
+			input,
+			options
+		}
+
+		function onResponse(responseMessage: SpeechLanguageDetectionResponseMessage) {
+			if (responseMessage.messageType == "SpeechLanguageDetectionResponse") {
+				requestOpenPromise.resolve(responseMessage)
+			}
+		}
+
+		function onError(e: any) {
+			requestOpenPromise.reject(e)
+		}
+
+		try {
+			this.sendRequest(requestMessage, onResponse, onError)
+		} catch (e) {
+			onError(e)
+		}
+
+		return requestOpenPromise.promise
+	}
+
+	async detectTextLanguage(input: string, options: TextLanguageDetectionOptions): Promise<TextLanguageDetectionResult> {
+		const requestOpenPromise = new OpenPromise<TextLanguageDetectionResult>()
+
+		const requestMessage: TextLanguageDetectionRequestMessage = {
+			messageType: "TextLanguageDetectionRequest",
+			input,
+			options
+		}
+
+		function onResponse(responseMessage: TextLanguageDetectionResponseMessage) {
+			if (responseMessage.messageType == "TextLanguageDetectionResponse") {
+				requestOpenPromise.resolve(responseMessage)
+			}
+		}
+
+		function onError(e: any) {
+			requestOpenPromise.reject(e)
+		}
+
+		try {
+			this.sendRequest(requestMessage, onResponse, onError)
+		} catch (e) {
+			onError(e)
+		}
+
+		return requestOpenPromise.promise
+	}
+
+	sendRequest(request: any, onResponse: (message: any) => void, onErrorResponse: (error: any) => void) {
+		const requestId = getRandomHexString()
+
+		request = {
+			requestId,
+			...request
+		}
+
+		this.sendMessage(request)
+
+		function onResponseMessage(message: any) {
+			if (message.messageType == "Error") {
+				onErrorResponse(message.error)
+			} else {
+				onResponse(message)
+			}
+		}
+
+		this.responseListeners.set(requestId, onResponseMessage)
+	}
+
+	onMessage(incomingMessage: any) {
+		const requestId = incomingMessage.requestId
+
+		if (!requestId) {
+			log("Received a WebSocket message without a request ID")
+			return
+		}
+
+		const listener = this.responseListeners.get(requestId)
+
+		if (listener) {
+			listener(incomingMessage)
+		}
+	}
+}

package/src/server/Server.ts

@@ -0,0 +1,178 @@
+import { WebSocketServer, WebSocket, ServerOptions as WsServerOptions } from 'ws'
+import { encode as encodeMsgPack, decode as decodeMsgPack } from 'msgpack-lite'
+import { logToStderr } from '../utilities/Utilities.js'
+import { OpenPromise } from '../utilities/OpenPromise.js'
+import { readFile, existsSync } from '../utilities/FileSystem.js'
+import { extendDeep } from '../utilities/ObjectUtilities.js'
+import { sendMessageToWorker, addListenerToWorkerMessages, startNewWorkerThread } from './Worker.js'
+import { Worker } from 'node:worker_threads'
+import { IncomingMessage, ServerResponse } from 'node:http'
+import { Logger } from '../utilities/Logger.js'
+import chalk from 'chalk'
+
+const log = logToStderr
+
+export async function startServer(serverOptions: ServerOptions, onStarted: (options: ServerOptions) => void) {
+	serverOptions = extendDeep(defaultServerOptions, serverOptions)
+
+	const wsServerOptions: WsServerOptions = {
+		perMessageDeflate: serverOptions.deflate,
+		maxPayload: serverOptions.maxPayload
+	}
+
+	function onHttpRequest(request: IncomingMessage, response: ServerResponse) {
+		response.writeHead(200, { 'Content-Type': 'text/plain' })
+		response.end("This is the Echogarden HTTP server!")
+	}
+
+	if (serverOptions.secure) {
+		if (!serverOptions.certPath || !existsSync(serverOptions.certPath)) {
+			throw new Error(`No valid certificate file path was given`)
+		}
+
+		if (!serverOptions.keyPath || !existsSync(serverOptions.keyPath)) {
+			throw new Error(`No valid key file path was given`)
+		}
+
+		const { createServer } = await import('https')
+
+		const httpsServer = createServer({
+			cert: await readFile(serverOptions.certPath!),
+			key: await readFile(serverOptions.keyPath!)
+		}, onHttpRequest)
+
+		httpsServer.listen(serverOptions.port!)
+
+		wsServerOptions.server = httpsServer
+	} else {
+		const { createServer } = await import('http')
+
+		const httpServer = createServer({}, onHttpRequest)
+
+		httpServer.listen(serverOptions.port)
+
+		wsServerOptions.server = httpServer
+	}
+
+	const wss = new WebSocketServer(wsServerOptions)
+
+	const requestIdToWebSocket = new Map<string, WebSocket>()
+
+	function onWorkerMessage(message: any) {
+		if (message.name == "writeToStdErr") {
+			return
+		}
+
+		// Remove input raw audio property from message, if exists, when using WebSocket protocol:
+		message['inputRawAudio'] = undefined
+
+		if (!message.requestId) {
+			throw new Error("Worker message doesn't have a request ID")
+		}
+
+		const ws = requestIdToWebSocket.get(message.requestId)
+
+		if (!ws || ws.readyState != WebSocket.OPEN) {
+			return
+		}
+
+		const encodedWorkerMessage = encodeMsgPack(message)
+
+		ws.send(encodedWorkerMessage)
+	}
+
+	let workerThread: Worker | undefined
+
+	if (serverOptions.useWorkerThread) {
+		workerThread = await startNewWorkerThread()
+		workerThread.on('message', onWorkerMessage)
+	} else {
+		addListenerToWorkerMessages(onWorkerMessage)
+	}
+
+	const serverOpenPromise = new OpenPromise<void>
+
+	wss.on("listening", () => {
+		log(chalk.gray(`Started Echogarden WebSocket server on port ${serverOptions.port}`))
+		onStarted(serverOptions)
+	})
+
+	wss.on("close", () => {
+		serverOpenPromise.resolve()
+	})
+
+	wss.on('connection', async (ws, req) => {
+		log(chalk.gray((`Accepted incoming connection from ${req.socket.remoteAddress}`)))
+
+		ws.on('message', (messageData, isBinary) => {
+			if (!isBinary) {
+				log(chalk.gray((`Received an unexpected string WebSocket message: '${(messageData as Buffer).toString("utf-8")}'`)))
+				return
+			}
+
+			let incomingMessage: any
+
+			try {
+				incomingMessage = decodeMsgPack(messageData as Buffer)
+			} catch (e) {
+				log(chalk.gray(`Failed to decode binary WebSocket message. Reason: ${e}`))
+				return
+			}
+
+			const requestId = incomingMessage.requestId
+
+			if (!requestId) {
+				log(chalk.gray(("Received a WebSocket message without a request ID")))
+				return
+			}
+
+			requestIdToWebSocket.set(requestId, ws)
+
+			if (workerThread) {
+				workerThread.postMessage(incomingMessage)
+			} else {
+				sendMessageToWorker(incomingMessage)
+			}
+		})
+
+		ws.on('error', (e) => {
+			log(`${chalk.redBright('WebSocket error')}: ${e.message}`)
+		})
+
+		ws.on("close", () => {
+			const keysToDelete: string[] = []
+
+			requestIdToWebSocket.forEach((value, key) => {
+				if (value == ws) {
+					keysToDelete.push(key)
+				}
+			})
+
+			keysToDelete.forEach(key => requestIdToWebSocket.delete(key))
+
+			log(chalk.gray((`Incoming connection from ${ req.socket.remoteAddress } was closed`)))
+		})
+	})
+
+	return serverOpenPromise.promise
+}
+
+export interface ServerOptions {
+	port?: number
+	secure?: boolean
+	certPath?: string
+	keyPath?: string
+	deflate?: boolean
+	maxPayload?: number
+	useWorkerThread?: boolean
+}
+
+export const defaultServerOptions: ServerOptions = {
+	port: 45054,
+	secure: false,
+	certPath: undefined,
+	keyPath: undefined,
+	deflate: true,
+	maxPayload: 1000 * 1000000, // 1GB
+	useWorkerThread: true
+}

package/src/server/ServerStarter.ts

@@ -0,0 +1,12 @@
+import { logToStderr, setupProgramTerminationListeners, setupUnhandledExceptionListeners } from '../utilities/Utilities.js'
+import { startServer } from './Server.js'
+
+const log = logToStderr
+
+setupUnhandledExceptionListeners()
+
+setupProgramTerminationListeners(() => {
+	log('')
+})
+
+await startServer({}, (options) => { })