@netlify/config 19.0.0-rc → 19.0.1

package/bin.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+// This is a workaround for npm issue: https://github.com/npm/cli/issues/2632
+
+import './lib/bin/main.js'

package/lib/api/build_settings.js

@@ -0,0 +1,28 @@
+import { removeFalsy } from '../utils/remove_falsy.js';
+// Netlify UI build settings are used as default configuration values in
+// production. In local builds, we retrieve them with `getSite` (`siteInfo`)
+// instead.
+// This also includes UI-installed plugins.
+export const addBuildSettings = function ({ defaultConfig, baseRelDir, siteInfo: { build_settings: buildSettings, plugins }, }) {
+    if (buildSettings === undefined) {
+        return { defaultConfig, baseRelDir };
+    }
+    const defaultConfigA = getDefaultConfig(buildSettings, defaultConfig, plugins);
+    const baseRelDirA = getBaseRelDir(buildSettings, baseRelDir);
+    return { defaultConfig: defaultConfigA, baseRelDir: baseRelDirA };
+};
+// From the `getSite` API response to the corresponding configuration properties
+const getDefaultConfig = function ({ cmd: command, dir: publish, functions_dir: functionsDirectory, base }, { build, plugins = [], ...defaultConfig }, uiPlugins = []) {
+    const siteBuild = removeFalsy({ command, publish, base });
+    const functions = functionsDirectory ? { functionsDirectory, functionsDirectoryOrigin: 'ui' } : {};
+    const uiPluginsA = uiPlugins.map(normalizeUiPlugin);
+    const pluginsA = [...uiPluginsA, ...plugins];
+    return { ...defaultConfig, build: { ...siteBuild, ...build }, plugins: pluginsA, ...functions };
+};
+// Make sure we know which fields we are picking from the API
+const normalizeUiPlugin = function ({ package: packageName, inputs, pinned_version: pinnedVersion }) {
+    return { package: packageName, inputs, pinned_version: pinnedVersion };
+};
+const getBaseRelDir = function ({ base_rel_dir: siteBaseRelDir }, baseRelDir = siteBaseRelDir) {
+    return Boolean(baseRelDir);
+};

package/lib/api/client.js

@@ -0,0 +1,12 @@
+import { NetlifyAPI } from 'netlify';
+import { removeUndefined } from '../utils/remove_falsy.js';
+// Retrieve Netlify API client, if an access token was passed
+export const getApiClient = function ({ token, offline, testOpts = {}, host, scheme, pathPrefix }) {
+    if (!token || offline) {
+        return;
+    }
+    // TODO: find less intrusive way to mock HTTP requests
+    const parameters = removeUndefined({ scheme: testOpts.scheme || scheme, host: testOpts.host || host, pathPrefix });
+    const api = new NetlifyAPI(token, parameters);
+    return api;
+};

package/lib/api/site_info.js

