@infersec/conduit 1.6.0 → 1.6.2

package/dist/cli.js

@@ -6,7 +6,7 @@ const __dirname = __pathDirname(__filename);
 
 import { parseArgs } from 'node:util';
 import 'node:crypto';
-import { a as asError, s as startInferenceAgent } from './start-XRPU7RSB.js';
+import { a as asError, s as startInferenceAgent } from './start-CQayYNYZ.js';
 import 'argon2';
 import 'node:child_process';
 import 'node:stream';
@@ -45,8 +45,8 @@ import 'querystring';
 import 'url';
 import 'http';
 import 'crypto';
-import 'node:stream/promises';
 import 'node:fs';
+import 'node:stream/promises';
 import 'fs/promises';
 import 'stream/promises';
 import 'node:string_decoder';

package/dist/index.js

@@ -5,7 +5,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 
 import 'node:crypto';
-import { s as startInferenceAgent, a as asError } from './start-XRPU7RSB.js';
+import { s as startInferenceAgent, a as asError } from './start-CQayYNYZ.js';
 import 'argon2';
 import 'node:child_process';
 import 'node:stream';
@@ -45,8 +45,8 @@ import 'querystring';
 import 'url';
 import 'http';
 import 'crypto';
-import 'node:stream/promises';
 import 'node:fs';
+import 'node:stream/promises';
 import 'fs/promises';
 import 'stream/promises';
 import 'node:string_decoder';

package/dist/{start-XRPU7RSB.js → start-CQayYNYZ.js}

@@ -30,8 +30,8 @@ import require$$1$3 from 'node:worker_threads';
 import require$$1$5, { fileURLToPath } from 'node:url';
 import require$$1$6 from 'node:async_hooks';
 import require$$1$7 from 'node:console';
-import require$$0$b, { mkdir, readFile, writeFile, realpath, readlink, readdir, lstat } from 'node:fs/promises';
-import path$1, { dirname, join, win32, posix } from 'node:path';
+import require$$0$b, { mkdir, readFile, writeFile, stat, unlink, rename, realpath, readlink, readdir, lstat } from 'node:fs/promises';
+import path$1, { join, dirname, win32, posix } from 'node:path';
 import require$$1$8 from 'node:dns';
 import require$$2$4 from 'node:sqlite';
 import require$$0$c from 'path';
@@ -44,9 +44,9 @@ import require$$8$1 from 'querystring';
 import require$$0$f from 'url';
 import require$$0$g from 'http';
 import require$$0$h from 'crypto';
-import { pipeline, finished } from 'node:stream/promises';
 import * as actualFS from 'node:fs';
 import { existsSync, createWriteStream, statSync, readFileSync, appendFileSync, writeFileSync, createReadStream } from 'node:fs';
+import { pipeline, finished } from 'node:stream/promises';
 import 'fs/promises';
 import 'stream/promises';
 import { StringDecoder } from 'node:string_decoder';
@@ -96473,11 +96473,13 @@ const ModelDownloadProgressSchema = object({
     completedFiles: array(string$1().min(1))
 });
 
