blun-king-cli 9.1.184 → 9.1.185

package/bin/launcher-runtime.js

@@ -34,6 +34,7 @@ const {
   RUNNING_UPDATE_MODE_MESSAGE,
   RUNNING_UPDATE_PREPARED_MESSAGE,
   activateRuntime,
+  handoffArgsForMode,
   handoffRuntime,
   prepareRunningUpdate,
   readActiveRuntime,
@@ -156,14 +157,18 @@ function resolveLauncherPrivatePaths(options = {}) {
   };
 }
 
-function readPackageVersion() {
-  const { version } = JSON.parse(fs.readFileSync(path.join(PKG, 'package.json'), 'utf8'));
+function readPackageVersionAt(packageRoot = PKG) {
+  const { version } = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
   if (typeof version !== 'string' || version.length === 0) {
     throw new Error('Ungueltige Paketversion in package.json');
   }
   return version;
 }
 
+function readPackageVersion() {
+  return readPackageVersionAt(PKG);
+}
+
 function shouldDetachProtectedCore(options = {}) {
   const platform = options.platform || process.platform;
   const stdinIsTTY = Object.hasOwn(options, 'stdinIsTTY')
@@ -321,38 +326,45 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       scheduleNextPreparation(child);
     });
   };
-  const core = (options.spawnProtectedCore || spawnProtectedCore)(args, env, cwd, {
+  const handleCoreMessage = (message, child) => {
+    if (message?.type === RUNTIME_READY_MESSAGE) {
+      runtimeReady = true;
+      refreshRunningUpdateMode();
+      if (automaticMode()) startPreparation(child);
+      else scheduleNextPreparation(child);
+    }
+    if (message?.type === RUNNING_UPDATE_MODE_MESSAGE && typeof message.mode === 'string') {
+      runningUpdateMode = normalizeRunningUpdateMode(message.mode);
+      handoffSessionId = undefined;
+      handoffMode = undefined;
+      clearRunningUpdatePoll();
+      if (automaticMode()) {
+        if (preparedTarget !== undefined) announcePrepared(child);
+        else if (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;
+    }
+  };
+  const spawnCore = options.spawnProtectedCore || spawnProtectedCore;
+  const core = options.existingCore || spawnCore(args, env, cwd, {
     packageRoot,
-    onMessage(message, child) {
-      if (message?.type === RUNTIME_READY_MESSAGE) {
-        runtimeReady = true;
-        refreshRunningUpdateMode();
-        if (automaticMode()) startPreparation(child);
-        else scheduleNextPreparation(child);
-      }
-      if (message?.type === RUNNING_UPDATE_MODE_MESSAGE && typeof message.mode === 'string') {
-        runningUpdateMode = normalizeRunningUpdateMode(message.mode);
-        handoffSessionId = undefined;
-        handoffMode = undefined;
-        clearRunningUpdatePoll();
-        if (automaticMode()) {
-          if (preparedTarget !== undefined) announcePrepared(child);
-          else if (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;
-      }
-    },
+    onMessage: handleCoreMessage,
   });
+  let existingMessageHandler;
+  if (options.existingCore) {
+    existingMessageHandler = (message) => handleCoreMessage(message, core.child);
+    core.child.on('message', existingMessageHandler);
+  }
   const loaded = await core.loaded;
   if (loaded && !runtimeReady) {
     // Core load is an independent readiness signal. Start the download even
@@ -366,6 +378,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   await releaseNotice();
   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
@@ -374,14 +387,14 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     writeRunningUpdateHandoffNotice(options.runningUpdateNoticeOutput || process.stdout);
     const handoff = await handoffRuntime({
       target: preparedTarget,
-      previous: { packageRoot, version: readPackageVersion() },
+      previous: { packageRoot, version: readPackageVersionAt(packageRoot) },
       sessionId: handoffSessionId,
       mode: handoffMode,
       args,
       probeTarget: options.probeRunningUpdate || (() => true),
       stopOld: async () => {},
       startCore: async ({ packageRoot: nextRoot, args: nextArgs }) => {
-        const nextCore = spawnProtectedCore(nextArgs, env, cwd, { packageRoot: nextRoot });
+        const nextCore = spawnCore(nextArgs, env, cwd, { packageRoot: nextRoot });
         const nextLoaded = await nextCore.loaded;
         const ready = nextLoaded && await waitForRuntimeReady(nextCore, options.readyTimeoutMs);
         if (!ready) {
@@ -394,9 +407,12 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     });
     const resumed = handoff.core;
     if (resumed === undefined || resumed.ready !== true) return 1;
-    const resumedResult = await resumed.completed;
-    if (resumedResult.error) throw resumedResult.error;
-    return exitCodeForChild(resumedResult, true);
+    const resumedArgs = handoffArgsForMode(args, handoffMode, handoffSessionId);
+    return superviseProtectedCore(resumedArgs, env, cwd, async () => {}, {
+      ...options,
+      existingCore: resumed,
+      packageRoot: handoff.runtime.packageRoot,
+    });
   }
   return exitCodeForChild(result, loaded);
 }

package/blun.mjs

@@ -514886,7 +514886,7 @@ function notifyRunningRuntimeReady(tui) {
 }
 function requestRunningUpdateAtSafeBoundary(tui) {
 	if (tui.runningUpdatePreparedVersion === void 0 || tui.runningUpdatePreparedMode === void 0 || tui.runningUpdateHandoffStarted || !process.connected) return false;
-	if (!isSafeRuntimeBoundary({
+	const boundaryState = () => ({
 		isShuttingDown: tui.isShuttingDown,
 		streamingPhase: tui.state.appState.streamingPhase,
 		isCompacting: tui.state.appState.isCompacting,
@@ -514894,7 +514894,8 @@ function requestRunningUpdateAtSafeBoundary(tui) {
 		activeToolCalls: tui.streamingUI.hasActiveToolCalls() ? 1 : 0,
 		shellCommands: tui.shellOutputStreams.size,
 		queueCommandRunning: tui.queueCommandRunning
-	})) return false;
+	});
+	if (!isSafeRuntimeBoundary(boundaryState())) return false;
 	const sessionId = tui.getCurrentSessionId();
 	if (sessionId.length === 0) return false;
 	tui.runningUpdateHandoffStarted = true;
@@ -514904,12 +514905,17 @@ function requestRunningUpdateAtSafeBoundary(tui) {
 			sessionId,
 			version: tui.runningUpdatePreparedVersion,
 			mode: tui.runningUpdatePreparedMode
+		}, (error) => {
+			if (error || !isSafeRuntimeBoundary(boundaryState())) {
+				tui.runningUpdateHandoffStarted = false;
+				return;
+			}
+			void tui.stop(RUNNING_UPDATE_HANDOFF_EXIT_CODE);
 		});
 	} catch {
 		tui.runningUpdateHandoffStarted = false;
 		return false;
 	}
-	void tui.stop(RUNNING_UPDATE_HANDOFF_EXIT_CODE);
 	return true;
 }
 function installRunningUpdateListener(tui) {

package/package.json

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