blun-king-cli 9.1.608 → 9.1.610

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # BLUN King Changelog
 
+## 9.1.610
+
+- Mit `@all` erreichst du in einer Telegram-Gruppe alle angebundenen Kings. Nachrichten ohne passende Erwähnung bleiben vom Modellkontext ausgeschlossen, wenn die Erwähnungsregel aktiv ist.
+- Konkrete Aufträge und Fragen bleiben beantwortbar; bloße Informationen und ausdrücklich bestätigungsfreie Nachrichten lösen keine unnötige Gruppenbestätigung aus.
+- Telegram-`/`-Befehle werden vor normalen TUI-Nachrichten zugestellt und nicht in die Arbeitswarteschlange gelegt. Kann ein Fernbefehl während eines laufenden Zugs nicht sicher ausgeführt werden, erhältst du sofort eine Ablehnung und kannst ihn erneut senden; er läuft nicht später überraschend an.
+- Ein leerer oder ausdrücklich stiller Headless-Zug sendet keine automatische Telegram-Antwort. Als eindeutiges Stille-Zeichen gilt `[[BLUN_TELEGRAM_SILENT]]` allein als Ausgabetext; die fünf beobachteten Stille-Formulierungen werden ebenfalls unterdrückt. Echte Antworten ohne `reply` bleiben zustellbar.
+- Auf Linux ist das npm-Paket wieder installierbar. `king --profile serve` und `king serve` öffnen wieder das bestehende Profil; dessen Konfiguration bleibt getrennt, während vorhandene gemeinsame Zugangsdaten weiter genutzt werden.
+- Diese Änderungen belegen weder eine kürzere Modellwartezeit noch geringeren Tokenverbrauch.
+
+## 9.1.609
+
+- Open the existing effort picker with Ctrl+L while preserving the editor draft. Reuse the existing effort settings and model restrictions rather than adding a second configuration path.
+- Preserve the existing busy-session rule: an effort change during active work is rejected, not queued for later. Ignore the shortcut during replay or editor takeover.
+- These changes do not establish faster live model responses, lower billed token usage, or complete OpenClaw parity.
+
 ## 9.1.608
 
 - Apply Telegram mention admission before unaddressed group messages enter the session context; preserve the explicit opt-out.

package/LIESMICH.txt

@@ -26,7 +26,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.608
+  npm install -g blun-king-cli@9.1.610
 
 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.608
