blun-king-cli 9.1.628 → 9.1.629

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/package.json

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