@melaya/runner 1.1.69 → 1.1.71

package/dist/cli.js

@@ -128,6 +128,17 @@ async function main() {
         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(() => { });
+        });
+    }
     // Fresh discovery: print it, publish it, remember it for the next start.
     void discovery.then((scan) => {
         reportModels(scan.models, (l) => handle.print(l));

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

@@ -1,4 +1,4 @@
-export declare const COMPUTER_HELPER_VERSION = "1.0.0";
+export declare const COMPUTER_HELPER_VERSION = "1.0.1";
 export declare const COMPUTER_HELPER_MANIFEST: Record<string, {
     url: string;
     sha256: string;

package/dist/computerHelperManifest.js

@@ -5,5 +5,14 @@
 // 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.0";
-export const COMPUTER_HELPER_MANIFEST = {};
+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"
+    }
+};

package/dist/computerHostCli.d.ts

@@ -120,7 +120,7 @@ export declare function checkCommand(msg: {
  * accepted when its sha256 matches. Empty until the first release: use
  * MELAYA_COMPUTER_HELPER or --computer-helper meanwhile.
  */
-export declare const HELPER_VERSION = "1.0.0";
+export declare const HELPER_VERSION = "1.0.1";
 export declare const HELPER_MANIFEST: Record<string, {
     url: string;
     sha256: string;

package/dist/computerHostCli.js

@@ -140,6 +140,13 @@ export function requiredTierOf(action) {
  */
 export const HARD_DENY_SOURCES = [
     "melaya",
+    // password managers and one-time-code apps (same list as the desktop app's HARD_DENY_PATTERNS,
+    // desktop/src/main/computer/allowlist.ts: the Windows helper has no built-in list of its own)
+    "1password|agilebits|bitwarden|keepass|lastpass|dashlane|nordpass|roboform|enpass|keepersecurity",
+    "\\bkeeper (password|desktop)|proton ?pass|\\bauthy\\b|authenticator|yubico",
+    "keychain ?access|com\\.apple\\.keychainaccess|com\\.apple\\.passwords|^passwords$",
+    // Windows Security
+    "sechealthui|securityhealth",
     // authentication prompts and privilege elevation
     "polkit|pkexec|gksu|kdesu|lxsudo",
     "pinentry|gcr-prompter|gnome-keyring|ssh-askpass|ksshaskpass|kwalletd",

package/dist/connection.d.ts

@@ -25,6 +25,12 @@ interface ConnectOpts {
 export interface RunnerConnection {
     /** Replace the model list and push it through `runner:models` when it changed. */
     publishModels(models: DetectedModel[]): void;
+    /**
+     * Forced rescan now (desktop app "rescan_models"): scanProviders({ force: true }),
+     * then publish like the periodic rescan. Coalesced: requests share a scan in
+     * flight, at most one forced scan per 5 s (modelRescan.ts). Resolves with the list.
+     */
+    rescanModels(): Promise<DetectedModel[]>;
     /** console.log that keeps the connect spinner intact. */
     print(line: string): void;
 }

package/dist/connection.js

@@ -29,6 +29,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { ensureSharedModules, getSharedDir } from "./sharedVendor.js";
 import { scanProviders, providerFingerprint } from "./detect.js";
+import { createForcedRescan } from "./modelRescan.js";
 import { startLumaBrowserBridge } from "./lumaBrowserBridge.js";
 // Melaya Browser (plan Sections 3/4/7): the governed browser control
 // bridge + its runner-side grant verifier and engine discovery.
@@ -542,6 +543,27 @@ export async function connect(opts) {
         }, MODEL_REFRESH_MS);
         modelRefresh.unref?.();
     };
+    // Forced rescan on request (desktop app after an engine launch / sign-in).
+    // Same publish path as the periodic rescan; also resets its change detection.
+    const forcedRescan = createForcedRescan({
+        scan: async () => {
+            const fp = await providerFingerprint().catch(() => "");
+            const scan = await scanProviders({ force: true });
+            if (fp)
+                lastFingerprint = fp;
+            lastScanAt = Date.now();
+            return scan.models;
+        },
+        publish: (models) => {
+            if (opts.verbose)
+                print(chalk.gray(`  [models] forced rescan: ${models.length} model(s)`));
+            publishModels(models);
+        },
+    });
+    const rescanModels = async () => {
+        await forcedRescan.request();
+        return opts.models;
+    };
     socket.on("connect", async () => {
         spinner.succeed(chalk.green("Connected to Melaya"));
         markStage("socket_connected");
@@ -3341,6 +3363,7 @@ export async function connect(opts) {
             clearInterval(modelRefresh);
             modelRefresh = null;
         }
+        forcedRescan.dispose();
         if (bgTimer) {
             clearInterval(bgTimer);
             bgTimer = null;
@@ -3389,7 +3412,7 @@ export async function connect(opts) {
     claimGracefulShutdown();
     process.on("SIGINT", cleanup);
     process.on("SIGTERM", cleanup);
-    return { publishModels, print };
+    return { publishModels, rescanModels, print };
 }
 export function verifySignature(content, signature, runnerToken) {
     if (!content || !signature || !runnerToken)

package/dist/detect.js

@@ -111,6 +111,16 @@ async function detectClaudeCode(force = false) {
             const names = await fetchClaudeFamilies(oauth.accessToken, force);
             return names.map((name) => ({ provider: "claude_code", name }));
         }
+        // The short-lived access token expired but the sign-in is still valid: the
+        // CLI only renews it when `claude` runs, and the runtime renews it through
+        // the CLI on first use (model.py _refresh_claude_oauth_via_cli). Report the
+        // user as signed in (known aliases; no API call with an expired token)
+        // instead of "not signed in". Never consume the refresh token here.
+        const refreshExpiresAt = Number(oauth.refreshTokenExpiresAt ?? 0);
+        if (oauth.accessToken && oauth.refreshToken && (!refreshExpiresAt || Date.now() < refreshExpiresAt)) {
+            const cached = networkCacheGet(`claude:${tokenKey(oauth.accessToken)}`, false);
+            return (cached ?? CLAUDE_ALIASES_FALLBACK).map((name) => ({ provider: "claude_code", name }));
+        }
     }
     catch { /* malformed creds → treat as logged out */ }
     return []; // not logged in / expired → don't advertise models
@@ -209,8 +219,10 @@ async function detectGithubCopilotWith(gh) {
             },
             signal: AbortSignal.timeout(6000),
         });
+        // No Copilot seat / revoked token → don't advertise (cached). Anything else
+        // (429, 5xx) is transient: null so it is not cached as "not signed in".
         if (!ex.ok)
-            return []; // no Copilot seat / revoked → don't advertise
+            return ex.status === 401 || ex.status === 403 || ex.status === 404 ? [] : null;
         const exd = (await ex.json());
         if (!exd.token)
             return [];

package/dist/hostChannel.d.ts

@@ -86,6 +86,10 @@ export type HostToRunnerMessage = {
 } | {
     type: "start";
     token: string;
+}
+/** Additive: rescan model providers now and publish the list through runner:models. */
+ | {
+    type: "rescan_models";
 } | {
     type: "computer.result";
     id: string;

package/dist/modelRescan.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Forced model rescans on request.
+ *
+ * The runner rescans its model providers every 15 min (connection.ts). When
+ * the desktop app launches an engine (Ollama / LM Studio started, a Claude
+ * Code / Codex / Copilot sign-in finished) it sends { type: "rescan_models" }
+ * (hostChannel.ts), so the new models reach Melaya in seconds instead.
+ *
+ * Requests are cheap to send and may arrive in bursts (the app after a launch,
+ * the web page every 10 s while it waits), so:
+ *   - a request while a forced scan runs shares that scan;
+ *   - at most one forced scan starts per `minIntervalMs` (5 s);
+ *   - a request inside that window is not dropped: it schedules one trailing
+ *     scan at the end of the window, shared by every request until then.
+ */
+export interface ForcedRescanOptions<T> {
+    /** One forced provider scan (scanProviders({ force: true })). */
+    scan: () => Promise<T>;
+    /** Publish the result the way the periodic rescan does (runner:models). */
+    publish: (result: T) => void;
+    /** Minimum gap between two forced scan starts. Default 5 s. */
+    minIntervalMs?: number;
+    /** Called when a scan or publish throws; the last good list stays. */
+    onError?: (e: unknown) => void;
+    /** Test seams. */
+    now?: () => number;
+    setTimer?: (fn: () => void, ms: number) => () => void;
+}
+export interface ForcedRescan {
+    /** Ask for a forced rescan. Resolves once the scan that serves it has published (or failed). */
+    request(): Promise<void>;
+    /** Cancel a pending trailing scan (shutdown). */
+    dispose(): void;
+}
+export declare const FORCED_RESCAN_MIN_INTERVAL_MS = 5000;
+export declare function createForcedRescan<T>(opts: ForcedRescanOptions<T>): ForcedRescan;

package/dist/modelRescan.js

@@ -0,0 +1,80 @@
+/**
+ * Forced model rescans on request.
+ *
+ * The runner rescans its model providers every 15 min (connection.ts). When
+ * the desktop app launches an engine (Ollama / LM Studio started, a Claude
+ * Code / Codex / Copilot sign-in finished) it sends { type: "rescan_models" }
+ * (hostChannel.ts), so the new models reach Melaya in seconds instead.
+ *
+ * Requests are cheap to send and may arrive in bursts (the app after a launch,
+ * the web page every 10 s while it waits), so:
+ *   - a request while a forced scan runs shares that scan;
+ *   - at most one forced scan starts per `minIntervalMs` (5 s);
+ *   - a request inside that window is not dropped: it schedules one trailing
+ *     scan at the end of the window, shared by every request until then.
+ */
+export const FORCED_RESCAN_MIN_INTERVAL_MS = 5_000;
+function defaultTimer(fn, ms) {
+    const t = setTimeout(fn, ms);
+    t.unref?.();
+    return () => clearTimeout(t);
+}
+export function createForcedRescan(opts) {
+    const minGap = opts.minIntervalMs ?? FORCED_RESCAN_MIN_INTERVAL_MS;
+    const now = opts.now ?? Date.now;
+    const setTimer = opts.setTimer ?? defaultTimer;
+    let inFlight = null;
+    let lastStart = Number.NEGATIVE_INFINITY;
+    let trailing = null;
+    let disposed = false;
+    const run = () => {
+        lastStart = now();
+        const p = (async () => {
+            try {
+                opts.publish(await opts.scan());
+            }
+            catch (e) {
+                try {
+                    opts.onError?.(e);
+                }
+                catch { /* ignore */ }
+            }
+        })().finally(() => { if (inFlight === p)
+            inFlight = null; });
+        inFlight = p;
+        return p;
+    };
+    return {
+        request() {
+            if (disposed)
+                return Promise.resolve();
+            if (inFlight)
+                return inFlight;
+            if (trailing)
+                return trailing.promise;
+            const wait = lastStart + minGap - now();
+            if (wait <= 0)
+                return run();
+            let resolve;
+            const promise = new Promise((r) => { resolve = r; });
+            const cancel = setTimer(() => {
+                trailing = null;
+                if (disposed) {
+                    resolve();
+                    return;
+                }
+                (inFlight ?? run()).then(resolve, resolve);
+            }, wait);
+            trailing = { promise, cancel, resolve };
+            return promise;
+        },
+        dispose() {
+            disposed = true;
+            if (trailing) {
+                trailing.cancel();
+                trailing.resolve();
+                trailing = null;
+            }
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melaya/runner",
-  "version": "1.1.69",
+  "version": "1.1.71",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "Apache-2.0",
   "author": "Melaya Labs LLC",