@melaya/runner 1.1.31 → 1.1.33

package/dist/cli.js

@@ -52,26 +52,33 @@ async function main() {
         .parse(process.argv);
     const opts = program.opts();
     console.log(BANNER);
-    // Detect Python
+    // Detect Python. Fast path: a supported host interpreter (3.10–3.12). If the
+    // host only has an unsupported/newer Python (Homebrew now ships 3.13/3.14 as
+    // `python3`) — or none at all — we PROVISION a managed CPython 3.12 via uv, so
+    // the runner needs zero Python setup on the box. `venv` can't do this (it only
+    // wraps an existing interpreter); uv downloads a standalone one.
+    let python;
     const py = await findPython();
-    if (!py.ok) {
-        if (py.foundVersion) {
-            console.log(chalk.red(`  ✗ ${py.foundVersion} found, but Melaya needs Python 3.${PY_MIN_MINOR}–3.${PY_MAX_MINOR}`));
-            console.log(chalk.gray("    Python 3.13+ has no wheels yet for the assistant's Python deps (agentscope + native"));
-            console.log(chalk.gray("    extensions), so the runner's venv can't build and every assistant turn fails."));
-            console.log(chalk.gray("    Install a supported Python, then restart the runner:"));
+    if (py.ok) {
+        python = py.cmd;
+        console.log(chalk.green(`  ✓ Python: ${python} (3.${py.minor})`));
+    }
+    else {
+        console.log(chalk.yellow(`  ⚠ No supported host Python (need 3.${PY_MIN_MINOR}–3.${PY_MAX_MINOR}` +
+            `${py.foundVersion ? `; host has ${py.foundVersion}` : ""}) — provisioning one automatically`));
+        const { provisionPython } = await import("./uvBootstrap.js");
+        const provisioned = await provisionPython(`3.${PY_MAX_MINOR}`, (m) => console.log(chalk.gray(`    ${m}`)));
+        if (!provisioned) {
+            console.log(chalk.red(`  ✗ Could not auto-provision Python 3.${PY_MAX_MINOR}`));
+            console.log(chalk.gray("    Install a supported Python manually, then restart the runner:"));
             console.log(chalk.gray("      macOS:   brew install python@3.12"));
             console.log(chalk.gray("      Linux:   sudo apt install python3.12 python3.12-venv    (or: pyenv install 3.12)"));
             console.log(chalk.gray("      Windows: winget install Python.Python.3.12"));
+            process.exit(1);
         }
-        else {
-            console.log(chalk.red("  ✗ Python not found in PATH"));
-            console.log(chalk.gray("    Install Python 3.12 from https://python.org"));
-        }
-        process.exit(1);
+        python = provisioned;
+        console.log(chalk.green(`  ✓ Python: ${python} (auto-provisioned 3.${PY_MAX_MINOR})`));
     }
-    const python = py.cmd;
-    console.log(chalk.green(`  ✓ Python: ${python} (3.${py.minor})`));
     // Detect local models
     const models = await detectModels();
     if (models.length === 0) {

package/dist/uvBootstrap.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Zero-setup Python provisioning.
+ *
+ * `python -m venv` does NOT install a Python — it creates a thin environment
+ * that symlinks back to an existing interpreter, frozen to that interpreter's
+ * version. So when the host has no supported Python (e.g. Homebrew now ships
+ * 3.13/3.14 as `python3`, which has no wheels for agentscope's native deps),
+ * the runner can't build a working venv no matter what.
+ *
+ * This module removes the requirement for a host Python entirely: it uses
+ * `uv` (a single static binary) to download a *managed, standalone* CPython of
+ * the supported version and returns its interpreter path. The existing venv
+ * pipeline then builds from that. `uv` itself is bootstrapped from its official
+ * GitHub release if it isn't already installed — no `brew install`, no manual
+ * steps. All failures degrade to `null` so the caller can fall back to a clear
+ * "install Python 3.12" message.
+ */
+type Log = (m: string) => void;
+export declare function localUvPath(): string;
+/**
+ * Provision a supported CPython with NO host Python required. Downloads a
+ * managed standalone CPython of `version` via uv (bootstrapping uv itself if
+ * needed) and returns its interpreter path — which the venv pipeline builds
+ * from. Returns null if provisioning isn't possible (offline, unsupported
+ * platform, tar missing), so the caller can show manual-install guidance.
+ */
+export declare function provisionPython(version: string, onLine: Log): Promise<string | null>;
+export {};

package/dist/uvBootstrap.js

@@ -0,0 +1,245 @@
+/**
+ * Zero-setup Python provisioning.
+ *
+ * `python -m venv` does NOT install a Python — it creates a thin environment
+ * that symlinks back to an existing interpreter, frozen to that interpreter's
+ * version. So when the host has no supported Python (e.g. Homebrew now ships
+ * 3.13/3.14 as `python3`, which has no wheels for agentscope's native deps),
+ * the runner can't build a working venv no matter what.
+ *
+ * This module removes the requirement for a host Python entirely: it uses
+ * `uv` (a single static binary) to download a *managed, standalone* CPython of
+ * the supported version and returns its interpreter path. The existing venv
+ * pipeline then builds from that. `uv` itself is bootstrapped from its official
+ * GitHub release if it isn't already installed — no `brew install`, no manual
+ * steps. All failures degrade to `null` so the caller can fall back to a clear
+ * "install Python 3.12" message.
+ */
+import { existsSync, mkdirSync, writeFileSync, chmodSync, rmSync, readdirSync, statSync, copyFileSync } from "fs";
+import { join } from "path";
+import { homedir, platform, arch } from "os";
+import { spawn, execSync } from "child_process";
+const CACHE_DIR = join(homedir(), ".melaya-runner");
+const BIN_DIR = join(CACHE_DIR, "bin");
+const isWin = platform() === "win32";
+function uvBinName() { return isWin ? "uv.exe" : "uv"; }
+export function localUvPath() { return join(BIN_DIR, uvBinName()); }
+// Release asset for this platform/arch, from github.com/astral-sh/uv/releases.
+function assetName() {
+    const p = platform(), a = arch();
+    if (p === "darwin")
+        return a === "arm64" ? "uv-aarch64-apple-darwin.tar.gz" : "uv-x86_64-apple-darwin.tar.gz";
+    if (p === "linux") {
+        if (a === "arm64")
+            return "uv-aarch64-unknown-linux-gnu.tar.gz";
+        if (a === "x64")
+            return "uv-x86_64-unknown-linux-gnu.tar.gz";
+        return null; // unusual arch — fall back to manual install guidance
+    }
+    if (p === "win32")
+        return a === "arm64" ? "uv-aarch64-pc-windows-msvc.zip" : "uv-x86_64-pc-windows-msvc.zip";
+    return null;
+}
+function tryExec(cmd) {
+    try {
+        return execSync(cmd, { encoding: "utf-8", timeout: 8000, stdio: ["pipe", "pipe", "pipe"] }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function findOnPath(bin) {
+    const out = tryExec(isWin ? `where ${bin}` : `command -v ${bin}`);
+    if (!out)
+        return null;
+    const first = out.split(/\r?\n/)[0].trim();
+    return first || null;
+}
+// Inactivity-bounded child runner (mirrors pythonEnv.runProc): a managed-CPython
+// download legitimately takes a while but streams progress, so we bound silence.
+function run(cmd, args, onLine, opts = {}) {
+    const inactivityMs = opts.inactivityMs ?? 5 * 60_000;
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, ...opts.env }, cwd: opts.cwd });
+        let done = false;
+        let timer;
+        const finish = (c) => { if (done)
+            return; done = true; if (timer)
+            clearTimeout(timer); resolve(c); };
+        const bump = () => {
+            if (timer)
+                clearTimeout(timer);
+            timer = setTimeout(() => { try {
+                child.kill("SIGKILL");
+            }
+            catch { /* gone */ } onLine(`(no output for ${Math.round(inactivityMs / 60000)}m — killed ${cmd})`); finish(1); }, inactivityMs);
+        };
+        const chew = (b) => { bump(); for (const ln of b.toString().split("\n")) {
+            const t = ln.trimEnd();
+            if (t)
+                onLine(t);
+        } };
+        child.stdout?.on("data", chew);
+        child.stderr?.on("data", chew);
+        child.on("exit", (c) => finish(c ?? 1));
+        child.on("error", () => finish(1));
+        bump();
+    });
+}
+function capture(cmd, args, env = {}) {
+    return new Promise((resolve) => {
+        let out = "";
+        const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, ...env } });
+        child.stdout?.on("data", (b) => { out += b.toString(); });
+        child.on("exit", () => resolve(out.trim()));
+        child.on("error", () => resolve(""));
+    });
+}
+// Extract the downloaded uv archive. uv ships .tar.gz for macOS/Linux and .zip
+// for Windows, so extraction must branch by type — a single `tar` call can't
+// cover both portably (a shell's `tar` may be MSYS GNU tar, which can't read
+// zip). destDir already contains the archive; we extract in place.
+async function extractArchive(archivePath, asset, destDir, onLine) {
+    if (asset.endsWith(".zip")) {
+        // Windows only. PowerShell's Expand-Archive is always present and reliably
+        // reads zips, unlike whatever `tar` happens to be on PATH.
+        const ps = `Expand-Archive -LiteralPath '${archivePath.replace(/'/g, "''")}' -DestinationPath '${destDir.replace(/'/g, "''")}' -Force`;
+        let code = await run("powershell", ["-NoProfile", "-NonInteractive", "-Command", ps], onLine);
+        if (code === 0)
+            return true;
+        // Fallback: Windows' bundled bsdtar (System32\tar.exe) also handles zip.
+        const sys32 = join(process.env.SystemRoot || "C:\\Windows", "System32", "tar.exe");
+        code = await run(existsSync(sys32) ? sys32 : "tar", ["-xf", asset, "-C", "."], onLine, { cwd: destDir });
+        return code === 0;
+    }
+    // macOS/Linux: .tar.gz — bsdtar (macOS) and GNU tar (Linux) both read gz.
+    // cwd + bare relative name keeps args colon-free (harmless on unix, required
+    // on Windows for the fallback path above).
+    const code = await run("tar", ["-xf", asset, "-C", "."], onLine, { cwd: destDir });
+    return code === 0;
+}
+function findBinaryRecursive(dir, name) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return null;
+    }
+    for (const e of entries) {
+        const full = join(dir, e);
+        let st;
+        try {
+            st = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (st.isDirectory()) {
+            const found = findBinaryRecursive(full, name);
+            if (found)
+                return found;
+        }
+        else if (e === name)
+            return full;
+    }
+    return null;
+}
+// Download + extract the uv binary from its latest GitHub release. The
+// `/releases/latest/download/<asset>` path redirects to the newest asset, so we
+// track upstream without pinning a possibly-nonexistent tag. tar handles the
+// .tar.gz on macOS/Linux and (via bsdtar) the .zip on Windows.
+async function downloadUv(onLine) {
+    const asset = assetName();
+    if (!asset) {
+        onLine(`no uv build available for ${platform()}/${arch()}`);
+        return null;
+    }
+    const url = `https://github.com/astral-sh/uv/releases/latest/download/${asset}`;
+    mkdirSync(BIN_DIR, { recursive: true });
+    const tmp = join(BIN_DIR, "_dl");
+    try {
+        rmSync(tmp, { recursive: true, force: true });
+    }
+    catch { /* fresh */ }
+    mkdirSync(tmp, { recursive: true });
+    const archivePath = join(tmp, asset);
+    onLine(`downloading uv (${asset})`);
+    try {
+        const res = await fetch(url, { redirect: "follow", signal: AbortSignal.timeout(120_000) });
+        if (!res.ok) {
+            onLine(`uv download failed: HTTP ${res.status}`);
+            return null;
+        }
+        writeFileSync(archivePath, Buffer.from(await res.arrayBuffer()));
+    }
+    catch (e) {
+        onLine(`uv download error: ${e?.message}`);
+        return null;
+    }
+    onLine("extracting uv");
+    const extracted = await extractArchive(archivePath, asset, tmp, onLine);
+    if (!extracted) {
+        onLine("extraction of the uv archive failed");
+        return null;
+    }
+    const found = findBinaryRecursive(tmp, uvBinName());
+    if (!found) {
+        onLine("uv binary not found inside the downloaded archive");
+        return null;
+    }
+    const dest = localUvPath();
+    try {
+        copyFileSync(found, dest);
+        if (!isWin)
+            chmodSync(dest, 0o755);
+    }
+    catch (e) {
+        onLine(`could not install uv to ${dest}: ${e?.message}`);
+        return null;
+    }
+    try {
+        rmSync(tmp, { recursive: true, force: true });
+    }
+    catch { /* best-effort cleanup */ }
+    return dest;
+}
+async function ensureUv(onLine) {
+    if (existsSync(localUvPath()))
+        return localUvPath(); // previously downloaded
+    const onPath = findOnPath(uvBinName());
+    if (onPath)
+        return onPath; // operator already has uv
+    return downloadUv(onLine); // bootstrap it
+}
+/**
+ * Provision a supported CPython with NO host Python required. Downloads a
+ * managed standalone CPython of `version` via uv (bootstrapping uv itself if
+ * needed) and returns its interpreter path — which the venv pipeline builds
+ * from. Returns null if provisioning isn't possible (offline, unsupported
+ * platform, tar missing), so the caller can show manual-install guidance.
+ */
+export async function provisionPython(version, onLine) {
+    const uv = await ensureUv(onLine);
+    if (!uv)
+        return null;
+    onLine(`installing a managed Python ${version} (one-time; ~30-60s)`);
+    // UV_SYSTEM_CERTS makes uv verify against the OS trust store instead of its
+    // bundled webpki roots — required behind TLS-intercepting proxies/antivirus
+    // (else "invalid peer certificate: UnknownIssuer") and on networks whose
+    // issuer isn't in webpki. Set as an env var (not the CLI flag) so it's a
+    // no-op on uv versions that don't know it rather than an unknown-flag error;
+    // the flag was also renamed from --native-tls, and env vars dodge that churn.
+    // UV_HTTP_TIMEOUT lifts the per-request timeout for the ~20MB CPython download.
+    const uvEnv = { UV_SYSTEM_CERTS: "1", UV_HTTP_TIMEOUT: "300" };
+    const code = await run(uv, ["python", "install", version], onLine, { env: uvEnv });
+    if (code !== 0) {
+        onLine(`uv python install ${version} failed`);
+        return null;
+    }
+    const path = await capture(uv, ["python", "find", version], uvEnv);
+    if (path && existsSync(path))
+        return path;
+    onLine(`uv could not resolve a Python ${version} interpreter path after install`);
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melaya/runner",
-  "version": "1.1.31",
+  "version": "1.1.33",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,