blun-king-cli 9.1.624 → 9.1.626

package/bin/launcher-runtime.js

@@ -33,69 +33,28 @@ const { unsupportedNodeMessage } = require('./node-version');
 const { repairConfiguredNativeModules } = require('./native-module-repair');
 const { acquireSharedRuntimeLease, tryAcquireUpdateLease } = require('./update-lease');
 const { runExplicitUpdate, runUpdateNotice } = require('./update-notice');
-const {
-  ensurePrivateDirectory,
-  securePrivateFile,
-  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));
-const ARGS = PROFILE.args;
-const CORE_LOAD_TIMEOUT_MS = 30_000;
+const {
+  ensurePrivateDirectory,
+  securePrivateFile,
+  writePrivateFile,
+} = require('./private-paths');
+
+const PKG = path.resolve(__dirname, '..');
+const ARGS = process.argv.slice(2);
 
-function normalizeWindowsPath(value) {
-  return path.win32.normalize(value).replace(/\\+$/u, '').toLowerCase();
-}
-
-function runningTuiPid(blunDir, options = {}) {
-  const fsImpl = options.fsImpl || fs;
-  const kill = options.kill || process.kill.bind(process);
-  const now = options.now ?? Date.now();
-  const stateDir = path.join(blunDir, 'channels', 'telegram');
-  try {
-    const leaseFile = path.join(stateDir, 'tui.pid');
-    const owner = JSON.parse(fsImpl.readFileSync(path.join(stateDir, 'tui-owner.json'), 'utf8'));
-    const leasePid = Number(fsImpl.readFileSync(leaseFile, 'utf8').trim());
-    if (owner?.version !== 1 || !Number.isSafeInteger(owner.pid) || owner.pid <= 1
-      || owner.pid !== leasePid || now - fsImpl.statSync(leaseFile).mtimeMs > 90_000) return null;
-    kill(owner.pid, 0);
-    return owner.pid;
-  } catch {
-    return null;
-  }
-}
-
-function isInteractiveKingStart(args) {
-  return args.length === 0 || (args.length === 1 && args[0] === '-c');
-}
+function normalizeWindowsPath(value) {
+  return path.win32.normalize(value).replace(/\\+$/u, '').toLowerCase();
+}
 
