@goodandready/dsh-tts 0.4.27 → 0.4.29

package/lib/engines/manager.js

@@ -11,11 +11,13 @@ export const MODEL_SPECS = {
     files: [
       {
         name: 'kokoro-v0_19.onnx',
-        url: 'https://huggingface.co/hexgrad/Kokoro-82M/resolve/main/kokoro-v0_19.onnx',
+        url: 'https://huggingface.co/hexgrad/Kokoro-82M/resolve/f905c3175b9f7a77d4c1b9be894ff99ff7e9a8f2/kokoro-v0_19.onnx',
+        minBytes: 1024,
       },
       {
         name: 'voices.json',
-        url: 'https://huggingface.co/hexgrad/Kokoro-82M/resolve/main/voices.json',
+        url: 'https://huggingface.co/hexgrad/Kokoro-82M/resolve/f905c3175b9f7a77d4c1b9be894ff99ff7e9a8f2/voices.json',
+        minBytes: 1024,
       },
     ],
   },
@@ -28,6 +30,7 @@ export const MODEL_SPECS = {
       {
         name: 'model_1200000.safetensors',
         url: 'https://huggingface.co/SWivid/F5-TTS/resolve/main/F5TTS_Base/model_1200000.safetensors',
+        minBytes: 1024,
       },
     ],
   },