@@ -0,0 +1,59 @@
+import { getEnvelope } from '../env/envelope.js';
+import { throwUserError } from '../error.js';
+import { ERROR_CALL_TO_ACTION } from '../log/messages.js';
+// Retrieve Netlify Site information, if available.
+// Used to retrieve local build environment variables and UI build settings.
+// This is not used in production builds since the buildbot passes this
+// information instead.
+// Requires knowing the `siteId` and having the access `token`.
+// Silently ignore API errors. For example the network connection might be down,
+// but local builds should still work regardless.
+export const getSiteInfo = async function ({ api, siteId, mode, testOpts: { env: testEnv = true } = {} }) {
+    if (api === undefined || mode === 'buildbot' || !testEnv) {
+        const siteInfo = siteId === undefined ? {} : { id: siteId };
+        return { siteInfo, accounts: [], addons: [] };
+    }
+    const [siteInfo, accounts, addons] = await Promise.all([
+        getSite(api, siteId),
+        getAccounts(api),
+        getAddons(api, siteId),
+    ]);
+    if (siteInfo.use_envelope) {
+        const envelope = await getEnvelope({ api, accountId: siteInfo.account_slug, siteId });
+        siteInfo.build_settings.env = envelope;
+    }
+    return { siteInfo, accounts, addons };
+};
+const getSite = async function (api, siteId) {
+    if (siteId === undefined) {
+        return {};
+    }
+    try {
+        const site = await api.getSite({ siteId });
+        return { ...site, id: siteId };
+    }
+    catch (error) {
+        throwUserError(`Failed retrieving site data for site ${siteId}: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
+    }
+};
+const getAccounts = async function (api) {
+    try {
+        const accounts = await api.listAccountsForUser();
+        return Array.isArray(accounts) ? accounts : [];
+    }
+    catch (error) {
+        throwUserError(`Failed retrieving user account: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
+    }
+};
+const getAddons = async function (api, siteId) {
+    if (siteId === undefined) {
+        return [];
+    }
+    try {
+        const addons = await api.listServiceInstancesForSite({ siteId });
+        return Array.isArray(addons) ? addons : [];
+    }
+    catch (error) {
+        throwUserError(`Failed retrieving addons for site ${siteId}: ${error.message}. ${ERROR_CALL_TO_ACTION}`);
+    }
+};

package/{src → lib}/base.js

@@ -1,14 +1,8 @@
-import { resolvePath } from './files.js'
-
+import { resolvePath } from './files.js';
 // Retrieve the first `base` directory used to load the first config file.
-export const getInitialBase = function ({
-  repositoryRoot,
-  defaultConfig: { build: { base: defaultBase } = {} },
-  inlineConfig: { build: { base: initialBase = defaultBase } = {} },
-}) {
-  return resolveBase(repositoryRoot, initialBase)
-}
-
+export const getInitialBase = function ({ repositoryRoot, defaultConfig: { build: { base: defaultBase } = {} }, inlineConfig: { build: { base: initialBase = defaultBase } = {} }, }) {
+    return resolveBase(repositoryRoot, initialBase);
+};
 // Two config files can be used:
 //  - The first one, using the `config` property or doing a default lookup
 //    of `netlify.toml`
@@ -21,14 +15,12 @@ export const getInitialBase = function ({
 // If the second file has a `base` property, it is ignored, i.e. it is not
 // recursive.
 export const getBase = function (base, repositoryRoot, config) {
-  return base === undefined ? resolveBase(repositoryRoot, config.build.base) : base
-}
-
+    return base === undefined ? resolveBase(repositoryRoot, config.build.base) : base;
+};
 const resolveBase = function (repositoryRoot, base) {
-  return resolvePath(repositoryRoot, repositoryRoot, base, 'build.base')
-}
-
+    return resolvePath(repositoryRoot, repositoryRoot, base, 'build.base');
+};
 // Also `config.build.base`.
 export const addBase = function (config, base) {
-  return { ...config, build: { ...config.build, base } }
-}
+    return { ...config, build: { ...config.build, base } };
+};

package/lib/bin/flags.js

