@platforma-sdk/r-builder 0.0.1

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@platforma-sdk/r-builder",
+  "description": "Build R run environment for Platforma",
+  "type": "module",
+  "version": "0.0.1",
+  "files": [
+    "scripts/"
+  ],
+  "bin": {
+    "pl-r-builder": "./scripts/builder.js"
+  },
+  "license": "UNLICENSED",
+  "dependencies": {
+    "undici": "~7.2.3",
+    "fs-extra": "^11.2.0",
+    "tar": "^7.4.3",
+    "unzipper": "^0.12.3",
+    "winston": "^3.17.0",
+    "xz": "^2.0.2"
+  },
+  "devDependencies": {
+    "@milaboratories/eslint-config": "^1.0.1"
+  }
+}

package/scripts/builder.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+/*
+ * Usage check
+ */
+
+const args = process.argv.slice(2);
+
+if (args.length !== 0) {
+  console.error(`Usage: ${process.argv[1]}`);
+  process.exit(1);
+}
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import * as util from './lib/util.js';
+import * as macos from './lib/macos.js';
+import * as linux from './lib/linux.js';
+import * as windows from './lib/windows.js';
+
+export async function buildRDist(logger, version) {
+  const currentOS = os.platform();
+  
+  const doneFile = `${version}.build-done`
+  if (fs.existsSync(doneFile)) {
+    logger.info(`Build of R is already done in this environment.\nTo force rebuild remove '${path.resolve(doneFile)}' file and run again.`)
+    return
+  }
+
+  switch (currentOS) {
+    case 'darwin': {
+      await macos.buildR(logger, version);
+      break;
+    }
+    
+    case 'linux': {
+      await linux.buildR(logger, version);
+      break;
+    }
+    
+    case 'win32': {
+      await windows.buildR(logger, version);
+      break;
+    }
+
+    default: {
+      logger.error(`unsupported OS: ${currentOS}`);
+      process.exit(1);
+    }
+  }
+
+  fs.writeFileSync(doneFile, '');
+}
+
+export async function buildRDeps(logger, version) {
+  const currentOS = os.platform();
+  
+  switch (currentOS) {
+    case 'darwin': {
+      await macos.buildDeps(logger, version);
+      break;
+    }
+
+    case 'linux': {
+      await linux.buildDeps(logger, version);
+      break;
+    }
+
+    case 'win32': {
+      await windows.buildDeps(logger, version);
+      break;
+    }
+
+    default: {
+      logger.error(`unsupported OS: ${currentOS}`);
+      process.exit(1);
+    }
+  }
+}
+
+const logger = util.createLogger('debug');
+
+(async () => {
+  const version = util.rVersion();
+  
+  await buildRDist(logger, version)
+  await buildRDeps(logger, version)
+  
+  util.runInherit(`pl-pkg build`);
+})().catch((reason) => {
+  logger.error(reason)
+  logger.debug(reason?.stack)
+  process.exit(1)
+});

package/scripts/lib/linux.js

