@platforma-sdk/r-builder 0.0.1 → 0.0.3

package/assets/R.linux.sh

@@ -0,0 +1,293 @@
+#!/bin/bash
+# Shell wrapper for R executable.
+
+if [ -z "${R_HOME_DIR}" ]; then
+  echo "'R_HOME_DIR' environment variable is not set. R cannot work not knowing where its root"
+  exit 1
+fi
+
+if test -n "${R_HOME}" && \
+   test "${R_HOME}" != "${R_HOME_DIR}"; then
+  echo "WARNING: ignoring environment value of R_HOME"
+fi
+
+R_ROOT_DIR="${R_HOME_DIR}"
+export R_ROOT_DIR
+
+RHOME="${R_HOME_DIR}"
+export RHOME
+R_HOME="${R_HOME_DIR}"
+export R_HOME
+
+R_SHARE_DIR="${R_HOME_DIR}/share"
+export R_SHARE_DIR
+R_INCLUDE_DIR="${R_HOME_DIR}/include"
+export R_INCLUDE_DIR
+R_DOC_DIR="${R_HOME_DIR}/doc"
+export R_DOC_DIR
+
+# Since this script can be called recursively, we allow R_ARCH to
+# be overridden from the environment.
+# This script is shared by parallel installs, so nothing in it should
+# depend on the sub-architecture except the default here.
+: ${R_ARCH=}
+
+usage="
+Usage: R [options] [< infile] [> outfile]
+   or: R CMD command [arguments]
+
+Start R, a system for statistical computation and graphics, with the
+specified options, or invoke an R tool via the 'R CMD' interface.
+
+Options:
+  -h, --help            Print short help message and exit
+  --version             Print version info and exit
+  --encoding=ENC        Specify encoding to be used for stdin
+  --encoding ENC
+  RHOME			Print path to R home directory and exit
+  --save                Do save workspace at the end of the session
+  --no-save             Don't save it
+  --no-environ          Don't read the site and user environment files
+  --no-site-file        Don't read the site-wide Rprofile
+  --no-init-file        Don't read the user R profile
+  --restore             Do restore previously saved objects at startup
+  --no-restore-data     Don't restore previously saved objects
+  --no-restore-history  Don't restore the R history file
+  --no-restore          Don't restore anything
+  --vanilla		Combine --no-save, --no-restore, --no-site-file,
+			--no-init-file and --no-environ
+  --no-readline         Don't use readline for command-line editing
+  --max-ppsize=N        Set max size of protect stack to N
+  --min-nsize=N         Set min number of fixed size obj's (\"cons cells\") to N
+  --min-vsize=N         Set vector heap minimum to N bytes; '4M' = 4 MegaB
+  -q, --quiet           Don't print startup message
+  --silent              Same as --quiet
+  -s, --no-echo         Make R run as quietly as possible
+  --interactive         Force an interactive session
+  --verbose             Print more information about progress
+  -d, --debugger=NAME   Run R through debugger NAME
+  --debugger-args=ARGS  Pass ARGS as arguments to the debugger
+  -g TYPE, --gui=TYPE	Use TYPE as GUI; possible values are 'X11' (default)
+			and 'Tk'.
+  --arch=NAME		Specify a sub-architecture
+  --args                Skip the rest of the command line
+  -f FILE, --file=FILE  Take input from 'FILE'
+  -e EXPR               Execute 'EXPR' and exit
+
+FILE may contain spaces but not shell metacharacters.
+
+Commands:
+  BATCH			Run R in batch mode
+  COMPILE		Compile files for use with R
+  SHLIB			Build shared library for dynamic loading
+  INSTALL		Install add-on packages
+  REMOVE		Remove add-on packages
+  build			Build add-on packages
+  check			Check add-on packages
+  LINK			Front-end for creating executable programs
+  Rprof			Post-process R profiling files
+  Rdconv		Convert Rd format to various other formats
+  Rd2pdf		Convert Rd format to PDF
+  Rd2txt		Convert Rd format to pretty text
+  Stangle		Extract S/R code from Sweave documentation
+  Sweave		Process Sweave documentation
+  Rdiff			Diff R output ignoring headers etc
+  config		Obtain configuration information about R
+  javareconf		Update the Java configuration variables
+  rtags                 Create Emacs-style tag files from C, R, and Rd files
+
+Please use 'R CMD command --help' to obtain further information about
+the usage of 'command'.
+
+Options --arch, --no-environ, --no-init-file, --no-site-file and --vanilla
+can be placed between R and CMD, to apply to R processes run by 'command'
+
+Report bugs at <https://bugs.R-project.org>."
+
+## some systems have a more portable sed, e.g. /usr/xpg4/bin/sed on Solaris,
+## so make sure that is used.
+SED=/usr/bin/sed
+export SED
+
+error () {
+  echo "ERROR: $*" >&2
+  exit 1
+}
+
+### Argument loop
+args=
+debugger=
+debugger_args=
+gui=
+while test -n "${1}"; do
+  case ${1} in
+    RHOME|--print-home)
+      echo "${R_HOME}"; exit 0 ;;
+    CMD)
+      shift;
+      export R_ARCH
+      . "${R_HOME}/etc${R_ARCH}/ldpaths"
+      exec sh "${R_HOME}/bin/Rcmd" "${@}" ;;
+    -g|--gui)
+      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
+	gui="${2}"
+        args="${args} ${1} ${2}"
+	shift
+      else
+	error "option '${1}' requires an argument"
+      fi
+      ;;
+    --gui=*)
+      gui=`echo "${1}" | ${SED} -e 's/[^=]*=//'`
+      args="${args} ${1}"
+      ;;
+    -d|--debugger)
+      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
+	debugger="${2}"; shift
+      else
+	error "option '${1}' requires an argument"
+      fi
+      ;;
+    --debugger=*)
+      debugger=`echo "${1}" | ${SED} -e 's/[^=]*=//'` ;;
+    --debugger-args=*)
+      debugger_args=`echo "${1}" | ${SED} -e 's/[^=]*=//'` ;;
+    -h|--help)
+      echo "${usage}"; exit 0 ;;
+    --args)
+      break ;;
+    --arch)
+      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
+	R_ARCH="/${2}"
+        shift
+      else
+        error "option '${1}' requires an argument"
+      fi
+      ## check sub-architecture here for a better error message
+      if ! test -d ${R_HOME}/etc${R_ARCH}; then
+        error "sub-architecture '${1}' is not installed"
+      fi
+      ;;
+    --arch=*)
+      r_arch=`echo "${1}" | ${SED} -e 's/[^=]*=//'`
+      R_ARCH="/${r_arch}"
+      ## check sub-architecture here for a better error message
+      if ! test -d ${R_HOME}/etc${R_ARCH}; then
+        error "sub-architecture '${r_arch}' is not installed"
+      fi
+      ;;
+    -e)
+      TAB=`printf "\t"`
+      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
+	a=`(echo "${2}" && echo) | ${SED} -e 's/ /~+~/g' | \
+          ${SED} -e :a -e N -e '$!ba' -e 's/\n/~n~/g' -e 's/~n~$//g' -e "s/$TAB/~t~/g"`
+        shift
+      else
+	error "option '${1}' requires a non-empty argument"
+      fi
+      args="${args} -e $a"
+      ;;
+    -f)
+      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
+	a=`echo "${2}" | ${SED} -e 's/ /~+~/g'`; shift
+      else
+	error "option '${1}' requires a filename argument"
+      fi
+      args="${args} -f $a"
+      ;;
+    --file=*)
+      a=`echo "${1}" | ${SED} -e 's/[^=]*=//' | ${SED} -e 's/ /~+~/g'`
+      args="${args} --file=$a"
+      ;;
+    --no-environ)
+      R_ENVIRON=''
+      export R_ENVIRON
+      R_ENVIRON_USER=''
+      export R_ENVIRON_USER
+      args="${args} ${1}"
+      ;;
+    --no-site-file)
+      R_PROFILE=''
+      export R_PROFILE
+      args="${args} ${1}"
+      ;;
+    --no-init-file)
+      R_PROFILE_USER=''
+      export R_PROFILE_USER
+      args="${args} ${1}"
+      ;;
+    --vanilla)
+      R_ENVIRON=''
+      export R_ENVIRON
+      R_ENVIRON_USER=''
+      export R_ENVIRON_USER
+      R_PROFILE=''
+      export R_PROFILE
+      R_PROFILE_USER=''
+      export R_PROFILE_USER
+      args="${args} ${1}"
+      ;;
+    *)
+      args="${args} ${1}" ;;
+  esac
+  shift
+done
+
+. "${R_HOME}/etc${R_ARCH}/ldpaths"
+
+R_binary="${R_HOME}/bin/exec${R_ARCH}/R"
+export R_ARCH
+
+case "${gui}" in
+Tk|tk|X11|x11)
+  ;;
+"")
+  ;;
+*)
+  error "unknown GUI ${gui}"
+esac
+
+## R_HOME may have moved, so check
+if test -x "${R_HOME}"; then
+  :
+else
+  error "R_HOME ('${R_HOME}') not found"
+fi
+
+## Startup
+if test -z "${debugger}"; then
+  exec "${R_binary}"  ${args} "${@}"
+else
+  ## Ideally, we would like the debugger to start R with additional
+  ## ('inferior') arguments, but not all debuggers can do this.  We know
+  ## about valgrind and some versions of GDB , and deal with these.
+  ## Otherwise, to be on the safe side, we disregard non-debugger
+  ## command line args.
+  args_ok=no
+  case "`${debugger} --version 2>/dev/null`" in
+    "GNU gdb"*)
+      if ${debugger} --help 2>/dev/null | \
+          grep ' *--args' >/dev/null; then
+	args_ok=yes
+	debugger_args="${debugger_args} --args"
+      fi
+      ;;
+    valgrind*)
+      args_ok=yes
+      ;;
+  esac
+  if test -n "${args}${*}" && test "${args_ok}" = no; then
+    args=`expr "${args} ${*}" : " *\(.*\)"`
+    echo "*** Further command line arguments ('${args}') disregarded"
+    echo "*** (maybe use 'run ${args}' from *inside* ${debugger})"
+    echo ""
+    exec ${debugger} ${debugger_args} "${R_binary}"
+  else
+    exec ${debugger} ${debugger_args} "${R_binary}" ${args} "${@}"
+  fi
+fi
+
+### Local Variables: ***
+### mode: sh ***
+### sh-indentation: 2 ***
+### End: ***

