@nizza/devkit 0.1.0-alpha.2 → 0.1.0-alpha.3

package/dist/esm/executors/environments/helpers.js

@@ -0,0 +1,59 @@
+import { promises } from 'fs';
+import { join } from 'path';
+import { logger } from '@nx/devkit';
+
+const { mkdir, writeFile, access } = promises;
+/**
+ * Creates the content for an environment file based on the core environment path.
+ *
+ * @param {string} coreEnvPath - The path to the core environment file.
+ * @returns {string} The content of the environment file.
+ */ async function createEnvironmentFileContent(coreEnvPath) {
+    return `
+  import { Environment } from '@nizza/core';
+  import coreEnvs from '${coreEnvPath}';
+
+  const config = {
+    ...coreEnvs,
+  };
+
+  export const environment: Environment<typeof config> = config;
+  export default environment;
+  `;
+}
+/**
+ * Ensures that the given directory exists, creating it if it does not.
+ *
+ * @param {string} dir - The path to the directory to check/create.
+ */ async function ensureDirectoryExists(dir) {
+    try {
+        await access(dir);
+        logger.info('✅ Directory exists.');
+    } catch  {
+        logger.info('📁 Directory does not exist. Creating...');
+        await mkdir(dir, {
+            recursive: true
+        });
+        logger.info('📁 Directory created.');
+    }
+}
+/**
+ * Writes environment files to the given base path if they do not already exist.
+ *
+ * @param {string} basePath - The base directory where the files should be written.
+ * @param {Record<string, string>} files - An object containing filenames and their respective content.
+ */ async function writeFilesIfNotExist(basePath, files) {
+    await Promise.all(Object.entries(files).map(async ([filename, content])=>{
+        const filePath = join(basePath, filename);
+        try {
+            await access(filePath);
+            logger.info(`✅ The file "${filename}" already exists.`);
+        } catch  {
+            logger.warn(`📝 The file "${filename}" does not exist. Creating...`);
+            await writeFile(filePath, content);
+            logger.info(`🎉 The file "${filename}" has been created.`);
+        }
+    }));
+}
+
+export { createEnvironmentFileContent, ensureDirectoryExists, writeFilesIfNotExist };

package/dist/esm/executors/environments/index.d.ts

@@ -0,0 +1,16 @@
+import { ExecutorContext } from '@nx/devkit';
+import { ExecutorResponse } from "../../index-f6330edc.js";
+interface ExecutorOptions {
+}
+/**
+ * The executor function to create environment files.
+ * Ensures that the directory for the environment files exists and creates the files
+ * if they do not exist already. Files created are 'environment.ts', 'environment.prod.ts',
+ * and 'environment.staging.ts'.
+ *
+ * @param {ExecutorOptions} _opts - Executor options, currently not used but provided for future extensibility.
+ * @param {ExecutorContext} ctx - The executor context, providing access to the project configuration.
+ * @returns {Promise<ExecutorResponse>} The result object with a success or error status.
+ */
+declare function runExecutor(_opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+export { ExecutorOptions, runExecutor as default };

package/dist/{src/executors/environments/executor.js → esm/executors/environments/index.js}

@@ -1,25 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, /**
- * The executor function to create environment files.
- * Ensures that the directory for the environment files exists and creates the files
- * if they do not exist already. Files created are 'environment.ts', 'environment.prod.ts',
- * and 'environment.staging.ts'.
- *
- * @param {ExecutorOptions} _opts - Executor options, currently not used but provided for future extensibility.
- * @param {ExecutorContext} ctx - The executor context, providing access to the project configuration.
- * @returns {Promise<ExecutorResponse>} The result object with a success or error status.
- */ "default", {
-    enumerable: true,
-    get: function() {
-        return runExecutor;
-    }
-});
-const _path = require("path");
-const _shared = require("../shared");
-const _helpers = require("./helpers");
+import { join } from 'path';
+import { getProjectConfig, ok, err } from '../shared/utils.js';
+import { ensureDirectoryExists, createEnvironmentFileContent, writeFilesIfNotExist } from './helpers.js';
+
 const ENV_DIR = 'src/environments';
 const ENV_DEV_FILE = 'environment.ts';
 const ENV_LOCAL_FILE = 'environment.local.ts';
