@caupulican/pi-adaptative 0.81.42 → 0.84.1

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

@@ -1,26 +1,14 @@
-import { spawn } from "node:child_process";
-import { copyFileSync, createWriteStream, existsSync, linkSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, } from "node:fs";
+import { copyFileSync, linkSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
 import { homedir, arch as osArch, platform as osPlatform } from "node:os";
 import { delimiter, dirname, join, relative } from "node:path";
 import { pipeline } from "node:stream/promises";
 import * as nodeZlib from "node:zlib";
+import { StreamingLineDecoder } from "@caupulican/pi-ai";
 import { getBundledResourcesDir } from "../../config.js";
-import { spawnProcess, spawnProcessSync, waitForChildProcessWithTermination, } from "../../utils/child-process.js";
-import { StreamingLineDecoder } from "../../utils/streaming-lines.js";
+import { spawnProcess, waitForChildProcessWithTermination, } from "../../utils/child-process.js";
 import { modelsDir as agentModelsDir, runtimesDir as agentRuntimesDir } from "../agent-paths.js";
+import { createRuntimeCommandRunner, extractZipArchive, installRuntimeArchive, requireRuntimeStdin, resolveRuntimeLifecycleDependencies, runtimeCommandAvailable, } from "./runtime-process.js";
 const MAX_OLLAMA_PULL_LINE_CHARS = 64 * 1024 * 1024;
-/**
- * `spawnProcess(..., { stdio: ["pipe", "pipe", "pipe"] })` always yields a non-null `stdin` at
- * runtime, but child-process.ts's typed overload only narrows `.stdin` to non-null for the
- * capture-only (`StdioNull, StdioPipe, StdioPipe`) shape, so the generic overload's `Writable |
- * null` leaks through here. This makes the true invariant explicit and fails loudly (instead of
- * silently misbehaving) if it's ever violated by a future stdio change.
- */
-function requireStdin(proc, label) {
-    if (!proc.stdin)
-        throw new Error(`${label}: no stdin pipe`);
-    return proc.stdin;
-}
 /** Pinned ollama release for the managed installer below. Bump here when needed — one constant. */
 export const OLLAMA_PINNED_VERSION = "0.31.1";
 /**
@@ -87,53 +75,10 @@ function fileSizeBytes(path) {
         return 0;
     }
 }
-async function runCommandDefault(command, args, options = {}) {
-    try {
-        const proc = spawnProcess(command, args, {
-            detached: process.platform !== "win32",
-            stdio: ["ignore", "pipe", "pipe"],
-            env: options.env ? { ...process.env, ...options.env } : process.env,
-        });
-        let stdout = "";
-        let stderr = "";
-        proc.stdout.setEncoding("utf8");
-        proc.stderr.setEncoding("utf8");
-        proc.stdout.on("data", (chunk) => {
-            stdout = `${stdout}${chunk}`.slice(-1024 * 1024);
-            options.onOutput?.(chunk);
-        });
-        proc.stderr.on("data", (chunk) => {
-            stderr = `${stderr}${chunk}`.slice(-1024 * 1024);
-            options.onOutput?.(chunk);
-        });
-        const terminal = await waitForChildProcessWithTermination(proc, {
-            timeoutMs: LOCAL_RUNTIME_COMMAND_TIMEOUT_MS,
-            killGraceMs: LOCAL_RUNTIME_KILL_GRACE_MS,
-        });
-        const timedOut = terminal.reason === "timeout";
-        return {
-            ok: terminal.code === 0,
-            stdout,
-            stderr,
-            code: terminal.code,
-            ...(terminal.code === 0
-                ? {}
-                : {
-                    error: timedOut
-                        ? `${command} timed out after ${LOCAL_RUNTIME_COMMAND_TIMEOUT_MS}ms`
-                        : stderr.trim() || stdout.trim() || `exit code ${terminal.code ?? "unknown"}`,
-                }),
-        };
-    }
-    catch (error) {
-        return {
-            ok: false,
-            stdout: "",
-            stderr: "",
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
+const runCommandDefault = createRuntimeCommandRunner({
+    timeoutMs: LOCAL_RUNTIME_COMMAND_TIMEOUT_MS,
+    killGraceMs: LOCAL_RUNTIME_KILL_GRACE_MS,
+});
 function sanitizeCommandOutput(value) {
     return value?.trim().split("\n").slice(-3).join("\n") || "unknown error";
 }
@@ -150,35 +95,14 @@ export function resolveTransformersBaseUrl(modelId) {
     return `http://127.0.0.1:${port}`;
 }
 export class OllamaRuntime {
-    _agentDir;
-    _baseUrl;
-    _fetch;
-    _spawn;
-    _exists;
-    _linkFile;
-    _copyFile;
-    _envPath;
-    _homeDir;
-    _sleep;
-    _platform;
-    _arch;
-    _createZstdDecompress;
-    _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, stdio: "ignore" }));
-        this._exists = args.deps?.existsFn ?? existsSync;
+        [this._fetch, this._spawn, this._exists, this._sleep] = resolveRuntimeLifecycleDependencies(args.deps);
         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)));
         this._platform = args.deps?.platform ?? osPlatform;
         this._arch = args.deps?.arch ?? osArch;
         // Feature-detect (not version-sniff): recent Node added zstd natively to node:zlib. Verified
@@ -192,10 +116,9 @@ export class OllamaRuntime {
                 : typeof nodeZlib.createZstdDecompress === "function"
                     ? () => nodeZlib.createZstdDecompress()
                     : undefined;
-        this._hasCommand =
-            args.deps?.hasCommand ??
-                ((command) => spawnProcessSync(command, ["--version"], { encoding: "utf8", timeout: 5_000 }).error === undefined);
-        this._extractArchiveOverride = args.deps?.extractArchive;
+        this._hasCommand = args.deps?.hasCommand ?? runtimeCommandAvailable;
+        this._extractArchiveFn =
+            args.deps?.extractArchive ?? ((input, destDir, kind) => this._extractArchive(input, destDir, kind));
     }
     get baseUrl() {
         return this._baseUrl;
@@ -405,25 +328,11 @@ export class OllamaRuntime {
         const asset = resolveOllamaAsset(this._platform(), this._arch());
         if (!asset)
             return { ok: false, error: "unsupported-platform" };
-        onProgress?.(`Downloading ${asset.name}…`);
         const downloadUrl = `https://github.com/ollama/ollama/releases/download/v${OLLAMA_PINNED_VERSION}/${asset.name}`;
-        let response;
-        try {
-            response = await this._fetch(downloadUrl);
-        }
-        catch (error) {
-            return { ok: false, error: `download-fail: ${error instanceof Error ? error.message : String(error)}` };
-        }
-        if (!response.ok || !response.body) {
-            return { ok: false, error: `download-fail: HTTP ${response.status}` };
-        }
-        const destDir = agentRuntimesDir("ollama", this._agentDir);
-        mkdirSync(destDir, { recursive: true });
-        onProgress?.(`Extracting ${asset.name}…`);
-        const extract = this._extractArchiveOverride ?? ((input, dest, kind) => this._extractArchive(input, dest, kind));
-        const extracted = await extract(response.body, destDir, asset.kind);
+        const extracted = await this._installArchive(downloadUrl, asset, onProgress);
         if (!extracted.ok)
             return extracted;
+        const destDir = agentRuntimesDir("ollama", this._agentDir);
         const binaryName = this._platform() === "win32" ? "ollama.exe" : "ollama";
         const binaryPath = join(destDir, "bin", binaryName);
         if (!this._exists(binaryPath)) {
@@ -432,6 +341,9 @@ export class OllamaRuntime {
         onProgress?.("Ollama installed.");
         return { ok: true };
     }
+    _installArchive(downloadUrl, asset, onProgress) {
+        return installRuntimeArchive(this._fetch, downloadUrl, agentRuntimesDir("ollama", this._agentDir), asset, this._extractArchiveFn, onProgress);
+    }
     /** Real extraction: `tar-gz` lets `tar` itself gunzip; `tar-zst` decompresses first (native
      * node:zlib preferred, system `zstd` as fallback, an honest error if neither exists — see
      * {@link _chooseZstdStrategy}); `zip` needs a seekable file, so it's buffered to disk first. */
@@ -483,13 +395,13 @@ export class OllamaRuntime {
             killGraceMs: LOCAL_RUNTIME_KILL_GRACE_MS,
         }));
         const streamPipelines = nativeZstd
