blun-king-cli 9.1.626 → 9.1.628

package/bin/managed-plugin-selection.cjs

@@ -1,115 +1,116 @@
-'use strict';
-const { createHash, randomUUID } = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-const { ensurePrivateDirectory, securePrivateTree } = require('./private-paths');
-const SCHEMA = 'blun.managed-plugin-selection/v1';
-
-function snapshotPluginTree(root) {
-  const entries = [];
-  const rootStat = fs.lstatSync(root);
-  if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) return null;
-  const visit = (directory, relativeDirectory = '') => {
-    for (const entry of fs.readdirSync(directory, { withFileTypes: true })
-      .sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0)) {
-      const relativePath = path.join(relativeDirectory, entry.name);
-      const absolutePath = path.join(directory, entry.name);
-      const stat = fs.lstatSync(absolutePath);
-      if (stat.isSymbolicLink()) return false;
-      if (stat.isDirectory()) {
-        entries.push({ kind: 'directory', path: relativePath });
-        if (!visit(absolutePath, relativePath)) return false;
-      } else if (stat.isFile()) {
-        entries.push({ kind: 'file', path: relativePath, content: fs.readFileSync(absolutePath) });
-      } else return false;
-    }
-    return true;
-  };
-  return visit(root) ? entries : null;
-}
-
-function digestPluginEntries(entries) {
-  if (entries === null) throw new Error('Invalid managed plugin tree');
-  const hash = createHash('sha256');
-  for (const entry of entries) {
-    hash.update(Buffer.from(`${entry.kind}\0${entry.path}\0`, 'utf8'));
-    if (entry.kind === 'file') {
-      const length = Buffer.allocUnsafe(8);
-      length.writeBigUInt64BE(BigInt(entry.content.length));
-      hash.update(length);
-      hash.update(entry.content);
-    }
-  }
-  return hash.digest('hex');
-}
-
-function samePath(left, right) {
-  const normalize = value => process.platform === 'win32' ? path.resolve(value).toLowerCase() : path.resolve(value);
-  return normalize(left) === normalize(right);
-}
-
-function scopedPluginRoot(blunDir, pluginRoot) {
-  const managed = path.resolve(blunDir, 'plugins', 'managed');
-  const root = path.resolve(pluginRoot);
-  if (!samePath(path.dirname(root), managed)) throw new Error('Selected AgentSpine root is outside this profile');
-  for (const directory of [blunDir, path.dirname(managed), managed, root]) {
-    const stat = fs.lstatSync(directory);
-    if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error('Selected AgentSpine root contains a linked directory');
-  }
-  if (!samePath(path.dirname(fs.realpathSync(root)), fs.realpathSync(managed))) {
-    throw new Error('Selected AgentSpine root resolves outside this profile');
-  }
-  return root;
-}
-
-function describeAgentSpineSelection({ blunDir, pluginRoot }) {
-  const root = scopedPluginRoot(blunDir, pluginRoot);
-  const digest = digestPluginEntries(snapshotPluginTree(root));
-  if (path.basename(root) !== `agent-spine-${digest}`) throw new Error('Selected AgentSpine digest mismatch');
-  return { schema: SCHEMA, digest };
-}
-
-function selectedAgentSpineRoot({ installed, blunDir }) {
-  const records = installed.plugins.filter(record => record.id === 'agent-spine');
-  if (!records.some(record => Object.hasOwn(record, 'managedSelection'))) return null;
-  if (records.length !== 1) throw new Error('Ambiguous AgentSpine selection');
-  const [record] = records;
-  const selection = record.managedSelection;
-  if (!selection || selection.schema !== SCHEMA || !/^[a-f0-9]{64}$/.test(selection.digest || '')
-    || Object.keys(selection).sort().join(',') !== 'digest,schema' || typeof record.root !== 'string') {
-    throw new Error('Invalid AgentSpine selection');
-  }
-  const actual = describeAgentSpineSelection({ blunDir, pluginRoot: record.root });
-  if (actual.digest !== selection.digest) throw new Error('Selected AgentSpine digest mismatch');
-  return record.root;
-}
-
-function copySelectedAgentSpinePlugin({ blunDir, sourceRoot }) {
-  const plugins = path.resolve(blunDir, 'plugins');
-  const managed = path.join(plugins, 'managed');
-  ensurePrivateDirectory(plugins);
-  ensurePrivateDirectory(managed);
-  const digest = digestPluginEntries(snapshotPluginTree(sourceRoot));
-  const pluginRoot = path.join(managed, `agent-spine-${digest}`);
-  if (fs.existsSync(pluginRoot)) {
-    describeAgentSpineSelection({ blunDir, pluginRoot });
-    return pluginRoot;
-  }
-  const staging = path.join(managed, `.agent-spine-selected-${process.pid}-${randomUUID()}.tmp`);
-  try {
-    fs.cpSync(sourceRoot, staging, { recursive: true, errorOnExist: true, force: false });
-    securePrivateTree(staging);
-    if (digestPluginEntries(snapshotPluginTree(staging)) !== digest) throw new Error('AgentSpine source changed during installation');
-    fs.renameSync(staging, pluginRoot);
-    describeAgentSpineSelection({ blunDir, pluginRoot });
-    return pluginRoot;
-  } finally {
-    if (!samePath(path.dirname(staging), managed) || !path.basename(staging).startsWith('.agent-spine-selected-')) {
-      throw new Error('Invalid AgentSpine staging cleanup path');
-    }
-    fs.rmSync(staging, { recursive: true, force: true });
-  }
-}
-
-module.exports = { snapshotPluginTree, digestPluginEntries, describeAgentSpineSelection,
-  selectedAgentSpineRoot, copySelectedAgentSpinePlugin };
+'use strict';
+const { createHash, randomUUID } = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const { renamePrivateStaging } = require('./rename-private-staging.cjs');
+const { ensurePrivateDirectory, securePrivateTree } = require('./private-paths');
+const SCHEMA = 'blun.managed-plugin-selection/v1';
+
+function snapshotPluginTree(root) {
+  const entries = [];
+  const rootStat = fs.lstatSync(root);
+  if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) return null;
+  const visit = (directory, relativeDirectory = '') => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })
+      .sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0)) {
+      const relativePath = path.join(relativeDirectory, entry.name);
+      const absolutePath = path.join(directory, entry.name);
+      const stat = fs.lstatSync(absolutePath);
+      if (stat.isSymbolicLink()) return false;
+      if (stat.isDirectory()) {
+        entries.push({ kind: 'directory', path: relativePath });
+        if (!visit(absolutePath, relativePath)) return false;
+      } else if (stat.isFile()) {
+        entries.push({ kind: 'file', path: relativePath, content: fs.readFileSync(absolutePath) });
+      } else return false;
+    }
+    return true;
+  };
+  return visit(root) ? entries : null;
+}
+
+function digestPluginEntries(entries) {
+  if (entries === null) throw new Error('Invalid managed plugin tree');
+  const hash = createHash('sha256');
+  for (const entry of entries) {
+    hash.update(Buffer.from(`${entry.kind}\0${entry.path}\0`, 'utf8'));
+    if (entry.kind === 'file') {
+      const length = Buffer.allocUnsafe(8);
+      length.writeBigUInt64BE(BigInt(entry.content.length));
+      hash.update(length);
+      hash.update(entry.content);
+    }
+  }
+  return hash.digest('hex');
+}
+
+function samePath(left, right) {
+  const normalize = value => process.platform === 'win32' ? path.resolve(value).toLowerCase() : path.resolve(value);
+  return normalize(left) === normalize(right);
+}
+
+function scopedPluginRoot(blunDir, pluginRoot) {
+  const managed = path.resolve(blunDir, 'plugins', 'managed');
+  const root = path.resolve(pluginRoot);
+  if (!samePath(path.dirname(root), managed)) throw new Error('Selected AgentSpine root is outside this profile');
+  for (const directory of [blunDir, path.dirname(managed), managed, root]) {
+    const stat = fs.lstatSync(directory);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error('Selected AgentSpine root contains a linked directory');
+  }
+  if (!samePath(path.dirname(fs.realpathSync(root)), fs.realpathSync(managed))) {
+    throw new Error('Selected AgentSpine root resolves outside this profile');
+  }
+  return root;
+}
+
+function describeAgentSpineSelection({ blunDir, pluginRoot }) {
+  const root = scopedPluginRoot(blunDir, pluginRoot);
+  const digest = digestPluginEntries(snapshotPluginTree(root));
+  if (path.basename(root) !== `agent-spine-${digest}`) throw new Error('Selected AgentSpine digest mismatch');
+  return { schema: SCHEMA, digest };
+}
+
+function selectedAgentSpineRoot({ installed, blunDir }) {
+  const records = installed.plugins.filter(record => record.id === 'agent-spine');
+  if (!records.some(record => Object.hasOwn(record, 'managedSelection'))) return null;
+  if (records.length !== 1) throw new Error('Ambiguous AgentSpine selection');
+  const [record] = records;
+  const selection = record.managedSelection;
+  if (!selection || selection.schema !== SCHEMA || !/^[a-f0-9]{64}$/.test(selection.digest || '')
+    || Object.keys(selection).sort().join(',') !== 'digest,schema' || typeof record.root !== 'string') {
+    throw new Error('Invalid AgentSpine selection');
+  }
+  const actual = describeAgentSpineSelection({ blunDir, pluginRoot: record.root });
+  if (actual.digest !== selection.digest) throw new Error('Selected AgentSpine digest mismatch');
+  return record.root;
+}
+
+function copySelectedAgentSpinePlugin({ blunDir, sourceRoot }) {
+  const plugins = path.resolve(blunDir, 'plugins');
+  const managed = path.join(plugins, 'managed');
+  ensurePrivateDirectory(plugins);
+  ensurePrivateDirectory(managed);
+  const digest = digestPluginEntries(snapshotPluginTree(sourceRoot));
+  const pluginRoot = path.join(managed, `agent-spine-${digest}`);
+  if (fs.existsSync(pluginRoot)) {
+    describeAgentSpineSelection({ blunDir, pluginRoot });
+    return pluginRoot;
+  }
+  const staging = path.join(managed, `.agent-spine-selected-${process.pid}-${randomUUID()}.tmp`);
+  try {
+    fs.cpSync(sourceRoot, staging, { recursive: true, errorOnExist: true, force: false });
+    securePrivateTree(staging);
+    if (digestPluginEntries(snapshotPluginTree(staging)) !== digest) throw new Error('AgentSpine source changed during installation');
+    renamePrivateStaging(staging, pluginRoot);
+    describeAgentSpineSelection({ blunDir, pluginRoot });
+    return pluginRoot;
+  } finally {
+    if (!samePath(path.dirname(staging), managed) || !path.basename(staging).startsWith('.agent-spine-selected-')) {
+      throw new Error('Invalid AgentSpine staging cleanup path');
+    }
+    fs.rmSync(staging, { recursive: true, force: true });
+  }
+}
+
+module.exports = { snapshotPluginTree, digestPluginEntries, describeAgentSpineSelection,
+  selectedAgentSpineRoot, copySelectedAgentSpinePlugin };