@@ -0,0 +1,173 @@
+import process from 'process';
+import filterObj from 'filter-obj';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { normalizeCliFeatureFlags } from '../options/feature_flags.js';
+// Parse CLI flags
+export const parseFlags = function () {
+    const { featureFlags: cliFeatureFlags = '', ...flags } = yargs(hideBin(process.argv))
+        .options(FLAGS)
+        .usage(USAGE)
+        .parse();
+    const featureFlags = normalizeCliFeatureFlags(cliFeatureFlags);
+    const flagsA = { ...flags, featureFlags };
+    const flagsB = filterObj(flagsA, isUserFlag);
+    return flagsB;
+};
+const jsonParse = function (value) {
+    return value === undefined ? undefined : JSON.parse(value);
+};
+// List of CLI flags
+const FLAGS = {
+    config: {
+        string: true,
+        describe: `Path to the configuration file.
+Defaults to any netlify.toml in the git repository root directory or the base directory`,
+    },
+    defaultConfig: {
+        string: true,
+        describe: `JSON configuration object containing default values.
+Each configuration default value is used unless overriden through the main configuration file.
+Default: none.`,
+        coerce: jsonParse,
+        hidden: true,
+    },
+    cachedConfig: {
+        string: true,
+        describe: `JSON configuration object returned by @netlify/config when --output=/ is used
+or when using @netlify/config programmatically.
+This is done as a performance optimization to cache the configuration loading logic.
+Default: none.`,
+        coerce: jsonParse,
+        hidden: true,
+    },
+    cachedConfigPath: {
+        string: true,
+        describe: `File path to the JSON configuration object returned by @netlify/config
+when --output=/path is used.
+This is done as a performance optimization to cache the configuration loading logic.
+Default: none.`,
+        hidden: true,
+    },
+    inlineConfig: {
+        string: true,
+        describe: `JSON configuration object overriding the configuration file and other settings.
+Default: none.`,
+        coerce: jsonParse,
+        hidden: true,
+    },
+    configMutations: {
+        array: true,
+        describe: `Array of changes to apply to the configuration.
+Each change must be an object with three properties:
+  - "keys": array of keys targetting the property to change
+  - "value": new value of that property
+  - "event": build event when this change was applied, e.g. "onPreBuild"
+Default: empty array.`,
+        coerce: jsonParse,
+        hidden: true,
+    },
+    cwd: {
+        string: true,
+        describe: `Current directory. Used to retrieve the configuration file.
+Default: current directory`,
+    },
+    repositoryRoot: {
+        string: true,
+        describe: `Git repository root directory. Used to retrieve the configuration file.
+Default: automatically guessed`,
+    },
+    output: {
+        string: true,
+        describe: `Where to output the JSON result.
+Default: "-" (stdout)`,
+    },
+    stable: {
+        boolean: true,
+        describe: `Sort keys printed in the output.
+Default: false`,
+        default: false,
+    },
+    token: {
+        string: true,
+        describe: `Netlify API token for authentication.
+The NETLIFY_AUTH_TOKEN environment variable can be used as well.`,
+    },
+    host: {
+        string: true,
+        describe: `Host of the Netlify API.`,
+        hidden: true,
+    },
+    scheme: {
+        string: true,
+        describe: `Scheme/protocol of the Netlify API.`,
+        hidden: true,
+    },
+    pathPrefix: {
+        string: true,
+        describe: `Base path prefix of the Netlify API.`,
+        hidden: true,
+    },
+    siteId: {
+        string: true,
+        describe: `Netlify Site ID.`,
+    },
+    context: {
+        string: true,
+        describe: `Build context.
+Default: 'production'`,
+    },
+    branch: {
+        string: true,
+        describe: `Repository branch.
+Default: automatically guessed`,
+    },
+    baseRelDir: {
+        boolean: true,
+        describe: `Feature flag meant for backward compatibility.
+When enabled, if the 'build.base' configuration property is defined, it is used
+to try to retrieve a second configuration file and discard the first one.
+Default: true`,
+        hidden: true,
+    },
+    mode: {
+        string: true,
+        describe: `Environment in which this is loaded. Can be:
+  - 'buildbot': within Netlify Buildbot
+  - 'cli': within Netlify CLI
+  - 'require': through import('@netlify/config')`,
+        hidden: true,
+    },
+    debug: {
+        boolean: true,
+        describe: 'Print debugging information',
+        hidden: true,
+    },
+    testOpts: {
+        describe: 'Options for testing only',
+        hidden: true,
+    },
+    featureFlags: {
+        describe: 'Comma-separated list of feature flags to enable unreleased features',
+        hidden: true,
+    },
+    offline: {
+        boolean: true,
+        describe: `Do not send requests to the Netlify API to retrieve site settings.
+Default: false`,
+    },
+    buffer: {
+        boolean: true,
+        describe: 'Buffer output instead of streaming it',
+        hidden: true,
+    },
+};
+const USAGE = `netlify-config [OPTIONS...]
+
+Retrieve and resolve the Netlify configuration.
+The result is printed as a JSON object on stdout.`;
+// Remove `yargs`-specific options, shortcuts, dash-cased and aliases
+const isUserFlag = function (key, value) {
+    return value !== undefined && !INTERNAL_KEYS.has(key) && key.length !== 1 && !key.includes('-');
+};
+const INTERNAL_KEYS = new Set(['help', 'version', '_', '$0']);

