blun-king-cli 9.1.317 → 9.1.318

package/bin/launcher-runtime.js

@@ -30,20 +30,16 @@ const { startMnemoConnectHeartbeat } = require('./mnemo-connect-heartbeat.cjs');
 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,
-  handoffArgsForMode,
   prepareRunningUpdate,
   pruneRunningUpdateReleases,
   recordRunningUpdateEvent,
   readActiveRuntime,
   readPendingRuntime,
-  restoreActiveRuntime,
   clearPendingRuntime,
   stageRuntime,
 } = require('./running-update.cjs');
@@ -310,7 +306,6 @@ 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 activeSession;
@@ -350,7 +345,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   };
   const scheduleNextPreparation = (child) => {
     clearRunningUpdatePoll();
-    if (supervisionCompleted || pendingHandoff !== undefined || updateStarted) return;
+    if (supervisionCompleted || updateStarted) return;
     runningUpdatePollTimer = (options.scheduleRunningUpdateRecheck || scheduleRunningUpdateRecheck)(() => {
       runningUpdatePollTimer = undefined;
       refreshRunningUpdateMode();
@@ -359,7 +354,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     });
   };
   const startPreparation = (child) => {
-    if (supervisionCompleted || pendingHandoff !== undefined || updateStarted
+    if (supervisionCompleted || updateStarted
       || options.runningUpdate === false || !automaticMode()) return;
     updateStarted = true;
     const sharedHome = env.BLUN_SHARED_HOME;
@@ -387,6 +382,15 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       }
       preparedTarget = target;
       persistPreparedRuntime();
+      if (child?.connected === true) {
+        try {
+          child.send({
+            type: RUNNING_UPDATE_PREPARED_MESSAGE,
+            version: target.version,
+            mode: runningUpdateMode,
+          });
+        } catch {}
+      }
       const runningVersion = readPackageVersionAt(packageRoot);
       (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(sharedHome, previousTarget === undefined ? {
         event: 'prepared-for-next-start',
@@ -411,43 +415,6 @@ 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
-      && validSessionMessage(message)) {
-      activeSession = Object.freeze({
-        cwd: resolveHandoffCwd(message.cwd, cwd),
-        sessionId: message.sessionId,
-      });
-      try {
-        persistPreparedRuntime();
-      } catch (error) {
-        options.onRunningUpdateError?.(error);
-        scheduleNextPreparation(child);
-        return;
-      }
-      pendingHandoff = Object.freeze({
-        cwd: activeSession.cwd,
-        mode: message.mode,
-        sessionId: message.sessionId,
-        target: preparedTarget,
-      });
-      clearRunningUpdatePoll();
-      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;
-          scheduleNextPreparation(child);
-        }
-      }
-    }
     if (message?.type === RUNTIME_READY_MESSAGE) {
       if (validSessionMessage(message)) {
         activeSession = Object.freeze({
@@ -513,69 +480,6 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   supervisionCompleted = true;
   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 resumeEnv = {
-      ...env,
-      [RUNNING_UPDATE_RESUME_SESSION_ENV]: pendingHandoff.sessionId,
-    };
-    const nextCore = spawnCore(handoffArgs, resumeEnv, 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, resumeEnv, 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, resumeEnv, handoffCwd, { packageRoot });
-    const fallbackLoaded = await fallback.loaded;
-    const fallbackReady = fallbackLoaded && await (options.waitForRuntimeReady || waitForRuntimeReady)(
-      fallback,
-      options.readyTimeoutMs,
-    );
-    if (!fallbackReady) return 1;
-    return superviseProtectedCore(handoffArgs, resumeEnv, 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

@@ -495659,7 +495659,7 @@ async function handleUpdateCommand(host) {
 	}
 	host.runningUpdatePreparedVersion = void 0;
 	host.runningUpdatePreparedMode = void 0;
-	host.runningUpdateHandoffStarted = false;
+	host.runningUpdatePreparedNoticeVersion = void 0;
 	if (process.connected) try {
 		process.send({ type: RUNNING_UPDATE_MODE_MESSAGE, mode: selectedMode });
 	} catch {}
@@ -515761,7 +515761,6 @@ const {
 	RUNNING_UPDATE_PREPARED_MESSAGE,
 	RUNTIME_EXIT_INTENT_MESSAGE,
 	RUNTIME_READY_MESSAGE,
-	isSafeRuntimeBoundary,
 	pruneRunningUpdateReleases
 } = __require("./bin/running-update.cjs");
 const {
@@ -515792,64 +515791,21 @@ function notifyRunningRuntimeReady(tui) {
 	sendRunningRuntimeSession(tui);
 }
 function requestRunningUpdateAtSafeBoundary(tui) {
-	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;
-	}
+	if (typeof version !== "string" || mode !== RUNNING_UPDATE_MODES.RESUME && mode !== RUNNING_UPDATE_MODES.NEW) return false;
+	if (tui.runningUpdatePreparedNoticeVersion === version) return false;
+	tui.runningUpdatePreparedNoticeVersion = version;
+	tui.showStatus(`Update ${version} ist sicher geladen. Die laufende Sitzung bleibt aktiv; beim naechsten natuerlichen Start wird sie automatisch fortgesetzt.`, "success");
+	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)) {
 			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;
+			requestRunningUpdateAtSafeBoundary(tui);
 		}
-		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);
@@ -515941,7 +515897,7 @@ var BlunTUI = class {
 	startupGoalPromptedSessionId;
 	runningUpdatePreparedVersion;
 	runningUpdatePreparedMode;
-	runningUpdateHandoffStarted = false;
+	runningUpdatePreparedNoticeVersion;
 	runningUpdateMessageDispose;
 	startupPhaseMs = {};
 	lastActivityMode;

package/package.json

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