@melaya/runner 1.1.68 → 1.1.70

package/dist/cli.js

@@ -17,7 +17,10 @@ import { Command } from "commander";
 import chalk from "chalk";
 import { reportInstallFailure } from "./installReport.js";
 import { connect } from "./connection.js";
-import { detectModels } from "./detect.js";
+import { scanProviders } from "./detect.js";
+import { isHosted, hostStatus, onHostMessage, sendToHost, waitForHostToken, exitHostedSoon } from "./hostChannel.js";
+import { markStage, onStage, startupComplete, startupTimings, formatStartupTimings } from "./startupTimings.js";
+import { readStartupCache, writeStartupCache } from "./startupCache.js";
 // Logo colors: cyan → blue → indigo gradient (matching melaya.org)
 const c1 = chalk.hex("#22D3EE").bold;
 const c2 = chalk.hex("#10B0F0").bold;
@@ -43,15 +46,55 @@ const BANNER = `
   ${br("▸")} ${dm("Local AI Pipeline Runner")}                      ${chalk.hex("#333")(`v${version}`)}
   ${br("─────────────────────────────────────────────────────")}
 `;
+// Inside the desktop app: give the last host message time to leave before exit.
+const flushHost = () => (isHosted() ? new Promise((r) => setTimeout(r, 300)) : Promise.resolve());
+// Desktop app "stop" (pause, disconnect, quit): run the graceful shutdown the
+// CLI already has for Ctrl+C. Newest SIGTERM handler first, so connection.ts
+// stops runs and assistant hosts before singleInstance.ts exits; the lock is
+// released on "exit" either way. Hard exit if nothing is listening yet.
+function stopHosted() {
+    const handlers = process.listeners("SIGTERM").slice().reverse();
+    exitHostedSoon(0, 5000);
+    for (const h of handlers) {
+        try {
+            h("SIGTERM");
+        }
+        catch { /* keep going */ }
+    }
+    if (handlers.length === 0)
+        process.exit(0);
+}
 async function main() {
+    const hosted = isHosted();
     const program = new Command()
         .name("melaya-runner")
-        .description("Run Melaya AI pipelines locally with your own models")
-        .requiredOption("--token <token>", "Runner token from the Melaya platform")
+        .description("Run Melaya AI pipelines locally with your own models");
+    // In the desktop app the token arrives over the host channel, never argv.
+    if (hosted)
+        program.option("--token <token>", "Runner token from the Melaya platform");
+    else
+        program.requiredOption("--token <token>", "Runner token from the Melaya platform");
+    program
         .option("--server <url>", "Server URL", "wss://api.melaya.org")
         .option("--verbose", "Show detailed logs", false)
+        .option("--computer", "Let Melaya agents operate allowed apps on this machine (headless Linux / VM)", false)
+        .option("--computer-helper <path>", "Path to the melaya-computer helper binary (default: MELAYA_COMPUTER_HELPER)")
+        .option("--diagnostics", "Print startup stage timings (config, socket, online, Python, model discovery)", false)
         .parse(process.argv);
     const opts = program.opts();
+    // --computer: this runner hosts the computer executor itself (computerHostCli.ts); the desktop app hosts its own.
+    if (opts.computer && !hosted) {
+        const { enableCliComputerHost } = await import("./computerHostCli.js");
+        enableCliComputerHost({ helperPath: opts.computerHelper, verbose: opts.verbose });
+    }
+    if (hosted) {
+        hostStatus("starting");
+        sendToHost({ type: "version", runnerVersion: version });
+        onHostMessage((msg) => { if (msg.type === "stop")
+            stopHosted(); });
+        opts.token = await waitForHostToken();
+    }
+    markStage("config");
     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
@@ -61,63 +104,139 @@ async function main() {
     const { acquireSingleInstanceLock } = await import("./singleInstance.js");
     const lock = acquireSingleInstanceLock();
     if (!lock.ok) {
+        hostStatus("blocked", `Another Melaya runner is already running on this computer (process ${lock.ownerPid}). Close it, then resume the runner.`);
         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.`));
         await reportInstallFailure("single_instance_locked", { token: opts.token, server: opts.server });
+        await flushHost();
         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
-    // 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) {
-        python = py.cmd;
-        console.log(chalk.green(`  ✓ Python: ${python} (3.${py.minor})`));
+    // Readiness (audit P1.2): connect FIRST with the last good model list from
+    // disk (or none), then resolve Python and scan model providers in parallel
+    // and publish the fresh list through `runner:models`. Before, Python probing,
+    // provisioning and a serial provider scan (up to ~24 s of timeouts) all ran
+    // before the socket even opened. Requests that need Python wait for it.
+    const cache = readStartupCache();
+    const pythonReady = resolvePython(cache.python);
+    const discovery = scanProviders();
+    const handle = await connect({
+        token: opts.token,
+        serverUrl: opts.server,
+        pythonPath: pythonReady,
+        models: cache.models ?? [],
+        verbose: opts.verbose,
+    });
+    say = (l) => handle.print(l);
+    // Desktop app: "rescan_models" after an engine launch or sign-in, so its models
+    // show up in seconds instead of at the next 15 min rescan.
+    if (hosted) {
+        onHostMessage((msg) => {
+            if (msg.type !== "rescan_models")
+                return;
+            void handle.rescanModels()
+                .then((models) => writeStartupCache({ models, modelsAt: Date.now() }))
+                .catch(() => { });
+        });
     }
-    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"));
-            await reportInstallFailure("python_missing", {
-                token: opts.token, server: opts.server,
-                detail: py.foundVersion ? `host=${py.foundVersion}` : "none",
-            });
-            process.exit(1);
+    // Fresh discovery: print it, publish it, remember it for the next start.
+    void discovery.then((scan) => {
+        reportModels(scan.models, (l) => handle.print(l));
+        if (opts.verbose || opts.diagnostics) {
+            const slow = scan.timedOut.length ? `; timed out: ${scan.timedOut.join(", ")}` : "";
+            handle.print(chalk.gray(`    model discovery ${scan.ms}ms (${Object.entries(scan.probeMs).map(([k, v]) => `${k} ${v}ms`).join(", ")}${slow})`));
+        }
+        handle.publishModels(scan.models);
+        writeStartupCache({ models: scan.models, modelsAt: Date.now() });
+        markStage("discovery_done");
+    }).catch(() => { markStage("discovery_done"); });
+    void pythonReady.then(async (python) => {
+        if (python) {
+            markStage("python_ready");
+            return;
+        }
+        // Same terminal failure as before the reorder: no usable Python, no runner.
+        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"));
+        await reportInstallFailure("python_missing", {
+            token: opts.token, server: opts.server,
+            detail: lastPythonFound ? `host=${lastPythonFound}` : "none",
+        });
+        hostStatus("error", `Could not set up Python 3.${PY_MAX_MINOR} for local AI runs. Check your internet connection, then resume the runner.`);
+        await flushHost();
+        process.exit(1);
+    });
+    // --diagnostics (and --verbose): the stage timeline once every stage is in, or after 2 min.
+    if (opts.diagnostics || opts.verbose) {
+        let printed = false;
+        const print = () => {
+            if (printed)
+                return;
+            printed = true;
+            const lines = formatStartupTimings().split("\n").map((l) => `    ${l}`).join("\n");
+            handle.print(chalk.gray(`\n  Startup timings (from process start):\n${lines}`));
+            if (opts.diagnostics)
+                handle.print(`startup-timings ${JSON.stringify(startupTimings().sinceStartMs)}`);
+        };
+        if (startupComplete())
+            print();
+        else {
+            const off = onStage(() => { if (startupComplete()) {
+                off();
+                print();
+            } });
+            setTimeout(() => { off(); print(); }, 120_000).unref?.();
         }
-        python = provisioned;
-        console.log(chalk.green(`  ✓ Python: ${python} (auto-provisioned 3.${PY_MAX_MINOR})`));
     }
-    // Detect local models
-    const models = await detectModels();
+}
+function reportModels(models, print) {
     if (models.length === 0) {
-        console.log(chalk.yellow("  ⚠ No local models detected (LM Studio / Ollama not running; Claude Code / Codex / GitHub Copilot not logged in)"));
-        console.log(chalk.gray("    Start LM Studio or Ollama, log in to Claude Code / Codex, or run `melaya-runner copilot login`, then restart the runner"));
+        print(chalk.yellow("  ⚠ No local models detected (LM Studio / Ollama not running; Claude Code / Codex / GitHub Copilot not logged in)"));
+        print(chalk.gray("    Start LM Studio or Ollama, log in to Claude Code / Codex, or run `melaya-runner copilot login`; the runner picks them up automatically"));
+        return;
     }
-    else {
-        for (const m of models) {
-            console.log(chalk.green(`  ✓ ${m.provider}: ${m.name}`));
+    for (const m of models)
+        print(chalk.green(`  ✓ ${m.provider}: ${m.name}`));
+}
+// The unsupported interpreter found during the last scan (for the failure report).
+let lastPythonFound;
+// Lines printed while the connect spinner may be spinning go through the
+// connection's printer once it exists (keeps the spinner line intact).
+let say = (l) => console.log(l);
+// Detect Python. Fast path: the interpreter that worked last time (one probe).
+// Then every candidate is probed IN PARALLEL (async, so the socket keeps
+// running) and the best one by preference order wins. 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.
+async function resolvePython(cached) {
+    if (cached?.cmd) {
+        const v = await probePyVersion(cached.cmd);
+        if (v && v.major === 3 && v.minor >= PY_MIN_MINOR && v.minor <= PY_MAX_MINOR) {
+            say(chalk.green(`  ✓ Python: ${cached.cmd} (3.${v.minor}${cached.provisioned ? ", auto-provisioned" : ""})`));
+            return cached.cmd;
         }
     }
-    console.log();
-    // Connect to the server
-    await connect({
-        token: opts.token,
-        serverUrl: opts.server,
-        pythonPath: python,
-        models,
-        verbose: opts.verbose,
-    });
+    const py = await findPython();
+    if (py.ok) {
+        say(chalk.green(`  ✓ Python: ${py.cmd} (3.${py.minor})`));
+        writeStartupCache({ python: { cmd: py.cmd, minor: py.minor } });
+        return py.cmd;
+    }
+    lastPythonFound = py.foundVersion;
+    say(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) => say(chalk.gray(`    ${m}`)));
+    if (!provisioned)
+        return null;
+    say(chalk.green(`  ✓ Python: ${provisioned} (auto-provisioned 3.${PY_MAX_MINOR})`));
+    writeStartupCache({ python: { cmd: provisioned, minor: PY_MAX_MINOR, provisioned: true } });
+    return provisioned;
 }
 // Supported CPython range for the runner's venv. agentscope and its native
 // deps (tiktoken, numpy, pydantic-core, curl_cffi via scrapling, sentence-
@@ -132,17 +251,21 @@ async function main() {
 const PY_MIN_MINOR = 10;
 const PY_MAX_MINOR = 12;
 async function probePyVersion(cmd) {
-    const { execSync } = await import("child_process");
-    try {
-        const out = execSync(`"${cmd}" --version`, { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }).trim();
-        const m = out.match(/Python (\d+)\.(\d+)/);
-        if (!m)
-            return null;
-        return { major: Number(m[1]), minor: Number(m[2]) };
-    }
-    catch {
-        return null;
-    }
+    const { execFile } = await import("child_process");
+    // Async (never blocks the socket) and no shell: the command is a fixed name or a cached path.
+    return new Promise((resolve) => {
+        try {
+            execFile(cmd, ["--version"], { encoding: "utf-8", timeout: 5000, windowsHide: true }, (err, stdout, stderr) => {
+                if (err)
+                    return resolve(null);
+                const m = `${stdout || ""}${stderr || ""}`.trim().match(/Python (\d+)\.(\d+)/);
+                resolve(m ? { major: Number(m[1]), minor: Number(m[2]) } : null);
+            });
+        }
+        catch {
+            resolve(null);
+        }
+    });
 }
 async function findPython() {
     const candidates = [];
@@ -165,17 +288,16 @@ async function findPython() {
     }
     // 3. Generic names last — accepted only if they resolve into the supported range.
     candidates.push("python3", "python");
+    // Probe all candidates at once; the preference order above still decides.
+    const unique = [...new Set(candidates)];
+    const versions = await Promise.all(unique.map((cmd) => probePyVersion(cmd)));
     let fallback; // a real 3.x that exists but is out of range
-    const seen = new Set();
-    for (const cmd of candidates) {
-        if (seen.has(cmd))
-            continue;
-        seen.add(cmd);
-        const v = await probePyVersion(cmd);
+    for (let i = 0; i < unique.length; i++) {
+        const v = versions[i];
         if (!v || v.major !== 3)
             continue;
         if (v.minor >= PY_MIN_MINOR && v.minor <= PY_MAX_MINOR)
-            return { ok: true, cmd, minor: v.minor };
+            return { ok: true, cmd: unique[i], minor: v.minor };
         if (!fallback)
             fallback = `Python ${v.major}.${v.minor}`;
     }
@@ -200,6 +322,8 @@ async function bootstrap() {
 }
 bootstrap().catch(async (e) => {
     console.error(chalk.red(`\n  Fatal: ${e.message}\n`));
+    // The full error goes to the app's log (stderr above); the status line stays generic.
+    hostStatus("error", "The runner stopped unexpectedly. Copy diagnostics for details.");
     // Token is parsed inside main(); recover it from argv so a crash BEFORE the
     // socket still reports. Only the STAGE is sent — never the error text, which
     // routinely carries file paths and usernames.
@@ -209,5 +333,6 @@ bootstrap().catch(async (e) => {
         token: tokArg ? tokArg.replace(/^--token[= ]?/, "") : undefined,
         server: srvArg ? srvArg.replace(/^--server[= ]?/, "") : undefined,
     });
+    await flushHost();
     process.exit(1);
 });

package/dist/codeWorker.js

@@ -63,8 +63,8 @@
 // kill verification (poll for exit; escalate; report kill_unverified if
 // the OS will not confirm death).
 import { spawn } from "node:child_process";
-import { writeFileSync, mkdirSync, existsSync } from "node:fs";
-import { join } from "node:path";
+import { writeFileSync, mkdirSync, existsSync, realpathSync } from "node:fs";
+import { join, dirname } from "node:path";
 import { createInterface } from "node:readline";
 export const DEFAULT_LIMITS = {
     wallClockMs: 60_000,
@@ -253,6 +253,14 @@ function buildSandboxedCommand(scratchDir, entryPath, limits) {
             // The node dyld shared cache path varies by macOS version; the
             // /System/Volumes/Preboot allowance covers macOS 13+.
             const nodeDir = nodeBin.replace(/\/[^/]+$/, "");
+            // Node resolves the entry script with realpathSync, which lstat()s
+            // every ancestor directory: allow metadata (stat only, no contents)
+            // on exactly those ancestors, nothing else. scratchDir is already a
+            // real path here (see runSandboxedScript).
+            const ancestorMeta = [];
+            for (let p = dirname(scratchDir); p !== "/"; p = dirname(p)) {
+                ancestorMeta.push(`(allow file-read-metadata (literal "${p}"))`);
+            }
             const profile = [
                 "(version 1)",
                 "(deny default)",
@@ -263,6 +271,10 @@ function buildSandboxedCommand(scratchDir, entryPath, limits) {
                 // Node's own scratch dir: full read/write.
                 `(allow file-read* (subpath "${scratchDir}"))`,
                 `(allow file-write* (subpath "${scratchDir}"))`,
+                ...ancestorMeta,
+                // Node aborts during process init (SIGABRT) unless it can read
+                // the root directory itself (not its subtree).
+                "(allow file-read-data (literal \"/\"))",
                 // macOS system libraries and dyld shared cache.
                 "(allow file-read* (subpath \"/System/Library\"))",
                 "(allow file-read* (subpath \"/System/Volumes\"))",
@@ -283,23 +295,23 @@ function buildSandboxedCommand(scratchDir, entryPath, limits) {
                 "(allow ipc-posix-shm-read-data)",
                 "(allow ipc-posix-shm-write-data)",
             ].join("\n");
-            // Memory and CPU caps via a shell `ulimit` wrapper around sandbox-exec.
-            // ulimit -v: virtual address space in KB (4x heap for runtime headroom).
-            // ulimit -t: hard CPU time in seconds.
-            // We use /bin/sh -c "ulimit ...; exec sandbox-exec ..." so both limits
-            // apply before the Node process starts. This is a soft-then-hard pair;
-            // SIGKILL from the parent wall-clock timer is the backstop.
-            const asKb = memMb * 4 * 1024;
-            const shellCmd = `ulimit -v ${asKb} -t ${cpuSec}; exec /usr/bin/sandbox-exec -p '${profile.replace(/'/g, "'\\''")}' ${JSON.stringify(nodeBin)} ${nodeArgs.map((a) => JSON.stringify(a)).join(" ")}`;
+            // CPU cap via a shell `ulimit` wrapper around sandbox-exec.
+            // ulimit -t: hard CPU time in seconds, applied before Node starts;
+            // `&&` refuses to start the worker if the cap cannot be set.
+            // HONEST LIMIT: macOS does not support RLIMIT_AS (`ulimit -v` fails
+            // with EINVAL and, chained with -t, used to skip the CPU cap too), so
+            // memory is capped by --max-old-space-size only. SIGKILL from the
+            // parent wall-clock timer is the backstop.
+            const shellCmd = `ulimit -t ${cpuSec} && exec /usr/bin/sandbox-exec -p '${profile.replace(/'/g, "'\\''")}' ${JSON.stringify(nodeBin)} ${nodeArgs.map((a) => JSON.stringify(a)).join(" ")}`;
             return {
                 cmd: "/bin/sh",
                 args: ["-c", shellCmd],
                 sandbox: "seatbelt",
             };
         }
