blun-king-cli 9.0.0 → 9.0.1

package/bin/update-lease.js

@@ -0,0 +1,399 @@
+'use strict';
+
+const { createHash } = require('node:crypto');
+const fs = require('node:fs');
+const net = require('node:net');
+const os = require('node:os');
+const path = require('node:path');
+
+const LEASE_ADOPT_MESSAGE = 'blun-update-lease-adopted';
+const LEASE_CANCEL_MESSAGE = 'blun-update-lease-cancel';
+const LEASE_COMMIT_MESSAGE = 'blun-update-lease-commit';
+const LEASE_HANDOFF_MESSAGE = 'blun-update-lease-handoff';
+const LEASE_BUSY_MESSAGE = 'blun-update-lease-busy';
+const LEASE_UNAVAILABLE_MESSAGE = 'blun-update-lease-unavailable';
+const LEASE_PROTOCOL_VERSION = 'BLUN_UPDATE_LEASE_V3';
+const LEASE_PROBE_TIMEOUT_MS = 500;
+const MAX_POSIX_SOCKET_PATH_BYTES = 96;
+
+function canonicalPackageIdentity(packageRoot, options = {}) {
+  if (typeof packageRoot !== 'string' || packageRoot.trim().length === 0) {
+    throw new Error('UPDATE_PACKAGE_ROOT_REQUIRED');
+  }
+  const fsImpl = options.fsImpl || fs;
+  const platform = options.platform || process.platform;
+  const realpath = fsImpl.realpathSync.native || fsImpl.realpathSync;
+  let canonical = realpath(path.resolve(packageRoot));
+  if (!fsImpl.statSync(canonical).isDirectory()) throw new Error('INVALID_UPDATE_PACKAGE_ROOT');
+  canonical = canonical.replaceAll('\\', '/');
+  if (platform === 'win32') canonical = canonical.toLowerCase();
+  return canonical;
+}
+
+function deriveUpdateLeaseEndpoint(packageRoot, options = {}) {
+  const platform = options.platform || process.platform;
+  const role = options.role === 'install' ? 'install' : 'notice';
+  const identity = canonicalPackageIdentity(packageRoot, options);
+  const digest = createHash('sha256')
+    .update(`blun-update-v3\0${role}\0${identity}`)
+    .digest('hex');
+  const magic = `${LEASE_PROTOCOL_VERSION} ${digest}\n`;
+  if (platform === 'win32') {
+    return Object.freeze({
+      magic,
+      path: `\\\\.\\pipe\\blun-update-v3-${digest.slice(0, 32)}`,
+      platform,
+    });
+  }
+
+  const uid = options.uid ?? (typeof process.getuid === 'function' ? process.getuid() : undefined);
+  const directoryName = `blun-update-${uid ?? digest.slice(0, 12)}`;
+  const requestedRoot = String(options.socketDirectory || options.tempDir || os.tmpdir())
+    .replaceAll('\\', '/');
+  let directory = options.socketDirectory
+    ? requestedRoot
+    : path.posix.join(requestedRoot, directoryName);
+  let socketPath = path.posix.join(directory, `lease-${digest.slice(0, 24)}.sock`);
+  if (Buffer.byteLength(socketPath, 'utf8') > MAX_POSIX_SOCKET_PATH_BYTES) {
+    directory = path.posix.join('/tmp', directoryName);
+    socketPath = path.posix.join(directory, `lease-${digest.slice(0, 24)}.sock`);
+  }
+  if (Buffer.byteLength(socketPath, 'utf8') > MAX_POSIX_SOCKET_PATH_BYTES) {
+    throw new Error('UPDATE_LEASE_SOCKET_PATH_TOO_LONG');
+  }
+  return Object.freeze({ directory, magic, path: socketPath, platform });
+}
+
+function closeServer(server) {
+  return new Promise((resolve) => {
+    if (!server.listening) {
+      resolve();
+      return;
+    }
+    try {
+      server.close(() => resolve());
+    } catch {
+      resolve();
+    }
+  });
+}
+
+function ensurePrivateSocketDirectory(endpoint, options = {}) {
+  if (endpoint.platform === 'win32') return;
+  const fsImpl = options.fsImpl || fs;
+  fsImpl.mkdirSync(endpoint.directory, { recursive: true, mode: 0o700 });
+  const stat = fsImpl.lstatSync(endpoint.directory);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error('INVALID_UPDATE_LEASE_DIRECTORY');
+  }
+  if (typeof process.getuid === 'function'
+    && Number.isInteger(stat.uid)
+    && stat.uid !== process.getuid()) {
+    throw new Error('INVALID_UPDATE_LEASE_DIRECTORY_OWNER');
+  }
+  fsImpl.chmodSync(endpoint.directory, 0o700);
+}
+
+function listenForLease(endpoint, options = {}) {
+  const netImpl = options.netImpl || net;
+  return new Promise((resolve, reject) => {
+    const server = netImpl.createServer((socket) => {
+      socket.on('error', () => {});
+      socket.end(endpoint.magic);
+    });
+    const onError = (error) => {
+      server.removeListener('error', onError);
+      reject(error);
+    };
+    server.once('error', onError);
+    server.listen({ path: endpoint.path, exclusive: true }, () => {
+      server.removeListener('error', onError);
+      resolve(server);
+    });
+  });
+}
+
+function probeExistingLease(endpoint, options = {}) {
+  const netImpl = options.netImpl || net;
+  const timeoutMs = options.probeTimeoutMs || LEASE_PROBE_TIMEOUT_MS;
+  return new Promise((resolve) => {
+    let settled = false;
+    let received = '';
+    let socket;
+    const finish = (state, error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        socket?.destroy();
+      } catch {}
+      // oxlint-disable-next-line promise/no-multiple-resolved -- settled is the idempotence guard.
+      resolve({ error, state });
+    };
+    const timer = setTimeout(() => finish('foreign'), timeoutMs);
+    timer.unref?.();
+    try {
+      socket = netImpl.createConnection({ path: endpoint.path });
+      socket.setEncoding?.('utf8');
+      socket.on('data', (chunk) => {
+        received += String(chunk);
+        if (Buffer.byteLength(received, 'utf8') > Buffer.byteLength(endpoint.magic, 'utf8')) {
+          finish('foreign');
+        }
+      });
+      socket.once('end', () => finish(received === endpoint.magic ? 'owner' : 'foreign'));
+      socket.once('error', (error) => {
+        const stale = error?.code === 'ECONNREFUSED' || error?.code === 'ENOENT';
+        finish(stale ? 'stale' : 'foreign', error);
+      });
+      socket.once('close', () => {
+        if (!settled) finish(received === endpoint.magic ? 'owner' : 'foreign');
+      });
+    } catch (error) {
+      const stale = error?.code === 'ECONNREFUSED' || error?.code === 'ENOENT';
+      finish(stale ? 'stale' : 'foreign', error);
+    }
+  });
+}
+
+function observeSocketPath(endpoint, options = {}) {
+  if (endpoint.platform === 'win32') return { state: 'not_applicable' };
+  const fsImpl = options.fsImpl || fs;
+  try {
+    const stat = fsImpl.lstatSync(endpoint.path);
+    if (!stat.isSocket() || stat.isSymbolicLink()) return { state: 'unsafe' };
+    return { dev: stat.dev, ino: stat.ino, state: 'socket' };
+  } catch (error) {
+    return error?.code === 'ENOENT' ? { state: 'missing' } : { state: 'unsafe' };
+  }
+}
+
+function removeObservedStaleSocket(endpoint, observed, options = {}) {
+  if (endpoint.platform === 'win32') return false;
+  const fsImpl = options.fsImpl || fs;
+  try {
+    const stat = fsImpl.lstatSync(endpoint.path);
+    if (observed.state !== 'socket'
+      || !stat.isSocket()
+      || stat.isSymbolicLink()
+      || stat.dev !== observed.dev
+      || stat.ino !== observed.ino) {
+      return false;
+    }
+    fsImpl.unlinkSync(endpoint.path);
+    return true;
+  } catch (error) {
+    return error?.code === 'ENOENT' && observed.state === 'missing';
+  }
+}
+
+function recordSocketIdentity(endpoint, options = {}) {
+  if (endpoint.platform === 'win32') return undefined;
+  const fsImpl = options.fsImpl || fs;
+  const stat = fsImpl.lstatSync(endpoint.path);
+  if (!stat.isSocket() || stat.isSymbolicLink()) throw new Error('INVALID_UPDATE_LEASE_SOCKET');
+  fsImpl.chmodSync(endpoint.path, 0o600);
+  return { dev: stat.dev, ino: stat.ino };
+}
+
+function removeOwnedSocket(endpoint, identity, options = {}) {
+  if (endpoint.platform === 'win32' || !identity) return;
+  const fsImpl = options.fsImpl || fs;
+  try {
+    const stat = fsImpl.lstatSync(endpoint.path);
+    if (stat.isSocket()
+      && !stat.isSymbolicLink()
+      && stat.dev === identity.dev
+      && stat.ino === identity.ino) {
+      fsImpl.unlinkSync(endpoint.path);
+    }
+  } catch {}
+}
+
+async function tryAcquireUpdateLease(options = {}) {
+  let endpoint;
+  try {
+    endpoint = deriveUpdateLeaseEndpoint(options.packageRoot, options);
+    ensurePrivateSocketDirectory(endpoint, options);
+  } catch {
+    return { acquired: false, reason: 'unavailable' };
+  }
+
+  let server;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      server = await listenForLease(endpoint, options);
+      break;
+    } catch (error) {
+      if (error?.code !== 'EADDRINUSE') {
+        return { acquired: false, reason: 'unavailable' };
+      }
+      const observed = observeSocketPath(endpoint, options);
+      const probe = await probeExistingLease(endpoint, options);
+      if (probe.state === 'owner') return { acquired: false, reason: 'busy' };
+      if (probe.state !== 'stale' || attempt > 0) {
+        return { acquired: false, reason: 'unavailable' };
+      }
+      if (endpoint.platform === 'win32') continue;
+      if (!removeObservedStaleSocket(endpoint, observed, options)) {
+        return { acquired: false, reason: 'unavailable' };
+      }
+    }
+  }
+  if (!server) return { acquired: false, reason: 'unavailable' };
+
+  let identity;
+  try {
+    identity = recordSocketIdentity(endpoint, options);
+  } catch {
+    await closeServer(server);
+    removeOwnedSocket(endpoint, identity, options);
+    return { acquired: false, reason: 'unavailable' };
+  }
+
+  let owned = true;
+  let released = false;
+  server.on('error', () => {
+    owned = false;
+  });
+  server.on('close', () => {
+    owned = false;
+  });
+  const lease = Object.freeze({
+    assertOwned() {
+      if (!owned || !server.listening) throw new Error('UPDATE_LEASE_LOST');
+    },
+    async release() {
+      if (released) return;
+      released = true;
+      owned = false;
+      await closeServer(server);
+      removeOwnedSocket(endpoint, identity, options);
+    },
+    unref() {
+      server.unref?.();
+    },
+  });
+  return { acquired: true, lease };
+}
+
+function isInstallerMessage(message) {
+  if (!message || message.type !== LEASE_HANDOFF_MESSAGE) return false;
+  const installer = message.installer;
+  return installer
+    && typeof installer === 'object'
+    && typeof message.packageRoot === 'string'
+    && path.isAbsolute(message.packageRoot)
+    && typeof installer.npmCliPath === 'string'
+    && path.isAbsolute(installer.npmCliPath)
+    && Array.isArray(installer.npmArgs)
+    && installer.npmArgs.every((entry) => typeof entry === 'string')
+    && typeof installer.installCwd === 'string'
+    && path.isAbsolute(installer.installCwd);
+}
+
+function runInstallerWorker() {
+  let state = 'BOOT';
+  let started = false;
+  let installLease;
+  let installCwd;
+  const isControlMessage = (message, type) => message
+    && typeof message === 'object'
+    && Object.getPrototypeOf(message) === Object.prototype
+    && Reflect.ownKeys(message).length === 1
+    && message.type === type;
+  const exitWithoutInstall = async (code = 0) => {
+    if (state === 'DONE') return;
+    state = 'DONE';
+    try {
+      await installLease?.release();
+    } catch {}
+    process.exit(code);
+  };
+  const startInstaller = (installer) => {
+    if (started || state !== 'COMMITTED') return;
+    started = true;
+    try {
+      installLease.assertOwned();
+      process.chdir(installer.installCwd);
+      process.argv = [process.execPath, installer.npmCliPath, ...installer.npmArgs];
+      require(installer.npmCliPath);
+    } catch {
+      process.exit(1);
+    }
+  };
+
+  process.once('message', async (message) => {
+    if (state !== 'BOOT' || !isInstallerMessage(message)) {
+      process.exit(1);
+      return;
+    }
+    state = 'PREPARED';
+    installCwd = message.installer.installCwd;
+    process.once('exit', () => {
+      if (!installCwd) return;
+      try {
+        process.chdir(path.dirname(installCwd));
+        fs.rmSync(installCwd, { recursive: true, force: true });
+      } catch {}
+    });
+    const leaseResult = await tryAcquireUpdateLease({
+      packageRoot: message.packageRoot,
+      role: 'install',
+    });
+    if (!leaseResult.acquired) {
+      const type = leaseResult.reason === 'busy'
+        ? LEASE_BUSY_MESSAGE
+        : LEASE_UNAVAILABLE_MESSAGE;
+      if (process.connected) {
+        try {
+          process.send({ type }, () => process.exit(75));
+          return;
+        } catch {}
+      }
+      process.exit(75);
+      return;
+    }
+    installLease = leaseResult.lease;
+    state = 'LEASED';
+    if (!process.connected) {
+      await exitWithoutInstall();
+      return;
+    }
+    const onControl = (control) => {
+      if (state !== 'LEASED') {
+        void exitWithoutInstall(1);
+        return;
+      }
+      if (isControlMessage(control, LEASE_CANCEL_MESSAGE)) {
+        void exitWithoutInstall();
+        return;
+      }
+      if (!isControlMessage(control, LEASE_COMMIT_MESSAGE)) {
+        void exitWithoutInstall(1);
+        return;
+      }
+      state = 'COMMITTED';
+      setImmediate(() => startInstaller(message.installer));
+    };
+    process.once('message', onControl);
+    try {
+      process.send({ type: LEASE_ADOPT_MESSAGE });
+    } catch {
+      process.removeListener('message', onControl);
+      await exitWithoutInstall();
+    }
+  });
+  process.once('disconnect', () => {
+    if (state !== 'COMMITTED' && state !== 'DONE') void exitWithoutInstall();
+  });
+}
+
+if (require.main === module && process.argv[2] === '--installer-worker') {
+  runInstallerWorker();
+}
+
+module.exports = {
+  deriveUpdateLeaseEndpoint,
+  tryAcquireUpdateLease,
+};