blun-king-cli 9.1.392 → 9.1.394

package/package.json

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

package/release-planned-removals.json

@@ -1,4 +1,15 @@
 {
-  "version": "9.1.69",
-  "removals": []
+  "version": "9.1.393",
+  "removals": [
+    {
+      "path": "package/bin/running-update.cjs",
+      "reason": "Background updater removed by owner decision; the visible manual startup picker remains.",
+      "decisionRef": "Telegram DM 5597, 5603, 5610, 5614 and 5619, 2026-08-28"
+    },
+    {
+      "path": "package/bin/running-update-preference.cjs",
+      "reason": "Background updater preference removed with the background updater; manual startup choices remain.",
+      "decisionRef": "Telegram DM 5597, 5603, 5610, 5614 and 5619, 2026-08-28"
+    }
+  ]
 }

package/bin/running-update-preference.cjs

@@ -1,68 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-const { randomUUID } = require('node:crypto');
-
-const { ensurePrivateDirectory, securePrivateFile, writePrivateFile } = require('./private-paths');
-
-const RUNNING_UPDATE_PREFERENCE_FILE = 'running-update.json';
-const RUNNING_UPDATE_MODES = Object.freeze({
-  MANUAL: 'manual',
-  RESUME: 'resume',
-  NEW: 'new',
-  OFF: 'off',
-});
-const DEFAULT_RUNNING_UPDATE_MODE = RUNNING_UPDATE_MODES.RESUME;
-const VALID_MODES = new Set(Object.values(RUNNING_UPDATE_MODES));
-
-function preferencePath(profileHome) {
-  return path.join(path.resolve(profileHome), RUNNING_UPDATE_PREFERENCE_FILE);
-}
-
-function normalizeRunningUpdateMode(value) {
-  return typeof value === 'string' && VALID_MODES.has(value)
-    ? value
-    : DEFAULT_RUNNING_UPDATE_MODE;
-}
-
-function readRunningUpdateMode(profileHome) {
-  try {
-    const filePath = preferencePath(profileHome);
-    const stat = fs.lstatSync(filePath);
-    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 16 * 1024) {
-      return DEFAULT_RUNNING_UPDATE_MODE;
-    }
-    const record = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    return normalizeRunningUpdateMode(record?.mode);
-  } catch {
-    return DEFAULT_RUNNING_UPDATE_MODE;
-  }
-}
-
-function writeRunningUpdateMode(profileHome, mode) {
-  if (!VALID_MODES.has(mode)) throw new Error('RUNNING_UPDATE_MODE_INVALID');
-  const home = path.resolve(profileHome);
-  const filePath = preferencePath(home);
-  const temporaryPath = path.join(home, `.${RUNNING_UPDATE_PREFERENCE_FILE}.${process.pid}.${randomUUID()}.tmp`);
-  ensurePrivateDirectory(home);
-  try {
-    writePrivateFile(temporaryPath, `${JSON.stringify({ mode })}\n`);
-    fs.renameSync(temporaryPath, filePath);
-    securePrivateFile(filePath);
-  } catch (error) {
-    fs.rmSync(temporaryPath, { force: true });
-    throw error;
-  }
-  return mode;
-}
-
-module.exports = {
-  DEFAULT_RUNNING_UPDATE_MODE,
-  RUNNING_UPDATE_MODES,
-  RUNNING_UPDATE_PREFERENCE_FILE,
-  normalizeRunningUpdateMode,
-  preferencePath,
-  readRunningUpdateMode,
-  writeRunningUpdateMode,
-};

package/bin/running-update.cjs

