@goodandready/dsh-tts 0.4.27 → 0.4.29

package/lib/providers/cloud.js

@@ -18,6 +18,29 @@ function escapeXml(s) {
     .replace(/"/g, '"')
 }
 
+function pcmToWav(pcmBuffer, sampleRate = 24000, channels = 1) {
+  if (pcmBuffer.length >= 4 && pcmBuffer.toString('ascii', 0, 4) === 'RIFF') {
+    return pcmBuffer
+  }
+  const header = Buffer.alloc(44)
+  const byteRate = sampleRate * channels * 2
+  const blockAlign = channels * 2
+  header.write('RIFF', 0)
+  header.writeUInt32LE(36 + pcmBuffer.length, 4)
+  header.write('WAVE', 8)
+  header.write('fmt ', 12)
+  header.writeUInt32LE(16, 16)
+  header.writeUInt16LE(1, 20)
+  header.writeUInt16LE(channels, 22)
+  header.writeUInt32LE(sampleRate, 24)
+  header.writeUInt32LE(byteRate, 28)
+  header.writeUInt16LE(blockAlign, 32)
+  header.writeUInt16LE(16, 34)
+  header.write('data', 36)
+  header.writeUInt32LE(pcmBuffer.length, 40)
+  return Buffer.concat([header, pcmBuffer])
+}
+
 export function makeCloudProviders(deps, req, withCloudTimeout) {
   const { resolveKey, fetchImpl, cfg } = deps
   const { text, lang, models, voices, role } = req
@@ -161,9 +184,23 @@ export function makeCloudProviders(deps, req, withCloudTimeout) {
     )
     if (!res.ok) throw new Error(`Google HTTP ${res.status}`)
     const data = await res.json()
-    const b64 = data?.candidates?.[0]?.content?.parts?.find((p) => p.inlineData)?.inlineData?.data
-    if (!b64) return { ok: false, provider: 'google', reason: 'no inline audio' }
-    const audio = Buffer.from(b64, 'base64')
+    const inline = data?.candidates?.[0]?.content?.parts?.find((p) => p.inlineData)?.inlineData
+    if (!inline?.data) return { ok: false, provider: 'google', reason: 'no inline audio' }
+    const raw = Buffer.from(inline.data, 'base64')
+    const mimeType = String(inline.mimeType || '')
+    let sampleRate = 24000
+    const m = mimeType.match(/rate=(\d+)/i)
+    if (m) sampleRate = parseInt(m[1], 10)
+    const isWavAlready = raw.length >= 4 && raw.toString('ascii', 0, 4) === 'RIFF'
+    let audio = null
+    const lowerMime = mimeType.toLowerCase()
+    if (isWavAlready || lowerMime.includes('wav')) {
+      audio = raw
+    } else if (!lowerMime || lowerMime.includes('pcm') || lowerMime.includes('raw') || lowerMime.includes('l16')) {
+      audio = pcmToWav(raw, sampleRate, 1)
+    } else {
+      return { ok: false, provider: 'google', reason: `unsupported Google TTS MIME: ${mimeType}` }
+    }
     return { ok: audio.length > 0, provider: 'google', audio, mime: 'audio/wav', reason: audio.length ? '' : 'empty audio' }
     } finally {
       cleanup()
@@ -181,8 +218,10 @@ export function makeCloudProviders(deps, req, withCloudTimeout) {
     const inner = safeStyle
       ? `<mstts:express-as style="${safeStyle}">${escapeXml(text)}</mstts:express-as>`
       : escapeXml(text)
-    const ssml = `<speak version="1.0" xml:lang="${lang || 'en-US'}">`
-      + `<voice xml:lang="${lang || 'en-US'}" name="${voice}">`
+    const safeLang = escapeXml(lang || 'en-US')
+    const safeVoice = escapeXml(voice)
+    const ssml = `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="${safeLang}">`
+      + `<voice xml:lang="${safeLang}" name="${safeVoice}">`
       + `${inner}</voice></speak>`
     const { signal, cleanup } = withCloudTimeout()
     try {

package/lib/providers/constants.js

@@ -31,9 +31,9 @@ export const DEFAULT_MODELS = {
   deepgram: 'aura-asteria-en',
   openrouter: 'openai/gpt-4o-mini-tts-2025-12-15',
   custom: '',
-  edge: 'ru-RU-SvetlanaNeural',
+  edge: 'en-US-AriaNeural',
   piper: '',
-  espeak: 'ru',
+  espeak: 'en',
 }
 
 export const DEFAULT_VOICES = {
@@ -53,9 +53,9 @@ export const DEFAULT_VOICES = {
   deepgram: '',
   openrouter: 'alloy',
   custom: '',
-  edge: 'ru-RU-SvetlanaNeural',
+  edge: 'en-US-AriaNeural',
   piper: '',
-  espeak: 'ru',
+  espeak: 'en',
 }
 
 

package/lib/providers/local.js

@@ -32,7 +32,7 @@ export function makeLocalProviders(deps, req) {
   }
   async function espeak() {
     try {
-      const voice = pick(DEFAULT_VOICES, voices, 'espeak') || lang || 'ru'
+      const voice = pick(DEFAULT_VOICES, voices, 'espeak') || lang || 'en'
       const out = await espeakSpeak(text, { bin: cfg.espeakBin, voice, timeoutMs: cfg.timeoutMs })
       return { ok: true, provider: 'espeak', audio: out.audio, mime: out.mime }
     } catch (e) {

package/lib/providers.js

@@ -16,13 +16,22 @@ export function makeProviders(deps, req) {
       timedOut = true
       controller.abort(new Error())
     }, cloudTimeoutMs)
+    let onParentAbort = null
     if (parentSignal) {
       if (parentSignal.aborted) controller.abort(parentSignal.reason)
-      else parentSignal.addEventListener('abort', () => controller.abort(parentSignal.reason), { once: true })
+      else {
+        onParentAbort = () => controller.abort(parentSignal.reason)
+        parentSignal.addEventListener('abort', onParentAbort, { once: true })
+      }
     }
     return {
       signal: controller.signal,
-      cleanup: () => clearTimeout(timer),
+      cleanup: () => {
+        clearTimeout(timer)
+        if (parentSignal && onParentAbort) {
+          try { parentSignal.removeEventListener('abort', onParentAbort) } catch (_err) { /* parent abort listener already removed */ }
+        }
+      },
     }
   }
 

package/lib/routes.js

@@ -1,3 +1,4 @@
+import { MODEL_SPECS } from './engines/manager.js'
 import { resolve } from 'node:path'
 import { registerPluginUpdater } from './updater.js'
 import { writeJson, readBody, isTrustedSettingsRequest } from './http-util.js'
@@ -17,6 +18,7 @@ export function registerHttpRoutes(ctx, api) {
     stats,
     speechCache,
     cleanText,
+    prepareSpeechText,
     synthesize,
     credentialsView,
     configResponse,
@@ -32,6 +34,10 @@ export function registerHttpRoutes(ctx, api) {
     path: '/dsh-tts/status',
     handler: async (req, res) => {
       if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
       const cfg = live()
       writeJson(res, 200, {
         ok: true,
@@ -42,7 +48,9 @@ export function registerHttpRoutes(ctx, api) {
         streamingEnabled: cfg.streamingEnabled,
         rate: cfg.rate,
         chime: cfg.chime,
-        bargeIn: cfg.bargeIn,
+        bargeIn: cfg.bargeIn && cfg.vadBargeIn !== false,
+        voiceDuplexEnabled: cfg.voiceDuplexEnabled !== false,
+        messengerTtsEnabled: cfg.messengerTtsEnabled !== false,
         language: cfg.language,
         chain: cfg.chain,
         roles: cfg.roles,
@@ -74,7 +82,6 @@ export function registerHttpRoutes(ctx, api) {
     },
   }), 'dsh-tts: /stream route')
 
-
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-tts/models/status',
@@ -112,6 +119,10 @@ export function registerHttpRoutes(ctx, api) {
         writeJson(res, 400, { ok: false, error: { code: 'param', message: 'missing engine parameter' } })
         return
       }
+      if (!Object.hasOwn(MODEL_SPECS, engine)) {
+        writeJson(res, 400, { ok: false, error: { code: 'param', message: 'unknown engine: ' + engine } })
+        return
+      }
       try {
         // Fire installation in background or await initial start
         modelManager.installModel(engine).catch(() => { /* background install error tracked in manager state */ })
@@ -149,6 +160,10 @@ export function registerHttpRoutes(ctx, api) {
         writeJson(res, 400, { ok: false, error: { code: 'param', message: 'missing engine parameter' } })
         return
       }
+      if (!Object.hasOwn(MODEL_SPECS, engine)) {
+        writeJson(res, 400, { ok: false, error: { code: 'param', message: 'unknown engine: ' + engine } })
+        return
+      }
       try {
         const result = await modelManager.deleteModel(engine)
         writeJson(res, 200, { ok: true, model: result })
@@ -167,30 +182,56 @@ export function registerHttpRoutes(ctx, api) {
         writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
         return
       }
-      let voiceInstalled = false
-      let messengerInstalled = false
+      function isPluginOrServicePresent(id) {
+        if (!ctx) return false
+        try {
+          if (typeof ctx.get === 'function' && ctx.get(id)) return true
+          if (ctx[id]) return true
+        } catch (_err) { /* service check fallback */ }
+        try {
+          const reg = ctx.registry || ctx.root?.registry
+          if (reg && typeof reg.entries === 'function') {
+            for (const [k, v] of reg.entries()) {
+              const name = String(v?.name || k?.name || '')
+              if (name === id || name === `dsh-${id}` || name === `@goodandready/dsh-${id}`) return true
+              if (id === 'messenger' && (name.includes('messenger') || name.includes('dsh-im'))) return true
+            }
+          }
+        } catch (_err) { /* registry check fallback */ }
+        try {
+          if (ctx.webServer) {
+            if (typeof ctx.webServer.hasRoute === 'function') {
+              if (ctx.webServer.hasRoute(`/dsh-${id}/status`)) return true
+            }
+            if (Array.isArray(ctx.webServer.routes)) {
+              if (ctx.webServer.routes.some((r) => r && r.path && r.path.includes(id))) return true
+            }
+          }
+        } catch (_err) { /* webServer route check fallback */ }
+        return false
+      }
 
-      try {
-        if (typeof ctx.webServer?.hasRoute === 'function') {
-          voiceInstalled = ctx.webServer.hasRoute('/dsh-voice/status')
-          messengerInstalled = ctx.webServer.hasRoute('/dsh-messenger-gateway/status')
-        }
-      } catch { /* ignore malformed client frame */ }
+      const voiceInstalled = isPluginOrServicePresent('voice')
+      const messengerInstalled = isPluginOrServicePresent('messenger')
 
       // Runtime routes are the only reliable signal. Do not probe ../ siblings
       // or node_modules layouts — they lie outside a normal npm install.
-
       writeJson(res, 200, {
         ok: true,
-        voice: {
-          installed: voiceInstalled,
-          package: '@goodandready/dsh-voice',
-          hint: 'dsh plugin --profile web add @goodandready/dsh-voice',
-        },
-        messenger: {
-          installed: messengerInstalled,
-          package: '@goodandready/dsh-messenger-gateway',
-          hint: 'dsh plugin --profile web add @goodandready/dsh-messenger-gateway',
+        voiceInstalled,
+        messengerInstalled,
+        note: 'State reflects active routes in the running harness.',
+        integrations: {
+          voice: {
+            installed: voiceInstalled,
+            package: '@goodandready/dsh-voice',
+            hint: 'dsh plugin --profile web add @goodandready/dsh-voice',
+          },
+          messenger: {
+            installed: messengerInstalled,
+            package: '@goodandready/dsh-messenger-gateway',
+            hint: 'dsh plugin --profile web add @goodandready/dsh-messenger-gateway',
+          },
         },
       })
     },
@@ -200,7 +241,7 @@ export function registerHttpRoutes(ctx, api) {
     kind: 'exact',
     path: '/dsh-tts/cache',
     handler: async (req, res) => {
-      if (req.method !== 'DELETE') {
+      if (req.method !== 'DELETE' && req.method !== 'POST') {
         writeJson(res, 405, { ok: false, error: { code: 'method', message: 'DELETE only' } })
         return
       }
@@ -209,10 +250,27 @@ export function registerHttpRoutes(ctx, api) {
         return
       }
       const removed = await speechCache.clear()
-      writeJson(res, 200, { ok: true, removed })
+      writeJson(res, 200, { ok: true, removed, cleared: removed })
     },
   }), 'dsh-tts: /cache route')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/cache/clear',
+    handler: async (req, res) => {
+      if (req.method !== 'POST' && req.method !== 'DELETE') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      const removed = await speechCache.clear()
+      writeJson(res, 200, { ok: true, removed, cleared: removed })
+    },
+  }), 'dsh-tts: /cache/clear route')
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-tts/preview',
@@ -281,6 +339,10 @@ export function registerHttpRoutes(ctx, api) {
     kind: 'exact',
     path: '/dsh-tts/config',
     handler: async (req, res) => {
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'dsh-tts: settings writes are same-origin only' } })
+        return
+      }
       if (req.method === 'GET') {
         writeJson(res, 200, await configResponse())
         return
@@ -289,10 +351,6 @@ export function registerHttpRoutes(ctx, api) {
         writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET or PUT' } })
         return
       }
-      if (!isTrustedSettingsRequest(req)) {
-        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'dsh-tts: settings writes are same-origin only' } })
-        return
-      }
       const settingsApi = typeof getSettingsApi === 'function' ? getSettingsApi() : null
       if (!settingsApi) {
         writeJson(res, 503, { ok: false, error: { code: 'settings', message: 'settings not ready' } })
@@ -308,8 +366,9 @@ export function registerHttpRoutes(ctx, api) {
         writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
         return
       }
+      const revision = payload?.revision ?? (typeof payload?.config === 'object' ? payload.config?.revision : undefined)
       if (payload && typeof payload.config === 'object') {
-        payload = { ...payload.config, keys: payload.keys }
+        payload = { ...payload.config, keys: payload.keys, revision: payload.revision ?? payload.config.revision }
       }
       const keys = pendingKeyWrites(payload && payload.keys)
       const stripped = stripSecretsFromConfig(payload)
@@ -322,10 +381,13 @@ export function registerHttpRoutes(ctx, api) {
         for (const item of keys) {
           await storeProviderKey(item.provider, item.value)
         }
-        await settingsApi.replace(parsed)
+        await settingsApi.replace(parsed, revision)
         writeJson(res, 200, await configResponse())
       } catch (e) {
-        writeJson(res, 500, { ok: false, error: { code: 'save', message: String(e && e.message || e) } })
+        const isConflict = e?.code === 'conflict' || e?.name === 'SettingsConflictError' || /conflict|revision/i.test(e?.message || '')
+        const statusCode = isConflict ? 409 : 500
+        const code = isConflict ? 'conflict' : 'save'
+        writeJson(res, statusCode, { ok: false, error: { code, message: String(e && e.message || e) } })
       }
     },
   }), 'dsh-tts: /config route')
