@melaya/runner 1.1.32 → 1.1.34

package/dist/cli.js

@@ -52,6 +52,19 @@ async function main() {
         .parse(process.argv);
     const opts = program.opts();
     console.log(BANNER);
+    // Single-instance guard: refuse to start if another runner is already running
+    // on this machine. Two runners for one user fight over a single server-side
+    // session (connect/disconnect churn, turns landing on the wrong host), so we
+    // stop the second launch up front rather than let them compete. A stale lock
+    // from a crashed runner is reclaimed automatically.
+    const { acquireSingleInstanceLock } = await import("./singleInstance.js");
+    const lock = acquireSingleInstanceLock();
+    if (!lock.ok) {
+        console.log(chalk.red(`  ✗ A Melaya runner is already running on this machine (pid ${lock.ownerPid}).`));
+        console.log(chalk.gray("    Only one runner can run per machine. Stop the other one first"));
+        console.log(chalk.gray(`    (e.g. \`kill ${lock.ownerPid}\`, or close its terminal), then start again.`));
+        process.exit(1);
+    }
     // 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

package/dist/singleInstance.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Single-instance guard for the runner.
+ *
+ * Two `@melaya/runner` processes for the same user fight over one server-side
+ * session: the server routes an assistant/pipeline turn to ONE socket, so a
+ * second runner produces connect/disconnect churn, split state, and turns that
+ * land on the wrong host. This lock makes a second launch on the same machine
+ * refuse up front ("can't start if another is already open") instead of quietly
+ * competing.
+ *
+ * Machine-scoped by design: it prevents the common footgun (double-launching on
+ * one box). It does NOT stop a runner on a *different* machine — that's a
+ * legitimate multi-device case, and the server's own per-user limit + the
+ * session reattach logic handle cross-machine arbitration.
+ *
+ * The lock is a small JSON file holding the owning pid. A stale lock (owner pid
+ * no longer alive — e.g. a hard kill that skipped cleanup) is reclaimed
+ * automatically, so a crash never permanently blocks the next start.
+ */
+export type LockResult = {
+    ok: true;
+} | {
+    ok: false;
+    ownerPid: number;
+};
+/**
+ * Try to acquire the machine-wide runner lock. Returns {ok:true} and installs
+ * process-exit cleanup on success; {ok:false, ownerPid} if a live runner
+ * already holds it. A stale lock (dead owner) is reclaimed.
+ */
+export declare function acquireSingleInstanceLock(): LockResult;

package/dist/singleInstance.js

@@ -0,0 +1,116 @@
+/**
+ * Single-instance guard for the runner.
+ *
+ * Two `@melaya/runner` processes for the same user fight over one server-side
+ * session: the server routes an assistant/pipeline turn to ONE socket, so a
+ * second runner produces connect/disconnect churn, split state, and turns that
+ * land on the wrong host. This lock makes a second launch on the same machine
+ * refuse up front ("can't start if another is already open") instead of quietly
+ * competing.
+ *
+ * Machine-scoped by design: it prevents the common footgun (double-launching on
+ * one box). It does NOT stop a runner on a *different* machine — that's a
+ * legitimate multi-device case, and the server's own per-user limit + the
+ * session reattach logic handle cross-machine arbitration.
+ *
+ * The lock is a small JSON file holding the owning pid. A stale lock (owner pid
+ * no longer alive — e.g. a hard kill that skipped cleanup) is reclaimed
+ * automatically, so a crash never permanently blocks the next start.
+ */
+import { mkdirSync, readFileSync, unlinkSync, openSync, writeSync, closeSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const CACHE_DIR = join(homedir(), ".melaya-runner");
+const LOCK_PATH = join(CACHE_DIR, "runner.lock");
+function pidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        // Signal 0 does not send a signal — it only checks the process exists.
+        // Throws ESRCH if gone, EPERM if alive but owned by another user (still
+        // "alive" for our purposes). Works on Windows too.
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e?.code === "EPERM";
+    }
+}
+/**
+ * Try to acquire the machine-wide runner lock. Returns {ok:true} and installs
+ * process-exit cleanup on success; {ok:false, ownerPid} if a live runner
+ * already holds it. A stale lock (dead owner) is reclaimed.
+ */
+export function acquireSingleInstanceLock() {
+    mkdirSync(CACHE_DIR, { recursive: true });
+    const writeOwn = () => {
+        // O_EXCL create: fails if the file already exists, which makes the
+        // check-and-claim atomic against another runner racing to start.
+        const fd = openSync(LOCK_PATH, "wx");
+        try {
+            writeSync(fd, JSON.stringify({ pid: process.pid, startedAt: Date.now() }));
+        }
+        finally {
+            closeSync(fd);
+        }
+    };
+    try {
+        writeOwn();
+    }
+    catch (e) {
+        if (e?.code !== "EEXIST")
+            throw e;
+        // A lock exists — is its owner still alive?
+        let ownerPid = 0;
+        try {
+            ownerPid = Number(JSON.parse(readFileSync(LOCK_PATH, "utf-8"))?.pid) || 0;
+        }
+        catch {
+            ownerPid = 0;
+        }
+        if (ownerPid && ownerPid !== process.pid && pidAlive(ownerPid)) {
+            return { ok: false, ownerPid };
+        }
+        // Stale (dead owner) or unreadable — reclaim it.
+        try {
+            unlinkSync(LOCK_PATH);
+        }
+        catch { /* someone else may have just cleaned it */ }
+        try {
+            writeOwn();
+        }
+        catch (e2) {
+            // Lost a reclaim race to another starting runner.
+            if (e2?.code === "EEXIST") {
+                let pid2 = 0;
+                try {
+                    pid2 = Number(JSON.parse(readFileSync(LOCK_PATH, "utf-8"))?.pid) || 0;
+                }
+                catch {
+                    pid2 = 0;
+                }
+                return { ok: false, ownerPid: pid2 || -1 };
+            }
+            throw e2;
+        }
+    }
+    // Release the lock on every normal or signalled exit. Only unlink if WE still
+    // own it, so a reclaimed-after-crash successor never deletes the live owner's.
+    let released = false;
+    const release = () => {
+        if (released)
+            return;
+        released = true;
+        try {
+            const held = Number(JSON.parse(readFileSync(LOCK_PATH, "utf-8"))?.pid) || 0;
+            if (held === process.pid)
+                unlinkSync(LOCK_PATH);
+        }
+        catch { /* already gone */ }
+    };
+    process.on("exit", release);
+    for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+        process.on(sig, () => { release(); process.exit(0); });
+    }
+    return { ok: true };
+}

