blun-king-cli 9.1.221 → 9.1.222

package/bin/launcher-runtime.js

@@ -29,16 +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_EXIT_CODE,
-  RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
-  RUNNING_UPDATE_HANDOFF_MESSAGE,
   RUNNING_UPDATE_MODE_MESSAGE,
-  RUNNING_UPDATE_PREPARED_MESSAGE,
   RUNTIME_EXIT_INTENT_MESSAGE,
   activateRuntime,
   clearActiveRuntime,
   handoffArgsForMode,
-  handoffRuntime,
   prepareRunningUpdate,
   pruneRunningUpdateReleases,
   recordRunningUpdateEvent,
@@ -283,9 +278,6 @@ function shouldRecoverActivatedRuntime(result, recovery, options = {}) {
 async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {}) {
   const packageRoot = path.resolve(options.packageRoot || PKG);
   let preparedTarget;
-  let handoffSessionId;
-  let handoffMode;
-  let handoffCwd = cwd;
   let updateStarted = false;
   let runtimeReady = false;
   let runtimeExitIntent = false;
@@ -297,9 +289,6 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     const persistedMode = readRunningUpdateMode(env.BLUN_HOME);
     if (persistedMode !== runningUpdateMode) {
       runningUpdateMode = persistedMode;
-      handoffSessionId = undefined;
-      handoffMode = undefined;
-      handoffCwd = cwd;
     }
   };
   const clearRunningUpdatePoll = () => {
@@ -317,20 +306,6 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       else scheduleNextPreparation(child);
     });
   };
-  const announcePrepared = (child) => {
-    if (preparedTarget === undefined || !automaticMode() || child.connected !== true) return;
-    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;
     updateStarted = true;
@@ -361,7 +336,6 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
         activePackageRoot: packageRoot,
       })).catch((error) => options.onRunningUpdateError?.(error));
       clearRunningUpdatePoll();
