popov/gogo2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

worling demo setup

Browse Source
This commit is contained in:
Dobromir Popov 2024-06-15 18:10:45 +03:00
parent bab8528db1
commit ffca907f39
3 changed files with 415 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
.env.demo
View File

@ -6,7 +6,9 @@
# SERVER_PORT_HTTP=8080 # SERVER_PORT_HTTP=8080
ENV_NAME=demo ENV_NAME=demo
TTS_API_URL=https://api.tts.d-popov.com/asr # TTS_API_URL=https://api.tts.d-popov.com/asr
# TTS_API_URL=https://api.tts.d-popov.com/asr
# TTS_BACKEND=http://192.168.0.11:9009/asr
# LLN_MODEL=qwen2 # LLN_MODEL=qwen2
# LNN_API_URL=https://ollama.d-popov.com/api/generate # LNN_API_URL=https://ollama.d-popov.com/api/generate
@ -17,7 +19,7 @@ LNN_API_URL=https://ollama.d-popov.com/api/generate
GROQ_API_KEY=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 GROQ_API_KEY=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
OPENAI_API_KEY=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 OPENAI_API_KEY=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
PUBLIC_WS_URL=wss://ws.tts.d-popov.com # PUBLIC_WS_URL=wss://ws.tts.d-popov.com
PUBLIC_HOSTNAME=tts.d-popov.com # PUBLIC_HOSTNAME=tts.d-popov.com
SERVER_PORT_HTTP=28080 # SERVER_PORT_HTTP=28080
SERVER_PORT_WS=28081 # SERVER_PORT_WS=28081

32
docker-compose.demo.yml
View File

@ -1,16 +1,22 @@
version: '3.8'
services: services:
node-app: chat-server:
container_name: node-voice-chat image: node:20-alpine
build: container_name: ml-voice-chat-server
context: . working_dir: /usr/src/app
dockerfile: web/deploy/demo.Dockerfile
ports:
- "28880:8080"
- "28881:8081"
volumes: volumes:
- .:/usr/src/app # Mounts the current directory to /usr/src/app in the container - /mnt/apps/DEV/REPOS/git.d-popov.com/ai-kevin:/usr/src/app
command: >
sh -c "npm install && node web/chat-server.js"
environment: environment:
NODE_ENV: demo # Sets the environment variable NODE_ENV to development NODE_ENV: demo
command: npm run start:demo-chat # Runs npm start when the container starts #TTS_BACKEND_URL: https://api.tts.d-popov.com/asr
TTS_API_URL: http://192.168.0.11:9009/asr
WS_URL: wss://ws.tts.d-popov.com
SERVER_PORT_HTTP: 8080
SERVER_PORT_WS: 8082
ports:
- 28080:8080
- 28081:8082
dns:
- 8.8.8.8
- 8.8.4.4

500
web/chat-server.js
View File

