mu-agent 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-10-24
+
+**0.2.1 makes mude 1.0 the recommended judge on a Mac, set up from `mu setup`, and its install survives a power cut.**
+
+### Added
+
+- `mu setup` offers mude 1.0 in its judge step on a Mac that can run it (Apple silicon, macOS 14 or later, 8 GB of memory or more). It is the first choice and the recommended one, so pressing Enter picks it; the Jev that was recommended before follows it and stays a choice. Picking it writes Jev as the judge, then installs mude 1.0 in front of it in the same terminal, with its progress. If the install doesn't finish, Jev stays the judge and `mu judge mude install` goes on from where it stopped. Scripts use `--judge mude`. On other machines the judge step is as before: free Jev is first and recommended.
+
+### Fixed
+
+- `mu judge mude install` survives a power cut in the middle of the download. Every 32 MiB the partly downloaded file is synced to the disk and the amount on disk is recorded in `<file>.part.saved`. The next install goes on from there, so it never builds on an end the disk didn't keep. A part left by mu 0.2.0, which has no record, goes on from 32 MiB before its end.
+- A resumed file that fails its sha256 check is downloaded once more from the start, instead of ending the install.
+- The download rides out a lost connection: a try that gets some of the file starts the count of failed tries again. Tries that get nothing wait 2, 5, 10, 20 and then 30 s, about two minutes in all, before the install stops.
+- Ctrl-C, or the desktop app ending an install, stops the download where it is, keeps what it got and says how much: "Stopped with 0.9 of 1.8 GB downloaded: mu judge mude install goes on from there". An install that goes on says how much is already there.
+- An install that goes on from one that stopped keeps that one's `--local-only`: it is recorded in `install.json` until the install finishes. Before, running it again without the flag left the hosted judges behind mude.
+
 ## [0.2.0] - 2026-10-23
 
 **0.2.0 starts the era of mu's own models: `mu judge mude install` turns on mude 1.0 in one command.**

package/judge/dist/mude.js

@@ -641,19 +641,21 @@ function readText(path) {
 import { createHash } from "node:crypto";
 import {
   createReadStream,
-  createWriteStream,
   existsSync as existsSync3,
   mkdirSync as mkdirSync3,
   readFileSync as readFileSync4,
   renameSync as renameSync2,
   rmSync as rmSync2,
   statSync as statSync3,
+  truncateSync,
   writeFileSync as writeFileSync4
 } from "node:fs";
+import { open } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname as dirname2, join as join3 } from "node:path";
-import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
+var CHECKPOINT_BYTES = 32 * 1024 * 1024;
+var RETRY_WAITS = [2e3, 5e3, 1e4, 2e4, 3e4];
 function huggingFaceToken(env = process.env, home = homedir()) {
   const direct = env.HF_TOKEN?.trim();
   if (direct) return direct;
@@ -755,42 +757,70 @@ async function downloadFiles(options) {
       }
       rmSync2(target, { force: true });
     }
-    await fetchFile(
-      options,
-      file,
-      target,
-      (bytes) => options.onProgress?.({ file: file.path, checking: false, done: settled + bytes, total })
-    );
-    options.onProgress?.({ file: file.path, checking: true, done: settled + file.size, total });
     const part = `${target}.part`;
-    const actual = await sha256File(part);
+    const onBytes = (bytes) => options.onProgress?.({ file: file.path, checking: false, done: settled + bytes, total });
+    let resumed = await fetchFile(options, file, part, onBytes);
+    options.onProgress?.({ file: file.path, checking: true, done: settled + file.size, total });
+    let actual = await sha256File(part);
+    if (actual !== file.sha256 && resumed) {
+      dropPart(part);
+      resumed = await fetchFile(options, file, part, onBytes);
+      options.onProgress?.({ file: file.path, checking: true, done: settled + file.size, total });
+      actual = await sha256File(part);
+    }
     if (actual !== file.sha256) {
-      rmSync2(part, { force: true });
+      dropPart(part);
       throw new DownloadError(
         `${file.path} does not match its pinned sha256 (got ${actual.slice(0, 12)}\u2026, want ${file.sha256.slice(0, 12)}\u2026); it was removed`,
         "integrity"
       );
     }
     renameSync2(part, target);
