blun-king-cli 9.1.60 → 9.1.62

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.59
+  npm install -g blun-king-cli@9.1.61
 
 Start
 -----
@@ -145,5 +145,14 @@ Telegram einrichten
 
    ~/.blun/channels/telegram/.env
 
-3. `king` starten und den angezeigten Pairing-Code mit
-   /telegram:access pair CODE bestätigen.
+3. `king` starten und in der Konsole eingeben:
+
+   /telegram:access connect
+
+4. Den dort erzeugten Einmalcode im gewünschten privaten Chat oder in der
+   gewünschten Gruppe senden:
+
+   /connect CODE
+
+Chat-ID und Absender-ID werden intern gespeichert und müssen nie eingegeben
+werden. Der Code verfällt nach zehn Minuten und funktioniert nur einmal.

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.59
+npm install -g blun-king-cli@9.1.61
 ```
 
 ## Reproduzierbares Staging und Packen
@@ -35,6 +35,11 @@ an. Version, Konto, Modell und Befehle sind ansonsten identisch. Der Unterschied
 gilt nur für den laufenden Prozess; die gespeicherte
 Plugin-Konfiguration wird nicht umgeschrieben.
 
+Telegram-Chats werden ohne manuell eingegebene IDs verbunden. In der Konsole
+erzeugt `/telegram:access connect` einen einmaligen Code. `/connect CODE` im
+gewünschten privaten Chat oder in einer Gruppe speichert Chat und Absender
+intern; der Code verfällt nach zehn Minuten und ist nur einmal verwendbar.
+
 ## Zuverlässiger King-Start
 
 Der Windows-Hilfsprozess für private Pfade übernimmt `TEMP` und `TMP` aus der
@@ -106,6 +111,10 @@ besten sicheren lokalen nächsten Schritt um. Der sichtbare Aufgabenplan und all
 Freigabegrenzen von `/idea` gelten weiterhin. Der Befehl funktioniert auch über
 Telegram.
 
+Der sichtbare Verlauf behält standardmäßig die vollständige laufende und
+wiederhergestellte Sitzung. Das Mausrad kann den Verlauf direkt beim ersten Zug
+öffnen; Editor und Fußzeile bleiben dabei fest sichtbar.
+
 Im automatisch angebundenen Telegram-Kanal werden ausschließlich `/loop`,
 `/goal`, `/idea`, `/chancenradar` und `/befehle` als Befehle ausgeführt. Ist der Agent
 beschäftigt, bleiben sie in der Warteschlange. Andere Slash-Eingaben werden aus

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-runtime.js

@@ -21,11 +21,21 @@ 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,
@@ -42,6 +52,7 @@ 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();
@@ -130,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(),
@@ -143,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 {
@@ -152,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;
@@ -159,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();
@@ -177,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);
 }
 
@@ -246,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';

package/bin/profile-runtime.cjs

@@ -26,6 +26,8 @@ const LEGACY_PROFILE_ENTRIES = Object.freeze([
   'tui.toml',
 ]);
 const MIGRATION_MARKER = '.legacy-profile-migrated-v1';
+const SESSION_PATH_MIGRATION_MARKER = '.legacy-profile-session-paths-v2';
+const SESSION_PATH_BACKUP_DIR = '.legacy-profile-session-paths-v2-backup';
 
 function normalizeProfileName(value) {
   const normalized = String(value || '').trim().toLowerCase();
@@ -102,27 +104,161 @@ function copyLegacyEntry(source, target, fsImpl) {
   if (stat.isFile()) fsImpl.copyFileSync(source, target);
 }
 
-function seedDefaultProfileFromLegacy(sharedHome, fsImpl = fs) {
-  const paths = resolveProfilePaths(sharedHome, DEFAULT_PROFILE);
-  const marker = path.join(paths.home, MIGRATION_MARKER);
-  if (fsImpl.existsSync(marker)) return paths;
+function relativePathInside(parent, child) {
+  const relative = path.relative(path.resolve(parent), path.resolve(child));
+  if (!relative || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    return null;
+  }
+  return relative;
+}
 
-  fsImpl.mkdirSync(paths.home, { recursive: true });
-  for (const entry of LEGACY_PROFILE_ENTRIES) {
-    copyLegacyEntry(path.join(sharedHome, entry), path.join(paths.home, entry), fsImpl);
+function replaceTextFileIfUnchanged(target, original, replacement, fsImpl) {
+  if (fsImpl.readFileSync(target, 'utf8') !== original) {
+    throw new Error(`Sitzungsdatei wurde waehrend der Migration geaendert: ${target}`);
   }
+  const temporary = `${target}.migration-${process.pid}-${Date.now()}.tmp`;
+  fsImpl.writeFileSync(temporary, replacement, 'utf8');
   try {
-    fsImpl.writeFileSync(marker, 'legacy profile state copied once\n', { encoding: 'utf8', flag: 'wx' });
+    fsImpl.renameSync(temporary, target);
   } catch (error) {
-    if (error?.code !== 'EEXIST') throw error;
+    try {
+      fsImpl.rmSync(temporary, { force: true });
+    } catch {}
+    throw error;
   }
+}
+
+function backupFile(source, target, fsImpl) {
+  if (fsImpl.existsSync(target)) return;
+  fsImpl.mkdirSync(path.dirname(target), { recursive: true });
+  fsImpl.copyFileSync(source, target);
+}
+
+function rewriteSessionState(statePath, legacySessionDir, profileSessionDir, backupRoot, relativeSessionDir, fsImpl) {
+  if (!fsImpl.existsSync(statePath)) return false;
+  const original = fsImpl.readFileSync(statePath, 'utf8');
+  let state;
+  try {
+    state = JSON.parse(original);
+  } catch {
+    return false;
+  }
+  if (!state || typeof state !== 'object' || Array.isArray(state) || !state.agents || typeof state.agents !== 'object') {
+    return false;
+  }
+
+  let changed = false;
+  const agents = {};
+  for (const [agentId, value] of Object.entries(state.agents)) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || typeof value.homedir !== 'string') {
+      agents[agentId] = value;
+      continue;
+    }
+    const relativeAgentPath = relativePathInside(legacySessionDir, value.homedir);
+    if (relativeAgentPath === null) {
+      agents[agentId] = value;
+      continue;
+    }
+    agents[agentId] = {
+      ...value,
+      homedir: path.join(profileSessionDir, relativeAgentPath),
+    };
+    changed = true;
+  }
+  if (!changed) return false;
+
+  backupFile(statePath, path.join(backupRoot, 'sessions', relativeSessionDir, 'state.json'), fsImpl);
+  const replacement = `${JSON.stringify({ ...state, agents }, null, 2)}\n`;
+  replaceTextFileIfUnchanged(statePath, original, replacement, fsImpl);
+  return true;
+}
+
+function repairDefaultProfileSessionPaths(sharedHome, fsImpl = fs, options = {}) {
+  const paths = resolveProfilePaths(sharedHome, DEFAULT_PROFILE);
+  const marker = path.join(paths.home, SESSION_PATH_MIGRATION_MARKER);
+  const filteredWorkDir = options.workDir === undefined ? null : path.resolve(options.workDir);
+  if (filteredWorkDir === null && fsImpl.existsSync(marker)) return paths;
+  if (!fsImpl.existsSync(paths.sessionIndex)) {
+    if (filteredWorkDir === null) fsImpl.writeFileSync(marker, 'legacy session paths repaired once\n', 'utf8');
+    return paths;
+  }
+
+  const legacySessions = path.join(sharedHome, 'sessions');
+  const backupRoot = path.join(paths.home, SESSION_PATH_BACKUP_DIR);
+  const original = fsImpl.readFileSync(paths.sessionIndex, 'utf8');
+  const output = [];
+  let changed = false;
+  for (const line of original.split(/\r?\n/u)) {
+    if (line.trim() === '') {
+      output.push(line);
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      output.push(line);
+      continue;
+    }
+    if (!entry || typeof entry !== 'object' || typeof entry.sessionId !== 'string'
+      || typeof entry.sessionDir !== 'string' || typeof entry.workDir !== 'string'
+      || (filteredWorkDir !== null && path.resolve(entry.workDir) !== filteredWorkDir)) {
+      output.push(line);
+      continue;
+    }
+    const relativeSessionDir = relativePathInside(legacySessions, entry.sessionDir);
+    if (relativeSessionDir === null || path.basename(relativeSessionDir) !== entry.sessionId) {
+      output.push(line);
+      continue;
+    }
+    const profileSessionDir = path.join(paths.sessions, relativeSessionDir);
+    if (!fsImpl.existsSync(profileSessionDir)) {
+      output.push(line);
+      continue;
+    }
+
+    rewriteSessionState(
+      path.join(profileSessionDir, 'state.json'),
+      path.resolve(entry.sessionDir),
+      profileSessionDir,
+      backupRoot,
+      relativeSessionDir,
+      fsImpl,
+    );
+    output.push(JSON.stringify({ ...entry, sessionDir: profileSessionDir }));
+    changed = true;
+  }
+
+  if (changed) {
+    backupFile(paths.sessionIndex, path.join(backupRoot, 'session_index.jsonl'), fsImpl);
+    replaceTextFileIfUnchanged(paths.sessionIndex, original, output.join('\n'), fsImpl);
+  }
+  if (filteredWorkDir === null) fsImpl.writeFileSync(marker, 'legacy session paths repaired once\n', 'utf8');
   return paths;
 }
 
+function seedDefaultProfileFromLegacy(sharedHome, fsImpl = fs) {
+  const paths = resolveProfilePaths(sharedHome, DEFAULT_PROFILE);
+  const marker = path.join(paths.home, MIGRATION_MARKER);
+  fsImpl.mkdirSync(paths.home, { recursive: true });
+  if (!fsImpl.existsSync(marker)) {
+    for (const entry of LEGACY_PROFILE_ENTRIES) {
+      copyLegacyEntry(path.join(sharedHome, entry), path.join(paths.home, entry), fsImpl);
+    }
+    try {
+      fsImpl.writeFileSync(marker, 'legacy profile state copied once\n', { encoding: 'utf8', flag: 'wx' });
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+    }
+  }
+  return repairDefaultProfileSessionPaths(sharedHome, fsImpl);
+}
+
 module.exports = {
   DEFAULT_PROFILE,
   normalizeProfileName,
   parseProfileLaunchArgs,
+  repairDefaultProfileSessionPaths,
   resolveProfilePaths,
   seedDefaultProfileFromLegacy,
 };