@ -1,192 +1,216 @@
const express = require('express'); const express = require('express')
const bodyParser = require('body-parser'); const bodyParser = require('body-parser')
const WebSocket = require('ws'); const WebSocket = require('ws')
const storage = require('node-persist'); const storage = require('node-persist')
const request = require('request'); const request = require('request')
const fs = require('fs'); const fs = require('fs')
const path = require('path'); const path = require('path')
const dotenv = require('dotenv'); const dotenv = require('dotenv')
const ollama = require('ollama'); const ollama = require('ollama')
const axios = require('axios'); const axios = require('axios')
const OpenAI = require('openai'); const OpenAI = require('openai')
const Groq = require('groq-sdk'); const Groq = require('groq-sdk')
// Load environment variables // Load environment variables
dotenv.config({ path: `.env${process.env.NODE_ENV === 'development' ? '.development' :'.'+ process.env.NODE_ENV }` }); dotenv.config({
path: `.env${
process.env.NODE_ENV === 'development'
? '.development'
: '.' + process.env.NODE_ENV
}`
})
console.log(`loaded env file: ${process.env.NODE_ENV}`)
// Initialize services // Initialize services
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY }); const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY })
const groq = new Groq({ apiKey: process.env.GROQ_API_KEY }); const groq = new Groq({ apiKey: process.env.GROQ_API_KEY })
// Express setup // Express setup
const app = express(); const app = express()
app.use(bodyParser.json()); app.use(bodyParser.json())
// Configuration constants // Configuration constants
const PORT_HTTP = process.env.SERVER_PORT_HTTP || 3000; const PORT_HTTP = process.env.SERVER_PORT_HTTP || 3000
const PORT_WS = process.env.SERVER_PORT_WS || 8080; const PORT_WS = process.env.SERVER_PORT_WS || 8082
const TTS_API_URL = process.env.TTS_API_URL; const TTS_API_URL = process.env.TTS_API_URL
const LNN_API_URL = process.env.LNN_API_URL; const LNN_API_URL = process.env.LNN_API_URL
const LLN_MODEL = process.env.LLN_MODEL; const LLN_MODEL = process.env.LLN_MODEL
console.log(`TTS API URL: ${TTS_API_URL}`)
let language = "en"; let language = 'en'
let storeRecordings = false; let storeRecordings = false
let queueCounter = 0; let queueCounter = 0
const sessions = new Map(); const sessions = new Map()
const chats = new Map(); // Store chat rooms const chats = new Map() // Store chat rooms
// Initialize storage and load initial values // Initialize storage and load initial values
async function initStorage() { async function initStorage () {
await storage.init(); await storage.init()
language = await storage.getItem('language') || language; language = (await storage.getItem('language')) || language
storeRecordings = await storage.getItem('storeRecordings') || storeRecordings; storeRecordings =
(await storage.getItem('storeRecordings')) || storeRecordings
const storedChats = await storage.getItem('chats') || []; const storedChats = (await storage.getItem('chats')) || []
storedChats.forEach(chat => chats.set(chat.id, chat)); storedChats.forEach(chat => chats.set(chat.id, chat))
const storedSessions = await storage.getItem('sessions') || []; const storedSessions = (await storage.getItem('sessions')) || []
storedSessions.forEach(session => sessions.set(session.sessionId, session)); storedSessions.forEach(session => sessions.set(session.sessionId, session))
} }
initStorage(); initStorage()
// WebSocket Server // WebSocket Server
const wss = new WebSocket.Server({ port: PORT_WS }); const wss = new WebSocket.Server({ port: PORT_WS })
wss.on('connection', ws => { wss.on('connection', ws => {
ws.on('message', async message => handleMessage(ws, message)); ws.on('message', async message => handleMessage(ws, message))
ws.on('close', () => handleClose(ws)); ws.on('close', () => handleClose(ws))
}); })
// Handle WebSocket messages // Handle WebSocket messages
async function handleMessage(ws, message) { async function handleMessage (ws, message) {
let data; let data
try { try {
data = JSON.parse(message); data = JSON.parse(message)
} catch { } catch {
return handleAudioData(ws, message); return handleAudioData(ws, message)
} }
try { try {
switch (data.type) { switch (data.type) {
case 'sessionId': case 'sessionId':
await handleSessionId(ws); await handleSessionId(ws)
break; break
case 'join': case 'join':
await handleJoin(ws, data); await handleJoin(ws, data)
break; break
case 'startChat': case 'startChat':
await handleStartChat(ws, data); await handleStartChat(ws, data)
break; break
case 'enterChat': case 'enterChat':
await handleEnterChat(ws, data); await handleEnterChat(ws, data)
break; break
case 'reconnect': case 'reconnect':
await handleReconnect(ws, data); await handleReconnect(ws, data)
break; break
default: default:
console.log('Unknown message type:', data.type); console.log('Unknown message type:', data.type)
} }
} catch (err) { } catch (err) {
console.error('Failed to handle message', err); console.error('Failed to handle message', err)
} }
} }
function handleClose(ws) { function handleClose (ws) {
sessions.delete(ws.sessionId); sessions.delete(ws.sessionId)
broadcastUserList(); broadcastUserList()
} }
// Handlers for specific message types // Handlers for specific message types
async function handleSessionId(ws) { async function handleSessionId (ws) {
ws.sessionId = generateSessionId(); ws.sessionId = generateSessionId()
sessions.set(ws.sessionId, { language: 'en' }); sessions.set(ws.sessionId, { language: 'en' })
await storage.setItem('sessions', Array.from(sessions.values())); await storage.setItem('sessions', Array.from(sessions.values()))
} }
async function handleJoin(ws, { username, language }) { async function handleJoin (ws, { username, language }) {
sessions.set(ws.sessionId, { username, sessionId: ws.sessionId, language }); sessions.set(ws.sessionId, { username, sessionId: ws.sessionId, language })
ws.send(JSON.stringify({ type: 'sessionId', sessionId: ws.sessionId, language, storeRecordings })); ws.send(
JSON.stringify({
type: 'sessionId',
sessionId: ws.sessionId,
language,
storeRecordings
})
)
const userChats = Array.from(chats.values()).filter(chat => chat.participants.includes(ws.sessionId)); const userChats = Array.from(chats.values()).filter(chat =>
ws.send(JSON.stringify({ type: 'chats', chats: userChats })); chat.participants.includes(ws.sessionId)
)
ws.send(JSON.stringify({ type: 'chats', chats: userChats }))
broadcastUserList(); broadcastUserList()
} }
async function handleStartChat(ws, { users }) { async function handleStartChat (ws, { users }) {
const chatId = generateChatId(); const chatId = generateChatId()
let participants = [ws.sessionId, ...users]; let participants = [ws.sessionId, ...users]
participants = [...new Set(participants)]; participants = [...new Set(participants)]
chats.set(chatId, { participants, messages: [] }); chats.set(chatId, { participants, messages: [] })
await storage.setItem('chats', Array.from(chats.values())); await storage.setItem('chats', Array.from(chats.values()))
notifyParticipants(participants); notifyParticipants(participants)
broadcastUserList(); broadcastUserList()
} }
async function handleEnterChat(ws, { chatId }) { async function handleEnterChat (ws, { chatId }) {
const enteredChat = chats.get(chatId); const enteredChat = chats.get(chatId)
const currentSession = sessions.get(ws.sessionId); const currentSession = sessions.get(ws.sessionId)
currentSession.currentChat = chatId; currentSession.currentChat = chatId
if (enteredChat && enteredChat.participants.includes(ws.sessionId)) { if (enteredChat && enteredChat.participants.includes(ws.sessionId)) {
ws.send(JSON.stringify({ type: 'chat', chat: enteredChat })); ws.send(JSON.stringify({ type: 'chat', chat: enteredChat }))
} }
} }
async function handleReconnect(ws, { sessionId }) { async function handleReconnect (ws, { sessionId }) {
const userSession = sessions.get(sessionId); const userSession = sessions.get(sessionId)
if (userSession) { if (userSession) {
sessions.set(ws.sessionId, userSession); sessions.set(ws.sessionId, userSession)
ws.sessionId = sessionId; ws.sessionId = sessionId
const userChats = Array.from(chats.values()).filter(chat => chat.participants.includes(ws.sessionId)); const userChats = Array.from(chats.values()).filter(chat =>
ws.send(JSON.stringify({ type: 'chats', chats: userChats })); chat.participants.includes(ws.sessionId)
)
ws.send(JSON.stringify({ type: 'chats', chats: userChats }))
} else { } else {
console.log('Session not found:', sessionId); console.log('Session not found:', sessionId)
} }
broadcastUserList(); broadcastUserList()
} }
// Utility functions // Utility functions
function generateSessionId() { function generateSessionId () {
return Math.random().toString(36).substring(2); return Math.random().toString(36).substring(2)
} }
function generateChatId() { function generateChatId () {
return Math.random().toString(36).substring(2); return Math.random().toString(36).substring(2)
} }
function broadcastUserList() { function broadcastUserList () {
const userList = Array.from(sessions.values()).map(user => ({ const userList = Array.from(sessions.values()).map(user => ({
username: user.username, username: user.username,
sessionId: user.sessionId, sessionId: user.sessionId,
currentChat: user.currentChat, currentChat: user.currentChat,
language: user.language language: user.language
})); }))
wss.clients.forEach(client => { wss.clients.forEach(client => {
if (client.readyState === WebSocket.OPEN) { if (client.readyState === WebSocket.OPEN) {
client.send(JSON.stringify({ type: 'userList', users: userList })); client.send(JSON.stringify({ type: 'userList', users: userList }))
} }
}); })
} }
function notifyParticipants(participants) { function notifyParticipants (participants) {
participants.forEach(sessionId => { participants.forEach(sessionId => {
const participantSocket = Array.from(wss.clients).find(client => client.sessionId === sessionId); const participantSocket = Array.from(wss.clients).find(
client => client.sessionId === sessionId
)
if (participantSocket && participantSocket.readyState === WebSocket.OPEN) { if (participantSocket && participantSocket.readyState === WebSocket.OPEN) {
const userChats = Array.from(chats.entries()) const userChats = Array.from(chats.entries())
.filter(([id, chat]) => chat.participants.includes(sessionId)) .filter(([id, chat]) => chat.participants.includes(sessionId))
.map(([id, chat]) => ({ id, participants: chat.participants })); .map(([id, chat]) => ({ id, participants: chat.participants }))
participantSocket.send(JSON.stringify({ type: 'chats', chats: userChats })); participantSocket.send(
JSON.stringify({ type: 'chats', chats: userChats })
)
} }
}); })
} }
async function handleAudioData(ws, data) { async function handleAudioData (ws, data) {
const sessionData = sessions.get(ws.sessionId); const sessionData = sessions.get(ws.sessionId)
let { language, task } = sessionData; let { language, task } = sessionData
const formData = { const formData = {
task: task || 'transcribe', task: task || 'transcribe',
@ -197,100 +221,148 @@ async function handleAudioData(ws, data) {
value: data, value: data,
options: { filename: 'audio.ogg', contentType: 'audio/ogg' } options: { filename: 'audio.ogg', contentType: 'audio/ogg' }
} }
}; }
if (!language || language === 'auto') { if (!language || language === 'auto') {
await detectLanguage(ws, formData); await detectLanguage(ws, formData)
} else { } else {
await transcribeAudio(ws, formData, sessionData); await transcribeAudio(ws, formData, sessionData)
} }
} }
async function detectLanguage(ws, formData) { async function detectLanguage (ws, formData) {
try { try {
const result = await requestPromise({ const result = await requestPromise({
method: 'POST', method: 'POST',
url: TTS_API_URL.replace('/asr', '/detect-language'), url: TTS_API_URL.replace('/asr', '/detect-language'),
formData formData
}); })
const { language_code } = JSON.parse(result); const { language_code } = JSON.parse(result)
if (language_code) { if (language_code) {
const sessionData = sessions.get(ws.sessionId); const sessionData = sessions.get(ws.sessionId)
sessionData.language = language_code; sessionData.language = language_code
ws.send(JSON.stringify({ type: 'languageDetected', languageDetected: language_code })); ws.send(
await transcribeAudio(ws, formData, sessionData); JSON.stringify({
type: 'languageDetected',
languageDetected: language_code
})
)
await transcribeAudio(ws, formData, sessionData)
} }
} catch (err) { } catch (err) {
console.error('Language detection failed:', err); console.error('Language detection failed:', err)
} }
} }
async function transcribeAudio(ws, formData, sessionData) { async function transcribeAudio (ws, formData, sessionData) {
const start = new Date().getTime(); const start = new Date().getTime()
queueCounter++; queueCounter++
try { try {
if(sessionData.language) { if (sessionData.language) {
formData.language = sessionData.language; formData.language = sessionData.language
} }
formData.vad_filter = 'true'; formData.vad_filter = 'true'
const body = await requestPromise({ method: 'POST', url: TTS_API_URL, formData }); const body = await requestPromise({
queueCounter--; method: 'POST',
url: TTS_API_URL,
formData
})
queueCounter--
const duration = new Date().getTime() - start; const duration = new Date().getTime() - start
ws.send(JSON.stringify({ ws.send(
JSON.stringify({
type: 'text', type: 'text',
queueCounter, queueCounter,
duration, duration,
language: sessionData.language, language: sessionData.language,
text: body text: body
})); })
)
await handleChatTranscription(ws, body, sessionData);
await handleChatTranscription(ws, body, sessionData)
} catch (err) { } catch (err) {
console.error('Transcription failed:', err); console.error('Transcription failed:', err)
} }
if (storeRecordings) { if (storeRecordings) {
const timestamp = Date.now(); const timestamp = Date.now()
fs.mkdir('rec', { recursive: true }, err => { fs.mkdir('rec', { recursive: true }, err => {
if (err) console.error(err); if (err) console.error(err)
else { else {
fs.writeFile(`rec/audio${timestamp}.ogg`, formData.audio_file.value, err => { fs.writeFile(
if (err) console.error(err); `rec/audio${timestamp}.ogg`,
else console.log(`Audio data saved to rec/audio${timestamp}.ogg`); formData.audio_file.value,
}); err => {
if (err) console.error(err)
else console.log(`Audio data saved to rec/audio${timestamp}.ogg`)
} }
}); )
}
})
} }
} }
async function handleChatTranscription(ws, body, sessionData) { async function handleChatTranscription (ws, body, sessionData) {
if (sessionData.currentChat) { if (sessionData.currentChat) {
const chat = chats.get(sessionData.currentChat); const chat = chats.get(sessionData.currentChat)
if (chat) { if (chat) {
let msg = { sender: sessionData.username, text: body, translations: [] }; let msg = { sender: sessionData.username, text: body, translations: [] }
chat.messages.push(msg); chat.messages.push(msg)
for (let sessionId of chat.participants) { for (let sessionId of chat.participants) {
if (sessionId !== ws.sessionId) { if (sessionId !== ws.sessionId) {
const targetLang = sessions.get(sessionId)?.language || 'en'; const targetLang = sessions.get(sessionId)?.language || 'en'
if (targetLang !== sessionData.language) { if (targetLang !== sessionData.language) {
const translation = await translateText(body, sessionData.language, targetLang); const translation = await translateText(
msg.translations.push({ language: targetLang, text: translation }); body,
sessionData.language,
targetLang
)
msg.translations.push({ language: targetLang, text: translation })
const participantSocket = Array.from(wss.clients).find(client => client.sessionId === sessionId); const participantSocket = Array.from(wss.clients).find(
if (participantSocket && participantSocket.readyState === WebSocket.OPEN) { client => client.sessionId === sessionId
participantSocket.send(JSON.stringify({ type: 'text', text: `${sessionData.username}: ${translation}` })); )
const audioBuffer = await generateSpeech(translation); if (
participantSocket.send(JSON.stringify({ type: 'audio', audio: audioBuffer.toString('base64') })); participantSocket &&
participantSocket.readyState === WebSocket.OPEN
) {
participantSocket.send(
JSON.stringify({
type: 'text',
text: `${sessionData.username}: ${translation}`
})
)
const audioBuffer = await generateSpeech(translation)
participantSocket.send(
JSON.stringify({
type: 'audio',
audio: audioBuffer.toString('base64')
})
)
} }
} else { } else {
const participantSocket = Array.from(wss.clients).find(client => client.sessionId === sessionId); const participantSocket = Array.from(wss.clients).find(
if (participantSocket && participantSocket.readyState === WebSocket.OPEN) { client => client.sessionId === sessionId
participantSocket.send(JSON.stringify({ type: 'text', text: `${sessionData.username}: ${body}` })); )
participantSocket.send(JSON.stringify({ type: 'audio', audio: formData.toString('base64') })); if (
participantSocket &&
participantSocket.readyState === WebSocket.OPEN
) {
participantSocket.send(
JSON.stringify({
type: 'text',
text: `${sessionData.username}: ${body}`
})
)
participantSocket.send(
JSON.stringify({
type: 'audio',
audio: formData.toString('base64')
})
)
} }
} }
} }
@ -299,105 +371,109 @@ async function handleChatTranscription(ws, body, sessionData) {
} }
} }
async function translateText(originalText, originalLanguage, targetLanguage) { async function translateText (originalText, originalLanguage, targetLanguage) {
const prompt = `Translate this text from ${originalLanguage} to ${targetLanguage}: ${originalText}`; const prompt = `Translate this text from ${originalLanguage} to ${targetLanguage}: ${originalText}`
const response = await groq.chat.completions.create({ const response = await groq.chat.completions.create({
messages: [ messages: [
{ {
role: "system", role: 'system',
content: `You are translating voice transcriptions from '${originalLanguage}' to '${targetLanguage}'. Reply with just the translation.`, content: `You are translating voice transcriptions from '${originalLanguage}' to '${targetLanguage}'. Reply with just the translation.`
}, },
{ {
role: "user", role: 'user',
content: originalText, content: originalText
}, }
], ],
model: "llama3-8b-8192", model: 'llama3-8b-8192'
}); })
return response.choices[0]?.message?.content || ""; return response.choices[0]?.message?.content || ''
} }
async function generateSpeech(text) { async function generateSpeech (text) {
const mp3 = await openai.audio.speech.create({ const mp3 = await openai.audio.speech.create({
model: "tts-1", model: 'tts-1',
voice: "alloy", voice: 'alloy',
input: text, input: text
}); })
return Buffer.from(await mp3.arrayBuffer()); return Buffer.from(await mp3.arrayBuffer())
} }
// HTTP Server // HTTP Server
app.get('/', (req, res) => { app.get('/', (req, res) => {
res.sendFile(path.join(__dirname, 'chat-client.html')); res.sendFile(path.join(__dirname, 'chat-client.html'))
}); })
app.get('/audio.js', (req, res) => { app.get('/audio.js', (req, res) => {
res.sendFile(path.join(__dirname, 'audio.js')); res.sendFile(path.join(__dirname, 'audio.js'))
}); })
app.post('/log', (req, res) => { app.post('/log', (req, res) => {
console.log(`[LOG ${new Date().toISOString()}] ${req.body.message}`); console.log(`[LOG ${new Date().toISOString()}] ${req.body.message}`)
res.status(200).send('OK'); res.status(200).send('OK')
}); })
app.get('/wsurl', (req, res) => { app.get('/wsurl', (req, res) => {
// if(process.env.PUBLIC_HOSTNAME){ // if(process.env.PUBLIC_HOSTNAME){
// process.env.WS_URL = `wss://${process.env.PUBLIC_HOSTNAME}` // process.env.WS_URL = `wss://${process.env.PUBLIC_HOSTNAME}`
// } // }
console.log('Request for WS URL resolved with:', process.env.PUBLIC_WS_URL ); console.log('Request for WS URL resolved with:', process.env.WS_URL)
res.status(200).send(process.env.PUBLIC_WS_URL); res.status(200).send(process.env.WS_URL)
}); })
app.get('/settings', async (req, res) => { app.get('/settings', async (req, res) => {
if (req.query.language) { if (req.query.language) {
language = req.query.language; language = req.query.language
await storage.setItem('language', language); await storage.setItem('language', language)
} }
if (req.query.storeRecordings) { if (req.query.storeRecordings) {
storeRecordings = req.query.storeRecordings; storeRecordings = req.query.storeRecordings
await storage.setItem('storeRecordings', storeRecordings); await storage.setItem('storeRecordings', storeRecordings)
} }
res.status(200).send({ language, storeRecordings }); res.status(200).send({ language, storeRecordings })
}); })
app.post('/settings', async (req, res) => { app.post('/settings', async (req, res) => {
const { sessionId, language, storeRecordings, task } = req.body; const { sessionId, language, storeRecordings, task } = req.body
const sessionData = sessions.get(sessionId); const sessionData = sessions.get(sessionId)
if (language) sessionData.language = language; if (language) sessionData.language = language
if (storeRecordings !== undefined) sessionData.storeRecordings = storeRecordings; if (storeRecordings !== undefined)
if (task) sessionData.task = task; sessionData.storeRecordings = storeRecordings
res.status(200).send('OK'); if (task) sessionData.task = task
}); res.status(200).send('OK')
})
app.post('/upload', (req, res) => { app.post('/upload', (req, res) => {
const timestamp = Date.now(); const timestamp = Date.now()
console.log('Received audio data:', timestamp); console.log('Received audio data:', timestamp)
fs.mkdir('rec', { recursive: true }, err => { fs.mkdir('rec', { recursive: true }, err => {
if (err) return res.status(500).send('ERROR'); if (err) return res.status(500).send('ERROR')
const file = fs.createWriteStream(`rec/audio_slice_${timestamp}.ogg`); const file = fs.createWriteStream(`rec/audio_slice_${timestamp}.ogg`)
req.pipe(file); req.pipe(file)
file.on('finish', () => res.status(200).send('OK')); file.on('finish', () => res.status(200).send('OK'))
}); })
}); })
app.get('/chats', (req, res) => { app.get('/chats', (req, res) => {
const { username } = req.query; const { username } = req.query
const userChats = Array.from(chats.values()).filter(chat => chat.participants.includes(username)); const userChats = Array.from(chats.values()).filter(chat =>
res.status(200).send({ chats: userChats }); chat.participants.includes(username)
}); )
res.status(200).send({ chats: userChats })
})
app.listen(PORT_HTTP, () => { app.listen(PORT_HTTP, () => {
console.log(`Server listening on port ${PORT_HTTP}`); console.log(`Server listening on port ${PORT_HTTP}`)
}); console.log(process.env.TTS_BACKEND_URL)
})
// Helper to wrap request in a promise // Helper to wrap request in a promise
function requestPromise(options) { function requestPromise (options) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
request(options, (error, response, body) => { request(options, (error, response, body) => {
if (error) return reject(error); if (error) return reject(error)
resolve(body); resolve(body)
}); })
}); })
} }