@infersec/conduit 1.60.1 → 1.61.0

package/dist/cli.js

@@ -10,7 +10,7 @@ import path$1, { join, dirname, win32, posix, resolve } from 'node:path';
 import * as require$$3$1 from 'node:fs';
 import require$$3__default, { existsSync, createWriteStream, statSync, readFileSync, appendFileSync, writeFileSync, createReadStream } from 'node:fs';
 import process$5, { platform, hrtime, execPath, execArgv } from 'node:process';
-import crypto, { createHash } from 'node:crypto';
+import crypto from 'node:crypto';
 import require$$0$8, { Readable, Transform, PassThrough, getDefaultHighWaterMark, Duplex, Writable } from 'node:stream';
 import 'argon2';
 import require$$1$7, { setDefaultResultOrder } from 'node:dns';
@@ -120764,8 +120764,36 @@ async function startLlamacpp({ enginePort, targetDirectory }) {
     return processManager;
 }
 
+const SAFE_CHARS = /[a-zA-Z0-9\-_.]/;
+const SEPARATOR = "__";
+function sanitizeSegment(value) {
+    return value
+        .split("")
+        .map(ch => {
+        if (ch === "/")
+            return SEPARATOR;
+        if (ch === "@")
+            return "_rev_";
+        if (ch === ":")
+            return SEPARATOR;
+        if (SAFE_CHARS.test(ch))
+            return ch;
+        return "";
+    })
+        .join("")
+        .replace(new RegExp(`${SEPARATOR}{2,}`, "g"), SEPARATOR);
+}
+function createModelStorageKey(model) {
+    const identifier = model.source.type === "huggingface" ? model.source.slug : model.source.irid;
+    return `${model.source.type}${SEPARATOR}${sanitizeSegment(identifier)}`;
+}
+
 // 2 hours
 const ENGINE_FETCH_TIMEOUT_MS$1 = 7200000;
+// 20 minutes
+const DOWNLOAD_LOCK_TIMEOUT_MS = 20 * 60 * 1000;
+// 5 seconds
+const DOWNLOAD_LOCK_POLL_INTERVAL_MS = 5000;
 const ENGINE_AGENT = new undiciExports.Agent({
     bodyTimeout: ENGINE_FETCH_TIMEOUT_MS$1,
     headersTimeout: ENGINE_FETCH_TIMEOUT_MS$1
@@ -120805,12 +120833,7 @@ class ModelManager extends EventEmitter {
         this.parallelism = typeof parallelism === "number" ? parallelism : null;
         // this.providerSlugentifier = source.identifier;
         this.logger = logger;
-        const uniqueHash = createHash("sha1")
-            .update(this.model.source.type === "huggingface"
-            ? this.model.source.slug
-            : this.model.source.irid)
-            .digest("hex");
-        this.uniqueName = `${this.model.id}-${uniqueHash}`;
+        this.uniqueName = createModelStorageKey(this.model);
         this.modelsDirectory = join(root, "models");
     }
     async fetchOpenAI(path, opts) {
@@ -120874,14 +120897,20 @@ class ModelManager extends EventEmitter {
                 if (this.model.source.type !== "huggingface") {
                     throw new Error(`Model source not implemented: ${this.model.source.type}`);
                 }
-                await downloadModelViaHuggingFace({
-                    format: this.model.format,
-                    huggingFaceToken: this.model.source.modelSecret,
-                    modelSlug: this.model.source.slug,
-                    onProgress: onDownloadProgress,
-                    progressFilePath: join(this.modelsDirectory, `${this.uniqueName}.progress.json`),
-                    targetDirectory: join(this.modelsDirectory, this.uniqueName)
-                });
+                await this.acquireDownloadLock();
+                try {
+                    await downloadModelViaHuggingFace({
+                        format: this.model.format,
+                        huggingFaceToken: this.model.source.modelSecret,
+                        modelSlug: this.model.source.slug,
+                        onProgress: onDownloadProgress,
+                        progressFilePath: join(this.modelsDirectory, `${this.uniqueName}.progress.json`),
+                        targetDirectory: join(this.modelsDirectory, this.uniqueName)
+                    });
+                }
+                finally {
+                    await this.releaseDownloadLock();
+                }
                 break;
             // case "ollama":
             //     this.logger.info("Loading model", {
@@ -121065,6 +121094,63 @@ class ModelManager extends EventEmitter {
             });
         }, 15_000);
     }
+    get lockFilePath() {
+        return join(this.modelsDirectory, `${this.uniqueName}.lock`);
+    }
+    async acquireDownloadLock() {
+        await mkdir(this.modelsDirectory, { recursive: true });
+        if (existsSync(this.lockFilePath)) {
+            const age = await this.getLockAge();
+            if (age !== null && age < DOWNLOAD_LOCK_TIMEOUT_MS) {
+                this.logger.info("Download lock held by another process, waiting", {
+                    lockAgeMs: age,
+                    lockFilePath: this.lockFilePath
+                });
+                await this.waitForDownloadLock();
+            }
+            else {
+                this.logger.info("Stale download lock found, breaking", {
+                    lockFilePath: this.lockFilePath
+                });
+                await this.releaseDownloadLock();
+            }
+        }
+        await writeFile(this.lockFilePath, JSON.stringify({ acquiredAt: Date.now() }));
+        this.logger.info("Acquired download lock", { lockFilePath: this.lockFilePath });
+    }
+    async getLockAge() {
+        try {
+            const raw = await readFile(this.lockFilePath, "utf-8");
+            const data = JSON.parse(raw);
+            return Date.now() - data.acquiredAt;
+        }
+        catch {
+            return null;
+        }
+    }
+    async releaseDownloadLock() {
+        try {
+            await unlink(this.lockFilePath);
+        }
+        catch {
+            // already released
+        }
+    }
+    async waitForDownloadLock() {
+        const start = Date.now();
+        while (Date.now() - start < DOWNLOAD_LOCK_TIMEOUT_MS) {
+            await new Promise(resolve => setTimeout(resolve, DOWNLOAD_LOCK_POLL_INTERVAL_MS));
+            if (!existsSync(this.lockFilePath)) {
+                return;
+            }
+            const age = await this.getLockAge();
+            if (age === null || age >= DOWNLOAD_LOCK_TIMEOUT_MS) {
+                await this.releaseDownloadLock();
+                return;
+            }
+        }
+        await this.releaseDownloadLock();
+    }
     bindEngineProcessEvents(processManager) {
         let hasTerminated = false;
         processManager.on("stderr", line => {

package/dist/modelManagement/ModelManager.d.ts

@@ -47,6 +47,11 @@ export declare class ModelManager extends EventEmitter<ModelManagerEvents> {
     private waitForEngineReady;
     private clearHealthPoll;
     private startHealthPoll;
+    private get lockFilePath();
+    private acquireDownloadLock;
+    private getLockAge;
+    private releaseDownloadLock;
+    private waitForDownloadLock;
     private bindEngineProcessEvents;
     private startEngineProcess;
 }

package/dist/modelManagement/sanitizeKey.d.ts

@@ -0,0 +1,2 @@
+import type { LLMModel } from "@infersec/definitions";
+export declare function createModelStorageKey(model: LLMModel): string;

package/package.json

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