blun-king-cli 9.1.36 → 9.1.37

package/bin/launcher-runtime.js

@@ -23,6 +23,7 @@ const {
 } = require('./standard-tools-bootstrap');
 const { CORE_LOADED_MESSAGE } = require('./core-bootstrap');
 const { prepareManagedNodeRuntime } = require('./node-runtime');
+const { repairConfiguredNativeModules } = require('./native-module-repair');
 const { acquireSharedRuntimeLease, tryAcquireUpdateLease } = require('./update-lease');
 const { runExplicitUpdate, runUpdateNotice } = require('./update-notice');
 const {
@@ -388,6 +389,17 @@ async function runLauncher(options = {}) {
       installTelegramForProfile(PKG, blunDir);
     }
 
+    const nativeModules = repairConfiguredNativeModules({
+      blunDir,
+      callerCwd,
+      onRepairStart() {
+        process.stdout.write('BLUN richtet native Node.js-Module fuer die neue Laufzeit ein.\n');
+      },
+    });
+    if (nativeModules.repaired.length > 0) {
+      process.stdout.write('Native Node.js-Module sind wieder einsatzbereit.\n');
+    }
+
     // --- 6. Start -----------------------------------------------------------
     const env = createLauncherEnvironment(process.env, mode, readPackageVersion());
     env.BLUN_HOME = blunDir;

package/bin/native-module-repair.js

@@ -0,0 +1,201 @@
+'use strict';
+
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SQLITE_PROBE = [
+  "const Database = require('better-sqlite3');",
+  "const db = new Database(':memory:');",
+  "const row = db.prepare('SELECT 1 AS ok').get();",
+  'db.close();',
+  "if (row?.ok !== 1) throw new Error('SQLITE_PROBE_FAILED');",
+].join(' ');
+
+function commandFailure(result) {
+  return String(result?.stderr || result?.stdout || result?.error?.message || '').trim();
+}
+
+function packageHasDependency(document, dependency) {
+  return ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies']
+    .some((field) => Object.hasOwn(document?.[field] || {}, dependency));
+}
+
+function nearestPackageDirectory(startDir) {
+  let current = path.resolve(startDir);
+  while (true) {
+    if (fs.existsSync(path.join(current, 'package.json'))) return current;
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+function projectRoot(startDir) {
+  let current = path.resolve(startDir);
+  while (true) {
+    if (fs.existsSync(path.join(current, '.git'))) return current;
+    const parent = path.dirname(current);
+    if (parent === current) return path.resolve(startDir);
+    current = parent;
+  }
+}
+
+function readMcpDocument(configPath) {
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    const document = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    return document && typeof document === 'object' ? document : null;
+  } catch {
+    return null;
+  }
+}
+
+function serverProjectDirectory(server, configPath) {
+  if (!server || typeof server !== 'object' || server.enabled === false) return null;
+  if (typeof server.cwd === 'string' && server.cwd.trim()) {
+    const cwd = server.cwd.trim();
+    return nearestPackageDirectory(
+      path.isAbsolute(cwd) ? cwd : path.resolve(path.dirname(configPath), cwd),
+    );
+  }
+  const args = Array.isArray(server.args) ? server.args : [];
+  const script = args.find((arg) => typeof arg === 'string' && /\.[cm]?js$/iu.test(arg));
+  if (!script) return null;
+  const scriptPath = path.isAbsolute(script)
+    ? script
+    : path.resolve(path.dirname(configPath), script);
+  return nearestPackageDirectory(path.dirname(scriptPath));
+}
+
+function configuredNativeProjectPaths({ blunDir, callerCwd }) {
+  const root = projectRoot(callerCwd);
+  const configPaths = [...new Set([
+    path.join(blunDir, 'mcp.json'),
+    path.join(root, '.mcp.json'),
+    path.join(callerCwd, '.blun', 'mcp.json'),
+  ].map((entry) => path.resolve(entry)))];
+  const candidates = [nearestPackageDirectory(callerCwd)];
+  for (const configPath of configPaths) {
+    const document = readMcpDocument(configPath);
+    const servers = document?.mcpServers;
+    if (!servers || typeof servers !== 'object' || Array.isArray(servers)) continue;
+    for (const server of Object.values(servers)) {
+      candidates.push(serverProjectDirectory(server, configPath));
+    }
+  }
+
+  const seen = new Set();
+  const projects = [];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const absolute = path.resolve(candidate);
+    const key = process.platform === 'win32' ? absolute.toLowerCase() : absolute;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    projects.push(absolute);
+  }
+  return projects;
+}
+
+function probeBetterSqlite({ nodeBinary, projectDir, spawnSyncImpl }) {
+  return spawnSyncImpl(nodeBinary, ['-e', SQLITE_PROBE], {
+    cwd: projectDir,
+    encoding: 'utf8',
+    timeout: 30_000,
+    windowsHide: true,
+  });
+}
+
+function npmInvocation(nodeBinary) {
+  const candidates = [
+    path.join(path.dirname(nodeBinary), 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.resolve(path.dirname(nodeBinary), '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+  ];
+  const npmCli = candidates.find((candidate) => fs.existsSync(candidate));
+  if (!npmCli) {
+    throw new Error('npm-cli.js wurde fuer die aktive Node.js-Laufzeit nicht gefunden.');
+  }
+  return { args: [npmCli], command: nodeBinary };
+}
+
+function repairNativeProject({
+  nodeBinary = process.execPath,
+  npmCommand,
+  onRepairStart,
+  projectDir,
+  spawnSyncImpl = spawnSync,
+}) {
+  if (typeof projectDir !== 'string' || !path.isAbsolute(projectDir)) {
+    throw new Error('Der Projektpfad fuer die native Ladeprobe muss absolut sein.');
+  }
+  const absoluteProjectDir = path.resolve(projectDir);
+  const packagePath = path.join(absoluteProjectDir, 'package.json');
+  let packageDocument;
+  try {
+    packageDocument = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  } catch {
+    return { kind: 'skipped', reason: 'package_unreadable' };
+  }
+  if (!packageHasDependency(packageDocument, 'better-sqlite3')) {
+    return { kind: 'skipped', reason: 'dependency_missing' };
+  }
+
+  const before = probeBetterSqlite({ nodeBinary, projectDir: absoluteProjectDir, spawnSyncImpl });
+  if (before.status === 0) return { kind: 'healthy' };
+
+  const npm = npmCommand === undefined
+    ? npmInvocation(nodeBinary)
+    : { args: [], command: npmCommand };
+  onRepairStart?.(absoluteProjectDir);
+  const rebuilt = spawnSyncImpl(npm.command, [...npm.args, 'rebuild', 'better-sqlite3'], {
+    cwd: absoluteProjectDir,
+    encoding: 'utf8',
+    timeout: 300_000,
+    windowsHide: true,
+  });
+  if (rebuilt.status !== 0) {
+    throw new Error(
+      `Native Node.js-Module konnten nicht repariert werden: ${commandFailure(rebuilt) || 'ohne Fehlertext'}`,
+    );
+  }
+
+  const after = probeBetterSqlite({ nodeBinary, projectDir: absoluteProjectDir, spawnSyncImpl });
+  if (after.status !== 0) {
+    throw new Error(
+      `Ladeprobe nach dem Rebuild fehlgeschlagen: ${commandFailure(after) || 'ohne Fehlertext'}`,
+    );
+  }
+  return { kind: 'repaired' };
+}
+
+function repairConfiguredNativeModules({
+  blunDir,
+  callerCwd,
+  nodeBinary = process.execPath,
+  onRepairStart,
+  projectPaths,
+  repairProject = repairNativeProject,
+  spawnSyncImpl = spawnSync,
+}) {
+  const projects = projectPaths || configuredNativeProjectPaths({ blunDir, callerCwd });
+  const result = { checked: projects.length, healthy: [], repaired: [], skipped: [] };
+  for (const projectDir of projects) {
+    const firstResult = repairProject({
+      nodeBinary,
+      projectDir,
+      spawnSyncImpl,
+      onRepairStart,
+    });
+    if (firstResult.kind === 'healthy') result.healthy.push(projectDir);
+    else if (firstResult.kind === 'repaired') result.repaired.push(projectDir);
+    else result.skipped.push(projectDir);
+  }
+  return result;
+}
+
+module.exports = {
+  configuredNativeProjectPaths,
+  repairConfiguredNativeModules,
+  repairNativeProject,
+};

package/package.json

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