blun-king-cli 9.0.0 → 9.0.1

package/LIESMICH.txt

@@ -18,7 +18,7 @@ Start
   king    Dieselbe Konsole mit Telegram
 
 Beim ersten Start in der Konsole /login eingeben. Der Browser öffnet den
-BLUN-OAuth-Login. Nach der Freigabe stehen King, Queen und Prince bereit.
+BLUN-OAuth-Login.
 Ein API-Schlüssel wird weder abgefragt noch in die Konfiguration geschrieben.
 
 Telegram einrichten
@@ -30,9 +30,3 @@ Telegram einrichten
 
 3. `king` starten und den angezeigten Pairing-Code mit
    /telegram:access pair CODE bestätigen.
-
-Lokale Daten
-------------
-Konfiguration, Anmeldedaten, Telegram-Zustand und Mnemo liegen unter ~/.blun.
-Die privaten Verzeichnisse und Dateien werden auf macOS mit restriktiven
-Dateirechten angelegt.

package/README.md

@@ -9,26 +9,14 @@ Der Schritt baut nichts, installiert nichts und veröffentlicht nichts. Vorher m
 `apps/blun-king/dist/main.mjs`, `dist-web`, die Darwin-Natives sowie
 `plugins/telegram/dist` bereits frisch gebaut sein.
 
-Mnemo ist kein Teil dieses Repos. Seine Quelle muss deshalb immer explizit angegeben
-werden; ein benutzerspezifischer Pfad wird nie angenommen:
-
-```text
-npm run stage:mac -- /pfad/zu/mnemo/packages/core
-npm run pack:mac  -- /pfad/zu/mnemo/packages/core
-```
-
-Alternativ kann `BLUN_MNEMO_SOURCE` gesetzt werden. Das Staging landet standardmäßig
+Das Staging landet standardmäßig
 unter `.stage/package`, das Tarball unter `.stage/artifacts`.
 `BLUN_NPM_STAGE_DIR` und `BLUN_NPM_ARTIFACT_DIR` können beide Ziele überschreiben;
 beim direkten Skriptaufruf stehen zusätzlich `--output` und `--artifacts` bereit.
 
 Der Schritt validiert alle Pflichtartefakte vor dem Leeren des alten Stagings. Er
 kopiert nur die Paket-Hülle, `blun.mjs`, `dist-web`, `native`, Telegrams
-`dist`/Manifest/Commands, die Repo-Skills und die angegebene Mnemo-Runtime. Lokale
-Mnemo-Zustände und Geheimnisse (`mnemo.db*`, `.env*`, `facts`, `logs`, `media`,
-`sources`, `tenants`, `tmp`, `node_modules`) werden ausgeschlossen. Die
-Mnemo-Abhängigkeiten werden in das gestagte `package.json` übernommen; Konflikte
-brechen vor dem Packen ab.
+`dist`/Manifest/Commands und die Repo-Skills.
 
 ## Startmodi
 
@@ -37,7 +25,7 @@ Konsole mit Telegram-Kanal, Pairing-Befehl und Telegram-Werkzeugen. Der
 Unterschied gilt nur für den laufenden Prozess; die gespeicherte
 Plugin-Konfiguration wird nicht umgeschrieben.
 
-Beim ersten Start werden das Telegram-Plugin, die lokale Mnemo-Runtime und die
-mitgelieferten Skills eingerichtet. Die Anmeldung erfolgt anschließend in der
+Beim ersten Start werden das Telegram-Plugin und die mitgelieferten Skills
+eingerichtet. Die Anmeldung erfolgt anschließend in der
 Konsole mit `/login` über den BLUN-OAuth-Server. Das Paket erzeugt keine
 statische Anbieter- oder API-Key-Konfiguration.

package/bin/blun.js

@@ -1,192 +1,280 @@
 #!/usr/bin/env node
 'use strict';