@@ -31,21 +13,30 @@ const environmentFiles = [
     ENV_PROD_FILE,
     ENV_STAGING_FILE
 ];
-async function runExecutor(_opts, ctx) {
+/**
+ * The executor function to create environment files.
+ * Ensures that the directory for the environment files exists and creates the files
+ * if they do not exist already. Files created are 'environment.ts', 'environment.prod.ts',
+ * and 'environment.staging.ts'.
+ *
+ * @param {ExecutorOptions} _opts - Executor options, currently not used but provided for future extensibility.
+ * @param {ExecutorContext} ctx - The executor context, providing access to the project configuration.
+ * @returns {Promise<ExecutorResponse>} The result object with a success or error status.
+ */ async function runExecutor(_opts, ctx) {
     try {
-        const projectConfig = (0, _shared.getProjectConfig)(ctx);
-        const environmentsDir = (0, _path.join)(projectConfig.root, ENV_DIR);
-        await (0, _helpers.ensureDirectoryExists)(environmentsDir);
+        const projectConfig = getProjectConfig(ctx);
+        const environmentsDir = join(projectConfig.root, ENV_DIR);
+        await ensureDirectoryExists(environmentsDir);
         for (const envFileName of environmentFiles){
             const { key, path } = getEnvPath(envFileName);
-            const content = await (0, _helpers.createEnvironmentFileContent)(path);
-            await (0, _helpers.writeFilesIfNotExist)(environmentsDir, {
+            const content = await createEnvironmentFileContent(path);
+            await writeFilesIfNotExist(environmentsDir, {
                 [key]: content
             });
         }
-        return (0, _shared.ok)();
+        return ok();
     } catch (error) {
-        return (0, _shared.err)(error, `Failed to create environment files:`);
+        return err(error, `Failed to create environment files:`);
     }
 }
 function getEnvPath(fileName) {
@@ -57,3 +48,5 @@ function getEnvPath(fileName) {
         path: `@nizza/core/envs/${baseFileName.replace('.ts', '')}`
     };
 }
+
+export { runExecutor as default };

package/dist/esm/executors/environments/schema.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "version": 2,
+  "title": "Environments executor",
+  "description": "",
+  "type": "object",
+  "properties": {},
+  "required": []
+}

package/dist/esm/executors/publish/helpers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Retrieves the version of a published package with a given name and tag.
+ *
+ * @param {string} packageName The name of the package to retrieve the version for.
+ * @param {string} tag The tag to retrieve the version for.
+ * @returns The version of the package as a string or an object containing versions for each tag.
+ */
+declare function getPublishedPackageVersion(packageName: string, tag?: string): Promise<any>;
+/**
+ * Checks if a package with the given name is already published and returns its version.
+ *
+ * @param {string} packageName The name of the package to check for.
+ * @returns An object containing the published versions of the package and a flag indicating if it is the first version.
+ */
+declare function checkPublishedVersion(packageName: string): Promise<{
+    publishedVersion: any;
+    isFirstVersion: boolean;
+}>;
+export { getPublishedPackageVersion, checkPublishedVersion };

package/dist/esm/executors/publish/helpers.js

@@ -0,0 +1,48 @@
+import { logger } from '@nx/devkit';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+/**
+ * Retrieves the version of a published package with a given name and tag.
+ *
+ * @param {string} packageName The name of the package to retrieve the version for.
+ * @param {string} tag The tag to retrieve the version for.
+ * @returns The version of the package as a string or an object containing versions for each tag.
+ */ async function getPublishedPackageVersion(packageName, tag) {
+    const withTag = tag ? `.${tag}` : ' --json';
+    const command = `npm view ${packageName} dist-tags${withTag}`;
+    const { stdout, stderr } = await execAsync(command);
+    if (stderr) {
+        logger.error(stderr.trim());
+        process.exit(1);
+    }
+    const published = stdout.trim();
+    return tag ? published : JSON.parse(published);
+}
+/**
+ * Checks if a package with the given name is already published and returns its version.
+ *
+ * @param {string} packageName The name of the package to check for.
+ * @returns An object containing the published versions of the package and a flag indicating if it is the first version.
+ */ async function checkPublishedVersion(packageName) {
+    let publishedVersion;
+    let isFirstVersion = false;
+    try {
+        publishedVersion = await getPublishedPackageVersion(packageName);
+    } catch (err) {
+        if (err?.message.includes('code E404')) {
+            isFirstVersion = true;
+            logger.info(`🏁 This is the first version of "${packageName}" package. \n`);
+        } else {
+            logger.error('❌ Error when checking the last published versions \n');
+            throw err;
+        }
+    }
+    return {
+        publishedVersion,
+        isFirstVersion
+    };
+}
+
+export { checkPublishedVersion, getPublishedPackageVersion };

package/dist/esm/executors/publish/index.d.ts

@@ -0,0 +1,12 @@
+import { ExecutorContext } from '@nx/devkit';
+import { ExecutorResponse } from "../../index-f6330edc.js";
+interface ExecutorOptions {
+    tag: string;
+    dryRun?: boolean;
+}
+/**
+ * This is a minimal script to publish package to "npm".
+ * Need to authenticate with NPM before running this script.
+ */
+declare function runExecutor(opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+export { ExecutorOptions, runExecutor as default };

package/dist/esm/executors/publish/index.js

@@ -0,0 +1,51 @@
+import { logger } from '@nx/devkit';
+import semver from 'semver';
+import '../../shared/logger.js';
+import { getPkgJson } from '../../shared/utils.js';
+import { getProjectConfig, runCommand, ok, err } from '../shared/utils.js';
+import { checkPublishedVersion } from './helpers.js';
+
+/**
+ * This is a minimal script to publish package to "npm".
+ * Need to authenticate with NPM before running this script.
+ */ async function runExecutor(opts, ctx) {
+    try {
+        const { tag, dryRun: isDryRun } = opts;
+        const { root: projectRoot } = getProjectConfig(ctx);
+        // Read the package.json file and extract the name and version.
+        const packageJson = getPkgJson(projectRoot);
+        const { name: packageName, version: packageVersion } = packageJson;
+        // Check if the package has been previously published and get the published version.
+        const { publishedVersion, isFirstVersion } = await checkPublishedVersion(packageName);
+        let greaterThanTagVersion, greaterThanLatestVersion;
+        if (!isFirstVersion) {
+            // Check if the package version is greater than the latest published version for the specified tag.
+            greaterThanTagVersion = publishedVersion?.[tag] ? semver.gt(packageVersion, publishedVersion?.[tag]) : true;
+            // Check if the package version is greater than the latest published version.
+            greaterThanLatestVersion = semver.gt(packageVersion, publishedVersion.latest);
+            console.log(`🔎 package.json version: ${packageVersion}`);
+            console.log('🔺 published versions:');
+            Object.entries(publishedVersion).forEach(([k, v])=>console.log(`   * ${k}: ${v}`));
+            console.log('\n');
+        }
+        // Publish the package if it's the first version or if it's a new version.
+        const needsPublish = isFirstVersion || greaterThanLatestVersion && greaterThanTagVersion;
+        if (needsPublish) {
+            const dryRun = isDryRun ? '--dry-run' : '';
+            const commandToPublish = `pnpm publish --access public --tag ${tag} --no-git-checks ${dryRun}`;
+            isDryRun && logger.info('👀 Skip publish (dry run) \n');
+            logger.info(`${commandToPublish} \n`);
+            // Execute the command to publish the package.
+            // process.chdir(projectRoot);
+            await runCommand(commandToPublish, projectRoot);
+            logger.info(`\n🚀 Successfully published ${packageName}@${packageVersion}`);
+        } else {
+            logger.warn(`👻 Package version "${packageVersion}" is invalid.`);
+        }
+        return ok();
+    } catch (error) {
+        return err(error, '❌ Error when publishing the package');
+    }
+}
+
+export { runExecutor as default };

package/dist/esm/executors/publish/schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "version": 2,
+  "title": "Publish executor",
+  "description": "",
+  "type": "object",
+  "properties": {
+    "tag": {
+      "type": "string",
+      "description": "Tag name to publish"
+    },
+    "dryRun": {
+      "type": "boolean",
+      "description": "Indicates whether a test execution should be done without really publishing",
+      "default": false
+    }
+  },
+  "required": ["tag"]
+}

package/dist/esm/executors/shared/utils.d.ts

@@ -0,0 +1,34 @@
+import { ExecutorContext, ProjectConfiguration } from '@nx/devkit';
+import { ExecutorResponse } from "../../types-7377dcc9.js";
+/**
+ * Indicates a successful executor operation.
+ *
+ * @param {string} message - Optional message to log for the success case.
+ * @returns {ExecutorResponse} - An object representing a successful operation.
+ */
+declare function ok(message?: string): ExecutorResponse;
+/**
+ * Indicates a failed executor operation.
+ *
+ * @param {string | Error | unknown} err - An optional error object or message indicating the nature of the failure.
+ * @param {string} message - An optional message to log for the error case. If not provided, a default error message is logged.
+ * @returns {ExecutorResponse} - An object representing a failed operation.
+ */
+declare function err(err?: string | Error | unknown, message?: string): ExecutorResponse;
+/**
+ * Generates a random alphanumeric identifier of a specified length.
+ *
+ * @param {number} [length=8] - The length of the identifier to generate. Defaults to 8 if not specified.
+ * @returns {string} - A string representing a unique identifier.
+ */
+declare function shortId(length?: number): string;
+/**
+ * Retrieves the project configuration for the current execution context.
+ *
+ * @param {ExecutorContext} ctx - The execution context containing project information.
+ * @returns {ProjectConfiguration} - The configuration object for the current project.
+ * @throws {Error} If the project configuration is invalid or not found.
+ */
+declare function getProjectConfig(ctx: ExecutorContext): ProjectConfiguration;
+declare function runCommand(command: string, cwd?: string | URL): Promise<void>;
+export { ok, err, shortId, getProjectConfig, runCommand };

package/dist/esm/executors/shared/utils.js

@@ -0,0 +1,72 @@
+import { logger } from '@nx/devkit';
+import { randomBytes } from 'crypto';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+/**
+ * Indicates a successful executor operation.
+ *
+ * @param {string} message - Optional message to log for the success case.
+ * @returns {ExecutorResponse} - An object representing a successful operation.
+ */ function ok(message) {
+    message && logger.info(message);
+    return {
+        success: true
+    };
+}
+/**
+ * Indicates a failed executor operation.
+ *
+ * @param {string | Error | unknown} err - An optional error object or message indicating the nature of the failure.
+ * @param {string} message - An optional message to log for the error case. If not provided, a default error message is logged.
+ * @returns {ExecutorResponse} - An object representing a failed operation.
+ */ function err(err, message) {
+    if (message) {
+        logger.error(message);
+    } else {
+        logger.error(`❌ an error occurred:`);
+    }
+    if (err) logger.error(err);
+    return {
+        success: false
+    };
+}
+/**
+ * Generates a random alphanumeric identifier of a specified length.
+ *
+ * @param {number} [length=8] - The length of the identifier to generate. Defaults to 8 if not specified.
+ * @returns {string} - A string representing a unique identifier.
+ */ function shortId(length = 8) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    return Array.from(randomBytes(length), (b)=>chars[b % chars.length]).join('');
+}
+/**
+ * Retrieves the project configuration for the current execution context.
+ *
+ * @param {ExecutorContext} ctx - The execution context containing project information.
+ * @returns {ProjectConfiguration} - The configuration object for the current project.
+ * @throws {Error} If the project configuration is invalid or not found.
+ */ function getProjectConfig(ctx) {
+    const projectName = ctx.projectName || '';
+    const projectConfig = ctx.projectsConfigurations?.projects?.[projectName];
+    if (!projectConfig) throw new Error('Invalid project configuration.');
+    return projectConfig;
+}
+async function runCommand(command, cwd) {
+    try {
+        const { stdout, stderr } = await execAsync(command, {
+            ...cwd && {
+                cwd
+            }
+        });
+        logger.info(stdout);
+        logger.info(stderr);
+    } catch (error) {
+        logger.error(`Unexpected error running command:`);
+        logger.error(error);
+        throw error;
+    }
+}
+
+export { err, getProjectConfig, ok, runCommand, shortId };

package/dist/esm/executors/update-executors-file/helpers.d.ts

@@ -0,0 +1,25 @@
+import { Executors } from "../../types-763439e4.js";
+/**
+ * Transforms the given path by adding or removing the './dist/' prefix
+ * and ensuring that it has the '.js' extension if it's not a JSON file.
+ *
+ * @param {string} path - The original file path to transform.
+ * @param {boolean} removeDist - Flag to determine if './dist/' should be removed.
+ * @returns {string} The transformed file path.
+ */
+declare const transformPathToRoot: (path: string) => string;
+declare const transformPathToDist: (path: string) => string;
+/**
+ * Updates the executor paths for the provided executors object.
+ * @param {Executors} executors - The executors object from executors.json.
+ * @param {boolean} toDist - Flag to determine if './dist' should be removed from paths.
+ * @returns - The updated executors object with transformed paths.
+ */
+declare const updateExecutorPaths: (executors: Executors, toDist: boolean) => Executors;
+/**
+ * Writes a JSON file asynchronously.
+ * @param {string} path - The file path where to write the JSON data.
+ * @param {any} data - The data to be written to the file.
+ */
+declare const writeJsonFileAsync: (path: string, data: any) => Promise<void>;
+export { transformPathToRoot, transformPathToDist, updateExecutorPaths, writeJsonFileAsync };

package/dist/esm/executors/update-executors-file/helpers.js

@@ -0,0 +1,71 @@
+import { logger } from '@nx/devkit';
+import { promises } from 'fs';
+import { cond, always, T, endsWith, test, pipe } from 'ramda';
+
+const { writeFile } = promises;
+/**
+ * Transforms the given path by adding or removing the './dist/' prefix
+ * and ensuring that it has the '.js' extension if it's not a JSON file.
+ *
+ * @param {string} path - The original file path to transform.
+ * @param {boolean} removeDist - Flag to determine if './dist/' should be removed.
+ * @returns {string} The transformed file path.
+ */ const transformPathToRoot = (path)=>{
+    const distPrefix = './dist/cjs/';
+    const srcRegex = /^\.\/src\//;
+    const distRegex = /^\.\/dist\//;
+    const jsExt = '.js';
+    endsWith(jsExt, path);
+    const isJson = endsWith('.json', path);
+    test(distRegex, path);
+    // Adds './dist/' prefix to the path if it's not already present.
+    const changeSrcPath = (p)=>p.replace(srcRegex, distPrefix);
+    // Adds '.js' extension to the path if it's not a JSON file and doesn't have the extension already.
+    const changeFileName = (p)=>isJson ? p : p.replace(/executor\.ts$/, 'index.js');
+    return pipe(changeSrcPath, changeFileName)(path);
+};
+const transformPathToDist = (path)=>{
+    const cjsPrefix = './cjs/';
+    const distRegex = /^\.\/dist\/cjs\//;
+    const changeDistPath = (p)=>p.replace(distRegex, cjsPrefix);
+    return changeDistPath(path);
+};
+/**
+ * Updates the executor paths for the provided executors object.
+ * @param {Executors} executors - The executors object from executors.json.
+ * @param {boolean} toDist - Flag to determine if './dist' should be removed from paths.
+ * @returns - The updated executors object with transformed paths.
+ */ const updateExecutorPaths = (executors, toDist)=>{
+    const transform = cond([
+        [
+            always(toDist),
+            transformPathToDist
+        ],
+        [
+            T,
+            transformPathToRoot
+        ]
+    ]);
+    return Object.entries(executors).reduce((updatedExecutors, [key, executor])=>{
+        updatedExecutors[key] = {
+            ...executor,
+            implementation: transform(executor.implementation),
+            schema: transform(executor.schema)
+        };
+        return updatedExecutors;
+    }, {});
+};
+/**
+ * Writes a JSON file asynchronously.
+ * @param {string} path - The file path where to write the JSON data.
+ * @param {any} data - The data to be written to the file.
+ */ const writeJsonFileAsync = async (path, data)=>{
+    try {
+        await writeFile(path, JSON.stringify(data, null, 2));
+        logger.info(`✅ Updated: ${path}`);
+    } catch (error) {
+        logger.error(`❌ Error writing file ${path}: ${error}`);
+    }
+};
+
+export { transformPathToDist, transformPathToRoot, updateExecutorPaths, writeJsonFileAsync };

package/dist/esm/executors/update-executors-file/index.d.ts

@@ -0,0 +1,12 @@
+import { ExecutorContext } from '@nx/devkit';
+import { ExecutorResponse } from "../../index-f6330edc.js";
+import { ExecutorOptions } from "../../types-763439e4.js";
+/**
+ * Executor function to update paths in the executors.json file.
+ *
+ * @param {ExecutorOptions} _opts - Executor options, currently not used but provided for future extensibility.
+ * @param {ExecutorContext} ctx - The executor context, providing access to the project configuration.
+ * @returns {Promise<ExecutorResponse>} The result object with a success or error status.
+ */
+declare function runExecutor(_opts: ExecutorOptions, ctx: ExecutorContext): Promise<ExecutorResponse>;
+export { runExecutor as default };

package/dist/esm/executors/update-executors-file/index.js

@@ -0,0 +1,39 @@
+import { promises } from 'fs';
+import { join } from 'path';
+import { getProjectConfig, ok, err } from '../shared/utils.js';
+import { updateExecutorPaths, writeJsonFileAsync } from './helpers.js';
+
+const { readFile } = promises;
+/**
+ * Executor function to update paths in the executors.json file.
+ *
+ * @param {ExecutorOptions} _opts - Executor options, currently not used but provided for future extensibility.
+ * @param {ExecutorContext} ctx - The executor context, providing access to the project configuration.
+ * @returns {Promise<ExecutorResponse>} The result object with a success or error status.
+ */ async function runExecutor(_opts, ctx) {
+    try {
+        const projectConfig = getProjectConfig(ctx);
+        const rootDir = projectConfig.root;
+        const executorsFilePath = join(rootDir, 'executors.json');
+        const distExecutorsFilePath = join(rootDir, 'dist', 'executors.json');
+        const originalContent = JSON.parse(await readFile(executorsFilePath, 'utf8'));
+        // Update paths to point to './dist/' and add '.js'
+        const updatedExecutors = updateExecutorPaths(originalContent.executors, false);
+        // Prepare the version for the dist folder by removing './dist/' from paths
+        const distExecutors = updateExecutorPaths(updatedExecutors, true);
+        // Write both files asynchronously and in parallel
+        await Promise.all([
+            writeJsonFileAsync(executorsFilePath, {
+                executors: updatedExecutors
+            }),
+            writeJsonFileAsync(distExecutorsFilePath, {
+                executors: distExecutors
+            })
+        ]);
+        return ok(`🚀 Executors updated successfully.`);
+    } catch (error) {
+        return err(error, `❌ Error processing file: ${error}`);
+    }
+}
+
+export { runExecutor as default };

package/dist/esm/executors/update-executors-file/schema.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "version": 2,
+  "title": "UpdateExecutorsFile executor",
+  "description": "",
+  "type": "object",
+  "properties": {},
+  "required": []
+}

package/dist/esm/executors/vtex-link/constants.d.ts

@@ -0,0 +1,4 @@
+declare const VTEX_PROJECT_PATH: string | undefined;
+declare const ERROR_LINKING_FLAG = "[31merror\u001B[39m: App build failed";
+declare const SUCCESS_LINKING_FLAG = "[32minfo\u001B[39m: App running";
+export { VTEX_PROJECT_PATH, ERROR_LINKING_FLAG, SUCCESS_LINKING_FLAG };

package/dist/esm/executors/vtex-link/constants.js

@@ -0,0 +1,5 @@
+const VTEX_PROJECT_PATH = process.env.NZ_VTEX_PROJECT;
+const ERROR_LINKING_FLAG = '[31merror: App build failed';
+const SUCCESS_LINKING_FLAG = '[32minfo: App running';
+
+export { ERROR_LINKING_FLAG, SUCCESS_LINKING_FLAG, VTEX_PROJECT_PATH };