blun-king-cli 9.1.208 → 9.1.209

package/bin/launcher-runtime.js

@@ -33,12 +33,15 @@ const {
   RUNNING_UPDATE_HANDOFF_MESSAGE,
   RUNNING_UPDATE_MODE_MESSAGE,
   RUNNING_UPDATE_PREPARED_MESSAGE,
+  RUNTIME_EXIT_INTENT_MESSAGE,
   activateRuntime,
   handoffArgsForMode,
   handoffRuntime,
   prepareRunningUpdate,
   pruneRunningUpdateReleases,
+  recordRunningUpdateEvent,
   readActiveRuntime,
+  restoreActiveRuntime,
 } = require('./running-update.cjs');
 const {
   RUNNING_UPDATE_MODES,
@@ -65,6 +68,7 @@ const RUNTIME_READY_TIMEOUT_MS = 60_000;
 const RUNNING_UPDATE_RECHECK_MS = 60_000;
 const RUNNING_UPDATE_RECHECK_JITTER_MS = 30_000;
 const RUNNING_UPDATE_HANDOFF_NOTICE = 'Ein Update wird geladen. Die TUI wird anschließend neu gestartet.';
+const RUNNING_UPDATE_STABILIZATION_MS = 2 * 60 * 1000;
 
 function runningUpdateRecheckDelay(randomValue = Math.random()) {
   const normalized = Number.isFinite(randomValue)
@@ -268,6 +272,14 @@ function resolveHandoffCwd(candidate, fallback) {
   }
 }
 
+function shouldRecoverActivatedRuntime(result, recovery, options = {}) {
+  if (recovery === undefined || options.runtimeExitIntent === true) return false;
+  const signal = result?.signal;
+  if (signal === 'SIGINT' || signal === 'SIGTERM' || signal === 'SIGHUP') return false;
+  const now = options.now ?? Date.now();
+  return now - recovery.activatedAt <= RUNNING_UPDATE_STABILIZATION_MS;
+}
+
 async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {}) {
   const packageRoot = path.resolve(options.packageRoot || PKG);
   let preparedTarget;
@@ -276,6 +288,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   let handoffCwd = cwd;
   let updateStarted = false;
   let runtimeReady = false;
+  let runtimeExitIntent = false;
   let runningUpdatePollTimer;
   let runningUpdateMode = readRunningUpdateMode(env.BLUN_HOME);
   const automaticMode = () => runningUpdateMode === RUNNING_UPDATE_MODES.RESUME
@@ -306,11 +319,17 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   };
   const announcePrepared = (child) => {
     if (preparedTarget === undefined || !automaticMode() || child.connected !== true) return;
-    child.send({
-      type: RUNNING_UPDATE_PREPARED_MESSAGE,
-      version: preparedTarget.version,
-      mode: runningUpdateMode,
-    });
+    try {
+      child.send({
+        type: RUNNING_UPDATE_PREPARED_MESSAGE,
+        version: preparedTarget.version,
+        mode: runningUpdateMode,
+      }, (error) => {
+        if (error) options.onRunningUpdateError?.(error);
+      });
+    } catch (error) {
+      options.onRunningUpdateError?.(error);
+    }
   };
   const startPreparation = (child) => {
     if (updateStarted || options.runningUpdate === false || !automaticMode()) return;
@@ -341,6 +360,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     });
   };
   const handleCoreMessage = (message, child) => {
+    if (message?.type === RUNTIME_EXIT_INTENT_MESSAGE) runtimeExitIntent = true;
     if (message?.type === RUNTIME_READY_MESSAGE) {
       runtimeReady = true;
       refreshRunningUpdateMode();
@@ -395,12 +415,13 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   const result = await core.completed;
   clearRunningUpdatePoll();
   if (existingMessageHandler) core.child.off('message', existingMessageHandler);
-  if (result.error) throw result.error;
   if (result.code === RUNNING_UPDATE_HANDOFF_EXIT_CODE
     && preparedTarget !== undefined
     && handoffSessionId !== undefined
     && handoffMode !== undefined) {
     writeRunningUpdateHandoffNotice(options.runningUpdateNoticeOutput || process.stdout);
+    const previousActiveRuntime = (options.readActiveRuntime || readActiveRuntime)(env.BLUN_SHARED_HOME);
+    const activatedAt = (options.nowImpl || Date.now)();
     const handoff = await handoffRuntime({
       target: preparedTarget,
       previous: { packageRoot, version: readPackageVersionAt(packageRoot) },
@@ -421,6 +442,11 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       },
       activateTarget: async (target) => {
         await (options.activateRuntime || activateRuntime)(env.BLUN_SHARED_HOME, target);
+        (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(env.BLUN_SHARED_HOME, {
+          event: 'activated',
+          fromVersion: readPackageVersionAt(packageRoot),
+          toVersion: target.version,
+        }, { now: options.nowImpl });
         try {
           await (options.pruneRunningUpdateReleases || pruneRunningUpdateReleases)(env.BLUN_SHARED_HOME, {
             activePackageRoot: target.packageRoot,
@@ -437,8 +463,45 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       ...options,
       existingCore: resumed,
       packageRoot: handoff.runtime.packageRoot,
+      recoveryRuntime: handoff.kind === 'activated' ? {
+        activatedAt,
+        activeRuntime: previousActiveRuntime,
+        packageRoot,
+        version: readPackageVersionAt(packageRoot),
+      } : undefined,
     });
   }
+  const recovery = options.recoveryRuntime;
+  if (shouldRecoverActivatedRuntime(result, recovery, {
+    now: (options.nowImpl || Date.now)(),
+    runtimeExitIntent,
+  })) {
+    (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(env.BLUN_SHARED_HOME, {
+      event: 'post-activation-exit',
+      activeVersion: readPackageVersionAt(packageRoot),
+      code: Number.isInteger(result.code) ? result.code : null,
+      error: result.error?.message || null,
+      signal: result.signal || null,
+      recoveryVersion: recovery.version,
+    }, { now: options.nowImpl });
+    await (options.restoreActiveRuntime || restoreActiveRuntime)(env.BLUN_SHARED_HOME, recovery.activeRuntime);
+    const fallback = spawnCore(args, env, cwd, { packageRoot: recovery.packageRoot });
+    const fallbackLoaded = await fallback.loaded;
+    const fallbackReady = fallbackLoaded && await waitForRuntimeReady(fallback, options.readyTimeoutMs);
+    (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(env.BLUN_SHARED_HOME, {
+      event: fallbackReady ? 'recovery-ready' : 'recovery-failed',
+      version: recovery.version,
+    }, { now: options.nowImpl });
+    if (fallbackReady) {
+      return superviseProtectedCore(args, env, cwd, async () => {}, {
+        ...options,
+        existingCore: fallback,
+        packageRoot: recovery.packageRoot,
+        recoveryRuntime: undefined,
+      });
+    }
+  }
+  if (result.error) throw result.error;
   return exitCodeForChild(result, loaded);
 }
 
@@ -768,12 +831,14 @@ async function runLauncher(options = {}) {
 module.exports = {
   RUNNING_UPDATE_RECHECK_JITTER_MS,
   RUNNING_UPDATE_RECHECK_MS,
+  RUNNING_UPDATE_STABILIZATION_MS,
   createManagedNodeEnvironment,
   resolveLauncherPrivatePaths,
   resolveHandoffCwd,
   runningUpdateRecheckDelay,
   runLauncher,
   scheduleRunningUpdateRecheck,
+  shouldRecoverActivatedRuntime,
   shouldDetachProtectedCore,
   spawnManagedLauncher,
   superviseProtectedCore,

package/bin/running-update.cjs

@@ -19,6 +19,7 @@ const RUNNING_UPDATE_PREPARED_MESSAGE = 'blun-running-update-prepared';
 const RUNNING_UPDATE_HANDOFF_MESSAGE = 'blun-running-update-handoff';
 const RUNNING_UPDATE_MODE_MESSAGE = 'blun-running-update-mode';
 const RUNTIME_READY_MESSAGE = 'blun-runtime-session-ready';
+const RUNTIME_EXIT_INTENT_MESSAGE = 'blun-runtime-exit-intent';
 const MAX_TARBALL_BYTES = 128 * 1024 * 1024;
 const AUTO_UPDATE_SETTLE_MS = 30 * 60 * 1000;
 const DEFAULT_RETAINED_RELEASE_VERSIONS = 3;
@@ -276,6 +277,28 @@ function activateRuntime(sharedHome, target) {
   }
 }
 
+function restoreActiveRuntime(sharedHome, runtime) {
+  if (runtime === null || runtime === undefined) {
+    fs.rmSync(activeRuntimePath(sharedHome), { force: true });
+    return;
+  }
+  activateRuntime(sharedHome, runtime);
+}
+
+function recordRunningUpdateEvent(sharedHome, event, options = {}) {
+  if (typeof sharedHome !== 'string' || !path.isAbsolute(sharedHome)) return false;
+  const updateRoot = path.join(path.resolve(sharedHome), 'updates');
+  ensurePrivateDirectory(path.resolve(sharedHome));
+  ensurePrivateDirectory(updateRoot);
+  const filePath = path.join(updateRoot, 'handoff.jsonl');
+  fs.appendFileSync(filePath, `${JSON.stringify({
+    at: new Date((options.now || Date.now)()).toISOString(),
+    ...event,
+  })}\n`, { encoding: 'utf8', mode: 0o600 });
+  securePrivateFile(filePath);
+  return true;
+}
+
 function registryRelease(registry, version) {
   const versions = ownData(registry, 'versions');
   const entry = ownData(versions, version);
@@ -474,6 +497,7 @@ module.exports = {
   RUNNING_UPDATE_HANDOFF_MESSAGE,
   RUNNING_UPDATE_MODE_MESSAGE,
   RUNNING_UPDATE_PREPARED_MESSAGE,
+  RUNTIME_EXIT_INTENT_MESSAGE,
   RUNTIME_READY_MESSAGE,
   activateRuntime,
   activeRuntimePath,
@@ -483,7 +507,9 @@ module.exports = {
   isSafeRuntimeBoundary,
   prepareRunningUpdate,
   pruneRunningUpdateReleases,
+  recordRunningUpdateEvent,
   readActiveRuntime,
+  restoreActiveRuntime,
   resumeArgsForHandoff,
   selectRunningUpdateTarget,
   verifyRuntimePackage,

package/blun.mjs

@@ -515041,6 +515041,7 @@ const {
 	RUNNING_UPDATE_HANDOFF_MESSAGE,
 	RUNNING_UPDATE_MODE_MESSAGE,
 	RUNNING_UPDATE_PREPARED_MESSAGE,
+	RUNTIME_EXIT_INTENT_MESSAGE,
 	RUNTIME_READY_MESSAGE,
 	isSafeRuntimeBoundary,
 	pruneRunningUpdateReleases
@@ -515734,6 +515735,9 @@ var BlunTUI = class {
 	async stop(exitCode) {
 		if (this.isShuttingDown) return;
 		this.isShuttingDown = true;
+		if (exitCode === 0 && process.connected) try {
+			process.send({ type: RUNTIME_EXIT_INTENT_MESSAGE });
+		} catch {}
 		this.unregisterSignalHandlers();
 		this.aborted = true;
 		this.channelQueueDeadline?.dispose();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.208",
+  "version": "9.1.209",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {