@qvac/sdk 0.2.7-dev.1761566029.f834aa3 → 0.4.0

package/dist/server/rpc/handlers/load-model/download-manager.js

@@ -1,11 +1,9 @@
 import {} from "../../../../schemas/index.js";
-import process from "bare-process";
 const activeDownloads = new Map();
 const clearCacheFlags = new Map();
 export const getActiveDownload = (key) => activeDownloads.get(key);
 export const registerDownload = (key, entry) => {
     activeDownloads.set(key, entry);
-    registerCleanupHandlers();
 };
 export const unregisterDownload = (key) => {
     activeDownloads.delete(key);
@@ -38,36 +36,19 @@ export const cancelAllDownloads = () => {
     console.log(`🧹 Cancelling ${activeDownloads.size} active downloads`);
     Array.from(activeDownloads.keys()).forEach((key) => createCancelFunction(key)());
 };
-// Register cleanup handlers for graceful shutdown
-let cleanupRegistered = false;
 let isCleaningUp = false;
-const registerCleanupHandlers = () => {
-    if (cleanupRegistered)
+export const cleanupDownloads = async () => {
+    if (isCleaningUp)
         return;
-    cleanupRegistered = true;
-    const cleanup = async () => {
-        if (isCleaningUp)
-            return;
-        isCleaningUp = true;
-        try {
-            const downloadPromises = Array.from(activeDownloads.values()).map((entry) => entry.promise.catch(() => { }));
-            cancelAllDownloads();
-            if (downloadPromises.length > 0) {
-                await Promise.allSettled(downloadPromises);
-            }
+    isCleaningUp = true;
+    try {
+        const downloadPromises = Array.from(activeDownloads.values()).map((entry) => entry.promise.catch(() => { }));
+        cancelAllDownloads();
+        if (downloadPromises.length > 0) {
+            await Promise.allSettled(downloadPromises);
         }
-        catch (error) {
-            console.error("❌ Error during download cleanup:", error);
-        }
-    };
-    let handlingExit = false;
-    const exitHandler = async () => {
-        if (handlingExit)
-            return;
-        handlingExit = true;
-        await cleanup();
-        process.exit(0);
-    };
-    process.once("SIGTERM", () => void exitHandler());
-    process.once("SIGINT", () => void exitHandler());
+    }
+    catch (error) {
+        console.error("❌ Error during download cleanup:", error);
+    }
 };

package/dist/server/rpc/handlers/load-model/http.js

@@ -4,6 +4,7 @@ import fetch from "bare-fetch";
 import { AbortController } from "bare-abort-controller";
 import { getModelsCacheDir, generateShortHash } from "../../../utils/index.js";
 import { getActiveDownload, registerDownload, unregisterDownload, createHttpDownloadKey, shouldClearCache, clearClearCacheFlag, } from "./download-manager.js";
+import { DownloadCancelledError, HTTPError, NoResponseBodyError, ResponseBodyNotReadableError, } from "../../../../utils/errors-server.js";
 function extractFilenameFromUrl(url) {
     // Parse URL to get the filename from the path
     const urlParts = url.split("/");
@@ -27,11 +28,10 @@ async function validateCachedFile(modelPath, url, signal) {
             expectedSize = parseInt(response.headers.get("content-length") || "0");
         }
         catch (error) {
-            console.log(`⚠️ Could not get expected file size from HEAD request: ${String(error)}`);
-            console.log(`✅ Using cached HTTP model: ${modelPath}`);
-            return modelPath;
+            console.log(`⚠️ Could not get expected file size from HEAD request, will re-download: ${String(error)}`);
+            return null;
         }
-        if (expectedSize > 0 && localSize !== expectedSize) {
+        if (localSize !== expectedSize) {
             console.log(`📥 Cached file size mismatch. Expected: ${expectedSize}, Found: ${localSize}. Re-downloading...`);
             return null;
         }
@@ -45,7 +45,7 @@ async function validateCachedFile(modelPath, url, signal) {
 }
 async function performHttpDownload(url, modelPath, downloadKey, progressCallback, signal) {
     if (signal?.aborted) {
-        throw new Error("Download cancelled");
+        throw new DownloadCancelledError();
     }
     console.log(`📥 Downloading model from HTTP: ${url}`);
     // Check if file exists for resuming
@@ -78,6 +78,16 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
         // Check if it's a 416 (Range Not Satisfiable) - file already complete
         if (response.status === 416 && startOffset > 0) {
             console.log(`✅ File already completely downloaded`);
+            // Send 100% progress for already complete file
+            if (progressCallback) {
+                progressCallback({
+                    type: "modelProgress",
+                    downloaded: startOffset,
+                    total: startOffset,
+                    percentage: 100,
+                    downloadKey,
+                });
+            }
             return;
         }
         // Check if server doesn't support range requests
@@ -94,14 +104,14 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                 ...(signal && { signal }),
             });
             if (!freshResponse.ok) {
-                throw new Error(`HTTP error: ${freshResponse.status} ${freshResponse.statusText}`);
+                throw new HTTPError(freshResponse.status, freshResponse.statusText);
             }
             // Use the fresh response
             Object.assign(response, freshResponse);
         }
         else if (response.status !== 206) {
             // 206 is Partial Content (successful resume)
-            throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
+            throw new HTTPError(response.status, response.statusText);
         }
     }
     // Get total size from headers
@@ -128,7 +138,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
     // Get the response body
     const body = response.body;
     if (!body) {
-        throw new Error("No response body received");
+        throw new NoResponseBodyError();
     }
     try {
         // Check if body has pipe method (it's a Node/Bare stream)
@@ -180,7 +190,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                 // Check if abort signal is triggered
                 if (signal && signal.aborted) {
                     writeStream.destroy();
-                    throw new Error("Download cancelled");
+                    throw new DownloadCancelledError();
                 }
                 const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
                 downloadedBytes += buffer.length;
@@ -259,7 +269,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                 });
             }
             else {
-                throw new Error("Response body is not readable");
+                throw new ResponseBodyNotReadableError();
             }
         }
     }
@@ -288,10 +298,41 @@ export async function downloadModelFromHttp(url, progressCallback) {
             // Check if already cached
             const cachedPath = await validateCachedFile(modelPath, url, abortController.signal);
             if (cachedPath) {
+                if (progressCallback) {
+                    try {
+                        const stats = await fsPromises.stat(cachedPath);
+                        progressCallback({
+                            type: "modelProgress",
+                            downloaded: stats.size,
+                            total: stats.size,
+                            percentage: 100,
+                            downloadKey,
+                        });
+                    }
+                    catch {
+                        // Ignore stat errors, file exists but might not be readable
+                    }
+                }
                 return cachedPath;
             }
             // Download the file
             await performHttpDownload(url, modelPath, downloadKey, progressCallback, abortController.signal);
+            // Send final 100% progress update
+            if (progressCallback) {
+                try {
+                    const stats = await fsPromises.stat(modelPath);
+                    progressCallback({
+                        type: "modelProgress",
+                        downloaded: stats.size,
+                        total: stats.size,
+                        percentage: 100,
+                        downloadKey,
+                    });
+                }
+                catch {
+                    // Ignore stat errors
+                }
+            }
             return modelPath;
         }
         catch (error) {