@goodandready/dsh-tts 0.3.23 → 0.4.1

package/lib/engines/f5.js

@@ -1,5 +1,32 @@
 import { spawn } from 'node:child_process'
 
+function collectPing(pythonBin, daemonPath) {
+  return new Promise((resolve) => {
+    const proc = spawn(pythonBin, [daemonPath, '--ping'])
+    let out = ''
+    let settled = false
+    const done = (ok) => {
+      if (settled) return
+      settled = true
+      resolve(ok)
+    }
+    proc.stdout.on('data', (c) => { out += c })
+    proc.on('error', () => done(false))
+    proc.on('close', (code) => {
+      if (code !== 0) {
+        done(false)
+        return
+      }
+      try {
+        const res = JSON.parse(out)
+        done(!!res.ok)
+      } catch {
+        done(false)
+      }
+    })
+  })
+}
+
 export class F5Engine {
   constructor({ daemonPath = 'scripts/f5_daemon.py', pythonBin = 'python3', modelPath = '' } = {}) {
     this.daemonPath = daemonPath
@@ -7,39 +34,24 @@ export class F5Engine {
     this.modelPath = modelPath
   }
 
+  /** Resolve true only after a successful daemon handshake. */
   async ping() {
-    return new Promise((resolve) => {
-      // Try spawning python with daemonPath --ping
-      const proc = spawn(this.pythonBin, [this.daemonPath, '--ping'])
-      let out = ''
-      proc.stdout.on('data', (c) => { out += c })
-      proc.on('error', () => {
-        // Fallback to 'python' if 'python3' is not found (e.g. on Windows)
-        if (this.pythonBin === 'python3') {
-          const fallback = spawn('python', [this.daemonPath, '--ping'])
-          let fallbackOut = ''
-          fallback.stdout.on('data', (c) => { fallbackOut += c })
-          fallback.on('error', () => resolve(true)) // In test environment without python, return true
-          fallback.on('close', (code) => {
-            try {
-              const res = JSON.parse(fallbackOut)
-              resolve(!!res.ok)
-            } catch {
-              resolve(code === 0)
-            }
-          })
-          return
-        }
-        resolve(true)
-      })
-      proc.on('close', (code) => {
-        try {
-          const res = JSON.parse(out)
-          resolve(!!res.ok)
-        } catch {
-          resolve(code === 0)
-        }
-      })
-    })
+    const primary = await collectPing(this.pythonBin, this.daemonPath)
+    if (primary) return true
+    if (this.pythonBin === 'python3') {
+      return collectPing('python', this.daemonPath)
+    }
+    return false
+  }
+
+  isRuntimeAvailable() {
+    return false
+  }
+
+  async synthesize() {
+    throw new Error(
+      'F5-TTS runtime is not bundled in @goodandready/dsh-tts. ' +
+      'Use Edge, Piper, or eSpeak for offline TTS.',
+    )
   }
 }

package/lib/engines/kokoro.js

@@ -1,5 +1,13 @@
 import fs from 'node:fs'
 
+/**
+ * Local Kokoro engine wrapper.
+ *
+ * Real ONNX inference is intentionally not bundled in this package: shipping
+ * onnxruntime + voice tensors would blow the DSH Store size budget and couple
+ * the plugin to native binaries. Until a supported external runtime is wired,
+ * synthesis must fail honestly — never emit a synthetic tone.
+ */
 export class KokoroEngine {
   constructor({ modelPath = '' } = {}) {
     this.modelPath = modelPath
@@ -10,39 +18,23 @@ export class KokoroEngine {
     return !!(this.modelPath && fs.existsSync(this.modelPath))
   }
 
-  /**
-   * Synthesizes audio stream yielding Float32Array PCM chunks (24kHz).
-   * @param {string} text
-   * @param {string} voice
-   * @returns {AsyncGenerator<Float32Array>}
-   */
-  async *synthesize(text, voice = 'af_bella') {
-    if (!text || !text.trim()) return
+  /** True only when a real inference backend can produce speech. */
+  isRuntimeAvailable() {
+    return false
+  }
 
-    // Generates 1s chunk of PCM frames (24000 samples for test/stub)
-    const samples = Math.max(2400, Math.min(24000, text.length * 800))
-    const chunk = new Float32Array(samples)
-    for (let i = 0; i < samples; i++) {
-      // Soft synthetic sine wave envelope so it does not pop
-      chunk[i] = Math.sin((i * 440 * 2 * Math.PI) / this.sampleRate) * 0.2 * (1 - i / samples)
-    }
-    yield chunk
+  async *synthesize() {
+    throw new Error(
+      'Kokoro ONNX runtime is not bundled in @goodandready/dsh-tts. ' +
+      'Install weights does not enable speech. Use Edge, Piper, or eSpeak for offline TTS.',
+    )
   }
 
-  async synthesizeWav(text, voice = 'af_bella') {
-    const chunks = []
-    for await (const chunk of this.synthesize(text, voice)) {
-      chunks.push(chunk)
-    }
-    let totalLen = 0
-    for (const c of chunks) totalLen += c.length
-    const merged = new Float32Array(totalLen)
-    let offset = 0
-    for (const c of chunks) {
-      merged.set(c, offset)
-      offset += c.length
+  async synthesizeWav() {
+    for await (const _ of this.synthesize()) {
+      // unreachable: synthesize always throws
     }
-    return pcmFloat32ToWav(merged, this.sampleRate)
+    throw new Error('Kokoro synthesis unavailable')
   }
 }
 

package/lib/engines/types.js

@@ -1,46 +1,59 @@
-import { execSync } from 'node:child_process'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
 
-export function detectGPU() {
+const execFileAsync = promisify(execFile)
+
+let gpuCache
+
+export async function detectGPU() {
+  if (typeof gpuCache === 'boolean') return gpuCache
   try {
-    const out = execSync('nvidia-smi --query-gpu=name --format=csv,noheader', {
-      stdio: ['ignore', 'pipe', 'ignore'],
-      timeout: 2000,
-      encoding: 'utf8',
-    })
-    return !!(out && out.trim())
+    const { stdout } = await execFileAsync(
+      'nvidia-smi',
+      ['--query-gpu=name', '--format=csv,noheader'],
+      { timeout: 2000 },
+    )
+    gpuCache = !!(stdout && stdout.trim())
   } catch {
-    return false
+    gpuCache = false
   }
+  return gpuCache
 }
 
 export class EngineRegistry {
-  constructor({ gpu, installed, manager } = {}) {
-    this.gpu = typeof gpu === 'boolean' ? gpu : detectGPU()
+  constructor({ gpu = false, installed = [], manager = null } = {}) {
+    this.gpu = !!gpu
     this.installed = Array.isArray(installed) ? installed : []
     this.manager = manager || null
   }
 
+  static async create({ installed, manager } = {}) {
+    const gpu = await detectGPU()
+    return new EngineRegistry({ gpu, installed, manager })
+  }
+
   isInstalled(engineId) {
     return this.installed.includes(engineId)
   }
 
   list() {
     const list = []
-    // Kokoro works on CPU everywhere
+    // Kokoro weights may be present, but inference is not bundled.
     if (this.installed.includes('kokoro')) {
       list.push({
         id: 'kokoro',
         name: 'Kokoro-82M',
         type: 'local-cpu',
+        runtimeAvailable: false,
         supports: (lang) => !lang || ['en', 'ru', 'ja', 'zh'].includes(String(lang).slice(0, 2).toLowerCase()),
       })
     }
-    // F5-TTS requires GPU
     if (this.gpu && this.installed.includes('f5')) {
       list.push({
         id: 'f5',
         name: 'F5-TTS',
         type: 'local-gpu',
+        runtimeAvailable: false,
         supports: () => true,
       })
     }

package/lib/http-util.js

@@ -0,0 +1,27 @@
+// Shared HTTP helpers for dsh-tts host routes.
+
+export function writeJson(res, code, body) {
+  try {
+    res.writeHead(code, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' })
+    res.end(JSON.stringify(body))
+  } catch { /* socket closed */ }
+}
+
+export function readBody(req, maxBytes) {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    let size = 0
+    req.on('data', (c) => {
+      size += c.length
+      if (size > maxBytes) { reject(new Error('body too large')); req.destroy(); return }
+      chunks.push(c)
+    })
+    req.on('end', () => resolve(Buffer.concat(chunks)))
+    req.on('error', reject)
+  })
+}
+
+/** Reject cross-site POSTs. Do not require loopback or Origin==Host: the Web UI is used over LAN and reverse proxies. */
+export function isTrustedSettingsRequest(request) {
+  return request.headers['sec-fetch-site'] !== 'cross-site'
+}