@@ -42,13 +45,26 @@ export function createModelManager({ root = process.env.DSH_HOME || path.join(os
     return path.join(baseDir, engineId)
   }
 
-  async function checkFileExists(filePath) {
-    try {
-      const st = await fs.promises.stat(filePath)
-      return st.isFile() && st.size > 0
-    } catch {
+  async function validateFileIntegrity(filePath, minBytes = 1024) {
+  try {
+    const st = await fs.promises.stat(filePath)
+    if (!st.isFile() || st.size < minBytes) return false
+    const fd = await fs.promises.open(filePath, 'r')
+    const buf = Buffer.alloc(Math.min(st.size, 1024))
+    await fd.read(buf, 0, buf.length, 0)
+    await fd.close()
+    const str = buf.toString('utf8').trim().toLowerCase()
+    if (str.startsWith('<!doctype') || str.startsWith('<html') || str.startsWith('<head') || str.includes('<html')) {
       return false
     }
+    return true
+  } catch (_err) {
+    return false
+  }
+}
+
+  async function checkFileExists(filePath, minBytes = 1024) {
+    return await validateFileIntegrity(filePath, minBytes)
   }
 
   async function getDirSize(dirPath) {
@@ -98,7 +114,7 @@ export function createModelManager({ root = process.env.DSH_HOME || path.join(os
     let allFilesExist = true
     for (const f of spec.files) {
       const p = path.join(dir, f.name)
-      if (!(await checkFileExists(p))) {
+      if (!(await checkFileExists(p, f.minBytes || 1024))) {
         allFilesExist = false
         break
       }
@@ -132,14 +148,14 @@ export function createModelManager({ root = process.env.DSH_HOME || path.join(os
     const spec = MODEL_SPECS[engineId]
     if (!spec) throw new Error(`Unknown engine: ${engineId}`)
 
-    if (activeDownloads.has(engineId)) {
-      throw new Error(`Download already in progress for ${engineId}`)
+    const existing = activeDownloads.get(engineId)
+    if (existing && existing.promise) {
+      return await existing.promise
     }
     lastErrors.delete(engineId)
 
     const customFetch = options.fetchImpl || fetchImpl
     const dir = getModelPath(engineId)
-    await fs.promises.mkdir(dir, { recursive: true })
 
     const controller = new AbortController()
     if (options.signal) {
@@ -152,90 +168,136 @@ export function createModelManager({ root = process.env.DSH_HOME || path.join(os
       downloadedBytes: 0,
       totalBytes: spec.approxMb * 1024 * 1024,
       controller,
+      promise: null,
     }
-    activeDownloads.set(engineId, downloadState)
-    let totalDownloaded = 0
 
-    try {
-      for (const f of spec.files) {
-        if (options.signal?.aborted || controller.signal.aborted) {
-          throw new Error('Download aborted')
-        }
+    const createdTmpFiles = []
 
-        const targetFile = path.join(dir, f.name)
-        const tmpFile = path.join(dir, `${f.name}.tmp`)
+    const execute = async () => {
+      await fs.promises.mkdir(dir, { recursive: true })
+      let totalDownloaded = 0
+      try {
+        for (const f of spec.files) {
+          if (options.signal?.aborted || controller.signal.aborted) {
+            throw new Error('Download aborted')
+          }
 
-        const res = await customFetch(f.url, { signal: controller.signal })
-        if (!res.ok) {
-          throw new Error(`Failed to download ${f.name}: HTTP ${res.status}`)
-        }
+          const targetFile = path.join(dir, f.name)
+          const nonce = `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
+          const tmpFile = path.join(dir, `${f.name}.${nonce}.tmp`)
+          createdTmpFiles.push(tmpFile)
+
+          const res = await customFetch(f.url, { signal: controller.signal })
+          if (!res.ok) {
+            throw new Error(`Failed to download ${f.name}: HTTP ${res.status}`)
+          }
+
+          if (res.body && typeof res.body.getReader === 'function') {
+            const reader = res.body.getReader()
+            const ws = fs.createWriteStream(tmpFile)
+            let streamError = null
+            const onStreamError = (err) => { streamError = err }
+            ws.once('error', onStreamError)
+            try {
+              while (true) {
+                if (streamError) throw streamError
+                const { done, value } = await reader.read()
+                if (done) break
+                if (streamError) throw streamError
 
-        if (res.body && typeof res.body.getReader === 'function') {
-          const reader = res.body.getReader()
-          const ws = fs.createWriteStream(tmpFile)
-          try {
-            while (true) {
-              const { done, value } = await reader.read()
-              if (done) break
-              await new Promise((resolve, reject) => {
                 if (!ws.write(value)) {
-                  ws.once('drain', resolve)
-                } else {
-                  process.nextTick(resolve)
+                  await new Promise((resolve, reject) => {
+                    const onDrain = () => { cleanup(); resolve() }
+                    const onError = (e) => { cleanup(); reject(e) }
+                    const cleanup = () => {
+                      ws.removeListener('drain', onDrain)
+                      ws.removeListener('error', onError)
+                    }
+                    ws.once('drain', onDrain)
+                    ws.once('error', onError)
+                  })
+                }
+                totalDownloaded += value.length
+                downloadState.downloadedBytes = totalDownloaded
+                downloadState.progress = Math.min(100, Math.round((totalDownloaded / (downloadState.totalBytes || 1)) * 100))
+                if (typeof options.onProgress === 'function') {
+                  options.onProgress(downloadState)
                 }
-                ws.once('error', reject)
-              })
-              totalDownloaded += value.length
-              downloadState.downloadedBytes = totalDownloaded
-              downloadState.progress = Math.min(100, Math.round((totalDownloaded / (downloadState.totalBytes || 1)) * 100))
-              if (typeof options.onProgress === 'function') {
-                options.onProgress(downloadState)
               }
+            } finally {
+              ws.removeListener('error', onStreamError)
+              await new Promise((resolve, reject) => {
+                ws.end((err) => (err ? reject(err) : resolve()))
+              })
             }
-          } finally {
-            await new Promise((resolve) => ws.end(resolve))
+          } else if (res.arrayBuffer) {
+            const buf = Buffer.from(await res.arrayBuffer())
+            totalDownloaded += buf.length
+            downloadState.downloadedBytes = totalDownloaded
+            downloadState.progress = Math.min(100, Math.round((totalDownloaded / (downloadState.totalBytes || 1)) * 100))
+            await fs.promises.writeFile(tmpFile, buf)
+          } else if (typeof res.text === 'function') {
+            const txt = await res.text()
+            const buf = Buffer.from(txt, 'utf8')
+            totalDownloaded += buf.length
+            downloadState.downloadedBytes = totalDownloaded
+            await fs.promises.writeFile(tmpFile, buf)
           }
-        } else if (res.arrayBuffer) {
-          const buf = Buffer.from(await res.arrayBuffer())
-          totalDownloaded += buf.length
-          downloadState.downloadedBytes = totalDownloaded
-          downloadState.progress = Math.min(100, Math.round((totalDownloaded / (downloadState.totalBytes || 1)) * 100))
-          await fs.promises.writeFile(tmpFile, buf)
-        } else if (typeof res.text === 'function') {
-          const txt = await res.text()
-          const buf = Buffer.from(txt, 'utf8')
-          totalDownloaded += buf.length
-          downloadState.downloadedBytes = totalDownloaded
-          await fs.promises.writeFile(tmpFile, buf)
-        }
 
-        await fs.promises.rename(tmpFile, targetFile)
-      }
+          const minExpected = f.minBytes || 1024
+          const st = await fs.promises.stat(tmpFile)
+          if (st.size < minExpected) {
+            throw new Error(`File ${f.name} truncated: got ${st.size} bytes, expected at least ${minExpected}`)
+          }
+          const valid = await validateFileIntegrity(tmpFile, minExpected)
+          if (!valid) {
+            throw new Error(`File ${f.name} failed integrity check: invalid format or HTML error`)
+          }
 
-      downloadState.progress = 100
-      activeDownloads.delete(engineId)
-      lastErrors.delete(engineId)
-      return await getStatus(engineId)
-    } catch (err) {
-      // Clean up tmp files
-      for (const f of spec.files) {
-        const tmpFile = path.join(dir, `${f.name}.tmp`)
-        await fs.promises.rm(tmpFile, { force: true }).catch(() => {})
+          await fs.promises.rename(tmpFile, targetFile)
+          const idx = createdTmpFiles.indexOf(tmpFile)
+          if (idx !== -1) createdTmpFiles.splice(idx, 1)
+        }
+
+        downloadState.progress = 100
+        lastErrors.delete(engineId)
+        activeDownloads.delete(engineId)
+        return await getStatus(engineId)
+      } catch (err) {
+        for (const tmp of createdTmpFiles) {
+          await fs.promises.rm(tmp, { force: true }).catch(() => {})
+        }
+        const rawMsg = String(err?.message || err || 'Installation failed')
+        const sanitized = rawMsg.replace(/https?:\/\/[^\s]+/g, '[url]')
+        lastErrors.set(engineId, { message: sanitized, failedAt: Date.now() })
+        throw err
+      } finally {
+        if (activeDownloads.get(engineId) === downloadState) {
+          activeDownloads.delete(engineId)
+        }
       }
-      const rawMsg = String(err?.message || err || 'Installation failed')
-      const sanitized = rawMsg.replace(/https?:\/\/[^\s]+/g, '[url]')
-      lastErrors.set(engineId, { message: sanitized, failedAt: Date.now() })
-      throw err
-    } finally {
-      activeDownloads.delete(engineId)
     }
+
+    const promise = execute()
+    downloadState.promise = promise
+    activeDownloads.set(engineId, downloadState)
+    return await promise
   }
 
   async function cancelDownload(engineId) {
     const active = activeDownloads.get(engineId)
     if (active && active.controller) {
       active.controller.abort()
-      activeDownloads.delete(engineId)
+      if (active.promise) {
+        try {
+          await active.promise
+        } catch (_err) {
+          // aborted download rejected as expected
+        }
+      }
+      if (activeDownloads.get(engineId) === active) {
+        activeDownloads.delete(engineId)
+      }
       lastErrors.delete(engineId)
       return true
     }