@@ -1,588 +0,0 @@
-'use strict';
-
-const { createHash, randomUUID } = require('node:crypto');
-const fs = require('node:fs');
-const https = require('node:https');
-const path = require('node:path');
-const { spawn } = require('node:child_process');
-
-const { compareSemver, requestTrustedJson } = require('./update-notice');
-const { tryAcquireUpdateLease } = require('./update-lease');
-const { ensurePrivateDirectory, securePrivateFile, writePrivateFile } = require('./private-paths');
-
-const PACKAGE_NAME = 'blun-king-cli';
-const MANIFEST_URL = 'https://chat.blun.ai/blun-code-version.json';
-const REGISTRY_URL = 'https://registry.npmjs.org/blun-king-cli';
-const ACTIVE_RUNTIME_FILE = 'active-runtime.json';
-const PENDING_RUNTIME_FILE = 'pending-runtime.json';
-const RUNNING_UPDATE_HANDOFF_EXIT_CODE = 76;
-const RUNNING_UPDATE_HANDOFF_ACK_MESSAGE = 'blun-running-update-handoff-ack';
-const RUNNING_UPDATE_PREPARED_MESSAGE = 'blun-running-update-prepared';
-const RUNNING_UPDATE_HANDOFF_MESSAGE = 'blun-running-update-handoff';
-const RUNNING_UPDATE_MODE_MESSAGE = 'blun-running-update-mode';
-const RUNTIME_READY_MESSAGE = 'blun-runtime-session-ready';
-const RUNTIME_EXIT_INTENT_MESSAGE = 'blun-runtime-exit-intent';
-const MAX_TARBALL_BYTES = 128 * 1024 * 1024;
-const AUTO_UPDATE_SETTLE_MS = 0;
-const DEFAULT_RETAINED_RELEASE_VERSIONS = 3;
-
-function ownData(value, key) {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
-  const descriptor = Object.getOwnPropertyDescriptor(value, key);
-  return descriptor && Object.hasOwn(descriptor, 'value') ? descriptor.value : undefined;
-}
-
-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;
-  try {
-    return Buffer.from(match[1], 'base64').length === 64;
-  } catch {
-    return false;
-  }
-}
-
-function selectRunningUpdateTarget(currentVersion, manifest, options = {}) {
-  const name = ownData(manifest, 'name');
-  const version = ownData(manifest, 'latest');
-  const integrity = ownData(manifest, 'integrity');
-  const releasedAt = ownData(manifest, 'releasedAt');
-  const releasedAtMs = Date.parse(releasedAt);
-  const now = options.now || Date.now;
-  if (name !== PACKAGE_NAME
-    || typeof version !== 'string'
-    || compareSemver(currentVersion, version) !== -1
-    || !validIntegrity(integrity)
-    || typeof releasedAt !== 'string'
-    || !Number.isFinite(releasedAtMs)
-    || now() - releasedAtMs < AUTO_UPDATE_SETTLE_MS) {
-    return null;
-  }
-  return Object.freeze({ version, integrity });
-}
-
-function releaseVersionEntries(sharedHome) {
-  const root = releasesRoot(sharedHome);
-  let entries;
-  try {
-    entries = fs.readdirSync(root, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const releases = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
-    const version = entry.name;
-    try {
-      if (compareSemver('0.0.0', version) !== -1) continue;
-    } catch {
-      continue;
-    }
-    const versionRoot = path.join(root, version);
-    const digestEntries = fs.readdirSync(versionRoot, { withFileTypes: true });
-    const packageRoots = [];
-    let valid = digestEntries.length > 0;
-    for (const digestEntry of digestEntries) {
-      if (!digestEntry.isDirectory() || digestEntry.isSymbolicLink()) {
-        valid = false;
-        break;
-      }
-      const packageRoot = path.join(versionRoot, digestEntry.name, 'node_modules', PACKAGE_NAME);
-      if (!verifyRuntimePackage(packageRoot, version, { allowedRoot: versionRoot })) {
-        valid = false;
-        break;
-      }
-      packageRoots.push(path.resolve(packageRoot));
-    }
-    if (valid && packageRoots.length > 0) releases.push({ packageRoots, version, versionRoot });
-  }
-  releases.sort((left, right) => compareSemver(right.version, left.version));
-  return releases;
-}
-
-async function pruneRunningUpdateReleases(sharedHome, options = {}) {
-  const keepVersions = Number.isInteger(options.keepVersions) && options.keepVersions >= 1
-    ? options.keepVersions
-    : DEFAULT_RETAINED_RELEASE_VERSIONS;
-  const activePackageRoot = typeof options.activePackageRoot === 'string'
-    ? path.resolve(options.activePackageRoot)
-    : readActiveRuntime(sharedHome)?.packageRoot;
-  const acquire = options.tryAcquireLease
-    || (({ packageRoot }) => tryAcquireUpdateLease({ packageRoot, role: 'install' }));
-  const releases = releaseVersionEntries(sharedHome);
-  const kept = new Set(releases.slice(0, keepVersions).map((release) => release.version));
-  for (const release of releases) {
-    if (release.packageRoots.includes(activePackageRoot)) kept.add(release.version);
-  }
-  const removedVersions = [];
-  const busyVersions = [];
-  for (const release of releases) {
-    if (kept.has(release.version)) continue;
-    const leases = [];
-    let blocked = false;
-    try {
-      for (const packageRoot of release.packageRoots) {
-        const result = await acquire({ packageRoot });
-        if (!result?.acquired || !result.lease) {
-          blocked = true;
-          break;
-        }
-        leases.push(result.lease);
-      }
-      if (blocked) {
-        busyVersions.push(release.version);
-        continue;
-      }
-      for (const lease of leases) lease.assertOwned();
-      fs.rmSync(release.versionRoot, { recursive: true, force: true });
-      removedVersions.push(release.version);
-    } finally {
-      await Promise.allSettled(leases.map((lease) => lease.release()));
-    }
-  }
-  return Object.freeze({
-    busyVersions: Object.freeze(busyVersions),
-    removedVersions: Object.freeze(removedVersions),
-  });
-}
-
-function isSafeRuntimeBoundary(state) {
-  return state?.isShuttingDown === false
-    && state.streamingPhase === 'idle'
-    && state.isCompacting === false
-    && (state.queuedMessages === 0 || state.queuedMessagesDurable === true)
-    && state.activeToolCalls === 0
-    && state.shellCommands === 0
-    && state.queueCommandRunning === false;
-}
-
-function resumeArgsForHandoff(args, sessionId) {
-  const filtered = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === '-c' || arg === '--continue') continue;
-    if (arg === '-r' || arg === '--resume' || arg === '--session') {
-      index += 1;
-      continue;
-    }
-    if (/^(?:--resume|--session)=/u.test(arg)) continue;
-    filtered.push(arg);
-  }
-  return [...filtered, '--resume', sessionId];
-}
-
-function handoffArgsForMode(args, mode, sessionId) {
-  const withoutSession = resumeArgsForHandoff(args, sessionId).slice(0, -2);
-  return mode === 'new' ? withoutSession : [...withoutSession, '--resume', sessionId];
-}
-
-async function handoffRuntime(options) {
-  const handoffArgs = handoffArgsForMode(options.args, options.mode || 'resume', options.sessionId);
-  if (!await options.probeTarget(options.target)) {
-    return { kind: 'probe-failed', runtime: options.previous };
-  }
-  await options.stopOld();
-  const targetCore = await options.startCore({
-    packageRoot: options.target.packageRoot,
-    args: handoffArgs,
-  });
-  if (targetCore.ready === true) {
-    await options.activateTarget(options.target);
-    return { kind: 'activated', runtime: options.target, core: targetCore };
-  }
-  const fallbackCore = await options.startCore({
-    packageRoot: options.previous.packageRoot,
-    args: handoffArgs,
-  });
-  return { kind: 'rolled-back', runtime: options.previous, core: fallbackCore };
-}
-
-function releasesRoot(sharedHome) {
-  return path.join(path.resolve(sharedHome), 'updates', 'releases');
-}
-
-function activeRuntimePath(sharedHome) {
-  return path.join(path.resolve(sharedHome), 'updates', ACTIVE_RUNTIME_FILE);
-}
-
-function pendingRuntimePath(sharedHome) {
-  return path.join(path.resolve(sharedHome), 'updates', PENDING_RUNTIME_FILE);
-}
-
-function pathWithin(root, candidate) {
-  const relative = path.relative(root, candidate);
-  return relative === '' || (relative !== '..'
-    && !relative.startsWith(`..${path.sep}`)
-    && !path.isAbsolute(relative));
-}
-
-function verifyRuntimePackage(packageRoot, version, options = {}) {
-  try {
-    const root = path.resolve(packageRoot);
-    const allowedRoot = path.resolve(options.allowedRoot || releasesRoot(options.sharedHome));
-    if (!pathWithin(allowedRoot, root)) return false;
-    const manifestPath = path.join(root, 'package.json');
-    const bundlePath = path.join(root, 'blun.mjs');
-    const bootstrapPath = path.join(root, 'bin', 'core-bootstrap.js');
-    for (const filePath of [manifestPath, bundlePath, bootstrapPath]) {
-      const stat = fs.lstatSync(filePath);
-      if (!stat.isFile() || stat.isSymbolicLink()) return false;
-    }
-    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-    return ownData(manifest, 'name') === PACKAGE_NAME && ownData(manifest, 'version') === version;
-  } catch {
-    return false;
-  }
-}
-
-function readRuntimeRecord(sharedHome, filePath) {
-  try {
-    const stat = fs.lstatSync(filePath);
-    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 16 * 1024) return null;
-    const record = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    const version = ownData(record, 'version');
-    const packageRoot = ownData(record, 'packageRoot');
-    const integrity = ownData(record, 'integrity');
-    if (typeof version !== 'string'
-      || typeof packageRoot !== 'string'
-      || !path.isAbsolute(packageRoot)
-      || !validIntegrity(integrity)
-      || !verifyRuntimePackage(packageRoot, version, { sharedHome })) {
-      return null;
-    }
-    const mode = ownData(record, 'mode');
-    const sessionId = ownData(record, 'sessionId');
-    const cwd = ownData(record, 'cwd');
-    return Object.freeze({
-      version,
-      packageRoot: path.resolve(packageRoot),
-      integrity,
-      ...(mode === 'resume' || mode === 'new' ? { mode } : {}),
-      ...(typeof sessionId === 'string' && sessionId.length > 0 ? { sessionId } : {}),
-      ...(typeof cwd === 'string' && path.isAbsolute(cwd) ? { cwd: path.resolve(cwd) } : {}),
-    });
-  } catch {
-    return null;
-  }
-}
-
-function readActiveRuntime(sharedHome) {
-  return readRuntimeRecord(sharedHome, activeRuntimePath(sharedHome));
-}
-
-function readPendingRuntime(sharedHome) {
-  return readRuntimeRecord(sharedHome, pendingRuntimePath(sharedHome));
-}
-
-function writeRuntimeRecord(sharedHome, fileName, target, extra = {}) {
-  if (!verifyRuntimePackage(target.packageRoot, target.version, { sharedHome })
-    || !validIntegrity(target.integrity)) {
-    throw new Error('RUNNING_UPDATE_TARGET_INVALID');
-  }
-  const updateRoot = path.join(path.resolve(sharedHome), 'updates');
-  ensurePrivateDirectory(path.resolve(sharedHome));
-  ensurePrivateDirectory(updateRoot);
-  const filePath = path.join(updateRoot, fileName);
-  const temporaryPath = path.join(updateRoot, `.${fileName}.${process.pid}.${randomUUID()}.tmp`);
-  try {
-    writePrivateFile(temporaryPath, `${JSON.stringify({
-      version: target.version,
-      packageRoot: path.resolve(target.packageRoot),
-      integrity: target.integrity,
-      ...extra,
-    })}\n`);
-    fs.renameSync(temporaryPath, filePath);
-    securePrivateFile(filePath);
-  } catch (error) {
-    fs.rmSync(temporaryPath, { force: true });
-    throw error;
-  }
-}
-
-function activateRuntime(sharedHome, target) {
-  writeRuntimeRecord(sharedHome, ACTIVE_RUNTIME_FILE, target, {
-    activatedAt: new Date().toISOString(),
-  });
-}
-
-function stageRuntime(sharedHome, target, options = {}) {
-  const mode = options.mode === 'resume' || options.mode === 'new' ? options.mode : undefined;
-  const sessionId = typeof options.sessionId === 'string' && options.sessionId.length > 0
-    ? options.sessionId
-    : undefined;
-  const cwd = typeof options.cwd === 'string' && path.isAbsolute(options.cwd)
-    ? path.resolve(options.cwd)
-    : undefined;
-  writeRuntimeRecord(sharedHome, PENDING_RUNTIME_FILE, target, {
-    preparedAt: new Date((options.now || Date.now)()).toISOString(),
-    ...(mode === undefined ? {} : { mode }),
-    ...(sessionId === undefined ? {} : { sessionId }),
-    ...(cwd === undefined ? {} : { cwd }),
-  });
-}
-
-function clearRuntimeRecord(sharedHome, expected, readRecord, filePath) {
-  const runtime = readRecord(sharedHome);
-  if (runtime === null) return false;
-  if (expected !== undefined
-    && (runtime.version !== expected.version
-      || runtime.packageRoot !== path.resolve(expected.packageRoot))) {
-    return false;
-  }
-  fs.rmSync(filePath(sharedHome), { force: true });
-  return true;
-}
-
-function clearActiveRuntime(sharedHome, expected) {
-  return clearRuntimeRecord(sharedHome, expected, readActiveRuntime, activeRuntimePath);
-}
-
-function clearPendingRuntime(sharedHome, expected) {
-  return clearRuntimeRecord(sharedHome, expected, readPendingRuntime, pendingRuntimePath);
-}
-
-function restoreActiveRuntime(sharedHome, runtime) {
-  if (runtime === null || runtime === undefined) {
-    fs.rmSync(activeRuntimePath(sharedHome), { force: true });
-    return;
-  }
-  activateRuntime(sharedHome, runtime);
-}
-
-function recordRunningUpdateEvent(sharedHome, event, options = {}) {
-  if (typeof sharedHome !== 'string' || !path.isAbsolute(sharedHome)) return false;
-  const updateRoot = path.join(path.resolve(sharedHome), 'updates');
-  ensurePrivateDirectory(path.resolve(sharedHome));
-  ensurePrivateDirectory(updateRoot);
-  const filePath = path.join(updateRoot, 'handoff.jsonl');
-  fs.appendFileSync(filePath, `${JSON.stringify({
-    at: new Date((options.now || Date.now)()).toISOString(),
-    ...event,
-  })}\n`, { encoding: 'utf8', mode: 0o600 });
-  securePrivateFile(filePath);
-  return true;
-}
-
-function registryRelease(registry, version) {
-  const versions = ownData(registry, 'versions');
-  const entry = ownData(versions, version);
-  const dist = ownData(entry, 'dist');
-  const integrity = ownData(dist, 'integrity');
-  const tarball = ownData(dist, 'tarball');
-  if (!validIntegrity(integrity) || typeof tarball !== 'string') return null;
-  let url;
-  try {
-    url = new URL(tarball);
-  } catch {
-    return null;
-  }
-  if (url.protocol !== 'https:'
-    || url.hostname !== 'registry.npmjs.org'
-    || url.username !== ''
-    || url.password !== '') {
-    return null;
-  }
-  return { integrity, tarball: url.href };
-}
-
-function downloadTarball(url, destination, options = {}) {
-  const httpsImpl = options.httpsImpl || https;
-  return new Promise((resolve, reject) => {
-    const request = httpsImpl.get(url, {
-      headers: { 'user-agent': 'blun-king-running-update' },
-      timeout: options.timeoutMs || 30_000,
-    }, (response) => {
-      if (response.statusCode !== 200) {
-        response.resume();
-        reject(new Error(`RUNNING_UPDATE_DOWNLOAD_${String(response.statusCode)}`));
-        return;
-      }
-      let bytes = 0;
-      const handle = fs.openSync(destination, 'wx', 0o600);
-      let settled = false;
-      const fail = (error) => {
-        if (settled) return;
-        settled = true;
-        try { fs.closeSync(handle); } catch {}
-        fs.rmSync(destination, { force: true });
-        reject(error);
-      };
-      response.on('data', (chunk) => {
-        bytes += chunk.length;
-        if (bytes > MAX_TARBALL_BYTES) {
-          response.destroy(new Error('RUNNING_UPDATE_TARBALL_TOO_LARGE'));
-          return;
-        }
-        try {
-          fs.writeSync(handle, chunk);
-        } catch (error) {
-          response.destroy(error);
-        }
-      });
-      response.once('error', fail);
-      response.once('end', () => {
-        if (settled) return;
-        settled = true;
-        fs.fsyncSync(handle);
-        fs.closeSync(handle);
-        resolve();
-      });
-    });
-    request.once('timeout', () => request.destroy(new Error('RUNNING_UPDATE_DOWNLOAD_TIMEOUT')));
-    request.once('error', reject);
-  });
-}
-
-function resolveNpmCliPath(execPath = process.execPath) {
-  const executableDirectory = path.dirname(path.resolve(execPath));
-  const candidates = [
-    path.join(executableDirectory, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
-    path.resolve(executableDirectory, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
-    path.resolve(executableDirectory, '..', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
-    path.resolve(__dirname, '..', '..', 'npm', 'bin', 'npm-cli.js'),
-  ];
-  for (const candidate of candidates) {
-    try {
-      const resolved = fs.realpathSync(candidate);
-      if (fs.statSync(resolved).isFile() && path.basename(resolved) === 'npm-cli.js') return resolved;
-    } catch {}
-  }
-  throw new Error('TRUSTED_NPM_CLI_NOT_FOUND');
-}
-
-function runProcess(command, args, options = {}) {
-  return new Promise((resolve, reject) => {
-    const child = (options.spawnImpl || spawn)(command, args, {
-      cwd: options.cwd,
-      env: options.env,
-      stdio: options.stdio || 'ignore',
-      windowsHide: true,
-    });
-    child.once('error', reject);
-    child.once('exit', (code, signal) => {
-      if (code === 0) resolve();
-      else reject(new Error(`RUNNING_UPDATE_PROCESS_FAILED:${code ?? signal ?? 'unknown'}`));
-    });
-  });
-}
-
-async function defaultInstallTarball(tarballPath, installPrefix, options = {}) {
-  const npmCliPath = resolveNpmCliPath(options.execPath);
-  const env = {
-    ...process.env,
-    TEMP: installPrefix,
-    TMP: installPrefix,
-    TMPDIR: installPrefix,
-    npm_config_registry: 'https://registry.npmjs.org/',
-    npm_config_strict_ssl: 'true',
-  };
-  await runProcess(options.execPath || process.execPath, [
-    npmCliPath,
-    'install',
-    `--prefix=${installPrefix}`,
-    '--ignore-scripts=false',
-    '--package-lock=false',
-    '--audit=false',
-    '--fund=false',
-    tarballPath,
-  ], { cwd: installPrefix, env, spawnImpl: options.spawnImpl });
-}
-
-async function defaultProbeRuntime(packageRoot, options = {}) {
-  try {
-    await runProcess(options.execPath || process.execPath, ['--check', path.join(packageRoot, 'blun.mjs')], options);
-    await runProcess(options.execPath || process.execPath, ['--check', path.join(packageRoot, 'bin', 'core-bootstrap.js')], options);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function prepareRunningUpdate(options) {
-  if (String(options.env?.BLUN_NO_AUTO_UPDATE || '') === '1') return null;
-  const manifest = await (options.loadManifest
-    ? options.loadManifest()
-    : requestTrustedJson(MANIFEST_URL));
-  const target = selectRunningUpdateTarget(options.currentVersion, manifest, { now: options.now });
-  if (target === null) return null;
-  const registry = await (options.loadRegistry
-    ? options.loadRegistry()
-    : requestTrustedJson(REGISTRY_URL));
-  const release = registryRelease(registry, target.version);
-  if (release === null || release.integrity !== target.integrity) {
-    throw new Error('RUNNING_UPDATE_INTEGRITY_SOURCE_MISMATCH');
-  }
-  const digest = createHash('sha256').update(target.integrity).digest('hex').slice(0, 16);
-  const releaseDirectory = path.join(releasesRoot(options.sharedHome), target.version, digest);
-  const packageRoot = path.join(releaseDirectory, 'node_modules', PACKAGE_NAME);
-  if (verifyRuntimePackage(packageRoot, target.version, { sharedHome: options.sharedHome })) {
-    return Object.freeze({ ...target, packageRoot });
-  }
-
-  const updateRoot = path.join(path.resolve(options.sharedHome), 'updates');
-  const stagingRoot = path.join(updateRoot, 'staging');
-  ensurePrivateDirectory(path.resolve(options.sharedHome));
-  ensurePrivateDirectory(updateRoot);
-  ensurePrivateDirectory(stagingRoot);
-  const temporaryRoot = fs.mkdtempSync(path.join(stagingRoot, 'runtime-'));
-  ensurePrivateDirectory(temporaryRoot);
-  const tarballPath = path.join(temporaryRoot, `${PACKAGE_NAME}.tgz`);
-  const installPrefix = path.join(temporaryRoot, 'install');
-  ensurePrivateDirectory(installPrefix);
-  try {
-    await (options.downloadTarball || downloadTarball)(release.tarball, tarballPath);
-    const actualIntegrity = `sha512-${createHash('sha512').update(fs.readFileSync(tarballPath)).digest('base64')}`;
-    if (actualIntegrity !== target.integrity) throw new Error('RUNNING_UPDATE_TARBALL_INTEGRITY_FAILED');
-    await (options.installTarball || defaultInstallTarball)(tarballPath, installPrefix, options);
-    const installedRoot = path.join(installPrefix, 'node_modules', PACKAGE_NAME);
-    if (!verifyRuntimePackage(installedRoot, target.version, { allowedRoot: installPrefix })) {
-      throw new Error('RUNNING_UPDATE_PACKAGE_INVALID');
-    }
-    if (!await (options.probeRuntime || defaultProbeRuntime)(installedRoot, options)) {
-      throw new Error('RUNNING_UPDATE_PROBE_FAILED');
-    }
-    ensurePrivateDirectory(releasesRoot(options.sharedHome));
-    ensurePrivateDirectory(path.dirname(releaseDirectory));
-    if (fs.existsSync(releaseDirectory)) fs.rmSync(releaseDirectory, { recursive: true, force: true });
-    fs.renameSync(installPrefix, releaseDirectory);
-    if (!verifyRuntimePackage(packageRoot, target.version, { sharedHome: options.sharedHome })) {
-      throw new Error('RUNNING_UPDATE_ACTIVATION_PACKAGE_INVALID');
-    }
-    return Object.freeze({ ...target, packageRoot });
-  } finally {
-    fs.rmSync(temporaryRoot, { recursive: true, force: true });
-  }
-}
-
-module.exports = {
-  ACTIVE_RUNTIME_FILE,
-  PENDING_RUNTIME_FILE,
-  AUTO_UPDATE_SETTLE_MS,
-  RUNNING_UPDATE_HANDOFF_EXIT_CODE,
-  RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
-  RUNNING_UPDATE_HANDOFF_MESSAGE,
-  RUNNING_UPDATE_MODE_MESSAGE,
-  RUNNING_UPDATE_PREPARED_MESSAGE,
-  RUNTIME_EXIT_INTENT_MESSAGE,
-  RUNTIME_READY_MESSAGE,
-  activateRuntime,
-  activeRuntimePath,
-  clearActiveRuntime,
-  clearPendingRuntime,
-  defaultProbeRuntime,
-  handoffArgsForMode,
-  handoffRuntime,
-  isSafeRuntimeBoundary,
-  prepareRunningUpdate,
-  pruneRunningUpdateReleases,
-  recordRunningUpdateEvent,
-  readActiveRuntime,
-  readPendingRuntime,
-  restoreActiveRuntime,
-  resumeArgsForHandoff,
-  selectRunningUpdateTarget,
-  stageRuntime,
-  pendingRuntimePath,
-  verifyRuntimePackage,
-};