+    rmSync2(savedPath(part), { force: true });
     remember(dir, verified, file);
     settled += file.size;
   }
   options.onProgress?.({ file: "", checking: false, done: total, total });
 }
-async function fetchFile(options, file, target, onBytes) {
-  const part = `${target}.part`;
-  const attempts = options.attempts ?? 4;
+var savedPath = (part) => `${part}.saved`;
+function dropPart(part) {
+  rmSync2(part, { force: true });
+  rmSync2(savedPath(part), { force: true });
+}
+function resumeFrom(part, size, checkpointBytes = CHECKPOINT_BYTES) {
+  const have = Math.min(sizeOf(part), size);
+  let saved;
+  try {
+    const value = Number.parseInt(readFileSync4(savedPath(part), "utf8").trim(), 10);
+    if (Number.isSafeInteger(value) && value >= 0) saved = value;
+  } catch {
+  }
+  return saved === void 0 ? Math.max(0, have - checkpointBytes) : Math.min(saved, have);
+}
+function writeSaved(part, bytes) {
+  const path = savedPath(part);
+  writeFileSync4(`${path}.tmp`, `${bytes}
+`);
+  renameSync2(`${path}.tmp`, path);
+}
+async function fetchFile(options, file, part, onBytes) {
+  const attempts = options.attempts ?? 8;
   const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let resumed = false;
+  let failures = 0;
   let lastError;
-  for (let attempt = 1; attempt <= attempts; attempt++) {
+  for (; ; ) {
     if (options.signal?.aborted) throw new DownloadError("The download was stopped", "aborted");
+    const before = resumeFrom(part, file.size, options.checkpointBytes);
     try {
-      await fetchOnce(options, file, part, onBytes);
-      return;
+      resumed = await fetchOnce(options, file, part, onBytes) || resumed;
+      return resumed;
     } catch (error) {
       if (error instanceof DownloadError && error.kind !== "network") throw error;
       lastError = error;
-      if (attempt < attempts) await sleep([2e3, 5e3, 1e4][attempt - 1] ?? 1e4);
+      failures = resumeFrom(part, file.size, options.checkpointBytes) > before ? 1 : failures + 1;
+      if (failures >= attempts) break;
+      await sleep(RETRY_WAITS[Math.min(failures, RETRY_WAITS.length) - 1]);
     }
   }
   const reason = lastError instanceof Error ? lastError.message : String(lastError);
@@ -800,21 +830,20 @@ async function fetchFile(options, file, target, onBytes) {
   );
 }
 async function fetchOnce(options, file, part, onBytes) {
-  let have = 0;
-  try {
-    have = statSync3(part).size;
-  } catch {
-  }
-  if (have > file.size) {
-    rmSync2(part, { force: true });
-    have = 0;
+  const checkpointBytes = options.checkpointBytes ?? CHECKPOINT_BYTES;
+  let have = resumeFrom(part, file.size, checkpointBytes);
+  if (have === file.size) {
+    if (sizeOf(part) > file.size) truncateSync(part, file.size);
+    return true;
   }
-  if (have === file.size) return;
   const controller = new AbortController();
   const stallMs = options.stallMs ?? 6e4;
   let stall = setTimeout(() => controller.abort(new Error(`no data for ${stallMs / 1e3} s`)), stallMs);
   const onAbort = () => controller.abort(options.signal?.reason);
   options.signal?.addEventListener("abort", onAbort, { once: true });
+  let handle;
+  let written = 0;
+  let synced = 0;
   try {
     const headers = {};
     if (have > 0) headers.Range = `bytes=${have}-`;
@@ -830,30 +859,52 @@ async function fetchOnce(options, file, part, onBytes) {
         "access"
       );
     }
-    if (response.status === 416 && have > 0) {
-      return;
+    if (response.status === 416) {
+      dropPart(part);
+      throw new Error("HTTP 416");
     }
     if (!response.ok || !response.body) throw new Error(`HTTP ${response.status}`);
-    const resumed = response.status === 206;
+    const resumed = response.status === 206 && have > 0;
     if (!resumed) have = 0;
-    const out = createWriteStream(part, { flags: resumed ? "a" : "w" });
-    let received = have;
-    onBytes(received);
-    const body = Readable.fromWeb(response.body);
-    body.on("data", (chunk) => {
-      received += chunk.length;
+    mkdirSync3(dirname2(part), { recursive: true });
+    handle = await open(part, existsSync3(part) ? "r+" : "w");
+    await handle.truncate(have);
+    writeSaved(part, have);
+    written = have;
+    synced = have;
+    onBytes(written);
+    const reader = response.body.getReader();
+    for (; ; ) {
+      const { done, value: chunk } = await reader.read();
+      if (done) break;
       clearTimeout(stall);
       stall = setTimeout(() => controller.abort(new Error(`no data for ${stallMs / 1e3} s`)), stallMs);
-      onBytes(received);
-    });
-    await pipeline(body, out);
-    if (received !== file.size) throw new Error(`got ${received} of ${file.size} bytes`);
+      if (written + chunk.length > file.size) throw new Error(`got more than the ${file.size} bytes of the file`);
+      await handle.write(chunk, 0, chunk.length, written);
+      written += chunk.length;
+      if (written - synced >= checkpointBytes) {
+        await handle.sync();
+        synced = written;
+        writeSaved(part, synced);
+      }
+      onBytes(written);
+    }
+    if (written !== file.size) throw new Error(`got ${written} of ${file.size} bytes`);
+    return resumed;
   } catch (error) {
     if (options.signal?.aborted) throw new DownloadError("The download was stopped", "aborted");
     throw error;
   } finally {
     clearTimeout(stall);
     options.signal?.removeEventListener("abort", onAbort);
+    if (handle) {
+      try {
+        await handle.sync();
+        if (written > synced) writeSaved(part, written);
+      } catch {
+      }
+      await handle.close();
+    }
   }
 }
 
@@ -874,7 +925,8 @@ function mudePaths(muHome) {
     key: join4(root, "key"),
     pid: join4(root, "server.pid"),
     log: join4(root, "server.log"),
-    state: join4(root, "state.json")
+    state: join4(root, "state.json"),
+    install: join4(root, "install.json")
   };
 }
 
@@ -1009,7 +1061,8 @@ ${installed2.output}`);
 var USAGE = `mu judge mude: mude 1.0, mu's own decision model optimized for coding, as the judge on this Mac
 (Apple silicon, macOS 14 or later)
 
-  mu judge mude install [--local-only]   download it (${(MUDE_BYTES / 1e9).toFixed(1)} GB), set it up, start it and make it the judge
+  mu judge mude install [--local-only]   download it (${(MUDE_BYTES / 1e9).toFixed(1)} GB), set it up, start it and make it the judge;
+                                         after a stop (Ctrl-C, a lost connection, a power cut), it goes on from there
   mu judge mude enable [--local-only | --with-fallback]
                                          make it the judge again, or change what happens when it can't answer
   mu judge mude disable                  back to the judges from before, and stop its server
@@ -1063,8 +1116,12 @@ function humanOut(write, tty) {
     line: (text) => write(`  ${text}
 `),
     status: (status2) => write(describe(status2)),
-    error: (message) => write(`${message}
-`)
+    error: (message) => {
+      if (shown >= 0 && tty) write("\n");
+      shown = -1;
+      write(`${message}
+`);
+    }
   };
 }
 function describe(status2) {
@@ -1129,6 +1186,17 @@ function freeBytes(path) {
     return void 0;
   }
 }
+var gb = (bytes) => (bytes / 1e9).toFixed(1);
+function installLocalOnly(ctx, args) {
+  if (args.includes("--local-only")) return true;
+  if (args.includes("--with-fallback")) return false;
+  try {
+    const value = JSON.parse(readFileSync6(ctx.paths.install, "utf8"));
+    return typeof value === "object" && value !== null && "localOnly" in value && value.localOnly === true;
+  } catch {
+    return false;
+  }
+}
 function installed(ctx) {
   return missingFiles(ctx.paths.model, MUDE_FILES).length === 0;
 }
@@ -1186,17 +1254,29 @@ async function ensureInstalled(ctx, out) {
         `Not enough free disk space: mude 1.0 needs about ${((need + 2e9) / 1e9).toFixed(1)} GB, and ${(free / 1e9).toFixed(1)} GB are free`
       );
     }
