@platforma-sdk/workflow-tengo 2.9.6 → 2.9.7

package/dist/tengo/lib/exec.lib.tengo

@@ -1,6 +1,6 @@
-
-
-
+/**
+ * A builder for executing commands.
+ */
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 assets := import("@platforma-sdk/workflow-tengo:assets")
@@ -24,820 +24,820 @@ _MEDIUM_QUEUE   := "medium"
 _LIGHT_QUEUE    := "light"
 _UI_TASKS_QUEUE := "ui-tasks"
 
-
-
-
-
-
+/**
+ * Creates a new builder for constructing and executing commands.
+ *
+ * @return builder - a new builder instance.
+ */
 builder := func() {
-self := undefined
-
-soft := undefined
-cmd := undefined
-args := [] // list of strings
-argsTyped := [] // list of {type: expression|string, value: string}
-typedArgSet := false
-typedEnvSet := false
-envs := {} // map of names to values-strings
-envsTyped := {} // map of names to {type: expression|string, value: string}
-secrets := {} // { "env_name": "{secrets.secret_name}", ... }
-
-entrypointSet := false
-
-assertEntrypointNotSet := func() {
-ll.assert(!entrypointSet,
-"either a command with arguments or a software were already set.")
-}
-
-queue := _HEAVY_QUEUE
-cache := 0
-nErrorLines := 200
-
-
-filesToAdd := {}
-
-filesToWrite := {}
-
-dirsToCreate := {}
-
-
-filesToSave := {}
-
-filesContentToSave := {}
-
-fileSetsToSave := {}
-
-fileSetsContentToSave := {}
-
-filesToStream := {}
-
-wdProcessors := {}
-
-
-assetInfos := {}
-assetDescriptors := {}
-assetRules := {}
-assetCache := {}
-
-mnz := monetization.init()
-
-
-_getMnzOption := func(...opts) {
-if slices.length(opts) < 1 {
-return undefined
-}
-opt := opts[0]["mnz"]
-
-
-return is_undefined(opt) ? undefined : opt
-}
-
-
-_addMnzOption := func(fileName, ...opts) {
-opt := _getMnzOption(opts...)
-if !is_undefined(opt) {
-monetization.addFileParams(mnz, fileName, opt)
-}
-}
-
-stdout := "stdout.txt"
-stderr := "stderr.txt"
-
-stdoutToValue := false
-stderrToValue := false
-stderrToStdout := false
-
-self = ll.toStrict({
-
-
-
-
-
-cmd: func(commandName) {
-assertEntrypointNotSet()
-
-cmd = commandName
-entrypointSet = true
-return self
-},
-
-
-
-
-
-
-software: func(sw) {
-assertEntrypointNotSet()
-ll.assert(assets.isSoftwareInfo(sw),
-"exec.builder.software: <software> parameter is not a software info. Provide the value obtained from assets.importSoftware() here"
-)
-
-soft = sw
-entrypointSet = true
-return self
-},
-
-
-
-
-
-
-arg: func(arg) {
-ll.assert(is_string(arg), "exec.arg(): argument must be a string, got: %v", arg)
-args = append(args, arg)
-argsTyped = append(argsTyped, {
-type: execConstants.ARG_TYPE_STRING,
-value: arg
-})
-return self
-},
-
-
-
-
-
-
-argWithVar: func(arg) {
-ll.assert(is_string(arg), "exec.argWithVar(): argument with var must be a string, got: %v", arg)
-
-
-t := desc.canBackendUseExpressions() ? execConstants.ARG_TYPE_EXPRESSION : execConstants.ARG_TYPE_VAR
-argsTyped = append(argsTyped, {
-type: t,
-value: arg
-})
-typedArgSet = true
-
-return self
-},
-
-
-
-
-
-
-
-env: func(name, value) {
-validation.assertJsonSchema([name, value], ["string"])
-envs[name] = value
-envsTyped[name] = {
-type: execConstants.ARG_TYPE_STRING,
-value: value
-}
-return self
-},
-
-
-
-
-
-
-
-envWithVar: func(name, value) {
-validation.assertJsonSchema([name, value], ["string"])
-
-
-t := desc.canBackendUseExpressions() ? execConstants.ARG_TYPE_EXPRESSION : execConstants.ARG_TYPE_VAR
-envsTyped[name] = {
-type: t,
-value: value
-}
-typedEnvSet = true
-
-return self
-},
-
-
-
-
-
-
-envMap: func(envMap) {
-enum.each(envMap, self.env)
-return self
-},
-
-
-
-
-
-
-
-secret: func(secretName, envName) {
-validation.assertJsonSchema([secretName, envName], ["string"])
-secrets[envName] = "{secrets."+secretName+"}"
-return self
-},
-
-
-
-
-inHeavyQueue: func() {
-queue = _HEAVY_QUEUE
-return self
-},
-
-
-
-
-inMediumQueue: func() {
-queue = _MEDIUM_QUEUE
-return self
-},
-
-
-
-
-inLightQueue: func() {
-queue = _LIGHT_QUEUE
-return self
-},
-
-
-
-
-inUiQueue: func() {
-queue = _UI_TASKS_QUEUE
-return self
-},
-
-
-
-
-
-
-
-cache: func(time) {
-ll.assert(
-is_int(time),
-"cache time must be an integer. " +
-"Did you forget to import a standard tengo library 'times'?")
-cache = time
-return self
-},
-
-
-
-
-
-
-cacheMillis: func(millis) {
-ll.assert(is_int(millis) && millis > 0, "cache time must be a number of milliseconds")
-cache = millis * times.millisecond
-return self
-},
-
-
-
-
-
-
-cacheSeconds: func(seconds) {
-ll.assert(is_int(seconds) && seconds > 0, "cache time must be a number of seconds")
-cache = seconds * times.second
-return self
-},
-
-
-
-
-
-
-cacheMinutes: func(minutes) {
-ll.assert(is_int(minutes) && minutes > 0, "cache time must be a number of minutes")
-cache = minutes * times.minute
-return self
-},
-
-
-
-
-
-
-cacheHours: func(hours) {
-ll.assert(is_int(hours) && hours > 0, "cache time must be a number of hours")
-cache = hours * times.hour
-return self
-},
-
-
-
-
-
-
-cacheDays: func(days) {
-ll.assert(is_int(days) && days > 0, "cache time must be a number of days")
-cache = days * times.hour * 24
-return self
-},
-
-
-
-
-
-
-nErrorLines: func(lines) {
-ll.assert(
-is_int(lines) && lines >= 0,
-"lines must be integer")
-
-nErrorLines = lines
-return self
-},
-
-
-
-
-
-
-
-
-
-addAsset: func(asset, destinationDir, ...pathsInArchive) {
-if (len(pathsInArchive) == 1 && is_array(pathsInArchive[0])) {
-
-pathsInArchive = pathsInArchive[0]
-}
-if len(pathsInArchive) == 0 {
-
-pathsInArchive = []
-}
-
-ll.assert(assets.isAssetInfo(asset),
-"exec.builder.addAsset: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
-validation.assertJsonSchema(destinationDir, "string", "exec.builder.addAsset: <destinationDir> is not a string. It must be a path inside working directory")
-validation.assertJsonSchema(pathsInArchive, ["string"], "exec.builder.addAsset: <pathsInArchive> must contain list of strings with paths inside archive")
-
-assetIdKey := ll.idToString(asset._id)
-if is_undefined(assetRules[assetIdKey]) {
-assetInfos[assetIdKey] = asset.resource
-assetDescriptors[assetIdKey] = ll.fromStrict(asset.descriptor)
-assetRules[assetIdKey] = {}
-}
-
-if len(pathsInArchive) == 0 || is_undefined(assetRules[assetIdKey][destinationDir]) {
-assetRules[assetIdKey][destinationDir] = []
-}
-
-if (len(pathsInArchive) > 0) {
-assetRules[assetIdKey][destinationDir] = append(assetRules[assetIdKey][destinationDir], pathsInArchive...)
-}
-
-return self
-},
-
-
-
-
-
-cacheAssetMillis: func (asset, millis) {
-ll.assert(assets.isAssetInfo(asset),
-"exec.builder.cacheAssetMillis: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
-ll.assert(is_int(millis),
-"exec.builder.cacheAssetMillis: asset cache time must be a number of milliseconds.")
-
-assetIdKey := ll.idToString(asset._id)
-assetCache[assetIdKey] = millis * times.millisecond
-
-return self
-},
-
-
-
-
-
-cacheAssetSeconds: func (asset, seconds) {
-ll.assert(assets.isAssetInfo(asset),
-"exec.builder.cacheAssetSeconds: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
-ll.assert(is_int(seconds),
-"exec.builder.cacheAssetSeconds: asset cache time must be a number of seconds.")
-
-assetIdKey := ll.idToString(asset._id)
-assetCache[assetIdKey] = seconds * times.second
-
-return self
-},
-
-
-
-
-
-cacheAssetMinutes: func (asset, minutes) {
-ll.assert(assets.isAssetInfo(asset),
-"exec.builder.cacheAssetMinutes: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
-ll.assert(is_int(minutes),
-"exec.builder.cacheAssetMinutes: asset cache time must be a number of minutes.")
-
-assetIdKey := ll.idToString(asset._id)
-assetCache[assetIdKey] = minutes * times.minute
-
-return self
-},
-
-
-
-
-
-cacheAssetHours: func (asset, hours) {
-ll.assert(assets.isAssetInfo(asset),
-"exec.builder.cacheAssetHours: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
-ll.assert(is_int(hours),
-"exec.builder.cacheAssetHours: asset cache time must be a number of hours.")
-
-assetIdKey := ll.idToString(asset._id)
-assetCache[assetIdKey] = hours * times.hour
-
-return self
-},
-
-
-
-
-
-cacheAssetDays: func (asset, days) {
-ll.assert(assets.isAssetInfo(asset),
-"exec.builder.cacheAssetHours: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
-ll.assert(is_int(days),
-"exec.builder.cacheAssetHours: asset cache time must be a number of days.")
-
-assetIdKey := ll.idToString(asset._id)
-assetCache[assetIdKey] = days * 24 * times.hour
-
-return self
-},
-
-enableMnz: func(productName) {
-monetization.enable(mnz, productName)
-return self
-},
-
-
-
-
-
-
-
-addFile: func(fileName, file, ...opts) {
-ll.assert(is_string(fileName), "exec.builder().addFile: fileName must be a string")
-ll.assert(smart.isReference(file), "exec.builder().addFile: file must be a reference")
-
-fileName = path.canonize(fileName)
-filesToAdd[fileName] = file
-_addMnzOption(fileName, opts...)
-return self
-},
-
-
-
-
-
-
-addFiles: func(filesMap, ...opts) {
-ll.assert(ll.isMap(filesMap), "exec.builder().addFiles: filesMap must be map of file names to file resources")
-for fileName, file in filesMap {
-self.addFile(fileName, file, opts...)
-}
-return self
-},
-
-
-
-
-
-
-
-
-writeFile: func(fileName, data, ...opts) {
-validation.assertJsonSchema(data, ["or",
-"string",
-"bytes",
-validation.reference])
-
-fileName = path.canonize(fileName)
-
-filesToWrite[fileName] = data
-_addMnzOption(fileName, opts...)
-
-return self
-},
-
-
-
-
-
-
-mkDir: func(dir) {
-dir = path.canonize(dir)
-dirsToCreate = sets.add(dirsToCreate, dir)
-return self
-},
-
-
-
-
-
-
-saveFile: func(fileName) {
-fileName = path.canonize(fileName)
-sets.add(filesToSave, fileName)
-return self
-},
-
-
-
-
-
-
-saveFileContent: func(fileName) {
-fileName = path.canonize(fileName)
-sets.add(filesContentToSave, fileName)
-return self
-},
-
-
-
-
-
-
-
-saveFileSet: func(name, regex) {
-fileSetsToSave[name] = regex
-return self
-},
-
-
-
-
-processWorkdir: func(name, tpl, tplArgs) {
-wdProcessors[name] = {
-tpl: tpl,
-tplArgs: tplArgs
-}
-return self
-},
-
-
-
-
-
-
-
-saveFileSetContent: func(name, regex) {
-fileSetsContentToSave[name] = regex
-return self
-},
-
-
-
-
-
-
-streamFile: func(fileName) {
-fileName = path.canonize(fileName)
-sets.add(filesToStream, fileName)
-
-return self
-},
-
-
-
-
-stdoutFileName: func(fileName) {
-fileName = path.canonize(fileName)
-stdout = fileName
-return self
-},
-
-
-
-
-stderrFileName: func(fileName) {
-fileName = path.canonize(fileName)
-stderr = fileName
-return self
-},
-
-
-
-
-saveStdoutContent: func() {
-stdoutToValue = true
-return self
-},
-
-
-
-
-saveStderrContent: func() {
-stderrToValue = true
-return self
-},
-
-
-
-
-printErrStreamToStdout: func() {
-stderrToStdout = true
-return self
-},
-
-
-
-
-
-
-run: func() {
-if stderrToStdout {
-stderr = stdout
-}
-sets.add(filesToStream, stdout)
-sets.add(filesToStream, stderr)
-sets.add(filesToSave, stdout)
-sets.add(filesToSave, stderr)
-if stdoutToValue {
-sets.add(filesContentToSave, stdout)
-}
-if stderrToValue {
-sets.add(filesContentToSave, stderr)
-}
-
-
-
-
-filesToWriteRefs := maps.mapValues(filesToWrite, func(v) {
-if smart.isReference(v) { return v }
-return smart.createValueResource(constants.RTYPE_BINARY_VALUE, v)
-})
-
-ll.assert(entrypointSet,
-"incomplete command: cmd() or software() must be provided to exec.builder")
-
-runOptions := {
-cmd: cmd,
-args: args,
-envs: envs,
-secrets: secrets,
-queue: queue,
-stdout: stdout,
-stderr: stderr,
-nErrorLines: nErrorLines
-}
-
-execInputs := {
-filesToAdd: smart.createMapResource(filesToAdd),
-filesToWrite: smart.createMapResource(filesToWriteRefs),
-dirsToCreate: slices.fromSet(dirsToCreate),
-runOptions: runOptions,
-filesToSave: slices.fromSet(filesToSave),
-filesContentToSave: slices.fromSet(filesContentToSave),
-fileSetsToSave: fileSetsToSave,
-fileSetsContentToSave: fileSetsContentToSave,
-filesToStream: slices.fromSet(filesToStream),
-wdProcessors: wdProcessors,
-assets: smart.createMapResource(assetInfos),
-assetDescriptors: assetDescriptors,
-assetRules: assetRules,
-assetCache: assetCache
-}
-
-
-
-
-if monetization.shouldRun(mnz) {
-execInputs.runOptions.monetization = monetization.toJson(mnz)
-}
-
-
-
-if typedArgSet || typedEnvSet {
-execInputs.runOptions.argsTyped = argsTyped
-execInputs.runOptions.envsTyped = envsTyped
-}
-
-if !is_undefined(soft) {
-execInputs.softwareInfo = soft.resource
-execInputs.runOptions.software = {
-name: soft.name,
-version: soft.version,
-descriptor: ll.fromStrict(soft.descriptor)
-}
-}
-
-tpl := render.create(assets.importTemplate("@platforma-sdk/workflow-tengo:exec.exec"), execInputs)
-
-self := undefined
-self = ll.toStrict(oop.inherit(tpl, {
-
-
-
-
-
-
-getFile: func(fileName) {
-return tpl.output("files", cache).getFutureInputField(fileName)
-},
-
-
-
-
-
-
-
-getFileContent: func(fileName) {
-return tpl.output("filesContent", cache).getFutureInputField(fileName)
-},
-
-
-
-
-
-
-
-getFileStream: func(fileName) {
-return tpl.output("fileStreams", cache).getFutureInputField(fileName, true)
-},
-
-
-
-
-
-
-
-getFileSet: func(fileSetName) {
-return tpl.output("fileSets", cache).getFutureInputField(fileSetName)
-},
-
-
-
-
-
-
-
-getFileSetContent: func(fileSetName) {
-return tpl.output("fileSetsContent", cache).getFutureInputField(fileSetName)
-},
-
-getProcessorResult: func(procName) {
-return tpl.output("wdProcessors", cache).getFutureInputField(procName)
-},
-
-
-
-
-getStdoutStream: func() {
-return self.getFileStream(stdout)
-},
-
-
-
-
-getStderrStream: func() {
-return self.getFileStream(stderr)
-},
-
-
-
-
-getStdoutFile: func() {
-return self.getFile(stdout)
-},
-
-
-
-
-getStderrFile: func() {
-return self.getFile(stderr)
-},
-
-
-
-
-getStdoutFileContent: func() {
-if stdoutToValue {
-return self.getFileContent(stdout)
-}
-ll.panic("stdout was not saved as a content")
-},
-
-
-
-
-getStderrFileContent: func() {
-if stderrToValue {
-return self.getFileContent(stderr)
-}
-ll.panic("stderr was not saved as a content")
-}
-}))
-
-return self
-}
-})
-
-return self
+	self := undefined
+
+	soft := undefined
+	cmd := undefined
+	args := [] // list of strings
+	argsTyped := [] // list of {type: expression|string, value: string}
+	typedArgSet := false
+	typedEnvSet := false
+	envs := {} // map of names to values-strings
+	envsTyped := {} // map of names to {type: expression|string, value: string}
+	secrets := {} // { "env_name": "{secrets.secret_name}", ... }
+
+	entrypointSet := false
+
+	assertEntrypointNotSet := func() {
+		ll.assert(!entrypointSet,
+			"either a command with arguments or a software were already set.")
+	}
+
+	queue := _HEAVY_QUEUE
+	cache := 0
+	nErrorLines := 200
+
+	// files to be added in workdir
+	filesToAdd := {}
+	// files to be created in the workdir with the content from resources
+	filesToWrite := {}
+	// directories to create in the workdir
+	dirsToCreate := {}
+
+	// files to save from the workdir
+	filesToSave := {}
+	// files which content to save from the workdir
+	filesContentToSave := {}
+	// file sets to save by regex
+	fileSetsToSave := {}
+	// file sets to save by regex (save file content)
+	fileSetsContentToSave := {}
+	// files to stream from the workdir
+	filesToStream := {}
+	// workdir processors
+	wdProcessors := {}
+
+	// assets to be extracted into workdir before execution
+	assetInfos := {}
+	assetDescriptors := {}
+	assetRules := {}
+	assetCache := {}
+
+	mnz := monetization.init()
+
+	/** Gets mnz key from opts or undefined. */
+	_getMnzOption := func(...opts) {
+		if slices.length(opts) < 1 {
+			return undefined
+		}
+		opt := opts[0]["mnz"]
+
+		// readability if: we can return undefined here
+		return is_undefined(opt) ? undefined : opt
+	}
+
+	/** Adds a monetization option if it's defined into mnzFileParams. */
+	_addMnzOption := func(fileName, ...opts) {
+		opt := _getMnzOption(opts...)
+		if !is_undefined(opt) {
+			monetization.addFileParams(mnz, fileName, opt)
+		}
+	}
+
+	stdout := "stdout.txt"
+	stderr := "stderr.txt"
+
+	stdoutToValue := false
+	stderrToValue := false
+	stderrToStdout := false
+
+	self = ll.toStrict({
+		/**
+		 * Sets the command to be executed, e.g. /usr/bin/env or sh.
+		 *
+		 * @param commandName: string - the name of the command.
+		 */
+		cmd: func(commandName) {
+			assertEntrypointNotSet()
+
+			cmd = commandName
+			entrypointSet = true
+			return self
+		},
+
+		/**
+		 * Sets the software to be executed.
+		 *
+		 * @param software: softwareInfo - the software to execute.
+		 */
+		software: func(sw) {
+			assertEntrypointNotSet()
+			ll.assert(assets.isSoftwareInfo(sw),
+				"exec.builder.software: <software> parameter is not a software info. Provide the value obtained from assets.importSoftware() here"
+			)
+
+			soft = sw
+			entrypointSet = true
+			return self
+		},
+
+		/**
+		 * Adds an argument to the command.
+		 *
+		 * @param arg: string - the argument to add.
+		 */
+		arg: func(arg) {
+			ll.assert(is_string(arg), "exec.arg(): argument must be a string, got: %v", arg)
+			args = append(args, arg)
+			argsTyped = append(argsTyped, {
+				type: execConstants.ARG_TYPE_STRING,
+				value: arg
+			})
+			return self
+		},
+
+		/**
+		 * Adds an argument that will be evaluated as expression in the command.
+		 *
+		 * @param arg: string - e.g. -Xms{system.memory_mb * 80 / 100}m
+		 */
+		argWithVar: func(arg) {
+			ll.assert(is_string(arg), "exec.argWithVar(): argument with var must be a string, got: %v", arg)
+
+			// deprecated: remove ARG_TYPE_VAR and this check after 15 Mar 2025
+			t := desc.canBackendUseExpressions() ? execConstants.ARG_TYPE_EXPRESSION : execConstants.ARG_TYPE_VAR
+			argsTyped = append(argsTyped, {
+				type: t,
+				value: arg
+			})
+			typedArgSet = true
+
+			return self
+		},
+
+		/**
+		 * Sets an environment variable.
+		 *
+		 * @param name: string - the name of the environment variable.
+		 * @param value: string - the value of the environment variable.
+		 */
+		env: func(name, value) {
+			validation.assertJsonSchema([name, value], ["string"])
+			envs[name] = value
+			envsTyped[name] = {
+				type: execConstants.ARG_TYPE_STRING,
+				value: value
+			}
+			return self
+		},
+
+		/**
+		 * Sets an environment variable.
+		 *
+		 * @param name: string - the name of the environment variable.
+		 * @param value: string - the value of the environment variable.
+		 */
+		envWithVar: func(name, value) {
+			validation.assertJsonSchema([name, value], ["string"])
+
+			// deprecated: remove ARG_TYPE_VAR and this check after 15 Mar 2025
+			t := desc.canBackendUseExpressions() ? execConstants.ARG_TYPE_EXPRESSION : execConstants.ARG_TYPE_VAR
+			envsTyped[name] = {
+				type: t,
+				value: value
+			}
+			typedEnvSet = true
+
+			return self
+		},
+
+		/**
+		 * Sets multiple environment variables.
+		 *
+		 * @param envMap: map[string]string - a map of environment variables.
+		 */
+		envMap: func(envMap) {
+			enum.each(envMap, self.env)
+			return self
+		},
+
+		/**
+		 * Set environment variable to value of given secret.
+		 *
+		 * @param secretName: string - name of secret to pass as environment variable.
+		 * @param envName: string - name of environment variable to set with value of secret.
+		 */
+		secret: func(secretName, envName) {
+			validation.assertJsonSchema([secretName, envName], ["string"])
+			secrets[envName] = "{secrets."+secretName+"}"
+			return self
+		},
+
+		/**
+		 * Execute command in the 'heavy' queue.
+		 */
+		inHeavyQueue: func() {
+			queue = _HEAVY_QUEUE
+			return self
+		},
+
+		/**
+		 * Execute command in the 'medium' queue.
+		 */
+		inMediumQueue: func() {
+			queue = _MEDIUM_QUEUE
+			return self
+		},
+
+		/**
+		 * Execute command in the 'light' queue.
+		 */
+		inLightQueue: func() {
+			queue = _LIGHT_QUEUE
+			return self
+		},
+
+		/**
+		 * Execute command in the 'ui-tasks' queue.
+		 */
+		inUiQueue: func() {
+			queue = _UI_TASKS_QUEUE
+			return self
+		},
+
+		/**
+		 * Use cacheMillis, cacheSeconds, cacheMinutes, cacheHours and cacheDays to not make hidden mistakes in cache time ranges.
+		 * Sets the cache time.
+		 *
+		 * @param time: duration - the cache time from 'times' library.
+		 */
+		cache: func(time) {
+			ll.assert(
+				is_int(time),
+				"cache time must be an integer. " +
+					"Did you forget to import a standard tengo library 'times'?")
+			cache = time
+			return self
+		},
+
+		/**
+		 * Sets the cache time in milliseconds.
+		 *
+		 * @param millis: number
+		 */
+		cacheMillis: func(millis) {
+			ll.assert(is_int(millis) && millis > 0, "cache time must be a number of milliseconds")
+			cache = millis * times.millisecond
+			return self
+		},
+
+		/**
+		 * Sets the cache time in seconds.
+		 *
+		 * @param seconds: number
+		 */
+		cacheSeconds: func(seconds) {
+			ll.assert(is_int(seconds) && seconds > 0, "cache time must be a number of seconds")
+			cache = seconds * times.second
+			return self
+		},
+
+		/**
+		 * Sets the cache time in minutes.
+		 *
+		 * @param minutes: number
+		 */
+		cacheMinutes: func(minutes) {
+			ll.assert(is_int(minutes) && minutes > 0, "cache time must be a number of minutes")
+			cache = minutes * times.minute
+			return self
+		},
+
+		/**
+		 * Sets the cache time in hours.
+		 *
+		 * @param hours: number
+		 */
+		cacheHours: func(hours) {
+			ll.assert(is_int(hours) && hours > 0, "cache time must be a number of hours")
+			cache = hours * times.hour
+			return self
+		},
+
+		/**
+		 * Sets the cache time in days
+		 *
+		 * @param days: number
+		 */
+		cacheDays: func(days) {
+			ll.assert(is_int(days) && days > 0, "cache time must be a number of days")
+			cache = days * times.hour * 24
+			return self
+		},
+
+		/**
+		 * Sets the number of error lines to be captured.
+		 *
+		 * @param lines: number - the number of error lines.
+		 */
+		nErrorLines: func(lines) {
+			ll.assert(
+				is_int(lines) && lines >= 0,
+				"lines must be integer")
+
+			nErrorLines = lines
+			return self
+		},
+
+		/**
+		 * Adds files from given asset into working directory.
+		 *
+		 * @param asset: assetInfo - asset info loaded from assets.importAsset()
+		 * @param destinationDir: string - path inside working directory for files to be extracted from archive. Use "." for root of the workdir.
+		 * @param pathsInArchive: string[] - paths inside the archive to be extracted into destinationDir.
+		 *                                   Empty array means 'unpack full archive'.
+		 */
+		addAsset: func(asset, destinationDir, ...pathsInArchive) {
+			if (len(pathsInArchive) == 1 && is_array(pathsInArchive[0])) {
+				// support [<paths>] single argument
+				pathsInArchive = pathsInArchive[0]
+			}
+			if len(pathsInArchive) == 0 {
+				// default for 'no paths' is to extract all
+				pathsInArchive = []
+			}
+
+			ll.assert(assets.isAssetInfo(asset),
+				"exec.builder.addAsset: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+			validation.assertJsonSchema(destinationDir, "string", "exec.builder.addAsset: <destinationDir> is not a string. It must be a path inside working directory")
+			validation.assertJsonSchema(pathsInArchive, ["string"], "exec.builder.addAsset: <pathsInArchive> must contain list of strings with paths inside archive")
+
+			assetIdKey := ll.idToString(asset._id)
+			if is_undefined(assetRules[assetIdKey]) {
+				assetInfos[assetIdKey] = asset.resource
+				assetDescriptors[assetIdKey] = ll.fromStrict(asset.descriptor)
+				assetRules[assetIdKey] = {}
+			}
+
+			if len(pathsInArchive) == 0 || is_undefined(assetRules[assetIdKey][destinationDir]) {
+				assetRules[assetIdKey][destinationDir] = []
+			}
+
+			if (len(pathsInArchive) > 0) {
+				assetRules[assetIdKey][destinationDir] = append(assetRules[assetIdKey][destinationDir], pathsInArchive...)
+			}
+
+			return self
+		},
+
+		/**
+		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
+		 * This allows to customize cache time on per-asset basis
+		 */
+		cacheAssetMillis: func (asset, millis) {
+			ll.assert(assets.isAssetInfo(asset),
+				"exec.builder.cacheAssetMillis: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+			ll.assert(is_int(millis),
+				"exec.builder.cacheAssetMillis: asset cache time must be a number of milliseconds.")
+
+			assetIdKey := ll.idToString(asset._id)
+			assetCache[assetIdKey] = millis * times.millisecond
+
+			return self
+		},
+
+		/**
+		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
+		 * This allows to customize cache time on per-asset basis
+		 */
+		cacheAssetSeconds: func (asset, seconds) {
+			ll.assert(assets.isAssetInfo(asset),
+				"exec.builder.cacheAssetSeconds: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+			ll.assert(is_int(seconds),
+				"exec.builder.cacheAssetSeconds: asset cache time must be a number of seconds.")
+
+			assetIdKey := ll.idToString(asset._id)
+			assetCache[assetIdKey] = seconds * times.second
+
+			return self
+		},
+
+		/**
+		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
+		 * This allows to customize cache time on per-asset basis
+		 */
+		cacheAssetMinutes: func (asset, minutes) {
+			ll.assert(assets.isAssetInfo(asset),
+				"exec.builder.cacheAssetMinutes: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+			ll.assert(is_int(minutes),
+				"exec.builder.cacheAssetMinutes: asset cache time must be a number of minutes.")
+
+			assetIdKey := ll.idToString(asset._id)
+			assetCache[assetIdKey] = minutes * times.minute
+
+			return self
+		},
+
+		/**
+		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
+		 * This allows to customize cache time on per-asset basis
+		 */
+		cacheAssetHours: func (asset, hours) {
+			ll.assert(assets.isAssetInfo(asset),
+				"exec.builder.cacheAssetHours: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+			ll.assert(is_int(hours),
+				"exec.builder.cacheAssetHours: asset cache time must be a number of hours.")
+
+			assetIdKey := ll.idToString(asset._id)
+			assetCache[assetIdKey] = hours * times.hour
+
+			return self
+		},
+
+		/**
+		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
+		 * This allows to customize cache time on per-asset basis
+		 */
+		cacheAssetDays: func (asset, days) {
+			ll.assert(assets.isAssetInfo(asset),
+				"exec.builder.cacheAssetHours: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+			ll.assert(is_int(days),
+				"exec.builder.cacheAssetHours: asset cache time must be a number of days.")
+
+			assetIdKey := ll.idToString(asset._id)
+			assetCache[assetIdKey] = days * 24 * times.hour
+
+			return self
+		},
+
+		enableMnz: func(productName) {
+			monetization.enable(mnz, productName)
+			return self
+		},
+
+		/**
+		 * Adds a file to the working directory
+		 *
+		 * @param fileName: string - the name of the input file.
+		 * @param file: reference - a resource id of the file or a field that points to it.
+		 */
+		addFile: func(fileName, file, ...opts) {
+			ll.assert(is_string(fileName), "exec.builder().addFile: fileName must be a string")
+			ll.assert(smart.isReference(file), "exec.builder().addFile: file must be a reference")
+
+			fileName = path.canonize(fileName)
+			filesToAdd[fileName] = file
+			_addMnzOption(fileName, opts...)
+			return self
+		},
+
+		/**
+		 * Adds multiple files to the working directory.
+		 *
+		 * @param filesMap: map[string]reference - a map of file names to files' references.
+		 */
+		addFiles: func(filesMap, ...opts) {
+			ll.assert(ll.isMap(filesMap), "exec.builder().addFiles: filesMap must be map of file names to file resources")
+			for fileName, file in filesMap {
+				self.addFile(fileName, file, opts...)
+			}
+			return self
+		},
+
+		/**
+		 * Writes a file with a given content.
+		 *
+		 * @param fileName: string - the name of the content.
+		 * @param data: bytes|reference - a primitive tengo value (map or array) or a reference to
+		 *        a resource from which data we create a file.
+		 */
+		writeFile: func(fileName, data, ...opts) {
+			validation.assertJsonSchema(data, ["or",
+				"string",
+				"bytes",
+				validation.reference])
+
+			fileName = path.canonize(fileName)
+
+			filesToWrite[fileName] = data
+			_addMnzOption(fileName, opts...)
+
+			return self
+		},
+
+		/**
+		 * Creates a directory.
+		 *
+		 * @param dir: string - the directory to create.
+		 */
+		mkDir: func(dir) {
+			dir = path.canonize(dir)
+			dirsToCreate = sets.add(dirsToCreate, dir)
+			return self
+		},
+
+		/**
+		 * Saves a file.
+		 *
+		 * @param fileName: string - the name of the output file.
+		 */
+		saveFile: func(fileName) {
+			fileName = path.canonize(fileName)
+			sets.add(filesToSave, fileName)
+			return self
+		},
+
+		/**
+		 * Saves a file's content to a value resource.
+		 *
+		 * @param fileName: string - the name of the output value.
+		 */
+		saveFileContent: func(fileName) {
+			fileName = path.canonize(fileName)
+			sets.add(filesContentToSave, fileName)
+			return self
+		},
+
+		/**
+		 * Saves files from the exec workdir using regex.
+		 *
+		 * @param name: string - a name to refer this file set in the outputs
+		 * @param regex: string - regex pattern
+		 */
+		saveFileSet: func(name, regex) {
+			fileSetsToSave[name] = regex
+			return self
+		},
+
+		/**
+		 * Run specified
+		 */
+		processWorkdir: func(name, tpl, tplArgs) {
+			wdProcessors[name] = {
+				tpl: tpl,
+				tplArgs: tplArgs
+			}
+			return self
+		},
+
+		/**
+		 * Saves files content from the exec workdir using regex.
+		 *
+		 * @param name: string - a name to refer this file set in the outputs
+		 * @param regex: string - regex pattern
+		 */
+		saveFileSetContent: func(name, regex) {
+			fileSetsContentToSave[name] = regex
+			return self
+		},
+
+		/**
+		 * A command to stream a file by a given file name.
+		 *
+		 * @param fileName: string - the name of the file to stream.
+		 */
+		streamFile: func(fileName) {
+			fileName = path.canonize(fileName)
+			sets.add(filesToStream, fileName)
+
+			return self
+		},
+
+		/**
+		 * Set stdout file name
+		 */
+		stdoutFileName: func(fileName) {
+			fileName = path.canonize(fileName)
+			stdout = fileName
+			return self
+		},
+
+		/**
+		 * Set stderr file name
+		 */
+		stderrFileName: func(fileName) {
+			fileName = path.canonize(fileName)
+			stderr = fileName
+			return self
+		},
+
+		/**
+		 * Sets stdout to be captured as a value resource.
+		 */
+		saveStdoutContent: func() {
+			stdoutToValue = true
+			return self
+		},
+
+		/**
+		 * Sets stderr to be captured as a value resource.
+		 */
+		saveStderrContent: func() {
+			stderrToValue = true
+			return self
+		},
+
+		/**
+		 * Redirects stderr output to stdout.
+		 */
+		printErrStreamToStdout: func() {
+			stderrToStdout = true
+			return self
+		},
+
+		/**
+		 * Executes the command.
+		 *
+		 * @return A map containing the execution results.
+		 */
+		run: func() {
+			if stderrToStdout {
+				stderr = stdout
+			}
+			sets.add(filesToStream, stdout)
+			sets.add(filesToStream, stderr)
+			sets.add(filesToSave, stdout)
+			sets.add(filesToSave, stderr)
+			if stdoutToValue {
+				sets.add(filesContentToSave, stdout)
+			}
+			if stderrToValue {
+				sets.add(filesContentToSave, stderr)
+			}
+
+			// We don't want these values to be encoded as JSON's since
+			// values are pure bytes.
+			// Thus, we create a resource with a custom type here manually.
+			filesToWriteRefs := maps.mapValues(filesToWrite, func(v) {
+				if smart.isReference(v) { return v }
+				return smart.createValueResource(constants.RTYPE_BINARY_VALUE, v)
+			})
+
+			ll.assert(entrypointSet,
+				"incomplete command: cmd() or software() must be provided to exec.builder")
+
+			runOptions := {
+				cmd: cmd,
+				args: args,
+				envs: envs,
+				secrets: secrets,
+				queue: queue,
+				stdout: stdout,
+				stderr: stderr,
+				nErrorLines: nErrorLines
+			}
+
+			execInputs := {
+				filesToAdd: smart.createMapResource(filesToAdd),
+				filesToWrite: smart.createMapResource(filesToWriteRefs),
+				dirsToCreate: slices.fromSet(dirsToCreate),
+				runOptions: runOptions,
+				filesToSave: slices.fromSet(filesToSave),
+				filesContentToSave: slices.fromSet(filesContentToSave),
+				fileSetsToSave: fileSetsToSave,
+				fileSetsContentToSave: fileSetsContentToSave,
+				filesToStream: slices.fromSet(filesToStream),
+				wdProcessors: wdProcessors,
+				assets: smart.createMapResource(assetInfos),
+				assetDescriptors: assetDescriptors,
+				assetRules: assetRules,
+				assetCache: assetCache
+			}
+
+			// We add monetization only if it's enabled
+			// to not break a deduplication of exec's
+			// that were created before this feature existed.
+			if monetization.shouldRun(mnz) {
+				execInputs.runOptions.monetization = monetization.toJson(mnz)
+			}
+
+			// We add new argsTyped and envsTyped only when they were added
+			// to not break a deduplication on old pl backend.
+			if typedArgSet || typedEnvSet {
+				execInputs.runOptions.argsTyped = argsTyped
+				execInputs.runOptions.envsTyped = envsTyped
+			}
+
+			if !is_undefined(soft) {
+				execInputs.softwareInfo = soft.resource
+				execInputs.runOptions.software = {
+					name: soft.name,
+					version: soft.version,
+					descriptor: ll.fromStrict(soft.descriptor)
+				}
+			}
+
+			tpl := render.create(assets.importTemplate("@platforma-sdk/workflow-tengo:exec.exec"), execInputs)
+
+			self := undefined
+			self = ll.toStrict(oop.inherit(tpl, {
+				/**
+				 * Retrieves a file.
+				 *
+				 * @param fileName: string
+				 * @return field - a reference to the file resource.
+				 */
+				getFile: func(fileName) {
+					return tpl.output("files", cache).getFutureInputField(fileName)
+				},
+
+				/**
+				 * Retrieves the content of a file.
+				 *
+				 * @param fileName: string
+				 * @return field - a reference to the file content resource.
+				 */
+				getFileContent: func(fileName) {
+					return tpl.output("filesContent", cache).getFutureInputField(fileName)
+				},
+
+				/**
+				 * Retrieves a file stream.
+				 *
+				 * @param fileName: string
+				 * @return field - a reference to the file stream resource.
+				 */
+				getFileStream: func(fileName) {
+					return tpl.output("fileStreams", cache).getFutureInputField(fileName, true)
+				},
+
+				/**
+				 * Retrieves a file set resource.
+				 *
+				 * @param fileSetName: string - name of a file set
+				 * @return field - a reference to the map resource with files
+				 */
+				getFileSet: func(fileSetName) {
+					return tpl.output("fileSets", cache).getFutureInputField(fileSetName)
+				},
+
+				/**
+				 * Retrieves a file set content resource.
+				 *
+				 * @param fileSetName: string - name of a file set
+				 * @return field - a reference to the map resource with files
+				 */
+				getFileSetContent: func(fileSetName) {
+					return tpl.output("fileSetsContent", cache).getFutureInputField(fileSetName)
+				},
+
+				getProcessorResult: func(procName) {
+					return tpl.output("wdProcessors", cache).getFutureInputField(procName)
+				},
+
+				/**
+				 * Retrieves the stdout stream.
+				 */
+				getStdoutStream: func() {
+					return self.getFileStream(stdout)
+				},
+
+				/**
+				 * Retrieves the stderr stream.
+				 */
+				getStderrStream: func() {
+					return self.getFileStream(stderr)
+				},
+
+				/**
+				 * Retrieves the stdout file.
+				 */
+				getStdoutFile: func() {
+					return self.getFile(stdout)
+				},
+
+				/**
+				 * Retrieves the stderr file.
+				 */
+				getStderrFile: func() {
+					return self.getFile(stderr)
+				},
+
+				/**
+				 * Retrieves the content of the stdout file.
+				 */
+				getStdoutFileContent: func() {
+					if stdoutToValue {
+						return self.getFileContent(stdout)
+					}
+					ll.panic("stdout was not saved as a content")
+				},
+
+				/**
+				 * Retrieves the content of the stderr file.
+				 */
+				getStderrFileContent: func() {
+					if stderrToValue {
+						return self.getFileContent(stderr)
+					}
+					ll.panic("stderr was not saved as a content")
+				}
+			}))
+
+			return self
+		}
+	})
+
+	return self
 }
 
 export ll.toStrict({
-builder: builder,
-canBackendUseExpressions: desc.canBackendUseExpressions
+	builder: builder,
+	canBackendUseExpressions: desc.canBackendUseExpressions
 })