-const DOWNLOAD_PROGRESS_TIMEOUT = 30000;
-const DOWNLOAD_RETRY_ATTEMPTS = 3;
+const DOWNLOAD_PROGRESS_TIMEOUT = 60000;
+const DOWNLOAD_RETRY_ATTEMPTS_FULL = 3;
+const DOWNLOAD_RETRY_ATTEMPTS_RANGE = 10;
 async function downloadModelViaHuggingFace({ format, huggingFaceToken, modelSlug: rawModelSlug, progressFilePath, targetDirectory }) {
     // Sanitise model ID
-    const [modelSlug, variant = null] = rawModelSlug.split(":");
+    const [modelSlugWithRevision, variant = null] = rawModelSlug.split(":");
+    const { modelSlug, revision } = parseModelRevision(modelSlugWithRevision);
     // Prepare directory
     await mkdir(targetDirectory, { recursive: true });
     let progress;
@@ -96512,65 +96514,411 @@ async function downloadModelViaHuggingFace({ format, huggingFaceToken, modelSlug
             console.log("Skipping due to already having completed file:", file.path, file.size);
             continue;
         }
-        let downloaded = false;
-        let lastError = null;
-        for (let attempt = 1; attempt <= DOWNLOAD_RETRY_ATTEMPTS; attempt++) {
+        const rangeInfo = await getRangeInfo({
+            accessToken,
+            filePath: file.path,
+            fileSize: file.size,
+            modelSlug,
+            revision
+        });
+        const { partialPath } = getDownloadPaths({ filePath: file.path, targetDirectory });
+        const shouldAttemptRange = rangeInfo.supportsRanges || existsSync(partialPath);
+        if (shouldAttemptRange) {
             try {
-                console.log("Downloading:", file.path, file.size, `(attempt ${attempt})`);
-                await mkdir(dirname(join(targetDirectory, file.path)), { recursive: true });
-                const response = await downloadFile({
+                await downloadFileWithRange({
                     accessToken,
-                    repo: modelSlug,
-                    path: file.path
-                    // path: join(targetDirectory, file.path)
+                    filePath: file.path,
+                    fileSize: rangeInfo.totalSize ?? file.size,
+                    modelSlug,
+                    revision,
+                    targetDirectory
                 });
-                if (!response) {
-                    throw new Error(`Requested file did not return a valid response: ${file.path}`);
-                }
-                const input = Readable.fromWeb(response.stream());
-                const meter = watchStreamProgress(25 * 1024 * 1024); // 25 MiB intervals
-                const output = createWriteStream(join(targetDirectory, file.path));
-                let progressTimeout = null;
-                let lastPercentage = "0.0";
-                let lastProgressBytes = 0;
-                meter.progress.on("progress", (totalBytes) => {
-                    lastProgressBytes = totalBytes;
-                    const percentComplete = ((totalBytes / file.size) * 100).toFixed(1);
-                    if (lastPercentage !== percentComplete) {
-                        console.log(` => ${percentComplete}% (${totalBytes} / ${file.size})`);
-                    }
-                    lastPercentage = percentComplete;
-                    clearTimeout(progressTimeout);
-                    progressTimeout = setTimeout(() => {
-                        input.destroy(new Error(`Timed out with no progress for ${DOWNLOAD_PROGRESS_TIMEOUT}ms while downloading ${file.path}. Last progress: ${lastPercentage}% (${lastProgressBytes} / ${file.size})`));
-                    }, DOWNLOAD_PROGRESS_TIMEOUT);
-                });
-                try {
-                    await pipeline(input, meter, output);
-                }
-                finally {
-                    clearTimeout(progressTimeout);
-                }
-                downloaded = true;
-                break;
             }
             catch (error) {
-                lastError = asError(error);
-                if (attempt < DOWNLOAD_RETRY_ATTEMPTS) {
-                    console.warn(`Retrying download (${attempt}/${DOWNLOAD_RETRY_ATTEMPTS}) for ${file.path} due to error: ${lastError.message}`);
-                    continue;
+                if (error instanceof RangeNotSupportedError) {
+                    console.warn(`Range download unavailable for ${file.path}: ${error.message}`);
+                    await downloadFileFull({
+                        accessToken,
+                        filePath: file.path,
+                        fileSize: file.size,
+                        modelSlug,
+                        targetDirectory
+                    });
+                }
+                else {
+                    throw error;
                 }
             }
         }
-        if (!downloaded) {
-            const errorMessage = `Failed downloading ${file.path} (${file.size} bytes) after ${DOWNLOAD_RETRY_ATTEMPTS} attempts. Last error: ${lastError?.message ?? "Unknown error"}`;
-            throw new Error(errorMessage);
+        else {
+            if (rangeInfo.reason) {
+                console.warn(`Range download unavailable for ${file.path}: ${rangeInfo.reason}`);
+            }
+            await downloadFileFull({
+                accessToken,
+                filePath: file.path,
+                fileSize: file.size,
+                modelSlug,
+                targetDirectory
+            });
         }
         // Update progress
         progress.completedFiles.push(file.path);
         await writeFile(progressFilePath, JSON.stringify(progress, undefined, 4));
     }
 }
+function encodePathSegments(path) {
+    return path
+        .split("/")
+        .map(segment => encodeURIComponent(segment))
+        .join("/");
+}
+function encodeRepoSlug(modelSlug) {
+    return modelSlug
+        .split("/")
+        .map(segment => encodeURIComponent(segment))
+        .join("/");
+}
+function parseModelRevision(modelSlugWithRevision) {
+    const revisionIndex = modelSlugWithRevision.indexOf("@");
+    if (revisionIndex === -1) {
+        return { modelSlug: modelSlugWithRevision, revision: "main" };
+    }
+    return {
+        modelSlug: modelSlugWithRevision.slice(0, revisionIndex),
+        revision: modelSlugWithRevision.slice(revisionIndex + 1)
+    };
+}
+function getDownloadPaths({ filePath, targetDirectory }) {
+    const finalPath = join(targetDirectory, filePath);
+    return {
+        finalPath,
+        partialPath: `${finalPath}.partial`
+    };
+}
+function getResolveURL({ filePath, modelSlug, revision }) {
+    const encodedRepo = encodeRepoSlug(modelSlug);
+    const encodedRevision = encodeURIComponent(revision);
+    const encodedPath = encodePathSegments(filePath);
+    return `https://huggingface.co/${encodedRepo}/resolve/${encodedRevision}/${encodedPath}`;
+}
+function getResolveDownloadURL({ filePath, modelSlug, revision }) {
+    const baseUrl = getResolveURL({ filePath, modelSlug, revision });
+    const resolvedUrl = new URL(baseUrl);
+    resolvedUrl.searchParams.set("download", "1");
+    return resolvedUrl.toString();
+}
+class RangeNotSupportedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RangeNotSupportedError";
+    }
+}
+function getAuthHeaders(accessToken) {
+    if (!accessToken) {
+        return {};
+    }
+    return {
+        Authorization: `Bearer ${accessToken}`
+    };
+}
+function shouldSendAuthHeader(url) {
+    try {
+        const hostname = new URL(url).hostname.toLowerCase();
+        return hostname.endsWith("huggingface.co") || hostname.endsWith("hf.co");
+    }
+    catch {
+        return false;
+    }
+}
+function parseContentRangeTotal(contentRange) {
+    if (!contentRange) {
+        return null;
+    }
+    const totalMatch = /\/(\d+)$/.exec(contentRange);
+    if (!totalMatch) {
+        return null;
+    }
+    const totalSize = Number(totalMatch[1]);
+    return Number.isFinite(totalSize) ? totalSize : null;
+}
+async function getDownloadURL({ accessToken, filePath, modelSlug, revision }) {
+    const url = getResolveDownloadURL({ filePath, modelSlug, revision });
+    try {
+        const response = await undiciExports.fetch(url, {
+            method: "GET",
+            redirect: "manual",
+            headers: getAuthHeaders(accessToken)
+        });
+        try {
+            if (response.status >= 300 && response.status < 400) {
+                const location = response.headers.get("location");
+                if (location) {
+                    return { reason: null, status: response.status, url: location };
+                }
+            }
+            if (response.ok) {
+                return { reason: null, status: response.status, url: response.url };
+            }
+            let responseBody = "<unavailable>";
+            try {
+                responseBody = await response.text();
+            }
+            catch {
+                responseBody = "<failed to read body>";
+            }
+            if (responseBody.length > 2000) {
+                responseBody = responseBody.slice(0, 2000);
+            }
+            console.warn(`Resolve request failed body for ${filePath}: ${responseBody}`);
+            return {
+                reason: `Resolve request failed with status ${response.status}`,
+                status: response.status,
+                url: null
+            };
+        }
+        finally {
+            if (response.body && response.bodyUsed === false && response.body.locked === false) {
+                await response.body.cancel();
+            }
+        }
+    }
+    catch (error) {
+        const parsed = asError(error);
+        return {
+            reason: `Resolve request failed: ${parsed.message}`,
+            status: null,
+            url: null
+        };
+    }
+}
+async function getRangeInfo({ accessToken, filePath, fileSize, modelSlug, revision }) {
+    const downloadUrlInfo = await getDownloadURL({
+        accessToken,
+        filePath,
+        modelSlug,
+        revision
+    });
+    if (!downloadUrlInfo.url) {
+        return {
+            reason: downloadUrlInfo.reason ?? "Resolve request failed",
+            supportsRanges: false,
+            totalSize: fileSize
+        };
+    }
+    try {
+        const response = await undiciExports.fetch(downloadUrlInfo.url, {
+            method: "GET",
+            headers: {
+                ...(shouldSendAuthHeader(downloadUrlInfo.url) ? getAuthHeaders(accessToken) : {}),
+                Range: "bytes=0-0"
+            }
+        });
+        try {
+            if (response.status === 206) {
+                const totalSize = parseContentRangeTotal(response.headers.get("content-range"));
+                return {
+                    reason: null,
+                    supportsRanges: true,
+                    totalSize: totalSize ?? fileSize
+                };
+            }
+            if (response.status === 200) {
+                return {
+                    reason: "Server returned 200 to range probe",
+                    supportsRanges: false,
+                    totalSize: fileSize
+                };
+            }
+            return {
+                reason: `Range probe failed with status ${response.status}`,
+                supportsRanges: false,
+                totalSize: fileSize
+            };
+        }
+        finally {
+            await response.body?.cancel();
+        }
+    }
+    catch (error) {
+        const parsed = asError(error);
+        return {
+            reason: `Range probe failed: ${parsed.message}`,
+            supportsRanges: false,
+            totalSize: fileSize
+        };
+    }
+}
+async function downloadFileFull({ accessToken, filePath, fileSize, modelSlug, targetDirectory }) {
+    const { finalPath, partialPath } = getDownloadPaths({ filePath, targetDirectory });
+    let lastError = null;
+    for (let attempt = 1; attempt <= DOWNLOAD_RETRY_ATTEMPTS_FULL; attempt++) {
+        try {
+            console.log("Downloading:", filePath, fileSize, `(attempt ${attempt})`);
+            await mkdir(dirname(finalPath), { recursive: true });
+            if (existsSync(partialPath)) {
+                await unlink(partialPath);
+            }
+            const response = await downloadFile({
+                accessToken,
+                repo: modelSlug,
+                path: filePath
+            });
+            if (!response) {
+                throw new Error(`Requested file did not return a valid response: ${filePath}`);
+            }
+            const input = Readable.fromWeb(response.stream());
+            const meter = watchStreamProgress(25 * 1024 * 1024); // 25 MiB intervals
+            const output = createWriteStream(partialPath, { flags: "w" });
+            let progressTimeout = null;
+            let lastPercentage = "0.0";
+            let lastProgressBytes = 0;
+            const resetProgressTimeout = () => {
+                clearTimeout(progressTimeout);
+                progressTimeout = setTimeout(() => {
+                    input.destroy(new Error(`Timed out with no progress for ${DOWNLOAD_PROGRESS_TIMEOUT}ms while downloading ${filePath}. Last progress: ${lastPercentage}% (${lastProgressBytes} / ${fileSize})`));
+                }, DOWNLOAD_PROGRESS_TIMEOUT);
+            };
+            input.on("data", resetProgressTimeout);
+            resetProgressTimeout();
+            meter.progress.on("progress", (totalBytes) => {
+                lastProgressBytes = totalBytes;
+                const percentComplete = ((totalBytes / fileSize) * 100).toFixed(1);
+                if (lastPercentage !== percentComplete) {
+                    console.log(` => ${percentComplete}% (${totalBytes} / ${fileSize})`);
+                }
+                lastPercentage = percentComplete;
+            });
+            try {
+                await pipeline(input, meter, output);
+            }
+            finally {
+                clearTimeout(progressTimeout);
+            }
+            await rename(partialPath, finalPath);
+            return;
+        }
+        catch (error) {
+            lastError = asError(error);
+            if (attempt < DOWNLOAD_RETRY_ATTEMPTS_FULL) {
+                console.warn(`Retrying full download (${attempt}/${DOWNLOAD_RETRY_ATTEMPTS_FULL}) for ${filePath} due to error: ${lastError.message}`);
+                continue;
+            }
+        }
+    }
+    const errorMessage = `Failed downloading ${filePath} (${fileSize} bytes) after ${DOWNLOAD_RETRY_ATTEMPTS_FULL} attempts. Last error: ${lastError?.message ?? "Unknown error"}`;
+    throw new Error(errorMessage);
+}
+async function downloadFileWithRange({ accessToken, filePath, fileSize, modelSlug, revision, targetDirectory }) {
+    const { finalPath, partialPath } = getDownloadPaths({ filePath, targetDirectory });
+    let lastError = null;
+    for (let attempt = 1; attempt <= DOWNLOAD_RETRY_ATTEMPTS_RANGE; attempt++) {
+        let startOffset = 0;
+        if (existsSync(partialPath)) {
+            const currentStats = await stat(partialPath);
+            startOffset = currentStats.size;
+            if (startOffset > fileSize) {
+                await unlink(partialPath);
+                startOffset = 0;
+            }
+            if (startOffset === fileSize) {
+                await rename(partialPath, finalPath);
+                return;
+            }
+        }
+        try {
+            const resumeLabel = startOffset > 0 ? `resuming at ${startOffset}` : "starting";
+            console.log("Downloading:", filePath, fileSize, `(attempt ${attempt}, ${resumeLabel})`);
+            await mkdir(dirname(finalPath), { recursive: true });
+            const downloadUrlInfo = await getDownloadURL({
+                accessToken,
+                filePath,
+                modelSlug,
+                revision
+            });
+            if (!downloadUrlInfo.url) {
+                if (downloadUrlInfo.status === 400) {
+                    throw new RangeNotSupportedError(downloadUrlInfo.reason ?? "Resolve request failed");
+                }
+                throw new Error(downloadUrlInfo.reason ?? "Resolve request failed");
+            }
+            const response = await undiciExports.fetch(downloadUrlInfo.url, {
+                headers: {
+                    ...(shouldSendAuthHeader(downloadUrlInfo.url)
+                        ? getAuthHeaders(accessToken)
+                        : {}),
+                    Range: `bytes=${startOffset}-`
+                }
+            });
+            if (!response.ok) {
+                let responseBody = "<unavailable>";
+                try {
+                    responseBody = await response.text();
+                }
+                catch {
+                    responseBody = "<failed to read body>";
+                }
+                if (responseBody.length > 2000) {
+                    responseBody = responseBody.slice(0, 2000);
+                }
+                console.warn(`Range request failed response body for ${filePath}: ${responseBody}`);
+                throw new Error(`Range request failed with status ${response.status} for ${filePath}`);
+            }
+            if (startOffset > 0 && response.status !== 206) {
+                throw new RangeNotSupportedError(`Server did not honor range request (status ${response.status})`);
+            }
+            if (!response.body) {
+                throw new Error(`Range request returned no body for ${filePath}`);
+            }
+            const input = Readable.fromWeb(response.body);
+            const meter = watchStreamProgress(25 * 1024 * 1024); // 25 MiB intervals
+            const output = createWriteStream(partialPath, { flags: "a" });
+            let progressTimeout = null;
+            let lastPercentage = ((startOffset / fileSize) * 100).toFixed(1);
+            let lastProgressBytes = startOffset;
+            const resetProgressTimeout = () => {
+                clearTimeout(progressTimeout);
+                progressTimeout = setTimeout(() => {
+                    input.destroy(new Error(`Timed out with no progress for ${DOWNLOAD_PROGRESS_TIMEOUT}ms while downloading ${filePath}. Last progress: ${lastPercentage}% (${lastProgressBytes} / ${fileSize})`));
+                }, DOWNLOAD_PROGRESS_TIMEOUT);
+            };
+            input.on("data", resetProgressTimeout);
+            resetProgressTimeout();
+            meter.progress.on("progress", (totalBytes) => {
+                lastProgressBytes = startOffset + totalBytes;
+                const percentComplete = ((lastProgressBytes / fileSize) * 100).toFixed(1);
+                if (lastPercentage !== percentComplete) {
+                    console.log(` => ${percentComplete}% (${lastProgressBytes} / ${fileSize})`);
+                }
+                lastPercentage = percentComplete;
+            });
+            try {
+                await pipeline(input, meter, output);
+            }
+            finally {
+                clearTimeout(progressTimeout);
+            }
+            const updatedStats = await stat(partialPath);
+            if (updatedStats.size < fileSize) {
+                throw new Error(`Download incomplete for ${filePath}. Received ${updatedStats.size} / ${fileSize} bytes`);
+            }
+            await rename(partialPath, finalPath);
+            return;
+        }
+        catch (error) {
+            lastError = asError(error);
+            if (lastError instanceof RangeNotSupportedError) {
+                throw lastError;
+            }
+            if (attempt < DOWNLOAD_RETRY_ATTEMPTS_RANGE) {
+                console.warn(`Retrying range download (${attempt}/${DOWNLOAD_RETRY_ATTEMPTS_RANGE}) for ${filePath} due to error: ${lastError.message}`);
+                continue;
+            }
+        }
+    }
+    const errorMessage = `Failed downloading ${filePath} (${fileSize} bytes) after ${DOWNLOAD_RETRY_ATTEMPTS_RANGE} attempts. Last error: ${lastError?.message ?? "Unknown error"}`;
+    throw new Error(errorMessage);
+}
 
 const balanced = (a, b, str) => {
     const ma = a instanceof RegExp ? maybeMatch(a, str) : a;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@infersec/conduit",
   "description": "End user conduit agent for connecting local LLMs to the cloud.",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "bin": {
     "infersec-conduit": "./dist/cli.js"
   },