package/assets/R.macos.sh

@@ -0,0 +1,290 @@
+#!/bin/sh
+# Shell wrapper for R executable.
+
+if [ -z "${R_HOME_DIR}" ]; then
+  echo "'R_HOME_DIR' environment variable is not set. R cannot work not knowing where its root"
+  exit 1
+fi
+
+if test -n "${R_HOME}" && \
+   test "${R_HOME}" != "${R_HOME_DIR}"; then
+  echo "WARNING: ignoring environment value of R_HOME"
+fi
+
+RHOME="${R_HOME_DIR}" # this is for Rscript. It checks RHOME instead of R_HOME in some versions
+export RHOME
+R_HOME="${R_HOME_DIR}"
+export R_HOME
+R_SHARE_DIR="${R_HOME_DIR}/share"
+export R_SHARE_DIR
+R_INCLUDE_DIR="${R_HOME_DIR}/include"
+export R_INCLUDE_DIR
+R_DOC_DIR="${R_HOME_DIR}/doc"
+export R_DOC_DIR
+
+# Since this script can be called recursively, we allow R_ARCH to
+# be overridden from the environment.
+# This script is shared by parallel installs, so nothing in it should
+# depend on the sub-architecture except the default here.
+: ${R_ARCH=}
+
+usage="
+Usage: R [options] [< infile] [> outfile]
+   or: R CMD command [arguments]
+
+Start R, a system for statistical computation and graphics, with the
+specified options, or invoke an R tool via the 'R CMD' interface.
+
+Options:
+  -h, --help            Print short help message and exit
+  --version             Print version info and exit
+  --encoding=ENC        Specify encoding to be used for stdin
+  --encoding ENC
+  RHOME			Print path to R home directory and exit
+  --save                Do save workspace at the end of the session
+  --no-save             Don't save it
+  --no-environ          Don't read the site and user environment files
+  --no-site-file        Don't read the site-wide Rprofile
+  --no-init-file        Don't read the user R profile
+  --restore             Do restore previously saved objects at startup
+  --no-restore-data     Don't restore previously saved objects
+  --no-restore-history  Don't restore the R history file
+  --no-restore          Don't restore anything
+  --vanilla		Combine --no-save, --no-restore, --no-site-file,
+			--no-init-file and --no-environ
+  --no-readline         Don't use readline for command-line editing
+  --max-connections=N   Set max number of connections to N
+  --max-ppsize=N        Set max size of protect stack to N
+  --min-nsize=N         Set min number of fixed size obj's (\"cons cells\") to N
+  --min-vsize=N         Set vector heap minimum to N bytes; '4M' = 4 MegaB
+  -q, --quiet           Don't print startup message
+  --silent              Same as --quiet
+  -s, --no-echo         Make R run as quietly as possible
+  --interactive         Force an interactive session
+  --verbose             Print more information about progress
+  -d, --debugger=NAME   Run R through debugger NAME
+  --debugger-args=ARGS  Pass ARGS as arguments to the debugger
+  -g TYPE, --gui=TYPE	Use TYPE as GUI; possible values are 'X11' (default)
+			and 'Tk'.
+  --arch=NAME		Specify a sub-architecture
+  --args                Skip the rest of the command line
+  -f FILE, --file=FILE  Take input from 'FILE'
+  -e EXPR               Execute 'EXPR' and exit
+
+FILE may contain spaces but not shell metacharacters.
+
+Commands:
+  BATCH			Run R in batch mode
+  COMPILE		Compile files for use with R
+  SHLIB			Build shared library for dynamic loading
+  INSTALL		Install add-on packages
+  REMOVE		Remove add-on packages
+  build			Build add-on packages
+  check			Check add-on packages
+  LINK			Front-end for creating executable programs
+  Rprof			Post-process R profiling files
+  Rdconv		Convert Rd format to various other formats
+  Rd2pdf		Convert Rd format to PDF
+  Rd2txt		Convert Rd format to pretty text
+  Stangle		Extract S/R code from Sweave documentation
+  Sweave		Process Sweave documentation
+  Rdiff			Diff R output ignoring headers etc
+  config		Obtain configuration information about R
+  javareconf		Update the Java configuration variables
+  rtags                 Create Emacs-style tag files from C, R, and Rd files
+
+Please use 'R CMD command --help' to obtain further information about
+the usage of 'command'.
+
+Options --arch, --no-environ, --no-init-file, --no-site-file and --vanilla
+can be placed between R and CMD, to apply to R processes run by 'command'
+
+Report bugs at <https://bugs.R-project.org>."
+
+## some systems have a more portable sed, e.g. /usr/xpg4/bin/sed on Solaris,
+## so make sure that is used.
+SED=/usr/bin/sed
+export SED
+
+error () {
+  echo "ERROR: $*" >&2
+  exit 1
+}
+
+### Argument loop
+args=
+debugger=
+debugger_args=
+gui=
+while test -n "${1}"; do
+  case ${1} in
+    RHOME|--print-home)
+      echo "${R_HOME}"; exit 0 ;;
+    CMD)
+      shift;
+      export R_ARCH
+      . "${R_HOME}/etc${R_ARCH}/ldpaths"
+      exec sh "${R_HOME}/bin/Rcmd" "${@}" ;;
+    -g|--gui)
+      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
+	gui="${2}"
+        args="${args} ${1} ${2}"
+	shift
+      else
+	error "option '${1}' requires an argument"
+      fi
+      ;;
+    --gui=*)
+      gui=`echo "${1}" | ${SED} -e 's/[^=]*=//'`
+      args="${args} ${1}"
+      ;;
+    -d|--debugger)
+      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
+	debugger="${2}"; shift
+      else
+	error "option '${1}' requires an argument"
+      fi
+      ;;
+    --debugger=*)
+      debugger=`echo "${1}" | ${SED} -e 's/[^=]*=//'` ;;
+    --debugger-args=*)
+      debugger_args=`echo "${1}" | ${SED} -e 's/[^=]*=//'` ;;
+    -h|--help)
+      echo "${usage}"; exit 0 ;;
+    --args)
+      break ;;
+    --arch)
+      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
+	R_ARCH="/${2}"
+        shift
+      else
+        error "option '${1}' requires an argument"
+      fi
+      ## check sub-architecture here for a better error message
+      if ! test -d ${R_HOME}/etc${R_ARCH}; then
+        error "sub-architecture '${1}' is not installed"
+      fi
+      ;;
+    --arch=*)
+      r_arch=`echo "${1}" | ${SED} -e 's/[^=]*=//'`
+      R_ARCH="/${r_arch}"
+      ## check sub-architecture here for a better error message
+      if ! test -d ${R_HOME}/etc${R_ARCH}; then
+        error "sub-architecture '${r_arch}' is not installed"
+      fi
+      ;;
+    -e)
+      TAB=`printf "\t"`
+      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
+	a=`(echo "${2}" && echo) | ${SED} -e 's/ /~+~/g' | \
+          ${SED} -e :a -e N -e '$!ba' -e 's/\n/~n~/g' -e 's/~n~$//g' -e "s/$TAB/~t~/g"`
+        shift
+      else
+	error "option '${1}' requires a non-empty argument"
+      fi
+      args="${args} -e $a"
+      ;;
+    -f)
+      if test -n "`echo ${2} | ${SED} 's/^-.*//'`"; then
+	a=`echo "${2}" | ${SED} -e 's/ /~+~/g'`; shift
+      else
+	error "option '${1}' requires a filename argument"
+      fi
+      args="${args} -f $a"
+      ;;
+    --file=*)
+      a=`echo "${1}" | ${SED} -e 's/[^=]*=//' | ${SED} -e 's/ /~+~/g'`
+      args="${args} --file=$a"
+      ;;
+    --no-environ)
+      R_ENVIRON=''
+      export R_ENVIRON
+      R_ENVIRON_USER=''
+      export R_ENVIRON_USER
+      args="${args} ${1}"
+      ;;
+    --no-site-file)
+      R_PROFILE=''
+      export R_PROFILE
+      args="${args} ${1}"
+      ;;
+    --no-init-file)
+      R_PROFILE_USER=''
+      export R_PROFILE_USER
+      args="${args} ${1}"
+      ;;
+    --vanilla)
+      R_ENVIRON=''
+      export R_ENVIRON
+      R_ENVIRON_USER=''
+      export R_ENVIRON_USER
+      R_PROFILE=''
+      export R_PROFILE
+      R_PROFILE_USER=''
+      export R_PROFILE_USER
+      args="${args} ${1}"
+      ;;
+    *)
+      args="${args} ${1}" ;;
+  esac
+  shift
+done
+
+. "${R_HOME}/etc${R_ARCH}/ldpaths"
+
+R_binary="${R_HOME}/bin/exec${R_ARCH}/R"
+export R_ARCH
+
+case "${gui}" in
+Tk|tk|X11|x11)
+  ;;
+"")
+  ;;
+*)
+  error "unknown GUI ${gui}"
+esac
+
+## R_HOME may have moved, so check
+if test -x "${R_HOME}"; then
+  :
+else
+  error "R_HOME ('${R_HOME}') not found"
+fi
+
+## Startup
+if test -z "${debugger}"; then
+  exec "${R_binary}"  ${args} "${@}"
+else
+  ## Ideally, we would like the debugger to start R with additional
+  ## ('inferior') arguments, but not all debuggers can do this.  We know
+  ## about valgrind and some versions of GDB , and deal with these.
+  ## Otherwise, to be on the safe side, we disregard non-debugger
+  ## command line args.
+  args_ok=no
+  case "`${debugger} --version 2>/dev/null`" in
+    "GNU gdb"*)
+      if ${debugger} --help 2>/dev/null | \
+          grep ' *--args' >/dev/null; then
+	args_ok=yes
+	debugger_args="${debugger_args} --args"
+      fi
+      ;;
+    valgrind*)
+      args_ok=yes
+      ;;
+  esac
+  if test -n "${args}${*}" && test "${args_ok}" = no; then
+    args=`expr "${args} ${*}" : " *\(.*\)"`
+    echo "*** Further command line arguments ('${args}') disregarded"
+    echo "*** (maybe use 'run ${args}' from *inside* ${debugger})"
+    echo ""
+    exec ${debugger} ${debugger_args} "${R_binary}"
+  else
+    exec ${debugger} ${debugger_args} "${R_binary}" ${args} "${@}"
+  fi
+fi
+
+### Local Variables: ***
+### mode: sh ***
+### sh-indentation: 2 ***
+### End: ***

