blun-king-cli 9.1.10 → 9.1.12

package/bin/update-lease.js

@@ -5,6 +5,7 @@ const fs = require('node:fs');
 const net = require('node:net');
 const os = require('node:os');
 const path = require('node:path');
+const { spawn } = require('node:child_process');
 
 const LEASE_ADOPT_MESSAGE = 'blun-update-lease-adopted';
 const LEASE_CANCEL_MESSAGE = 'blun-update-lease-cancel';
@@ -15,6 +16,7 @@ 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;
+const LEASE_CONNECTIONS = Symbol('blunLeaseConnections');
 
 function canonicalPackageIdentity(packageRoot, options = {}) {
   if (typeof packageRoot !== 'string' || packageRoot.trim().length === 0) {
@@ -32,7 +34,11 @@ function canonicalPackageIdentity(packageRoot, options = {}) {
 
 function deriveUpdateLeaseEndpoint(packageRoot, options = {}) {
   const platform = options.platform || process.platform;
-  const role = options.role === 'install' ? 'install' : 'notice';
+  const role = options.role === 'install'
+    ? 'install'
+    : options.role === 'runtime'
+      ? 'runtime'
+      : 'notice';
   const identity = canonicalPackageIdentity(packageRoot, options);
   const digest = createHash('sha256')
     .update(`blun-update-v3\0${role}\0${identity}`)
@@ -64,20 +70,201 @@ function deriveUpdateLeaseEndpoint(packageRoot, options = {}) {
   return Object.freeze({ directory, magic, path: socketPath, platform });
 }
 
-function closeServer(server) {
+function connectRuntimeBroker(endpoint, options = {}) {
+  const netImpl = options.netImpl || net;
+  const timeoutMs = options.probeTimeoutMs || LEASE_PROBE_TIMEOUT_MS;
   return new Promise((resolve) => {
-    if (!server.listening) {
-      resolve();
-      return;
-    }
+    let settled = false;
+    let received = '';
+    let socket;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (!result.acquired) {
+        try {
+          socket?.destroy();
+        } catch {}
+      }
+      resolve(result);
+    };
+    const timer = setTimeout(() => finish({ acquired: false, reason: 'unavailable' }), timeoutMs);
+    timer.unref?.();
     try {
-      server.close(() => resolve());
+      socket = netImpl.createConnection({ path: endpoint.path });
+      socket.setEncoding?.('utf8');
+      socket.once('connect', () => socket.write(endpoint.magic));
+      socket.on('data', (chunk) => {
+        received += String(chunk);
+        if (!received.includes('\n')) return;
+        if (received !== endpoint.magic) {
+          finish({ acquired: false, reason: 'unavailable' });
+          return;
+        }
+        let owned = true;
+        let released = false;
+        socket.once('close', () => { owned = false; });
+        socket.once('error', () => { owned = false; });
+        const lease = Object.freeze({
+          assertOwned() {
+            if (!owned || socket.destroyed) throw new Error('RUNTIME_LEASE_LOST');
+          },
+          async release() {
+            if (released) return;
+            released = true;
+            owned = false;
+            if (socket.destroyed) return;
+            socket.destroy();
+          },
+          unref() {
+            socket.unref?.();
+          },
+        });
+        finish({ acquired: true, lease });
+      });
+      socket.once('error', () => finish({ acquired: false, reason: 'unavailable' }));
+      socket.once('close', () => finish({ acquired: false, reason: 'unavailable' }));
     } catch {
-      resolve();
+      finish({ acquired: false, reason: 'unavailable' });
     }
   });
 }
 
+function spawnRuntimeBroker(packageRoot, options = {}) {
+  const spawnImpl = options.spawnImpl || spawn;
+  const child = spawnImpl(
+    options.execPath || process.execPath,
+    [__filename, '--runtime-broker'],
+    {
+      cwd: os.tmpdir(),
+      detached: true,
+      env: {
+        ...process.env,
+        BLUN_RUNTIME_BROKER_PACKAGE_ROOT: packageRoot,
+      },
+      stdio: 'ignore',
+      windowsHide: true,
+    },
+  );
+  child.unref?.();
+}
+
+async function acquireSharedRuntimeLease(options = {}) {
+  const packageRoot = canonicalPackageIdentity(options.packageRoot, options);
+  const endpoint = deriveUpdateLeaseEndpoint(packageRoot, { ...options, role: 'runtime' });
+  const deadline = Date.now() + (options.startTimeoutMs || 3_000);
+  let spawned = false;
+  while (Date.now() < deadline) {
+    const connected = await connectRuntimeBroker(endpoint, options);
+    if (connected.acquired) return connected;
+    if (!spawned) {
+      spawned = true;
+      spawnRuntimeBroker(packageRoot, options);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+  const install = await tryAcquireUpdateLease({ ...options, packageRoot, role: 'install' });
+  if (install.acquired) {
+    await install.lease.release();
+    return { acquired: false, reason: 'unavailable' };
+  }
+  return { acquired: false, reason: install.reason };
+}
+
+async function runRuntimeBroker(options = {}) {
+  const packageRoot = options.packageRoot
+    || String(process.env.BLUN_RUNTIME_BROKER_PACKAGE_ROOT || '');
+  if (!path.isAbsolute(packageRoot)) throw new Error('RUNTIME_BROKER_PACKAGE_ROOT_REQUIRED');
+  const install = await tryAcquireUpdateLease({ packageRoot, role: 'install' });
+  if (!install.acquired) return false;
+
+  const endpoint = deriveUpdateLeaseEndpoint(packageRoot, { role: 'runtime' });
+  ensurePrivateSocketDirectory(endpoint);
+  const holders = new Set();
+  let idleTimer;
+  let closing = false;
+  let identity;
+  const closeBroker = async (server) => {
+    if (closing) return;
+    closing = true;
+    clearTimeout(idleTimer);
+    await closeServer(server);
+    removeOwnedSocket(endpoint, identity);
+    await install.lease.release();
+  };
+  const server = net.createServer((socket) => {
+    socket.setEncoding('utf8');
+    let received = '';
+    let admitted = false;
+    const reject = () => {
+      try {
+        socket.destroy();
+      } catch {}
+    };
+    const onData = (chunk) => {
+      if (admitted) return;
+      received += String(chunk);
+      if (Buffer.byteLength(received, 'utf8') > Buffer.byteLength(endpoint.magic, 'utf8')) {
+        reject();
+        return;
+      }
+      if (!received.includes('\n')) return;
+      if (received !== endpoint.magic) {
+        reject();
+        return;
+      }
+      admitted = true;
+      clearTimeout(idleTimer);
+      holders.add(socket);
+      socket.write(endpoint.magic);
+    };
+    socket.on('data', onData);
+    socket.on('error', () => {});
+    socket.once('close', () => {
+      holders.delete(socket);
+      if (holders.size === 0 && !closing) {
+        idleTimer = setTimeout(() => { void closeBroker(server); }, 0);
+      }
+    });
+  });
+  try {
+    await new Promise((resolve, reject) => {
+      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();
+      });
+    });
+    identity = recordSocketIdentity(endpoint);
+  } catch {
+    await closeServer(server);
+    await install.lease.release();
+    return false;
+  }
+  install.lease.unref();
+  server.unref?.();
+  idleTimer = setTimeout(() => { void closeBroker(server); }, 5_000);
+  return true;
+}
+
+function closeServer(server) {
+  for (const socket of server[LEASE_CONNECTIONS] || []) {
+    try {
+      socket.destroy();
+    } catch {}
+  }
+  if (!server.listening) return Promise.resolve();
+  try {
+    server.close();
+    server.unref?.();
+  } catch {}
+  return Promise.resolve();
+}
+
 function ensurePrivateSocketDirectory(endpoint, options = {}) {
   if (endpoint.platform === 'win32') return;
   const fsImpl = options.fsImpl || fs;
@@ -98,9 +285,12 @@ function listenForLease(endpoint, options = {}) {
   const netImpl = options.netImpl || net;
   return new Promise((resolve, reject) => {
     const server = netImpl.createServer((socket) => {
+      server[LEASE_CONNECTIONS].add(socket);
+      socket.once('close', () => server[LEASE_CONNECTIONS].delete(socket));
       socket.on('error', () => {});
       socket.end(endpoint.magic);
     });
+    server[LEASE_CONNECTIONS] = new Set();
     const onError = (error) => {
       server.removeListener('error', onError);
       reject(error);
@@ -391,9 +581,17 @@ function runInstallerWorker() {
 
 if (require.main === module && process.argv[2] === '--installer-worker') {
   runInstallerWorker();
+} else if (require.main === module && process.argv[2] === '--runtime-broker') {
+  void runRuntimeBroker().then((started) => {
+    if (!started) process.exitCode = 75;
+  }).catch(() => {
+    process.exitCode = 1;
+  });
 }
 
 module.exports = {
+  acquireSharedRuntimeLease,
   deriveUpdateLeaseEndpoint,
+  runRuntimeBroker,
   tryAcquireUpdateLease,
 };