package/bin/native-command-runner.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const { spawn } = require('node:child_process');
+const path = require('node:path');
+const { StringDecoder } = require('node:string_decoder');
+
+const MAX_DIAGNOSTIC_BYTES = 1024 * 1024;
+
+async function stopOwnedProcessTree(child) {
+  if (!child.pid || child.exitCode !== null || child.signalCode !== null) return;
+  if (process.platform !== 'win32') {
+    try { process.kill(-child.pid, 'SIGKILL'); } catch { child.kill('SIGKILL'); }
+    return;
+  }
+  await new Promise(resolve => {
+    const fallback = () => {
+      if (child.exitCode === null && child.signalCode === null) {
+        try { child.kill('SIGKILL'); } catch {}
+      }
+      resolve();
+    };
+    const killer = spawn(path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'taskkill.exe'),
+      ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' });
+    killer.once('error', fallback);
+    killer.once('close', fallback);
+  });
+}
+
+async function runNativeCommand(command, args, { cwd, signal, spawnImpl = spawn }) {
+  signal?.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const child = spawnImpl(command, args, { cwd, windowsHide: true,
+      detached: process.platform !== 'win32', stdio: ['ignore', 'pipe', 'pipe'] });
+    let error;
+    let stopping;
+    let cancelled = false;
+    const collect = stream => {
+      const decoder = new StringDecoder('utf8');
+      let bytes = 0;
+      let text = '';
+      let truncated = false;
+      stream.on('data', chunk => {
+        const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        const kept = data.subarray(0, Math.max(0, MAX_DIAGNOSTIC_BYTES - bytes));
+        bytes += kept.length;
+        truncated ||= kept.length !== data.length;
+        if (kept.length) text += decoder.write(kept);
+      });
+      return () => text + decoder.end() + (truncated ? '\n[NATIVE_DIAGNOSTIC_OUTPUT_TRUNCATED]' : '');
+    };
+    const stdout = collect(child.stdout);
+    const stderr = collect(child.stderr);
+    const stop = () => {
+      cancelled = true;
+      stopping ??= stopOwnedProcessTree(child).catch(stopError => {
+        error = stopError;
+        try { child.kill('SIGKILL'); } catch {}
+      });
+    };
+    signal?.addEventListener('abort', stop, { once: true });
+    child.once('error', spawnError => { error = spawnError; });
+    child.once('close', async (status, exitSignal) => {
+      signal?.removeEventListener('abort', stop);
+      await stopping;
+      if (cancelled) reject(new DOMException('Native command cancelled', 'AbortError'));
+      else resolve({ status, signal: exitSignal, stdout: stdout(), stderr: stderr(), error });
+    });
+    if (signal?.aborted) stop();
+  });
+}
+
+module.exports = { runNativeCommand };