-        // No sandbox-exec: fall back to permission model + ulimit wrapper.
-        const asKb = memMb * 4 * 1024;
-        const shellCmd = `ulimit -v ${asKb} -t ${cpuSec}; exec ${JSON.stringify(nodeBin)} ${nodeArgs.map((a) => JSON.stringify(a)).join(" ")}`;
+        // No sandbox-exec: fall back to permission model + ulimit wrapper
+        // (CPU cap only, see the RLIMIT_AS note above).
+        const shellCmd = `ulimit -t ${cpuSec} && exec ${JSON.stringify(nodeBin)} ${nodeArgs.map((a) => JSON.stringify(a)).join(" ")}`;
         return {
             cmd: "/bin/sh",
             args: ["-c", shellCmd],
@@ -348,14 +360,18 @@ export async function runSandboxedScript(opts) {
     const consoleLines = [];
     const traces = [];
     mkdirSync(opts.scratchDir, { recursive: true });
-    const entryPath = join(opts.scratchDir, "melaya-code-worker.cjs");
+    // macOS: os.tmpdir() is /var/folders/..., a symlink to /private/var/...
+    // Seatbelt and the Node permission model both check resolved paths, so
+    // the worker is given the real path everywhere.
+    const scratchDir = process.platform === "darwin" ? realpathSync(opts.scratchDir) : opts.scratchDir;
+    const entryPath = join(scratchDir, "melaya-code-worker.cjs");
     writeFileSync(entryPath, WORKER_ENTRY_SOURCE, "utf-8");
-    const { cmd, args, sandbox } = buildSandboxedCommand(opts.scratchDir, entryPath, limits);
+    const { cmd, args, sandbox } = buildSandboxedCommand(scratchDir, entryPath, limits);
     let child;
     try {
         child = spawn(cmd, args, {
-            cwd: opts.scratchDir,
-            env: sanitizedEnv(opts.scratchDir),
+            cwd: scratchDir,
+            env: sanitizedEnv(scratchDir),
             // ONLY stdio pipes are inherited; Node does not pass extra fds
             // unless they are listed here, which closes the inherited-fd
             // channel (plan 0.7).

package/dist/computerHelperManifest.d.ts

@@ -0,0 +1,5 @@
+export declare const COMPUTER_HELPER_VERSION = "1.0.1";
+export declare const COMPUTER_HELPER_MANIFEST: Record<string, {
+    url: string;
+    sha256: string;
+} | undefined>;

package/dist/computerHelperManifest.js

@@ -0,0 +1,18 @@
+// GENERATED by .github/scripts/write-computer-helper-manifest.mjs in desktop-release.yml.
+// Do not edit by hand: commit the file the release job uploads (artifact
+// "computer-helper-manifest") once the helpers are published at these URLs.
+//
+// Pinned computer helper releases for the runner CLI host (computerHostCli.ts),
+// keyed by `${process.platform}-${process.arch}`. A download is only accepted
+// when its sha256 matches.
+export const COMPUTER_HELPER_VERSION = "1.0.1";
+export const COMPUTER_HELPER_MANIFEST = {
+    "linux-arm64": {
+        "url": "https://api.melaya.org/desktop/helpers/1.0.1/melaya-computer-linux-aarch64",
+        "sha256": "f5e6825fc00b589178b0540ed6f2e350dc8ac77bb97e08ae17395282465fec36"
+    },
+    "linux-x64": {
+        "url": "https://api.melaya.org/desktop/helpers/1.0.1/melaya-computer-linux-x86_64",
+        "sha256": "795933f10803f2bc25c95207e5a196ff6413e2e55f038ccd54c3f6f19e7c764c"
+    }
+};