+npm install -g blun-king-cli@9.1.610
 ```
 
 ### Windows: Node.js, npm und Git Bash

package/bin/launcher-runtime.js

@@ -33,29 +33,68 @@ 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 PKG = path.resolve(__dirname, '..');
-const ARGS = process.argv.slice(2);
+const {
+  ensurePrivateDirectory,
+  securePrivateFile,
+  writePrivateFile,
+} = require('./private-paths');
+const { parseProfileLaunchArgs, resolveSelectedProfile } = require('./profile-launch.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;
 
-function normalizeWindowsPath(value) {
-  return path.win32.normalize(value).replace(/\\+$/u, '').toLowerCase();
-}
+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 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,
+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,
     };
   }
 
@@ -78,8 +117,20 @@ function resolveLauncherPrivatePaths(options = {}) {
     throw new Error('Das lokale Windows-Benutzerprofil ist kein kanonischer lokaler Pfad.');
   }
 
-  const blunHome = path.win32.join(userHome, '.blun');
-  if (configuredHome
+  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
     && normalizeWindowsPath(path.win32.resolve(configuredHome)) !== normalizeWindowsPath(blunHome)) {
     throw new Error(`BLUN_HOME muss unter Windows exakt im Windows-Benutzerprofil liegen: ${blunHome}`);
   }
@@ -367,18 +418,29 @@ async function runLauncher(options = {}) {
       }
       process.stdout.write(launcherHelpText());
       const env = createLauncherEnvironment(process.env, mode, readPackageVersion());
-      const informationalEnv = { ...process.env };
-      delete informationalEnv.BLUN_HOME;
-      env.BLUN_HOME = resolveLauncherPrivatePaths({ env: informationalEnv }).blunHome;
+      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;
+      }
       process.exitCode = await runInformationalCore(ARGS, env, callerCwd, releaseNotice);
       return;
     }
 
-    let privatePaths;
-    const getPrivatePaths = () => {
-      privatePaths ||= resolveLauncherPrivatePaths();
-      return privatePaths;
-    };
+    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;
+    };
     const nodeRuntime = await prepareManagedNodeRuntime({
       getBlunDir: () => getPrivatePaths().blunHome,
     });
@@ -397,15 +459,28 @@ 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;
-      env.BLUN_HOME = resolveLauncherPrivatePaths({ env: informationalEnv }).blunHome;
+      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;
+      }
       process.exitCode = await superviseProtectedCore(ARGS, env, callerCwd, releaseNotice);
       return;
     }
 
-    const blunDir = getPrivatePaths().blunHome;
-    ensurePrivateDirectory(blunDir);
+    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);
 
     // --- 1. Oeffentlicher npm-Update-Dialog. -------------------------------
     const updateResult = options.skipUpdateNotice === true
@@ -470,8 +545,12 @@ async function runLauncher(options = {}) {
     }
 
     // --- 6. Start -----------------------------------------------------------
-    const env = createLauncherEnvironment(process.env, mode, readPackageVersion(), blunDir);
-    env.BLUN_HOME = blunDir;
+    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;
+    }
     process.exitCode = await superviseProtectedCore(
       ARGS,
       env,
@@ -483,8 +562,10 @@ async function runLauncher(options = {}) {
   }
 }
 
-module.exports = {
-  resolveLauncherPrivatePaths,
+module.exports = {
+  resolveLauncherPrivatePaths,
+  isInteractiveKingStart,
+  runningTuiPid,
   runLauncher,
   shouldDetachProtectedCore,
   spawnManagedLauncher,

package/bin/private-paths.js

@@ -44,7 +44,10 @@ public static class BlunPrivateAclNative
     private const uint FILE_DIRECTORY_FILE = 0x00000001;
     private const uint FILE_SYNCHRONOUS_IO_NONALERT = 0x00000020;
     private const uint FILE_OPEN_REPARSE_POINT = 0x00200000;
-    private const uint FILE_OPEN_IF = 3;
+    private const uint FILE_OPEN_IF = 3;
+    private const uint FILE_SHARE_READ = 0x00000001;
+    private const uint FILE_SHARE_WRITE = 0x00000002;
+    private const uint FILE_SHARE_DELETE = 0x00000004;
     private const uint OBJ_CASE_INSENSITIVE = 0x00000040;
     private const uint SE_FILE_OBJECT = 1;
     private const uint OWNER_SECURITY_INFORMATION = 0x00000001;
@@ -602,17 +605,30 @@ public static class BlunPrivateAclNative
             IoStatusBlock ioStatus;
             int status = NtCreateFile(
                 out rawHandle,
-                GENERIC_READ | READ_CONTROL | WRITE_DAC | DELETE | SYNCHRONIZE,
+                GENERIC_READ | READ_CONTROL | WRITE_DAC | DELETE | SYNCHRONIZE,
                 ref attributes,
                 out ioStatus,
                 IntPtr.Zero,
                 0,
-                0,
-                FILE_OPEN_IF,
+                FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                FILE_OPEN_IF,
                 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_REPARSE_POINT,
-                IntPtr.Zero,
-                0);
-            if (status < 0)
+                IntPtr.Zero,
+                0);
+            if (status < 0 && RtlNtStatusToDosError(status) == 32)
+                status = NtCreateFile(
+                    out rawHandle,
+                    GENERIC_READ | READ_CONTROL | WRITE_DAC | SYNCHRONIZE,
+                    ref attributes,
+                    out ioStatus,
+                    IntPtr.Zero,
+                    0,
+                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                    FILE_OPEN_IF,
+                    FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_REPARSE_POINT,
+                    IntPtr.Zero,
+                    0);
+            if (status < 0)
                 throw new Win32Exception((int)RtlNtStatusToDosError(status));
             return new SafeFileHandle(rawHandle, true);
         }
@@ -1058,8 +1074,8 @@ public static class BlunPrivateAclNative
     }
 }`;
 