package/bin/native-module-repair.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { spawnSync } = require('node:child_process');
+const { runNativeCommand } = require('./native-command-runner');
 const fs = require('node:fs');
 const path = require('node:path');
 
@@ -21,10 +21,11 @@ function packageHasDependency(document, dependency) {
     .some((field) => Object.hasOwn(document?.[field] || {}, dependency));
 }
 
-function nearestPackageDirectory(startDir) {
+function nearestPackageDirectory(startDir, stopDir) {
   let current = path.resolve(startDir);
   while (true) {
     if (fs.existsSync(path.join(current, 'package.json'))) return current;
+    if (stopDir !== undefined && current === stopDir) return null;
     const parent = path.dirname(current);
     if (parent === current) return null;
     current = parent;
@@ -75,7 +76,7 @@ function configuredNativeProjectPaths({ blunDir, callerCwd }) {
     path.join(root, '.mcp.json'),
     path.join(callerCwd, '.blun', 'mcp.json'),
   ].map((entry) => path.resolve(entry)))];
-  const candidates = [nearestPackageDirectory(callerCwd)];
+  const candidates = [nearestPackageDirectory(callerCwd, root)];
   for (const configPath of configPaths) {
     const document = readMcpDocument(configPath);
     const servers = document?.mcpServers;
@@ -98,12 +99,10 @@ function configuredNativeProjectPaths({ blunDir, callerCwd }) {
   return projects;
 }
 
-function probeBetterSqlite({ nodeBinary, projectDir, spawnSyncImpl }) {
-  return spawnSyncImpl(nodeBinary, ['-e', SQLITE_PROBE], {
+function probeBetterSqlite({ nodeBinary, projectDir, runCommand, signal }) {
+  return runCommand(nodeBinary, ['-e', SQLITE_PROBE], {
     cwd: projectDir,
-    encoding: 'utf8',
-    timeout: 30_000,
-    windowsHide: true,
+    signal,
   });
 }
 
@@ -119,13 +118,15 @@ function npmInvocation(nodeBinary) {
   return { args: [npmCli], command: nodeBinary };
 }
 
-function repairNativeProject({
+async function repairNativeProject({
   nodeBinary = process.execPath,
   npmCommand,
   onRepairStart,
   projectDir,
-  spawnSyncImpl = spawnSync,
+  runCommand = runNativeCommand,
+  signal,
 }) {
+  signal?.throwIfAborted();
   if (typeof projectDir !== 'string' || !path.isAbsolute(projectDir)) {
     throw new Error('Der Projektpfad fuer die native Ladeprobe muss absolut sein.');
   }
@@ -141,26 +142,27 @@ function repairNativeProject({
     return { kind: 'skipped', reason: 'dependency_missing' };
   }
 
-  const before = probeBetterSqlite({ nodeBinary, projectDir: absoluteProjectDir, spawnSyncImpl });
+  const before = await probeBetterSqlite({ nodeBinary, projectDir: absoluteProjectDir, runCommand, signal });
+  signal?.throwIfAborted();
   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'], {
+  const rebuilt = await runCommand(npm.command, [...npm.args, 'rebuild', 'better-sqlite3'], {
     cwd: absoluteProjectDir,
-    encoding: 'utf8',
-    timeout: 300_000,
-    windowsHide: true,
+    signal,
   });
+  signal?.throwIfAborted();
   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 });
+  const after = await probeBetterSqlite({ nodeBinary, projectDir: absoluteProjectDir, runCommand, signal });
+  signal?.throwIfAborted();
   if (after.status !== 0) {
     throw new Error(
       `Ladeprobe nach dem Rebuild fehlgeschlagen: ${commandFailure(after) || 'ohne Fehlertext'}`,
@@ -169,22 +171,26 @@ function repairNativeProject({
   return { kind: 'repaired' };
 }
 
-function repairConfiguredNativeModules({
+async function repairConfiguredNativeModules({
   blunDir,
   callerCwd,
   nodeBinary = process.execPath,
   onRepairStart,
   projectPaths,
   repairProject = repairNativeProject,
-  spawnSyncImpl = spawnSync,
+  runCommand = runNativeCommand,
+  signal,
 }) {
+  signal?.throwIfAborted();
   const projects = projectPaths || configuredNativeProjectPaths({ blunDir, callerCwd });
   const result = { checked: projects.length, healthy: [], repaired: [], skipped: [] };
   for (const projectDir of projects) {
-    const firstResult = repairProject({
+    signal?.throwIfAborted();
+    const firstResult = await repairProject({
       nodeBinary,
       projectDir,
-      spawnSyncImpl,
+      runCommand,
+      signal,
       onRepairStart,
     });
     if (firstResult.kind === 'healthy') result.healthy.push(projectDir);