-      announcePrepared(child);
     }).catch((error) => {
       updateStarted = false;
       options.onRunningUpdateError?.(error);
@@ -378,48 +352,14 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     }
     if (message?.type === RUNNING_UPDATE_MODE_MESSAGE && typeof message.mode === 'string') {
       runningUpdateMode = normalizeRunningUpdateMode(message.mode);
-      handoffSessionId = undefined;
-      handoffMode = undefined;
-      handoffCwd = cwd;
       clearRunningUpdatePoll();
       if (automaticMode()) {
-        if (preparedTarget !== undefined) announcePrepared(child);
-        else if (runtimeReady) {
+        if (preparedTarget === undefined && runtimeReady) {
           updateStarted = false;
           startPreparation(child);
         }
       } else if (runtimeReady) scheduleNextPreparation(child);
     }
-    if (message?.type === RUNNING_UPDATE_HANDOFF_MESSAGE
-      && typeof message.sessionId === 'string'
-      && message.sessionId.length > 0
-      && message.mode === runningUpdateMode
-      && automaticMode()) {
-      handoffSessionId = message.sessionId;
-      handoffMode = runningUpdateMode;
-      handoffCwd = resolveHandoffCwd(message.cwd, cwd);
-      if (preparedTarget !== undefined && message.version === preparedTarget.version) {
-        try {
-          (options.stageRuntime || stageRuntime)(env.BLUN_SHARED_HOME, preparedTarget, {
-            mode: handoffMode,
-            sessionId: handoffSessionId,
-            cwd: handoffCwd,
-          });
-          child.send({
-            type: RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
-            version: preparedTarget.version,
-            mode: handoffMode,
-            sessionId: handoffSessionId,
-          }, (error) => {
-            if (error) options.onRunningUpdateError?.(error);
-          });
-        } catch (error) {
-          handoffSessionId = undefined;
-          handoffMode = undefined;
-          options.onRunningUpdateError?.(error);
-        }
-      }
-    }
   };
   const spawnCore = options.spawnProtectedCore || spawnProtectedCore;
   const core = options.existingCore || spawnCore(args, env, cwd, {
@@ -460,67 +400,6 @@ 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
-    && preparedTarget !== undefined
-    && handoffSessionId !== undefined
-    && handoffMode !== undefined) {
-    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) },
-      sessionId: handoffSessionId,
-      mode: handoffMode,
-      args,
-      probeTarget: options.probeRunningUpdate || (() => true),
-      stopOld: async () => {},
-      startCore: async ({ packageRoot: nextRoot, args: nextArgs }) => {
-        const nextCore = spawnCore(nextArgs, env, handoffCwd, { packageRoot: nextRoot });
-        const nextLoaded = await nextCore.loaded;
-        const ready = nextLoaded && await waitForRuntimeReady(nextCore, options.readyTimeoutMs);
-        if (!ready) {
-          try { nextCore.child.kill(); } catch {}
-          await nextCore.completed;
-        }
-        return { ...nextCore, ready };
-      },
-      activateTarget: async (target) => {
-        await (options.activateRuntime || activateRuntime)(env.BLUN_SHARED_HOME, target);
-        (options.clearPendingRuntime || clearPendingRuntime)(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,
-          });
-        } catch (error) {
-          options.onRunningUpdateError?.(error);
-        }
-      },
-    });
-    if (handoff.kind !== 'activated') {
-      (options.clearPendingRuntime || clearPendingRuntime)(env.BLUN_SHARED_HOME, preparedTarget);
-    }
-    const resumed = handoff.core;
-    if (resumed === undefined || resumed.ready !== true) return 1;
-    const resumedArgs = handoffArgsForMode(args, handoffMode, handoffSessionId);
-    return superviseProtectedCore(resumedArgs, env, handoffCwd, async () => {}, {
-      ...options,
-      existingCore: resumed,
-      packageRoot: handoff.runtime.packageRoot,
-      startupPendingRuntime: undefined,
-      staleActiveRuntime: undefined,
-      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)(),
@@ -651,6 +530,7 @@ function spawnActiveLauncher(packageRoot, cwd, args = RAW_ARGS) {
 async function runLauncher(options = {}) {
   const callerCwd = process.cwd();
   let startupPendingRuntime;
+  let deferredPendingRuntime;
   let staleActiveRuntime;
   if (options.skipActiveRuntime !== true) {
     const activeHome = resolveLauncherPrivatePaths().sharedHome;
@@ -660,20 +540,12 @@ async function runLauncher(options = {}) {
     if (pendingRuntime !== null
       && path.resolve(pendingRuntime.packageRoot) !== PKG
       && compareSemver(currentVersion, pendingRuntime.version) === -1) {
-      const pendingArgs = pendingRuntime.mode !== undefined && pendingRuntime.sessionId !== undefined
-        ? handoffArgsForMode(RAW_ARGS, pendingRuntime.mode, pendingRuntime.sessionId)
-        : RAW_ARGS;
-      process.exitCode = await spawnActiveLauncher(
-        pendingRuntime.packageRoot,
-        pendingRuntime.cwd || callerCwd,
-        pendingArgs,
-      );
-      return;
+      deferredPendingRuntime = pendingRuntime;
     }
     if (pendingRuntime !== null && path.resolve(pendingRuntime.packageRoot) === PKG) {
       startupPendingRuntime = pendingRuntime;
     }
-    if (startupPendingRuntime === undefined && activeRuntime !== null
+    if (startupPendingRuntime === undefined && deferredPendingRuntime === undefined && activeRuntime !== null
       && path.resolve(activeRuntime.packageRoot) !== PKG
       && compareSemver(currentVersion, activeRuntime.version) === -1) {
       process.exitCode = await spawnActiveLauncher(activeRuntime.packageRoot, callerCwd);
@@ -837,8 +709,24 @@ async function runLauncher(options = {}) {
         stderr: process.stderr,
         blunDir: privatePaths.sharedHome,
         packageRoot: PKG,
+        preparedRuntime: deferredPendingRuntime,
         noticeLease,
       });
+    if (updateResult.kind === 'installed'
+      && updateResult.source === 'prepared_runtime'
+      && deferredPendingRuntime !== undefined) {
+      const pendingArgs = deferredPendingRuntime.mode !== undefined
+        && deferredPendingRuntime.sessionId !== undefined
+        ? handoffArgsForMode(RAW_ARGS, deferredPendingRuntime.mode, deferredPendingRuntime.sessionId)
+        : RAW_ARGS;
+      await releaseNotice();
+      process.exitCode = await spawnActiveLauncher(
+        deferredPendingRuntime.packageRoot,
+        deferredPendingRuntime.cwd || callerCwd,
+        pendingArgs,
+      );
+      return;
+    }
     if (updateResult.kind === 'installed' || updateResult.kind === 'update_in_progress') return;
 
     if (!runtimeLease) {

package/bin/update-notice.js

@@ -1393,6 +1393,13 @@ async function runUpdateFlow(options, explicitUpdate) {
         ? explicitNoTarget(stdout, reason, currentVersion)
         : { kind: 'continue', reason };
     }
+    const preparedRuntime = options.preparedRuntime;
+    const preparedRuntimeReady = preparedRuntime !== null
+      && typeof preparedRuntime === 'object'
+      && preparedRuntime.version === release.version
+      && typeof preparedRuntime.packageRoot === 'string'
+      && path.isAbsolute(preparedRuntime.packageRoot)
+      && verifyInstalledPackageVersion(preparedRuntime.packageRoot, release.version);
     if (!explicitUpdate
       && pendingVersion === undefined
       && readSnoozeState(blunDir, release.version, now)) {
@@ -1438,7 +1445,7 @@ async function runUpdateFlow(options, explicitUpdate) {
         ? explicitFailure(stderr, 'lease_unavailable')
         : { kind: 'continue', reason: 'lease_unavailable' };
     }
-    if (!options.installVersion) {
+    if (!options.installVersion && !preparedRuntimeReady) {
       installerSession = await (options.prepareInstaller || preparePinnedInstaller)(
         release.version,
         { blunDir, packageRoot },
@@ -1502,9 +1509,11 @@ async function runUpdateFlow(options, explicitUpdate) {
     let installResult;
     updateProgress(3, 'Paket wird installiert');
     try {
-      installResult = options.installVersion
-        ? await options.installVersion(release.version)
-        : await installerSession.commit();
+      installResult = preparedRuntimeReady
+        ? { code: 0, verified: true, preparedRuntime: true }
+        : options.installVersion
+          ? await options.installVersion(release.version)
+          : await installerSession.commit();
     } catch {
       installResult = { code: undefined };
     }
@@ -1536,7 +1545,11 @@ async function runUpdateFlow(options, explicitUpdate) {
         `Update ${currentVersion} -> ${release.version} erfolgreich installiert. Starte BLUN Code neu, um die neue Version zu verwenden.\n`,
       );
       if (release.notesUrl) stdout.write(`Versionshinweise: ${release.notesUrl}\n`);
-      return { kind: 'installed', version: release.version };
+      return {
+        kind: 'installed',
+        version: release.version,
+        ...(installResult.preparedRuntime === true ? { source: 'prepared_runtime' } : {}),
+      };
     }
 
     if (Number.isInteger(installResult?.code) && installResult.code !== 0) {

package/blun.mjs

@@ -515119,8 +515119,6 @@ function turnsToTrim(turns, maxTurns, hysteresis) {
 const {
 	AUTO_UPDATE_SETTLE_MS,
 	RUNNING_UPDATE_HANDOFF_EXIT_CODE,
-	RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
-	RUNNING_UPDATE_HANDOFF_MESSAGE,
 	RUNNING_UPDATE_MODE_MESSAGE,
 	RUNNING_UPDATE_PREPARED_MESSAGE,
 	RUNTIME_EXIT_INTENT_MESSAGE,
@@ -515148,64 +515146,14 @@ function notifyRunningRuntimeReady(tui) {
 	} catch {}
 }
 function requestRunningUpdateAtSafeBoundary(tui) {
-	if (tui.runningUpdatePreparedVersion === void 0 || tui.runningUpdatePreparedMode === void 0 || tui.runningUpdateHandoffStarted || !process.connected) return false;
-	const boundaryState = () => ({
-		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
-	});
-	if (!isSafeRuntimeBoundary(boundaryState())) return false;
-	const sessionId = tui.getCurrentSessionId();
-	if (sessionId.length === 0) return false;
-	tui.runningUpdateHandoffStarted = true;
-	try {
-		process.send({
-			type: RUNNING_UPDATE_HANDOFF_MESSAGE,
-			sessionId,
-			version: tui.runningUpdatePreparedVersion,
-			mode: tui.runningUpdatePreparedMode,
-			cwd: tui.state.appState.workDir
-		}, (error) => {
-			if (error || !isSafeRuntimeBoundary(boundaryState())) {
-				tui.runningUpdateHandoffStarted = false;
-			}
-		});
-	} catch {
-		tui.runningUpdateHandoffStarted = false;
-		return false;
-	}
-	return true;
+	return false;
 }
 function installRunningUpdateListener(tui) {
 	const handler = (message) => {
-		if (message?.type === RUNNING_UPDATE_HANDOFF_ACK_MESSAGE) {
-			if (!tui.runningUpdateHandoffStarted || 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("Ein Update wird geladen und die TUI wird neu gestartet.", "success");
-			void tui.stop(RUNNING_UPDATE_HANDOFF_EXIT_CODE).catch(() => {
-				tui.runningUpdateHandoffStarted = false;
-			});
-			return;
-		}
 		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;
-		requestRunningUpdateAtSafeBoundary(tui);
+		tui.showStatus(`Update ${message.version} ist bereit und wird beim naechsten Start aktiviert.`, "success");
 	};
 	process.on("message", handler);
 	return () => process.off("message", handler);

package/package.json

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