@@ -0,0 +1,301 @@
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+
+import * as pkg from './pkg.js';
+import * as util from './util.js';
+
+const platformName = os.arch() === 'arm64' ? 'linux-aarch64' : `linux-x64`;
+
+async function installSystemPackages(logger) {
+  const originalAptSources = '/etc/apt/sources.list';
+  logger.info(`Analyzing '${originalAptSources}'`);
+
+  const modifiedAptSources = path.join(os.tmpdir(), 'apt-sources-list');
+  let srcExists = false;
+
+  const lines = fs.readFileSync(originalAptSources).toString().split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (/^\s*#\s*(deb-src)\s+.*\s+(universe)\s*$/.test(line)) {
+      srcExists = true;
+      lines[i] = line.replace(/^\s*#\s*/, '');
+    }
+    if (/^\s*deb-src\s+/.test(line)) {
+      srcExists = true;
+    }
+  }
+
+  if (srcExists) {
+    logger.info(`Patching '${originalAptSources}'`);
+    fs.writeFileSync(modifiedAptSources, lines.join('\n'));
+    util.runInherit(`sudo mv '${modifiedAptSources}' '${originalAptSources}'`);
+  } else {
+    logger.warn(
+      `WARNING! No 'deb-src' records found in '${originalAptSources}'. 'apt-get build-dep' would probably fail.`
+    );
+  }
+
+  logger.info('Installing packages');
+  util.runInherit(`sudo apt-get update`);
+  util.runInherit(`sudo apt-get install --yes rsync build-essential unzip curl patchelf r-recommended`);
+  util.runInherit(`sudo apt-get install --yes libssl-dev libcurl4-openssl-dev libpng-dev liblapack-dev libblas-dev libfontconfig1-dev libxml2-dev`);
+  util.runInherit(`sudo apt-get build-dep --yes r-base`);
+}
+
+function getGCCMajorVersion() {
+  const output = util.run('gcc --version')
+
+  const firstLine = output.split('\n')[0];
+  const versionPart = firstLine.split(' ')[2];
+  const majorVersion = versionPart.split('.')[0];
+  return parseInt(majorVersion, 10);
+}
+
+async function getRSources(logger, version) {
+  const rSourcesArchive = path.join(util.downloadsDir, `R-${version}.tar.gz`);
+
+  logger.info(`Downloading R ${version} sources...`);
+  await util.download(
+    logger,
+    `https://cran.r-project.org/src/base/R-4/R-${version}.tar.gz`,
+    rSourcesArchive
+  );
+
+  const rSourcesDir = path.join(util.artifactsDir);
+  fs.mkdirSync(rSourcesDir, { recursive: true });
+
+  logger.info(`Extracting R sources from archive...`);
+  await util.extractTarGz(rSourcesArchive, rSourcesDir);
+
+  return path.resolve(rSourcesDir, `R-${version}`);
+}
+
+function configureRBuild(logger, version, sourcesDir, installDir) {
+  logger.info(`Configuring R build`);
+
+  util.runInherit(`${sourcesDir}/tools/rsync-recommended`, {
+    cwd: sourcesDir
+  });
+
+  const buildDir = path.join(util.buildDir, 'R', version);
+  fs.mkdirSync(buildDir, { recursive: true });
+
+  const configSiteName = 'config.site';
+  fs.copyFileSync(
+    path.join(sourcesDir, configSiteName),
+    path.join(buildDir, configSiteName)
+  );
+
+  logger.info(`  running '${sourcesDir}/configure'...`);
+  const installDirAbs = path.resolve(installDir);
+  util.runInherit(
+    `${sourcesDir}/configure --with-blas=no --with-lapack=no --with-x=no --prefix=${installDirAbs}`,
+    { cwd: buildDir }
+  );
+
+  return buildDir;
+}
+
+function buildRDist(logger, buildDir, installRoot, rRoot) {
+  util.runInherit(`make`, { cwd: buildDir });
+  util.runInherit(`make install`, { cwd: buildDir });
+
+  // Move core of R installation into desired R root, leaving behind all supporting
+  // (and unnecessary) files.
+  if (fs.existsSync(rRoot)) {
+    fs.rmSync(rRoot, { recursive: true })
+  }
+  fs.renameSync(path.join(installRoot, 'lib', 'R'), rRoot);
+
+  // 1st round of dependencies collection with binaries ELF patching to make R work from
+  // its new location. We'll collect dependencies of installed packages later by one more round.
+  collectDependencies(logger, rRoot, true);
+}
+
+const systemLibs = [
+  /ld-linux-x86-64\.so(\.[0-9.]+)?$/,
+  /libc\.so(\.[0-9.]+)?$/,
+  /libm\.so(\.[0-9.]+)?$/,
+  /libcom_err\.so(\.[0-9.]+)?$/,
+  /libstdc\+\+\.so(\.[0-9.]+)?$/,
+  /libresolv\.so(\.[0-9.]+)?$/
+];
+
+function collectDependencies(logger, installDir, patchElf = false) {
+  logger.info('Collecting libraries to make R distribution portable');
+
+  const libsDir = path.join(installDir, 'lib');
+  const allLibs = () => util.findFiles(installDir, /\.so(\.[0-9.]+)?$/);
+  const executables = [path.join(installDir, 'bin/exec/R')];
+
+  const collected = collectSoLibs(
+    logger,
+    [...executables, ...allLibs()],
+    libsDir,
+    systemLibs
+  );
+  logger.info(
+    `Libraries collected into '${libsDir}':\n  ${collected.join('\n  ')}`
+  );
+
+  if (patchElf) {
+    for (const binName of [...executables]) {
+      const relativeLibLocation = path.relative(path.dirname(binName), libsDir);
+      const newRPath = `$ORIGIN/${relativeLibLocation}`;
+      logger.info(`  patching ELF in '${binName}' (rpath = '${newRPath}')...`);
+      patchBinElf(logger, binName, newRPath);
+    }
+  }
+}
+
+function collectSoLibs(logger, binaryFiles, libsDir, libsToIgnore) {
+  const allDependencies = new Set();
+
+  binaryFiles.forEach((binaryFile) => {
+    logger.info(`Loading library dependencies of '${binaryFile}'`);
+
+    libLoop: for (const libPath of getBinDependencies(binaryFile)) {
+      if (path.resolve(libPath).startsWith(path.resolve(libsDir))) {
+        continue libLoop; // already in desired libs dir
+      }
+
+      for (const ignoreRule of libsToIgnore) {
+        if (
+          (typeof ignoreRule === 'function' && ignoreRule(libPath)) ||
+          (ignoreRule instanceof RegExp && ignoreRule.test(libPath))
+        ) {
+          continue libLoop; // lib is ignored
+        }
+      }
+
+      allDependencies.add(libPath);
+    }
+  });
+
+  const collectedLibs = Array.from(allDependencies);
+
+  for (const libPath of collectedLibs) {
+    logger.info(`  copying '${libPath}'`);
+    const targetPath = path.join(libsDir, path.basename(libPath));
+    fs.copyFileSync(libPath, targetPath);
+  }
+
+  return collectedLibs;
+}
+
+function getBinDependencies(binaryFile) {
+  const output = util.run(`ldd '${binaryFile}'`).toString();
+  /*
+    The output of ldd looks like this:
+      linux-vdso.so.1 (0x00007f2f6859d000)
+      libRblas.so => not found
+      libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007f2f684ac000)
+      libreadline.so.8 => not found
+      libpcre2-8.so.0 => /lib/x86_64-linux-gnu/libpcre2-8.so.0 (0x00007f2f67f66000)
+      liblzma.so.5 => /lib/x86_64-linux-gnu/liblzma.so.5 (0x00007f2f6847a000)
+      libbz2.so.1.0 => /lib/x86_64-linux-gnu/libbz2.so.1.0 (0x00007f2f68464000)
+      libz.so.1 => /lib/x86_64-linux-gnu/libz.so.1 (0x00007f2f67f4a000)
+      libtirpc.so.3 => not found
+      libicuuc.so.70 => not found
+      libicui18n.so.70 => not found
+      libgomp.so.1 => not found
+      libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f2f67c00000)
+      /lib64/ld-linux-x86-64.so.2 (0x00007f2f6859f000)
+  */
+
+  // Split by every space symbol. Lines that start with '/' are most likely absolute paths to libraries.
+  return util.uniq(
+    output
+      .split(/\s/)
+      .filter((l) => l.startsWith('/'))
+      .sort()
+  );
+}
+
+/**
+ * Patch binary file updating its RPATH
+ *
+ * @param {winston.Logger} logger
+ * @param {string} binaryFile - binary file to patch. .so or executable.
+ * @param {string} rpath - new RPATH to set
+ */
+function patchBinElf(logger, binaryFile, rpath) {
+  util.runInherit(`patchelf --remove-rpath '${binaryFile}'`);
+  util.runInherit(`patchelf --set-rpath '${rpath}' '${binaryFile}'`);
+}
+/**
+ * Setup current process environment to integrate with sccache
+ *
+ * @param {winston.Logger} logger
+ */
+function useSCCache(logger) {
+  if (util.isOK('which sccache')) {
+    logger.info("Using sccache as build caching tool...")
+    process.env.SCCACHE_GHA_ENABLED = "true"
+    process.env.CC = `sccache gcc`
+    process.env.CXX = `sccache g++`
+  }
+}
+
+/**
+ * Build portable R distribution and all required packages from sources
+ *
+ * @param {winston.Logger} logger
+ * @param {string} version - R version to build
+ */
+export async function buildR(logger, version) {
+  if (os.platform() !== 'linux') {
+    logger.error(`Current OS is not Linux (os.platform=${os.platform()})`);
+    process.exit(1);
+  }
+
+  useSCCache(logger)
+
+  const distDir = path.join(util.rDistDir, platformName);
+
+  fs.mkdirSync(path.dirname(distDir), { recursive: true });
+  fs.mkdirSync(util.downloadsDir, { recursive: true });
+
+  await installSystemPackages(logger);
+
+  const rSourcesDir = await getRSources(logger, version);
+  const installDir = path.join(util.rDistDir, 'tmp-install');
+  const rBuildDir = configureRBuild(logger, version, rSourcesDir, installDir);
+
+  buildRDist(logger, rBuildDir, installDir, distDir);
+
+  fs.renameSync(path.join(distDir, 'bin/R'), path.join(distDir, 'bin/R.orig'))
+  fs.copyFileSync(pkg.asset('R.linux.sh'), path.join(distDir, 'bin/R'));
+
+  const gccVersion = getGCCMajorVersion()
+  const gccUtilsPath = path.join('/usr/lib/gcc/x86_64-linux-gnu', gccVersion.toString())
+
+  util.installBasicRPackages(logger, distDir, [gccUtilsPath]);
+}
+
+export async function buildDeps(logger, version) {
+  if (os.platform() !== 'linux') {
+    logger.error(`Current OS is not Linux (os.platform=${os.platform()})`);
+    process.exit(1);
+  }
+
+  useSCCache(logger);
+
+  const distDir = path.join(util.rDistDir, platformName);
+
+  const gccVersion = getGCCMajorVersion()
+  const gccUtilsPath = path.join('/usr/lib/gcc/x86_64-linux-gnu', gccVersion.toString())
+
+  util.buildRDependencies(
+    logger,
+    distDir,
+    path.join(distDir, 'packages'),
+    'dependencies',
+    [gccUtilsPath],
+  )
+
+  // We need to collect dependencies AFTER all packages intallation
+  // to save also deps of the packages (which are wider than R itself)
+  collectDependencies(logger, distDir);
+}

