blun-king-cli 9.1.588 → 9.1.594

package/bin/update-notice.js

@@ -47,7 +47,7 @@ const SEMVER_PATTERN = new RegExp(
     + `(?:-(${SEMVER_IDENTIFIER}(?:\\.${SEMVER_IDENTIFIER})*))?`
     + '(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?$',
 );
-const MANIFEST_KEYS = Object.freeze([
+const LEGACY_MANIFEST_KEYS = Object.freeze([
   'install',
   'latest',
   'minSupported',
@@ -55,6 +55,29 @@ const MANIFEST_KEYS = Object.freeze([
   'notesUrl',
   'releasedAt',
 ]);
+const RELEASE_NOTES_MANIFEST_KEYS = Object.freeze([
+  'install', 'latest', 'minSupported', 'name', 'notesUrl', 'releaseNotes', 'releasedAt',
+]);
+const MANIFEST_KEYS = Object.freeze([
+  'install', 'integrity', 'latest', 'minSupported', 'name', 'notesUrl', 'releaseNotes', 'releasedAt',
+]);
+
+function parseReleaseNotes(value) {
+  if (!Array.isArray(value) || value.length > 8) return undefined;
+  const notes = [];
+  for (const note of value) {
+    if (!isBoundedText(note, 240)) return undefined;
+    notes.push(note);
+  }
+  return Object.freeze(notes);
+}
+
+function validIntegrity(value) {
+  if (typeof value !== 'string') return false;
+  const match = /^sha512-([A-Za-z0-9+/]+={0,2})$/u.exec(value);
+  if (!match) return false;
+  return Buffer.from(match[1], 'base64').length === 64;
+}
 const ENDPOINT_LIMITS = new Map([
   [REGISTRY_URL, 1024 * 1024],
   [FALLBACK_MANIFEST_URL, 64 * 1024],
@@ -195,8 +218,13 @@ function isIsoTimestamp(value) {
 }
 
 function parseFallbackManifest(value) {
-  const record = exactDataRecord(value, MANIFEST_KEYS);
+  const record = exactDataRecord(value, MANIFEST_KEYS)
+    || exactDataRecord(value, RELEASE_NOTES_MANIFEST_KEYS)
+    || exactDataRecord(value, LEGACY_MANIFEST_KEYS);
   const notesUrl = record ? canonicalOfficialNotesUrl(record.notesUrl) : undefined;
+  const releaseNotes = record && Object.hasOwn(record, 'releaseNotes')
+    ? parseReleaseNotes(record.releaseNotes)
+    : undefined;
   if (!record
     || record.name !== PACKAGE_NAME
     || !parseSemver(record.latest)
@@ -204,6 +232,8 @@ function parseFallbackManifest(value) {
     || compareSemver(record.minSupported, record.latest) === 1
     || !isIsoTimestamp(record.releasedAt)
     || !notesUrl
+    || (Object.hasOwn(record, 'integrity') && !validIntegrity(record.integrity))
+    || (Object.hasOwn(record, 'releaseNotes') && releaseNotes === undefined)
     || !isBoundedText(record.install, 256)) {
     return undefined;
   }
@@ -213,6 +243,8 @@ function parseFallbackManifest(value) {
     minSupported: record.minSupported,
     releasedAt: record.releasedAt,
     notesUrl,
+    ...(Object.hasOwn(record, 'integrity') ? { integrity: record.integrity } : {}),
+    ...(releaseNotes === undefined ? {} : { releaseNotes }),
     install: record.install,
   });
 }
@@ -245,7 +277,9 @@ function resolveEffectiveRelease(currentVersion, registryTags, fallbackManifest)
   if (compareSemver(version, currentVersion) <= 0) return undefined;
 
   if (validFallback && compareSemver(validFallback.latest, version) === 0) {
-    return { channel: 'stable', version, notesUrl: validFallback.notesUrl };
+    return { channel: 'stable', version, notesUrl: validFallback.notesUrl,
+      ...(validFallback.releaseNotes === undefined ? {} : { releaseNotes: validFallback.releaseNotes }),
+    };
   }
   return { channel: 'stable', version };
 }

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