@@ -402,13 +464,22 @@ export function registerHttpRoutes(ctx, api) {
       }
       let payload
       try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch { /* invalid JSON treated as empty */ /* invalid JSON treated as empty */ payload = {} }
-      const text = cleanText(payload.text, live())
-      if (!text) { writeJson(res, 400, { ok: false, error: { code: 'no-text', message: 'no text' } }); return }
+      const rawText = String(payload.text || '')
+      if (!rawText.trim()) { writeJson(res, 400, { ok: false, error: { code: 'no-text', message: 'no text' } }); return }
       const cfg = live()
+      const isMessenger = payload.channel === 'messenger' || payload.source === 'messenger' || req.headers['x-dsh-channel'] === 'messenger'
+      if (isMessenger && !cfg.messengerTtsEnabled) {
+        writeJson(res, 403, { ok: false, error: { code: 'disabled', message: 'messenger tts is disabled' } })
+        return
+      }
       const controller = new AbortController()
       const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
       try {
-        const out = await synthesize(text, cfg, controller.signal)
+        const text = typeof prepareSpeechText === 'function'
+          ? await prepareSpeechText(rawText, cfg, controller.signal)
+          : cleanText(rawText, cfg, 0)
+        if (!text) { writeJson(res, 400, { ok: false, error: { code: 'no-text', message: 'no text' } }); return }
+        const out = await synthesize(text, cfg, controller.signal, 'reply', { skipClean: true })
         writeJson(res, 200, {
           ok: true,
           provider: out.provider,
@@ -424,15 +495,15 @@ export function registerHttpRoutes(ctx, api) {
     },
   }), 'dsh-tts: /speak route')
 