package/assets/collect-dependencies.R

@@ -0,0 +1,96 @@
+library(pkgdepends)
+
+repo_root <- "."
+
+cut_prefix <- function(str, prefix) {
+  if (startsWith(str, prefix)) {
+    return(substr(str, nchar(prefix) + 1, nchar(str)))
+  }
+
+  return(str)
+}
+
+ensure_parent_dir_exists <- function(target_file) {
+  if (file.exists(dirname(target_file))) {
+    return()
+  }
+
+  dir.create(dirname(target_file), recursive = TRUE)
+}
+
+get_path_depth <- function(target_file) {
+  path_depth <- 0
+  while (TRUE) {
+    parent_path <- dirname(target_file)
+    if (parent_path == target_file) {
+      return(path_depth)
+    }
+    target_file <- parent_path
+    path_depth <- path_depth + 1
+  }
+}
+
+get_package <- function(url, dest_name, ...) {
+  destfile <- file.path(repo_root, dest_name)
+  if (!file.exists(destfile)) {
+    ensure_parent_dir_exists(destfile)
+    download.file(url, destfile, ...)
+  }
+
+  return()
+}
+
+create_alias <- function(original_name, alias_name) {
+  if (file.exists(alias_name)) {
+    return()
+  }
+
+  ensure_parent_dir_exists(alias_name)
+  depth <- get_path_depth(alias_name)
+  depth <- depth - 1 # don't count file name it
+
+  relative <- "."
+  for (i in seq_len(depth)) {
+    relative <- file.path(relative, "..")
+  }
+
+  file.symlink(file.path(relative, original_name), alias_name)
+}
+
+pkgs <- commandArgs(trailingOnly = TRUE) # "openssl@2.2.2", "openssl@2.3.0"
+print("Loading packages and their dependencies:")
+print(pkgs)
+
+pdl <- new_pkg_download_proposal(pkgs)
+pdl$resolve()
+deps <- pdl$get_resolution()
+
+for (i in seq_len(nrow(deps))) {
+  urls <- deps$sources[i][[1]]
+  dest <- deps$target[i]
+  get_package(urls[1], dest)
+
+  if (length(urls) > 1) {
+    base_url <- deps$mirror[i]
+
+    for (i in 2:length(urls)) {
+      additional_url <- urls[i]
+      alias <- cut_prefix(additional_url, paste0(base_url, "/"))
+      create_alias(dest, alias)
+    }
+  }
+}
+
+repos <- unique(deps$repodir)
+for (repo_name in repos) {
+  if (startsWith(repo_name, "bin/")) {
+    tools::write_PACKAGES(
+      file.path(repo_root, repo_name),
+      type = "mac.binary",
+    )
+  } else {
+    tools::write_PACKAGES(file.path(repo_root, repo_name))
+  }
+}
+
+warnings()