package/lib/bin/main.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { promises as fs } from 'fs';
+import { dirname } from 'path';
+import process from 'process';
+import fastSafeStringify from 'fast-safe-stringify';
+import omit from 'omit.js';
+import { isUserError } from '../error.js';
+import { resolveConfig } from '../main.js';
+import { parseFlags } from './flags.js';
+// CLI entry point
+const runCli = async function () {
+    try {
+        const { stable, output = DEFAULT_OUTPUT, ...flags } = parseFlags();
+        const result = await resolveConfig(flags);
+        await handleCliSuccess(result, stable, output);
+    }
+    catch (error) {
+        handleCliError(error);
+    }
+};
+const DEFAULT_OUTPUT = '-';
+// The result is output as JSON on success (exit code 0)
+const handleCliSuccess = async function (result, stable, output) {
+    const resultA = serializeApi(result);
+    const resultB = omit.default(resultA, SECRET_PROPERTIES);
+    const stringifyFunc = stable ? fastSafeStringify.stableStringify : JSON.stringify;
+    const resultJson = stringifyFunc(resultB, null, 2);
+    await outputResult(resultJson, output);
+    process.exitCode = 0;
+};
+const outputResult = async function (resultJson, output) {
+    if (output === '-') {
+        console.log(resultJson);
+        return;
+    }
+    await fs.mkdir(dirname(output), { recursive: true });
+    await fs.writeFile(output, resultJson);
+};
+// `api` is not JSON-serializable, so we remove it
+// We still indicate it as a boolean
+const serializeApi = function ({ api, ...result }) {
+    if (api === undefined) {
+        return result;
+    }
+    return { ...result, hasApi: true };
+};
+const SECRET_PROPERTIES = ['token'];
+const handleCliError = function (error) {
+    // Errors caused by users do not show stack traces and have exit code 1
+    if (isUserError(error)) {
+        console.error(error.message);
+        process.exitCode = 1;
+        return;
+    }
+    // Internal errors / bugs have exit code 2
+    console.error(error.stack);
+    process.exitCode = 2;
+};
+runCli();

package/{src → lib}/build_dir.js

@@ -1,26 +1,22 @@
-import { isDirectory } from 'path-type'
-
-import { throwUserError } from './error.js'
-
+import { isDirectory } from 'path-type';
+import { throwUserError } from './error.js';
 // Retrieve the build directory used to resolve most paths.
 // This is (in priority order):
 //  - `build.base`
 //  - `--repositoryRoot`
 //  - the current directory (default value of `--repositoryRoot`)
 export const getBuildDir = async function (repositoryRoot, base) {
-  const buildDir = base === undefined ? repositoryRoot : base
-  await checkBuildDir(buildDir, repositoryRoot)
-  return buildDir
-}
-
+    const buildDir = base === undefined ? repositoryRoot : base;
+    await checkBuildDir(buildDir, repositoryRoot);
+    return buildDir;
+};
 // The build directory is used as the current directory of build commands and
 // build plugins. Therefore it must exist.
 // We already check `repositoryRoot` earlier in the code, so only need to check
 // `buildDir` when it is the base directory instead.
 const checkBuildDir = async function (buildDir, repositoryRoot) {
-  if (buildDir === repositoryRoot || (await isDirectory(buildDir))) {
-    return
-  }
-
-  throwUserError(`Base directory does not exist: ${buildDir}`)
-}
+    if (buildDir === repositoryRoot || (await isDirectory(buildDir))) {
+        return;
+    }
+    throwUserError(`Base directory does not exist: ${buildDir}`);
+};

package/{src → lib}/cached_config.js

@@ -1,5 +1,4 @@
-import { promises as fs } from 'fs'
-
+import { promises as fs } from 'fs';
 // Performance optimization when @netlify/config caller has already previously
 // called it and cached the result.
 // This is used by the buildbot which:
@@ -7,23 +6,21 @@ import { promises as fs } from 'fs'
 //  - later calls @netlify/build, which runs @netlify/config under the hood
 // This is also used by Netlify CLI.
 export const getCachedConfig = async function ({ cachedConfig, cachedConfigPath, token, api }) {
-  const parsedCachedConfig = await parseCachedConfig(cachedConfig, cachedConfigPath)
-  // The CLI does not print some properties when they are not serializable or
-  // are confidential. Those will be missing from `cachedConfig`. The caller
-  // must supply them again when using `cachedConfig`.
-  return parsedCachedConfig === undefined ? undefined : { token, ...parsedCachedConfig, api }
-}
-
+    const parsedCachedConfig = await parseCachedConfig(cachedConfig, cachedConfigPath);
+    // The CLI does not print some properties when they are not serializable or
+    // are confidential. Those will be missing from `cachedConfig`. The caller
+    // must supply them again when using `cachedConfig`.
+    return parsedCachedConfig === undefined ? undefined : { token, ...parsedCachedConfig, api };
+};
 // `cachedConfig` is a plain object while `cachedConfigPath` is a file path to
 // a JSON file. The former is useful in programmatic usage while the second one
 // is useful in CLI usage, to avoid hitting the OS limits if the configuration
 // file is too big.
 const parseCachedConfig = async function (cachedConfig, cachedConfigPath) {
-  if (cachedConfig !== undefined) {
-    return cachedConfig
-  }
-
-  if (cachedConfigPath !== undefined) {
-    return JSON.parse(await fs.readFile(cachedConfigPath))
-  }
-}
+    if (cachedConfig !== undefined) {
+        return cachedConfig;
+    }
+    if (cachedConfigPath !== undefined) {
+        return JSON.parse(await fs.readFile(cachedConfigPath));
+    }
+};