package/scripts/lib/macos.js

@@ -0,0 +1,68 @@
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import fsextra from 'fs-extra';
+
+import * as pkg from './pkg.js';
+import * as util from './util.js';
+import * as srcs from './macos_src.js';
+
+const platformName = os.arch() === 'arm64' ? 'macosx-aarch64' : `macosx-x64`;
+
+function currentArch() {
+  return util.run('uname -m'); // 'x86_64' or 'arm64'
+}
+
+async function installR(logger, version) {
+  logger.info(`Downloading R ${version}...`);
+
+  const rPkgPath = path.join(util.downloadsDir, `R-${version}.pkg`);
+  const rArch = currentArch()
+  await util.download(
+    logger,
+    `https://cloud.r-project.org/bin/macosx/big-sur-${rArch}/base/R-${version}-${rArch}.pkg`,
+    rPkgPath
+  );
+
+  logger.info(`Installing R ${version}...`);
+  util.runInherit(`sudo installer -pkg '${rPkgPath}' -target /`);
+
+  return fs.realpathSync('/Library/Frameworks/R.framework/Resources')
+}
+
+export async function buildR(logger, version) {
+  if (os.platform() !== 'darwin') {
+    logger.error(`Current OS is not MacOS X (os.platform=${os.platform()})`);
+    process.exit(1);
+  }
+
+  const distDir = path.join(util.rDistDir, platformName);
+
+  fs.mkdirSync(distDir, { recursive: true });
+  fs.mkdirSync(util.downloadsDir, { recursive: true });
+
+  const gFortran = await srcs.installGNUFortran(logger)
+  if (gFortran) {
+    logger.info(`Adding '${gFortran}/bin' into PATH`);
+    process.env.PATH = `${gFortran}/bin:${process.env.PATH}`;
+  }
+
+  const rRootPath = await installR(logger, version)
+  await fsextra.copy(rRootPath, distDir)
+
+  fs.renameSync(path.join(distDir, 'bin/R'), path.join(distDir, 'bin/R.orig'))
+  fs.copyFileSync(pkg.asset('R.macos.sh'), path.join(distDir, 'bin/R'))
+
+  util.installBasicRPackages(logger, distDir);
+}
+
+export async function buildDeps(logger, version) {
+  const distDir = path.join(util.rDistDir, platformName);
+
+  util.buildRDependencies(
+    logger,
+    distDir,
+    path.join(distDir, 'packages'),
+    'dependencies',
+  )
+}

package/scripts/lib/macos_src.js