package/package.json

@@ -2,8 +2,9 @@
   "name": "@platforma-sdk/r-builder",
   "description": "Build R run environment for Platforma",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "files": [
+    "assets/",
     "scripts/"
   ],
   "bin": {
@@ -11,12 +12,10 @@
   },
   "license": "UNLICENSED",
   "dependencies": {
-    "undici": "~7.2.3",
+    "undici": "~7.4.0",
     "fs-extra": "^11.2.0",
     "tar": "^7.4.3",
-    "unzipper": "^0.12.3",
-    "winston": "^3.17.0",
-    "xz": "^2.0.2"
+    "winston": "^3.17.0"
   },
   "devDependencies": {
     "@milaboratories/eslint-config": "^1.0.1"

package/scripts/builder.js

@@ -22,12 +22,6 @@ 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': {
@@ -50,8 +44,6 @@ export async function buildRDist(logger, version) {
       process.exit(1);
     }
   }
-
-  fs.writeFileSync(doneFile, '');
 }
 
 export async function buildRDeps(logger, version) {

package/scripts/lib/linux.js

@@ -7,6 +7,39 @@ import * as util from './util.js';
 
 const platformName = os.arch() === 'arm64' ? 'linux-aarch64' : `linux-x64`;
 
+function useCaching(logger) {
+  if (util.isOK('which ccache')) {
+    useCCache(logger)
+  } else if (util.isOK('which sccache')) {
+    useSCCache(logger)
+  } else {
+    logger.warn('No caching tool found. Builds will be slow.')
+  }
+}
+
+/**
+ * Setup current process environment to integrate with sccache
+ *
+ * @param {winston.Logger} logger
+ */
+function useSCCache(logger) {
+  logger.info("Using sccache as build caching tool...")
+  process.env.SCCACHE_GHA_ENABLED = "true"
+  process.env.CC = `sccache gcc`
+  process.env.CXX = `sccache g++`
+}
+
+/**
+ * Setup current process environment to integrate with ccache
+ *
+ * @param {winston.Logger} logger
+ */
+function useCCache(logger) {
+  logger.info("Using ccache as build caching tool...")
+  process.env.CC = `ccache gcc`
+  process.env.CXX = `ccache g++`
+}
+
 async function installSystemPackages(logger) {
   const originalAptSources = '/etc/apt/sources.list';
   logger.info(`Analyzing '${originalAptSources}'`);
@@ -224,19 +257,6 @@ 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
@@ -250,7 +270,7 @@ export async function buildR(logger, version) {
     process.exit(1);
   }
 
-  useSCCache(logger)
+  useCaching(logger)
 
   const distDir = path.join(util.rDistDir, platformName);
 
@@ -267,6 +287,7 @@ export async function buildR(logger, version) {
 
   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'));
+  fs.chmodSync(path.join(distDir, 'bin/R'), 0o755)
 
   const gccVersion = getGCCMajorVersion()
   const gccUtilsPath = path.join('/usr/lib/gcc/x86_64-linux-gnu', gccVersion.toString())
@@ -280,7 +301,7 @@ export async function buildDeps(logger, version) {
     process.exit(1);
   }
 
-  useSCCache(logger);
+  useCaching(logger);
 
   const distDir = path.join(util.rDistDir, platformName);
 

package/scripts/lib/macos.js

@@ -52,6 +52,7 @@ export async function buildR(logger, version) {
 
   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'))
+  fs.chmodSync(path.join(distDir, 'bin/R'), 0o755)
 
   util.installBasicRPackages(logger, distDir);
 }

package/scripts/lib/pkg.js

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

package/scripts/lib/util.js

@@ -20,7 +20,10 @@ 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
+
+// directory with all renv cache stored inside final R run environment distribution.
+// When changing this name, remember to update R preparation steps in workflow-tengo SDK.
+const renvDirName = 'renv-root'
 
 const pipelineAsync = promisify(pipeline);
 
@@ -134,15 +137,10 @@ export async function download(logger, url, destination) {
 }
 
 export async function extractTarXz(archivePath, destination) {
-  const archiveStream = fs.createReadStream(archivePath);
-
-  const decompress = new xz.Decompressor();
-
-  await pipelineAsync(
-    archiveStream,
-    decompress,
-    tar.extract({ cwd: destination })
-  );
+  if (!fs.existsSync(destination)) {
+    fs.mkdirSync(destination, { recursive: true });
+  }
+  runInherit(`tar -xJf '${archivePath}' -C '${destination}'`);
 }
 
 export async function extractTarGz(archivePath, destination) {
@@ -234,7 +232,9 @@ export function createLogger(level = 'debug') {
 
     format: winston.format.combine(
       winston.format.printf(({ level, message }) => {
-        const indent = ' '.repeat(level.length + 2); // For ': ' after the level
+        const now = new Date();
+        const time = `[${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}]`;
+        const indent = ' '.repeat(time.length + 1 + level.length + 2); // For ': ' after the level
         const indentedMessage = message
           .split('\n')
           .map((line, index) => (index === 0 ? line : indent + line))
@@ -242,7 +242,7 @@ export function createLogger(level = 'debug') {
 
         const colorize = (l) => winston.format.colorize().colorize(l, l);
 
-        return `${colorize(level)}: ${indentedMessage}`;
+        return `${time} ${colorize(level)}: ${indentedMessage}`;
       })
     ),
 
@@ -270,7 +270,7 @@ 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 = {
+  const env = {
     RHOME: path.resolve(rRoot),
     R_HOME_DIR: path.resolve(rRoot),
     RENV_PATHS_ROOT: renvRoot,
@@ -403,22 +403,25 @@ export function buildRDependencies(
       '--no-echo',
       '-e', ...quote(`renv::restore( clean = TRUE )`),
     ], {
-      wd: tempRenvDir,
+      wd: depsDir,
       paths: additionalPaths,
     })
 
+  } else if (fs.existsSync(path.join(depsDir, initFile))) {
+    runInRenv(logger, rRoot, ['--no-echo', `--file=${initFile}`], {
+      wd: depsDir,
+      paths: additionalPaths,
+    })
+
+    if (!fs.existsSync(path.join(depsDir, lockFile))) {
+      runInRenv(logger, rRoot, ['--no-echo', '-e', ...quote(`renv::snapshot()`)])
+    }
+
   } 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' });
@@ -433,8 +436,12 @@ export function buildRDependencies(
     }
   }
 
-  fs.rmSync(tempRenvDir, { recursive: true })
+  // Store resulting 'renv.lock' file in R installation root directory,
+  // so we can use it when preparing renv on Platforma Backend side (workflow-tengo SDK).
+  fs.copyFileSync(path.join(depsDir, lockFile), path.join(rRoot, renvDirName, lockFile))
+
   if (fs.existsSync(origProjectsFile)) {
+    // Restore original 'projects' file to not leave traces of environment preparation.
     fs.renameSync(origProjectsFile, projectsFile)
   }
 
@@ -474,6 +481,8 @@ function patchREnviron(
   envs = {},
   comment = "",
 ) {
+  logger.info(`Patching Renviron file in ${rRoot} directory`)
+
   let rEnvironPath = path.join(rRoot, 'etc', 'Renviron')
   if (!fs.existsSync(rEnvironPath)) {
     rEnvironPath = path.join(rRoot, 'etc', 'Renviron.site')
@@ -487,20 +496,7 @@ function patchREnviron(
   }
 
   for (const [envName, envValue] of Object.entries(envs)) {
-    line = `${envName}=\${${envName}:-'${envValue}'}`
+    const 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

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import os from 'node:os';
-import fs from 'node:fs';
+import fsextra from 'fs-extra';
 
 import * as pkg from './pkg.js';
 import * as util from './util.js';
@@ -17,12 +17,7 @@ export async function buildR(logger, version) {
 
   // 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
-  });
+  await fsextra.copy(stubDir, distDir);
 
   // TODO: R for windows
 }