@grnsft/if 0.7.1 → 1.0.0-beta.0

package/CONTRIBUTING.md

@@ -8,6 +8,7 @@ The following document is a rule set of guidelines for contributing.
 
 - [What and when to contribute](#what-and-when-to-contribute)
 - [Reporting bugs](#reporting-bugs)
+- [Disclosing vulnerabilities](#disclosing-vulnerabilities)
 - [Code Contributions](#code-contributions)
   - [Step 1: Fork](#step-1-fork)
   - [Step 2: Branch](#step-2-branch)
@@ -37,16 +38,16 @@ We appreciate bug reports! If you experience an issue with IF, you can report it
 3. Click on `Create New Issue` and select the `Bug Report` template.
 4. Fill out the requested information.
 
-The more detailed information you provide in the bug report, the easier it will be for us to diagnose, triage and resolve your issue. We ask for some simple information about your issue, including a description of the error, the expected behaviour, the actual behaviour and the stepos we can take to reproduce the error in our local environments. We also then prompt you to provide a link to [Stackblitz](https://stackblitz.com/) or a similar online environment where we can run your manifest and observe the error. If you prefer *not* to send a link, we would appreciate a copy of the manifest file that you ran to produce the error, information about your runtime environment and any additional code that's required to reproduce the error. This is all designed to enable us to reproduce the same error and debug it for you as quickly as possible.
+The more detailed information you provide in the bug report, the easier it will be for us to diagnose, triage, and resolve your issue. We ask for some simple information about your issue, including a description of the error, the expected behaviour, the actual behaviour and the steps we can take to reproduce the error in our local environments. We also then prompt you to provide a link to [Stackblitz](https://stackblitz.com/) or a similar online environment where we can run your manifest and observe the error. If you prefer *not* to send a link, we would appreciate a copy of the manifest file that you ran to produce the error, information about your runtime environment, and any additional code that's required to reproduce the error. This is all designed to enable us to reproduce the same error and debug it for you as quickly as possible.
 
-Once a suitably detailed bug report exists, we will triage it. We hold weekly triage calls on Tuesdays. In most cases, the triage call will be the core team's first interaction with the bug, although in some cases we may engage asynchronously in advance of the call. Triage means that the core team will examine the issue and assign an urgency label - either Low, Medium or High. 
+Once a suitably detailed bug report exists, we will triage it. Triage means that the core team will examine the issue and assign an urgency label - either Low, Medium or High. 
 
 The assessment rubric is as follows:
 
 |                                                                                                                        | Consequence                                                                              | Severity |
 | ---------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- | -------- |
 | Bugs in IF core leading to incorrect calculations                                                                      | unusable framework                                                                       | 5        |
-| Bugs in builtins leading to incorrect calculations                                                                   | core pathways fail, IF very limited in functionality                                     | 5        |
+| Bugs in builtins leading to incorrect calculations                                                                     | core pathways fail, IF very limited in functionality                                     | 5        |
 | Bugs in template                                                                                                       | Harder to build plugins, ecosystem growth is impacted                                    | 2        |
 | Bugs in docs                                                                                                           | product does not match expectation, hard to debug, frustration, loss of adoption         | 2        |
 | Security flaw: privacy related                                                                                         | leak user data, unlikely to achieve adoption in serious orgs                             | 5        |
@@ -69,7 +70,7 @@ The mapping of severity to label is as follows:
 | 4        | H     |
 | 5        | H     |
 
-During the bug triage we will also discuss a remediation plan for the bug. This will be communicated in the comments on the bug report. For high urgency bugs, the fix will be implemented as soon as possible, maybe reorganizing our current work to accommodate it. For medium priority bugs, we will schedule the fix in the next available sprint. Low priority bugs will be backlogged and addressed when there is developer time available. Low priority bugs will also be tagged `help-wanted` so that they can be addressed by community members.
+The fix will be implemented for high-urgency bugs as soon as possible. Low priority bugs will be backlogged and addressed when there is developer time available. Low priority bugs will also be tagged `help-wanted` so that they can be addressed by community members.
 
 Not every bug will be fixed. We may decide *not* to fix a bug in cases such as:
 
@@ -80,6 +81,18 @@ Not every bug will be fixed. We may decide *not* to fix a bug in cases such as:
 
 The bug will be labelled `fix-now`, `fix-later` or `wont-fix` to reflect our remediation plan and details will be provided in issue comments.
 
+## Disclosing vulnerabilities
+
+If you discover a security vulnerability in IF, please report it to if-disclosures@greensoftware.foundation.
+
+Include the following information:
+
+- description of the issue
+- steps to reproduce
+- steps to fix, if known
+
+The IF team will respond as quickly as possible. Post-graduation there will be no full-time development team, but GSF staff will aim to get the vulnerability patched as quickly as possible, aiming for <=14 day response time.
+
 
 ## Code Contributions
 
@@ -155,7 +168,7 @@ $ git push origin <topic-branch-name>
 
 ### Step 6: Pull Request
 
-Open a Pull Request from your fork of the repository to the `dev` branch of the IF repository with a clear title and description according to [template](.github/PULL_REQUEST_TEMPLATE.md).
+Open a Pull Request from your fork of the repository to the `main` branch of the IF repository with a clear title and description according to [template](.github/PULL_REQUEST_TEMPLATE.md).
 
 Pull requests will not be reviewed unless they pass all CI. This includes a lint check and running our unit tests.
 
@@ -178,7 +191,7 @@ We prefer not to use abbreviations of contractions in parameter names.
 
 Using fully descriptive names makes the code more readable, which in turn helps reviewers and anyone else aiming to understand how the plugin works. 
 
-It also helps to avoid ambiguity and naming collisions within and across plugins. Your name should describe what an element does as precisely as practically possible.
+It also helps to avoid ambiguity and naming collisions within and across plugins. Ensure that names clearly and precisely describe the purpose of an element to make its functionality immediately apparent.
 
 For example, we prefer `functionalUnit` to `funcUnit`, `fUnit`, or any other abbreviation.
 

package/ENABLEMENT.md

@@ -0,0 +1,115 @@
+# Enablement Guide for Impact Framework (IF)
+
+## What is the Impact Framework?
+
+The **Impact Framework (IF)** empowers you to calculate and understand the environmental impact of your software. It comes with a standard library of built-in plugins, referred to as builtins, and an Explorer for discovering and installing third-party plugins.
+
+## How to Use the Impact Framework?
+
+### Prerequisites
+
+Before getting started, ensure you have the following:
+
+1. **Node.js**: Installed and configured.
+2. **NPM**: Comes with Node.js; ensure it’s updated.
+3. **Access to Documentation**: Familiarize yourself with the [IF documentation](https://if.greensoftware.foundation/).
+4. **Basic YAML Knowledge**: For creating and managing manifest files.
+
+## Steps to Enable the Impact Framework
+
+### Step 1: Installation
+
+Install the latest version of IF globally using NPM:
+
+```sh
+npm install -g "@grnsft/if"
+```
+
+`IF` provides multiple command-line tools, with the primary tool being `if-run`.
+
+### Step 2: Working with Command-Line Tools
+
+1. `if-run`: Execute Manifest Files
+
+   - Description: Executes manifest files to calculate impact.
+   - Manifest File: A YAML file central to IF functionality. It contains configurations, application architecture, input data, and serves as a portable, shareable, human-readable document for audits.
+   - Usage:
+
+   ```sh
+   if-run --manifest <path-to-your-manifest-file>
+   ```
+
+More about if-run [here](https://if.greensoftware.foundation/reference/cli#if-run).
+
+2. `if-env`: Create Local Development Environments
+
+   - Description: Sets up a local environment for running manifests.
+   - Usage:
+
+   ```sh
+   mkdir my-manifest && cd my-manifest
+   if-env
+   ```
+
+Find details in the [documentation](https://if.greensoftware.foundation/reference/cli#if-env).
+
+3. `if-check`: Verify Manifests
+
+   - Description: Combines the functionalities of if-env and if-diff to verify manifest files with outputs and execution sections.
+   - Usage:
+
+   ```sh
+   # Check a specific manifest file
+   if-check -m <path-to-your-manifest-file>
+
+   # Check all manifests in a directory
+   if-check -d /path-to-your-manifests
+   ```
+
+Explore more in the [documentation](https://if.greensoftware.foundation/reference/cli#if-check).
+
+4. `if-csv`: Save Data to CSV
+
+   - Description: Saves calculated impact data to a CSV file.
+   - Usage:
+
+   ```sh
+   if-csv -m ./my-manifest.yml -p carbon
+   ```
+
+Read more in the [documentation](https://if.greensoftware.foundation/reference/cli#if-csv).
+
+5. `if-diff`: Compare Manifests or Outputs
+
+   - Description: Compares two manifest or output files to identify differences.
+   - Usage:
+
+   ```sh
+   if-diff <file1> <file2>
+   ```
+
+Details are available in the [documentation](https://if.greensoftware.foundation/reference/cli#if-diff).
+
+### Step 3: Explore Plugins
+
+- Built-In Plugins: Utilize IF’s built-ins for common environmental impact assessments.
+- Third-Party Plugins: Visit the Explorer to discover and install third-party plugins tailored to your needs.
+
+### Step 4: Help and Guidance
+
+For assistance with any command, use the --help flag:
+
+```sh
+if-run --help
+```
+
+## Additional Resources
+
+- Documentation: [IF Documentation](https://if.greensoftware.foundation)
+- Third-Party Plugins: [Plugin Explorer](https://explorer.if.greensoftware.foundation)
+
+## Support
+
+Join the IF Community for updates and discussions:
+
+- Mailing List: [if-community@greensoftware.foundation](https://groups.google.com/u/1/a/greensoftware.foundation/g/if-community)

package/README.md

@@ -64,12 +64,6 @@ if-run -h
 
 Please read our documentation at [if.greensoftware.foundation](https://if.greensoftware.foundation/)
 
-## Video walk-through
-
-Watch this video to learn how to create and run a `manifest`.
-
-[![Watch the walk-through video](https://i3.ytimg.com/vi/R-6eDM8AsvY/maxresdefault.jpg)](https://youtu.be/GW37Qd4AQbU)
-
 ## Join our mailing list
 
 We have a public mailing list at [if-community@greensoftware.foundation](https://groups.google.com/u/1/a/greensoftware.foundation/g/if-community). We send out weekly updates that explain what we've shipped, what we're working on and how you can get involved each week!

package/SECURITY.md

@@ -0,0 +1,100 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+To report a security issue, please email if-disclosures@greensoftware.foundation with a description of the issue, steps required to reproduce the issue, affected versions and, if known, mitigations for the issue.
+
+Our contributors are comprised of volunteers so we cannot guarantee a specific response time, but someone from our team will reply and address the issue as soon as possible.
+
+# Security Review
+
+We perform regular reviews inline with the information provided below.  All releases go through these reviews but multiple people in the project team prior to release as part of our quality and security review.
+
+## Basics
+### Basic Project Website Content
+- Describe what the project does - ✅  in README and homepage at https://if.greensoftware.foundation
+- Provide info how to obtain/provide feedback and contribute - ✅ https://if.greensoftware.foundation/community
+- Explain contribution process - ✅ https://github.com/Green-Software-Foundation/if/blob/main/CONTRIBUTING.md
+
+### FLOSS license
+- Must be released as FLOSS - ✅ MIT License https://github.com/Green-Software-Foundation/if/blob/main/LICENSE
+- Must post the license - ✅ https://github.com/Green-Software-Foundation/if/blob/main/LICENSE
+- Also approved by OSI - ✅  https://opensource.org/license/MIT/
+
+### Documentation
+- Provides basic documentation - ✅ https://if.greensoftware.foundation
+
+### Other
+- Project site, downloads etc must support HTTPS with TLS - ✅ using GitHub to host which supports this https://github.com/Green-Software-Foundation/if
+- Have mechanism for discussion - ✅ github issues https://github.com/Green-Software-Foundation/if/issues, discussion board https://github.com/Green-Software-Foundation/if/discussions and mailing list at if-community@greensoftware.foundaton
+- Project must be maintained - ✅ actively maintaned by GSF and its members
+
+## Change control
+###  Public VCS repo
+- Readable public VCS repo - ✅ yes, Github https://github.com/Green-Software-Foundation/if
+- Track changes - ✅ yes, Git https://github.com/Green-Software-Foundation/if/commits/main
+- Interim versions between releases available for review - ✅ yes, interim versions actively developed and availble on the `main` branch https://github.com/Green-Software-Foundation/if
+
+### Unique versioning numbering
+- Unique indentifier for each release - ✅ https://github.com/Green-Software-Foundation/if/releases
+
+### Release notes
+- Human readable release notes for each release (not git log) - ✅ https://github.com/Green-Software-Foundation/if/releases
+- Address each publicly known vulnerability - ✅ N/A, no vulnerability reported yet
+
+## Reporting
+### Bug reporting process
+- Process to submit bugs - ✅ https://github.com/Green-Software-Foundation/if/blob/main/CONTRIBUTING.md#reporting-bugs
+- Must acknowledge bugs (reply) submitted between 2-12 months - ✅ each bug has at least an acknowledgement or was opened by a maintainer (so acknowledged by a maintainer): https://github.com/Green-Software-Foundation/if/issues?q=is%3Aopen+is%3Aissue+label%3Abug
+- Publicly available archive for reports and responses - ✅ github issues: https://github.com/Green-Software-Foundation/if/issues?q=is%3Aopen+is%3Aissue+label%3Abug
+
+## Vulnerability report process
+- Have a vulnerability report process - ✅ Included in CONTRIBUTING.md
+- Private vulnerability if supported must include info how to send - ✅ N/A (allowed) - no private vulnerability reporting set up but proposed
+- Initial response time for vulnerability submitted in last 6 months must be <= 14 days - ✅ N/A (allowed) - no vulnerabilities have yet been reported. Response times for bugs and other issues have been <14 days, post-graduation development will be by volunteers and open source developer community, so we can't guarantee a time to resolution.
+
+## Quality
+### Working build system
+- Must provide a working build system - ✅ IF is a locally running NodeJS app. We do provide a devcontainer for eays environment setup. Installation is simply achieved using `npm i @grnsft/if`.
+
+### Automated test suite
+- Have at least one automated test suite and documentation how to run it - ✅  We have a comprehensive set of unit tests and a library of becnhmark manifest files that act as integration tests. These can be run locally, and they are executed as part of our CI/CD on any PRs into `main`.
+
+## New functionaility testing
+- Formal/informal policy for adding tests for new features - ✅ Test suite in CI/CD checks for breaking changes in PRs. Any new feature must include unit tests and an example manifest that demonstrates usage.
+- Evidence of policy being adhered to - ✅ 
+
+### Warning flags
+- Compiler warning flags or linter tools for code quality/errors - ✅ CodeQL analysis in automated CI : https://github.com/Green-Software-Foundation/carbon-aware-sdk/blob/dev/.github/workflows/1-pr.yaml#L82
+- Address warnings from these tools - ✅ blocking PRs on fail
+
+## Security
+### Secure development knowledge
+- At least one primary developer who knows how to design secure software - ✅ Manushak and Narek are both primary developers and have broad experience.
+- At least one of the project's primary developers MUST know of common kinds of errors that lead to vulnerabilities in this kind of software, as well as at least one method to counter or mitigate each of them - ✅ 
+
+### Use basic good cryptographic practices
+- https://www.bestpractices.dev/en/criteria/0#0.crypto_published - ✅ n/a
+- https://www.bestpractices.dev/en/criteria/0#0.crypto_floss - ✅ n/a 
+- https://www.bestpractices.dev/en/criteria/0#0.crypto_keylength - ✅ n/a
+- https://www.bestpractices.dev/en/criteria/0#0.crypto_working - ✅ n/a
+- https://www.bestpractices.dev/en/criteria/0#0.crypto_password_storage - ✅ n/a
+- https://www.bestpractices.dev/en/criteria/0#0.crypto_random - ✅ n/a
+
+### Secured delivery against man-in-the-middle (MITM) attacks
+- Delivery mechanisms that counters MITM - ✅ n/a
+- Cyrptographic hash NOT retrived over HTTP - ✅  n/a
+
+### Publicly known vulnerabilities fixed
+- No unpatched vulnerabilities of medium or higher severity that have been publicly known for more than 60 day - ✅ no such vulnerabilities
+
+### Other security issues
+- Public repo doesnt leak private credential - ✅ does not do that.
+
+## Analysis
+### Static code analysis
+- At least one FLOSS static code analysis tool - ✅ CodeQL is integrated into our CI/CD.
+- All medium and higher severity exploitable vulnerabilities discovered with static code analysis MUST be fixed in a timely way after they are confirmed - ✅ We have not yet had any exploitable vulnerabilities reported, but the GSF team will respond promptly to any disclosed issues.
+
+### Dynamic code analysis
+- All medium and higher severity exploitable vulnerabilities discovered with dynamic code analysis MUST be fixed in a timely way after they are confirmed. - ✅ We have not yet had any exploitable vulnerabilities reported, but the GSF team will respond promptly to any disclosed issues.

package/adopters.md

@@ -0,0 +1,9 @@
+# Adopters
+
+Impact Framework is being used by several major organizations to introspect their software systems, as well as having a thriving open source community.
+
+One adopter we will highlight in this file is Amadeus. They have used IF at a large scale, processing multi-million line manifests covering thousands of production servers. they have built their own tooling stack on top of IF. They kindly provided the following quote:
+
+"At Amadeus, the Impact Framework (IF) has become an essential brick in our software carbon measurement engine. Its scalability provides us with a transparent and robust way to model the energy consumption and carbon emissions of our whole cloud infrastructure. Its open-source nature fosters collaboration and innovation, making it a critical part of our efforts to drive environmental responsibility."
+
+*Robin Castellon, Amadeus*

package/build/common/config/strings.d.ts

@@ -8,4 +8,6 @@ export declare const STRINGS: {
     DIRECTORY_NOT_FOUND: string;
     AGGREGATION_UNITS_NOT_MATCH: (param: string) => string;
     AGGREGATION_METHODS_NOT_MATCH: (param: string) => string;
+    MISSING_INPUTS_PARAMETER: (pluginName: string) => string;
+    MISSING_OUTPUTS_PARAMETER: (pluginName: string) => string;
 };

package/build/common/config/strings.js

@@ -13,7 +13,9 @@ Incubation projects are experimental, offer no support guarantee, have minimal g
     SUCCESS_MESSAGE: 'The environment is successfully setup!',
     MANIFEST_IS_MISSING: 'Manifest is missing.',
     DIRECTORY_NOT_FOUND: 'Directory not found.',
-    AGGREGATION_UNITS_NOT_MATCH: (param) => `Your manifest uses two instances of ${param} with different units. Please check that you are using consistent units for ${param} throughout your manifest.`,
-    AGGREGATION_METHODS_NOT_MATCH: (param) => `Your manifest uses two instances of ${param} with different 'aggregation-method'. Please check that you are using right 'aggregation-method' for ${param} throughout your manifest.`,
+    AGGREGATION_UNITS_NOT_MATCH: (param) => `Your manifest uses two instances of \`${param}\` with different units. Please check that you are using consistent units for \`${param}\` throughout your manifest.`,
+    AGGREGATION_METHODS_NOT_MATCH: (param) => `Your manifest uses two instances of \`${param}\` with different 'aggregation-method'. Please check that you are using right 'aggregation-method' for \`${param}\` throughout your manifest.`,
+    MISSING_INPUTS_PARAMETER: (pluginName) => `The inputs parameter metadata of the \`${pluginName}\` plugin is missing.`,
+    MISSING_OUTPUTS_PARAMETER: (pluginName) => `The outputs parameter metadata of the \`${pluginName}\` plugin is missing.`,
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/common/util/logger.js

@@ -32,8 +32,8 @@ const { combine, timestamp, printf, colorize, align } = winston.format;
 exports.logger = winston.createLogger({
     format: combine(colorize({ all: true }), timestamp({
         format: 'YYYY-MM-DD hh:mm:ss.SSS A',
-    }), align(), printf((info) => `[${info.timestamp}] ${info.level}: ${info.message}
-${info.stack || ''}`)),
+    }), align(), printf((info) => `[${info.timestamp}] ${info.stack || `${info.level}: ${info.message}`}
+`)),
     transports: [new winston.transports.Console()],
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbW1vbi91dGlsL2xvZ2dlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGlEQUFtQztBQUVuQyxNQUFNLEVBQUMsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLEtBQUssRUFBQyxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUM7QUFFckU7O0dBRUc7QUFDVSxRQUFBLE1BQU0sR0FBRyxPQUFPLENBQUMsWUFBWSxDQUFDO0lBQ3pDLE1BQU0sRUFBRSxPQUFPLENBQ2IsUUFBUSxDQUFDLEVBQUMsR0FBRyxFQUFFLElBQUksRUFBQyxDQUFDLEVBQ3JCLFNBQVMsQ0FBQztRQUNSLE1BQU0sRUFBRSwyQkFBMkI7S0FDcEMsQ0FBQyxFQUNGLEtBQUssRUFBRSxFQUNQLE1BQU0sQ0FDSixDQUFDLElBQVMsRUFBRSxFQUFFLENBQ1osSUFBSSxJQUFJLENBQUMsU0FBUyxLQUFLLElBQUksQ0FBQyxLQUFLLEtBQUssSUFBSSxDQUFDLE9BQU87RUFDeEQsSUFBSSxDQUFDLEtBQUssSUFBSSxFQUFFLEVBQUUsQ0FDZixDQUNGO0lBQ0QsVUFBVSxFQUFFLENBQUMsSUFBSSxPQUFPLENBQUMsVUFBVSxDQUFDLE9BQU8sRUFBRSxDQUFDO0NBQy9DLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIHdpbnN0b24gZnJvbSAnd2luc3Rvbic7XG5cbmNvbnN0IHtjb21iaW5lLCB0aW1lc3RhbXAsIHByaW50ZiwgY29sb3JpemUsIGFsaWdufSA9IHdpbnN0b24uZm9ybWF0O1xuXG4vKipcbiAqIFdpbnN0b24gbG9nZ2VyIGluc3RhbmNlLlxuICovXG5leHBvcnQgY29uc3QgbG9nZ2VyID0gd2luc3Rvbi5jcmVhdGVMb2dnZXIoe1xuICBmb3JtYXQ6IGNvbWJpbmUoXG4gICAgY29sb3JpemUoe2FsbDogdHJ1ZX0pLFxuICAgIHRpbWVzdGFtcCh7XG4gICAgICBmb3JtYXQ6ICdZWVlZLU1NLUREIGhoOm1tOnNzLlNTUyBBJyxcbiAgICB9KSxcbiAgICBhbGlnbigpLFxuICAgIHByaW50ZihcbiAgICAgIChpbmZvOiBhbnkpID0+XG4gICAgICAgIGBbJHtpbmZvLnRpbWVzdGFtcH1dICR7aW5mby5sZXZlbH06ICR7aW5mby5tZXNzYWdlfVxuJHtpbmZvLnN0YWNrIHx8ICcnfWBcbiAgICApXG4gICksXG4gIHRyYW5zcG9ydHM6IFtuZXcgd2luc3Rvbi50cmFuc3BvcnRzLkNvbnNvbGUoKV0sXG59KTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbW1vbi91dGlsL2xvZ2dlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGlEQUFtQztBQUVuQyxNQUFNLEVBQUMsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLEtBQUssRUFBQyxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUM7QUFFckU7O0dBRUc7QUFDVSxRQUFBLE1BQU0sR0FBRyxPQUFPLENBQUMsWUFBWSxDQUFDO0lBQ3pDLE1BQU0sRUFBRSxPQUFPLENBQ2IsUUFBUSxDQUFDLEVBQUMsR0FBRyxFQUFFLElBQUksRUFBQyxDQUFDLEVBQ3JCLFNBQVMsQ0FBQztRQUNSLE1BQU0sRUFBRSwyQkFBMkI7S0FDcEMsQ0FBQyxFQUNGLEtBQUssRUFBRSxFQUNQLE1BQU0sQ0FDSixDQUFDLElBQVMsRUFBRSxFQUFFLENBQ1osSUFBSSxJQUFJLENBQUMsU0FBUyxLQUFLLElBQUksQ0FBQyxLQUFLLElBQUksR0FBRyxJQUFJLENBQUMsS0FBSyxLQUFLLElBQUksQ0FBQyxPQUFPLEVBQUU7Q0FDNUUsQ0FDSSxDQUNGO0lBQ0QsVUFBVSxFQUFFLENBQUMsSUFBSSxPQUFPLENBQUMsVUFBVSxDQUFDLE9BQU8sRUFBRSxDQUFDO0NBQy9DLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIHdpbnN0b24gZnJvbSAnd2luc3Rvbic7XG5cbmNvbnN0IHtjb21iaW5lLCB0aW1lc3RhbXAsIHByaW50ZiwgY29sb3JpemUsIGFsaWdufSA9IHdpbnN0b24uZm9ybWF0O1xuXG4vKipcbiAqIFdpbnN0b24gbG9nZ2VyIGluc3RhbmNlLlxuICovXG5leHBvcnQgY29uc3QgbG9nZ2VyID0gd2luc3Rvbi5jcmVhdGVMb2dnZXIoe1xuICBmb3JtYXQ6IGNvbWJpbmUoXG4gICAgY29sb3JpemUoe2FsbDogdHJ1ZX0pLFxuICAgIHRpbWVzdGFtcCh7XG4gICAgICBmb3JtYXQ6ICdZWVlZLU1NLUREIGhoOm1tOnNzLlNTUyBBJyxcbiAgICB9KSxcbiAgICBhbGlnbigpLFxuICAgIHByaW50ZihcbiAgICAgIChpbmZvOiBhbnkpID0+XG4gICAgICAgIGBbJHtpbmZvLnRpbWVzdGFtcH1dICR7aW5mby5zdGFjayB8fCBgJHtpbmZvLmxldmVsfTogJHtpbmZvLm1lc3NhZ2V9YH1cbmBcbiAgICApXG4gICksXG4gIHRyYW5zcG9ydHM6IFtuZXcgd2luc3Rvbi50cmFuc3BvcnRzLkNvbnNvbGUoKV0sXG59KTtcbiJdfQ==

package/build/common/util/yaml.js

@@ -27,22 +27,34 @@ exports.checkIfFileIsYaml = exports.saveYamlFileAs = exports.openYamlFileAsObjec
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const YAML = __importStar(require("js-yaml"));
+const utils_1 = require("@grnsft/if-core/utils");
+const { ReadFileError, WriteFileError } = utils_1.ERRORS;
 /**
  * Reads and parses `yaml` file to object.
  */
 const openYamlFileAsObject = async (filePath) => {
-    const yamlFileBuffer = await fs.readFile(filePath, 'utf8');
-    return YAML.load(yamlFileBuffer);
+    try {
+        const yamlFileBuffer = await fs.readFile(filePath, 'utf8');
+        return YAML.load(yamlFileBuffer);
+    }
+    catch (error) {
+        throw new ReadFileError(error.message);
+    }
 };
 exports.openYamlFileAsObject = openYamlFileAsObject;
 /**
  * Saves given `yaml` dump as a file.
  */
 const saveYamlFileAs = async (object, pathToFile) => {
-    const dirPath = path.dirname(pathToFile);
-    await fs.mkdir(dirPath, { recursive: true });
-    const yamlString = YAML.dump(object, { noRefs: true });
-    return fs.writeFile(pathToFile, yamlString);
+    try {
+        const dirPath = path.dirname(pathToFile);
+        await fs.mkdir(dirPath, { recursive: true });
+        const yamlString = YAML.dump(object, { noRefs: true });
+        return await fs.writeFile(pathToFile, yamlString);
+    }
+    catch (error) {
+        throw new WriteFileError(error.message);
+    }
 };
 exports.saveYamlFileAs = saveYamlFileAs;
 /**
@@ -56,4 +68,4 @@ const checkIfFileIsYaml = (fileName) => {
     return yamlFileTypes.includes(extension);
 };
 exports.checkIfFileIsYaml = checkIfFileIsYaml;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-check/util/npm.js

@@ -25,15 +25,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeCommands = void 0;
 const path = __importStar(require("node:path"));
-const helpers_1 = require("../../common/util/helpers");
+const child_process_1 = require("child_process");
 const fs_1 = require("../../common/util/fs");
 const config_1 = require("../config");
 const { IF_CHECK_VERIFIED } = config_1.STRINGS;
+/**
+ * Escapes shell characters that could be dangerous in a command.
+ */
+const escapeShellArg = (str) => str.replace(/([`$\\&;|*?<>])/g, '\\$1');
 /**
  * Executes a series of npm commands based on the provided manifest file.
  */
 const executeCommands = async (manifest, cwd) => {
-    // TODO: After release remove isGlobal and appropriate checks
     const isGlobal = !!process.env.npm_config_global;
     const manifestDirPath = path.dirname(manifest);
     const manifestFileName = (0, fs_1.getFileName)(manifest);
@@ -41,13 +44,56 @@ const executeCommands = async (manifest, cwd) => {
     const prefixFlag = process.env.CURRENT_DIR && process.env.CURRENT_DIR !== process.cwd()
         ? `--prefix=${path.relative(process.env.CURRENT_DIR, process.cwd())}`
         : '';
-    const ifEnv = `${isGlobal ? `if-env ${prefixFlag}` : `npm run if-env ${prefixFlag} --`} -m ${manifest}`;
-    const ifEnvCommand = cwd ? `${ifEnv} -c` : ifEnv;
-    const ifRunCommand = `${isGlobal ? `if-run ${prefixFlag}` : `npm run if-run ${prefixFlag} --`} -m ${manifest} -o ${executedManifest}`;
-    const ifDiffCommand = `${isGlobal ? `if-diff ${prefixFlag}` : `npm run if-diff ${prefixFlag} --`} -s ${executedManifest}.yaml -t ${manifest}`;
-    const ttyCommand = " node -p 'Boolean(process.stdout.isTTY)'";
-    await (0, helpers_1.execPromise)(`${ifEnvCommand} && ${ifRunCommand} && ${ttyCommand} | ${ifDiffCommand}`, {
+    const sanitizedManifest = escapeShellArg(manifest);
+    const sanitizedExecutedManifest = escapeShellArg(executedManifest);
+    const ifEnvCommand = [
+        isGlobal ? 'if-env' : 'npm',
+        ...(isGlobal ? [] : ['run', 'if-env']),
+        '--',
+        ...(prefixFlag === '' ? [] : [prefixFlag]),
+        '-m',
+        sanitizedManifest,
+    ];
+    const ifRunCommand = [
+        isGlobal ? 'if-run' : 'npm',
+        ...(isGlobal ? [] : ['run', 'if-run']),
+        '--',
+        ...(prefixFlag === '' ? [] : [prefixFlag]),
+        '-m',
+        sanitizedManifest,
+        '-o',
+        sanitizedExecutedManifest,
+    ];
+    const ttyCommand = ['node', '-p', 'Boolean(process.stdout.isTTY)'];
+    const ifDiffCommand = [
+        isGlobal ? 'if-diff' : 'npm',
+        ...(isGlobal ? [] : ['run', 'if-diff']),
+        '--',
+        ...(prefixFlag === '' ? [] : [prefixFlag]),
+        '-s',
+        `${sanitizedExecutedManifest}.yaml`,
+        '-t',
+        sanitizedManifest,
+    ];
+    (0, child_process_1.execFileSync)(ifEnvCommand[0], ifEnvCommand.slice(1), {
+        cwd: process.env.CURRENT_DIR || process.cwd(),
+        shell: true,
+    });
+    (0, child_process_1.execFileSync)(ifRunCommand[0], ifRunCommand.slice(1), {
+        cwd: process.env.CURRENT_DIR || process.cwd(),
+    });
+    (0, child_process_1.execFileSync)(ttyCommand[0], ttyCommand.slice(1), {
+        cwd: process.env.CURRENT_DIR || process.cwd(),
+    });
+    const ttyResult = (0, child_process_1.execFileSync)(ttyCommand[0], ttyCommand.slice(1), {
+        cwd: process.env.CURRENT_DIR || process.cwd(),
+    });
+    const tty = ttyResult && ttyResult.toString().trim();
+    const fullCommand = `${tty === 'true' ? 'tty |' : ''} ${ifDiffCommand.join(' ')}`;
+    (0, child_process_1.execFileSync)(fullCommand, {
         cwd: process.env.CURRENT_DIR || process.cwd(),
+        stdio: 'inherit',
+        shell: true,
     });
     if (!cwd) {
         await (0, fs_1.removeFileIfExists)(`${manifestDirPath}/package.json`);
@@ -56,4 +102,4 @@ const executeCommands = async (manifest, cwd) => {
     console.log(IF_CHECK_VERIFIED(path.basename(manifest)));
 };
 exports.executeCommands = executeCommands;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"npm.js","sourceRoot":"","sources":["../../../src/if-check/util/npm.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'node:path';\nimport {execFileSync} from 'child_process';\nimport {getFileName, removeFileIfExists} from '../../common/util/fs';\nimport {STRINGS} from '../config';\n\nconst {IF_CHECK_VERIFIED} = STRINGS;\n\n/**\n * Escapes shell characters that could be dangerous in a command.\n */\nconst escapeShellArg = (str: string) => str.replace(/([`$\\\\&;|*?<>])/g, '\\\\$1');\n\n/**\n * Executes a series of npm commands based on the provided manifest file.\n */\nexport const executeCommands = async (manifest: string, cwd: boolean) => {\n  const isGlobal = !!process.env.npm_config_global;\n  const manifestDirPath = path.dirname(manifest);\n  const manifestFileName = getFileName(manifest);\n  const executedManifest = path.join(manifestDirPath, `re-${manifestFileName}`);\n\n  const prefixFlag =\n    process.env.CURRENT_DIR && process.env.CURRENT_DIR !== process.cwd()\n      ? `--prefix=${path.relative(process.env.CURRENT_DIR!, process.cwd())}`\n      : '';\n\n  const sanitizedManifest = escapeShellArg(manifest);\n  const sanitizedExecutedManifest = escapeShellArg(executedManifest);\n\n  const ifEnvCommand = [\n    isGlobal ? 'if-env' : 'npm',\n    ...(isGlobal ? [] : ['run', 'if-env']),\n    '--',\n    ...(prefixFlag === '' ? [] : [prefixFlag]),\n    '-m',\n    sanitizedManifest,\n  ];\n\n  const ifRunCommand = [\n    isGlobal ? 'if-run' : 'npm',\n    ...(isGlobal ? [] : ['run', 'if-run']),\n    '--',\n    ...(prefixFlag === '' ? [] : [prefixFlag]),\n    '-m',\n    sanitizedManifest,\n    '-o',\n    sanitizedExecutedManifest,\n  ];\n\n  const ttyCommand = ['node', '-p', 'Boolean(process.stdout.isTTY)'];\n  const ifDiffCommand = [\n    isGlobal ? 'if-diff' : 'npm',\n    ...(isGlobal ? [] : ['run', 'if-diff']),\n    '--',\n    ...(prefixFlag === '' ? [] : [prefixFlag]),\n    '-s',\n    `${sanitizedExecutedManifest}.yaml`,\n    '-t',\n    sanitizedManifest,\n  ];\n\n  execFileSync(ifEnvCommand[0], ifEnvCommand.slice(1), {\n    cwd: process.env.CURRENT_DIR || process.cwd(),\n    shell: true,\n  });\n\n  execFileSync(ifRunCommand[0], ifRunCommand.slice(1), {\n    cwd: process.env.CURRENT_DIR || process.cwd(),\n  });\n\n  execFileSync(ttyCommand[0], ttyCommand.slice(1), {\n    cwd: process.env.CURRENT_DIR || process.cwd(),\n  });\n\n  const ttyResult = execFileSync(ttyCommand[0], ttyCommand.slice(1), {\n    cwd: process.env.CURRENT_DIR || process.cwd(),\n  });\n\n  const tty = ttyResult && ttyResult.toString().trim();\n  const fullCommand = `${tty === 'true' ? 'tty |' : ''} ${ifDiffCommand.join(\n    ' '\n  )}`;\n\n  execFileSync(fullCommand, {\n    cwd: process.env.CURRENT_DIR || process.cwd(),\n    stdio: 'inherit',\n    shell: true,\n  });\n\n  if (!cwd) {\n    await removeFileIfExists(`${manifestDirPath}/package.json`);\n  }\n\n  await removeFileIfExists(`${executedManifest}.yaml`);\n\n  console.log(IF_CHECK_VERIFIED(path.basename(manifest)));\n};\n"]}

package/build/if-run/builtins/divide/index.js

@@ -55,9 +55,7 @@ exports.Divide = (0, interfaces_1.PluginFactory)({
  */
 const calculateDivide = (input, index, params) => {
     const { denominator, numerator } = params;
-    const finalDenominator = typeof denominator === 'number'
-        ? denominator
-        : input[denominator] || denominator;
+    const finalDenominator = typeof denominator === 'number' ? denominator : input[denominator];
     const finalNumerator = typeof numerator === 'number' ? numerator : input[numerator];
     if (finalDenominator === 0) {
         console.warn(ZERO_DIVISION(exports.Divide.name, index));
@@ -65,4 +63,4 @@ const calculateDivide = (input, index, params) => {
     }
     return finalNumerator / finalDenominator;
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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