@@ -0,0 +1,314 @@
+// This imodule contains code for building R on Mac OS X from sources.
+// As R project provides official binary builds in their installer AND
+// their installers can relatively simply be converted to 'portable'
+// versions, we do not have to build our own R binaries.
+// But still, if we will need it any time in future, this scripts would be
+// very helpful starting point.
+
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+
+import * as util from './util.js';
+
+const platformName = os.arch() === 'arm64' ? 'macosx-aarch64' : `macosx-x64`;
+
+function currentMacOSXVersion() {
+  return util.run('sw_vers -productVersion').toString().trim(); // i.e. 14.4.1
+}
+
+function currentArch() {
+  return util.run('uname -m');
+}
+
+export async function installGNUFortran(logger) {
+  const gfortranArchivePath = path.join(util.downloadsDir, 'gfortran.tar.xz');
+  const gfortranDistPath = path.join(util.artifactsDir, 'gfortran');
+  const gfortranGlobal = '/opt/gfortran';
+
+  logger.info(`Checking GNU Fortran...`);
+
+  if (util.isOK('gfortran --help')) {
+    logger.info(`  GNU Fortran is already available.`);
+    return ''; // gfortran's 'bin/' already in PATH
+  }
+  if (fs.existsSync(path.join(gfortranGlobal, 'bin', 'gfortran'))) {
+    logger.info(`  GNU Fortran is already installed to '${gfortranGlobal}'.`);
+    return gfortranGlobal; // should add it's 'bin/' to PATH
+  }
+
+  logger.info(`Downloading GNU Fortran...`);
+  await util.download(
+    logger,
+    'https://github.com/R-macos/gcc-12-branch/releases/download/12.2-darwin-r0/gfortran-12.2-darwin20-r0-universal.tar.xz',
+    gfortranArchivePath
+  );
+
+  logger.info(`  installing GNU Fortran to '${gfortranDistPath}'...`);
+
+  fs.mkdirSync(gfortranDistPath, { recursive: true });
+  await util.extractTarXz(gfortranArchivePath, gfortranDistPath);
+  const localGfortranRoot = path.join(gfortranDistPath, 'opt', 'gfortran');
+
+  const systemSDKPath = util.run('xcrun --show-sdk-path').toString().trim();
+  logger.info(`  linking system SDK path '${systemSDKPath}' into GNU Fortran`);
+  fs.rmSync(path.join(localGfortranRoot, 'SDK'));
+
+  fs.symlinkSync(systemSDKPath, path.join(localGfortranRoot, 'SDK'));
+
+  logger.info(`  linking GNU Fortran to '${gfortranGlobal}'...`);
+  util.runInherit(
+    `sudo ln -sfn '${path.resolve(localGfortranRoot)}' '${gfortranGlobal}'`
+  );
+
+  return gfortranGlobal;
+}
+
+export async function installMacTeX(logger) {
+  logger.info(`Downloading MacTeX...`);
+
+  const macTeXPkgPath = path.join(util.downloadsDir, 'MacTeX.pkg');
+  await util.download(
+    logger,
+    'https://mirror.ctan.org/systems/mac/mactex/MacTeX.pkg',
+    macTeXPkgPath
+  );
+
+  if (util.isOK('tex')) {
+    logger.info(`MacTeX seems to be already installed.`);
+    return;
+  }
+
+  logger.info(`Installing MacTeX...`);
+  util.runInherit(`sudo installer -pkg '${macTeXPkgPath}' -target /`);
+}
+
+export async function installXQuartz(logger) {
+  logger.info(`Downloading XQuartz...`);
+
+  const xQuartzPkgPath = path.join(util.downloadsDir, 'XQuartz.pkg');
+  await util.download(
+    logger,
+    'https://github.com/XQuartz/XQuartz/releases/download/XQuartz-2.8.5/XQuartz-2.8.5.pkg',
+    xQuartzPkgPath
+  );
+
+  if (util.isOK('XQuartz')) {
+    logger.info(`XQuartz seems to be already installed.`);
+    return;
+  }
+
+  logger.info(`Installing XQuartz...`);
+  util.runInherit(`sudo installer -pkg '${xQuartzPkgPath}' -target /`);
+}
+
+export async function installRTools(logger) {
+  const toolsRepoDir = path.join(util.artifactsDir, 'r-recipes');
+  fs.mkdirSync(path.dirname(toolsRepoDir), { recursive: true });
+
+  if (!fs.existsSync(toolsRepoDir)) {
+    logger.info(`Downloading additional R tools recipes...`);
+    util.runInherit(
+      `git clone https://github.com/R-macos/recipes.git ${toolsRepoDir}`
+    );
+  }
+
+  logger.info(`Installing additional R tools...`);
+
+  const arch = currentArch();
+  const installPrefix = `/opt/R/${arch.toString().trim()}`;
+  util.runInherit(`sudo mkdir -p '${installPrefix}'`);
+
+  // Sometimes r-base-dev fails because of network errors, like rate limiting on remote side, or failed archive downloads.
+  // We try to re-run the build script, because it is several times faster than restarting whole CI build, as
+  // 'make' under r-base-dev skips already built targets.
+  util.retry(logger, 3, 'Additional tool installation failed', () =>
+    util.runInherit('sudo -E ./build.sh r-base-dev', {
+      cwd: toolsRepoDir,
+      env: {
+        PREFIX: installPrefix
+      }
+    })
+  );
+
+  return path.resolve(installPrefix);
+}
+
+export async function getRSources(logger, version) {
+  const rSourcesArchive = path.join(util.downloadsDir, `R-${version}.tar.gz`);
+
+  logger.info(`Downloading R ${version} sources...`);
+  await util.download(
+    logger,
+    `https://cran.r-project.org/src/base/R-4/R-${version}.tar.gz`,
+    rSourcesArchive
+  );
+
+  const rSourcesDir = path.join(util.artifactsDir);
+  fs.mkdirSync(rSourcesDir, { recursive: true });
+
+  logger.info(`Extracting R sources from archive...`);
+  await util.extractTarGz(rSourcesArchive, rSourcesDir);
+
+  return path.resolve(rSourcesDir, `R-${version}`);
+}
+
+export function configureRBuild(
+  logger,
+  version,
+  sourcesDir,
+  installDir,
+  rToolsDir,
+  fortranRoot
+) {
+  logger.info(`Configuring R build...`);
+
+  util.runInherit(`${sourcesDir}/tools/rsync-recommended`, {
+    cwd: sourcesDir
+  });
+
+  const buildDir = path.join(util.buildDir, 'R', version);
+  fs.mkdirSync(buildDir, { recursive: true });
+
+  const configSiteName = 'config.site';
+  logger.info(`  patching '${path.join(sourcesDir, configSiteName)}'...`);
+  let configSiteContent = fs
+    .readFileSync(path.join(sourcesDir, configSiteName), 'utf-8')
+    .toString();
+
+  let hasARCH = false;
+  let hasOS = false;
+  for (const line in configSiteContent.split('\n')) {
+    hasARCH = hasARCH || /^\s*ARCH\s*=/.test(line);
+    hasOS = hasOS || /^\s*OSVER\s*=/.test(line);
+  }
+
+  const osMajor = currentMacOSXVersion().split('.')[0] + '.0'; // 14.4.1 -> 14.0
+  const arch = currentArch();
+  if (hasOS) {
+    configSiteContent = replace(/^\s*OS\s*=/, `OSVER=${osMajor}`);
+  } else {
+    configSiteContent += `\nOSVER=${osMajor}\n`;
+  }
+  if (hasARCH) {
+    configSiteContent = replace(/^\s*ARCH\s*=/, `ARCH=${arch}`);
+  } else {
+    configSiteContent += `\nARCH=${arch}\n`;
+  }
+
+  fs.writeFileSync(path.join(buildDir, configSiteName), configSiteContent);
+
+  logger.info(`  running '${sourcesDir}/configure'...`);
+  const installDirAbs = path.resolve(installDir);
+  util.runInherit(
+    `${sourcesDir}/configure --with-blas=no --with-lapack=no --with-x=no --prefix=${installDirAbs}`,
+    {
+      cwd: buildDir,
+      env: {
+        CC: 'sccache clang',
+        CFLAGS: `-Wall -g -O2 -pedantic -mmacosx-version-min=${osMajor} -arch ${arch} -falign-functions=64 -Wno-error=implicit-function-declaration`,
+        CPPFLAGS: `-I${rToolsDir}/include`,
+        FC: `${fortranRoot}/bin/gfortran`,
+        FCFLAGS: `-Wall -g -O2 -pedantic -mmacosx-version-min=${osMajor} -arch ${arch} -mtune=native`,
+        LDFLAGS: `-L${rToolsDir}/lib`,
+        CXX: 'sccache clang',
+        CXXFLAGS: `-Wall -g -O2 -pedantic -mmacosx-version-min=${osMajor} -arch ${arch} -falign-functions=64`,
+        R_LD_LIBRARY_PATH: `${rToolsDir}/lib`,
+        PKG_CONFIG: `${rToolsDir}/bin/pkg-config`,
+        PKG_CONFIG_PATH: `${rToolsDir}/lib/pkgconfig:${rToolsDir}/share/pkgconfig:/usr/lib/pkgconfig:/opt/X11/lib/pkgconfig:/opt/X11/share/pkgconfig`
+      }
+    }
+  );
+
+  return buildDir;
+}
+
+export function buildRFramework(logger, buildDir) {
+  logger.info('Bundling and installing R');
+  util.runInherit(`make`, { cwd: buildDir });
+  util.runInherit(`make install`, { cwd: buildDir });
+}
+
+export function collectLibraries(logger, rRoot) {
+  const dstLibsDir = 'lib/R/lib';
+
+  const allLibs = () => util.findFiles(path.resolve(rRoot), /\.(dylib|so)$/);
+
+  logger.info("Consolidating all dynamic library dependencies into R's root");
+
+  const fixRLibs = allLibs()
+    .map((libPath) => `--fix-file '${libPath}'`)
+    .join(' ');
+
+  // Collect all libraries into '<rRoot>/lib/R/lib'
+  util.runInherit(
+    `dylibbundler` +
+      ` --bundle-deps` +
+      ` --dest-dir '${dstLibsDir}'` +
+      ` --search-path '${dstLibsDir}'` +
+      ` --skip-missing` +
+      ` --skip-existing` +
+      ` --install-path '@rpath'` +
+      ` ${fixRLibs}` +
+      ` --fix-file 'lib/R/bin/exec/R'`,
+    { cwd: rRoot }
+  );
+
+  // Patch R binary to set RPATH to be relative to executable.
+  util.runInherit(
+    `install_name_tool` +
+      ` -add_rpath` +
+      ` '@executable_path/../../lib/'` +
+      ` 'lib/R/bin/exec/R'`,
+    { cwd: rRoot }
+  );
+}
+
+export async function buildRPackage() {
+  if (os.platform() !== 'darwin') {
+    logger.error(`Current OS is not MacOS X (os.platform=${os.platform()})`);
+    process.exit(1);
+  }
+
+  const distDir = path.join(util.rDistDir, version, platformName);
+
+  process.chdir(util.repoRoot);
+  fs.mkdirSync(distDir, { recursive: true });
+  fs.mkdirSync(util.downloadsDir, { recursive: true });
+
+  if (!util.isOK('xcode-select --print-path')) {
+    // 1. Install Command Line Tools for XCode as they are not present in current system
+    util.runInherit('sudo xcode-select --install');
+  }
+
+  const fortranPrefix = await installGNUFortran(logger);
+  if (fortranPrefix) {
+    logger.info(`Adding '${fortranPrefix}/bin' into PATH`);
+    process.env.PATH = `${fortranPrefix}/bin:${process.env.PATH}`;
+  }
+
+  await installMacTeX(logger);
+  await installXQuartz(logger);
+  const toolsPrefix = await installRTools(logger);
+  util.patchEnvPath('PATH', `${toolsPrefix}/bin`);
+
+  const rSourcesDir = await getRSources(logger, version);
+  const rBuildDir = configureRBuild(
+    logger,
+    version,
+    rSourcesDir,
+    distDir,
+    toolsPrefix,
+    fortranPrefix
+  );
+
+  buildRFramework(logger, rBuildDir);
+
+  const rStartScriptPath = path.join(util.repoRoot, util.assetsRoot, 'R.macos.sh');
+
+  fs.copyFileSync(rStartScriptPath, path.join(distDir, 'bin/R'));
+  fs.copyFileSync(rStartScriptPath, path.join(distDir, 'lib/R/bin/R'));
+
+  installBasicRPackages(logger, distDir);
+  collectLibraries(logger, distDir);
+}