package/dist/uvBootstrap.js

@@ -57,9 +57,10 @@ function findOnPath(bin) {
 }
 // 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, inactivityMs = 5 * 60_000) {
+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 });
+        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)
@@ -85,15 +86,38 @@ function run(cmd, args, onLine, inactivityMs = 5 * 60_000) {
         bump();
     });
 }
-function capture(cmd, args) {
+function capture(cmd, args, env = {}) {
     return new Promise((resolve) => {
         let out = "";
-        const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"], env: process.env });
+        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 {
@@ -154,9 +178,9 @@ async function downloadUv(onLine) {
         return null;
     }
     onLine("extracting uv");
-    const code = await run("tar", ["-xf", archivePath, "-C", tmp], onLine);
-    if (code !== 0) {
-        onLine("tar extraction of uv failed (is `tar` available?)");
+    const extracted = await extractArchive(archivePath, asset, tmp, onLine);
+    if (!extracted) {
+        onLine("extraction of the uv archive failed");
         return null;
     }
     const found = findBinaryRecursive(tmp, uvBinName());
@@ -200,12 +224,20 @@ export async function provisionPython(version, onLine) {
     if (!uv)
         return null;
     onLine(`installing a managed Python ${version} (one-time; ~30-60s)`);
-    const code = await run(uv, ["python", "install", version], onLine);
+    // 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]);
+    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`);

package/package.json

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