@goodandready/dsh-tts 0.4.26 → 0.4.28

package/lib/engines/manager.js

@@ -12,10 +12,12 @@ export const MODEL_SPECS = {
       {
         name: 'kokoro-v0_19.onnx',
         url: 'https://huggingface.co/hexgrad/Kokoro-82M/resolve/main/kokoro-v0_19.onnx',
+        minBytes: 1024,
       },
       {
         name: 'voices.json',
         url: 'https://huggingface.co/hexgrad/Kokoro-82M/resolve/main/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,10 +45,10 @@ export function createModelManager({ root = process.env.DSH_HOME || path.join(os
     return path.join(baseDir, engineId)
   }
 
-  async function checkFileExists(filePath) {
+  async function checkFileExists(filePath, minBytes = 1024) {
     try {
       const st = await fs.promises.stat(filePath)
-      return st.isFile() && st.size > 0
+      return st.isFile() && st.size >= minBytes
     } catch {
       return false
     }
@@ -98,7 +101,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 +135,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,83 +155,114 @@ 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}`)
+          }
 
-      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 {
+        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) {