-/*
- * BLUN CLI Launcher (npm) — Erststart richtet alles ein:
- *   1. King richtet das Telegram-Plugin im BLUN_HOME ein
- *   2. Eigene lokale Memory (mnemo, SQLite) unter ~/.blun/mnemo — kein Hub,
- *      alles privat auf dem Rechner, ueberlebt Sessions und Updates.
- * Danach: TUI starten. Anmeldung und Modellkatalog kommen ueber BLUN OAuth.
- */
+
+// This public entry must stay self-contained. Package-local modules are loaded
+// only after the update owner proves that the package root is not being replaced.
+const { createHash } = require('node:crypto');
 const fs = require('node:fs');
-const path = require('node:path');
+const net = require('node:net');
 const os = require('node:os');
-const { spawnSync, spawn } = require('node:child_process');
-const {
-  LAUNCHER_MODES,
-  NPM_PACKAGE_UPDATE_COMMAND,
-  createLauncherEnvironment,
-  isNpmPackageUpdateRequest,
-  launcherModeFromArgv,
-} = require('./launcher-mode');
-const { installManagedTelegramPlugin } = require('./plugin-bootstrap');
-const {
-  ensurePrivateDirectory,
-  securePrivateFile,
-  writePrivateFile,
-} = require('./private-paths');
-
-const PKG = path.resolve(__dirname, '..');
-const HOME = os.homedir();
-const configuredBlunHome = String(process.env.BLUN_HOME || '').trim();
-const BLUN = configuredBlunHome ? path.resolve(configuredBlunHome) : path.join(HOME, '.blun');
-const MODE = launcherModeFromArgv(process.argv);
-const ARGS = process.argv.slice(2);
-
-if (ARGS.some((arg) => arg === '--version' || arg === '-V')) {
-  const { version } = JSON.parse(fs.readFileSync(path.join(PKG, 'package.json'), 'utf8'));
-  if (typeof version !== 'string' || version.length === 0) {
-    throw new Error('Ungueltige Paketversion in package.json');
+const path = require('node:path');
+
+const LEASE_PROTOCOL_VERSION = 'BLUN_UPDATE_LEASE_V3';
+const LEASE_PROBE_TIMEOUT_MS = 500;
+const MAX_POSIX_SOCKET_PATH_BYTES = 96;
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+function deriveLeaseEndpoint(role) {
+  const realpath = fs.realpathSync.native || fs.realpathSync;
+  let identity = realpath(PACKAGE_ROOT);
+  if (!fs.statSync(identity).isDirectory()) throw new Error('INVALID_PACKAGE_ROOT');
+  identity = identity.replaceAll('\\', '/');
+  if (process.platform === 'win32') identity = identity.toLowerCase();
+  const digest = createHash('sha256')
+    .update(`blun-update-v3\0${role}\0${identity}`)
+    .digest('hex');
+  const magic = `${LEASE_PROTOCOL_VERSION} ${digest}\n`;
+  if (process.platform === 'win32') {
+    return {
+      magic,
+      path: `\\\\.\\pipe\\blun-update-v3-${digest.slice(0, 32)}`,
+      platform: 'win32',
+    };
+  }
+
+  const uid = typeof process.getuid === 'function' ? process.getuid() : undefined;
+  const directoryName = `blun-update-${uid ?? digest.slice(0, 12)}`;
+  let directory = path.posix.join(os.tmpdir().replaceAll('\\', '/'), directoryName);
+  let socketPath = path.posix.join(directory, `lease-${digest.slice(0, 24)}.sock`);
+  if (Buffer.byteLength(socketPath, 'utf8') > MAX_POSIX_SOCKET_PATH_BYTES) {
+    directory = path.posix.join('/tmp', directoryName);
+    socketPath = path.posix.join(directory, `lease-${digest.slice(0, 24)}.sock`);
   }
-  process.stdout.write(`${version}\n`);
-  process.exit(0);
+  if (Buffer.byteLength(socketPath, 'utf8') > MAX_POSIX_SOCKET_PATH_BYTES) {
+    throw new Error('UPDATE_LEASE_SOCKET_PATH_TOO_LONG');
+  }
+  return { directory, magic, path: socketPath, platform: process.platform };
 }
 
-if (isNpmPackageUpdateRequest(ARGS)) {
-  process.stdout.write(`${NPM_PACKAGE_UPDATE_COMMAND}\n`);
-  process.exit(0);
+function ensurePrivateSocketDirectory(endpoint) {
+  if (endpoint.platform === 'win32') return;
+  fs.mkdirSync(endpoint.directory, { recursive: true, mode: 0o700 });
+  const stat = fs.lstatSync(endpoint.directory);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error('INVALID_UPDATE_LEASE_DIRECTORY');
+  }
+  if (typeof process.getuid === 'function'
+    && Number.isInteger(stat.uid)
+    && stat.uid !== process.getuid()) {
+    throw new Error('INVALID_UPDATE_LEASE_DIRECTORY_OWNER');
+  }
+  fs.chmodSync(endpoint.directory, 0o700);
 }
 
-/**
- * Prueft hoechstens einmal pro Tag, ob eine neuere Version von blun-king-cli
- * auf npm liegt, und zeigt einen dezenten Hinweis. Alle Fehler werden
- * verschluckt — der Start darf davon NIE abhaengen.
- */
-async function maybeShowUpdateHint(pkgRoot, blunDir) {
-  try {
-    const own = JSON.parse(fs.readFileSync(path.join(pkgRoot, 'package.json'), 'utf8'));
-    const stamp = path.join(blunDir, 'update-check.json');
-    let last = 0;
-    try { last = JSON.parse(fs.readFileSync(stamp, 'utf8')).at || 0; } catch {}
-    if (Date.now() - last < 24 * 60 * 60 * 1000) return;
-
-    const latest = await new Promise((resolve) => {
-      const req = require('node:https').get(
-        'https://registry.npmjs.org/blun-king-cli/latest',
-        { timeout: 2500, headers: { accept: 'application/json' } },
-        (res) => {
-          let body = '';
-          res.on('data', (c) => (body += c));
-          res.on('end', () => {
-            try { resolve(JSON.parse(body).version); } catch { resolve(null); }
-          });
-        },
-      );
-      req.on('error', () => resolve(null));
-      req.on('timeout', () => { req.destroy(); resolve(null); });
+function closeServer(server) {
+  return new Promise((resolve) => {
+    if (!server.listening) {
+      resolve();
+      return;
+    }
+    try {
+      server.close(() => resolve());
+    } catch {
+      resolve();
+    }
+  });
+}
+
+function listenForLease(endpoint) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer((socket) => {
+      socket.on('error', () => {});
+      socket.end(endpoint.magic);
     });
+    const onError = (error) => {
+      server.removeListener('error', onError);
+      reject(error);
+    };
+    server.once('error', onError);
+    server.listen({ path: endpoint.path, exclusive: true }, () => {
+      server.removeListener('error', onError);
+      resolve(server);
+    });
+  });
+}
 
-    try { fs.writeFileSync(stamp, JSON.stringify({ at: Date.now() })); } catch {}
-    if (latest && latest !== own.version && isNewer(latest, own.version)) {
-      console.log('');
-      console.log('  Update verfuegbar: ' + own.version + ' -> ' + latest);
-      console.log('  Aktualisieren mit:  npm i -g blun-king-cli');
-      console.log('');
+function probeLease(endpoint) {
+  return new Promise((resolve) => {
+    let received = '';
+    let settled = false;
+    let socket;
+    const finish = (state) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        socket?.destroy();
+      } catch {}
+      // oxlint-disable-next-line promise/no-multiple-resolved -- settled is the idempotence guard.
+      resolve(state);
+    };
+    const timer = setTimeout(() => finish('foreign'), LEASE_PROBE_TIMEOUT_MS);
+    timer.unref?.();
+    try {
+      socket = net.createConnection({ path: endpoint.path });
+      socket.setEncoding('utf8');
+      socket.on('data', (chunk) => {
+        received += String(chunk);
+        if (Buffer.byteLength(received, 'utf8') > Buffer.byteLength(endpoint.magic, 'utf8')) {
+          finish('foreign');
+        }
+      });
+      socket.once('end', () => finish(received === endpoint.magic ? 'owner' : 'foreign'));
+      socket.once('error', (error) => {
+        finish(error?.code === 'ECONNREFUSED' || error?.code === 'ENOENT'
+          ? 'stale'
+          : 'foreign');
+      });
+      socket.once('close', () => {
+        if (!settled) finish(received === endpoint.magic ? 'owner' : 'foreign');
+      });
+    } catch (error) {
+      finish(error?.code === 'ECONNREFUSED' || error?.code === 'ENOENT'
+        ? 'stale'
+        : 'foreign');
     }
-  } catch {
-    // Update-Check ist Kosmetik — niemals den Start blockieren.
+  });
+}
+
+function observeSocket(endpoint) {
+  if (endpoint.platform === 'win32') return { state: 'not_applicable' };
+  try {
+    const stat = fs.lstatSync(endpoint.path);
+    if (!stat.isSocket() || stat.isSymbolicLink()) return { state: 'unsafe' };
+    return { dev: stat.dev, ino: stat.ino, state: 'socket' };
+  } catch (error) {
+    return error?.code === 'ENOENT' ? { state: 'missing' } : { state: 'unsafe' };
   }
 }
 
-function isNewer(a, b) {
-  const pa = String(a).split('.').map((n) => parseInt(n, 10) || 0);
-  const pb = String(b).split('.').map((n) => parseInt(n, 10) || 0);
-  for (let i = 0; i < 3; i++) {
-    if ((pa[i] || 0) > (pb[i] || 0)) return true;
-    if ((pa[i] || 0) < (pb[i] || 0)) return false;
+function removeObservedSocket(endpoint, observed) {
+  if (endpoint.platform === 'win32') return false;
+  try {
+    const stat = fs.lstatSync(endpoint.path);
+    if (observed.state !== 'socket'
+      || !stat.isSocket()
+      || stat.isSymbolicLink()
+      || stat.dev !== observed.dev
+      || stat.ino !== observed.ino) {
+      return false;
+    }
+    fs.unlinkSync(endpoint.path);
+    return true;
+  } catch (error) {
+    return error?.code === 'ENOENT' && observed.state === 'missing';
   }
-  return false;
 }
 
-(async () => {
-  ensurePrivateDirectory(BLUN);
-
-  // --- 1. Bestehende Konfiguration absichern -------------------------------
-  // Ein frischer Start bleibt absichtlich ohne statischen Anbieter. /login
-  // provisioniert King, Queen und Prince ueber den BLUN-OAuth-Server.
-  const cfgFile = path.join(BLUN, 'config.toml');
-  if (fs.existsSync(cfgFile)) securePrivateFile(cfgFile);
-
-  // --- 2. Telegram-Plugin + Token-Vorlage (nur King) -----------------------
-  if (MODE === LAUNCHER_MODES.KING) {
-    installManagedTelegramPlugin({ packageRoot: PKG, blunDir: BLUN });
-    const channelDir = path.join(BLUN, 'channels', 'telegram');
-    fs.mkdirSync(channelDir, { recursive: true });
-    const envFile = path.join(channelDir, '.env');
-    if (!fs.existsSync(envFile)) {
-      writePrivateFile(envFile, 'BLUN_TELEGRAM_BOT_TOKEN=HIER_DEIN_BOT_TOKEN_EINFUEGEN\n');
-    } else {
-      securePrivateFile(envFile);
+function recordSocket(endpoint) {
+  if (endpoint.platform === 'win32') return undefined;
+  const stat = fs.lstatSync(endpoint.path);
+  if (!stat.isSocket() || stat.isSymbolicLink()) throw new Error('INVALID_UPDATE_LEASE_SOCKET');
+  fs.chmodSync(endpoint.path, 0o600);
+  return { dev: stat.dev, ino: stat.ino };
+}
+
+function removeOwnedSocket(endpoint, identity) {
+  if (endpoint.platform === 'win32' || !identity) return;
+  try {
+    const stat = fs.lstatSync(endpoint.path);
+    if (stat.isSocket()
+      && !stat.isSymbolicLink()
+      && stat.dev === identity.dev
+      && stat.ino === identity.ino) {
+      fs.unlinkSync(endpoint.path);
     }
+  } catch {}
+}
+
+async function acquireNoticeLease() {
+  let endpoint;
+  try {
+    endpoint = deriveLeaseEndpoint('notice');
+    ensurePrivateSocketDirectory(endpoint);
+  } catch {
+    return { acquired: false, reason: 'unavailable' };
   }
 
-  // --- 2b. Built-in-Skills installieren (fehlende ergaenzen, nie
-  //         vorhandene ueberschreiben — User-Anpassungen bleiben) -----------
-  const skillsSrc = path.join(PKG, 'skills');
-  const skillsDst = path.join(BLUN, 'skills');
-  if (fs.existsSync(skillsSrc)) {
-    fs.mkdirSync(skillsDst, { recursive: true });
-    for (const entry of fs.readdirSync(skillsSrc)) {
-      const dst = path.join(skillsDst, entry);
-      if (!fs.existsSync(dst)) {
-        fs.cpSync(path.join(skillsSrc, entry), dst, { recursive: true });
+  let server;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      server = await listenForLease(endpoint);
+      break;
+    } catch (error) {
+      if (error?.code !== 'EADDRINUSE') return { acquired: false, reason: 'unavailable' };
+      const observed = observeSocket(endpoint);
+      const state = await probeLease(endpoint);
+      if (state === 'owner') return { acquired: false, reason: 'busy' };
+      if (state !== 'stale' || attempt > 0) return { acquired: false, reason: 'unavailable' };
+      if (endpoint.platform === 'win32') continue;
+      if (!removeObservedSocket(endpoint, observed)) {
+        return { acquired: false, reason: 'unavailable' };
       }
     }
   }
+  if (!server) return { acquired: false, reason: 'unavailable' };
+
+  let identity;
+  try {
+    identity = recordSocket(endpoint);
+  } catch {
+    await closeServer(server);
+    return { acquired: false, reason: 'unavailable' };
+  }
 
-  // --- 3. Eigene lokale Memory (einmalig anlegen) --------------------------
-  const memHome = path.join(BLUN, 'mnemo');
-  const factsDir = path.join(memHome, 'facts');
-  fs.mkdirSync(factsDir, { recursive: true });
-  const dbFile = path.join(memHome, 'mnemo.db');
-  const agent = (process.env.BLUN_MNEMO_AGENT || os.userInfo().username || 'agent')
-    .toLowerCase().replaceAll(/[^a-z0-9_-]/g, '-') || 'agent';
-  if (!fs.existsSync(dbFile)) {
-    const result = spawnSync(process.execPath, [path.join(PKG, 'mnemo', 'bootstrap_auto.js')], {
-      env: {
-        ...process.env,
-        BLUN_HOME: BLUN,
-        MNEMO_DB: dbFile,
-        MNEMO_AGENT: agent,
-        MNEMO_OWNER_NAME: agent,
-        MNEMO_FACTS_DIR: factsDir,
-        MNEMO_ENV_FILE: path.join(memHome, '.env.local'),
-        MNEMO_HOOK_ENV_FILE: path.join(BLUN, '.mnemo-hook.env'),
-        MNEMO_HUB_URL: '',
+  let owned = true;
+  let released = false;
+  server.on('error', () => { owned = false; });
+  server.on('close', () => { owned = false; });
+  return {
+    acquired: true,
+    lease: Object.freeze({
+      assertOwned() {
+        if (!owned || !server.listening) throw new Error('UPDATE_LEASE_LOST');
       },
-      stdio: 'ignore',
+      async release() {
+        if (released) return;
+        released = true;
+        owned = false;
+        await closeServer(server);
+        removeOwnedSocket(endpoint, identity);
+      },
+    }),
+  };
+}
+
+async function installLeaseIsClear() {
+  try {
+    const endpoint = deriveLeaseEndpoint('install');
+    ensurePrivateSocketDirectory(endpoint);
+    return await probeLease(endpoint) === 'stale';
+  } catch {
+    return false;
+  }
+}
+
+async function main() {
+  const result = await acquireNoticeLease();
+  if (!result.acquired) return;
+  try {
+    if (!await installLeaseIsClear()) return;
+    result.lease.assertOwned();
+    const { runLauncher } = require('./launcher-runtime');
+    result.lease.assertOwned();
+    const filename = path.basename(__filename).toLowerCase();
+    await runLauncher({
+      mode: filename.startsWith('king') ? 'king' : 'blun',
+      noticeLease: result.lease,
     });
-    if (result.status === 0 && fs.existsSync(dbFile)) {
-      console.log('  Eigene Memory angelegt (Agent: ' + agent + ') — merkt sich alles, Sessions-uebergreifend.');
-    } else {
-      console.error('  Warnung: Memory konnte nicht angelegt werden — BLUN laeuft trotzdem, nur ohne Langzeitgedaechtnis.');
-    }
+  } finally {
+    await result.lease.release();
   }
+}
 
-  // --- 3b. Update-Hinweis. Best-effort, blockiert NIE und prueft hoechstens
-  //         einmal pro Tag die neueste Version auf npm. ---------------------
-  await maybeShowUpdateHint(PKG, BLUN);
-
-  // --- 4. Start -------------------------------------------------------------
-  const env = createLauncherEnvironment(process.env, MODE);
-  env.BLUN_HOME = BLUN;
-  env.BLUN_MODEL_MAX_COMPLETION_TOKENS = env.BLUN_MODEL_MAX_COMPLETION_TOKENS || '32768';
-  env.BLUN_MNEMO_MCP = path.join(PKG, 'mnemo', 'mcp.js');
-  env.BLUN_MNEMO_AGENT = agent;
-  env.MNEMO_DB = dbFile;
-  env.MNEMO_FACTS_DIR = factsDir;
-  env.MNEMO_HUB_URL = '';
-
-  const workspace = path.join(HOME, 'BLUN-Workspace');
-  fs.mkdirSync(workspace, { recursive: true });
-
-  const child = spawn(process.execPath, [path.join(PKG, 'blun.mjs'), '--yolo', ...ARGS], {
-    cwd: workspace,
-    env,
-    stdio: 'inherit',
-  });
-  child.on('exit', (code) => process.exit(code ?? 0));
-})().catch((error) => {
+// oxlint-disable-next-line unicorn/prefer-top-level-await -- Public npm bins are CommonJS.
+void main().catch((error) => {
+  // oxlint-disable-next-line no-console -- Fatal launcher errors belong on stderr.
   console.error('BLUN Start fehlgeschlagen: '
     + (error && error.message ? error.message : String(error)));
-  process.exit(1);
+  process.exitCode = 1;
 });

package/bin/core-bootstrap.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+
+const { tryAcquireUpdateLease } = require('./update-lease');
+
+const CORE_LOADED_MESSAGE = 'blun-core-bootstrap-loaded';
+
+async function runCoreBootstrap() {
+  const packageRoot = path.resolve(__dirname, '..');
+  const mainPath = path.join(packageRoot, 'blun.mjs');
+  const leaseResult = await tryAcquireUpdateLease({ packageRoot, role: 'install' });
+  if (!leaseResult.acquired) process.exit(75);
+
+  try {
+    leaseResult.lease.assertOwned();
+    process.argv = [process.execPath, mainPath, ...process.argv.slice(2)];
+    await import(pathToFileURL(mainPath).href);
+    leaseResult.lease.assertOwned();
+  } catch (error) {
+    await leaseResult.lease.release();
+    throw error;
+  }
+
+  // The bundled CLI loads package assets lazily after module evaluation. Keep
+  // the install lease for this process's lifetime, without keeping print/help
+  // commands alive solely because of the owner server.
+  leaseResult.lease.unref();
+
+  if (process.connected) {
+    try {
+      process.send({ type: CORE_LOADED_MESSAGE }, () => {
+        try {
+          process.disconnect();
+        } catch {}
+      });
+    } catch {}
+  }
+}
+
+if (require.main === module) {
+  // oxlint-disable-next-line unicorn/prefer-top-level-await -- Worker entry is CommonJS.
+  void runCoreBootstrap().catch(() => process.exit(1));
+}
+
+module.exports = { CORE_LOADED_MESSAGE, runCoreBootstrap };