blun-king-cli 9.1.616 → 9.1.617

package/bin/launcher-runtime.js

@@ -39,6 +39,7 @@ const {
   writePrivateFile,
 } = require('./private-paths');
 const { parseProfileLaunchArgs, resolveSelectedProfile } = require('./profile-launch.cjs');
+const { createProfileHandoff, PROFILE_HANDOFF_READY, PROFILE_HANDOFF_EXIT } = require('./profile-handoff.cjs');
 
 const PKG = path.resolve(__dirname, '..');
 const PROFILE = parseProfileLaunchArgs(process.argv.slice(2), launcherModeFromArgv(process.argv));
@@ -153,7 +154,7 @@ function shouldDetachProtectedCore(options = {}) {
   return platform !== 'win32' || stdinIsTTY !== true;
 }
 
-function spawnProtectedCore(args, env, cwd) {
+function spawnProtectedCore(args, env, cwd, onProfileMessage) {
   const child = spawn(
     process.execPath,
     [path.join(PKG, 'bin', 'core-bootstrap.js'), ...args],
@@ -167,7 +168,8 @@ function spawnProtectedCore(args, env, cwd) {
   );
   let loadedSettled = false;
   let completedSettled = false;
-  let operatorSignal;
+  let operatorSignal;
+  let profileReady = false;
   let resolveLoaded;
   let resolveCompleted;
   const loadTimer = setTimeout(() => {
@@ -201,16 +203,29 @@ function spawnProtectedCore(args, env, cwd) {
     signalHandlers.set(signal, handler);
     process.once(signal, handler);
   }
-  child.on('message', (message) => {
-    if (message?.type !== CORE_LOADED_MESSAGE) return;
-    settleLoaded(true);
-    try {
-      child.disconnect();
-    } catch {}
+  child.on('message', (message) => {
+    if (message?.type !== CORE_LOADED_MESSAGE) {
+      if (completedSettled || !onProfileMessage) return;
+      if (message?.type === PROFILE_HANDOFF_READY && Object.keys(message).length === 1) {
+        profileReady = true;
+        return;
+      }
+      if (!loadedSettled) return;
+      const reply = onProfileMessage(message);
+      if (reply) {
+        try { child.send(reply, () => {}); } catch {}
+      }
+      return;
+    }
+    settleLoaded(true);
+    if (onProfileMessage) child.channel?.unref();
+    else {
+      try { child.disconnect(); } catch {}
+    }
   });
   child.once('error', (error) => settleCompleted({ error }));
   child.once('exit', (code, signal) => settleCompleted({ code, signal }));
-  return { child, completed, loaded };
+  return { child, completed, loaded, isProfileReady: () => profileReady };
 }
 
 async function runInformationalCore(args, env, cwd, releaseNotice) {
@@ -222,10 +237,14 @@ async function runInformationalCore(args, env, cwd, releaseNotice) {
   return Number.isInteger(result.code) ? result.code : exitCodeForChild(result, false);
 }
 
-async function superviseProtectedCore(args, env, cwd, releaseNotice) {
-  let noticeReleased = false;
-  for (;;) {
-    const core = spawnProtectedCore(args, env, cwd);
+async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {}) {
+  let noticeReleased = false;
+  let rollback;
+  let recoveryAttempted = false;
+  for (;;) {
+    const handoff = options.prepareProfile
+      ? createProfileHandoff(env, target => runningTuiPid(target) !== null) : undefined;
+    const core = spawnProtectedCore(args, env, cwd, handoff && ((message) => handoff.prepare(message)));
     const loaded = await core.loaded;
     if (!noticeReleased) {
       noticeReleased = true;
@@ -236,12 +255,47 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice) {
     const intentionalStop = consumeIntentionalStopMarker({
       homeDir: env.BLUN_HOME, childPid: core.child.pid, nowMs: Date.now(),
     });
-    recordRuntimeExit({
+    recordRuntimeExit({
       homeDir: env.BLUN_HOME, source: 'launcher', kind: result.error ? 'child-error' : 'child-exit',
       exitCode, signal: result.signal, phase: loaded ? 'runtime' : 'startup',
       cliVersion: env.BLUN_PUBLIC_PACKAGE_VERSION, profile: env.BLUN_PROFILE,
-      loaded, childPid: core.child.pid, error: result.error,
-    });
+      loaded, childPid: core.child.pid, error: result.error,
+    });
+    // A profile transition is committed only after the old process exits cleanly.
+    // Failed target startup restores the previous owner, never the previous PID.
+    if (rollback && (!loaded || !core.isProfileReady()) && !result.signal) {
+      ({ args, env } = rollback);
+      rollback = undefined;
+      continue;
+    }
+    if (loaded && core.isProfileReady()) {
+      rollback = undefined;
+      recoveryAttempted = false;
+    }
+    if (handoff && loaded && !intentionalStop && !result.error && !result.signal
+      && result.code === PROFILE_HANDOFF_EXIT) {
+      if (!handoff.hasPending()) return 1;
+      const sourceSessionId = handoff.getSourceSessionId();
+      const recoveryArgs = sourceSessionId === undefined ? ['-c'] : ['-r', sourceSessionId];
+      try {
+        const selected = handoff.commit();
+        const nextEnv = await options.prepareProfile(selected);
+        handoff.commit();
+        rollback = { args: recoveryArgs, env };
+        args = ['-c'];
+        env = { ...nextEnv, BLUN_PROFILE_HANDOFF: '1' };
+        continue;
+      } catch (error) {
+        recordRuntimeExit({ homeDir: env.BLUN_HOME, source: 'launcher', kind: 'profile-handoff-failure',
+          phase: 'startup', cliVersion: env.BLUN_PUBLIC_PACKAGE_VERSION, profile: env.BLUN_PROFILE,
+          exitCode: 1, error });
+        if (recoveryAttempted) return 1;
+        recoveryAttempted = true;
+        // Reopen the original owner when the selection became unavailable.
+        args = recoveryArgs;
+        continue;
+      }
+    }
     if (intentionalStop || !isAbnormalCoreExit(result, loaded)) {
       if (result.error) throw result.error;
       return exitCode;
@@ -272,7 +326,7 @@ function exitCodeForChild(result, loaded) {
   return 1;
 }
 
-function installTelegramForProfile(packageRoot, blunDir) {
+function installTelegramForProfile(packageRoot, blunDir) {
   installManagedTelegramPlugin({ packageRoot, blunDir });
   const channelsDir = path.join(blunDir, 'channels');
   const channelDir = path.join(channelsDir, 'telegram');
@@ -284,7 +338,37 @@ function installTelegramForProfile(packageRoot, blunDir) {
   } else {
     securePrivateFile(envFile);
   }
-}
+}
+
+function prepareProfileRuntime(blunDir, callerCwd, mode) {
+  ensurePrivateDirectory(blunDir);
+  const cfgFile = path.join(blunDir, 'config.toml');
+  if (fs.existsSync(cfgFile)) securePrivateFile(cfgFile);
+  const standardMcpNames = availableStandardToolNames({ packageRoot: PKG })
+    .filter((name) => name !== 'telegram');
+  seedStandardTools({ packageRoot: PKG, blunDir, names: standardMcpNames });
+  seedStandardDesignSkill({ packageRoot: PKG, blunDir });
+  installManagedAgentSpinePlugin({ packageRoot: PKG, blunDir });
+  if (mode === LAUNCHER_MODES.KING) installTelegramForProfile(PKG, blunDir);
+  return repairConfiguredNativeModules({
+    blunDir, callerCwd,
+    onRepairStart() {
+      process.stdout.write('BLUN richtet native Node.js-Module fuer die neue Laufzeit ein.\n');
+    },
+  });
+}
+
+async function withProfileRuntimeReservation(homeDir, work) {
+  const result = await tryAcquireUpdateLease({ packageRoot: homeDir, role: 'profile' });
+  if (!result.acquired) throw Object.assign(new Error(`PROFILE_RUNTIME_${result.reason.toUpperCase()}`),
+    { code: result.reason === 'busy' ? 'PROFILE_RUNTIME_BUSY' : 'PROFILE_RUNTIME_UNAVAILABLE' });
+  try {
+    result.lease.assertOwned();
+    const value = await work();
+    result.lease.assertOwned();
+    return value;
+  } finally { await result.lease.release(); }
+}
 
 function spawnManagedLauncher(binary, cwd) {
   return new Promise((resolve, reject) => {
@@ -511,51 +595,42 @@ async function runLauncher(options = {}) {
   // --- 2. Bestehende Konfiguration absichern -------------------------------
   // Ein frischer Start bleibt absichtlich ohne statischen Anbieter. /login
   // provisioniert King ueber den BLUN-OAuth-Server.
-    const cfgFile = path.join(blunDir, 'config.toml');
-    if (fs.existsSync(cfgFile)) securePrivateFile(cfgFile);
-    require('./verify-bundled-agent-sources.cjs').verifyBundledAgentSources(PKG);
+    require('./verify-bundled-agent-sources.cjs').verifyBundledAgentSources(PKG);
+    const nativeModules = mode === LAUNCHER_MODES.KING && isInteractiveKingStart(ARGS)
+      ? await withProfileRuntimeReservation(blunDir, () => prepareProfileRuntime(blunDir, callerCwd, mode))
+      : prepareProfileRuntime(blunDir, callerCwd, mode);
 
-    // --- 3. BLUN-Standard-MCPs additiv im Benutzerprofil einrichten ---------
-    const standardMcpNames = availableStandardToolNames({ packageRoot: PKG })
-      .filter((name) => name !== 'telegram');
-    seedStandardTools({
-      packageRoot: PKG,
-      blunDir,
-      names: standardMcpNames,
-    });
-
-  // --- 4. Eigenes BLUN-Grunddesign als einzigen Standard-Skill installieren
-    seedStandardDesignSkill({ packageRoot: PKG, blunDir });
-    installManagedAgentSpinePlugin({ packageRoot: PKG, blunDir });
-
-    // --- 5. Telegram-Plugin + Token-Vorlage (nur King) -----------------------
-    if (mode === LAUNCHER_MODES.KING) {
-      installTelegramForProfile(PKG, blunDir);
-    }
-
-    const nativeModules = repairConfiguredNativeModules({
-      blunDir,
-      callerCwd,
-      onRepairStart() {
-        process.stdout.write('BLUN richtet native Node.js-Module fuer die neue Laufzeit ein.\n');
-      },
-    });
     if (nativeModules.repaired.length > 0) {
       process.stdout.write('Native Node.js-Module sind wieder einsatzbereit.\n');
     }
 
-    // --- 6. Start -----------------------------------------------------------
+    // --- 6. Start -----------------------------------------------------------
     const env = createLauncherEnvironment(process.env, mode, readPackageVersion(), blunDir);
     env.BLUN_HOME = blunDir;
     if (PROFILE.name !== undefined) {
       env.BLUN_SHARED_HOME = getPrivatePaths().sharedHome;
       env.BLUN_PROFILE = PROFILE.name;
     }
+    const handoffOptions = mode === LAUNCHER_MODES.KING && isInteractiveKingStart(ARGS)
+      ? { prepareProfile: async (selected) => {
+        const target = selected.homeDir;
+        await withProfileRuntimeReservation(target, () => prepareProfileRuntime(target, callerCwd, mode));
+        const next = createLauncherEnvironment(process.env, mode, readPackageVersion(), target);
+        next.BLUN_HOME = target;
+        next.BLUN_SHARED_HOME = selected.sharedHome;
+        next.BLUN_PROFILE = selected.name;
+        delete next.BLUN_TELEGRAM_STATE_DIR;
+        delete next.BLUN_PLUGIN_ROOT;
+        return next;
+      } } : {};
+    if (handoffOptions.prepareProfile) env.BLUN_PROFILE_HANDOFF = '1';
+    else delete env.BLUN_PROFILE_HANDOFF;
     process.exitCode = await superviseProtectedCore(
       ARGS,
       env,
       callerCwd,
-      releaseNotice,
+      releaseNotice,
+      handoffOptions,
     );
   } finally {
     await releaseNotice();
@@ -563,6 +638,7 @@ async function runLauncher(options = {}) {
 }
 
 module.exports = {
+  withProfileRuntimeReservation,
   resolveLauncherPrivatePaths,
   isInteractiveKingStart,
   runningTuiPid,

package/bin/profile-handoff.cjs

@@ -0,0 +1,152 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { randomUUID } = require('node:crypto');
+const { listExistingProfiles, resolveSelectedProfile } = require('./profile-launch.cjs');
+
+const PROFILE_HANDOFF_REQUEST = 'blun-profile-handoff-request';
+const PROFILE_HANDOFF_REPLY = 'blun-profile-handoff-reply';
+const PROFILE_HANDOFF_CANCEL = 'blun-profile-handoff-cancel';
+const PROFILE_HANDOFF_READY = 'blun-profile-handoff-ready';
+const PROFILE_HANDOFF_EXIT = 76;
+const REQUEST_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
+const SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/u;
+const samePath = (a, b) => process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b;
+const unavailable = () => Object.assign(new Error('PROFILE_HANDOFF_UNAVAILABLE'), { code: 'PROFILE_HANDOFF_UNAVAILABLE' });
+
+function createProfileHandoff(env, isBusy = () => false) {
+  let pending;
+  const validate = (name) => {
+    if (typeof env.BLUN_HOME !== 'string' || !path.isAbsolute(env.BLUN_HOME)
+      || (env.BLUN_SHARED_HOME !== undefined && !path.isAbsolute(env.BLUN_SHARED_HOME))) throw unavailable();
+    const sharedHome = path.resolve(env.BLUN_SHARED_HOME || env.BLUN_HOME);
+    const homeDir = path.resolve(env.BLUN_HOME);
+    const current = env.BLUN_PROFILE;
+    if (current !== undefined) {
+      if (!env.BLUN_SHARED_HOME || path.basename(resolveSelectedProfile(sharedHome, current)) !== current
+        || !samePath(homeDir, resolveSelectedProfile(sharedHome, current))) throw unavailable();
+    } else if (!samePath(homeDir, sharedHome)) throw unavailable();
+    const names = listExistingProfiles(sharedHome);
+    if (typeof name !== 'string' || !names.includes(name) || name === current
+      || (current !== undefined && !names.includes(current))) throw unavailable();
+    const target = resolveSelectedProfile(sharedHome, name);
+    if (isBusy(target)) throw unavailable();
+    const identities = [sharedHome, path.join(sharedHome, 'profile'), homeDir, target]
+      .map(file => ({ file, stat: fs.lstatSync(file, { bigint: true }) }));
+    if (identities.some(({ stat }) => !stat.isDirectory() || stat.isSymbolicLink())) throw unavailable();
+    return { name, sharedHome, homeDir: target, identities };
+  };
+  return {
+    hasPending: () => pending !== undefined,
+    getSourceSessionId: () => pending?.sourceSessionId,
+    prepare(message) {
+      if (message?.type === PROFILE_HANDOFF_CANCEL && typeof message.requestId === 'string'
+        && REQUEST_ID.test(message.requestId) && Object.keys(message).sort().join(',') === 'requestId,type') {
+        if (pending?.requestId === message.requestId) pending = undefined;
+        return { type: PROFILE_HANDOFF_REPLY, requestId: message.requestId, status: 'cancelled' };
+      }
+      if (!message || message.type !== PROFILE_HANDOFF_REQUEST || typeof message.requestId !== 'string' || !REQUEST_ID.test(message.requestId)) return undefined;
+      const shape = Object.keys(message).sort().join(',');
+      if (shape !== 'name,requestId,type' && shape !== 'name,requestId,sourceSessionId,type') return undefined;
+      if (shape === 'name,requestId,sourceSessionId,type'
+        && (typeof message.sourceSessionId !== 'string' || !SESSION_ID.test(message.sourceSessionId))) return undefined;
+      let status = 'rejected';
+      try {
+        if (pending) {
+          if (pending.requestId === message.requestId && pending.name === message.name
+            && pending.sourceSessionId === message.sourceSessionId) status = 'prepared';
+        } else {
+          pending = { ...validate(message.name), requestId: message.requestId, sourceSessionId: message.sourceSessionId };
+          status = 'prepared';
+        }
+      } catch {}
+      return { type: PROFILE_HANDOFF_REPLY, requestId: message.requestId, status };
+    },
+    commit() {
+      try {
+        if (!pending) throw unavailable();
+        const fresh = validate(pending.name);
+        for (let index = 0; index < pending.identities.length; index++) {
+          const before = pending.identities[index];
+          const after = fresh.identities[index];
+          if (before.file !== after.file || before.stat.dev !== after.stat.dev || before.stat.ino !== after.stat.ino) throw unavailable();
+        }
+        return Object.freeze({ name: fresh.name, sharedHome: fresh.sharedHome, homeDir: fresh.homeDir,
+          ...(pending.sourceSessionId === undefined ? {} : { sourceSessionId: pending.sourceSessionId }) });
+      } catch {
+        throw unavailable();
+      }
+    },
+  };
+}
+
+function createProfileHandoffClient(channel = process) {
+  const enabled = channel.env?.BLUN_PROFILE_HANDOFF === '1';
+  let pending;
+  let disposed = false;
+  const available = () => !disposed && enabled && channel.connected === true
+    && typeof channel.send === 'function';
+  const cancel = () => {
+    const request = pending;
+    if (!request) return;
+    pending = undefined;
+    request.finish(false);
+    if (channel.connected === true) {
+      try { channel.send({ type: PROFILE_HANDOFF_CANCEL, requestId: request.id }, () => {}); } catch {}
+    }
+  };
+  return Object.freeze({
+    isPrepared: () => available() && pending?.prepared === true,
+    cancel,
+    dispose() { cancel(); disposed = true; },
+    /** @param {string} name @param {{ signal?: AbortSignal, timeoutMs?: number, sourceSessionId?: string }} [options] */
+    prepare(name, { signal, timeoutMs = 5000, sourceSessionId } = {}) {
+      try {
+        if (!available() || pending || signal?.aborted || typeof name !== 'string'
+          || path.basename(resolveSelectedProfile(path.parse(__dirname).root, name)) !== name
+          || !Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 30000
+          || (sourceSessionId !== undefined && (typeof sourceSessionId !== 'string' || !SESSION_ID.test(sourceSessionId)))) return Promise.resolve(false);
+      } catch { return Promise.resolve(false); }
+      return new Promise(resolve => {
+        const request = { id: randomUUID(), prepared: false, finish: undefined };
+        let settled = false;
+        let timer;
+        const aborted = () => cancel();
+        const disconnected = () => cancel();
+        const message = reply => {
+          if (pending !== request || reply?.type !== PROFILE_HANDOFF_REPLY || reply.requestId !== request.id
+            || Object.keys(reply).sort().join(',') !== 'requestId,status,type') return;
+          if (reply.status === 'prepared') request.finish(true);
+          else if (reply.status === 'rejected' || reply.status === 'cancelled') cancel();
+        };
+        request.finish = prepared => {
+          if (!prepared) signal?.removeEventListener('abort', aborted);
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          channel.removeListener('message', message);
+          channel.removeListener('disconnect', disconnected);
+          try { channel.channel?.unref(); } catch {}
+          request.prepared = prepared;
+          resolve(prepared);
+        };
+        pending = request;
+        channel.on('message', message);
+        channel.once('disconnect', disconnected);
+        signal?.addEventListener('abort', aborted, { once: true });
+        timer = setTimeout(aborted, timeoutMs);
+        try {
+          channel.channel?.ref();
+          channel.send({ type: PROFILE_HANDOFF_REQUEST, requestId: request.id, name,
+            ...(sourceSessionId === undefined ? {} : { sourceSessionId }) }, error => {
+            if (error && pending === request) cancel();
+          });
+        } catch { cancel(); }
+      });
+    },
+  });
+}
+
+module.exports = { createProfileHandoff, createProfileHandoffClient, PROFILE_HANDOFF_CANCEL, PROFILE_HANDOFF_REQUEST, PROFILE_HANDOFF_REPLY,
+  PROFILE_HANDOFF_READY, PROFILE_HANDOFF_EXIT };

package/bin/update-lease.js

@@ -34,7 +34,9 @@ function canonicalPackageIdentity(packageRoot, options = {}) {
 
 function deriveUpdateLeaseEndpoint(packageRoot, options = {}) {
   const platform = options.platform || process.platform;
-  const role = options.role === 'install'
+  const role = options.role === 'profile'
+    ? 'profile'
+    : options.role === 'install'
     ? 'install'
     : options.role === 'runtime'
       ? 'runtime'