bpm-core 0.0.126 → 0.0.128

package/README.md

@@ -3,10 +3,145 @@
 
 > Ensure your project is updated to Angular 19 to avoid compatibility issues.
 
-## Recently Added Features
-- ### Time Picker
+## [Recently Added Features](#recently-added-features)
+- ### [BPM Core CLI](#bpm-core-cli)
+  A command-line interface tool that provides helper scripts to speed up common tasks.
+
+  Run the tool using the `bpm-core` command in your terminal.  
+  To see all available commands, run:
+
+  ```bash
+  bpm-core --help
+  ```
+
+  The BPM Core CLI includes several helper scripts. You can run any script using its corresponding command.
+
+  Below is the available commands:
+
+  ---
+
+  - `deploy`  
+    Use this command to deploy your service (currently supports only **library services**) to one of the following environments: `dev`, `sit`, or `bat`.
+
+    The deployment process includes:
+    - Running the Angular build  
+    - Syncing with the remote repository  
+    - Triggering a Jenkins job
+
+    **Example usage**  
+    In your terminal, navigate to the service directory and run the following command:
+
+    ```bash
+    bpm-core deploy --env sit --repo-path D:\stc\build\sit --commit-msg "COW: correct typo in Arabic translation" --remote-dir "cow-new" --username jenkinsUserName --token jenkinsTokenOrPassword
+    ```
+
+    **For more details about available options**, run:
+
+    ```bash
+    bpm-core deploy --help
+    ```
+
+
+- ### [Input Mapping and Filtering](#input-mapping-and-filtering)
+  The `app-input` component now supports two powerful inputs:
+
+  - **`[mapFn]`** — A function that modifies the input value **before it's rendered**, allowing for transformations like uppercase conversion, formatting, or character replacement.
+  - **`[filterFn]`** — A function that validates or restricts what characters can be typed, pasted, or dropped into the input.
+  
+  **Built-in Utility Classes Provided:**
+  >
+  > - `InputFilters`:
+  >   - `InputFilters.arabicOnly`
+  >   - `InputFilters.englishOnly`
+  >   - `InputFilters.digitsOnly`
+  >   - `InputFilters.buildPattern()`
+  >
+  > - `InputMappers`:
+  >   - `InputMappers.toUpperCase`
+  >   - `InputMappers.toLowerCase`
+
+  **Examples:**
+  - Example 1: Custom filter – Allow only numbers
+    ```ts
+    numbersOnlyFilter: InputFilterFn = (char, current, next, event) => {
+      return /^[0-9]+$/.test(char);
+    };
+    ```
+    ```html
+    <app-input
+      label="Phone Number"
+      [filterFn]="numbersOnlyFilter"
+    ></app-input>
+    ```
+
+  - Example 2: Built-in filter – Arabic-only characters
+    ```ts
+    import { InputFilters } from 'bpm-core';
+
+    class MyComponent {
+      InputFilters = InputFilters;
+    }
+    ```
+    ```html
+    <app-input
+      label="الاسم بالعربية"
+      [filterFn]="InputFilters.arabicOnly"
+    ></app-input>
+    ```
+    > 💡 **Hint:** Use `InputFilters.buildPattern()` when you need to **customize exactly which characters are allowed** in an input.  
+    > You can combine multiple character groups like Arabic letters, digits, symbols, and spaces then generate a custom filter function using `.build()`.
+
+  - Example 3: Custom filter using `buildPattern()` — Allow English letters, digits, spaces, and symbols
+
+    ```ts
+    import { InputFilters } from 'bpm-core';
+
+    class MyComponent {
+      customEnglishFilter = InputFilters.buildPattern()
+        .allowEnglishAlphabets()
+        .allowDigits()
+        .allowSpace()
+        .allowSymbols()
+        .build();
+    }
+    ```
+    ```html
+    <app-input
+      label="Username"
+      [filterFn]="customEnglishFilter"
+    ></app-input>
+    ```
+  - Example 4: Custom map — Capitalize first letter of each word
+    ```ts
+    capitalizeWordsMapFn: InputMapFn = (char, current, next) => {
+      return next.replace(/\b\w/g, (match) => match.toUpperCase());
+    };
+    ```
+    ```html
+    <app-input
+      label="Full Name"
+      [mapFn]="capitalizeWordsMapFn"
+    ></app-input>
+    ```
+
+  - Example 5: Built-in map — Force lowercase
+    ```ts
+    import { InputMappers } from 'bpm-core';
+
+    class MyComponent {
+      InputMappers = InputMappers;
+    }
+    ```
+    ```html
+    <app-input
+      label="Email"
+      [mapFn]="InputMappers.toLowercase"
+    ></app-input>
+    ```
+
+- ### [Time Picker](#time-picker) 
   To use it, import `TimepickerComponent` in your TypeScript file and add `<app-timepicker>` to your template. For more information, hover over the selector after adding it to your template.