-const WINDOWS_ACL_CSHARP_GZIP = gzipSync(
-  Buffer.from(WINDOWS_ACL_CSHARP),
+const WINDOWS_ACL_CSHARP_GZIP = gzipSync(
+  Buffer.from(WINDOWS_ACL_CSHARP.replace(/\n[ \t]*\n/gu, '\n')),
   { level: 9 },
 ).toString('base64');
 
@@ -1068,9 +1084,9 @@ const WINDOWS_ACL_SCRIPT = [
   "$ProgressPreference = 'SilentlyContinue'",
   'try {',
   'Set-StrictMode -Version 3',
-  "$target=[Environment]::GetEnvironmentVariable('BLUN_PRIVATE_ACL_TARGET','Process')",
-  "$kind=[Environment]::GetEnvironmentVariable('BLUN_PRIVATE_ACL_KIND','Process')",
-  "$sid=[Environment]::GetEnvironmentVariable('BLUN_PRIVATE_ACL_USER_SID','Process')",
+  '$target=$env:BLUN_PRIVATE_ACL_TARGET',
+  '$kind=$env:BLUN_PRIVATE_ACL_KIND',
+  '$sid=$env:BLUN_PRIVATE_ACL_USER_SID',
   "if ([string]::IsNullOrWhiteSpace($target) -or -not [IO.Path]::IsPathRooted($target)) { throw 'Invalid target.' }",
   "if ($kind -ne 'directory' -and $kind -ne 'file' -and $kind -ne 'file-write' -and $kind -ne 'tree') { throw 'Invalid kind.' }",
   `$bytes=[Convert]::FromBase64String('${WINDOWS_ACL_CSHARP_GZIP}')`,
@@ -1105,15 +1121,18 @@ const WINDOWS_ACL_SCRIPT = [
   '$mem.Dispose()',
   '}',
   '}',
-  "[Console]::Out.Write('BLUN_PRIVATE_ACL_OK_V1')",
-  'exit 0',
-  '} catch {',
-  "[Console]::Error.Write('BLUN_PRIVATE_ACL_ERROR_V1')",
-  'exit 1',
+  "[Console]::Out.Write('BLUN_PRIVATE_ACL_OK_V1')",
+  'exit 0',
+  '} catch {',
+  "$e='BLUN_PRIVATE_ACL_ERROR_V1'; if ($kind -eq 'directory') { $e += '|' + $_.Exception.Message }; [Console]::Error.Write($e)",
+  'exit 1',
   '}',
 ].join('\n');
 
-const WINDOWS_ACL_ENCODED_COMMAND = Buffer.from(WINDOWS_ACL_SCRIPT, 'utf16le').toString('base64');
+const WINDOWS_ACL_ENCODED_COMMAND = Buffer.from(
+  WINDOWS_ACL_SCRIPT.replace(/\n[ \t]*\n/gu, '\n'),
+  'utf16le',
+).toString('base64');
 
 function windowsSystemDirectory(options) {
   const env = options.env || process.env;
@@ -1127,10 +1146,16 @@ function windowsSystemDirectory(options) {
   return path.win32.normalize(directory);
 }
 
-function windowsHostEnvironment(systemDirectory) {
-  const systemRoot = path.win32.dirname(systemDirectory);
-  return { SystemRoot: systemRoot, WINDIR: systemRoot };
-}
+function windowsHostEnvironment(systemDirectory, options) {
+  const systemRoot = path.win32.dirname(systemDirectory);
+  const source = options.env || process.env;
+  const temporaryDirectory = source.TEMP || source.TMP;
+  return {
+    SystemRoot: systemRoot,
+    WINDIR: systemRoot,
+    ...(temporaryDirectory ? { TEMP: temporaryDirectory, TMP: temporaryDirectory } : {}),
+  };
+}
 
 function runWindowsCommand(executable, args, options, env, input) {
   const execFileSyncImpl = options.execFileSyncImpl || execFileSync;
@@ -1190,14 +1215,14 @@ function resolveWindowsPrivateTarget(targetPath) {
       throw new Error('Invalid Windows private path.');
     }
     return absoluteTarget;
-  } catch {
-    throw new Error('Windows private ACL hardening or verification failed.');
+  } catch (error) {
+    throw new Error('Windows private ACL hardening or verification failed: invalid target path.', { cause: error });
   }
 }
 
-function windowsAclController(options) {
-  const systemDirectory = windowsSystemDirectory(options);
-  const hostEnvironment = windowsHostEnvironment(systemDirectory);
+function windowsAclController(options) {
+  const systemDirectory = windowsSystemDirectory(options);
+  const hostEnvironment = windowsHostEnvironment(systemDirectory, options);
   const whoami = path.win32.join(systemDirectory, 'whoami.exe');
   const powershell = path.win32.join(
     systemDirectory,
@@ -1228,14 +1253,19 @@ function windowsAclController(options) {
     return userSid;
   };
 
-  const invoke = (targetPath, kind, input) => {
-    try {
-      const absoluteTarget = resolveWindowsPrivateTarget(targetPath);
-      const root = path.parse(absoluteTarget).root;
+  const invoke = (targetPath, kind, input) => {
+    try {
+      const absoluteTarget = resolveWindowsPrivateTarget(targetPath);
+      const failure = (reason) => new Error(
+        kind === 'directory'
+          ? `Windows private ACL hardening or verification failed for ${absoluteTarget}: ${reason}`
+          : 'Windows private ACL hardening or verification failed.',
+      );
+      const root = path.parse(absoluteTarget).root;
       if (!path.isAbsolute(absoluteTarget)
         || root.toLowerCase() === absoluteTarget.toLowerCase()
         || !['directory', 'file', 'file-write', 'tree'].includes(kind)) {
-        throw new Error('Windows private ACL hardening or verification failed.');
+        throw failure('invalid target or operation');
       }
       const env = {
         ...hostEnvironment,
@@ -1253,11 +1283,19 @@ function windowsAclController(options) {
           env,
           input,
         );
-      } catch {
-        throw new Error('Windows private ACL hardening or verification failed.');
-      }
-      if (output !== WINDOWS_ACL_OK_SENTINEL) {
-        throw new Error('Windows private ACL hardening or verification failed.');
+      } catch (error) {
+        const stderr = String(error?.stderr || '');
+        const marker = 'BLUN_PRIVATE_ACL_ERROR_V1|';
+        const detail = kind === 'directory' && stderr.startsWith(marker)
+          ? stderr.slice(marker.length).replace(/[\x00-\x1f\x7f]/gu, ' ').slice(0, 400)
+          : 'Windows ACL helper failed without a native diagnosis';
+        if (kind === 'directory') {
+          throw new Error(failure(detail).message, { cause: new Error(detail) });
+        }
+        throw failure(detail);
+      }
+      if (output !== WINDOWS_ACL_OK_SENTINEL) {
+        throw failure('unexpected ACL helper response');
       }
     } finally {
       input?.fill(0);

package/bin/profile-launch.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+const path = require('node:path');
+
+const PROFILE_NAME = /^[a-z0-9][a-z0-9_-]{0,31}$/u;
+const RESERVED = new Set(['doctor', 'export', 'help', 'login', 'mcp', 'server', 'tools', 'update', 'upgrade', 'version']);
+
+function profileName(value) {
+  const name = String(value || '').trim().toLowerCase();
+  if (!PROFILE_NAME.test(name)) {
+    throw new Error('Profilnamen duerfen nur Buchstaben, Zahlen, Unterstriche und Bindestriche enthalten.');
+  }
+  return name;
+}
+
+function parseProfileLaunchArgs(args, mode) {
+  const remaining = [...args];
+  if (mode !== 'king') return { args: remaining, name: undefined };
+
+  const flag = remaining.indexOf('--profile');
+  if (flag >= 0) {
+    if (flag + 1 >= remaining.length) throw new Error('--profile braucht einen Profilnamen.');
+    const name = profileName(remaining[flag + 1]);
+    remaining.splice(flag, 2);
+    return { args: remaining, name };
+  }
+
+  if (remaining.length === 1 && !remaining[0].startsWith('-') && !RESERVED.has(remaining[0].toLowerCase())) {
+    return { args: [], name: profileName(remaining[0]), implicit: true };
+  }
+  if (remaining.length === 2 && remaining.includes('-c')) {
+    const candidate = remaining.find(value => value !== '-c');
+    if (candidate && !candidate.startsWith('-')) return { args: ['-c'], name: profileName(candidate), implicit: true };
+  }
+  return { args: remaining, name: undefined };
+}
+
+function resolveSelectedProfile(sharedHome, name, pathImpl = path) {
+  return pathImpl.join(sharedHome, 'profile', profileName(name));
+}
+
+module.exports = { parseProfileLaunchArgs, resolveSelectedProfile };