package/lib/case.js

@@ -0,0 +1,18 @@
+// Some properties can be optionally capitalized. We normalize them to lowercase
+export const normalizeConfigCase = function ({ Build, build = Build, ...config }) {
+    const buildA = normalizeBuildCase(build);
+    return { ...config, build: buildA };
+};
+const normalizeBuildCase = function ({ Base, base = Base, Command, command = Command, Edge_functions: EdgeFunctions, edge_functions: edgeFunctions = EdgeFunctions, Environment, environment = Environment, Functions, functions = Functions, Ignore, ignore = Ignore, Processing, processing = Processing, Publish, publish = Publish, ...build } = {}) {
+    return {
+        ...build,
+        base,
+        command,
+        edge_functions: edgeFunctions,
+        environment,
+        functions,
+        ignore,
+        processing,
+        publish,
+    };
+};

package/lib/context.js

@@ -0,0 +1,86 @@
+import isPlainObj from 'is-plain-obj';
+import mapObj from 'map-obj';
+import { mergeConfigs } from './merge.js';
+import { normalizeBeforeConfigMerge } from './merge_normalize.js';
+import { validateContextsPluginsConfig } from './validate/context.js';
+import { validatePreContextConfig } from './validate/main.js';
+// Validate and normalize `config.context.*`
+export const normalizeContextProps = function ({ config, config: { context: contextProps }, origin }) {
+    if (contextProps === undefined) {
+        return config;
+    }
+    validatePreContextConfig(config);
+    const allContextProps = mapObj(contextProps, (key, contextConfig) => [key, addNamespace(contextConfig)]);
+    const normalizedContextProps = mapObj(allContextProps, (key, contextConfig) => [
+        key,
+        normalizeBeforeConfigMerge(contextConfig, origin),
+    ]);
+    return { ...config, context: normalizedContextProps };
+};
+// Merge `config.context.{CONTEXT|BRANCH}.*` to `config.build.*` or `config.*`
+// CONTEXT is the `--context` CLI flag.
+// BRANCH is the `--branch` CLI flag.
+export const mergeContext = function ({ config: { context: contextProps, ...config }, config: { plugins }, context, branch, logs, }) {
+    if (contextProps === undefined) {
+        return config;
+    }
+    const contexts = [context, branch];
+    validateContextsPluginsConfig({ contextProps, plugins, contexts, logs });
+    const filteredContextProps = contexts.map((key) => contextProps[key]).filter(Boolean);
+    return mergeConfigs([config, ...filteredContextProps]);
+};
+// `config.context.{context}.*` properties are merged either to `config.*` or
+// to `config.build.*`. We distinguish between both by checking the property
+// name.
+const addNamespace = (contextConfig) => Object.entries(contextConfig).reduce(addNamespacedProperty, {});
+const addNamespacedProperty = function (contextConfig, [key, value]) {
+    return isBuildProperty(key, value)
+        ? { ...contextConfig, build: { ...contextConfig.build, [key]: value } }
+        : { ...contextConfig, [key]: value };
+};
+const isBuildProperty = function (key, value) {
+    return BUILD_PROPERTIES.has(key) && !isFunctionsConfig(key, value) && !isEdgeFunctionsConfig(key, value);
+};
+// All properties in `config.build.*`
+const BUILD_PROPERTIES = new Set([
+    'base',
+    'command',
+    'edge_functions',
+    'environment',
+    'functions',
+    'ignore',
+    'processing',
+    'publish',
+]);
+// `config.functions` is a plain object while `config.build.functions` is a
+// string.
+const isFunctionsConfig = function (key, value) {
+    return key === 'functions' && isPlainObj(value);
+};
+// `config.edge_functions` is an array of objects while
+// `config.build.edge_functions` is a string.
+const isEdgeFunctionsConfig = function (key, value) {
+    return key === 'edge_functions' && Array.isArray(value);
+};
+// Ensure that `inlineConfig` has higher priority than context properties by
+// assigining it to `context.*`. Still keep it at the top-level as well since
+// some properties are not handled context-sensitively by the API.
+// Takes into account that `context.{context}.build.*` is the same as
+// `context.{context}.*`
+export const ensureConfigPriority = function ({ build = {}, ...config }, context, branch) {
+    const base = {
+        ...config,
+        build,
+    };
+    // remove the redirects to not have context specific redirects.
+    // The redirects should be only on the root level.
+    delete config.redirects;
+    return {
+        ...base,
+        context: {
+            ...config.context,
+            [context]: { ...config, ...build, build },
+            [branch]: { ...config, ...build, build },
+        },
+    };
+};