-- ### Summary Section / Stage  
+- ### [Summary Section](#summary-section)  
   This is a stage that appears before the request stage.
 
   To enable this feature:
@@ -63,17 +198,27 @@
   ```
   </details> 
 
-## Changes Log
+## [Changes Log](#changes-log)
+
+<a id="bpm-core00128-2025-08-25"></a>
+### [bpm-core@0.0.128 — 2025-08-25](#bpm-core00128-2025-08-25)
+- feat(cli): implement BPM Core CLI with deploy command.
+- refactor(app-input): remove keyType parameter from filter function.
+
+<a id="bpm-core00127-2025-08-06"></a>
+### [bpm-core@0.0.127 — 2025-08-06](#bpm-core00127-2025-08-06)
+- feat(app-input): `app-input` now supports `filterFn` and `mapFn` inputs.
+- feat(validation-errors): Added default error messages for `max` and `min` validators.
 
 <a id="bpm-core00126-2025-07-30"></a>
 ### [bpm-core@0.0.126 — 2025-07-30](#bpm-core00126-2025-07-30)
-- Fix (file-uploader): avoid clearing attachments with multiple enabled.
-- Fix (file-uploader): activate "maxLength" input to specify maximum number of files
-- Fix (attachment-section): resolve _intl console error and translate MatPaginator labels to Arabic.
+- fix(file-uploader): avoid clearing attachments with multiple enabled.
+- fix(file-uploader): activate "maxLength" input to specify maximum number of files
+- fix(attachment-section): resolve _intl console error and translate MatPaginator labels to Arabic.
 
 <a id="bpm-core00125-2025-07-23"></a>
 ### [bpm-core@0.0.125 — 2025-07-23](#bpm-core00125-2025-07-23)
-- Fix: resolve issue with downloading attachments from comments history.
+- fix: resolve issue with downloading attachments from comments history.
 
 <a id="bpm-core00124-2025-07-17"></a>
 ### [bpm-core@0.0.124 — 2025-07-17](#bpm-core00124-2025-07-17)

package/cli/deploy/build.js

@@ -0,0 +1,62 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LibraryBuild = exports.Build = void 0;
+const utilities_1 = require("./utilities");
+const fs = __importStar(require("fs"));
+class Build {
+    constructor() { }
+    async runBuild(servicePath) {
+        await this.runNgBuild(servicePath);
+        this.renameBuildFiles(servicePath);
+        this.removeUnneededBuildFiles(servicePath);
+    }
+}
+exports.Build = Build;
+class LibraryBuild extends Build {
+    runNgBuild(servicePath) {
+        return (0, utilities_1.runCommand)('npx ng build --aot -c production --output-hashing none', servicePath);
+    }
+    isWebpackBuildRequired() {
+        return false;
+    }
+    renameBuildFiles(servicePath) {
+        const filesToRenameAfterBuild = [
+            { from: `${servicePath}/dist/main.js`, to: `${servicePath}/dist/wm-main.bundle.js` },
+            { from: `${servicePath}/dist/styles.css`, to: `${servicePath}/dist/wm-styles.bundle.css` },
+            { from: `${servicePath}/dist/polyfills.js`, to: `${servicePath}/dist/wm-polyfills.bundle.js` },
+            { from: `${servicePath}/dist/scripts.js`, to: `${servicePath}/dist/wm-scripts.bundle.js` },
+            { from: `${servicePath}/dist/runtime.js`, to: `${servicePath}/dist/wm-inline.bundle.js` }
+        ];
+        filesToRenameAfterBuild.forEach(item => fs.renameSync(item.from, item.to));
+    }
+    removeUnneededBuildFiles(servicePath) {
+        const scssDirPath = `${servicePath}/dis/assets/scss`;
+        if (fs.existsSync(scssDirPath)) {
+            fs.rmdirSync(scssDirPath, { recursive: true });
+        }
+    }
+}
+exports.LibraryBuild = LibraryBuild;

package/cli/deploy/git-operations-handler.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitOperationsHandler = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const child_process_1 = require("child_process");
+const utilities_1 = require("./utilities");
+class GitOperationsHandler {
+    constructor() { }
+    async sync(localBuildRepoPath, serviceRemoteDir, servicePath, commitMessage, logger, env) {
+        if (await this.getCurrentBranch(localBuildRepoPath) !== env) {
+            throw new Error(`Current branch in build repo is not "${env}". Please switch to the correct branch and try again.`);
+        }
+        logger.log('Pulling latest changes from remote repo...');
+        await this.pull(localBuildRepoPath);
+        logger.log('Copying build files to service directory in build repo...');
+        await this.copyBuildFilesToServiceDirInBuildRepo(localBuildRepoPath, serviceRemoteDir, servicePath);
+        logger.log(`Files copied from "${servicePath}" to "${path.join(localBuildRepoPath, serviceRemoteDir)}".`);
+        logger.log('Committing changes to local build repo...');
+        await this.commit(localBuildRepoPath, commitMessage);
+        logger.log('Pushing changes to remote repo...');
+        await this.push(localBuildRepoPath);
+    }
+    async pull(localBuildRepoPath) {
+        return await (0, utilities_1.runCommand)('git pull', localBuildRepoPath);
+    }
+    copyBuildFilesToServiceDirInBuildRepo(localBuildRepoPath, serviceDirNameInBuildRepo, servicePath) {
+        const from = path.join(servicePath, 'dist');
+        const to = path.join(localBuildRepoPath, serviceDirNameInBuildRepo);
+        return this.copyFiles(from, to);
+    }
+    async commit(localBuildRepoPath, commitMessage) {
+        const execAsync = (0, util_1.promisify)(child_process_1.exec);
+        try {
+            const { stdout: status } = await execAsync('git status --porcelain', { cwd: localBuildRepoPath });
+            if (status.trim().length === 0) {
+                throw new Error('No changes to commit');
+            }
+            await execAsync('git add .', { cwd: localBuildRepoPath });
+            await execAsync(`git commit -m "${commitMessage}"`, { cwd: localBuildRepoPath });
+        }
+        catch (error) {
+            throw new Error('Failed to commit', { cause: error });
+        }
+    }
+    push(localBuildRepoPath) {
+        return (0, utilities_1.runCommand)('git push', localBuildRepoPath);
+    }
+    async copyFiles(srcDir, destDir) {
+        try {
+            await fs.promises.mkdir(destDir, { recursive: true });
+            const items = await fs.promises.readdir(srcDir, { withFileTypes: true });
+            for (const item of items) {
+                const srcPath = path.join(srcDir, item.name);
+                const destPath = path.join(destDir, item.name);
+                if (item.isDirectory()) {
+                    await this.copyFiles(srcPath, destPath);
+                }
+                else {
+                    await fs.promises.copyFile(srcPath, destPath);
+                }
+            }
+        }
+        catch (error) {
+            const errorMsg = `Error copying files: ${error.message}`;
+            throw Error(errorMsg);
+        }
+    }
+    async getCurrentBranch(localBuildRepoPath) {
+        const execAsync = (0, util_1.promisify)(child_process_1.exec);
+        try {
+            const { stdout: currentBranch } = await execAsync('git rev-parse --abbrev-ref HEAD', { cwd: localBuildRepoPath });
+            return currentBranch.trim();
+        }
+        catch (error) {
+            throw new Error('Failed to get current branch', { cause: error });
+        }
+    }
+}
+exports.GitOperationsHandler = GitOperationsHandler;

package/cli/deploy/index.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployCommand = void 0;
+const path = __importStar(require("path"));
+const commander_1 = require("commander");
+const build_1 = require("./build");
+const git_operations_handler_1 = require("./git-operations-handler");
+const jenkins_manager_1 = require("./jenkins-manager");
+const utilities_1 = require("./utilities");
+exports.deployCommand = new commander_1.Command('deploy');
+exports.deployCommand
+    .description('Deploy a service to a specific environment, deployment process includes building the service, syncing with the remote repository, and running a Jenkins job if credentials are provided.')
+    .requiredOption('--env <string>', 'The env you want to deploy to it (dev, sit, or bat)')
+    .requiredOption('--repo-path <string>', 'The path for the local build repo make sure it is switched to env branch you want to deploy to it')
+    .requiredOption('--commit-msg <string>', 'The commit message for the changes you want to commit to the build repo')
+    .requiredOption('--remote-dir <string>', 'The remote directory name in the build repo where the service files will be copied to')
+    .option('--skip-build', 'Skip Angular build (optional)', false)
+    .option('--username <string>', 'Jenkins username (optional, if not provided Jenkins job will not run)')
+    .option('--token <string>', 'Jenkins token or password (optional, if not provided Jenkins job will not run)')
+    .action(async (options) => {
+    const cwd = process.cwd();
+    const serviceName = path.basename(cwd);
+    const env = (0, utilities_1.parseEnv)(options.env);
+    const logger = new utilities_1.Logger();
+    try {
+        if (!options.skipBuild) {
+            await logger.asyncLog('Building...')(new build_1.LibraryBuild().runBuild(cwd), 'Build Done.', 'Build Failed.');
+        }
+        await logger.asyncLog('Syncing with the remote repo...')(new git_operations_handler_1.GitOperationsHandler().sync(options.repoPath, options.remoteDir, cwd, options.commitMsg, logger, env), 'Sync Done.', 'Sync Failed.');
+        if (options.username && options.token) {
+            await logger.asyncLog('Running Jenkins job...')(new jenkins_manager_1.JenkinsManager().run(options.username, options.token, env, logger), 'Jenkins Job Done.', 'Failed to run Jenkins job.');
+            logger.success(`${serviceName.toLocaleUpperCase()} deployed to ${options.env.toUpperCase()} successfully.`);
+        }
+    }
+    catch (err) {
+        console.log(`${err.message} ${(err.cause?.message || err.cause) ? 'because ' + (err.cause?.message || err.cause) : ''}`);
+    }
+});

package/cli/deploy/jenkins-manager.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JenkinsManager = void 0;
+class JenkinsManager {
+    async run(username, token, env, logger) {
+        const jobName = this.getJobName(env);
+        try {
+            const buildNumber = await this.triggerJenkinsAndGetBuildNumber(username, token, jobName, logger);
+            await this.waitForBuildToFinish(buildNumber, username, token, jobName, logger);
+        }
+        catch (err) {
+            throw new Error(`Failed to run Jenkins job`, { cause: err });
+        }
+    }
+    async triggerJenkinsAndGetBuildNumber(username, token, jobName, logger) {
+        const JENKINS_URL = 'http://172.20.151.119:9090';
+        const auth = btoa(`${username}:${token}`);
+        try {
+            const triggerResponse = await fetch(`${JENKINS_URL}/job/${jobName}/build`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Basic ${auth}`
+                },
+                redirect: 'manual'
+            });
+            if (triggerResponse.status !== 201) {
+                throw new Error(`Failed to trigger build:, ${triggerResponse.statusText}`);
+            }
+            const queueUrl = triggerResponse.headers.get('Location');
+            if (!queueUrl) {
+                throw new Error('No queue URL returned');
+            }
+            logger.log(`Build queued.`);
+            let buildNumber = null;
+            const maxAttempts = 20;
+            const delay = 3000;
+            for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                const queueRes = await fetch(`${queueUrl}api/json`, {
+                    headers: {
+                        'Authorization': `Basic ${auth}`
+                    }
+                });
+                const queueData = await queueRes.json();
+                if (queueData.executable && queueData.executable.number) {
+                    buildNumber = queueData.executable.number;
+                    break;
+                }
+                logger.log(`Waiting for build to start... (${attempt + 1})`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+            if (buildNumber) {
+                logger.log(`Build started with number: ${buildNumber}`);
+                return buildNumber;
+            }
+            else {
+                throw new Error('Failed to get build number.');
+            }
+        }
+        catch (err) {
+            throw new Error(`Error triggering Jenkins build: ${err.message}`);
+        }
+    }
+    async waitForBuildToFinish(buildNumber, username, token, jobName, logger) {
+        const JENKINS_URL = 'http://172.20.151.119:9090';
+        const auth = btoa(`${username}:${token}`);
+        const maxAttempts = 40;
+        const delay = 5000;
+        for (let i = 0; i < maxAttempts; i++) {
+            const res = await fetch(`${JENKINS_URL}/job/${jobName}/${buildNumber}/api/json`, {
+                headers: {
+                    'Authorization': `Basic ${auth}`
+                }
+            });
+            const data = await res.json();
+            if (!data.building) {
+                const result = data.result;
+                if (result === 'SUCCESS') {
+                    logger.log(`Build #${buildNumber} completed successfully.`);
+                    return data;
+                }
+                else {
+                    throw new Error(`Build #${buildNumber} failed.`);
+                }
+            }
+            logger.log(`Build #${buildNumber} is still running... (${i + 1})`);
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+        return null;
+    }
+    getJobName(env) {
+        if (!env) {
+            throw new Error('Environment is required to get the job name');
+        }
+        env = env.toLowerCase();
+        const jobNameMap = {
+            dev: 'wmbpm-web-dev',
+            sit: 'wmbpm-web-sit',
+            bat: 'wmbpm-web-bat'
+        };
+        const jobName = jobNameMap[env];
+        if (!jobName) {
+            throw new Error(`No job name found for environment: ${env}`);
+        }
+        return jobName;
+    }
+}
+exports.JenkinsManager = JenkinsManager;

