blun-king-cli 9.1.625 → 9.1.628-pruefpaket.modules.r7

package/bin/core-bootstrap.js

@@ -1,77 +1,93 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-const { pathToFileURL } = require('node:url');
-
-const { acquireSharedRuntimeLease } = require('./update-lease');
-const { installWindowsNodeCrashDump } = require('./windows-node-crash-dump.cjs');
-const { recordRuntimeExit } = require('./runtime-exit-ledger.cjs');
-const { isStandaloneHelpRequest } = require('./launcher-mode');
-
-const CORE_LOADED_MESSAGE = 'blun-core-bootstrap-loaded';
-
-async function runCoreBootstrap() {
-  const informational = isStandaloneHelpRequest(process.argv.slice(2));
-  let diagnostics;
-  if (!informational) {
-    try { diagnostics = installWindowsNodeCrashDump({ homeDir: process.env.BLUN_HOME }); } catch {}
-  }
-  const packageRoot = path.resolve(__dirname, '..');
-  const mainPath = path.join(packageRoot, 'blun.mjs');
-  let leaseResult;
-
-  try {
-    leaseResult = await acquireSharedRuntimeLease({ packageRoot });
-    if (!leaseResult.acquired) throw new Error('RUNTIME_PROTECTION_UNAVAILABLE');
-    leaseResult.lease.assertOwned();
-    process.argv = [process.execPath, mainPath, ...process.argv.slice(2)];
-    await import(pathToFileURL(mainPath).href);
-    leaseResult.lease.assertOwned();
-  } catch (error) {
-    if (!informational) {
-      try {
-        if (diagnostics?.enabled) diagnostics.write(error, 'bootstrap-failure');
-        else recordRuntimeExit({ homeDir: process.env.BLUN_HOME, source: 'bootstrap',
-          kind: 'bootstrap-failure', phase: 'startup', error });
-      } catch {}
-    }
-    try { diagnostics?.dispose(); } catch {}
-    try { await leaseResult?.lease?.release(); }
-    catch (leaseError) {
-      if (!informational) {
-        try {
-          recordRuntimeExit({ homeDir: process.env.BLUN_HOME, source: 'bootstrap',
-            kind: 'lease-release-failure', phase: 'cleanup', error: leaseError });
-        } catch {}
-      }
-    }
-    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((error) => {
-    const message = error && error.message ? error.message : String(error);
-    fs.writeSync(process.stderr.fd, `BLUN Start fehlgeschlagen: ${message}\n`);
-    process.exit(1);
-  });
-}
-
-module.exports = { CORE_LOADED_MESSAGE, runCoreBootstrap };
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+
+const { acquireSharedRuntimeLease } = require('./update-lease');
+const { installWindowsNodeCrashDump } = require('./windows-node-crash-dump.cjs');
+const { recordRuntimeExit } = require('./runtime-exit-ledger.cjs');
+const { isStandaloneHelpRequest, isReadOnlyInspectionRequest } = require('./launcher-mode');
+
+const CORE_LOADED_MESSAGE = 'blun-core-bootstrap-loaded';
+
+function bindInteractiveTerminalOwner() {
+  if (process.platform !== 'win32' || process.env.BLUN_TERMINAL_OWNER !== '1' || !process.channel) return;
+  const stop = () => {
+    setTimeout(() => process.exit(143), 5000).unref();
+    if (!process.emit('SIGTERM')) process.exit(143);
+  };
+  process.once('disconnect', stop);
+  if (!process.connected) stop();
+}
+
+async function runCoreBootstrap() {
+  bindInteractiveTerminalOwner();
+  const args = process.argv.slice(2);
+  const informational = isStandaloneHelpRequest(args) || isReadOnlyInspectionRequest(args);
+  let diagnostics;
+  if (!informational) {
+    try { diagnostics = installWindowsNodeCrashDump({ homeDir: process.env.BLUN_HOME }); } catch {}
+  }
+  const packageRoot = path.resolve(__dirname, '..');
+  const mainPath = path.join(packageRoot, 'blun.mjs');
+  let leaseResult;
+
+  try {
+    leaseResult = await acquireSharedRuntimeLease({ packageRoot });
+    if (!leaseResult.acquired) throw new Error('RUNTIME_PROTECTION_UNAVAILABLE');
+    leaseResult.lease.assertOwned();
+    process.argv = [process.execPath, mainPath, ...process.argv.slice(2)];
+    await import(pathToFileURL(mainPath).href);
+    leaseResult.lease.assertOwned();
+  } catch (error) {
+    if (!informational) {
+      try {
+        if (diagnostics?.enabled) diagnostics.write(error, 'bootstrap-failure');
+        else recordRuntimeExit({ homeDir: process.env.BLUN_HOME, source: 'bootstrap',
+          kind: 'bootstrap-failure', phase: 'startup', error });
+      } catch {}
+    }
+    try { diagnostics?.dispose(); } catch {}
+    try { await leaseResult?.lease?.release(); }
+    catch (leaseError) {
+      if (!informational) {
+        try {
+          recordRuntimeExit({ homeDir: process.env.BLUN_HOME, source: 'bootstrap',
+            kind: 'lease-release-failure', phase: 'cleanup', error: leaseError });
+        } catch {}
+      }
+    }
+    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 }, () => {
+        if (process.env.BLUN_TERMINAL_OWNER === '1') {
+          process.channel?.unref();
+          return;
+        }
+        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((error) => {
+    const message = error && error.message ? error.message : String(error);
+    fs.writeSync(process.stderr.fd, `BLUN Start fehlgeschlagen: ${message}\n`);
+    process.exit(1);
+  });
+}
+
+module.exports = { CORE_LOADED_MESSAGE, runCoreBootstrap };

package/bin/launcher-mode.js

@@ -1,93 +1,126 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-const LAUNCHER_MODES = Object.freeze({
-  BLUN: 'blun',
-  KING: 'king',
-});
-
-const LAUNCHER_HELP_TEXT = [
-  '',
-  'Launchers:',
-  '  blun  Starts the CLI without automatically attaching Telegram.',
-  '  king  Starts the same CLI and automatically attaches the configured Telegram channel.',
-  '  Both use the same version, account, model, and commands.',
-  '  blun tools list shows optional tools; enable writes only explicit choices.',
-  '',
-].join('\n');
-
-function launcherModeFromArgv(argv) {
-  const entry = argv[1] || '';
-  const filename = entry.replaceAll('\\', '/').split('/').pop() || '';
-  const command = filename.replace(/\.(?:c|m)?js$/i, '').toLowerCase();
-  return command === LAUNCHER_MODES.KING ? LAUNCHER_MODES.KING : LAUNCHER_MODES.BLUN;
-}
-
-function runtimePolicyEnvironment(blunDir) {
-  if (blunDir === undefined) return {};
-  let policy;
-  try {
-    if (!path.isAbsolute(blunDir)) throw new Error('Invalid home');
-    const file = path.join(blunDir, 'runtime-policy.json');
-    const stat = fs.lstatSync(file);
-    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 4096) throw new Error('Invalid file');
-    policy = JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch (error) {
-    if (error.code === 'ENOENT') return {};
-    throw new Error('Invalid BLUN runtime policy');
-  }
-  const review = policy?.responseReview;
-  if (policy?.schema !== 'blun.runtime-policy/v1'
-    || Object.keys(policy).sort().join(',') !== 'responseReview,schema'
-    || !review || Object.keys(review).sort().join(',') !== 'guardVersion,language,required'
-    || review.required !== true || typeof review.language !== 'string'
-    || !/^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/.test(review.language)
-    || /^(auto|all)$/i.test(review.language)
-    || typeof review.guardVersion !== 'string' || !/^\d+\.\d+\.\d+$/.test(review.guardVersion)) {
-    throw new Error('Invalid BLUN runtime policy');
-  }
-  return {
-    BLUN_LANGUAGE_GUARD_MANDATORY: '1',
-    BLUN_LANGUAGE_GUARD_LANGUAGE: review.language,
-    BLUN_LANGUAGE_GUARD_VERSION: review.guardVersion,
-    BLUN_TELEGRAM_LANGUAGE_GATE: 'required',
-    BLUN_TELEGRAM_OUTPUT_LOCALE: review.language,
-    AGENTSPINE_STATE_DIR: path.join(blunDir, 'state', 'agent-spine'),
-  };
-}
-
-function createLauncherEnvironment(sourceEnv, mode, publicPackageVersion, blunDir) {
-  return {
-    ...sourceEnv,
-    ...runtimePolicyEnvironment(blunDir),
-    BLUN_NO_AUTO_UPDATE: '1',
-    BLUN_PUBLIC_PACKAGE_VERSION: publicPackageVersion,
-    BLUN_TELEGRAM_ATTACH: mode === LAUNCHER_MODES.KING ? 'on' : 'off',
-    BLUN_TELEGRAM_HEADLESS: 'off',
-  };
-}
-
-function isNpmPackageUpdateRequest(args) {
-  if (!Array.isArray(args) || args.length !== 1) return false;
-  const command = String(args[0] || '').toLowerCase();
-  return command === 'update' || command === 'upgrade';
-}
-
-function isStandaloneHelpRequest(args) {
-  return Array.isArray(args) && args.length === 1 && (args[0] === '--help' || args[0] === '-h');
-}
-
-function launcherHelpText() {
-  return LAUNCHER_HELP_TEXT;
-}
-
-module.exports = {
-  LAUNCHER_MODES,
-  createLauncherEnvironment,
-  isNpmPackageUpdateRequest,
-  isStandaloneHelpRequest,
-  launcherHelpText,
-  launcherModeFromArgv,
-};
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { parseArgs } = require('node:util');
+
+const LAUNCHER_MODES = Object.freeze({
+  BLUN: 'blun',
+  KING: 'king',
+});
+
+const SETUP_INSPECTION_OPTIONS = new Set([
+  '--json', '--reference', '--proposal', '--validate', '--document', '--query', '--target',
+]);
+const CONFIG_INSPECTION_COMMANDS = new Set(['validate', 'inspect', 'preview']);
+
+const LAUNCHER_HELP_TEXT = [
+  '',
+  'Launchers:',
+  '  blun  Starts the CLI without automatically attaching Telegram.',
+  '  king  Starts the same CLI and automatically attaches the configured Telegram channel.',
+  '  Both use the same version, account, model, and commands.',
+  '  blun tools list shows optional tools; enable writes only explicit choices.',
+  '',
+].join('\n');
+
+function launcherModeFromArgv(argv) {
+  const entry = argv[1] || '';
+  const filename = entry.replaceAll('\\', '/').split('/').pop() || '';
+  const command = filename.replace(/\.(?:c|m)?js$/i, '').toLowerCase();
+  return command === LAUNCHER_MODES.KING ? LAUNCHER_MODES.KING : LAUNCHER_MODES.BLUN;
+}
+
+function runtimePolicyEnvironment(blunDir) {
+  if (blunDir === undefined) return {};
+  let policy;
+  try {
+    if (!path.isAbsolute(blunDir)) throw new Error('Invalid home');
+    const file = path.join(blunDir, 'runtime-policy.json');
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 4096) throw new Error('Invalid file');
+    policy = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT') return {};
+    throw new Error('Invalid BLUN runtime policy');
+  }
+  const review = policy?.responseReview;
+  if (policy?.schema !== 'blun.runtime-policy/v1'
+    || Object.keys(policy).sort().join(',') !== 'responseReview,schema'
+    || !review || Object.keys(review).sort().join(',') !== 'guardVersion,language,required'
+    || review.required !== true || typeof review.language !== 'string'
+    || !/^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/.test(review.language)
+    || /^(auto|all)$/i.test(review.language)
+    || typeof review.guardVersion !== 'string' || !/^\d+\.\d+\.\d+$/.test(review.guardVersion)) {
+    throw new Error('Invalid BLUN runtime policy');
+  }
+  return {
+    BLUN_LANGUAGE_GUARD_MANDATORY: '1',
+    BLUN_LANGUAGE_GUARD_LANGUAGE: review.language,
+    BLUN_LANGUAGE_GUARD_VERSION: review.guardVersion,
+    BLUN_TELEGRAM_LANGUAGE_GATE: 'required',
+    BLUN_TELEGRAM_OUTPUT_LOCALE: review.language,
+    AGENTSPINE_STATE_DIR: path.join(blunDir, 'state', 'agent-spine'),
+  };
+}
+
+function createLauncherEnvironment(sourceEnv, mode, publicPackageVersion, blunDir) {
+  return {
+    ...sourceEnv,
+    ...runtimePolicyEnvironment(blunDir),
+    BLUN_NO_AUTO_UPDATE: '1',
+    BLUN_PUBLIC_PACKAGE_VERSION: publicPackageVersion,
+    BLUN_TELEGRAM_ATTACH: mode === LAUNCHER_MODES.KING ? 'on' : 'off',
+    BLUN_TELEGRAM_HEADLESS: 'off',
+  };
+}
+
+function isNpmPackageUpdateRequest(args) {
+  if (!Array.isArray(args) || args.length !== 1) return false;
+  const command = String(args[0] || '').toLowerCase();
+  return command === 'update' || command === 'upgrade';
+}
+
+function isStandaloneHelpRequest(args) {
+  return Array.isArray(args) && args.length === 1 && (args[0] === '--help' || args[0] === '-h');
+}
+
+function isReadOnlySetupRequest(args) {
+  return Array.isArray(args) && args[0] === 'setup'
+    && args.slice(1).some(value => typeof value === 'string' && SETUP_INSPECTION_OPTIONS.has(value.split('=', 1)[0]));
+}
+
+function isReadOnlyInspectionRequest(args) {
+  return isReadOnlySetupRequest(args)
+    || (Array.isArray(args) && args[0] === 'config' && CONFIG_INSPECTION_COMMANDS.has(args[1]))
+    || (Array.isArray(args) && args[0] === 'docs')
+    || isReadOnlyDoctorRequest(args);
+}
+
+function isReadOnlyDoctorRequest(args) {
+  if (!Array.isArray(args) || args[0] !== 'doctor') return false;
+  try {
+    const { positionals } = parseArgs({ args: args.slice(1), allowPositionals: true,
+      options: { json: { type: 'boolean' }, schema: { type: 'boolean' }, help: { type: 'boolean', short: 'h' } } });
+    if (positionals.length === 0) return true;
+    if (positionals[0] === 'config' || positionals[0] === 'tui') return positionals.length <= 2;
+    return positionals[0] === 'mcp' && positionals.length === 2;
+  } catch {
+    return false;
+  }
+}
+
+function launcherHelpText() {
+  return LAUNCHER_HELP_TEXT;
+}
+
+module.exports = {
+  LAUNCHER_MODES,
+  createLauncherEnvironment,
+  isNpmPackageUpdateRequest,
+  isStandaloneHelpRequest,
+  isReadOnlySetupRequest,
+  isReadOnlyInspectionRequest,
+  launcherHelpText,
+  launcherModeFromArgv,
+};

package/bin/launcher-runtime.js

@@ -13,6 +13,7 @@ const {
   createLauncherEnvironment,
   isNpmPackageUpdateRequest,
   isStandaloneHelpRequest,
+  isReadOnlyInspectionRequest,
   launcherHelpText,
   launcherModeFromArgv,
 } = require('./launcher-mode');
@@ -50,6 +51,34 @@ function resolveLauncherPrivatePaths(options = {}) {
   const env = options.env || process.env;
   const platform = options.platform || process.platform;
   const configuredHome = String(env.BLUN_HOME || '').trim();
+  const stateDir = String(env.BLUN_STATE_DIR || '').trim();
+  if (stateDir) {
+    const paths = platform === 'win32' ? path.win32 : path.posix;
+    if (!paths.isAbsolute(stateDir) || (platform === 'win32' && !/^[A-Za-z]:[\\/]/u.test(stateDir))) {
+      throw new Error('BLUN_STATE_DIR must be an absolute local path.');
+    }
+    const blunHome = paths.resolve(stateDir);
+    const fsImpl = options.fsImpl || fs;
+    let ancestor = blunHome;
+    for (;;) {
+      try {
+        const stat = fsImpl.lstatSync(ancestor);
+        const realpath = fsImpl.realpathSync.native || fsImpl.realpathSync;
+        const canonical = realpath(ancestor);
+        const normalize = platform === 'win32' ? normalizeWindowsPath : paths.normalize;
+        if (!stat.isDirectory() || stat.isSymbolicLink() || normalize(canonical) !== normalize(ancestor)) {
+          throw new Error('BLUN_STATE_DIR must not traverse a symbolic link or junction.');
+        }
+        break;
+      } catch (error) {
+        if (error.code !== 'ENOENT') throw error;
+        const parent = paths.dirname(ancestor);
+        if (parent === ancestor) throw error;
+        ancestor = parent;
+      }
+    }
+    return { blunHome, userHome: (options.homedir || os.homedir)() };
+  }
   if (platform !== 'win32') {
     const userHome = (options.homedir || os.homedir)();
     return {
@@ -102,13 +131,14 @@ function shouldDetachProtectedCore(options = {}) {
 }
 
 function spawnProtectedCore(args, env, cwd) {
+  const terminalOwner = process.platform === 'win32' && process.stdin.isTTY === true;
   const child = spawn(
     process.execPath,
     [path.join(PKG, 'bin', 'core-bootstrap.js'), ...args],
     {
       cwd,
       detached: shouldDetachProtectedCore(),
-      env,
+      env: { ...env, BLUN_TERMINAL_OWNER: terminalOwner ? '1' : '0' },
       stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
       windowsHide: true,
     },
@@ -146,6 +176,7 @@ function spawnProtectedCore(args, env, cwd) {
   child.on('message', (message) => {
     if (message?.type !== CORE_LOADED_MESSAGE) return;
     settleLoaded(true);
+    if (terminalOwner) return;
     try {
       child.disconnect();
     } catch {}
@@ -367,6 +398,22 @@ async function runLauncher(options = {}) {
       return;
     }
 
+    if (isReadOnlyInspectionRequest(ARGS)) {
+      const compatibilityError = unsupportedNodeMessage(process.versions.node, process.platform);
+      if (compatibilityError !== null) {
+        process.stderr.write(`${compatibilityError}\n`);
+        process.exitCode = 1;
+        return;
+      }
+      const blunDir = resolveLauncherPrivatePaths().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;
+      process.exitCode = await runInformationalCore(ARGS, env, callerCwd, releaseNotice);
+      return;
+    }
+
     let privatePaths;
     const getPrivatePaths = () => {
       privatePaths ||= resolveLauncherPrivatePaths();
@@ -451,13 +498,31 @@ 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');
-      },
-    });
+    const nativeOwner = new AbortController();
+    let nativeStopSignal;
+    const nativeSignals = new Map();
+    for (const signal of ['SIGHUP', 'SIGINT', 'SIGTERM']) {
+      const handler = () => { nativeStopSignal = signal; nativeOwner.abort(); };
+      nativeSignals.set(signal, handler);
+      process.once(signal, handler);
+    }
+    let nativeModules;
+    try {
+      nativeModules = await repairConfiguredNativeModules({
+        blunDir,
+        callerCwd,
+        signal: nativeOwner.signal,
+        onRepairStart() {
+          process.stdout.write('BLUN richtet native Node.js-Module fuer die neue Laufzeit ein.\n');
+        },
+      });
+    } catch (error) {
+      if (!nativeOwner.signal.aborted) throw error;
+      process.exitCode = nativeStopSignal === 'SIGINT' ? 130 : nativeStopSignal === 'SIGHUP' ? 129 : 143;
+      return;
+    } finally {
+      for (const [signal, handler] of nativeSignals) process.removeListener(signal, handler);
+    }
     if (nativeModules.repaired.length > 0) {
       process.stdout.write('Native Node.js-Module sind wieder einsatzbereit.\n');
     }
@@ -465,6 +530,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;
     process.exitCode = await superviseProtectedCore(
       ARGS,
       env,

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 };