package/lib/default.js

@@ -0,0 +1,27 @@
+import { addBuildSettings } from './api/build_settings.js';
+import { logDefaultConfig } from './log/main.js';
+// Retrieve default configuration file. It has less priority and it also does
+// not get normalized, merged with contexts, etc.
+export const parseDefaultConfig = function ({ defaultConfig, base, baseRelDir, siteInfo, logs, debug }) {
+    const defaultConfigB = addDefaultConfigBase(defaultConfig, base);
+    const { defaultConfig: defaultConfigC, baseRelDir: baseRelDirA = DEFAULT_BASE_REL_DIR } = addBuildSettings({
+        defaultConfig: defaultConfigB,
+        baseRelDir,
+        siteInfo,
+    });
+    logDefaultConfig(defaultConfigC, { logs, debug, baseRelDir: baseRelDirA });
+    return { defaultConfig: defaultConfigC, baseRelDir: baseRelDirA };
+};
+// When the `base` was overridden, add it to `defaultConfig` so it behaves
+// as if it had been specified in the UI settings
+const addDefaultConfigBase = function (defaultConfig, base) {
+    if (base === undefined) {
+        return defaultConfig;
+    }
+    const { build = {} } = defaultConfig;
+    return { ...defaultConfig, build: { ...build, base } };
+};
+// `baseRelDir` should default to `true` only if the option was not passed and
+// it could be retrieved from the `siteInfo`, which is why the default value
+// is assigned later than other properties.
+const DEFAULT_BASE_REL_DIR = true;

package/lib/env/envelope.js

@@ -0,0 +1,24 @@
+export const getEnvelope = async function ({ api, accountId, siteId }) {
+    if (accountId === undefined) {
+        return {};
+    }
+    try {
+        const environmentVariables = await api.getEnvVars({ accountId, siteId });
+        const sortedEnvVarsFromDevContext = environmentVariables
+            .sort((left, right) => (left.key.toLowerCase() < right.key.toLowerCase() ? -1 : 1))
+            .reduce((acc, cur) => {
+            const envVar = cur.values.find((val) => ['dev', 'all'].includes(val.context));
+            if (envVar && envVar.value) {
+                return {
+                    ...acc,
+                    [cur.key]: envVar.value,
+                };
+            }
+            return acc;
+        }, {});
+        return sortedEnvVarsFromDevContext;
+    }
+    catch {
+        return {};
+    }
+};

package/lib/env/git.js

@@ -0,0 +1,23 @@
+import { execa } from 'execa';
+import { removeFalsy } from '../utils/remove_falsy.js';
+// Retrieve git-related information for use in environment variables.
+// git is optional and there might be not git repository.
+// We purposely keep this decoupled from the git utility.
+export const getGitEnv = async function (buildDir, branch) {
+    const [COMMIT_REF, CACHED_COMMIT_REF] = await Promise.all([
+        git(['rev-parse', 'HEAD'], buildDir),
+        git(['rev-parse', 'HEAD^'], buildDir),
+    ]);
+    const gitEnv = { BRANCH: branch, HEAD: branch, COMMIT_REF, CACHED_COMMIT_REF, PULL_REQUEST: 'false' };
+    const gitEnvA = removeFalsy(gitEnv);
+    return gitEnvA;
+};
+const git = async function (args, cwd) {
+    try {
+        const { stdout } = await execa('git', args, { cwd });
+        return stdout;
+    }
+    catch {
+        // continue regardless error
+    }
+};