package/cli/deploy/utilities.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+exports.runCommand = runCommand;
+exports.parseEnv = parseEnv;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const readline = __importStar(require("readline"));
+function runCommand(command, pathToRunIn) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, {
+            stdio: ['inherit', 'pipe', 'pipe'],
+            shell: true,
+            cwd: pathToRunIn
+        });
+        let stderrData = '';
+        let stdoutData = '';
+        child.stdout && child.stdout.on('data', data => {
+            stdoutData += data.toString();
+        });
+        child.stderr && child.stderr.on('data', (data) => {
+            stderrData += data.toString();
+        });
+        child.on('exit', function (code, signal) {
+            const isBundleExceededError = stderrData.includes('bundle initial exceeded maximum budget');
+            if (code === 0 || isBundleExceededError) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Failed to run command "${command}" on path "${pathToRunIn}"`, { cause: stderrData }));
+            }
+        });
+        child.on('error', (err) => {
+            reject(new Error(`Failed to run command "${command}" on path "${pathToRunIn}"`, { cause: stderrData }));
+        });
+    });
+}
+function parseEnv(env) {
+    const allEnvs = ['dev', 'sit', 'bat'];
+    if (typeof env === 'string' && allEnvs.includes(env.toLowerCase())) {
+        return env.toLowerCase();
+    }
+    throw new Error(`Invalid environment: ${env}. Valid options are: ${allEnvs.join(', ')}.`);
+}
+class Logger {
+    loading(msg) {
+        this.currentLoadingMsg = msg;
+        const spinnerChars = ['|', '/', '-', '\\'];
+        let current = 0;
+        this.intervalId = setInterval(() => {
+            process.stdout.write(`\r${spinnerChars[current]} ${chalk_1.default.yellow(msg)}`);
+            current = (current + 1) % spinnerChars.length;
+        }, 100);
+    }
+    log(msg, useDefaultColor = true) {
+        this.stopLoading();
+        console.log(useDefaultColor ? chalk_1.default.dim(msg) : msg);
+        this.loading(this.currentLoadingMsg);
+    }
+    success(msg) {
+        this.stopLoading();
+        process.stdout.write(`${chalk_1.default.bold.green('✔ ' + msg)}\n`);
+    }
+    error(msg) {
+        this.stopLoading();
+        process.stdout.write(`${chalk_1.default.bold.red('X ' + msg)}\n`);
+    }
+    asyncLog(loadingMsg) {
+        this.loading(loadingMsg);
+        return async (promise, successMsg, failedMsg) => {
+            try {
+                await promise;
+                this.success(successMsg);
+            }
+            catch (err) {
+                this.error(failedMsg);
+                throw err;
+            }
+        };
+    }
+    stopLoading() {
+        readline.clearLine(process.stdout, 0);
+        readline.cursorTo(process.stdout, 0);
+        if (this.intervalId)
+            clearInterval(this.intervalId);
+    }
+}
+exports.Logger = Logger;

package/cli/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const deploy_1 = require("./deploy");
+const program = new commander_1.Command();
+program
+    .name("bpm-core")
+    .description("BPM Core CLI tool.")
+    .version("1.0.0");
+program.addCommand(deploy_1.deployCommand);
+program.parse(process.argv);