-function resolveLauncherPrivatePaths(options = {}) {
-  const env = options.env || process.env;
-  const platform = options.platform || process.platform;
-  const configuredHome = String(env.BLUN_HOME || '').trim();
-  const selectedProfile = options.profileName ?? PROFILE.name;
-  if (platform !== 'win32') {
-    const posix = path.posix;
-    const userHome = (options.homedir || os.homedir)();
-    if (selectedProfile !== undefined) {
-      const configuredShared = String(env.BLUN_SHARED_HOME || '').trim();
-      const sharedHome = configuredShared
-        ? posix.resolve(configuredShared)
-        : configuredHome && posix.basename(posix.dirname(configuredHome)) === 'profile'
-          ? posix.resolve(configuredHome, '..', '..')
-          : configuredHome ? posix.resolve(configuredHome) : posix.join(userHome, '.blun');
-      const blunHome = resolveSelectedProfile(sharedHome, selectedProfile, posix);
-      if (configuredShared && configuredHome && posix.resolve(configuredHome) !== blunHome) {
-        throw new Error(`BLUN_HOME passt nicht zum Profil ${selectedProfile}: ${blunHome}`);
-      }
-      return { blunHome, sharedHome, userHome };
-    }
-    return {
-      blunHome: configuredHome ? path.resolve(configuredHome) : path.join(userHome, '.blun'),
-      userHome,
+function resolveLauncherPrivatePaths(options = {}) {
+  const env = options.env || process.env;
+  const platform = options.platform || process.platform;
+  const configuredHome = String(env.BLUN_HOME || '').trim();
+  if (platform !== 'win32') {
+    const userHome = (options.homedir || os.homedir)();
+    return {
+      blunHome: configuredHome ? path.resolve(configuredHome) : path.join(userHome, '.blun'),
+      userHome,
     };
   }
 
@@ -118,20 +77,8 @@ function resolveLauncherPrivatePaths(options = {}) {
     throw new Error('Das lokale Windows-Benutzerprofil ist kein kanonischer lokaler Pfad.');
   }
 
-  const blunHome = path.win32.join(userHome, '.blun');
-  if (selectedProfile !== undefined) {
-    const profileHome = resolveSelectedProfile(blunHome, selectedProfile, path.win32);
-    const configuredShared = String(env.BLUN_SHARED_HOME || '').trim();
-    if (configuredShared && normalizeWindowsPath(path.win32.resolve(configuredShared)) !== normalizeWindowsPath(blunHome)) {
-      throw new Error(`BLUN_SHARED_HOME muss unter Windows exakt im Windows-Benutzerprofil liegen: ${blunHome}`);
-    }
-    if (configuredHome && normalizeWindowsPath(path.win32.resolve(configuredHome)) !== normalizeWindowsPath(profileHome)
-      && normalizeWindowsPath(path.win32.resolve(configuredHome)) !== normalizeWindowsPath(blunHome)) {
-      throw new Error(`BLUN_HOME passt nicht zum Profil ${selectedProfile}: ${profileHome}`);
-    }
-    return { blunHome: profileHome, sharedHome: blunHome, userHome };
-  }
-  if (configuredHome
+  const blunHome = path.win32.join(userHome, '.blun');
+  if (configuredHome
     && normalizeWindowsPath(path.win32.resolve(configuredHome)) !== normalizeWindowsPath(blunHome)) {
     throw new Error(`BLUN_HOME muss unter Windows exakt im Windows-Benutzerprofil liegen: ${blunHome}`);
   }
@@ -148,42 +95,35 @@ function readPackageVersion() {
 
 function shouldDetachProtectedCore(options = {}) {
   const platform = options.platform || process.platform;
-  if (platform === 'win32' && options.interactive === true) return false;
   const stdinIsTTY = Object.hasOwn(options, 'stdinIsTTY')
     ? options.stdinIsTTY
     : process.stdin.isTTY;
   return platform !== 'win32' || stdinIsTTY !== true;
 }
 
-function spawnProtectedCore(args, env, cwd, onProfileMessage) {
+function spawnProtectedCore(args, env, cwd) {
+  const terminalOwner = process.platform === 'win32' && process.stdin.isTTY === true;
   const child = spawn(
     process.execPath,
     [path.join(PKG, 'bin', 'core-bootstrap.js'), ...args],
     {
       cwd,
-      detached: shouldDetachProtectedCore({ interactive: Boolean(onProfileMessage) }),
-      env: { ...env, BLUN_TERMINAL_OWNER: process.platform === 'win32' && onProfileMessage ? '1' : '0' },
+      detached: shouldDetachProtectedCore(),
+      env: { ...env, BLUN_TERMINAL_OWNER: terminalOwner ? '1' : '0' },
       stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
       windowsHide: true,
     },
   );
   let loadedSettled = false;
   let completedSettled = false;
-  let operatorSignal;
-  let profileReady = false;
+  let operatorSignal;
   let resolveLoaded;
   let resolveCompleted;
-  const loadTimer = setTimeout(() => {
-    try {
-      child.kill();
-    } catch {}
-  }, CORE_LOAD_TIMEOUT_MS);
   const loaded = new Promise((resolve) => { resolveLoaded = resolve; });
   const completed = new Promise((resolve) => { resolveCompleted = resolve; });
   const settleLoaded = (value) => {
     if (loadedSettled) return;
     loadedSettled = true;
-    clearTimeout(loadTimer);
     resolveLoaded(value);
   };
   const settleCompleted = (result) => {
@@ -204,29 +144,17 @@ function spawnProtectedCore(args, env, cwd, onProfileMessage) {
     signalHandlers.set(signal, handler);
     process.once(signal, handler);
   }
-  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.on('message', (message) => {
+    if (message?.type !== CORE_LOADED_MESSAGE) return;
+    settleLoaded(true);
+    if (terminalOwner) return;
+    try {
+      child.disconnect();
+    } catch {}
   });
   child.once('error', (error) => settleCompleted({ error }));
   child.once('exit', (code, signal) => settleCompleted({ code, signal }));
-  return { child, completed, loaded, isProfileReady: () => profileReady };
+  return { child, completed, loaded };
 }
 
 async function runInformationalCore(args, env, cwd, releaseNotice) {
@@ -238,14 +166,10 @@ async function runInformationalCore(args, env, cwd, releaseNotice) {
   return Number.isInteger(result.code) ? result.code : exitCodeForChild(result, false);
 }
 
-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)));
+async function superviseProtectedCore(args, env, cwd, releaseNotice) {
+  let noticeReleased = false;
+  for (;;) {
+    const core = spawnProtectedCore(args, env, cwd);
     const loaded = await core.loaded;
     if (!noticeReleased) {
       noticeReleased = true;
@@ -256,47 +180,12 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     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,
-    });
-    // 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;
-      }
-    }
+      loaded, childPid: core.child.pid, error: result.error,
+    });
     if (intentionalStop || !isAbnormalCoreExit(result, loaded)) {
       if (result.error) throw result.error;
       return exitCode;
@@ -327,7 +216,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');
@@ -339,37 +228,7 @@ 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) => {
@@ -503,29 +362,18 @@ async function runLauncher(options = {}) {
       }
       process.stdout.write(launcherHelpText());
       const env = createLauncherEnvironment(process.env, mode, readPackageVersion());
-      const informationalEnv = { ...process.env };
-      delete informationalEnv.BLUN_HOME;
-      const paths = resolveLauncherPrivatePaths({ env: informationalEnv });
-      env.BLUN_HOME = paths.blunHome;
-      if (PROFILE.name !== undefined) {
-        env.BLUN_SHARED_HOME = paths.sharedHome;
-        env.BLUN_PROFILE = PROFILE.name;
-      }
+      const informationalEnv = { ...process.env };
+      delete informationalEnv.BLUN_HOME;
+      env.BLUN_HOME = resolveLauncherPrivatePaths({ env: informationalEnv }).blunHome;
       process.exitCode = await runInformationalCore(ARGS, env, callerCwd, releaseNotice);
       return;
     }
 
-    let privatePaths;
-    const getPrivatePaths = () => {
-      if (!privatePaths) {
-        const resolved = resolveLauncherPrivatePaths();
-        if (PROFILE.implicit && !fs.existsSync(resolved.blunHome)) {
-          throw new Error(`Profil ${PROFILE.name} gibt es nicht. Anlegen mit king --profile ${PROFILE.name}.`);
-        }
-        privatePaths = resolved;
-      }
-      return privatePaths;
-    };
+    let privatePaths;
+    const getPrivatePaths = () => {
+      privatePaths ||= resolveLauncherPrivatePaths();
+      return privatePaths;
+    };
     const nodeRuntime = await prepareManagedNodeRuntime({
       getBlunDir: () => getPrivatePaths().blunHome,
     });
@@ -544,28 +392,15 @@ async function runLauncher(options = {}) {
     if (ARGS.some((arg) => arg === '--help' || arg === '-h')) {
       process.stdout.write(launcherHelpText());
       const env = createLauncherEnvironment(process.env, mode, readPackageVersion());
-      const informationalEnv = { ...process.env };
-      delete informationalEnv.BLUN_HOME;
-      const paths = resolveLauncherPrivatePaths({ env: informationalEnv });
-      env.BLUN_HOME = paths.blunHome;
-      if (PROFILE.name !== undefined) {
-        env.BLUN_SHARED_HOME = paths.sharedHome;
-        env.BLUN_PROFILE = PROFILE.name;
-      }
+      const informationalEnv = { ...process.env };
+      delete informationalEnv.BLUN_HOME;
+      env.BLUN_HOME = resolveLauncherPrivatePaths({ env: informationalEnv }).blunHome;
       process.exitCode = await superviseProtectedCore(ARGS, env, callerCwd, releaseNotice);
       return;
     }
 
-    const blunDir = getPrivatePaths().blunHome;
-    if (mode === LAUNCHER_MODES.KING && isInteractiveKingStart(ARGS)) {
-      const activePid = runningTuiPid(blunDir);
-      if (activePid !== null) {
-        process.stderr.write(`King läuft bereits (PID ${activePid}).\n`);
-        process.exitCode = 1;
-        return;
-      }
-    }
-    ensurePrivateDirectory(blunDir);
+    const blunDir = getPrivatePaths().blunHome;
+    ensurePrivateDirectory(blunDir);
 
     // --- 1. Oeffentlicher npm-Update-Dialog. -------------------------------
     const updateResult = options.skipUpdateNotice === true
@@ -596,53 +431,55 @@ async function runLauncher(options = {}) {
   // --- 2. Bestehende Konfiguration absichern -------------------------------
   // Ein frischer Start bleibt absichtlich ohne statischen Anbieter. /login
   // provisioniert King ueber den BLUN-OAuth-Server.
-    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);
+    const cfgFile = path.join(blunDir, 'config.toml');
+    if (fs.existsSync(cfgFile)) securePrivateFile(cfgFile);
+    require('./verify-bundled-agent-sources.cjs').verifyBundledAgentSources(PKG);
+
+    // --- 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 -----------------------------------------------------------
-    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;
+    // --- 6. Start -----------------------------------------------------------
+    const env = createLauncherEnvironment(process.env, mode, readPackageVersion(), blunDir);
+    env.BLUN_HOME = blunDir;
     process.exitCode = await superviseProtectedCore(
       ARGS,
       env,
       callerCwd,
-      releaseNotice,
-      handoffOptions,
+      releaseNotice,
     );
   } finally {
     await releaseNotice();
   }
 }
 
-module.exports = {
-  withProfileRuntimeReservation,
-  resolveLauncherPrivatePaths,
-  isInteractiveKingStart,
-  runningTuiPid,
+module.exports = {
+  resolveLauncherPrivatePaths,
   runLauncher,
   shouldDetachProtectedCore,
   spawnManagedLauncher,