wildcrane-runner 0.6.6 → 0.6.9

package/dist/akb/package.json

@@ -1 +1 @@
-{"name":"wildcrane","version":"0.11.5","akbContract":2,"type":"module","private":true}
+{"name":"wildcrane","version":"0.11.8","akbContract":4,"type":"module","private":true}

package/dist/launcher.mjs

@@ -1,4 +1,4 @@
-// wildcrane-runner 0.6.6 — built by runner/scripts/build.mjs. Do not edit.
+// wildcrane-runner 0.6.9 — built by runner/scripts/build.mjs. Do not edit.
 import { createRequire as __ai4kanbanRequire } from 'node:module'
 const require = __ai4kanbanRequire(import.meta.url)
 
@@ -107,9 +107,10 @@ function status(line) {
 }
 
 // src/protocol.ts
-var VERSION = true ? "0.6.6" : "0.0.0";
+var VERSION = true ? "0.6.9" : "0.0.0";
 var EXIT_REFUSED = 10;
 var EXIT_OUTDATED = 11;
+var EXIT_UPDATE = 12;
 
 // src/update.ts
 import crypto2 from "node:crypto";
@@ -273,8 +274,8 @@ async function askTarget(machine) {
       signal: AbortSignal.timeout(ASK_MS)
     });
     if (!answer.ok) return null;
-    const { version } = await answer.json();
-    return typeof version === "string" && version ? version : null;
+    const { version, restartable } = await answer.json();
+    return typeof version === "string" && /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version) ? { version, restartable: restartable === true } : null;
   } catch {
     return null;
   }
@@ -283,7 +284,7 @@ async function candidates(own) {
   const state = readState();
   const proven = state.good.find((v) => fs3.existsSync(entryOf(versionDir(v))));
   const current = proven && compare(proven, own.version) > 0 ? { version: proven, entry: entryOf(versionDir(proven)) } : own;
-  const target = await askTarget(machineId());
+  const target = (await askTarget(machineId()))?.version;
   if (!target || target === current.version || state.bad.includes(target)) return [current];
   if (target === own.version) return [own, current];
   const got = await install(target);
@@ -294,16 +295,56 @@ async function candidates(own) {
   if (got.why === "node") status(t.nodeTooOld(got.detail));
   return [current];
 }
-function runOnce(candidate) {
+function runOnce(candidate, options) {
   return new Promise((resolve) => {
     const child = spawn(process.execPath, [candidate.entry], {
-      stdio: ["inherit", "inherit", "inherit", "ipc"],
-      env: { ...process.env, WILDCRANE_RUNNER_VERSION: candidate.version }
+      stdio: ["ignore", options.quiet ? 2 : "inherit", "inherit", "ipc"],
+      env: { ...process.env, WILDCRANE_RUNNER_VERSION: candidate.version, WILDCRANE_RUNNER_KIND: options.kind ?? "terminal" }
     });
+    options.onSpawn?.((type) => {
+      if (child.connected) child.send({ type }, () => {
+      });
+    });
+    let update = null;
+    let checking = false;
+    const check = async () => {
+      if (checking || stopping || update) return;
+      checking = true;
+      try {
+        const desired = await askTarget(machineId());
+        if (!desired?.restartable) return;
+        const target = desired.version;
+        if (!target || target === candidate.version || readState().bad.includes(target)) return;
+        const got = await install(target);
+        if (!got.ok) {
+          status("Runner \u66F4\u65B0\u4E0B\u8F7D\u5931\u8D25\uFF0C\u7EE7\u7EED\u8FD0\u884C\u5F53\u524D\u7248\u672C\uFF0C\u7A0D\u540E\u91CD\u8BD5\u3002");
+          return;
+        }
+        if (stopping || child.exitCode !== null || child.signalCode !== null) return;
+        if ((await askTarget(machineId()))?.version !== target) return;
+        update = { version: target, entry: entryOf(got.dir), fresh: !readState().good.includes(target) };
+        child.send({ type: "update" }, () => {
+        });
+      } finally {
+        checking = false;
+      }
+    };
+    const poll = setInterval(() => {
+      if (connected) void check().catch(() => {
+      });
+    }, Number(process.env.WILDCRANE_UPDATE_MS) || 6e4);
     let connected = false;
     let timer = null;
     let timedOut = false;
     let stopping = false;
+    let forceKill;
+    if (candidate.fresh) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+        forceKill = setTimeout(() => child.kill("SIGKILL"), 5e3);
+      }, Number(process.env.WILDCRANE_CONNECT_MS) || CONNECT_MS);
+    }
     const forward = (signal) => () => {
       stopping = true;
       child.kill(signal);
@@ -312,13 +353,11 @@ function runOnce(candidate) {
     const onTerm = forward("SIGTERM");
     process.on("SIGINT", onInt);
     process.on("SIGTERM", onTerm);
+    options.signal?.addEventListener("abort", onTerm, { once: true });
+    if (options.signal?.aborted) onTerm();
     child.on("message", (message) => {
-      if (message.type === "started" && candidate.fresh && !connected) {
-        timer = setTimeout(() => {
-          timedOut = true;
-          child.kill("SIGTERM");
-        }, Number(process.env.WILDCRANE_CONNECT_MS) || CONNECT_MS);
-      }
+      options.onMessage?.(message);
+      if (message.type === "update-deferred") update = null;
       if (message.type === "waiting" && timer) {
         clearTimeout(timer);
         timer = null;
@@ -334,9 +373,13 @@ function runOnce(candidate) {
       }
     });
     child.on("exit", (code, signal) => {
+      clearInterval(poll);
+      clearTimeout(forceKill);
       if (timer) clearTimeout(timer);
       process.off("SIGINT", onInt);
       process.off("SIGTERM", onTerm);
+      options.signal?.removeEventListener("abort", onTerm);
+      if (code === EXIT_UPDATE && update && !stopping) return resolve({ update });
       if (connected || !candidate.fresh || stopping) return resolve({ exit: code ?? (signal ? 1 : 0) });
       if (timedOut) return resolve({ failed: "timeout" });
       if (code === 0 || code === EXIT_REFUSED || code === EXIT_OUTDATED) return resolve({ exit: code });
@@ -344,13 +387,18 @@ function runOnce(candidate) {
     });
   });
 }
-async function launch(own) {
+async function launch(own, options = {}) {
   const list = await candidates(own);
   for (let i = 0; i < list.length; i++) {
+    if (options.signal?.aborted) return 0;
     const candidate = list[i];
-    const outcome = await runOnce(candidate);
+    const outcome = await runOnce(candidate, options);
     if ("exit" in outcome) return outcome.exit;
-    if (outcome.failed === "crashed") markBad(candidate.version);
+    if ("update" in outcome) {
+      list.splice(i + 1, list.length, outcome.update, candidate);
+      continue;
+    }
+    markBad(candidate.version);
     const next = list[i + 1];
     if (next) status(t.rolledBack(next.version));
   }