package/scripts/lib/pkg.js

@@ -0,0 +1,11 @@
+import * as nodePath from 'node:path';
+
+const _root = nodePath.resolve(nodePath.join(import.meta.dirname, '..', '..'))
+
+export function path(p) {
+    return nodePath.join(_root, ...p);
+}
+
+export function asset(p) {
+    return path('assets', ...p)
+}

package/scripts/lib/util.js

@@ -0,0 +1,506 @@
+import child_process from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { pipeline } from 'node:stream';
+import { promisify } from 'node:util';
+import { fetch } from 'undici';
+
+import * as tar from 'tar';
+import winston from 'winston';
+import zlib from 'zlib';
+import xz from 'xz';
+
+import * as pkg from './pkg.js';
+
+// All paths are relative here by intention:
+// we maintain the same directory hierarchy across all packages.
+export const rDistDir = 'rdist'; // where built R would be stored
+export const buildDir = 'build'; // where intermediate build files would be stored
+export const downloadsDir = `${buildDir}/artifacts/dld`;
+export const artifactsDir = `${buildDir}/artifacts/pkg`;
+
+export const dependenciesDir = 'dependencies'; // where to search for dependencies specification (init.R or renv.lock)
+const renvDirName = 'renv-root' // directory with all renv cache stored inside final R run environment distribution
+
+const pipelineAsync = promisify(pipeline);
+
+export function run(command, opts = {}) {
+  const processOpts = {
+    ...opts,
+    env: {
+      ...process.env,
+      ...opts.env,
+    },
+    stdio: 'pipe'
+  }
+
+  const stdout = child_process.execSync(command, processOpts);
+  return stdout.toString();
+}
+
+export function packageJson() {
+  if (!fs.existsSync("package.json")) {
+    throw new Error("file 'package.json' not found in current directory. The script should be executed from package root dir.")
+  }
+
+  return JSON.parse(fs.readFileSync("package.json"))
+}
+
+export function rVersion() {
+  const v = packageJson()?.["block-software"]?.entrypoints?.main?.environment?.artifact?.["r-version"]
+  if (!v) {
+    throw new Error("Expected main entrypoint to have R type and to have R version defined: 'block-software.entrypoints.main.environment.artifact.r-version' is not set")
+  }
+
+  return v
+}
+
+export function runInherit(command, opts = {}) {
+  const processOpts = {
+    ...opts,
+    env: {
+      ...process.env,
+      ...opts.env,
+    },
+    stdio: 'inherit'
+  }
+  child_process.execSync(command, processOpts);
+}
+
+export function isOK(command) {
+  try {
+    child_process.execSync(command, { stdio: 'ignore' });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+export function patchEnvPath(varName, pathToAdd) {
+  if (!process.env[varName]) {
+    process.env[varName] = pathToAdd;
+    return;
+  }
+
+  const items = process.env[varName].split(path.delimiter);
+  const newValue = [pathToAdd, ...items].join(path.delimiter);
+  process.env[varName] = newValue;
+}
+
+var showProgress = process.stdout.isTTY;
+
+export async function download(logger, url, destination) {
+  if (fs.existsSync(destination)) {
+    logger.info(`  download skipped: ${destination} already exists`);
+    return Promise.resolve();
+  }
+
+  const writer = fs.createWriteStream(destination);
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    writer.close();
+    throw new Error(`Failed to download: ${response.status} ${response.statusText}`);
+  }
+
+  if (showProgress) {
+    const totalBytes = parseInt(response.headers.get('content-length') || '0', 10);
+    const knownSize = totalBytes > 0;
+    let downloadedBytes = 0;
+
+    const reader = response.body.getReader();
+    const pump = async () => {
+      const { done, value } = await reader.read();
+      if (done) return;
+      
+      downloadedBytes += value.length;
+      const progress = knownSize
+        ? (downloadedBytes / totalBytes) * 100
+        : downloadedBytes;
+      const percents = knownSize ? progress.toFixed(2) + '% ' : '';
+      const bytes = knownSize
+        ? `(${downloadedBytes.toString()}/${totalBytes.toString()})`
+        : downloadedBytes.toString();
+      process.stdout.write(`  downloading: ${percents}${bytes}\r`);
+      
+      writer.write(value);
+      await pump();
+    };
+    
+    await pump();
+  } else {
+    await pipeline(response.body, writer);
+  }
+}
+
+export async function extractTarXz(archivePath, destination) {
+  const archiveStream = fs.createReadStream(archivePath);
+
+  const decompress = new xz.Decompressor();
+
+  await pipelineAsync(
+    archiveStream,
+    decompress,
+    tar.extract({ cwd: destination })
+  );
+}
+
+export async function extractTarGz(archivePath, destination) {
+  await pipelineAsync(
+    fs.createReadStream(archivePath),
+    zlib.createUnzip(),
+    tar.extract({ cwd: destination })
+  );
+}
+
+export function findFiles(dir, filter) {
+  let results = [];
+
+  const list = fs.readdirSync(dir);
+  list.forEach((file) => {
+    const filePath = path.join(dir, file);
+    const stat = fs.statSync(filePath);
+    if (stat && stat.isDirectory()) {
+      results = results.concat(findFiles(filePath, filter));
+    } else {
+      if (
+        (typeof filter === 'function' && filter(file)) ||
+        (filter instanceof RegExp && filter.test(file))
+      ) {
+        results.push(filePath);
+      }
+    }
+  });
+
+  return results;
+}
+
+export function uniq(list) {
+  return list.filter((item, index) => {
+    return index === 0 || item !== list[index - 1];
+  });
+}
+
+/**
+ * Quote each item in given <list>
+ *
+ * @param {string[] | string} list - items to quote
+ * @param {' | "} q - quote symbol to use: ' or "
+ * @returns {string[]} - list of quoted items
+ */
+export function quote(list, q = "'") {
+  if (!list) {
+    return [];
+  }
+
+  if (typeof list === 'string') {
+    list = [list];
+  }
+
+  return list.map((item) => `${q}${item.replaceAll(q, '\\' + q)}${q}`);
+}
+
+/**
+ * Convert list of strings into R list definition (c("item1", "item2", "..."))
+ *
+ * @param {string[]} items - list of items to convert
+ * @param {' | "} q - quote symbol to use (' or ")
+ * @returns {string}
+ */
+function rList(items, q = '"') {
+  return `c(${quote(items, q).join(',')})`
+}
+
+export function retry(logger, maxAttempts, msg, cb) {
+  let i = 0;
+
+  while (true) {
+    i++;
+
+    try {
+      return cb();
+    } catch (e) {
+      logger.error(msg + ': ' + e);
+      if (i >= maxAttempts) {
+        throw e;
+      }
+    }
+  }
+}
+
+export function createLogger(level = 'debug') {
+  return winston.createLogger({
+    level: level,
+
+    format: winston.format.combine(
+      winston.format.printf(({ level, message }) => {
+        const indent = ' '.repeat(level.length + 2); // For ': ' after the level
+        const indentedMessage = message
+          .split('\n')
+          .map((line, index) => (index === 0 ? line : indent + line))
+          .join('\n');
+
+        const colorize = (l) => winston.format.colorize().colorize(l, l);
+
+        return `${colorize(level)}: ${indentedMessage}`;
+      })
+    ),
+
+    transports: [
+      new winston.transports.Console({
+        stderrLevels: ['error', 'warn', 'info', 'debug'],
+        handleExceptions: true
+      })
+    ]
+  });
+}
+
+/**
+ * Run R command
+ *
+ * @param {winston.Logger} logger
+ * @param {string} rRoot - path to R installation root
+ * @param {string[]} args - command run arguments
+ * @param {{ paths?: string[],
+ *           wd?: string,
+ *           createWD?: boolean,
+ *           env?: Record<string, string> }} opts - additional run parameters
+ */
+export function runR(logger, rRoot, args, opts = {}) {
+  const cmdToRun = `${path.resolve(rRoot, 'bin/R')} ${args.join(' ')}`;
+  const renvRoot = path.join(path.resolve(rRoot), renvDirName)
+
+  env = {
+    RHOME: path.resolve(rRoot),
+    R_HOME_DIR: path.resolve(rRoot),
+    RENV_PATHS_ROOT: renvRoot,
+    RENV_PATHS_BINARY: path.join(renvRoot, 'binaries'),
+    RENV_PATHS_SOURCE: path.join(renvRoot, 'sources'),
+    RENV_PATHS_CACHE: path.join(renvRoot, 'cache'),
+    RENV_PATHS_PREFIX: 'common',
+    RENV_PATHS_PREFIX_AUTO: 'FALSE',
+    RENV_CONFIG_AUTO_SNAPSHOT: 'FALSE',
+    RENV_CONFIG_SYNCHRONIZED_CHECK: 'FALSE',
+
+    ...opts?.env,
+  }
+
+  if (opts?.paths) {
+    env.PATH = `${process.env['PATH']}:${opts.paths.join(':')}`
+  }
+
+  const runOpts = {
+    cwd: opts?.wd,
+    env: env,
+  }
+
+  logger.debug("Running command", cmdToRun, runOpts)
+
+  if (opts?.wd && !fs.existsSync(opts.wd) && opts?.createWD) {
+    logger.debug("creating working directory for command")
+    fs.mkdirSync(opts.wd, { recursive: true })
+  }
+  runInherit(cmdToRun, runOpts);
+}
+
+/**
+ * Run R command
+ *
+ * @param {winston.Logger} logger
+ * @param {string} rRoot - path to R installation root
+ * @param {string[]} args - command run arguments
+ * @param {{ paths?: string[],
+ *           wd?: string,
+ *           env?: Record<string, string> }} opts - additional run parameters
+ */
+function runInRenv(logger, rRoot, args, opts = {}) {
+  runR(logger, rRoot, ['--quiet', '--no-echo', '--no-save', '--no-restore', '-e', quote('renv::activate()')], opts)
+  runR(logger, rRoot, args, opts)
+}
+
+const basicRPackages = [
+  'renv',
+  'devtools',
+  'usethis',
+  "pkgdepends",
+];
+
+/**
+ * Install the most basic R packages that are required all the time (like alternative package managers)
+ *
+ * @param {winston.Logger} logger
+ * @param {string} rRoot - path to R installation root
+ * @param {string[]} additionalPaths - list of paths to be appended to PATH environment variable during execution
+ */
+export function installBasicRPackages(logger, rRoot, additionalPaths = []) {
+  const install = (...pkgs) => {
+    return `install.packages(${rList(pkgs)}, repos="https://cloud.r-project.org/")`;
+  };
+
+  logger.info(`Installing basic R packages to make them be available by default.`, basicRPackages);
+
+  runR(logger, rRoot,
+    ['--no-echo',
+      '-e', ...quote(install(...basicRPackages), "'")],
+    { paths: additionalPaths },
+  );
+}
+
+/**
+ * Read and parse R dependencies file, providing structured information on list of packages to be installed.
+ *
+ * @param {winston.Logger} logger
+ * @param {string} depsFile
+ * @returns {{
+ *              type: string,
+ *              version?: string,
+ *              packages: string[]
+ *           }[]}
+ */
+export function readRDependencies(logger, depsFile) {
+  const fileContent = fs.readFileSync(depsFile, 'utf-8');
+  const deps = JSON.parse(fileContent)
+  logger.debug(`R dependencies loaded`, deps)
+  return deps
+}
+
+/**
+ * Build R dependencies and store prebuilt package archives in <packagesRoot> directory, so it can later be used
+ * as packages source during installation process on client side.
+ *
+ * @param {winston.Logger} logger
+ * @param {string} rRoot - path to R installation root
+ * @param {string} packagesRoot - path to directory wher R binary package archives should be stored.
+ * @param {string[]} additionalPaths - list of paths to be appended to PATH environment variable during execution
+ */
+export function buildRDependencies(
+  logger,
+  rRoot,
+  packagesRoot,
+  depsDir,
+  additionalPaths = [],
+) {
+  if (!fs.existsSync(packagesRoot)) {
+    fs.mkdirSync(packagesRoot, { recursive: true })
+  }
+
+  const projectsFile = path.join(path.resolve(rRoot), renvDirName, 'projects')
+  const origProjectsFile = projectsFile + '.orig'
+  if (fs.existsSync(projectsFile)) {
+    fs.renameSync(projectsFile, origProjectsFile)
+  }
+
+  const allDeps = new Set();
+  let biocVersion = ''
+
+  const lockFile = 'renv.lock'
+  const initFile = 'init.R'
+
+  const lockPath = path.join(depsDir, lockFile)
+
+  if (fs.existsSync(lockPath)) {
+    runInRenv(logger, rRoot, [
+      '--no-echo',
+      '-e', ...quote(`renv::restore( clean = TRUE )`),
+    ], {
+      wd: tempRenvDir,
+      paths: additionalPaths,
+    })
+
+  } else {
+    if (!fs.existsSync(path.join(depsDir, initFile))) {
+      throw new Error(
+        `directory ${depsDir} has no ${lockFile} or ${initFile}. No dependencies detected.\n`+
+        `Create empty init.R file if you really need empty R run environment without any preinstalled dependencies`
+      )
+    }
+
+    runInRenv(logger, rRoot, ['--no-echo', `--file=${initFile}`], {
+      wd: tempRenvDir,
+      paths: additionalPaths,
+    })
+  }
+
+  const lockData = fs.readFileSync(lockPath, { encoding: 'utf-8' });
+  const lockInfo = JSON.parse(lockData.toString())
+  for (const pkgInfo of Object.values(lockInfo.Packages)) {
+    allDeps.add(`${pkgInfo.Package}@${pkgInfo.Version}`)
+    if (pkgInfo.Package === 'BiocVersion') {
+      if (biocVersion !== '' && biocVersion !== pkgInfo.Version) {
+        throw new Error(`BiocVersion conflict: ${pkgInfo.Version} and ${biocVersion} cannot be used in the same run environment`)
+      }
+      biocVersion = pkgInfo.Version
+    }
+  }
+
+  fs.rmSync(tempRenvDir, { recursive: true })
+  if (fs.existsSync(origProjectsFile)) {
+    fs.renameSync(origProjectsFile, projectsFile)
+  }
+
+  runR(logger, rRoot,
+    [
+      `--file=${pkg.asset('collect-dependencies.R')}`,
+      `--args ${quote(Array.from(allDeps)).join(' ')}`
+    ], {
+    wd: packagesRoot,
+    createWD: true,
+    paths: additionalPaths,
+  })
+
+  biocVersion = biocVersion.split('.').slice(0, -1).join('.') // 3.20.0 -> 3.20
+
+  patchREnviron(logger, rRoot, {
+    R_BIOC_VERSION: biocVersion,
+    BIOCONDUCTOR_ONLINE_VERSION_DIAGNOSIS: "FALSE",
+
+    RENV_PATHS_PREFIX: "common",
+    RENV_CONFIG_AUTO_SNAPSHOT: "FALSE",
+    RENV_CONFIG_SYNCHRONIZED_CHECK: "FALSE",
+  },
+    "Environment customisation for Platforma Backend");
+}
+
+/**
+ * Appends Renviron file with defaults for given environment variables.
+ *
+ * @param {winston.Logger} logger
+ * @param {string} rRoot
+ * @param {Record<string, string>} envs
+ */
+function patchREnviron(
+  logger,
+  rRoot,
+  envs = {},
+  comment = "",
+) {
+  let rEnvironPath = path.join(rRoot, 'etc', 'Renviron')
+  if (!fs.existsSync(rEnvironPath)) {
+    rEnvironPath = path.join(rRoot, 'etc', 'Renviron.site')
+  }
+  if (!fs.existsSync(rEnvironPath)) {
+    throw new Error(`Renviron file not found in ${path.join(rRoot, 'etc')} directory. Can't patch default R environment settings`)
+  }
+
+  if (comment) {
+    fs.appendFileSync(rEnvironPath, `\n\n##\n## ${comment}\n##\n\n`, 'utf8');
+  }
+
+  for (const [envName, envValue] of Object.entries(envs)) {
+    line = `${envName}=\${${envName}:-'${envValue}'}`
+    fs.appendFileSync(rEnvironPath, line + '\n', 'utf8');
+  }
+}
+
+/**
+ * Recreate directory by removing it and creating back.
+ *
+ * @param {string} dir - path to directory
+ */
+function recreateDir(dir) {
+  if (fs.existsSync(dir)) {
+    fs.rmSync(dir, { recursive: true })
+  }
+  fs.mkdirSync(dir, { recursive: true })
+
+}

package/scripts/lib/windows.js

@@ -0,0 +1,37 @@
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+
+import * as pkg from './pkg.js';
+import * as util from './util.js';
+
+const platformName = os.arch() === 'arm64' ? 'windows-aarch64' : `windows-x64`;
+
+export async function buildR(logger, version) {
+  if (platformName !== 'windows-x64') {
+    logger.error(`Current OS is not Windows x64 (${platformName})`);
+    process.exit(1);
+  }
+
+  const distDir = path.join(util.rDistDir, platformName);
+
+  // Copy Windows R stub files to dist directory
+  const stubDir = pkg.asset('windows-x64-stub');
+  await fs.promises.cp(stubDir, distDir, {
+    recursive: true,
+    preserveTimestamps: true,
+    force: true,
+    errorOnExist: false
+  });
+
+  // TODO: R for windows
+}
+
+export async function buildDeps(logger, version) {
+  const distDir = path.join(util.rDistDir, platformName);
+
+  // Copy original R to current package as we cannot distribute them separately now.
+  // util.runInherit(`rsync '${rDistDir}/' '${distDir}/'`)
+
+  // TODO: R for windows
+}