blun-king-cli 9.1.57 → 9.1.60

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.59
 
 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.59
 ```
 
 ## Reproduzierbares Staging und Packen

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

@@ -31,9 +31,16 @@ const {
   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;
 
 function normalizeWindowsPath(value) {
@@ -44,10 +51,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 +92,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() {
@@ -271,12 +306,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 +333,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 +342,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 +367,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 +397,7 @@ async function runLauncher(options = {}) {
         stdin: process.stdin,
         stdout: process.stdout,
         stderr: process.stderr,
-        blunDir,
+        blunDir: privatePaths.sharedHome,
         packageRoot: PKG,
         noticeLease,
       });
@@ -382,7 +429,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 +449,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,

package/bin/private-paths.js

@@ -34,6 +34,9 @@ public static class BlunPrivateAclNative
     private const uint READ_CONTROL = 0x00020000;
     private const uint WRITE_DAC = 0x00040000;
     private const uint SYNCHRONIZE = 0x00100000;
+    private const uint FILE_SHARE_READ = 0x00000001;
+    private const uint FILE_SHARE_WRITE = 0x00000002;
+    private const uint FILE_SHARE_DELETE = 0x00000004;
     private const uint CREATE_NEW = 1;
     private const uint OPEN_EXISTING = 3;
     private const uint FILE_ATTRIBUTE_NORMAL = 0x00000080;
@@ -608,7 +611,7 @@ public static class BlunPrivateAclNative
                 out ioStatus,
                 IntPtr.Zero,
                 0,
-                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,
@@ -1271,8 +1274,8 @@ function windowsAclController(options) {
         const detail = rawDetail.replace(/[\u0000-\u001f\u007f]+/gu, ' ').trim().slice(0, 500);
         throw new Error(
           detail.length > 0
-            ? `Windows private ACL operation failed: ${detail}`
-            : 'Windows private ACL operation failed.',
+            ? `Windows private ACL operation failed for ${kind} target "${absoluteTarget}": ${detail}`
+            : `Windows private ACL operation failed for ${kind} target "${absoluteTarget}".`,
           { cause: error },
         );
       }

package/bin/profile-runtime.cjs

@@ -0,0 +1,128 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_PROFILE = 'default';
+const PROFILE_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]{0,31}$/u;
+const RESERVED_SINGLE_ARGUMENTS = new Set([
+  'doctor',
+  'export',
+  'help',
+  'mcp',
+  'server',
+  'tools',
+  'update',
+  'upgrade',
+  'version',
+]);
+const LEGACY_PROFILE_ENTRIES = Object.freeze([
+  'channels',
+  'config.toml',
+  'mcp.json',
+  'plugins',
+  'session_index.jsonl',
+  'sessions',
+  'tui.toml',
+]);
+const MIGRATION_MARKER = '.legacy-profile-migrated-v1';
+
+function normalizeProfileName(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (!PROFILE_NAME_PATTERN.test(normalized)) {
+    throw new Error('Profilnamen duerfen nur Buchstaben, Zahlen, Unterstriche und Bindestriche enthalten.');
+  }
+  return normalized;
+}
+
+function parseProfileLaunchArgs(inputArgs, mode = 'blun') {
+  const args = Array.isArray(inputArgs) ? [...inputArgs] : [];
+  if (String(mode).toLowerCase() !== 'king') {
+    return { args, profileName: DEFAULT_PROFILE };
+  }
+
+  const profileFlagIndex = args.indexOf('--profile');
+  if (profileFlagIndex >= 0) {
+    if (profileFlagIndex + 1 >= args.length) {
+      throw new Error('--profile braucht einen Profilnamen.');
+    }
+    const profileName = normalizeProfileName(args[profileFlagIndex + 1]);
+    args.splice(profileFlagIndex, 2);
+    return { args, profileName };
+  }
+
+  if (args.length === 1) {
+    const candidate = String(args[0] || '');
+    if (!candidate.startsWith('-') && !RESERVED_SINGLE_ARGUMENTS.has(candidate.toLowerCase())) {
+      return { args: [], profileName: normalizeProfileName(candidate) };
+    }
+  }
+
+  if (args.length === 2 && args.includes('-c')) {
+    const candidate = args.find((arg) => arg !== '-c');
+    if (candidate && !candidate.startsWith('-')) {
+      return { args: ['-c'], profileName: normalizeProfileName(candidate) };
+    }
+  }
+
+  return { args, profileName: DEFAULT_PROFILE };
+}
+
+function resolveProfilePaths(sharedHome, profileName, pathImpl = path) {
+  const normalized = normalizeProfileName(profileName);
+  const home = pathImpl.join(sharedHome, 'profile', normalized);
+  return Object.freeze({
+    profileName: normalized,
+    sharedHome,
+    home,
+    channels: pathImpl.join(home, 'channels'),
+    sessions: pathImpl.join(home, 'sessions'),
+    plugins: pathImpl.join(home, 'plugins'),
+    config: pathImpl.join(home, 'config.toml'),
+    mcp: pathImpl.join(home, 'mcp.json'),
+    sessionIndex: pathImpl.join(home, 'session_index.jsonl'),
+    credentials: pathImpl.join(sharedHome, 'credentials'),
+    oauth: pathImpl.join(sharedHome, 'oauth'),
+    deviceId: pathImpl.join(sharedHome, 'device_id'),
+    skills: pathImpl.join(sharedHome, 'skills'),
+    secure: pathImpl.join(sharedHome, 'secure'),
+    persona: pathImpl.join(sharedHome, 'persona.json'),
+    globalLog: pathImpl.join(sharedHome, 'logs', 'blun.log'),
+  });
+}
+
+function copyLegacyEntry(source, target, fsImpl) {
+  if (!fsImpl.existsSync(source) || fsImpl.existsSync(target)) return;
+  const stat = fsImpl.lstatSync(source);
+  if (stat.isSymbolicLink()) return;
+  if (stat.isDirectory()) {
+    fsImpl.cpSync(source, target, { recursive: true, errorOnExist: false });
+    return;
+  }
+  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;
+
+  fsImpl.mkdirSync(paths.home, { recursive: true });
+  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 paths;
+}
+
+module.exports = {
+  DEFAULT_PROFILE,
+  normalizeProfileName,
+  parseProfileLaunchArgs,
+  resolveProfilePaths,
+  seedDefaultProfileFromLegacy,
+};

package/bin/rate-limit-recovery-policy.cjs

@@ -0,0 +1,34 @@
+"use strict";
+
+const MAX_AUTOMATIC_RATE_LIMIT_RESUMES = 3;
+const RATE_LIMIT_RETRY_BASE_MS = 60_000;
+const RATE_LIMIT_COMPACTION_THRESHOLD_TOKENS = 64_000;
+
+function isImmediateGenerateRetryAllowed(statusCode) {
+  return statusCode !== 429 && [500, 502, 503, 504].includes(statusCode);
+}
+
+function rateLimitRetryDelayMs(retryCount) {
+  if (!Number.isInteger(retryCount) || retryCount < 1) {
+    throw new Error("retryCount must be a positive integer.");
+  }
+  return RATE_LIMIT_RETRY_BASE_MS * (2 ** (retryCount - 1));
+}
+
+function shouldStopAutomaticRateLimitResume(retryCount) {
+  return retryCount >= MAX_AUTOMATIC_RATE_LIMIT_RESUMES;
+}
+
+function shouldCompactBeforeRateLimitResume(estimatedRequestTokens) {
+  return Number.isFinite(estimatedRequestTokens)
+    && estimatedRequestTokens >= RATE_LIMIT_COMPACTION_THRESHOLD_TOKENS;
+}
+
+module.exports = {
+  MAX_AUTOMATIC_RATE_LIMIT_RESUMES,
+  RATE_LIMIT_RETRY_BASE_MS,
+  isImmediateGenerateRetryAllowed,
+  rateLimitRetryDelayMs,
+  shouldCompactBeforeRateLimitResume,
+  shouldStopAutomaticRateLimitResume,
+};

package/bin/standard-tools-bootstrap.js

@@ -74,6 +74,41 @@ function hasEquivalentServer(servers, name, tool) {
   });
 }
 
+function sameStringArray(left, right) {
+  return Array.isArray(left)
+    && Array.isArray(right)
+    && left.length === right.length
+    && left.every((value, index) => value === right[index]);
+}
+
+function recognizedBundledServer(current, expected) {
+  return isObject(current)
+    && current.transport === expected.transport
+    && current.command === expected.command
+    && sameStringArray(current.args, expected.args);
+}
+
+function migrateBundledTimeouts(name, current, expected) {
+  if (!recognizedBundledServer(current, expected)) return false;
+  let changed = false;
+  if (name === 'agent-browser') {
+    if (current.startupTimeoutMs === 30_000) {
+      current.startupTimeoutMs = expected.startupTimeoutMs;
+      changed = true;
+    }
+    if (current.toolTimeoutMs === 60_000) {
+      current.toolTimeoutMs = expected.toolTimeoutMs;
+      changed = true;
+    }
+  }
+  if (name === 'blun-language-guard'
+    && (current.toolTimeoutMs === 30_000 || current.toolTimeoutMs === 60_000)) {
+    current.toolTimeoutMs = expected.toolTimeoutMs;
+    changed = true;
+  }
+  return changed;
+}
+
 function writeMcpDocument(configPath, document) {
   const temporaryPath = path.join(
     path.dirname(configPath),
@@ -160,21 +195,27 @@ function seedStandardTools({
   const document = readMcpDocument(configPath);
   const servers = { ...document.mcpServers };
   const added = [];
+  const updated = [];
 
   for (const name of selectedNames) {
     const tool = catalogue.tools[name];
-    if (hasEquivalentServer(servers, name, tool)) continue;
-    servers[name] = bundledToolConfig(name, tool, {
+    const expected = bundledToolConfig(name, tool, {
       packageRoot,
       blunDir,
       platform,
       env,
     });
+    if (Object.hasOwn(servers, name)) {
+      if (migrateBundledTimeouts(name, servers[name], expected)) updated.push(name);
+      continue;
+    }
+    if (hasEquivalentServer(servers, name, tool)) continue;
+    servers[name] = expected;
     added.push(name);
   }
 
-  if (added.length > 0) writeMcpDocument(configPath, { ...document, mcpServers: servers });
-  return { added, configPath };
+  if (added.length > 0 || updated.length > 0) writeMcpDocument(configPath, { ...document, mcpServers: servers });
+  return { added, updated, configPath };
 }
 
 function seedStandardDesignSkill({ packageRoot, blunDir }) {

package/bin/subagent-timeout-policy.cjs

@@ -0,0 +1,79 @@
+"use strict";
+
+const DEFAULT_SUBAGENT_TIMEOUT_MS = 4 * 60 * 60 * 1000;
+const MAX_SUBAGENT_TIMEOUT_MINUTES = 7 * 24 * 60;
+const SUBAGENT_TIMEOUT_ENV = "BLUN_SUBAGENT_TIMEOUT_MINUTES";
+
+function resolveSubagentTimeoutMs({ perRunMinutes, env = process.env } = {}) {
+  const raw = perRunMinutes ?? env[SUBAGENT_TIMEOUT_ENV];
+  if (raw === undefined || raw === null || raw === "") {
+    return DEFAULT_SUBAGENT_TIMEOUT_MS;
+  }
+
+  const minutes = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isInteger(minutes) || minutes < 0 || minutes > MAX_SUBAGENT_TIMEOUT_MINUTES) {
+    throw new Error(
+      `${SUBAGENT_TIMEOUT_ENV} must be an integer from 0 to ${MAX_SUBAGENT_TIMEOUT_MINUTES} minutes.`,
+    );
+  }
+  return minutes === 0 ? undefined : minutes * 60 * 1000;
+}
+
+function abortError(reason) {
+  if (reason instanceof Error) return reason;
+  return new Error(reason === undefined ? "Subagent interrupted." : String(reason));
+}
+
+async function runAgentWithTimeoutContinuation({
+  handle,
+  timeoutMs,
+  signal,
+  abortCurrent,
+  retrySameAgent,
+}) {
+  let currentHandle = handle;
+
+  while (true) {
+    let timeout;
+    let removeAbortListener = () => {};
+    const completion = Promise.resolve(currentHandle.completion).then(
+      (outcome) => ({ kind: "completed", outcome }),
+      (error) => ({ kind: "failed", error }),
+    );
+    const timedOut = timeoutMs === undefined
+      ? new Promise(() => {})
+      : new Promise((resolve) => {
+          timeout = setTimeout(() => resolve({ kind: "timed_out" }), timeoutMs);
+        });
+    const interrupted = signal.aborted
+      ? Promise.resolve({ kind: "interrupted", reason: signal.reason })
+      : new Promise((resolve) => {
+          const onAbort = () => resolve({ kind: "interrupted", reason: signal.reason });
+          signal.addEventListener("abort", onAbort, { once: true });
+          removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+        });
+
+    const result = await Promise.race([completion, timedOut, interrupted]);
+    if (timeout !== undefined) clearTimeout(timeout);
+    removeAbortListener();
+
+    if (result.kind === "completed") return { handle: currentHandle, outcome: result.outcome };
+    if (result.kind === "failed") throw result.error;
+    if (result.kind === "interrupted") {
+      abortCurrent(result.reason);
+      await Promise.resolve(currentHandle.completion).catch(() => {});
+      throw abortError(result.reason);
+    }
+
+    const reason = new Error("Subagent continuation interval elapsed.");
+    abortCurrent(reason);
+    await Promise.resolve(currentHandle.completion).catch(() => {});
+    currentHandle = await retrySameAgent(currentHandle.agentId);
+  }
+}
+
+module.exports = {
+  DEFAULT_SUBAGENT_TIMEOUT_MS,
+  resolveSubagentTimeoutMs,
+  runAgentWithTimeoutContinuation,
+};