+    const already = downloadedBytes(ctx.paths.model, MUDE_FILES);
     out.step(
       "download",
-      `Downloading mude 1.0 (${MUDE_REPO}, ${(need / 1e9).toFixed(1)} GB) and checking every file`
+      already > 0 ? `Going on with the mude 1.0 download (${MUDE_REPO}): ${gb(already)} of ${gb(MUDE_BYTES)} GB are here already` : `Downloading mude 1.0 (${MUDE_REPO}, ${gb(need)} GB) and checking every file`
     );
-    await downloadFiles({
-      dir: ctx.paths.model,
-      files: MUDE_FILES,
-      url: (path) => mudeFileUrl(path, ctx.env.HF_ENDPOINT || void 0),
-      token: huggingFaceToken(ctx.env),
-      onProgress: (event) => out.progress(event)
-    });
+    try {
+      await downloadFiles({
+        dir: ctx.paths.model,
+        files: MUDE_FILES,
+        url: (path) => mudeFileUrl(path, ctx.env.HF_ENDPOINT || void 0),
+        token: huggingFaceToken(ctx.env),
+        onProgress: (event) => out.progress(event),
+        signal: ctx.signal
+      });
+    } catch (error) {
+      if (error instanceof DownloadError && error.kind === "aborted") {
+        throw new DownloadError(
+          `Stopped with ${gb(downloadedBytes(ctx.paths.model, MUDE_FILES))} of ${gb(MUDE_BYTES)} GB downloaded: mu judge mude install goes on from there`,
+          "aborted"
+        );
+      }
+      throw error;
+    }
   }
   if (!venvReady(ctx.paths, ctx.lockFile)) {
     out.step("python", "Setting up the Python environment for mude 1.0 (MLX, transformers; about 1 GB, once)");
@@ -1253,9 +1333,14 @@ async function main(argv, ctx, write, tty = false) {
     }
     switch (command) {
       case "install": {
+        const localOnly = installLocalOnly(ctx, args);
+        mkdirSync5(ctx.paths.root, { recursive: true });
+        writeFileSync6(ctx.paths.install, `${JSON.stringify({ localOnly })}
+`);
         await ensureInstalled(ctx, out);
         const at = await start(ctx, out);
-        enable(ctx, out, at, flag("--local-only"));
+        enable(ctx, out, at, localOnly);
+        rmSync4(ctx.paths.install, { force: true });
         break;
       }
       case "enable": {
@@ -1326,7 +1411,20 @@ function contextFromEnv(env = process.env, home = homedir3()) {
 }
 
 // packages/kyrn-judge/src/mude/cli.ts
-main(process.argv.slice(2), contextFromEnv(), (text) => process.stdout.write(text), Boolean(process.stdout.isTTY)).then(
+var stop = new AbortController();
+var onSignal = (signal) => {
+  if (stop.signal.aborted) process.exit(signal === "SIGINT" ? 130 : 143);
+  stop.abort();
+  setTimeout(() => process.exit(signal === "SIGINT" ? 130 : 143), 5e3).unref();
+};
+process.on("SIGINT", onSignal);
+process.on("SIGTERM", onSignal);
+main(
+  process.argv.slice(2),
+  { ...contextFromEnv(), signal: stop.signal },
+  (text) => process.stdout.write(text),
+  Boolean(process.stdout.isTTY)
+).then(
   (code) => {
     process.exitCode = code;
   },