@unito/integration-cli 0.55.1

package/dist/src/commands/publish.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const ngrok_1 = tslib_1.__importDefault(require("ngrok"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const gradient = tslib_1.__importStar(require("gradient-string"));
+const json_colorizer_1 = tslib_1.__importDefault(require("json-colorizer"));
+const child_process_1 = tslib_1.__importDefault(require("child_process"));
+const tmp_1 = tslib_1.__importDefault(require("tmp"));
+const crypto_1 = tslib_1.__importDefault(require("crypto"));
+const baseCommand_1 = require("../baseCommand");
+const errors_1 = require("../errors");
+const integrations_1 = require("../resources/integrations");
+const GlobalConfiguration = tslib_1.__importStar(require("../resources/globalConfiguration"));
+const IntegrationsPlatform = tslib_1.__importStar(require("../services/integrationsPlatform"));
+const IntegrationConfiguration = tslib_1.__importStar(require("../resources/configuration"));
+const fileSystem_1 = require("../resources/fileSystem");
+const integrationsPlatform_1 = require("../resources/integrationsPlatform");
+class Publish extends baseCommand_1.BaseCommand {
+    static description = 'Publish your integration';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        environment: core_1.Flags.custom({
+            description: 'the environment of the platform',
+            options: Object.values(GlobalConfiguration.Environment),
+            default: GlobalConfiguration.Environment.Production,
+        })(),
+        'registry-only': core_1.Flags.boolean({
+            description: '(advanced) only update the registry',
+            default: false,
+            hidden: true,
+            exclusive: ['preview', 'live-preview'],
+        }),
+        preview: core_1.Flags.boolean({
+            description: 'preview the integration - your integration will run and be privately accessible on the target environment',
+            default: false,
+            exclusive: ['registry-only', 'live-preview'],
+        }),
+        'live-preview': core_1.Flags.boolean({
+            description: 'live-preview the integration - Useful to iterate quickly during development, your integration runs locally and is privately accessible on the target environment',
+            default: false,
+            exclusive: ['registry-only', 'preview'],
+        }),
+        'config-path': core_1.Flags.string({
+            summary: 'relative path to a custom ".unito.json" file',
+            description: `Use a custom configuration file instead of the default '.unito.json' or other environment specific
+      ones.
+
+      If you want to force the CLI to use a specific configuration file, you can use this flag to specify the relative
+      path from your integration's root folder (with a leading '/').
+
+      Usage: <%= config.bin %> <%= command.id %> --config-path=/myCustomConfig.json`,
+        }),
+        force: core_1.Flags.boolean({
+            description: 'bypass the confirmation prompt and force the command to run - this is useful for CI/CD pipelines',
+            default: false,
+            hidden: true,
+        }),
+    };
+    async catch(error) {
+        /* istanbul ignore if */
+        if ((0, errors_1.handleError)(error)) {
+            this.exit(-1);
+        }
+        throw error;
+    }
+    async run() {
+        (0, integrations_1.validateIsIntegrationDirectory)();
+        const { flags } = await this.parse(Publish);
+        // Read the configurations.
+        const globalConfiguration = await GlobalConfiguration.read(this.config.configDir);
+        const environment = flags.environment ?? GlobalConfiguration.Environment.Production;
+        const integrationConfiguration = await IntegrationConfiguration.getConfiguration(environment, flags['config-path']);
+        if (integrationConfiguration.authorizations) {
+            integrationConfiguration.authorizations = integrationConfiguration.authorizations.filter(authorization => !authorization.development);
+        }
+        // Login to the platform.
+        await (0, integrationsPlatform_1.validateAuthenticated)(globalConfiguration, environment);
+        // Package the integration.
+        tmp_1.default.setGracefulCleanup();
+        if (flags['live-preview']) {
+            await this.livePreviewIntegration(integrationConfiguration);
+        }
+        else if (flags['registry-only']) {
+            let proceed = true;
+            if (!flags.force && environment === GlobalConfiguration.Environment.Production) {
+                ({ proceed } = await inquirer_1.default.prompt({
+                    name: 'proceed',
+                    message: '🙈🔫 You are about to update an integration in production directly. This is unusual, you should go through the normal publish and review process, are you sure you want to proceed?',
+                    type: 'confirm',
+                }));
+            }
+            if (proceed) {
+                core_1.ux.log(`🙈 Hang on tight, updating Integration ${integrationConfiguration.name} information's in ${environment}!`);
+                await this.updateRegistry(integrationConfiguration);
+            }
+            else {
+                core_1.ux.log('🙊 Abort! You are safe now 🍸 relax');
+            }
+        }
+        else {
+            // Switch to a temporary directory to avoid modifying local files.
+            this.copyAndMoveToTmpDir();
+            if (flags.preview) {
+                await this.previewIntegration(integrationConfiguration);
+            }
+            else {
+                await this.publishIntegration(integrationConfiguration);
+            }
+        }
+    }
+    async livePreviewIntegration(integrationConfiguration) {
+        // Get the profile.
+        core_1.ux.action.start('Get profile');
+        const profile = await IntegrationsPlatform.getProfile();
+        core_1.ux.action.stop();
+        // Generate a new name.
+        const newName = `${integrationConfiguration.name}-live-preview-${this.hashEmail(profile.email)}`;
+        // Update the secrets.
+        const updatedConfiguration = await this.generateNewSecrets(integrationConfiguration, newName);
+        // Update the name.
+        updatedConfiguration.name = newName;
+        // Update the display name.
+        if (updatedConfiguration.ui?.displayName) {
+            updatedConfiguration.ui.displayName = [
+                updatedConfiguration.ui.displayName,
+                'Live Preview',
+                this.hashEmail(profile.email),
+            ].join(' - ');
+        }
+        // Start ngrok & update the base url.
+        core_1.ux.action.start('Starting ngrok');
+        updatedConfiguration.baseUrl = await ngrok_1.default.connect(9200);
+        core_1.ux.action.stop();
+        // Update the registry.
+        await this.updateRegistry(updatedConfiguration);
+        // Launch the process.
+        core_1.ux.log('Launching the integration');
+        child_process_1.default.spawn('npm', ['run', 'dev'], {
+            stdio: 'inherit',
+            env: { ...process.env, NODE_ENV: 'development', PORT: '9200' },
+        });
+    }
+    async updateRegistry(integrationConfiguration) {
+        const integrations = await IntegrationsPlatform.getIntegrations();
+        const existing = integrations.find(integration => integration.name === integrationConfiguration.name);
+        // Create or update the integration.
+        let updated;
+        for (const authorization of integrationConfiguration.authorizations ?? []) {
+            authorization.instructionsImage = await this.getInstructionsImage(authorization.name);
+            authorization.instructionsMarkdown = await this.getInstructionsMarkdown(authorization.name);
+        }
+        if (existing) {
+            core_1.ux.action.start('Integration found. Updating');
+            updated = await IntegrationsPlatform.updateIntegration(existing.id, integrationConfiguration);
+        }
+        else {
+            core_1.ux.action.start('Integration not found. Creating');
+            updated = await IntegrationsPlatform.createIntegration(integrationConfiguration);
+        }
+        core_1.ux.action.stop();
+        // Summary of the operation.
+        core_1.ux.log('');
+        core_1.ux.log(`The integration was ${existing ? 'updated' : 'created'} with the following information:`);
+        core_1.ux.log('');
+        core_1.ux.log((0, json_colorizer_1.default)(this.indent(JSON.stringify(updated, null, 2))));
+        core_1.ux.log('');
+        core_1.ux.log('The authorization instructions were updated as follow:');
+        core_1.ux.log('');
+        for (const authorization of integrationConfiguration.authorizations ?? []) {
+            core_1.ux.log(`  ${authorization.name}:`);
+            core_1.ux.log(`    image: ${authorization.instructionsImage ? '<set>' : '<unset>'}`);
+            core_1.ux.log(`    markdown: ${authorization.instructionsMarkdown ? '<set>' : '<unset>'}`);
+        }
+        core_1.ux.log('');
+    }
+    copyAndMoveToTmpDir() {
+        // Copy integration in tmp folder.
+        core_1.ux.action.start('Packaging');
+        const archivePath = this.archiveIntegration();
+        const tmpDir = tmp_1.default.dirSync();
+        child_process_1.default.execSync(`unzip ${archivePath} -d ${tmpDir.name}`);
+        // Change the working directory.
+        process.chdir(tmpDir.name);
+        child_process_1.default.execSync('git init . --initial-branch=main');
+    }
+    async previewIntegration(integrationConfiguration) {
+        // Get the profile.
+        core_1.ux.action.start('Get profile');
+        const profile = await IntegrationsPlatform.getProfile();
+        core_1.ux.action.stop();
+        // Generate a new name.
+        const newName = `${integrationConfiguration.name}-preview-${this.hashEmail(profile.email)}`;
+        // Update the secrets.
+        const updatedConfiguration = await this.generateNewSecrets(integrationConfiguration, newName);
+        core_1.ux.action.start('Creating preview');
+        // Update the name.
+        updatedConfiguration.name = newName;
+        // Update the display name.
+        if (updatedConfiguration.ui?.displayName) {
+            updatedConfiguration.ui.displayName = [
+                updatedConfiguration.ui.displayName,
+                'Preview',
+                this.hashEmail(profile.email),
+            ].join(' - ');
+        }
+        // Write the updated configuration on disk.
+        await IntegrationConfiguration.writeConfiguration(updatedConfiguration);
+        core_1.ux.action.stop();
+        // Publish the integration.
+        await this.publishIntegration(updatedConfiguration);
+    }
+    async publishIntegration(integrationConfiguration) {
+        // Packaging the integration.
+        core_1.ux.action.start('Packaging');
+        // Write the final configuration on disk.
+        await IntegrationConfiguration.writeConfiguration(integrationConfiguration);
+        const archivePath = this.archiveIntegration();
+        core_1.ux.action.stop();
+        // Publish the integration.
+        core_1.ux.action.start('Publishing');
+        await IntegrationsPlatform.publishIntegration(archivePath);
+        core_1.ux.action.stop();
+        // Summary of the operation.
+        core_1.ux.log('');
+        core_1.ux.log(['Your integration', gradient.fruit(integrationConfiguration.name), 'is being published.'].join(' '));
+        core_1.ux.log(chalk_1.default.yellowBright("Note that if the code of your integration did not change, it won't be republished."));
+    }
+    indent(paragraph, tabs = 1) {
+        return paragraph
+            .split('\n')
+            .map(line => [' '.repeat(Math.max(0, tabs) * 2), line].join(''))
+            .join('\n');
+    }
+    archiveIntegration() {
+        const archivePath = tmp_1.default.tmpNameSync({ postfix: `.zip` });
+        child_process_1.default.execSync(`git ls-files --cached --others --exclude-standard | zip -@ ${archivePath}`, {
+            cwd: process.cwd(),
+            env: { ...process.env },
+        });
+        return archivePath;
+    }
+    hashEmail(email) {
+        return crypto_1.default.createHash('shake256', { outputLength: 2 }).update(email).digest('hex');
+    }
+    async generateNewSecrets(integrationConfiguration, newIntegrationName) {
+        core_1.ux.action.start(`Reencrypting with name ${newIntegrationName}`);
+        const updatedConfiguration = JSON.parse(JSON.stringify(integrationConfiguration)); // deep copy.
+        for (const authorization of updatedConfiguration.authorizations ?? []) {
+            /* istanbul ignore if */
+            if (!authorization.oauth2) {
+                continue;
+            }
+            for (const [fieldName, value] of Object.entries(authorization.oauth2)) {
+                const newlyEncryptedData = await this.reencryptData(integrationConfiguration.name, [authorization.name, fieldName].join(':'), value, newIntegrationName);
+                if (newlyEncryptedData) {
+                    authorization.oauth2[fieldName] = newlyEncryptedData;
+                }
+            }
+        }
+        for (const [key, secret] of Object.entries(updatedConfiguration.secrets ?? {})) {
+            const newlyEncryptedData = await this.reencryptData(integrationConfiguration.name, `secrets:${key}`, secret, newIntegrationName);
+            if (newlyEncryptedData) {
+                updatedConfiguration.secrets[key] = newlyEncryptedData;
+            }
+        }
+        core_1.ux.action.stop();
+        return updatedConfiguration;
+    }
+    async reencryptData(originalIntegrationName, key, encryptedData, newIntegrationName) {
+        if (typeof encryptedData !== 'string') {
+            return;
+        }
+        if (!encryptedData.startsWith('unito-secret-')) {
+            core_1.ux.log(`Skipping ${key}`);
+            return;
+        }
+        core_1.ux.log(`Reencrypting ${key}`);
+        const { encryptedData: reencryptedData } = await IntegrationsPlatform.reencryptData(originalIntegrationName, encryptedData, newIntegrationName);
+        return reencryptedData;
+    }
+    async getInstructionsImage(authName) {
+        const extensions = ['png', 'jpg', 'jpeg'];
+        for (const ext of extensions) {
+            const fileName = [process.cwd(), 'assets', `instructions.${authName}.${ext}`].join('/');
+            const fileBuffer = await (0, fileSystem_1.getFileBuffer)(fileName, 400 * 1024); // 400 KB size limit
+            if (fileBuffer) {
+                const mimeType = ext === 'png' ? 'image/png' : 'image/jpeg';
+                return `data:${mimeType};base64,${fileBuffer.toString('base64')}`;
+            }
+        }
+        return null;
+    }
+    async getInstructionsMarkdown(authName) {
+        const fileName = [process.cwd(), 'assets', `instructions.${authName}.md`].join('/');
+        const fileBuffer = await (0, fileSystem_1.getFileBuffer)(fileName, 64 * 1024); // 64 KB size limit
+        return fileBuffer?.toString('utf8') ?? null;
+    }
+}
+exports.default = Publish;

package/dist/src/commands/test.d.ts

@@ -0,0 +1,9 @@
+import { FlagInput } from '@oclif/core/lib/interfaces/parser';
+import { BaseCommand } from '../baseCommand';
+export default class Test extends BaseCommand<typeof Test> {
+    static description: string;
+    static examples: string[];
+    static flags: FlagInput;
+    catch(error: Error): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/src/commands/test.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const child_process_1 = tslib_1.__importDefault(require("child_process"));
+const crawlerDriver_1 = require("@unito/integration-debugger/dist/src/services/crawlerDriver");
+const baseCommand_1 = require("../baseCommand");
+const errors_1 = require("../errors");
+const GlobalConfiguration = tslib_1.__importStar(require("../resources/globalConfiguration"));
+const integrations_1 = require("../resources/integrations");
+const configuration_1 = require("../resources/configuration");
+const decryption_1 = require("../resources/decryption");
+class Test extends baseCommand_1.BaseCommand {
+    static description = 'Test your integration';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        environment: core_1.Flags.custom({
+            description: 'the environment of the platform',
+            options: Object.values(GlobalConfiguration.Environment),
+            default: GlobalConfiguration.Environment.Production,
+        })(),
+        verbose: core_1.Flags.boolean({
+            description: 'output more (debug) information',
+            default: false,
+        }),
+        'starting-path': core_1.Flags.string({
+            description: 'starting path of the crawler',
+            default: '/',
+        }),
+        'starting-operation': core_1.Flags.custom({
+            description: 'starting operation of the crawler',
+            options: Object.values(crawlerDriver_1.Operation),
+            default: crawlerDriver_1.Operation.GetItem,
+        })(),
+        'output-path': core_1.Flags.string({
+            description: 'output report in JSON format at the specified path',
+        }),
+        'credential-payload': core_1.Flags.string({
+            description: '(advanced) credential to use.',
+        }),
+        'test-account': core_1.Flags.string({
+            description: 'Test account to use.',
+            options: Object.values(configuration_1.CredentialScope),
+            default: configuration_1.CredentialScope.DEVELOPMENT,
+        }),
+        crawlMode: core_1.Flags.string({
+            description: 'mode to use while crawling the integration graph',
+            options: Object.values(configuration_1.CrawlMode),
+            default: configuration_1.CrawlMode.FULL,
+        }),
+        checks: core_1.Flags.string({
+            description: 'checks to perform while crawling the integration graph',
+            multiple: true,
+            default: [],
+        }),
+        debug: core_1.Flags.boolean({
+            description: 'Log launch command to console before running it - including decrypted values - for debugging only',
+            hidden: true,
+            default: false,
+        }),
+        'config-path': core_1.Flags.string({
+            summary: 'relative path to a custom ".unito.json" file',
+            description: `Use a custom configuration file instead of the default '.unito.json' or other environment specific
+      ones.
+
+      If you want to force the CLI to use a specific configuration file, you can use this flag to specify the relative
+      path from your integration's root folder (with a leading '/').
+
+      Usage: <%= config.bin %> <%= command.id %> --config-path=/myCustomConfig.json`,
+        }),
+    };
+    async catch(error) {
+        /* istanbul ignore if */
+        if ((0, errors_1.handleError)(error)) {
+            this.exit(-1);
+        }
+        throw error;
+    }
+    async run() {
+        (0, integrations_1.validateIsIntegrationDirectory)();
+        const { flags } = await this.parse(Test);
+        // Install NPM dependencies.
+        core_1.ux.action.start('Installing NPM dependencies');
+        child_process_1.default.execSync('npm install', {
+            env: { ...process.env, NODE_ENV: 'development' },
+            stdio: ['ignore', 'ignore', 'inherit'],
+        });
+        core_1.ux.action.stop();
+        // Resolve the configuration.
+        const environment = flags.environment ?? GlobalConfiguration.Environment.Production;
+        const configuration = await (0, configuration_1.getConfiguration)(environment, flags['config-path']);
+        let credentialPayload = flags['credential-payload'];
+        // Default to test account's credentials if none are specifically provided
+        if (credentialPayload === null || credentialPayload === undefined) {
+            const decryptedCredentials = await (0, decryption_1.decryptTestAccountCredentials)(configuration, environment, flags['test-account'], this.config.configDir);
+            credentialPayload = JSON.stringify(decryptedCredentials);
+        }
+        if (!credentialPayload || credentialPayload === '{}') {
+            throw new errors_1.MissingCredentialsError();
+        }
+        // Decrypt secrets, if necessary.
+        const secrets = await (0, decryption_1.decryptSecrets)(configuration, environment, this.config.configDir);
+        // Launch the tests.
+        const commandArguments = [
+            `${process.env.NODE_MODULES_FOLDER}/@unito/integration-debugger/dist/src/index.js`,
+            '--integration-url=http://localhost:9200',
+            '--spawn-process=npm run dev',
+            `--credential-payload=${credentialPayload}`,
+            `--secrets-payload=${JSON.stringify(secrets)}`,
+            '--non-interactive',
+            `--starting-path=${flags['starting-path']}`,
+            `--starting-operation=${flags['starting-operation']}`,
+        ];
+        if (configuration.graphRelativeUrl) {
+            commandArguments.push(`--graph-relative-url=${configuration.graphRelativeUrl}`);
+        }
+        if (configuration.credentialAccountRelativeUrl) {
+            commandArguments.push(`--credential-account-relative-url=${configuration.credentialAccountRelativeUrl}`);
+        }
+        if (configuration.webhookParsingRelativeUrl) {
+            commandArguments.push(`--webhook-parsing-relative-url=${configuration.webhookParsingRelativeUrl}`);
+        }
+        if (configuration.webhookSubscriptionsRelativeUrl) {
+            commandArguments.push(`--webhook-subscriptions-relative-url=${configuration.webhookSubscriptionsRelativeUrl}`);
+        }
+        if (configuration.webhookAcknowledgeRelativeUrl) {
+            commandArguments.push(`--webhook-acknowledge-relative-url=${configuration.webhookAcknowledgeRelativeUrl}`);
+        }
+        if (flags.checks?.length) {
+            commandArguments.push(`--checks=${flags.checks.join(',')}`);
+        }
+        if (flags.verbose) {
+            commandArguments.push('--verbose');
+        }
+        if (flags['output-path']) {
+            commandArguments.push(`--output-path=${flags['output-path']}`);
+        }
+        if (flags['crawlMode'] === configuration_1.CrawlMode.SAMPLE) {
+            commandArguments.push('--operation-collection-items-per-page=10');
+            commandArguments.push('--operation-collection-follow-next-pages=false');
+        }
+        if (flags['crawlMode'] === configuration_1.CrawlMode.SINGLE) {
+            commandArguments.push('--operation-collection-items-per-page=1');
+            commandArguments.push('--operation-collection-follow-next-pages=false');
+        }
+        if (flags.debug) {
+            core_1.ux.log(`Launching... node ${commandArguments.join(' ')}`);
+        }
+        const child = child_process_1.default.spawn('node', commandArguments, {
+            detached: true,
+            stdio: 'inherit',
+            env: { ...process.env, NODE_ENV: 'development', PORT: '9200' },
+        });
+        // istanbul ignore next
+        child.on('exit', (code) => {
+            process.exit(code);
+        });
+        // Window change (ex: resize) signal.
+        // istanbul ignore next
+        process.on('SIGWINCH', () => {
+            child.kill('SIGWINCH');
+        });
+    }
+}
+exports.default = Test;

package/dist/src/commands/upgrade.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from '../baseCommand';
+export default class Upgrade extends BaseCommand<typeof Upgrade> {
+    static description: string;
+    static examples: string[];
+    catch(error: Error): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/src/commands/upgrade.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const child_process_1 = tslib_1.__importDefault(require("child_process"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const baseCommand_1 = require("../baseCommand");
+const errors_1 = require("../errors");
+const errors_2 = require("../errors");
+class Upgrade extends baseCommand_1.BaseCommand {
+    static description = 'Upgrade the CLI';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    /* istanbul ignore next */
+    async catch(error) {
+        if ((0, errors_1.handleError)(error)) {
+            this.exit(-1);
+        }
+        throw error;
+    }
+    async run() {
+        //
+        // Check for the presence of UNITO_GITHUB_PKG_TOKEN.
+        //
+        // Necessary until we deploy to a public NPM repository.
+        //
+        core_1.ux.action.start('Checking for the presence of UNITO_GITHUB_PKG_TOKEN');
+        // istanbul ignore next
+        if (!process.env.UNITO_GITHUB_PKG_TOKEN) {
+            throw new errors_2.MissingEnvironmentVariableError('UNITO_GITHUB_PKG_TOKEN');
+        }
+        core_1.ux.action.stop('found');
+        //
+        // Global command options
+        //
+        const packageName = '@unitoio/integration-cli';
+        const execOptions = { env: { ...process.env } };
+        const npmOptions = [
+            '--global',
+            '--registry=https://npm.pkg.github.com/unitoio',
+            '--//npm.pkg.github.com/:_authToken=$UNITO_GITHUB_PKG_TOKEN',
+        ].join(' ');
+        //
+        // Current version
+        //
+        core_1.ux.action.start('Checking the current version');
+        const currentVersion = child_process_1.default
+            .execSync(`npm list ${npmOptions} --depth 0 | grep ${packageName} | sed "s/.*@\\([^@]*\\)$/\\1/"`, execOptions)
+            .toString()
+            .trim();
+        core_1.ux.action.stop(currentVersion);
+        //
+        // Next version
+        //
+        core_1.ux.action.start('Checking the available version');
+        const newVersion = child_process_1.default
+            .execSync(`npm show ${npmOptions} ${packageName} version`, execOptions)
+            .toString()
+            .trim();
+        core_1.ux.action.stop(newVersion);
+        //
+        // Latest version
+        //
+        const latestVersion = currentVersion === newVersion;
+        if (latestVersion) {
+            core_1.ux.log(chalk_1.default.yellowBright("You already have the latest version but let's make sure it is working properly!"));
+        }
+        //
+        // Validate / Upgrade the package globally.
+        //
+        core_1.ux.action.start(`${latestVersion ? 'Validating' : 'Upgrading'} the package`);
+        // To make sure we have a clean version of the CLI, with updated packages, we force the re-installation.
+        child_process_1.default.execSync(`npm install --force ${npmOptions} ${packageName}`, {
+            ...execOptions,
+            stdio: ['ignore', 'ignore', 'inherit'],
+        });
+        core_1.ux.action.stop();
+        //
+        // Validated / Upgraded.
+        //
+        if (latestVersion) {
+            core_1.ux.log(chalk_1.default.greenBright(`The CLI is valid! Enjoy!`));
+        }
+        else {
+            core_1.ux.log(chalk_1.default.greenBright(`Upgraded from ${currentVersion} to ${newVersion}! Enjoy!`));
+        }
+    }
+}
+exports.default = Upgrade;