-  registerPluginUpdater(ctx, {
+  ctx.effect(() => registerPluginUpdater(ctx, {
     endpoint: '/dsh-tts/updater',
     packageName: '@goodandready/dsh-tts',
     manifestUrl: new URL('../package.json', import.meta.url),
-  })
+  }), 'dsh-tts: updater route /dsh-tts/updater')
 
-  registerPluginUpdater(ctx, {
+  ctx.effect(() => registerPluginUpdater(ctx, {
     endpoint: '/api/dsh-tts/update',
     packageName: '@goodandready/dsh-tts',
     manifestUrl: new URL('../package.json', import.meta.url),
-  })
+  }), 'dsh-tts: updater route /api/dsh-tts/update')
 }

package/lib/stream-hub.js

@@ -3,24 +3,69 @@
 const subscribers = new Set()
 let heartbeatTimer = null
 
+// Max buffer size for a slow subscriber before disconnecting (512 KB)
+export const MAX_SUBSCRIBER_BUFFER = 512 * 1024
+
 function detach(res) {
   try {
-    if (res.__dtsOnClose) res.off('close', res.__dtsOnClose)
-    if (res.__dtsOnError) res.off('error', res.__dtsOnError)
+    if (res.__dtsOnClose && typeof res.off === 'function') res.off('close', res.__dtsOnClose)
+    if (res.__dtsOnError && typeof res.off === 'function') res.off('error', res.__dtsOnError)
+    if (res.__dtsOnDrain && typeof res.off === 'function') res.off('drain', res.__dtsOnDrain)
   } catch { /* listeners may already be gone */ }
   res.__dtsOnClose = null
   res.__dtsOnError = null
+  res.__dtsOnDrain = null
+  res.__dtsBackpressured = false
+  res.__dtsBufferedBytes = 0
 }
 
 function safeWrite(res, payload) {
+  const payloadBytes = Buffer.byteLength(payload)
+  const currentBuffered = typeof res.writableLength === 'number'
+    ? res.writableLength
+    : (res.__dtsBufferedBytes || 0)
+
+  if (res.__dtsBackpressured && currentBuffered + payloadBytes > MAX_SUBSCRIBER_BUFFER) {
+    subscribers.delete(res)
+    detach(res)
+    try { res.end() } catch (_err) { /* already ended */ }
+    return false
+  }
+
+  let writeOk = true
   try {
-    res.write(payload)
-    return true
-  } catch {
+    writeOk = res.write(payload)
+  } catch (_err) {
     subscribers.delete(res)
     detach(res)
     return false
   }
+
+  if (writeOk === false) {
+    res.__dtsBackpressured = true
+    res.__dtsBufferedBytes = (res.__dtsBufferedBytes || 0) + payloadBytes
+    if (res.__dtsBufferedBytes > MAX_SUBSCRIBER_BUFFER) {
+      subscribers.delete(res)
+      detach(res)
+      try { res.end() } catch (_err) { /* already ended */ }
+      return false
+    }
+    if (!res.__dtsOnDrain) {
+      const onDrain = () => {
+        res.__dtsBackpressured = false
+        res.__dtsBufferedBytes = 0
+      }
+      res.__dtsOnDrain = onDrain
+      try {
+        if (typeof res.on === 'function') res.on('drain', onDrain)
+      } catch (_err) { /* non-eventemitter mock */ }
+    }
+  } else if (res.__dtsBackpressured && (!res.writableLength || res.writableLength === 0)) {
+    res.__dtsBackpressured = false
+    res.__dtsBufferedBytes = 0
+  }
+
+  return writeOk
 }
 
 function ensureHeartbeat() {
@@ -47,8 +92,10 @@ export function addStreamSubscriber(res) {
   res.__dtsOnClose = onClose
   res.__dtsOnError = onClose
   try {
-    res.on('close', onClose)
-    res.on('error', onClose)
+    if (typeof res.on === 'function') {
+      res.on('close', onClose)
+      res.on('error', onClose)
+    }
   } catch { /* non-node response object in tests */ }
   ensureHeartbeat()
 }
@@ -80,4 +127,4 @@ export function clearStreamSubscribers() {
     clearInterval(heartbeatTimer)
     heartbeatTimer = null
   }
-}
+}

