blun-king-cli 9.1.58 → 9.1.61

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.57
+  npm install -g blun-king-cli@9.1.61
 
 Start
 -----

package/README.md

@@ -9,7 +9,7 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.57
+npm install -g blun-king-cli@9.1.61
 ```
 
 ## Reproduzierbares Staging und Packen

package/bin/core-bootstrap.js

@@ -5,6 +5,7 @@ const path = require('node:path');
 const { pathToFileURL } = require('node:url');
 
 const { acquireSharedRuntimeLease } = require('./update-lease');
+const { RUNTIME_READY_MESSAGE } = require('./running-update.cjs');
 
 const CORE_LOADED_MESSAGE = 'blun-core-bootstrap-loaded';
 
@@ -31,11 +32,7 @@ async function runCoreBootstrap() {
 
   if (process.connected) {
     try {
-      process.send({ type: CORE_LOADED_MESSAGE }, () => {
-        try {
-          process.disconnect();
-        } catch {}
-      });
+      process.send({ type: CORE_LOADED_MESSAGE });
     } catch {}
   }
 }
@@ -49,4 +46,4 @@ if (require.main === module) {
   });
 }
 
-module.exports = { CORE_LOADED_MESSAGE, runCoreBootstrap };
+module.exports = { CORE_LOADED_MESSAGE, RUNTIME_READY_MESSAGE, runCoreBootstrap };

package/bin/launcher-mode.js

@@ -10,6 +10,8 @@ const LAUNCHER_HELP_TEXT = [
   'Launchers:',
   '  blun  Starts the CLI without automatically attaching Telegram.',
   '  king  Starts the same CLI and automatically attaches the configured Telegram channel.',
+  '  king <profile> starts an isolated named King profile.',
+  '  king -c <profile> continues the last session in that profile.',
   '  Both use the same version, account, model, and commands.',
   '  blun tools list shows optional tools; enable writes only explicit choices.',
   '',

package/bin/launcher-runtime.js

@@ -21,20 +21,38 @@ const {
   seedStandardDesignSkill,
   seedStandardTools,
 } = require('./standard-tools-bootstrap');
-const { CORE_LOADED_MESSAGE } = require('./core-bootstrap');
+const { CORE_LOADED_MESSAGE, RUNTIME_READY_MESSAGE } = require('./core-bootstrap');
 const { prepareManagedNodeRuntime } = require('./node-runtime');
 const { repairConfiguredNativeModules } = require('./native-module-repair');
 const { acquireSharedRuntimeLease, tryAcquireUpdateLease } = require('./update-lease');
-const { runExplicitUpdate, runUpdateNotice } = require('./update-notice');
+const { compareSemver, runExplicitUpdate, runUpdateNotice } = require('./update-notice');
+const {
+  RUNNING_UPDATE_HANDOFF_EXIT_CODE,
+  RUNNING_UPDATE_HANDOFF_MESSAGE,
+  RUNNING_UPDATE_PREPARED_MESSAGE,
+  activateRuntime,
+  handoffRuntime,
+  prepareRunningUpdate,
+  readActiveRuntime,
+  resumeArgsForHandoff,
+} = require('./running-update.cjs');
 const {
   ensurePrivateDirectory,
   securePrivateFile,
   writePrivateFile,
 } = require('./private-paths');
+const {
+  parseProfileLaunchArgs,
+  resolveProfilePaths,
+  seedDefaultProfileFromLegacy,
+} = require('./profile-runtime.cjs');
 
 const PKG = path.resolve(__dirname, '..');
-const ARGS = process.argv.slice(2);
+const RAW_ARGS = process.argv.slice(2);
+const PROFILE = parseProfileLaunchArgs(RAW_ARGS, launcherModeFromArgv(process.argv));
+const ARGS = PROFILE.args;
 const CORE_LOAD_TIMEOUT_MS = 30_000;
+const RUNTIME_READY_TIMEOUT_MS = 60_000;
 
 function normalizeWindowsPath(value) {
   return path.win32.normalize(value).replace(/\\+$/u, '').toLowerCase();
@@ -44,10 +62,24 @@ function resolveLauncherPrivatePaths(options = {}) {
   const env = options.env || process.env;
   const platform = options.platform || process.platform;
   const configuredHome = String(env.BLUN_HOME || '').trim();
+  const configuredSharedHome = String(env.BLUN_SHARED_HOME || '').trim();
+  const profileName = options.profileName || PROFILE.profileName;
   if (platform !== 'win32') {
     const userHome = (options.homedir || os.homedir)();
+    const sharedHome = configuredSharedHome
+      ? path.resolve(configuredSharedHome)
+      : configuredHome
+      ? path.resolve(configuredHome)
+      : path.join(userHome, '.blun');
+    const profilePaths = resolveProfilePaths(sharedHome, profileName);
+    if (configuredSharedHome && configuredHome
+      && path.resolve(configuredHome) !== path.resolve(profilePaths.home)) {
+      throw new Error(`BLUN_HOME passt nicht zum Profil ${profileName}: ${profilePaths.home}`);
+    }
     return {
-      blunHome: configuredHome ? path.resolve(configuredHome) : path.join(userHome, '.blun'),
+      blunHome: profilePaths.home,
+      profilePaths,
+      sharedHome,
       userHome,
     };
   }
@@ -71,12 +103,26 @@ function resolveLauncherPrivatePaths(options = {}) {
     throw new Error('Das lokale Windows-Benutzerprofil ist kein kanonischer lokaler Pfad.');
   }
 
-  const blunHome = path.win32.join(userHome, '.blun');
+  const sharedHome = path.win32.join(userHome, '.blun');
+  const profilePaths = resolveProfilePaths(sharedHome, profileName, path.win32);
+  if (configuredSharedHome
+    && normalizeWindowsPath(path.win32.resolve(configuredSharedHome)) !== normalizeWindowsPath(sharedHome)) {
+    throw new Error(`BLUN_SHARED_HOME muss unter Windows exakt im Windows-Benutzerprofil liegen: ${sharedHome}`);
+  }
+  const configuredHomeIsLegacyShared = !configuredSharedHome
+    && configuredHome
+    && normalizeWindowsPath(path.win32.resolve(configuredHome)) === normalizeWindowsPath(sharedHome);
   if (configuredHome
-    && normalizeWindowsPath(path.win32.resolve(configuredHome)) !== normalizeWindowsPath(blunHome)) {
-    throw new Error(`BLUN_HOME muss unter Windows exakt im Windows-Benutzerprofil liegen: ${blunHome}`);
+    && !configuredHomeIsLegacyShared
+    && normalizeWindowsPath(path.win32.resolve(configuredHome)) !== normalizeWindowsPath(profilePaths.home)) {
+    throw new Error(`BLUN_HOME passt nicht zum Profil ${profileName}: ${profilePaths.home}`);
   }
-  return { blunHome, userHome };
+  return {
+    blunHome: profilePaths.home,
+    profilePaths,
+    sharedHome,
+    userHome,
+  };
 }
 
 function readPackageVersion() {
@@ -95,10 +141,11 @@ function shouldDetachProtectedCore(options = {}) {
   return platform !== 'win32' || stdinIsTTY !== true;
 }
 
-function spawnProtectedCore(args, env, cwd) {
+function spawnProtectedCore(args, env, cwd, options = {}) {
+  const packageRoot = path.resolve(options.packageRoot || PKG);
   const child = spawn(
     process.execPath,
-    [path.join(PKG, 'bin', 'core-bootstrap.js'), ...args],
+    [path.join(packageRoot, 'bin', 'core-bootstrap.js'), ...args],
     {
       cwd,
       detached: shouldDetachProtectedCore(),
@@ -108,8 +155,10 @@ function spawnProtectedCore(args, env, cwd) {
     },
   );
   let loadedSettled = false;
+  let readySettled = false;
   let completedSettled = false;
   let resolveLoaded;
+  let resolveReady;
   let resolveCompleted;
   const loadTimer = setTimeout(() => {
     try {
@@ -117,6 +166,7 @@ function spawnProtectedCore(args, env, cwd) {
     } catch {}
   }, CORE_LOAD_TIMEOUT_MS);
   const loaded = new Promise((resolve) => { resolveLoaded = resolve; });
+  const ready = new Promise((resolve) => { resolveReady = resolve; });
   const completed = new Promise((resolve) => { resolveCompleted = resolve; });
   const settleLoaded = (value) => {
     if (loadedSettled) return;
@@ -124,11 +174,17 @@ function spawnProtectedCore(args, env, cwd) {
     clearTimeout(loadTimer);
     resolveLoaded(value);
   };
+  const settleReady = (value) => {
+    if (readySettled) return;
+    readySettled = true;
+    resolveReady(value);
+  };
   const settleCompleted = (result) => {
     if (completedSettled) return;
     completedSettled = true;
     for (const [signal, handler] of signalHandlers) process.removeListener(signal, handler);
     settleLoaded(false);
+    settleReady(false);
     resolveCompleted(result);
   };
   const signalHandlers = new Map();
@@ -142,23 +198,93 @@ function spawnProtectedCore(args, env, cwd) {
     process.once(signal, handler);
   }
   child.on('message', (message) => {
-    if (message?.type !== CORE_LOADED_MESSAGE) return;
-    settleLoaded(true);
-    try {
-      child.disconnect();
-    } catch {}
+    if (message?.type === CORE_LOADED_MESSAGE) settleLoaded(true);
+    if (message?.type === RUNTIME_READY_MESSAGE) settleReady(true);
+    options.onMessage?.(message, child);
   });
   child.once('error', (error) => settleCompleted({ error }));
   child.once('exit', (code, signal) => settleCompleted({ code, signal }));
-  return { child, completed, loaded };
+  return { child, completed, loaded, packageRoot, ready };
+}
+
+async function waitForRuntimeReady(core, timeoutMs = RUNTIME_READY_TIMEOUT_MS) {
+  let timer;
+  const timedOut = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(false), timeoutMs);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([core.ready, timedOut]);
+  } finally {
+    clearTimeout(timer);
+  }
 }
 
-async function superviseProtectedCore(args, env, cwd, releaseNotice) {
-  const core = spawnProtectedCore(args, env, cwd);
+async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {}) {
+  const packageRoot = path.resolve(options.packageRoot || PKG);
+  let preparedTarget;
+  let handoffSessionId;
+  let updateStarted = false;
+  const startPreparation = (child) => {
+    if (updateStarted || options.runningUpdate === false) return;
+    updateStarted = true;
+    const sharedHome = env.BLUN_SHARED_HOME;
+    if (typeof sharedHome !== 'string' || sharedHome.length === 0) return;
+    Promise.resolve((options.prepareRunningUpdate || prepareRunningUpdate)({
+      currentVersion: JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8')).version,
+      sharedHome,
+      env,
+    })).then((target) => {
+      if (target === null || child.connected !== true) return;
+      preparedTarget = target;
+      child.send({ type: RUNNING_UPDATE_PREPARED_MESSAGE, version: target.version });
+    }).catch((error) => {
+      options.onRunningUpdateError?.(error);
+    });
+  };
+  const core = spawnProtectedCore(args, env, cwd, {
+    packageRoot,
+    onMessage(message, child) {
+      if (message?.type === RUNTIME_READY_MESSAGE) startPreparation(child);
+      if (message?.type === RUNNING_UPDATE_HANDOFF_MESSAGE
+        && typeof message.sessionId === 'string'
+        && message.sessionId.length > 0) {
+        handoffSessionId = message.sessionId;
+      }
+    },
+  });
   const loaded = await core.loaded;
   await releaseNotice();
   const result = await core.completed;
   if (result.error) throw result.error;
+  if (result.code === RUNNING_UPDATE_HANDOFF_EXIT_CODE
+    && preparedTarget !== undefined
+    && handoffSessionId !== undefined) {
+    const handoff = await handoffRuntime({
+      target: preparedTarget,
+      previous: { packageRoot, version: readPackageVersion() },
+      sessionId: handoffSessionId,
+      args,
+      probeTarget: options.probeRunningUpdate || (() => true),
+      stopOld: async () => {},
+      startCore: async ({ packageRoot: nextRoot, args: nextArgs }) => {
+        const nextCore = spawnProtectedCore(nextArgs, env, cwd, { 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: (target) => (options.activateRuntime || activateRuntime)(env.BLUN_SHARED_HOME, target),
+    });
+    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);
+  }
   return exitCodeForChild(result, loaded);
 }
 
@@ -211,8 +337,40 @@ function spawnManagedLauncher(binary, cwd) {
   });
 }
 
+function spawnActiveLauncher(packageRoot, cwd) {
+  const entryName = path.basename(process.argv[1] || 'king.js').toLowerCase() === 'blun.js'
+    ? 'blun.js'
+    : 'king.js';
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(packageRoot, 'bin', entryName), ...RAW_ARGS], {
+      cwd,
+      env: { ...process.env, BLUN_ACTIVE_RUNTIME_ROOT: packageRoot },
+      stdio: 'inherit',
+      windowsHide: true,
+    });
+    child.once('error', reject);
+    child.once('exit', (code, signal) => {
+      if (Number.isInteger(code)) resolve(code);
+      else if (signal === 'SIGINT') resolve(130);
+      else if (signal === 'SIGTERM') resolve(143);
+      else resolve(1);
+    });
+  });
+}
+
 async function runLauncher(options = {}) {
   const callerCwd = process.cwd();
+  if (options.skipActiveRuntime !== true) {
+    const activeHome = resolveLauncherPrivatePaths().sharedHome;
+    const activeRuntime = readActiveRuntime(activeHome);
+    const currentVersion = readPackageVersion();
+    if (activeRuntime !== null
+      && path.resolve(activeRuntime.packageRoot) !== PKG
+      && compareSemver(currentVersion, activeRuntime.version) === -1) {
+      process.exitCode = await spawnActiveLauncher(activeRuntime.packageRoot, callerCwd);
+      return;
+    }
+  }
   const mode = options.mode || launcherModeFromArgv(process.argv);
   const explicitUpdateRequest = isNpmPackageUpdateRequest(ARGS);
   const explicitToolsRequest = String(ARGS[0] || '').toLowerCase() === 'tools';
@@ -271,12 +429,12 @@ async function runLauncher(options = {}) {
         if (mcpNames.length > 0) {
           seedStandardTools({
             packageRoot: PKG,
-            blunDir: privatePaths.blunHome,
+            blunDir: privatePaths.profilePaths.home,
             names: mcpNames,
           });
         }
         if (selected.includes('telegram')) {
-          installTelegramForProfile(PKG, privatePaths.blunHome);
+          installTelegramForProfile(PKG, privatePaths.profilePaths.home);
         }
         process.stdout.write(`${selected.join('\n')}\n`);
         return;
@@ -298,7 +456,7 @@ async function runLauncher(options = {}) {
         stdin: process.stdin,
         stdout: process.stdout,
         stderr: process.stderr,
-        blunDir: privatePaths.blunHome,
+        blunDir: privatePaths.sharedHome,
         packageRoot: PKG,
         noticeLease,
         request: ARGS[0],
@@ -307,13 +465,13 @@ async function runLauncher(options = {}) {
       return;
     }
 
-    let privatePaths;
+    let privatePathsCache;
     const getPrivatePaths = () => {
-      privatePaths ||= resolveLauncherPrivatePaths();
-      return privatePaths;
+      privatePathsCache ||= resolveLauncherPrivatePaths();
+      return privatePathsCache;
     };
     const nodeRuntime = await prepareManagedNodeRuntime({
-      getBlunDir: () => getPrivatePaths().blunHome,
+      getBlunDir: () => getPrivatePaths().sharedHome,
     });
     if (nodeRuntime.kind === 'failed') {
       process.stderr.write(`${nodeRuntime.message}\n`);
@@ -332,12 +490,24 @@ async function runLauncher(options = {}) {
       const env = createLauncherEnvironment(process.env, mode, readPackageVersion());
       const informationalEnv = { ...process.env };
       delete informationalEnv.BLUN_HOME;
-      env.BLUN_HOME = resolveLauncherPrivatePaths({ env: informationalEnv }).blunHome;
+      delete informationalEnv.BLUN_SHARED_HOME;
+      const privatePaths = resolveLauncherPrivatePaths({ env: informationalEnv });
+      const profilePaths = privatePaths.profilePaths;
+      env.BLUN_HOME = profilePaths.home;
+      env.BLUN_SHARED_HOME = privatePaths.sharedHome;
+      env.BLUN_LOG_HOME = privatePaths.sharedHome;
+      env.BLUN_PROFILE = PROFILE.profileName;
       process.exitCode = await superviseProtectedCore(ARGS, env, callerCwd, releaseNotice);
       return;
     }
 
-    const blunDir = getPrivatePaths().blunHome;
+    const privatePaths = getPrivatePaths();
+    const profilePaths = privatePaths.profilePaths;
+    ensurePrivateDirectory(privatePaths.sharedHome);
+    if (PROFILE.profileName === 'default') {
+      seedDefaultProfileFromLegacy(privatePaths.sharedHome);
+    }
+    const blunDir = profilePaths.home;
     ensurePrivateDirectory(blunDir);
 
     // --- 1. Oeffentlicher npm-Update-Dialog. -------------------------------
@@ -350,7 +520,7 @@ async function runLauncher(options = {}) {
         stdin: process.stdin,
         stdout: process.stdout,
         stderr: process.stderr,
-        blunDir,
+        blunDir: privatePaths.sharedHome,
         packageRoot: PKG,
         noticeLease,
       });
@@ -382,7 +552,7 @@ async function runLauncher(options = {}) {
     });
 
   // --- 4. Eigenes BLUN-Grunddesign als einzigen Standard-Skill installieren
-    seedStandardDesignSkill({ packageRoot: PKG, blunDir });
+    seedStandardDesignSkill({ packageRoot: PKG, blunDir: privatePaths.sharedHome });
 
     // --- 5. Telegram-Plugin + Token-Vorlage (nur King) -----------------------
     if (mode === LAUNCHER_MODES.KING) {
@@ -402,7 +572,10 @@ async function runLauncher(options = {}) {
 
     // --- 6. Start -----------------------------------------------------------
     const env = createLauncherEnvironment(process.env, mode, readPackageVersion());
-    env.BLUN_HOME = blunDir;
+    env.BLUN_HOME = profilePaths.home;
+    env.BLUN_SHARED_HOME = privatePaths.sharedHome;
+    env.BLUN_LOG_HOME = privatePaths.sharedHome;
+    env.BLUN_PROFILE = PROFILE.profileName;
     env.BLUN_MODEL_MAX_COMPLETION_TOKENS = env.BLUN_MODEL_MAX_COMPLETION_TOKENS || '32768';
     process.exitCode = await superviseProtectedCore(
       ARGS,