blun-king-cli 9.1.628 → 9.1.630

package/bin/launcher-runtime.js

@@ -40,9 +40,142 @@ const {
   writePrivateFile,
 } = require('./private-paths');
 
-const { writeTelegramTemplate } = require('./rename-private-staging.cjs');
+const { writeTelegramTemplate } = require('./rename-private-staging.cjs');
 const PKG = path.resolve(__dirname, '..');
-const ARGS = process.argv.slice(2);
+const { parseProfileLaunchArgs, resolveSelectedProfile } = require('./profile-launch.cjs');
+
+// Generated from actual 628 Commander registrations; see GRAMMAR-628.json.
+// No subcommand option arity table: subcommand tails belong to Core.
+const ROOT_OPTION_ARITY = Object.freeze({
+  "-V": "flag",
+  "--version": "flag",
+  "--local": "flag",
+  "--message": "required",
+  "--history-limit": "required",
+  "--timeout-ms": "required",
+  "--thinking": "required",
+  "--url": "required",
+  "--token": "required",
+  "--password": "required",
+  "--tls-fingerprint": "required",
+  "-S": "optional",
+  "--session": "optional",
+  "-r": "optional",
+  "--resume": "optional",
+  "-c": "flag",
+  "--continue": "flag",
+  "-C": "flag",
+  "-y": "flag",
+  "--yolo": "flag",
+  "--auto": "flag",
+  "-p": "required",
+  "--prompt": "required",
+  "--output-format": "required",
+  "--skills-dir": "required",
+  "--add-dir": "required",
+  "--effort": "required",
+  "--permission-mode": "required",
+  "--fork-session": "required",
+  "--allowed-tools": "required",
+  "--settings": "required",
+  "--yes": "flag",
+  "--auto-approve": "flag",
+  "--plan": "flag",
+  "-h": "flag",
+  "--help": "flag"
+});
+const ROOT_COMMAND_NAMES = new Set(["export","proof","brief","handoff","replay","guard","demo","workspace","acp","server","web","login","mistakes","memory","doctor","config","agents","sessions","status","models","logs","vis","setup","docs","upgrade","update","__plugin_run_node","tui","chat","terminal"]);
+
+function parseExplicitProfileArgs(args, mode) {
+  if (mode !== LAUNCHER_MODES.KING) return { args: [...args], name: undefined };
+  const remaining = [];
+  let name;
+  let firstOperandSeen = false;
+  let unknownDestination = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--') {
+      remaining.push(...args.slice(i));
+      break;
+    }
+    if (arg === '--profile' || arg.startsWith('--profile=')) {
+      if (name !== undefined) throw new Error('--profile darf nur einmal angegeben werden.');
+      if (arg !== '--profile') throw new Error('--profile braucht einen getrennten Profilnamen.');
+      const pair = i + 1 < args.length ? [arg, args[++i]] : [arg];
+      name = parseProfileLaunchArgs(pair, mode).name;
+      continue;
+    }
+    remaining.push(arg);
+    let token = arg;
+    let arity;
+    let recognized = false;
+    let attached = false;
+    let separator = false;
+    // Replay Commander's virtual tokens after each BOOLEAN short option.
+    // The remainder can itself become --, a long option, or a value option:
+    // -cy- -> -c -y --; -cy-prompt -> -c -y --prompt.
+    for (;;) {
+      if (token === '--') { separator = true; break; }
+      arity = Object.hasOwn(ROOT_OPTION_ARITY, token) ? ROOT_OPTION_ARITY[token] : undefined;
+      recognized = arity !== undefined;
+      if (recognized) break;
+      if (token.length > 2 && token[0] === '-' && token[1] !== '-') {
+        const short = '-' + token[1];
+        arity = ROOT_OPTION_ARITY[short];
+        if (arity !== undefined) {
+          if (arity !== 'flag') { recognized = true; attached = true; break; }
+          token = '-' + token.slice(2);
+          continue;
+        }
+      }
+      if (/^--[^=]+=/u.test(token)) {
+        arity = ROOT_OPTION_ARITY[token.slice(0, token.indexOf('='))];
+        recognized = arity === 'required' || arity === 'optional';
+        attached = recognized;
+      }
+      break;
+    }
+    if (separator) {
+      remaining.push(...args.slice(i + 1));
+      break;
+    }
+    if (recognized) {
+      if (!attached && i + 1 < args.length
+        && (arity === 'required'
+          || (arity === 'optional' && !(args[i + 1].length > 1 && args[i + 1][0] === '-')))) {
+        remaining.push(args[++i]);
+      }
+      continue;
+    }
+    const maybeOption = token.length > 1 && token[0] === '-';
+    if (maybeOption) unknownDestination = true;
+    // Match Commander's first operand/unknown split. A command-looking value
+    // behind -p/-S, a previous positional target or an unknown option is NOT
+    // a new command boundary.
+    if (!unknownDestination && !firstOperandSeen) {
+      if (ROOT_COMMAND_NAMES.has(arg)) {
+        remaining.push(...args.slice(i + 1));
+        break;
+      }
+      firstOperandSeen = true;
+    }
+  }
+  return { args: remaining, name };
+}
+
+const PROFILE = parseExplicitProfileArgs(process.argv.slice(2), launcherModeFromArgv(process.argv));
+const ARGS = PROFILE.args;
+
+function applyProfileEnvironment(env, paths) {
+  env.BLUN_HOME = paths.blunHome;
+  if (PROFILE.name !== undefined) {
+    env.BLUN_SHARED_HOME = paths.sharedHome;
+    env.BLUN_PROFILE = PROFILE.name;
+  } else if (String(env.BLUN_STATE_DIR || '').trim()) {
+    env.BLUN_SHARED_HOME = paths.blunHome;
+  }
+  return env;
+}
 
 function normalizeWindowsPath(value) {
   return path.win32.normalize(value).replace(/\\+$/u, '').toLowerCase();
@@ -52,6 +185,7 @@ 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;
   const stateDir = String(env.BLUN_STATE_DIR || '').trim();
   if (stateDir) {
     const paths = platform === 'win32' ? path.win32 : path.posix;
@@ -78,10 +212,35 @@ function resolveLauncherPrivatePaths(options = {}) {
         ancestor = parent;
       }
     }
+    if (selectedProfile !== undefined) {
+      // A state override cannot bypass the canonical OS-home/profile guards.
+      const profileEnv = { ...env };
+      delete profileEnv.BLUN_STATE_DIR;
+      const selected = resolveLauncherPrivatePaths({ ...options, env: profileEnv, profileName: selectedProfile });
+      const normalize = platform === 'win32' ? normalizeWindowsPath : paths.normalize;
+      if (normalize(blunHome) !== normalize(selected.blunHome)) {
+        throw new Error('BLUN_STATE_DIR widerspricht dem ausgewaehlten Profil.');
+      }
+      return selected;
+    }
     return { blunHome, userHome: (options.homedir || os.homedir)() };
   }
   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,