-            ? [pipeline(input, nativeZstd, requireStdin(tarProc, "tar"))]
+            ? [pipeline(input, nativeZstd, requireRuntimeStdin(tarProc, "tar"))]
             : zstdProc
                 ? [
-                    pipeline(input, requireStdin(zstdProc, "zstd")),
-                    pipeline(zstdProc.stdout, requireStdin(tarProc, "tar")),
+                    pipeline(input, requireRuntimeStdin(zstdProc, "zstd")),
+                    pipeline(zstdProc.stdout, requireRuntimeStdin(tarProc, "tar")),
                 ]
-                : [pipeline(input, requireStdin(tarProc, "tar"))];
+                : [pipeline(input, requireRuntimeStdin(tarProc, "tar"))];
         let terminals;
         try {
             [, terminals] = await Promise.all([Promise.all(streamPipelines), Promise.all(processWaits)]);
@@ -511,38 +423,15 @@ export class OllamaRuntime {
         return { ok: true };
     }
     async _extractZip(input, destDir) {
-        // Zip's central directory needs seekable file access — buffer to a temp file first.
-        const zipPath = join(destDir, "..", `ollama-download-${process.pid}-${Date.now()}.zip`);
-        await pipeline(input, createWriteStream(zipPath));
-        try {
-            const extractCommand = this._platform() === "win32" && this._hasCommand("tar") ? "tar" : "unzip";
-            const args = extractCommand === "tar" ? ["-xf", zipPath, "-C", destDir] : ["-q", zipPath, "-d", destDir];
-            const proc = spawnProcess(extractCommand, args, {
-                detached: process.platform !== "win32",
-                stdio: "ignore",
-            });
-            const terminal = await waitForChildProcessWithTermination(proc, {
-                timeoutMs: LOCAL_RUNTIME_EXTRACTION_TIMEOUT_MS,
-                killGraceMs: LOCAL_RUNTIME_KILL_GRACE_MS,
-            });
-            if (terminal.reason === "timeout" || terminal.code !== 0) {
-                return {
-                    ok: false,
-                    error: terminal.reason === "timeout"
-                        ? `extract-fail: ${extractCommand} timed out after ${LOCAL_RUNTIME_EXTRACTION_TIMEOUT_MS}ms`
-                        : `extract-fail: ${extractCommand} exited with code ${terminal.code ?? "unknown"}`,
-                };
-            }
-            return { ok: true };
-        }
-        finally {
-            try {
-                rmSync(zipPath, { force: true });
-            }
-            catch {
-                // best-effort cleanup
-            }
-        }
+        return extractZipArchive({
+            input: input,
+            destDir,
+            tempPrefix: "ollama-download",
+            platform: this._platform,
+            hasCommand: this._hasCommand,
+            timeoutMs: LOCAL_RUNTIME_EXTRACTION_TIMEOUT_MS,
+            killGraceMs: LOCAL_RUNTIME_KILL_GRACE_MS,
+        });
     }
     /** Shared spawn-then-health-poll for both start modes below; `extraEnv` is the only thing that
      * differs between them (owned storage vs reusing the user's own). */
@@ -564,21 +453,17 @@ export class OllamaRuntime {
         this.stop();
         return { started: false, reason: "health_check_timeout" };
     }
-    /**
-     * Start a pi-managed serve with OWNED storage and the hardened env verified on this class of
-     * hardware. No-op (reported) when a server already responds — pi never double-serves. Used by
-     * `/models add` et al, where isolated per-model-pull storage is the point.
-     */
-    async start() {
+    async _startServer(modelsDir) {
         if (await this._serverUp()) {
             return { started: false, reason: this._child ? "already_running_managed" : "already_running_system" };
         }
         const binary = this._findBinary();
         if (!binary)
             return { started: false, reason: "binary_missing" };
-        mkdirSync(this.ownedModelsDir(), { recursive: true });
+        if (modelsDir)
+            mkdirSync(modelsDir, { recursive: true });
         return this._spawnAndPoll(binary, {
-            OLLAMA_MODELS: this.ownedModelsDir(),
+            ...(modelsDir ? { OLLAMA_MODELS: modelsDir } : {}),
             OLLAMA_FLASH_ATTENTION: "1",
             OLLAMA_KV_CACHE_TYPE: "q8_0",
             OLLAMA_NUM_PARALLEL: "1",
@@ -586,6 +471,14 @@ export class OllamaRuntime {
             OLLAMA_MAX_LOADED_MODELS: "3",
         });
     }
+    /**
+     * Start a pi-managed serve with OWNED storage and the hardened env verified on this class of
+     * hardware. No-op (reported) when a server already responds — pi never double-serves. Used by
+     * `/models add` et al, where isolated per-model-pull storage is the point.
+     */
+    async start() {
+        return this._startServer(this.ownedModelsDir());
+    }
     /**
      * Start a serve that REUSES the user's own existing models directory (no `OLLAMA_MODELS`
      * override — falls through to Ollama's own default, `~/.ollama`), for callers that must see the
@@ -593,19 +486,7 @@ export class OllamaRuntime {
      * hardened perf env as {@link start}; the only difference is which storage the server sees.
      */
     async startReuseExisting() {
-        if (await this._serverUp()) {
-            return { started: false, reason: this._child ? "already_running_managed" : "already_running_system" };
-        }
-        const binary = this._findBinary();
-        if (!binary)
-            return { started: false, reason: "binary_missing" };
-        return this._spawnAndPoll(binary, {
-            OLLAMA_FLASH_ATTENTION: "1",
-            OLLAMA_KV_CACHE_TYPE: "q8_0",
-            OLLAMA_NUM_PARALLEL: "1",
-            OLLAMA_KEEP_ALIVE: "30m",
-            OLLAMA_MAX_LOADED_MODELS: "3",
-        });
+        return this._startServer();
     }
     /** Resource hygiene only: stops the pi-managed serve process; never deletes anything. */
     stop() {
@@ -684,18 +565,13 @@ export class OllamaRuntime {
             return { ok: false, error: error instanceof Error ? error.message : String(error) };
         }
     }
-    async createFromModelfile(args) {
+    async _requestModelMutation(endpoint, init, operation) {
         try {
-            const response = await this._fetch(`${this._baseUrl}/api/create`, {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({ model: args.name, modelfile: args.modelfile, stream: false }),
-                signal: AbortSignal.timeout(60_000),
-            });
+            const response = await this._fetch(`${this._baseUrl}${endpoint}`, init);
             if (!response.ok) {
                 return {
                     ok: false,
-                    error: `create failed: HTTP ${response.status} ${await response.text().catch(() => "")}`,
+                    error: `${operation} failed: HTTP ${response.status} ${await response.text().catch(() => "")}`,
                 };
             }
             return { ok: true };
@@ -704,6 +580,14 @@ export class OllamaRuntime {
             return { ok: false, error: error instanceof Error ? error.message : String(error) };
         }
     }
+    async createFromModelfile(args) {
+        return this._requestModelMutation("/api/create", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ model: args.name, modelfile: args.modelfile, stream: false }),
+            signal: AbortSignal.timeout(60_000),
+        }, "create");
+    }
     /** Pull a model through the server API (weights land in the SERVER's models dir). */
     async pull(ref, onProgress) {
         try {
@@ -764,47 +648,19 @@ export class OllamaRuntime {
     }
     /** EXPLICIT user action only — callers must have shown what gets deleted and confirmed. */
     async remove(ref) {
-        try {
-            const response = await this._fetch(`${this._baseUrl}/api/delete`, {
-                method: "DELETE",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({ model: ref }),
-            });
-            if (!response.ok) {
-                return {
-                    ok: false,
-                    error: `delete failed: HTTP ${response.status} ${await response.text().catch(() => "")}`,
-                };
-            }
-            return { ok: true };
-        }
-        catch (error) {
-            return { ok: false, error: error instanceof Error ? error.message : String(error) };
-        }
+        return this._requestModelMutation("/api/delete", {
+            method: "DELETE",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ model: ref }),
+        }, "delete");
     }
 }
 export class TransformersRuntime {
-    _agentDir;
-    _modelId;
-    _baseUrl;
-    _fetch;
-    _spawn;
-    _exists;
-    _sleep;
-    _platform;
-    _runCommand;
-    _serverScriptPath;
-    _proc;
     constructor(args) {
         this._agentDir = args.agentDir;
         this._modelId = args.modelId;
         this._baseUrl = args.baseUrl?.replace(/\/$/, "") ?? resolveTransformersBaseUrl(args.modelId);
-        this._fetch = args.deps?.fetchFn ?? fetch;
-        this._spawn =
-            args.deps?.spawnFn ??
-                ((command, argv, options) => spawn(command, argv, { env: options.env, stdio: "ignore" }));
-        this._exists = args.deps?.existsFn ?? existsSync;
-        this._sleep = args.deps?.sleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+        [this._fetch, this._spawn, this._exists, this._sleep] = resolveRuntimeLifecycleDependencies(args.deps);
         this._platform = args.deps?.platform ?? osPlatform;
         this._runCommand = args.deps?.runCommand ?? runCommandDefault;
         this._serverScriptPath =