@nosana/node 1.0.0-rc

package/dist/output-formatter/outputFormatSelector.js

@@ -0,0 +1,23 @@
+import { OutputFormatterFactory } from './OutputFormatterFactory.js';
+/**
+ * Singleton pattern to ensure a single instance of OutputFormatter.
+ * This function selects the appropriate formatter (JSON or Text) based on the input.
+ * @param {string} format - Options indicating whether to use JSON formatting. If text, uses Text formatting.
+ * @returns {OutputFormatter} - The singleton instance of OutputFormatter.
+ *
+ * Usage:
+ *
+ * ```typescript
+ * // To get a Text formatter
+ * const textFormatter = outputFormatSelector();
+ * ```
+ */
+export const outputFormatSelector = (() => {
+    let instance = null;
+    return (format) => {
+        if (!instance) {
+            instance = OutputFormatterFactory.createFormatter(format);
+        }
+        return instance;
+    };
+})();

package/dist/output-formatter/text/TextOutputEventHandlers.d.ts

@@ -0,0 +1,7 @@
+import { OutputEventParams } from '../outputEvents.js';
+type EventHandler<T extends keyof OutputEventParams> = (param: OutputEventParams[T]) => void;
+type OutputEventHandlers = {
+    [K in keyof OutputEventParams]: EventHandler<K>;
+};
+export declare const textOutputEventHandlers: OutputEventHandlers;
+export {};

package/dist/output-formatter/text/TextOutputEventHandlers.js

