blun-king-cli 9.1.589 → 9.1.595

package/bin/windows-node-crash-dump.cjs

@@ -0,0 +1,289 @@
+'use strict';
+
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+const { ensurePrivateDirectory } = require('./private-paths');
+const { recordRuntimeExit } = require('./runtime-exit-ledger.cjs');
+
+const WER_DUMP_COUNT = 3;
+const WER_DUMP_TYPE = 1;
+const WER_REGISTRY_KEY = 'HKLM\\SOFTWARE\\Microsoft\\Windows\\Windows Error Reporting\\LocalDumps\\node.exe';
+const MAX_NODE_REPORTS = 3;
+const LEGACY_REPORT_PATTERN = /^blun-node\.[1-9]\d*\.[a-f0-9]{32}\.report\.json$/u;
+const REG_OPTIONS = Object.freeze({ encoding: 'utf8', shell: false, windowsHide: true, timeout: 3000, maxBuffer: 65536 });
+
+function windowsRegistryCommand(options) {
+  const env = options.env || process.env;
+  const systemRoot = env.SystemRoot || env.SYSTEMROOT || env.WINDIR || env.windir;
+  if (typeof systemRoot !== 'string' || !/^[a-z]:\\/iu.test(systemRoot)
+    || path.win32.normalize(systemRoot) !== systemRoot || systemRoot.slice(2).includes(':')
+    || /[\u0000-\u001F<>"|?*/]/u.test(systemRoot)
+    || systemRoot.slice(3).split('\\').some(part => !part || /[. ]$/u.test(part))) {
+    throw new Error('invalid-system-directory');
+  }
+  const directory = path.win32.join(systemRoot, 'System32');
+  return { executable: path.win32.join(directory, 'reg.exe'),
+    options: { ...REG_OPTIONS, cwd: directory, env: { SystemRoot: systemRoot, WINDIR: systemRoot } } };
+}
+
+function windowsWerCrashDumpPlan(options = {}) {
+  const pathImpl = (options.platform || process.platform) === 'win32' ? path.win32 : path;
+  if (typeof options.homeDir !== 'string' || !pathImpl.isAbsolute(options.homeDir)
+    || /[\r\n\0]/u.test(options.homeDir)) throw new Error('invalid-home-directory');
+  const dumpFolder = pathImpl.join(options.homeDir, 'diagnostics', 'crash-dumps');
+  return { dumpFolder, registryKey: WER_REGISTRY_KEY,
+    values: { DumpFolder: dumpFolder, DumpCount: WER_DUMP_COUNT, DumpType: WER_DUMP_TYPE } };
+}
+
+function configureWindowsWerCrashDumps(options = {}) {
+  if ((options.platform || process.platform) !== 'win32') return { configured: false, reason: 'not-windows' };
+  if (options.confirmSystemWide !== true) return { configured: false, reason: 'explicit-system-wide-consent-required' };
+  let command;
+  try { command = windowsRegistryCommand(options); }
+  catch { return { configured: false, reason: 'system-directory-unavailable' }; }
+  let plan;
+  try {
+    plan = windowsWerCrashDumpPlan({ homeDir: options.homeDir, platform: 'win32' });
+    (options.prepareDirectory || ensurePrivateDirectory)(plan.dumpFolder);
+  } catch { return { configured: false, reason: 'report-directory-unavailable' }; }
+  const execute = options.spawnSync || spawnSync;
+  const appliedValues = [];
+  for (const [name, type, value] of [
+    ['DumpFolder', 'REG_EXPAND_SZ', plan.dumpFolder],
+    ['DumpCount', 'REG_DWORD', String(WER_DUMP_COUNT)],
+    ['DumpType', 'REG_DWORD', String(WER_DUMP_TYPE)],
+  ]) {
+    let result;
+    try { result = execute(command.executable, ['ADD', plan.registryKey, '/v', name, '/t', type, '/d', value, '/f'], command.options); }
+    catch { result = { status: 1 }; }
+    if (result.error || result.status !== 0) {
+      return { configured: false, reason: 'registry-write-failed', appliedValues, failedValue: name, plan };
+    }
+    appliedValues.push(name);
+  }
+  return { configured: true, appliedValues, plan };
+}
+
+function queryWindowsWerCrashDumps(options = {}) {
+  if ((options.platform || process.platform) !== 'win32') return { configured: false, reason: 'not-windows' };
+  let plan;
+  let result;
+  try {
+    const command = windowsRegistryCommand(options);
+    plan = windowsWerCrashDumpPlan({ homeDir: options.homeDir, platform: 'win32' });
+    result = (options.spawnSync || spawnSync)(command.executable, ['QUERY', plan.registryKey], command.options);
+  } catch { return { configured: false, reason: 'registry-query-failed' }; }
+  if (result.error || result.status !== 0) return { configured: false, reason: 'registry-query-failed', plan };
+  const values = new Map();
+  for (const line of String(result.stdout || '').split(/\r?\n/u)) {
+    const match = /^\s+(DumpFolder|DumpCount|DumpType)\s+(REG_EXPAND_SZ|REG_DWORD)\s+(.+?)\s*$/iu.exec(line);
+    if (match) {
+      const key = match[1].toLowerCase();
+      if (values.has(key)) return { configured: false, reason: 'registry-values-mismatch', plan };
+      values.set(key, [match[2].toUpperCase(), match[3]]);
+    }
+  }
+  const [folderType, folder] = values.get('dumpfolder') || [];
+  const [countType, count] = values.get('dumpcount') || [];
+  const [dumpType, type] = values.get('dumptype') || [];
+  const configured = folderType === 'REG_EXPAND_SZ'
+    && path.win32.normalize(folder).toLowerCase() === path.win32.normalize(plan.dumpFolder).toLowerCase()
+    && countType === 'REG_DWORD' && /^0x0*3$/iu.test(count)
+    && dumpType === 'REG_DWORD' && /^0x0*1$/iu.test(type);
+  return { configured, reason: configured ? undefined : 'registry-values-mismatch', plan };
+}
+
+function reportFailure(code) {
+  return Object.assign(new Error(code), { reportFailure: code });
+}
+
+function sameEntry(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+
+function reportIdentity(file) {
+  try {
+    const stat = fs.lstatSync(file, { bigint: true });
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1n) throw reportFailure('unsafe-report-file');
+    return stat;
+  } catch (error) {
+    if (error.code === 'ENOENT') return undefined;
+    throw error;
+  }
+}
+
+function reserveReportSlot(directory, pid) {
+  const identity = fs.lstatSync(directory, { bigint: true });
+  const verifyDirectory = () => {
+    const current = fs.lstatSync(directory, { bigint: true });
+    if (!current.isDirectory() || current.isSymbolicLink() || !sameEntry(current, identity)) {
+      throw reportFailure('unsafe-report-directory');
+    }
+  };
+  verifyDirectory();
+  const entries = fs.opendirSync(directory);
+  try {
+    let count = 0;
+    for (let entry = entries.readSync(); entry; entry = entries.readSync()) {
+      if (++count > 1024) throw reportFailure('report-directory-too-large');
+      if (LEGACY_REPORT_PATTERN.test(entry.name)) throw reportFailure('legacy-reports-require-cleanup');
+    }
+  } finally { entries.closeSync(); }
+
+  const slots = Array.from({ length: MAX_NODE_REPORTS }, (_, index) => {
+    const filename = `blun-node.slot-${index + 1}.report.json`;
+    return { filename, lock: path.join(directory, `blun-node.slot-${index + 1}.lock`),
+      previous: reportIdentity(path.join(directory, filename)) };
+  }).toSorted((left, right) => {
+    const a = left.previous?.mtimeNs ?? -1n;
+    const b = right.previous?.mtimeNs ?? -1n;
+    return a < b ? -1 : a > b ? 1 : 0;
+  });
+  for (const slot of slots) {
+    verifyDirectory();
+    let descriptor;
+    try { descriptor = fs.openSync(slot.lock, 'wx', 0o600); }
+    catch (error) { if (error.code === 'EEXIST') continue; throw error; }
+    let lockIdentity;
+    let closed = false;
+    const release = () => {
+      if (closed) return;
+      closed = true;
+      try {
+        verifyDirectory();
+        const current = reportIdentity(slot.lock);
+        if (lockIdentity && current && sameEntry(current, lockIdentity)
+          && sameEntry(fs.fstatSync(descriptor, { bigint: true }), lockIdentity)) fs.unlinkSync(slot.lock);
+      } catch {} finally { try { fs.closeSync(descriptor); } catch {} }
+    };
+    try {
+      lockIdentity = fs.fstatSync(descriptor, { bigint: true });
+      if (!lockIdentity.isFile() || lockIdentity.nlink !== 1n) throw reportFailure('unsafe-report-reservation');
+      fs.writeFileSync(descriptor, `${JSON.stringify({ schemaVersion: 1, pid })}\n`);
+      verifyDirectory();
+      const reportPath = path.join(directory, slot.filename);
+      const previous = reportIdentity(reportPath);
+      return { filename: slot.filename, release,
+        verify() {
+          verifyDirectory();
+          const owner = reportIdentity(slot.lock);
+          const current = reportIdentity(reportPath);
+          if (!owner || !sameEntry(owner, lockIdentity)
+            || (previous ? !current || !sameEntry(previous, current)
+              || previous.size !== current.size || previous.mtimeNs !== current.mtimeNs : current !== undefined)) {
+            throw reportFailure('report-file-changed');
+          }
+        } };
+    } catch (error) { release(); throw error; }
+  }
+  // Abrupt native exits may leave reservations behind. Never guess that an
+  // owner is dead: capacity exhaustion disables detail reports, not startup.
+  throw reportFailure('report-capacity-unavailable');
+}
+
+function installWindowsNodeCrashDump(options = {}) {
+  if ((options.platform || process.platform) !== 'win32') {
+    return { enabled: false, detailedReportsEnabled: false, reason: 'not-windows', dispose() {} };
+  }
+  const processObject = options.processObject || process;
+  const report = options.report || processObject.report;
+  const homeDir = options.homeDir || processObject.env.BLUN_HOME;
+  const env = options.env || processObject.env;
+  const recordExit = options.recordExit || recordRuntimeExit;
+  const requested = env.BLUN_NODE_CRASH_REPORTS === '1';
+  let detailedReportsEnabled = false;
+  let dumpFolder;
+  let reason;
+  let previous;
+  let assigned;
+  let filename;
+  let reservation;
+  const restore = () => {
+    if (!previous) return;
+    for (const key of Object.keys(previous)) {
+      try { if (report[key] === assigned[key]) report[key] = previous[key]; } catch {}
+    }
+  };
+  const releaseReservation = () => {
+    try {
+      if (!assigned || report.directory !== dumpFolder || report.filename !== filename
+        || !(report.reportOnFatalError || report.reportOnUncaughtException || report.reportOnSignal)) reservation?.release();
+    } catch {}
+  };
+  if (requested) {
+    if (!report || typeof report.writeReport !== 'function' || !('excludeEnv' in report)
+      || !('excludeNetwork' in report)) reason = 'report-unavailable';
+    else {
+      try {
+        if (typeof homeDir !== 'string' || !path.isAbsolute(homeDir)) throw new Error('invalid-home-directory');
+        dumpFolder = path.join(homeDir, 'diagnostics', 'crash-dumps');
+        (options.prepareDirectory || ensurePrivateDirectory)(dumpFolder);
+        reservation = reserveReportSlot(dumpFolder, processObject.pid);
+        filename = reservation.filename;
+        assigned = { directory: dumpFolder, filename, excludeEnv: true, excludeNetwork: true,
+          reportOnSignal: false, reportOnUncaughtException: false, reportOnFatalError: true };
+        previous = Object.fromEntries(Object.keys(assigned).map(key => [key, report[key]]));
+        for (const [key, value] of Object.entries(assigned)) {
+          report[key] = value;
+          if (report[key] !== value) throw new Error('report-setting-rejected');
+        }
+        detailedReportsEnabled = true;
+      } catch (error) {
+        restore();
+        releaseReservation();
+        reason = error.reportFailure || 'report-directory-unavailable';
+      }
+    }
+  }
+  let attempted = false;
+  let disposed = false;
+  const write = (error, origin) => {
+    if (disposed || attempted) return null;
+    attempted = true;
+    const kind = origin === 'bootstrap-failure' ? origin
+      : origin === 'unhandledRejection' ? 'unhandled-rejection' : 'uncaught-exception';
+    try { recordExit({ homeDir, source: 'bootstrap', kind, error, pid: processObject.pid,
+      ppid: processObject.ppid, phase: kind === 'bootstrap-failure' ? 'startup' : 'runtime' }); } catch {}
+    if (!detailedReportsEnabled) return null;
+    try {
+      if (report.directory !== dumpFolder || report.filename !== filename
+        || report.excludeEnv !== true || report.excludeNetwork !== true) return null;
+      reservation.verify();
+      report.writeReport(filename, error instanceof Error ? error : new Error(String(error)));
+      return path.join(dumpFolder, filename);
+    } catch { return null; }
+  };
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    try { processObject.removeListener('uncaughtExceptionMonitor', write); } catch {}
+    try { processObject.removeListener('exit', dispose); } catch {}
+    restore();
+    releaseReservation();
+  };
+  try {
+    processObject.on('uncaughtExceptionMonitor', write);
+    processObject.once('exit', dispose);
+  } catch {
+    dispose();
+    return { enabled: false, detailedReportsEnabled: false, reason: 'observer-unavailable', write, dispose };
+  }
+  return { enabled: true, detailedReportsEnabled, dumpFolder, reason, write, dispose };
+}
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  let result;
+  if (args.length === 1 && args[0] === '--query-wer') result = queryWindowsWerCrashDumps({ homeDir: process.env.BLUN_HOME });
+  else if (args.length === 2 && args[0] === '--configure-wer' && args[1] === '--confirm-system-wide') {
+    result = configureWindowsWerCrashDumps({ homeDir: process.env.BLUN_HOME, confirmSystemWide: true });
+  } else {
+    result = { configured: false, reason: 'explicit-command-required' };
+  }
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  process.exitCode = result.configured ? 0 : 1;
+}
+
+module.exports = { WER_DUMP_COUNT, WER_DUMP_TYPE, MAX_NODE_REPORTS, configureWindowsWerCrashDumps,
+  installWindowsNodeCrashDump, queryWindowsWerCrashDumps, windowsWerCrashDumpPlan };