blun-king-cli 9.1.264 → 9.1.265

package/bin/launcher-runtime.js

@@ -29,7 +29,11 @@ const { repairConfiguredNativeModules } = require('./native-module-repair');
 const { acquireSharedRuntimeLease, tryAcquireUpdateLease } = require('./update-lease');
 const { compareSemver, runExplicitUpdate, runUpdateNotice } = require('./update-notice');
 const {
+  RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
+  RUNNING_UPDATE_HANDOFF_EXIT_CODE,
+  RUNNING_UPDATE_HANDOFF_MESSAGE,
   RUNNING_UPDATE_MODE_MESSAGE,
+  RUNNING_UPDATE_PREPARED_MESSAGE,
   RUNTIME_EXIT_INTENT_MESSAGE,
   activateRuntime,
   clearActiveRuntime,
@@ -305,6 +309,7 @@ function shouldRecoverActivatedRuntime(result, recovery, options = {}) {
 async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {}) {
   const packageRoot = path.resolve(options.packageRoot || PKG);
   let preparedTarget;
+  let pendingHandoff;
   let updateStarted = false;
   let runtimeReady = false;
   let runtimeExitIntent = false;
@@ -359,6 +364,15 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
         fromVersion: readPackageVersionAt(packageRoot),
         toVersion: target.version,
       }, { now: options.nowImpl });
+      if (child?.connected === true) {
+        try {
+          child.send({
+            type: RUNNING_UPDATE_PREPARED_MESSAGE,
+            version: target.version,
+            mode: runningUpdateMode,
+          });
+        } catch {}
+      }
       Promise.resolve((options.pruneRunningUpdateReleases || pruneRunningUpdateReleases)(sharedHome, {
         activePackageRoot: packageRoot,
       })).catch((error) => options.onRunningUpdateError?.(error));
