@qvac/sdk 0.4.1 → 0.6.0

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

@@ -1,10 +1,17 @@
 import fs, { promises as fsPromises } from "bare-fs";
+import path from "bare-path";
 import { Readable } from "bare-stream";
 import fetch from "bare-fetch";
 import { AbortController } from "bare-abort-controller";
-import { getModelsCacheDir, generateShortHash } from "../../../utils/index.js";
+import { withTimeout } from "../../../../utils/withTimeout.js";
+import { getModelsCacheDir, getShardedModelCacheDir, generateShortHash, detectShardedModel, parsePatternBasedShardUrl, extractTensorsFromShards, calculatePercentage, isArchiveUrl, extractAndValidateShardedArchive, validateShardedModelCache, checkAllShardsExist, generateShardFilenames, hasValidGGUFHeader, } from "../../../utils/index.js";
+import { getSDKConfig } from "../../../bare/registry/config-registry.js";
 import { getActiveDownload, registerDownload, unregisterDownload, createHttpDownloadKey, shouldClearCache, clearClearCacheFlag, } from "./download-manager.js";
-import { DownloadCancelledError, HTTPError, NoResponseBodyError, ResponseBodyNotReadableError, } from "../../../../utils/errors-server.js";
+import { DownloadCancelledError, HTTPError, NoResponseBodyError, PartialDownloadOfflineError, ResponseBodyNotReadableError, } from "../../../../utils/errors-server.js";
+import { getServerLogger } from "../../../../logging/index.js";
+const logger = getServerLogger();
+const DEFAULT_CONCURRENCY = 3;
+const DEFAULT_HTTP_CONNECTION_TIMEOUT_MS = 10_000;
 function extractFilenameFromUrl(url) {
     // Parse URL to get the filename from the path
     const urlParts = url.split("/");
@@ -18,28 +25,44 @@ async function validateCachedFile(modelPath, url, signal) {
         await fsPromises.access(modelPath);
         const localStats = await fsPromises.stat(modelPath);
         const localSize = localStats.size;
-        // Get expected size from HEAD request
+        const config = getSDKConfig();
+        const connectionTimeout = config.httpConnectionTimeoutMs ?? DEFAULT_HTTP_CONNECTION_TIMEOUT_MS;
         let expectedSize = 0;
         try {
-            const response = await fetch(url, {
+            const response = await withTimeout(fetch(url, {
                 method: "HEAD",
                 ...(signal && { signal }),
-            });
+            }), connectionTimeout);
             expectedSize = parseInt(response.headers.get("content-length") || "0");
         }
-        catch (error) {
-            console.log(`⚠️ Could not get expected file size from HEAD request, will re-download: ${String(error)}`);
+        catch (headError) {
+            logger.warn(`⚠️ HEAD request failed: ${headError instanceof Error ? headError.message : String(headError)}`);
+            logger.info(`📴 Falling back to GGUF header validation...`);
+            const hasValidHeader = await hasValidGGUFHeader(modelPath);
+            if (hasValidHeader) {
+                logger.info(`✅ Offline - GGUF header valid, using cached file: ${modelPath}`);
+                return modelPath;
+            }
+            if (localSize > 0) {
+                logger.error(`❌ Offline with partial download (${localSize} bytes). Cannot resume without network.`);
+                throw new PartialDownloadOfflineError(url, localSize);
+            }
+            logger.warn(`⚠️ Offline and GGUF validation failed - file may be incomplete`);
             return null;
         }
         if (localSize !== expectedSize) {
-            console.log(`📥 Cached file size mismatch. Expected: ${expectedSize}, Found: ${localSize}. Re-downloading...`);
+            logger.info(`📥 Cached file size mismatch. Expected: ${expectedSize}, Found: ${localSize}. Re-downloading...`);
             return null;
         }
-        console.log(`✅ Using cached HTTP model: ${modelPath}`);
+        logger.info(`✅ Using cached HTTP model: ${modelPath}`);
         return modelPath;
     }
-    catch {
-        // File doesn't exist
+    catch (error) {
+        // Re-throw PartialDownloadOfflineError
+        if (error instanceof PartialDownloadOfflineError) {
+            throw error;
+        }
+        // File doesn't exist or other access error
         return null;
     }
 }
@@ -47,7 +70,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
     if (signal?.aborted) {
         throw new DownloadCancelledError();
     }
-    console.log(`📥 Downloading model from HTTP: ${url}`);
+    logger.info(`📥 Downloading model from HTTP: ${url}`);
     // Check if file exists for resuming
     let startOffset = 0;
     let downloadedBytes = 0;
@@ -55,10 +78,10 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
         const existingStats = await fsPromises.stat(modelPath);
         startOffset = existingStats.size;
         downloadedBytes = startOffset;
-        console.log(`📥 Resuming download from byte ${startOffset}`);
+        logger.info(`📥 Resuming download from byte ${startOffset}`);
     }
     catch {
-        console.log(`📥 Starting fresh download`);
+        logger.info(`📥 Starting fresh download`);
     }
     // Prepare headers for resume if needed
     const headers = {
@@ -67,17 +90,30 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
     if (startOffset > 0) {
         headers["Range"] = `bytes=${startOffset}-`;
     }
-    // Make the fetch request
-    const response = await fetch(url, {
-        method: "GET",
-        headers,
-        ...(signal && { signal }),
-        // bare-fetch automatically follows redirects
-    });
+    const config = getSDKConfig();
+    const connectionTimeout = config.httpConnectionTimeoutMs ?? DEFAULT_HTTP_CONNECTION_TIMEOUT_MS;
+    let response;
+    try {
+        response = await withTimeout(fetch(url, {
+            method: "GET",
+            headers,
+            ...(signal && { signal }),
+        }), connectionTimeout);
+    }
+    catch (error) {
+        // Check if it was parent abort
+        if (signal?.aborted) {
+            throw new DownloadCancelledError();
+        }
+        // Connection timeout or network error
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        logger.error(`❌ Connection failed: ${errorMsg}. URL: ${url}`);
+        throw new HTTPError(0, `Connection failed: ${errorMsg}`, error);
+    }
     if (!response.ok) {
         // Check if it's a 416 (Range Not Satisfiable) - file already complete
         if (response.status === 416 && startOffset > 0) {
-            console.log(`✅ File already completely downloaded`);
+            logger.info(`✅ File already completely downloaded`);
             // Send 100% progress for already complete file
             if (progressCallback) {
                 progressCallback({
@@ -92,22 +128,20 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
         }
         // Check if server doesn't support range requests
         if (response.status === 200 && startOffset > 0) {
-            console.log(`⚠️ Server doesn't support resume, starting fresh download`);
+            logger.warn(`⚠️ Server doesn't support resume, starting fresh download`);
             startOffset = 0;
             downloadedBytes = 0;
             // Retry without Range header
-            const freshResponse = await fetch(url, {
+            response = await fetch(url, {
                 method: "GET",
                 headers: {
-                    "User-Agent": "qvac-sdk/1.0",
+                    "User-Agent": "qvac-sdk",
                 },
                 ...(signal && { signal }),
             });
-            if (!freshResponse.ok) {
-                throw new HTTPError(freshResponse.status, freshResponse.statusText);
+            if (!response.ok) {
+                throw new HTTPError(response.status, response.statusText);
             }
-            // Use the fresh response
-            Object.assign(response, freshResponse);
         }
         else if (response.status !== 206) {
             // 206 is Partial Content (successful resume)
@@ -131,7 +165,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
         // For fresh downloads
         totalBytes = contentLength ? parseInt(contentLength) : 0;
     }
-    console.log(`📏 Total size: ${totalBytes} bytes (${(totalBytes / 1024 / 1024).toFixed(2)} MB)`);
+    logger.info(`📏 Total size: ${totalBytes} bytes (${(totalBytes / 1024 / 1024).toFixed(2)} MB)`);
     // Create write stream (append if resuming)
     const writeStreamOptions = startOffset > 0 && response.status === 206 ? { flags: "a" } : {};
     const writeStream = fs.createWriteStream(modelPath, writeStreamOptions);
@@ -154,7 +188,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                         type: "modelProgress",
                         downloaded: downloadedBytes,
                         total: totalBytes,
-                        percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
+                        percentage: calculatePercentage(downloadedBytes, totalBytes),
                         downloadKey,
                     });
                 }
@@ -174,7 +208,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                     signal.addEventListener("abort", abortHandler);
                 }
                 writeStream.on("finish", () => {
-                    console.log(`✅ Model downloaded successfully to ${modelPath}`);
+                    logger.info(`✅ Model downloaded successfully to ${modelPath}`);
                     if (signal) {
                         signal.removeEventListener("abort", abortHandler);
                     }
@@ -199,7 +233,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                         type: "modelProgress",
                         downloaded: downloadedBytes,
                         total: totalBytes,
-                        percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
+                        percentage: calculatePercentage(downloadedBytes, totalBytes),
                         downloadKey,
                     });
                 }
@@ -216,7 +250,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
             // Close the write stream
             await new Promise((resolve, reject) => {
                 writeStream.end(() => {
-                    console.log(`✅ Model downloaded successfully to ${modelPath}`);
+                    logger.info(`✅ Model downloaded successfully to ${modelPath}`);
                     resolve();
                 });
                 writeStream.on("error", reject);
@@ -241,7 +275,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                                 type: "modelProgress",
                                 downloaded: downloadedBytes,
                                 total: totalBytes,
-                                percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
+                                percentage: calculatePercentage(downloadedBytes, totalBytes),
                                 downloadKey,
                             });
                         }
@@ -262,7 +296,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                 // Close the write stream
                 await new Promise((resolve, reject) => {
                     writeStream.end(() => {
-                        console.log(`✅ Model downloaded successfully to ${modelPath}`);
+                        logger.info(`✅ Model downloaded successfully to ${modelPath}`);
                         resolve();
                     });
                     writeStream.on("error", reject);
@@ -275,21 +309,27 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
     }
     catch (error) {
         writeStream.destroy();
-        console.error("Error during download:", error instanceof Error ? error.message : String(error));
+        logger.error("Error during download:", error instanceof Error ? error.message : String(error));
         throw error instanceof Error ? error : new Error(String(error));
     }
 }
 export async function downloadModelFromHttp(url, progressCallback) {
+    const filename = extractFilenameFromUrl(url);
+    if (isArchiveUrl(url)) {
+        return downloadShardedModelFromArchive(url, progressCallback);
+    }
+    const shardInfo = detectShardedModel(filename);
+    if (shardInfo.isSharded && shardInfo.totalShards) {
+        return downloadShardedModelFromHttp(url, progressCallback);
+    }
     const downloadKey = createHttpDownloadKey(url);
-    // Check if already downloading
     const existing = getActiveDownload(downloadKey);
     if (existing) {
-        console.log(`📥 Reusing existing download for: ${downloadKey}`);
+        logger.info(`📥 Reusing existing download for: ${downloadKey}`);
         return existing.promise;
     }
     const cacheDir = getModelsCacheDir();
     const sourceHash = generateShortHash(url);
-    const filename = extractFilenameFromUrl(url);
     const modelPath = `${cacheDir}/${sourceHash}_${filename}`;
     // Create managed download with AbortController
     const abortController = new AbortController();
@@ -309,8 +349,11 @@ export async function downloadModelFromHttp(url, progressCallback) {
                             downloadKey,
                         });
                     }
-                    catch {
-                        // Ignore stat errors, file exists but might not be readable
+                    catch (error) {
+                        logger.debug("Failed to get file stats for progress callback", {
+                            path: cachedPath,
+                            error,
+                        });
                     }
                 }
                 return cachedPath;
@@ -329,28 +372,34 @@ export async function downloadModelFromHttp(url, progressCallback) {
                         downloadKey,
                     });
                 }
-                catch {
-                    // Ignore stat errors
+                catch (error) {
+                    logger.debug("Failed to get file stats for final progress update", {
+                        path: modelPath,
+                        error,
+                    });
                 }
             }
             return modelPath;
         }
         catch (error) {
-            console.error("❌ Error downloading model:", error instanceof Error ? error.message : String(error));
+            logger.error("❌ Error downloading model:", error instanceof Error ? error.message : String(error));
             // Check if we should delete the partial file (clearCache was requested)
             if (error instanceof Error && error.message === "Download cancelled") {
                 if (shouldClearCache(downloadKey)) {
-                    console.log("🗑️ Clearing cache - deleting partial file");
+                    logger.info("🗑️ Clearing cache - deleting partial file");
                     try {
                         await fsPromises.unlink(modelPath);
-                        console.log(`✅ Deleted partial file: ${modelPath}`);
+                        logger.info(`✅ Deleted partial file: ${modelPath}`);
                     }
-                    catch {
-                        // Ignore cleanup errors
+                    catch (error) {
+                        logger.debug("Failed to delete partial file during cleanup", {
+                            path: modelPath,
+                            error,
+                        });
                     }
                 }
                 else {
-                    console.log("📥 Download paused - partial file preserved for resume");
+                    logger.info("📥 Download paused - partial file preserved for resume");
                 }
                 clearClearCacheFlag(downloadKey);
             }
@@ -376,3 +425,265 @@ export async function downloadModelFromHttp(url, progressCallback) {
     registerDownload(downloadKey, downloadEntry);
     return downloadPromise;
 }
+async function downloadShardedModelFromHttp(shardUrl, progressCallback) {
+    const config = getSDKConfig();
+    const concurrency = config.httpDownloadConcurrency ?? DEFAULT_CONCURRENCY;
+    const { shardUrls: shardInfos, cacheKey } = parsePatternBasedShardUrl(shardUrl);
+    const downloadKey = `http-sharded:${cacheKey}`;
+    logger.info(`📥 HTTP sharded download: ${shardInfos.length} shards detected from ${shardUrl}`);
+    const existing = getActiveDownload(downloadKey);
+    if (existing) {
+        logger.info(`📥 Reusing existing sharded download for: ${downloadKey}`);
+        return existing.promise;
+    }
+    const abortController = new AbortController();
+    const shardDir = getShardedModelCacheDir(cacheKey);
+    const downloadPromise = (async () => {
+        try {
+            const shardStates = await Promise.all(shardInfos.map(async (shard, index) => {
+                const shardPath = path.join(shardDir, shard.filename);
+                let expectedSize = 0;
+                try {
+                    const response = await fetch(shard.url, {
+                        method: "HEAD",
+                        signal: abortController.signal,
+                    });
+                    expectedSize = parseInt(response.headers.get("content-length") || "0");
+                }
+                catch (error) {
+                    logger.warn("Failed to get shard size via HEAD request", {
+                        url: shard.url,
+                        error,
+                    });
+                    // expectedSize remains 0, progress percentage will be 0
+                }
+                return {
+                    index,
+                    shard,
+                    shardPath,
+                    expectedSize,
+                    downloadedBytes: 0,
+                    isComplete: false,
+                };
+            }));
+            const overallTotal = shardStates.reduce((sum, s) => sum + s.expectedSize, 0);
+            logger.info(`📏 Total size: ${overallTotal} bytes (${(overallTotal / 1024 / 1024).toFixed(2)} MB)`);
+            const cacheChecks = await Promise.all(shardStates.map(async (state) => {
+                const cached = await validateCachedFile(state.shardPath, state.shard.url, abortController.signal);
+                return { state, isCached: cached !== null };
+            }));
+            const shardsToDownload = cacheChecks
+                .filter((c) => !c.isCached)
+                .map((c) => c.state);
+            for (const check of cacheChecks) {
+                if (check.isCached) {
+                    check.state.isComplete = true;
+                    check.state.downloadedBytes = check.state.expectedSize;
+                }
+            }
+            logger.info(`📥 ${shardsToDownload.length} of ${shardInfos.length} shards need downloading`);
+            await downloadShardsWithConcurrency(shardsToDownload, shardStates, concurrency, abortController.signal, downloadKey, overallTotal, progressCallback);
+            logger.info(`✅ All ${shardInfos.length} shards downloaded successfully`);
+            await extractTensorsFromShards(shardDir, shardInfos[0].filename);
+            return path.join(shardDir, shardInfos[0].filename);
+        }
+        catch (error) {
+            logger.error("❌ Error during sharded download:", error instanceof Error ? error.message : String(error));
+            if (error instanceof Error && error.message === "Download cancelled") {
+                if (shouldClearCache(downloadKey)) {
+                    logger.info("🗑️ Clearing cache - deleting partial shard files");
+                    try {
+                        await fsPromises.rm(shardDir, { recursive: true, force: true });
+                        logger.info(`✅ Deleted shard directory: ${shardDir}`);
+                    }
+                    catch (cleanupError) {
+                        logger.debug("Failed to delete shard directory during cleanup", {
+                            path: shardDir,
+                            error: cleanupError,
+                        });
+                    }
+                }
+            }
+            throw error;
+        }
+        finally {
+            unregisterDownload(downloadKey);
+            clearClearCacheFlag(downloadKey);
+        }
+    })();
+    registerDownload(downloadKey, {
+        key: downloadKey,
+        promise: downloadPromise,
+        abortController,
+        startTime: Date.now(),
+        type: "http",
+        url: shardUrl,
+        modelPath: shardDir,
+    });
+    return downloadPromise;
+}
+async function downloadShardedModelFromArchive(archiveUrl, progressCallback) {
+    const filename = extractFilenameFromUrl(archiveUrl);
+    const sourceHash = generateShortHash(archiveUrl);
+    const downloadKey = `http-archive:${sourceHash}`;
+    logger.info(`📦 HTTP archive download: ${filename}`);
+    const existing = getActiveDownload(downloadKey);
+    if (existing) {
+        logger.info(`📥 Reusing existing archive download for: ${downloadKey}`);
+        return existing.promise;
+    }
+    const abortController = new AbortController();
+    const extractDir = getShardedModelCacheDir(sourceHash);
+    const archivePath = path.join(extractDir, `${sourceHash}_${filename}`);
+    const downloadPromise = (async () => {
+        try {
+            await fsPromises.mkdir(extractDir, { recursive: true });
+            const files = await fsPromises.readdir(extractDir);
+            const shardedFile = files.find((f) => detectShardedModel(String(f)).isSharded);
+            if (!shardedFile) {
+                return downloadAndExtractArchive();
+            }
+            const shardFilename = String(shardedFile);
+            const allShardsExist = await checkAllShardsExist(extractDir, shardFilename);
+            if (!allShardsExist) {
+                logger.warn(`⚠️ Incomplete shards found, re-downloading archive`);
+                return downloadAndExtractArchive();
+            }
+            const shardFilenames = generateShardFilenames(shardFilename);
+            const firstShard = path.join(extractDir, shardFilenames[0]);
+            const isComplete = await validateShardedModelCache(extractDir, shardFilename);
+            if (isComplete) {
+                logger.info(`✅ Archive already extracted: ${extractDir}`);
+                if (progressCallback) {
+                    progressCallback({
+                        type: "modelProgress",
+                        downloaded: 1,
+                        total: 1,
+                        percentage: 100,
+                        downloadKey,
+                    });
+                }
+                return firstShard;
+            }
+            logger.info(`📝 All shards present but tensors.txt missing, extracting tensors...`);
+            try {
+                await extractTensorsFromShards(extractDir, shardFilename);
+                logger.info(`✅ Tensors extracted successfully`);
+                if (progressCallback) {
+                    progressCallback({
+                        type: "modelProgress",
+                        downloaded: 1,
+                        total: 1,
+                        percentage: 100,
+                        downloadKey,
+                    });
+                }
+                return firstShard;
+            }
+            catch (error) {
+                logger.warn(`Failed to extract tensors, will re-download archive`, {
+                    error,
+                });
+                return downloadAndExtractArchive();
+            }
+        }
+        catch (error) {
+            logger.error("❌ Error downloading/extracting archive:", error);
+            throw error;
+        }
+        finally {
+            unregisterDownload(downloadKey);
+        }
+        async function downloadAndExtractArchive() {
+            await performHttpDownload(archiveUrl, archivePath, downloadKey, progressCallback, abortController.signal);
+            logger.info(`✅ Archive downloaded, extracting to: ${extractDir}`);
+            const firstShardPath = await extractAndValidateShardedArchive(archivePath, extractDir, abortController.signal);
+            try {
+                await fsPromises.unlink(archivePath);
+                logger.info(`🗑️ Cleaned up archive file: ${archivePath}`);
+            }
+            catch (cleanupError) {
+                logger.debug("Failed to delete archive file during cleanup", {
+                    path: archivePath,
+                    error: cleanupError,
+                });
+            }
+            return firstShardPath;
+        }
+    })();
+    registerDownload(downloadKey, {
+        key: downloadKey,
+        promise: downloadPromise,
+        abortController,
+        startTime: Date.now(),
+        type: "http",
+        url: archiveUrl,
+        modelPath: archivePath,
+    });
+    return downloadPromise;
+}
+async function downloadShardsWithConcurrency(shardsToDownload, allShards, concurrency, signal, downloadKey, overallTotal, progressCallback) {
+    const queue = [...shardsToDownload];
+    const inFlight = new Set();
+    while (queue.length > 0 || inFlight.size > 0) {
+        if (signal.aborted) {
+            throw new DownloadCancelledError();
+        }
+        while (queue.length > 0 && inFlight.size < concurrency) {
+            const state = queue.shift();
+            const downloadPromise = (async () => {
+                logger.info(`📥 Downloading shard ${state.index + 1}: ${state.shard.filename}`);
+                await performHttpDownload(state.shard.url, state.shardPath, downloadKey, (progress) => {
+                    state.downloadedBytes = progress.downloaded;
+                    if (progressCallback) {
+                        const overallDownloaded = allShards.reduce((sum, s) => sum + s.downloadedBytes, 0);
+                        progressCallback({
+                            type: "modelProgress",
+                            downloaded: state.downloadedBytes,
+                            total: state.expectedSize,
+                            percentage: calculatePercentage(state.downloadedBytes, state.expectedSize),
+                            downloadKey,
+                            shardInfo: {
+                                currentShard: state.index + 1,
+                                totalShards: allShards.length,
+                                shardName: state.shard.filename,
+                                overallDownloaded,
+                                overallTotal,
+                                overallPercentage: calculatePercentage(overallDownloaded, overallTotal),
+                            },
+                        });
+                    }
+                }, signal);
+                logger.info(`✅ Shard ${state.index + 1} complete: ${state.shard.filename}`);
+            })().finally(() => {
+                inFlight.delete(downloadPromise);
+            });
+            inFlight.add(downloadPromise);
+        }
+        if (inFlight.size > 0) {
+            await Promise.race(inFlight);
+        }
+    }
+    // Mark all downloaded shards as complete
+    for (const state of shardsToDownload) {
+        state.isComplete = true;
+        state.downloadedBytes = state.expectedSize;
+    }
+    if (progressCallback) {
+        progressCallback({
+            type: "modelProgress",
+            downloaded: overallTotal,
+            total: overallTotal,
+            percentage: 100,
+            downloadKey,
+            shardInfo: {
+                currentShard: allShards.length,
+                totalShards: allShards.length,
+                shardName: allShards[allShards.length - 1].shard.filename,
+                overallDownloaded: overallTotal,
+                overallTotal,
+                overallPercentage: 100,
+            },
+        });
+    }
+}