blun-king-cli 9.1.624 → 9.1.626

package/bin/profile-handoff.cjs

@@ -1,152 +0,0 @@
-'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

@@ -1,120 +0,0 @@
-'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 };