package/lib/text.js

@@ -59,7 +59,24 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
 
-export const BUILTIN_IT_DICTIONARY = []
+export const BUILTIN_IT_DICTIONARY = [
+  { from: 'API', to: 'A P I', whole: true, lang: '' },
+  { from: 'CLI', to: 'C L I', whole: true, lang: '' },
+  { from: 'CPU', to: 'C P U', whole: true, lang: '' },
+  { from: 'GPU', to: 'G P U', whole: true, lang: '' },
+  { from: 'RAM', to: 'ram', whole: true, lang: '' },
+  { from: 'SQL', to: 'sequel', whole: true, lang: '' },
+  { from: 'UI', to: 'U I', whole: true, lang: '' },
+  { from: 'URL', to: 'U R L', whole: true, lang: '' },
+  { from: 'UUID', to: 'U U I D', whole: true, lang: '' },
+  { from: 'JSON', to: 'j-son', whole: true, lang: '' },
+  { from: 'YAML', to: 'yam-el', whole: true, lang: '' },
+  { from: 'HTML', to: 'H T M L', whole: true, lang: '' },
+  { from: 'CSS', to: 'C S S', whole: true, lang: '' },
+  { from: 'SSH', to: 'S S H', whole: true, lang: '' },
+  { from: 'DNS', to: 'D N S', whole: true, lang: '' },
+  { from: 'IP', to: 'I P', whole: true, lang: '' },
+]
 
 export function applyPronunciation(text, rules, language, enableBuiltinIt = false) {
   let out = String(text || '')
@@ -121,7 +138,13 @@ export function stripForSpeech(raw, maxChars, opts) {
 
 export function assistantText(message) {
   if (!message) return ''
-  return blocksToText(message.content)
+  if (typeof message === 'string') return message
+  if (typeof message === 'object') {
+    if (message.content !== undefined) return blocksToText(message.content)
+    if (typeof message.text === 'string') return message.text
+    if (typeof message.message === 'string') return message.message
+  }
+  return ''
 }
 
 // Protect common English abbreviations from false sentence splits

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-tts",
-  "version": "0.4.27",
+  "version": "0.4.29",
   "description": "Text-to-speech for DeepSeek Harness: speak agent replies in the Web UI with a provider fallback chain (OpenAI, ElevenLabs, Google, Azure, Groq, Deepgram, OpenRouter, Edge, Piper, eSpeak).",
   "license": "MIT",
   "type": "module",