@@ -371,6 +385,34 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   };
   const handleCoreMessage = (message, child) => {
     if (message?.type === RUNTIME_EXIT_INTENT_MESSAGE) runtimeExitIntent = true;
+    if (message?.type === RUNNING_UPDATE_HANDOFF_MESSAGE
+      && preparedTarget !== undefined
+      && message.version === preparedTarget.version
+      && message.mode === runningUpdateMode
+      && typeof message.sessionId === 'string'
+      && message.sessionId.length > 0
+      && message.sessionId.length <= 256
+      && !/[\u0000-\u001f\u007f]/u.test(message.sessionId)
+      && resolveHandoffCwd(message.cwd, '') !== '') {
+      pendingHandoff = Object.freeze({
+        cwd: resolveHandoffCwd(message.cwd, cwd),
+        mode: message.mode,
+        sessionId: message.sessionId,
+        target: preparedTarget,
+      });
+      if (child?.connected === true) {
+        try {
+          child.send({
+            type: RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
+            version: preparedTarget.version,
+            mode: message.mode,
+            sessionId: message.sessionId,
+          });
+        } catch {
+          pendingHandoff = undefined;
+        }
+      }
+    }
     if (message?.type === RUNTIME_READY_MESSAGE) {
       runtimeReady = true;
       refreshRunningUpdateMode();
@@ -427,6 +469,65 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   const result = await core.completed;
   clearRunningUpdatePoll();
   if (existingMessageHandler) core.child.off('message', existingMessageHandler);
+  if (result.code === RUNNING_UPDATE_HANDOFF_EXIT_CODE && pendingHandoff !== undefined) {
+    const sharedHome = env.BLUN_SHARED_HOME;
+    const target = pendingHandoff.target;
+    const handoffArgs = handoffArgsForMode(args, pendingHandoff.mode, pendingHandoff.sessionId);
+    const handoffCwd = pendingHandoff.cwd;
+    const previousActive = (options.readActiveRuntime || readActiveRuntime)(sharedHome);
+    const nextCore = spawnCore(handoffArgs, env, handoffCwd, { packageRoot: target.packageRoot });
+    const nextLoaded = await nextCore.loaded;
+    const nextReady = nextLoaded && await (options.waitForRuntimeReady || waitForRuntimeReady)(
+      nextCore,
+      options.readyTimeoutMs,
+    );
+    if (nextReady) {
+      await (options.activateRuntime || activateRuntime)(sharedHome, target);
+      (options.clearPendingRuntime || clearPendingRuntime)(sharedHome, target);
+      const activatedAt = (options.nowImpl || Date.now)();
+      (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(sharedHome, {
+        event: 'activated-at-safe-boundary',
+        fromVersion: readPackageVersionAt(packageRoot),
+        toVersion: target.version,
+        mode: pendingHandoff.mode,
+      }, { now: options.nowImpl });
+      return superviseProtectedCore(handoffArgs, env, handoffCwd, async () => {}, {
+        ...options,
+        existingCore: nextCore,
+        packageRoot: target.packageRoot,
+        recoveryRuntime: {
+          activeRuntime: previousActive,
+          activatedAt,
+          packageRoot,
+          version: readPackageVersionAt(packageRoot),
+        },
+        staleActiveRuntime: undefined,
+        startupPendingRuntime: undefined,
+      });
+    }
+    try { nextCore.child.kill(); } catch {}
+    (options.clearPendingRuntime || clearPendingRuntime)(sharedHome, target);
+    (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(sharedHome, {
+      event: 'safe-boundary-start-failed',
+      fromVersion: readPackageVersionAt(packageRoot),
+      toVersion: target.version,
+    }, { now: options.nowImpl });
+    const fallback = spawnCore(handoffArgs, env, handoffCwd, { packageRoot });
+    const fallbackLoaded = await fallback.loaded;
+    const fallbackReady = fallbackLoaded && await (options.waitForRuntimeReady || waitForRuntimeReady)(
+      fallback,
+      options.readyTimeoutMs,
+    );
+    if (!fallbackReady) return 1;
+    return superviseProtectedCore(handoffArgs, env, handoffCwd, async () => {}, {
+      ...options,
+      existingCore: fallback,
+      packageRoot,
+      recoveryRuntime: undefined,
+      staleActiveRuntime: undefined,
+      startupPendingRuntime: undefined,
+    });
+  }
   const recovery = options.recoveryRuntime;
   if (shouldRecoverActivatedRuntime(result, recovery, {
     now: (options.nowImpl || Date.now)(),

package/blun.mjs

@@ -515372,14 +515372,64 @@ function notifyRunningRuntimeReady(tui) {
 	} catch {}
 }
 function requestRunningUpdateAtSafeBoundary(tui) {
-	return false;
+	if (tui.runningUpdateHandoffStarted || tui.isShuttingDown || !process.connected) return false;
+	const version = tui.runningUpdatePreparedVersion;
+	const mode = tui.runningUpdatePreparedMode;
+	const sessionId = tui.getCurrentSessionId();
+	const cwd = tui.state.appState.workDir;
+	if (typeof version !== "string" || mode !== RUNNING_UPDATE_MODES.RESUME && mode !== RUNNING_UPDATE_MODES.NEW || sessionId.length === 0) return false;
+	if (!isSafeRuntimeBoundary({
+		isShuttingDown: tui.isShuttingDown,
+		streamingPhase: tui.state.appState.streamingPhase,
+		isCompacting: tui.state.appState.isCompacting,
+		queuedMessages: tui.state.queuedMessages.length,
+		activeToolCalls: tui.streamingUI.hasActiveToolCalls() ? 1 : 0,
+		shellCommands: tui.shellOutputStreams.size,
+		queueCommandRunning: tui.queueCommandRunning
+	})) return false;
+	tui.runningUpdateHandoffStarted = true;
+	tui.showStatus(`Update ${version} ist bereit. Die sichere Update-Pause beginnt jetzt.`, "success");
+	try {
+		process.send({
+			type: RUNNING_UPDATE_HANDOFF_MESSAGE,
+			version,
+			mode,
+			sessionId,
+			cwd
+		}, (error) => {
+			if (!error) return;
+			tui.runningUpdateHandoffStarted = false;
+			tui.showStatus("Das Update bleibt bereit und wird an der naechsten sicheren Grenze erneut versucht.", "warning");
+		});
+		return true;
+	} catch {
+		tui.runningUpdateHandoffStarted = false;
+		return false;
+	}
 }
 function installRunningUpdateListener(tui) {
 	const handler = (message) => {
-		if (message?.type !== RUNNING_UPDATE_PREPARED_MESSAGE || typeof message.version !== "string" || message.mode !== RUNNING_UPDATE_MODES.RESUME && message.mode !== RUNNING_UPDATE_MODES.NEW) return;
-		tui.runningUpdatePreparedVersion = message.version;
-		tui.runningUpdatePreparedMode = message.mode;
-		tui.showStatus(`Update ${message.version} ist bereit und wird beim naechsten Start aktiviert.`, "success");
+		if (message?.type === RUNNING_UPDATE_PREPARED_MESSAGE && typeof message.version === "string" && (message.mode === RUNNING_UPDATE_MODES.RESUME || message.mode === RUNNING_UPDATE_MODES.NEW)) {
+			tui.runningUpdatePreparedVersion = message.version;
+			tui.runningUpdatePreparedMode = message.mode;
+			if (!requestRunningUpdateAtSafeBoundary(tui)) tui.showStatus(`Update ${message.version} ist bereit und wartet auf die naechste sichere Arbeitsgrenze.`, "success");
+			return;
+		}
+		if (message?.type !== RUNNING_UPDATE_HANDOFF_ACK_MESSAGE || tui.runningUpdateHandoffStarted !== true || message.version !== tui.runningUpdatePreparedVersion || message.mode !== tui.runningUpdatePreparedMode || message.sessionId !== tui.getCurrentSessionId()) return;
+		if (!isSafeRuntimeBoundary({
+			isShuttingDown: tui.isShuttingDown,
+			streamingPhase: tui.state.appState.streamingPhase,
+			isCompacting: tui.state.appState.isCompacting,
+			queuedMessages: tui.state.queuedMessages.length,
+			activeToolCalls: tui.streamingUI.hasActiveToolCalls() ? 1 : 0,
+			shellCommands: tui.shellOutputStreams.size,
+			queueCommandRunning: tui.queueCommandRunning
+		})) {
+			tui.runningUpdateHandoffStarted = false;
+			return;
+		}
+		tui.showStatus(`Update ${message.version} wird aktiviert. Die Sitzung wird automatisch fortgesetzt.`, "success");
+		void tui.stop(RUNNING_UPDATE_HANDOFF_EXIT_CODE);
 	};
 	process.on("message", handler);
 	return () => process.off("message", handler);

package/package.json

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