@@ -108,6 +267,19 @@ function resolveLauncherPrivatePaths(options = {}) {
   }
 
   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}`);
@@ -290,6 +462,9 @@ function spawnManagedLauncher(binary, cwd) {
 async function runLauncher(options = {}) {
   const callerCwd = process.cwd();
   const mode = options.mode || launcherModeFromArgv(process.argv);
+  if (PROFILE.name !== undefined) {
+    applyProfileEnvironment(process.env, resolveLauncherPrivatePaths());
+  }
   const explicitUpdateRequest = isNpmPackageUpdateRequest(ARGS);
   const explicitToolsRequest = String(ARGS[0] || '').toLowerCase() === 'tools';
   const noticeResult = options.skipUpdateNotice === true
@@ -394,7 +569,7 @@ 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;
+      applyProfileEnvironment(env, resolveLauncherPrivatePaths({ env: informationalEnv }));
       process.exitCode = await runInformationalCore(ARGS, env, callerCwd, releaseNotice);
       return;
     }
@@ -406,11 +581,11 @@ async function runLauncher(options = {}) {
         process.exitCode = 1;
         return;
       }
-      const blunDir = resolveLauncherPrivatePaths().blunHome;
+      const inspectionPaths = resolveLauncherPrivatePaths();
+      const blunDir = inspectionPaths.blunHome;
       require('./verify-bundled-agent-sources.cjs').verifyBundledAgentSources(PKG);
       const env = createLauncherEnvironment(process.env, LAUNCHER_MODES.BLUN, readPackageVersion(), blunDir);
-      env.BLUN_HOME = blunDir;
-      if (String(process.env.BLUN_STATE_DIR || '').trim()) env.BLUN_SHARED_HOME = blunDir;
+      applyProfileEnvironment(env, inspectionPaths);
       process.exitCode = await runInformationalCore(ARGS, env, callerCwd, releaseNotice);
       return;
     }
@@ -440,7 +615,7 @@ 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;
+      applyProfileEnvironment(env, resolveLauncherPrivatePaths({ env: informationalEnv }));
       process.exitCode = await superviseProtectedCore(ARGS, env, callerCwd, releaseNotice);
       return;
     }
@@ -530,8 +705,7 @@ async function runLauncher(options = {}) {
 
     // --- 6. Start -----------------------------------------------------------
     const env = createLauncherEnvironment(process.env, mode, readPackageVersion(), blunDir);
-    env.BLUN_HOME = blunDir;
-    if (String(process.env.BLUN_STATE_DIR || '').trim()) env.BLUN_SHARED_HOME = blunDir;
+    applyProfileEnvironment(env, getPrivatePaths());
     process.exitCode = await superviseProtectedCore(
       ARGS,
       env,

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/profile-launch.cjs

@@ -0,0 +1,120 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('node:fs');
+
+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));
+}
+
+function catalogUnavailable() {
+  return Object.assign(new Error('PROFILE_CATALOG_UNAVAILABLE'), { code: 'PROFILE_CATALOG_UNAVAILABLE' });
+}
+
+function directoryIdentity(target, fsImpl) {
+  let stat;
+  try { stat = fsImpl.lstatSync(target, { bigint: true }); }
+  catch (error) {
+    if (error.code === 'ENOENT') return undefined;
+    throw error;
+  }
+  if (!stat.isDirectory() || stat.isSymbolicLink()) throw catalogUnavailable();
+  return stat;
+}
+
+function homeIdentity(home, fsImpl) {
+  const root = path.parse(home).root;
+  let current = root;
+  let stat = directoryIdentity(current, fsImpl);
+  for (const part of home.slice(root.length).split(path.sep).filter(Boolean)) {
+    if (stat === undefined) return undefined;
+    current = path.join(current, part);
+    stat = directoryIdentity(current, fsImpl);
+  }
+  return stat;
+}
+
+function sameDirectory(before, after) {
+  return before !== undefined && after !== undefined && before.dev === after.dev && before.ino === after.ino;
+}
+
+/** Directory names only; selection must revalidate them before changing owner. */
+function listExistingProfiles(sharedHome, options = {}) {
+  const fsImpl = options.fsImpl || fs;
+  try {
+    if (typeof sharedHome !== 'string' || !path.isAbsolute(sharedHome)) throw catalogUnavailable();
+    const home = path.resolve(sharedHome);
+    if (process.platform === 'win32' && home.startsWith('\\\\')) throw catalogUnavailable();
+    const beforeHome = homeIdentity(home, fsImpl);
+    if (beforeHome === undefined) return [];
+    const profileRoot = path.join(home, 'profile');
+    const beforeProfiles = directoryIdentity(profileRoot, fsImpl);
+    if (beforeProfiles === undefined) {
+      if (!sameDirectory(beforeHome, homeIdentity(home, fsImpl))) throw catalogUnavailable();
+      return [];
+    }
+    const rows = [];
+    const dir = fsImpl.opendirSync(profileRoot);
+    try {
+      let count = 0;
+      for (let entry; (entry = dir.readSync()) !== null;) {
+        if (++count > 4096) throw catalogUnavailable();
+        const name = entry.name;
+        if (!PROFILE_NAME.test(name)) continue;
+        const target = resolveSelectedProfile(home, name);
+        let stat;
+        try { stat = fsImpl.lstatSync(target, { bigint: true }); }
+        catch (error) {
+          if (error.code === 'ENOENT') continue;
+          throw error;
+        }
+        if (stat.isDirectory() && !stat.isSymbolicLink()) rows.push({ name, target, stat });
+      }
+    } finally { dir.closeSync(); }
+    if (!sameDirectory(beforeHome, homeIdentity(home, fsImpl))
+      || !sameDirectory(beforeProfiles, directoryIdentity(profileRoot, fsImpl))) throw catalogUnavailable();
+    for (const row of rows) {
+      if (!sameDirectory(row.stat, directoryIdentity(row.target, fsImpl))) throw catalogUnavailable();
+    }
+    if (!sameDirectory(beforeHome, homeIdentity(home, fsImpl))
+      || !sameDirectory(beforeProfiles, directoryIdentity(profileRoot, fsImpl))) throw catalogUnavailable();
+    return rows.map(row => row.name).sort();
+  } catch {
+    throw catalogUnavailable();
+  }
+}
+
+module.exports = { parseProfileLaunchArgs, resolveSelectedProfile, listExistingProfiles };

package/blun.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// BLUN_BUILD_INPUT_SHA256:c6e4e4587ddf016fdb40a775622da5455beee2ed97708e374bf683b38e4a9dea
+// BLUN_BUILD_INPUT_SHA256:295bff16bb3a40df46f164599652a975e64b232ee91e1b245fa87962a4b61885
 /*! wasm-webp 0.1.0
 MIT License
 
@@ -13347,23 +13347,15 @@ var init_managed_usage = __esmMin((() => {
 	init_utils$2();
 	DEFAULT_BLUN_BASE_URL = "https://api.blun.ai/v1";
 	DEFAULT_BLUN_AUXILIARY_BASE_URL = "https://api.blun.ai/coding/v1";
-	ACCOUNT_USAGE_WINDOWS = [
-		[
-			"fuenf_stunden",
-			"five_hours",
-			"5h"
-		],
-		[
-			"sieben_tage",
-			"seven_days",
-			"7d"
-		],
-		[
-			"monat",
-			"month",
-			"month"
-		]
-	];
+	ACCOUNT_USAGE_WINDOWS = [[
+		"sieben_tage",
+		"seven_days",
+		"7d"
+	], [
+		"monat",
+		"month",
+		"month"
+	]];
 }));
 function cloneOverrides(overrides) {
 	if (overrides === void 0) return void 0;
@@ -13864,9 +13856,11 @@ function parseManagedQuotaPayload(payload) {
 	const billingKind = nonEmptyString$6(payload["art"]);
 	const globalUnlimited = payload["unlimited"];
 	if (plan === void 0 || typeof paid !== "boolean" || !Number.isSafeInteger(creditCents) || creditCents < 0 || billingKind === void 0 || globalUnlimited !== void 0 && typeof globalUnlimited !== "boolean" || !isRecord$27(payload["stand"])) return;
-	if (!hasStrictQuotaStand(payload["stand"], globalUnlimited === true)) return void 0;
+	const stand = payload["stand"];
+	if (!hasStrictQuotaStand(stand, globalUnlimited === true)) return void 0;
+	const presentWindows = QUOTA_WINDOWS.filter(([sourceKey]) => sourceKey in stand);
 	const limits = parseManagedUsagePayload(payload).limits;
-	if (limits.length !== REQUIRED_WINDOWS.length || REQUIRED_WINDOWS.some(([, id]) => limits.filter((row) => row.id === id).length !== 1)) return;
+	if (limits.length !== presentWindows.length || presentWindows.some(([, id]) => limits.filter((row) => row.id === id).length !== 1)) return;
 	return {
 		plan,
 		paid,
@@ -13931,7 +13925,8 @@ function nonEmptyString$6(value) {
 	return normalized.length === 0 ? void 0 : normalized;
 }
 function hasStrictQuotaStand(stand, globalUnlimited) {
-	return REQUIRED_WINDOWS.every(([sourceKey]) => {
+	return QUOTA_WINDOWS.every(([sourceKey]) => {
+		if (!(sourceKey in stand)) return true;
 		const row = stand[sourceKey];
 		if (!isRecord$27(row)) return false;
 		const used = row["verbraucht"];
@@ -13954,18 +13949,14 @@ function hasValidResetAt(value) {
 	if (typeof value !== "string") return false;
 	return /(?:Z|[+-]\d{2}:\d{2})$/i.test(value) && Number.isFinite(Date.parse(value));
 }
-var MANAGED_QUOTA_PATH, REQUIRED_WINDOWS;
+var MANAGED_QUOTA_PATH, QUOTA_WINDOWS;
 var init_managed_quota$1 = __esmMin((() => {
 	init_constants$6();
 	init_api_error();
 	init_managed_usage();
 	init_utils$2();
 	MANAGED_QUOTA_PATH = "/api/verbrauch/mein-stand";
-	REQUIRED_WINDOWS = [
-		["fuenf_stunden", "five_hours"],
-		["sieben_tage", "seven_days"],
-		["monat", "month"]
-	];
+	QUOTA_WINDOWS = [["sieben_tage", "seven_days"], ["monat", "month"]];
 }));
 function blunCodeFeedbackUrl(baseUrl) {
 	return `${blunCodeAuxiliaryBaseUrl(baseUrl)}/feedback`;
@@ -529129,8 +529120,11 @@ function normalizeManagedQuotaWindows(rows) {
 			unlimited: row.unlimited === true ? true : void 0
 		});
 	}
-	if (byId.size !== WINDOW_IDS.length) return void 0;
-	return WINDOW_IDS.map((id) => byId.get(id));
+	if (byId.size === 0 && rows.some((row) => row.id !== void 0 && WINDOW_IDS.includes(row.id))) return;
+	return WINDOW_IDS.flatMap((id) => {
+		const window = byId.get(id);
+		return window === void 0 ? [] : [window];
+	});
 }
 function selectHighestManagedQuotaWindow(windows) {
 	return windows?.filter((window) => window.unlimited !== true).reduce((highest, window) => highest === void 0 || window.fraction > highest.fraction ? window : highest, void 0);
@@ -529148,11 +529142,7 @@ function nextManagedQuotaWarning(windows, highestShown) {
 var MANAGED_QUOTA_WARNING_METADATA_KEY, WINDOW_IDS;
 var init_managed_quota = __esmMin((() => {
 	MANAGED_QUOTA_WARNING_METADATA_KEY = "managedQuotaWarningThreshold";
-	WINDOW_IDS = [
-		"five_hours",
-		"seven_days",
-		"month"
-	];
+	WINDOW_IDS = ["seven_days", "month"];
 }));
 function managedProviderOnly(providers) {
 	const managed = providers[DEFAULT_OAUTH_PROVIDER_NAME];
@@ -537127,6 +537117,7 @@ function centerQuotaLine(line, width) {
 	return `${" ".repeat(leftPadding)}${line}`;
 }
 function formatManagedQuotaFooterLines(windows, colors, width, options = {}) {
+	windows = windows.filter((window) => window.id !== "five_hours");
 	if (windows.length === 0 || width <= 0) return [];
 	const locale = options.locale ?? getCurrentUiLocale();
 	const variants = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.628",
+  "version": "9.1.630",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {

package/worker-host.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// BLUN_BUILD_INPUT_SHA256:c6e4e4587ddf016fdb40a775622da5455beee2ed97708e374bf683b38e4a9dea
+// BLUN_BUILD_INPUT_SHA256:295bff16bb3a40df46f164599652a975e64b232ee91e1b245fa87962a4b61885
 /*! wasm-webp 0.1.0
 MIT License
 
@@ -13011,23 +13011,15 @@ function managedContextWindowFrom(payload) {
 	const [first] = values;
 	return values.every((value) => value === first) ? first : void 0;
 }
-const ACCOUNT_USAGE_WINDOWS = [
-	[
-		"fuenf_stunden",
-		"five_hours",
-		"5h"
-	],
-	[
-		"sieben_tage",
-		"seven_days",
-		"7d"
-	],
-	[
-		"monat",
-		"month",
-		"month"
-	]
-];
+const ACCOUNT_USAGE_WINDOWS = [[
+	"sieben_tage",
+	"seven_days",
+	"7d"
+], [
+	"monat",
+	"month",
+	"month"
+]];
 function toAccountUsageRow(raw, id, label, accountUnlimited) {
 	if (!isRecord$9(raw)) return null;
 	const used = toInt(raw["verbraucht"]);
@@ -13738,11 +13730,7 @@ async function provisionManagedBlunCodeConfig(options) {
 	};
 }
 const MANAGED_QUOTA_PATH = "/api/verbrauch/mein-stand";
-const REQUIRED_WINDOWS = [
-	["fuenf_stunden", "five_hours"],
-	["sieben_tage", "seven_days"],
-	["monat", "month"]
-];
+const QUOTA_WINDOWS = [["sieben_tage", "seven_days"], ["monat", "month"]];
 function blunManagedQuotaUrl(oauthHost) {
 	return `${(oauthHost ?? process.env["BLUN_OAUTH_HOST"] ?? "https://account.blun.ai").replace(/\/+$/, "")}${MANAGED_QUOTA_PATH}`;
 }
@@ -13754,9 +13742,11 @@ function parseManagedQuotaPayload(payload) {
 	const billingKind = nonEmptyString$5(payload["art"]);
 	const globalUnlimited = payload["unlimited"];
 	if (plan === void 0 || typeof paid !== "boolean" || !Number.isSafeInteger(creditCents) || creditCents < 0 || billingKind === void 0 || globalUnlimited !== void 0 && typeof globalUnlimited !== "boolean" || !isRecord$9(payload["stand"])) return;
-	if (!hasStrictQuotaStand(payload["stand"], globalUnlimited === true)) return void 0;
+	const stand = payload["stand"];
+	if (!hasStrictQuotaStand(stand, globalUnlimited === true)) return void 0;
+	const presentWindows = QUOTA_WINDOWS.filter(([sourceKey]) => sourceKey in stand);
 	const limits = parseManagedUsagePayload(payload).limits;
-	if (limits.length !== REQUIRED_WINDOWS.length || REQUIRED_WINDOWS.some(([, id]) => limits.filter((row) => row.id === id).length !== 1)) return;
+	if (limits.length !== presentWindows.length || presentWindows.some(([, id]) => limits.filter((row) => row.id === id).length !== 1)) return;
 	return {
 		plan,
 		paid,
@@ -13821,7 +13811,8 @@ function nonEmptyString$5(value) {
 	return normalized.length === 0 ? void 0 : normalized;
 }
 function hasStrictQuotaStand(stand, globalUnlimited) {
-	return REQUIRED_WINDOWS.every(([sourceKey]) => {
+	return QUOTA_WINDOWS.every(([sourceKey]) => {
+		if (!(sourceKey in stand)) return true;
 		const row = stand[sourceKey];
 		if (!isRecord$9(row)) return false;
 		const used = row["verbraucht"];