@@ -0,0 +1,128 @@
+import chalk from 'chalk';
+import figlet from 'figlet';
+import { OUTPUT_EVENTS, } from '../outputEvents.js';
+import { colors } from '../../NodeManager/utils/utils.js';
+function mapToDoNothingFunction(events) {
+    return events.reduce((handlers, event) => {
+        handlers[event] = () => { };
+        return handlers;
+    }, {});
+}
+export const textOutputEventHandlers = {
+    /**
+     * This is where we dump the event that you want to do nothing
+     * this is so you do not forget to integrate them and create error
+     */
+    ...mapToDoNothingFunction([
+        OUTPUT_EVENTS.OUTPUT_IPFS_UPLOADED,
+        OUTPUT_EVENTS.OUTPUT_JSON_FLOW_URL,
+        OUTPUT_EVENTS.OUTPUT_JOB_PRICE,
+        OUTPUT_EVENTS.OUTPUT_JOB_POSTING,
+        OUTPUT_EVENTS.OUTPUT_JOB_POSTED_TX,
+        OUTPUT_EVENTS.OUTPUT_RESULT_URL,
+        OUTPUT_EVENTS.OUTPUT_JOB_EXECUTION,
+    ]),
+    [OUTPUT_EVENTS.OUTPUT_SERVICE_URL]: (param) => {
+        const urls = param.url.split(',').map((url) => `https://${url}`);
+        console.log(chalk.cyan(`Service URL:\t`), urls);
+    },
+    [OUTPUT_EVENTS.OUTPUT_PRIVATE_URL_MESSAGE]: (param) => {
+        console.log(chalk.cyan(`this servcie exposed url is private and will be available when a node picks up this job`));
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_SERVICE_URL]: (param) => {
+        console.log(`URL:\t\t${colors.GREEN}${param.url}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_INVALID]: () => {
+        console.error(chalk.red('Invalid job entered'));
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_EXPIRED]: (param) => {
+        console.error(chalk.red(`Job exposed URL is expired since Job has been ${param.state}`));
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_NOT_READY]: () => {
+        console.error(chalk.red('Job exposed URL is not ready yet'));
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_ERROR]: (param) => {
+        throw new Error(`Failed to fetch exposed URL \n${param.error.message}`);
+    },
+    [OUTPUT_EVENTS.READ_KEYFILE]: (param) => {
+        console.log(`Reading keypair from ${colors.CYAN}${param.keyfile}${colors.RESET}\n`);
+    },
+    [OUTPUT_EVENTS.EMPTY_KEYFILE]: (param) => {
+        console.log(`Found empty string within ${colors.CYAN}${param.keyfile}${colors.RESET}\n`);
+    },
+    [OUTPUT_EVENTS.CREATE_KEYFILE]: (param) => {
+        console.log(`Creating new keypair and storing it in ${colors.CYAN}${param.keyfile}${colors.RESET}\n`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_BALANCES]: (param) => {
+        console.log(`SOL balance:\t${colors.GREEN}${param.sol} SOL${colors.RESET}`);
+        console.log(`NOS balance:\t${colors.GREEN}${param.nos} NOS${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_NETWORK]: (param) => {
+        console.log(`Network:\t${colors.GREEN}${param.network}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_WALLET]: (param) => {
+        console.log(`Wallet:\t\t${colors.GREEN}${param.publicKey}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL]: (param) => {
+        console.log(`Job:\t\t${colors.BLUE}${param.job_url}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_MARKET_URL]: (param) => {
+        console.log(`Market:\t\t${colors.BLUE}${param.market_url}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_TOTAL_COST]: (param) => {
+        console.log(`Total Costs:\t${colors.CYAN}${param.cost} NOS${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_STATUS]: (param) => {
+        console.log(`Status:\t\t${param.status === 'COMPLETED' ? colors.GREEN : colors.CYAN}${param.status}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTER_AUTH_TOKEN]: (param) => {
+        console.log(`Authorization:\t${colors.GREEN}${param}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_VALIDATION_ERROR]: (param) => {
+        console.error(param.error);
+        throw new Error(chalk.red.bold('Job Definition validation failed'));
+    },
+    [OUTPUT_EVENTS.OUTPUT_FAILED_TO_FETCH_MARKETS_ERROR]: (param) => {
+        throw new Error(`Failed to fetch market \n${param.error.message}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTED_ERROR]: (param) => {
+        console.error(chalk.red("Couldn't post job"));
+        throw param;
+    },
+    [OUTPUT_EVENTS.OUTPUT_SOL_BALANCE_LOW_ERROR]: (param) => {
+        throw new Error(chalk.red(`Minimum of ${chalk.bold('0.005')} SOL needed: SOL available ${chalk.bold(param.sol)}`));
+    },
+    [OUTPUT_EVENTS.OUTPUT_NOS_BALANCE_LOW_ERROR]: (param) => {
+        throw new Error(chalk.red(`Not enough NOS: NOS available ${chalk.bold(param.nosBalance)}, NOS needed: ${chalk.bold(param.nosNeeded)}`));
+    },
+    [OUTPUT_EVENTS.OUTPUT_AIRDROP_REQUEST_FAILED_ERROR]: (param) => {
+        throw new Error('Couldnt airdrop tokens to your address');
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_NOT_FOUND]: (param) => {
+        console.error(`${colors.RED}Could not retrieve job\n${colors.RESET}`, param.error);
+    },
+    [OUTPUT_EVENTS.OUTPUT_CANNOT_LOG_RESULT]: () => {
+        console.log(`${colors.RED}Cannot log results${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_ARTIFACT_SUPPORT_INCOMING_ERROR]: (param) => {
+        throw new Error('artifact support coming soon!');
+    },
+    [OUTPUT_EVENTS.OUTPUT_JSON_FLOW_TYPE_NOT_SUPPORTED_ERROR]: (param) => {
+        throw new Error(`type ${param.type} not supported yet`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_NODE_URL]: (param) => {
+        console.log(`Node:\t\t${colors.BLUE}${param.url}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_DURATION]: (param) => {
+        console.log(`Duration:\t${colors.CYAN}${param.duration} seconds${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_START_TIME]: (param) => {
+        console.log(`Start Time:\t${colors.CYAN}${param.date}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_RETRIVE_JOB_COMMAND]: (param) => {
+        console.log(`\nrun ${colors.CYAN}nosana job get ${param.job} --network ${param.network}${colors.RESET} to retrieve job and result`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_HEADER_LOGO]: (param) => {
+        console.log(figlet.textSync(param.text));
+    },
+};

package/dist/output-formatter/text/TextOutputFormatter.d.ts

@@ -0,0 +1,6 @@
+import { OutputEvent, OutputEventParams } from '../outputEvents.js';
+import { OutputFormatterAdapter } from '../OutputFormatter.js';
+export declare class TextOutputFormatter implements OutputFormatterAdapter {
+    finalize(): void;
+    output<T extends OutputEvent>(event: T, param: OutputEventParams[T]): void;
+}

package/dist/output-formatter/text/TextOutputFormatter.js

@@ -0,0 +1,7 @@
+import { textOutputEventHandlers } from './TextOutputEventHandlers.js';
+export class TextOutputFormatter {
+    finalize() { }
+    output(event, param) {
+        textOutputEventHandlers[event](param);
+    }
+}

package/dist/output-formatter/text/VerboseTextOutputEventHandlers.d.ts

@@ -0,0 +1,7 @@
+import { OutputEventParams } from '../outputEvents.js';
+type EventHandler<T extends keyof OutputEventParams> = (param: OutputEventParams[T]) => void;
+type OutputEventHandlers = {
+    [K in keyof OutputEventParams]: EventHandler<K>;
+};
+export declare const verboseTextOutputEventHandlers: OutputEventHandlers;
+export {};

package/dist/output-formatter/text/VerboseTextOutputEventHandlers.js

@@ -0,0 +1,138 @@
+import chalk from 'chalk';
+import figlet from 'figlet';
+import { OUTPUT_EVENTS, } from '../outputEvents.js';
+import { colors } from '../../NodeManager/utils/utils.js';
+export const verboseTextOutputEventHandlers = {
+    [OUTPUT_EVENTS.READ_KEYFILE]: (param) => {
+        console.log(`Reading keypair from ${colors.CYAN}${param.keyfile}${colors.RESET}\n`);
+    },
+    [OUTPUT_EVENTS.EMPTY_KEYFILE]: (param) => {
+        console.log(`Found empty string within ${colors.CYAN}${param.keyfile}${colors.RESET}\n`);
+    },
+    [OUTPUT_EVENTS.CREATE_KEYFILE]: (param) => {
+        console.log(`Creating new keypair and storing it in ${colors.CYAN}${param.keyfile}${colors.RESET}\n`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_BALANCES]: (param) => {
+        console.log(`SOL balance:\t${colors.GREEN}${param.sol} SOL${colors.RESET}`);
+        console.log(`NOS balance:\t${colors.GREEN}${param.nos} NOS${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_NETWORK]: (param) => {
+        console.log(`Network:\t${colors.GREEN}${param.network}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_WALLET]: (param) => {
+        console.log(`Wallet:\t\t${colors.GREEN}${param.publicKey}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_IPFS_UPLOADED]: (param) => {
+        console.log(`IPFS uploaded:\t${colors.BLUE}${param.ipfsHash}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_SERVICE_URL]: (param) => {
+        console.log(chalk.cyan(`Service URL:\t${chalk.bold(`https://${param.url}`)}`));
+    },
+    [OUTPUT_EVENTS.OUTPUT_PRIVATE_URL_MESSAGE]: (param) => {
+        console.log(chalk.cyan(`this servcie exposed url is private you can access it once a node picks up this job via the command: ${chalk.bold(param.command)}`));
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_SERVICE_URL]: (param) => {
+        console.log(`Node:\t${colors.GREEN}${param.url}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_INVALID]: () => {
+        console.error(chalk.red('Invalid job entered'));
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_EXPIRED]: (param) => {
+        console.error(chalk.red(`Job exposed URL is expired since Job has been ${param.state}`));
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_NOT_READY]: () => {
+        console.error(chalk.red('Job exposed URL is not ready yet'));
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_ERROR]: (param) => {
+        throw new Error(`Failed to fetch exposed URL \n${param.error.message}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL]: (param) => {
+        console.log(`Job URL:\t${colors.BLUE}${param.job_url}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JSON_FLOW_URL]: (param) => {
+        console.log(`JSON flow:\t${colors.BLUE}${param.json_flow_url}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_MARKET_URL]: (param) => {
+        console.log(`Market:\t\t${colors.BLUE}${param.market_url}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_PRICE]: (param) => {
+        console.log(`Price:\t\t${colors.CYAN}${param.price} NOS/s${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_TOTAL_COST]: (param) => {
+        console.log(`Total Costs:\t${colors.CYAN}${param.cost} NOS${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_STATUS]: (param) => {
+        console.log(`Status:\t\t${param.status === 'COMPLETED' ? colors.GREEN : colors.CYAN}${param.status}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTER_AUTH_TOKEN]: (param) => {
+        console.log(`Authorization:\t${colors.GREEN}${param}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTING]: (param) => {
+        console.log(`Job:\t\t${colors.CYAN}${param.market_address}${colors.RESET} for price ${colors.YELLOW}${param.price} NOS/s${colors.RESET} (total: ${param.total} NOS)`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTED_TX]: (param) => {
+        console.log(`Solana tx:\t${colors.CYAN}https://explorer.solana.com/tx/${param.tx}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_VALIDATION_ERROR]: (param) => {
+        console.error(param.error);
+        throw new Error(chalk.red.bold('Job Definition validation failed'));
+    },
+    [OUTPUT_EVENTS.OUTPUT_FAILED_TO_FETCH_MARKETS_ERROR]: (param) => {
+        throw new Error(`Failed to fetch market \n${param.error.message}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTED_ERROR]: (param) => {
+        console.error(chalk.red("Couldn't post job"));
+        throw param;
+    },
+    [OUTPUT_EVENTS.OUTPUT_SOL_BALANCE_LOW_ERROR]: (param) => {
+        throw new Error(chalk.red(`Minimum of ${chalk.bold('0.005')} SOL needed: SOL available ${chalk.bold(param.sol)}`));
+    },
+    [OUTPUT_EVENTS.OUTPUT_NOS_BALANCE_LOW_ERROR]: (param) => {
+        throw new Error(chalk.red(`Not enough NOS: NOS available ${chalk.bold(param.nosBalance)}, NOS needed: ${chalk.bold(param.nosNeeded)}`));
+    },
+    [OUTPUT_EVENTS.OUTPUT_AIRDROP_REQUEST_FAILED_ERROR]: (param) => {
+        throw new Error('Couldnt airdrop tokens to your address');
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_NOT_FOUND]: (param) => {
+        console.error(`${colors.RED}Could not retrieve job\n${colors.RESET}`, param.error);
+    },
+    [OUTPUT_EVENTS.OUTPUT_CANNOT_LOG_RESULT]: () => {
+        console.log(`${colors.RED}Cannot log results${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_ARTIFACT_SUPPORT_INCOMING_ERROR]: (param) => {
+        throw new Error('artifact support coming soon!');
+    },
+    [OUTPUT_EVENTS.OUTPUT_JSON_FLOW_TYPE_NOT_SUPPORTED_ERROR]: (param) => {
+        throw new Error(`type ${param.type} not supported yet`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_NODE_URL]: (param) => {
+        console.log(`Node:\t\t${colors.BLUE}${param.url}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_DURATION]: (param) => {
+        console.log(`Duration:\t${colors.CYAN}${param.duration} seconds${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_START_TIME]: (param) => {
+        console.log(`Start Time:\t${colors.CYAN}${param.date}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_RESULT_URL]: (param) => {
+        console.log(`Result:\t\t${colors.BLUE}${param.url}${colors.RESET}`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_RETRIVE_JOB_COMMAND]: (param) => {
+        console.log(`\nrun ${colors.CYAN}nosana job get ${param.job} --network ${param.network}${colors.RESET} to retrieve job and result`);
+    },
+    [OUTPUT_EVENTS.OUTPUT_HEADER_LOGO]: (param) => {
+        console.log(figlet.textSync(param.text));
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_EXECUTION]: (param) => {
+        console.log('Logs:');
+        console.log(`\n${colors.CYAN}- Executed step ${param.opState.operationId} in ${(param.opState.endTime - param.opState.startTime) / 1000}s${colors.RESET}\n`);
+        for (const log of param.opState.logs) {
+            const color = log.type === 'stderr' && param.opState.exitCode ? colors.RED : '';
+            const sanitizedLog = log.log;
+            console.log(`${color}${sanitizedLog}${colors.RESET}`);
+        }
+        if (param.opState.status) {
+            console.log(`\n${param.opState.exitCode ? colors.RED : colors.GREEN}Exited with status ${param.opState.status} with code ${param.opState.exitCode} ${colors.RESET}`);
+        }
+    },
+};

package/dist/output-formatter/text/VerboseTextOutputFormatter.d.ts

@@ -0,0 +1,6 @@
+import { OutputEvent, OutputEventParams } from '../outputEvents.js';
+import { OutputFormatterAdapter } from '../OutputFormatter.js';
+export declare class VerboseTextOutputFormatter implements OutputFormatterAdapter {
+    finalize(): void;
+    output<T extends OutputEvent>(event: T, param: OutputEventParams[T]): void;
+}

package/dist/output-formatter/text/VerboseTextOutputFormatter.js

@@ -0,0 +1,7 @@
+import { verboseTextOutputEventHandlers } from './VerboseTextOutputEventHandlers.js';
+export class VerboseTextOutputFormatter {
+    finalize() { }
+    output(event, param) {
+        verboseTextOutputEventHandlers[event](param);
+    }
+}

package/dist/output-formatter/text/__tests__/TextOutputFormatter.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/output-formatter/text/__tests__/TextOutputFormatter.spec.js

@@ -0,0 +1,25 @@
+import outputEventsMock from '../../__mocks__/outputEvents.mock.js';
+import { TextOutputFormatter } from '../TextOutputFormatter.js';
+import { OUTPUT_EVENTS } from '../../outputEvents.js';
+import { textOutputEventHandlers } from '../TextOutputEventHandlers.js';
+vi.mock('../TextOutputEventHandlers', () => {
+    return {
+        textOutputEventHandlers: outputEventsMock,
+    };
+});
+describe('TextOutputFormatter', () => {
+    let formatter;
+    beforeEach(() => {
+        formatter = new TextOutputFormatter();
+        vi.clearAllMocks();
+    });
+    it('should handle events and call the appropriate event handlers', () => {
+        const param = { keyfile: 'test-keyfile' };
+        const event = OUTPUT_EVENTS.READ_KEYFILE;
+        formatter.output(event, param);
+        expect(textOutputEventHandlers.READ_KEYFILE).toHaveBeenCalledWith(param);
+    });
+    it('should finalize and not perform any action', () => {
+        formatter.finalize();
+    });
+});

package/dist/static/index.d.ts

@@ -0,0 +1,7 @@
+import type { JobDefinition } from '@nosana/sdk';
+declare const pkg: {
+    version: string;
+    name: string;
+};
+declare const specsAndNetworkJob: JobDefinition;
+export { pkg, specsAndNetworkJob };

package/dist/static/index.js

@@ -0,0 +1,12 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const customDirname = path.dirname(fileURLToPath(import.meta.url));
+function readJsonFileSync(filePath) {
+    const absolutePath = path.resolve(customDirname, filePath);
+    const fileContent = fs.readFileSync(absolutePath, 'utf-8');
+    return JSON.parse(fileContent);
+}
+const pkg = readJsonFileSync('../../package.json');
+const specsAndNetworkJob = readJsonFileSync('./specs-and-network-job.json');
+export { pkg, specsAndNetworkJob };

package/dist/version/index.d.ts

@@ -0,0 +1 @@
+export declare function validateCLIVersion(): Promise<void>;

package/dist/version/index.js

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+import { pkg } from '../static/index.js';
+function requiresNewVersion(required, current) {
+    return parseInt(required) > parseInt(current);
+}
+function exitCleanly(currentVersion, latestVersion) {
+    console.log(chalk.red(`You are currently running Nosana CLI version ${currentVersion}. Version ${latestVersion} has been released, please update your CLI to the latest version using npm install ${pkg.name}.`));
+    process.exit(129);
+}
+export async function validateCLIVersion() {
+    try {
+        const [current_major, current_minor, current_patch] = pkg.version.split('.');
+        if (parseInt(current_major) === 0 &&
+            parseInt(current_minor) === 0 &&
+            parseInt(current_patch) === 0) {
+            console.warn(chalk.yellow('Running in dev mode, skipping version check'));
+            return;
+        }
+        const packageData = await fetch(`https://registry.npmjs.com/${pkg.name}`);
+        const packageJSON = await packageData.json();
+        const registryLatestVersion = packageJSON['dist-tags']?.latest;
+        if (!registryLatestVersion || typeof registryLatestVersion !== 'string') {
+            throw new Error('Could not retrieve valid package information from npm');
+        }
+        const [required_major, required_minor, required_patch] = registryLatestVersion.split('.');
+        if (parseInt(required_major) === parseInt(current_major)) {
+            if (parseInt(required_minor) === parseInt(current_minor)) {
+                if (requiresNewVersion(required_patch, current_patch)) {
+                    exitCleanly(pkg.version, registryLatestVersion);
+                }
+            }
+            else {
+                if (requiresNewVersion(required_minor, current_minor)) {
+                    exitCleanly(pkg.version, registryLatestVersion);
+                }
+            }
+        }
+        else {
+            if (requiresNewVersion(required_major, current_major)) {
+                exitCleanly(pkg.version, registryLatestVersion);
+            }
+        }
+    }
+    catch (error) {
+        console.log(`${chalk.red("Failed to fetch CLI's minium required version.")}\n${error}`);
+    }
+}