@caupulican/pi-adaptative 0.81.20 → 0.81.22

package/dist/core/models/local-runtime.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
-import { createWriteStream, existsSync, mkdirSync, rmSync } from "node:fs";
+import { copyFileSync, createWriteStream, existsSync, linkSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, } from "node:fs";
 import { homedir, arch as osArch, platform as osPlatform } from "node:os";
-import { delimiter, join } from "node:path";
+import { delimiter, dirname, join, relative } from "node:path";
 import { pipeline } from "node:stream/promises";
 import * as nodeZlib from "node:zlib";
 import { getBundledResourcesDir } from "../../config.js";
@@ -56,6 +56,17 @@ const TRANSFORMERS_SERVER_RELATIVE_PATH = join("runtimes", "hf-transformers-open
 const TRANSFORMERS_PINNED_PACKAGES = ["transformers==5.13.0", "huggingface-hub==1.22.0", "safetensors==0.8.0"];
 const TRANSFORMERS_REQUIRED_MODULES = ["torch", "transformers", "huggingface_hub", "safetensors"];
 const TORCH_PINNED_VERSION = "2.12.1";
+function isCrossDeviceLinkError(error) {
+    return typeof error === "object" && error !== null && error.code === "EXDEV";
+}
+function fileSizeBytes(path) {
+    try {
+        return statSync(path).size;
+    }
+    catch {
+        return 0;
+    }
+}
 async function runCommandDefault(command, args, options = {}) {
     try {
         const proc = spawnProcess(command, args, {
@@ -113,6 +124,8 @@ export class OllamaRuntime {
     _fetch;
     _spawn;
     _exists;
+    _linkFile;
+    _copyFile;
     _envPath;
     _homeDir;
     _sleep;
@@ -122,12 +135,15 @@ export class OllamaRuntime {
     _hasCommand;
     _extractArchiveOverride;
     _child;
+    _childModelsDir;
     constructor(args) {
         this._agentDir = args.agentDir;
         this._baseUrl = (args.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
         this._fetch = args.deps?.fetchFn ?? fetch;
         this._spawn = args.deps?.spawnFn ?? ((command, argv, options) => spawn(command, argv, options));
         this._exists = args.deps?.existsFn ?? existsSync;
+        this._linkFile = args.deps?.linkFile ?? linkSync;
+        this._copyFile = args.deps?.copyFile ?? copyFileSync;
         this._envPath = args.deps?.envPath ?? process.env.PATH ?? "";
         this._homeDir = args.deps?.homeDir ?? homedir();
         this._sleep = args.deps?.sleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
@@ -155,6 +171,35 @@ export class OllamaRuntime {
     ownedModelsDir() {
         return join(this._agentDir, "models", "ollama");
     }
+    userModelsDir() {
+        return join(this._homeDir, ".ollama", "models");
+    }
+    _storeSummary(kind, path) {
+        return { kind, path, modelCount: this._countStoreModels(path) };
+    }
+    _countStoreModels(storeDir) {
+        return this._walkFiles(join(storeDir, "manifests")).length;
+    }
+    _walkFiles(root) {
+        if (!this._exists(root))
+            return [];
+        let entries;
+        try {
+            entries = readdirSync(root, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        const files = [];
+        for (const entry of entries) {
+            const path = join(root, entry.name);
+            if (entry.isDirectory())
+                files.push(...this._walkFiles(path));
+            else if (entry.isFile())
+                files.push(path);
+        }
+        return files;
+    }
     _findBinary() {
         const piOwned = join(this._agentDir, "runtimes", "ollama", "bin", "ollama");
         if (this._exists(piOwned))
@@ -172,27 +217,115 @@ export class OllamaRuntime {
         return undefined;
     }
     async _serverUp() {
+        return (await this._serverModels()).up;
+    }
+    async _serverModels() {
         try {
             const response = await this._fetch(`${this._baseUrl}/api/tags`, {
                 signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS),
             });
-            return response.ok;
+            if (!response.ok)
+                return { up: false, modelCount: 0 };
+            const data = (await response.json().catch(() => ({})));
+            return { up: true, modelCount: Array.isArray(data.models) ? data.models.length : 0 };
         }
         catch {
-            return false;
+            return { up: false, modelCount: 0 };
         }
     }
+    _activeStoreSummary(serverModelCount, ownedStore, userStore) {
+        if (this._childModelsDir) {
+            return {
+                kind: this._childModelsDir === this.ownedModelsDir() ? "pi-owned" : "user",
+                path: this._childModelsDir,
+                modelCount: serverModelCount,
+            };
+        }
+        if (serverModelCount > 0 &&
+            serverModelCount === ownedStore.modelCount &&
+            serverModelCount !== userStore.modelCount) {
+            return { ...ownedStore, modelCount: serverModelCount };
+        }
+        if (serverModelCount > 0 &&
+            serverModelCount === userStore.modelCount &&
+            serverModelCount !== ownedStore.modelCount) {
+            return { ...userStore, modelCount: serverModelCount };
+        }
+        return { kind: "external", path: "external/unknown", modelCount: serverModelCount };
+    }
     async detect() {
         const binary = this._findBinary();
-        const serverUp = await this._serverUp();
+        const serverModels = await this._serverModels();
+        const ownedStore = this._storeSummary("pi-owned", this.ownedModelsDir());
+        const userStore = this._storeSummary("user", this.userModelsDir());
+        const activeStore = serverModels.up
+            ? this._activeStoreSummary(serverModels.modelCount, ownedStore, userStore)
+            : undefined;
         return {
             binaryPath: binary?.path,
             binarySource: binary?.source,
-            serverUp,
+            serverUp: serverModels.up,
             serverUrl: this._baseUrl,
-            managedByPi: this._child !== undefined && serverUp,
+            managedByPi: this._child !== undefined && serverModels.up,
             ownedModelsDir: this.ownedModelsDir(),
+            userModelsDir: this.userModelsDir(),
+            ownedStore,
+            userStore,
+            activeStore,
+        };
+    }
+    importUserModels() {
+        const sourceDir = this.userModelsDir();
+        const targetDir = this.ownedModelsDir();
+        const result = {
+            sourceDir,
+            targetDir,
+            manifestsImported: 0,
+            manifestsSkipped: 0,
+            blobsHardlinked: 0,
+            blobsCopied: 0,
+            blobsSkipped: 0,
+            bytesImported: 0,
         };
+        if (sourceDir === targetDir || !this._exists(sourceDir))
+            return result;
+        mkdirSync(targetDir, { recursive: true });
+        this._importManifestFiles(join(sourceDir, "manifests"), join(targetDir, "manifests"), result);
+        this._importBlobFiles(join(sourceDir, "blobs"), join(targetDir, "blobs"), result);
+        return result;
+    }
+    _importManifestFiles(sourceRoot, targetRoot, result) {
+        for (const source of this._walkFiles(sourceRoot)) {
+            const target = join(targetRoot, relative(sourceRoot, source));
+            if (this._exists(target)) {
+                result.manifestsSkipped++;
+                continue;
+            }
+            mkdirSync(dirname(target), { recursive: true });
+            this._copyFile(source, target);
+            result.manifestsImported++;
+        }
+    }
+    _importBlobFiles(sourceRoot, targetRoot, result) {
+        for (const source of this._walkFiles(sourceRoot)) {
+            const target = join(targetRoot, relative(sourceRoot, source));
+            if (this._exists(target)) {
+                result.blobsSkipped++;
+                continue;
+            }
+            mkdirSync(dirname(target), { recursive: true });
+            try {
+                this._linkFile(source, target);
+                result.blobsHardlinked++;
+            }
+            catch (error) {
+                if (!isCrossDeviceLinkError(error))
+                    throw error;
+                this._copyFile(source, target);
+                result.blobsCopied++;
+            }
+            result.bytesImported += fileSizeBytes(target);
+        }
     }
     /**
      * Manual-steps fallback text — shown when the managed install below wasn't offered (headless),
@@ -333,9 +466,9 @@ export class OllamaRuntime {
      * differs between them (owned storage vs reusing the user's own). */
     async _spawnAndPoll(binary, extraEnv) {
         const host = this._baseUrl.replace(/^https?:\/\//, "");
-        this._child = this._spawn(binary.path, ["serve"], {
-            env: { ...process.env, OLLAMA_HOST: host, ...extraEnv },
-        });
+        const env = { ...process.env, OLLAMA_HOST: host, ...extraEnv };
+        this._childModelsDir = env.OLLAMA_MODELS ?? this.userModelsDir();
+        this._child = this._spawn(binary.path, ["serve"], { env });
         this._child.unref?.();
         for (let attempt = 0; attempt < START_POLL_ATTEMPTS; attempt++) {
             if (await this._serverUp())
@@ -399,6 +532,7 @@ export class OllamaRuntime {
             // already gone
         }
         this._child = undefined;
+        this._childModelsDir = undefined;
         return { stopped: true };
     }
     async list() {
@@ -410,6 +544,43 @@ export class OllamaRuntime {
             .filter((model) => typeof model.name === "string")
             .map((model) => ({ name: model.name, sizeBytes: model.size ?? 0 }));
     }
+    async listResidentModels() {
+        const response = await this._fetch(`${this._baseUrl}/api/ps`, { signal: AbortSignal.timeout(10_000) });
+        if (!response.ok)
+            throw new Error(`ollama ps failed: HTTP ${response.status}`);
+        const data = (await response.json());
+        return (data.models ?? [])
+            .map((model) => ({ name: model.name ?? model.model, sizeBytes: model.size_vram ?? model.size ?? 0 }))
+            .filter((model) => typeof model.name === "string" && model.name.length > 0);
+    }
+    async ensureResident(model) {
+        return this._postKeepAlive(model, "30m");
+    }
+    async releaseResident(model) {
+        return this._postKeepAlive(model, 0);
+    }
+    async _postKeepAlive(model, keepAlive) {
+        try {
+            const response = await this._fetch(`${this._baseUrl}/api/generate`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    model,
+                    prompt: "",
+                    stream: false,
+                    keep_alive: keepAlive,
+                    options: { num_predict: 0 },
+                }),
+                signal: AbortSignal.timeout(60_000),
+            });
+            if (!response.ok)
+                return { ok: false, error: `HTTP ${response.status}: ${await response.text().catch(() => "")}` };
+            return { ok: true };
+        }
+        catch (error) {
+            return { ok: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
     async show(ref) {
         try {
             const response = await this._fetch(`${this._baseUrl}/api/show`, {
@@ -671,21 +842,117 @@ export class TransformersRuntime {
         ]);
         return result.ok;
     }
+    readPyvenvHome() {
+        const pyvenvCfg = join(this.venvDir, "pyvenv.cfg");
+        if (!this._exists(pyvenvCfg))
+            return undefined;
+        try {
+            const text = readFileSync(pyvenvCfg, "utf8");
+            const homeLine = text
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .find((line) => line.toLowerCase().startsWith("home ="));
+            return homeLine?.slice(homeLine.indexOf("=") + 1).trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async venvInterpreterCoherent() {
+        const pyvenvHome = this.readPyvenvHome();
+        if (!pyvenvHome)
+            return false;
+        const base = await this.runPython(["-c", "import sys; print(sys.base_prefix or sys.prefix)"]);
+        if (!base.ok)
+            return false;
+        const basePrefix = base.stdout.trim();
+        if (!basePrefix)
+            return true;
+        return pyvenvHome === basePrefix || pyvenvHome.startsWith(basePrefix) || basePrefix.startsWith(pyvenvHome);
+    }
+    async venvHealthy() {
+        const pip = await this.runPython(["-m", "pip", "--version"]);
+        return pip.ok && (await this.venvInterpreterCoherent());
+    }
+    linuxVenvPackageCommand() {
+        try {
+            const osRelease = readFileSync("/etc/os-release", "utf8").toLowerCase();
+            if (osRelease.includes("alpine"))
+                return "sudo apk add python3 py3-pip";
+            if (osRelease.includes("fedora") || osRelease.includes("rhel") || osRelease.includes("centos")) {
+                return "sudo dnf install python3";
+            }
+        }
+        catch {
+            // fall through to the most common Debian/Ubuntu package split.
+        }
+        return "sudo apt install python3-venv";
+    }
+    venvInstallHint() {
+        if (this._platform() === "darwin")
+            return "install Python from python.org or run: brew install python";
+        if (this._platform() === "win32")
+            return "install Python 3 from python.org, then run: py -3 -m venv <path>";
+        if (this._platform() === "linux")
+            return this.linuxVenvPackageCommand();
+        return "install Python with venv/ensurepip support for this platform";
+    }
+    venvFailure(error) {
+        return {
+            ok: false,
+            error: `venv-fail: ${sanitizeCommandOutput(error)}. Install Python venv support: ${this.venvInstallHint()}`,
+        };
+    }
+    async createVenv(onProgress) {
+        const python = await this.findPython();
+        if (!python)
+            return { ok: false, error: "python-missing" };
+        onProgress?.(`creating isolated Python venv at ${this.venvDir}`);
+        const venv = await this._runCommand(python.command, [...python.args, "-m", "venv", this.venvDir]);
+        if (!venv.ok)
+            return this.venvFailure(venv.error ?? venv.stderr);
+        if (!this._exists(this.pythonPath))
+            return this.venvFailure(`${this.pythonPath} was not created`);
+        return { ok: true };
+    }
+    async repairExistingVenv(onProgress) {
+        if (await this.venvHealthy())
+            return { ok: true };
+        onProgress?.("repairing pi-managed Transformers venv with ensurepip");
+        const ensurepip = await this.runPython(["-m", "ensurepip", "--upgrade"], onProgress);
+        if (ensurepip.ok && (await this.venvHealthy()))
+            return { ok: true };
+        onProgress?.("recreating pi-managed Transformers venv");
+        rmSync(this.venvDir, { recursive: true, force: true });
+        return this.createVenv(onProgress);
+    }
+    async ensurePipAvailable(onProgress) {
+        const pip = await this.runPython(["-m", "pip", "--version"]);
+        if (pip.ok)
+            return { ok: true };
+        onProgress?.("bootstrapping pip inside pi-managed venv");
+        const ensurepip = await this.runPython(["-m", "ensurepip", "--upgrade"], onProgress);
+        if (!ensurepip.ok)
+            return this.venvFailure(ensurepip.error ?? ensurepip.stderr);
+        const verified = await this.runPython(["-m", "pip", "--version"]);
+        return verified.ok ? { ok: true } : this.venvFailure(verified.error ?? verified.stderr);
+    }
     async installManaged(onProgress) {
         mkdirSync(this.runtimeDir, { recursive: true });
         mkdirSync(this.cacheDir, { recursive: true });
-        if (!this._exists(this.pythonPath)) {
-            const python = await this.findPython();
-            if (!python)
-                return { ok: false, error: "python-missing" };
-            onProgress?.(`creating isolated Python venv at ${this.venvDir}`);
-            const venv = await this._runCommand(python.command, [...python.args, "-m", "venv", this.venvDir]);
-            if (!venv.ok)
-                return { ok: false, error: `venv-fail: ${sanitizeCommandOutput(venv.error ?? venv.stderr)}` };
+        if (this._exists(this.pythonPath)) {
+            const repaired = await this.repairExistingVenv(onProgress);
+            if (!repaired.ok)
+                return repaired;
         }
         if (!this._exists(this.pythonPath)) {
-            return { ok: false, error: `venv-fail: ${this.pythonPath} was not created` };
+            const created = await this.createVenv(onProgress);
+            if (!created.ok)
+                return created;
         }
+        const pipReady = await this.ensurePipAvailable(onProgress);
+        if (!pipReady.ok)
+            return pipReady;
         onProgress?.("upgrading pip inside pi-managed venv");
         const pip = await this.runPython(["-m", "pip", "install", "--upgrade", "pip"], onProgress);
         if (!pip.ok)