@cloud-copilot/cli 0.1.39 → 0.2.0

package/dist/esm/cli.js

@@ -1,120 +1,49 @@
 import { exit } from './utils.js';
-function isBooleanOption(option) {
-    return option.type === 'boolean';
-}
-function isEnumOption(option) {
-    return option.type === 'enum';
-}
-/**
- * Create a type safe configuration for CLI arguments.
- *
- * @param config the configuration for the CLI arguments.
- * @returns the configuration object.
- */
-export function createConfig(config) {
-    return config;
-}
 /**
  * Parse CLI Arguments and return the parsed typesafe results.
  *
  * @param command the name of the command arguments are being parsed for.
  * @param subcommands the list of subcommands that can be used, if any.
- * @param cliOptions the configuration options for the CLI command.
- * @param additionalArgs additional arguments to be used for parsing and displaying help.
+ * @param cliArgs the configuration options for the CLI command.
+ * @param additionalOptions additional arguments to be used for parsing and displaying help.
  * @returns the parsed arguments, operands, and subcommand if applicable.
  */
-export function parseCliArguments(command, subcommands, cliOptions, additionalArgs) {
-    const args = additionalArgs?.args ?? process.argv.slice(2);
-    const env = additionalArgs?.env ?? process.env;
+export async function parseCliArguments(command, subcommands, cliArgs, additionalOptions) {
+    const args = additionalOptions?.args ?? process.argv.slice(2);
+    const env = additionalOptions?.env ?? process.env;
     const parsedArgs = {};
     const operands = [];
     const booleanOptions = {};
     const subcommandKeys = Object.keys(subcommands);
     const numberOfSubcommands = subcommandKeys.length;
-    const combinedOptions = { ...cliOptions };
+    const combinedOptions = { ...cliArgs };
+    const logger = additionalOptions?.consoleLogger ?? console;
     let subcommand;
-    if (args.length === 0 && additionalArgs?.showHelpIfNoArgs) {
-        printHelpContents(command, subcommands, cliOptions, additionalArgs);
+    if (args.length === 0 && additionalOptions?.showHelpIfNoArgs) {
+        printHelpContents(command, subcommands, cliArgs, additionalOptions);
         exit(0, undefined);
         return {};
     }
     // Step 1: Initialize defaults
-    initializeOptionDefaults(parsedArgs, booleanOptions, cliOptions);
+    const parsedEnvironmentArgs = {};
+    initializeOptionDefaults(parsedEnvironmentArgs, booleanOptions, cliArgs);
     // Step 2: Handle environment variables
-    parseEnvironmentVariables(cliOptions, parsedArgs, env, additionalArgs?.envPrefix);
-    if (additionalArgs?.envPrefix) {
-        const prefix = additionalArgs.envPrefix + '_';
-        const envToKeys = Object.keys(cliOptions).reduce((acc, key) => {
-            acc[camelToCapitalSnakeCase(key)] = key;
-            return acc;
-        }, {});
-        for (const [key, value] of Object.entries(env)) {
-            if (key.startsWith(prefix)) {
-                const optionKey = key.slice(prefix.length);
-                const option = envToKeys[optionKey];
-                if (option) {
-                    const config = combinedOptions[option];
-                    if (isEnumOption(config)) {
-                        if (config.values === 'single') {
-                            const matchingValue = config.validValues.find((v) => v.toLowerCase() === value.toLowerCase());
-                            if (!matchingValue) {
-                                exit(2, `Environment ${key} allows only the following values: ${config.validValues.join(', ')}`);
-                            }
-                            parsedArgs[option] = matchingValue;
-                        }
-                        else if (config.values === 'multiple') {
-                            const invalidValues = [];
-                            const validValues = [];
-                            const values = value.split(' ');
-                            for (const v of values) {
-                                const matchingValue = config.validValues.find((valid) => valid.toLowerCase() === v.toLowerCase());
-                                if (matchingValue) {
-                                    validValues.push(matchingValue);
-                                }
-                                else {
-                                    invalidValues.push(value);
-                                }
-                            }
-                            if (invalidValues.length > 0) {
-                                exit(2, `Environment ${key} allows only the following values: ${config.validValues.join(', ')}`);
-                            }
-                            parsedArgs[option] = validValues;
-                        }
-                    }
-                    else if (config.type === 'boolean') {
-                        parsedArgs[option] = true;
-                    }
-                    else if (config.values === 'single') {
-                        const { parsed, invalid } = validateTypes(config.type, value);
-                        if (invalid.length > 0) {
-                            exit(2, `Environment ${key} expects a valid ${config.type}, but received: ${invalid.join(', ')}`);
-                        }
-                        parsedArgs[option] = parsed;
-                    }
-                    else if (config.values === 'multiple') {
-                        const values = value.split(' ');
-                        const { parsed, invalid } = validateTypes(config.type, values);
-                        if (invalid.length > 0) {
-                            exit(2, `Environment ${key} expects a valid ${config.type}, but received: ${invalid.join(', ')}`);
-                        }
-                        parsedArgs[option] = parsed;
-                    }
-                }
-            }
-        }
-    }
+    await parseEnvironmentVariables(cliArgs, parsedEnvironmentArgs, env, additionalOptions?.envPrefix);
     // Step 3: Group arguments into objects
     const commandChunks = groupArguments(args);
     // Step 4: Validation and parsing arguments
     for (const { first, rest, isLast, isFirst } of commandChunks) {
         // Handle --help and --version
         if (first === '--help') {
-            printHelpContents(command, subcommands, cliOptions, additionalArgs, subcommand);
+            printHelpContents(command, subcommands, cliArgs, additionalOptions, subcommand);
             exit(0, undefined);
+            return {};
         }
         if (first === '--version') {
-            if (additionalArgs?.version) {
-                exit(0, additionalArgs?.version);
+            if (additionalOptions?.version) {
+                await printVersion(additionalOptions.version, logger);
+                exit(0, undefined);
+                return {};
             }
         }
         // Handle commands if applicable
@@ -141,9 +70,9 @@ export function parseCliArguments(command, subcommands, cliOptions, additionalAr
                     return {};
                 }
                 subcommand = matchingCommands.at(0);
-                const subcommandOptions = subcommands[subcommand].options;
-                initializeOptionDefaults(parsedArgs, booleanOptions, subcommandOptions);
-                parseEnvironmentVariables(subcommandOptions, parsedArgs, env, additionalArgs?.envPrefix);
+                const subcommandOptions = subcommands[subcommand].arguments;
+                initializeOptionDefaults(parsedEnvironmentArgs, booleanOptions, subcommandOptions);
+                await parseEnvironmentVariables(subcommandOptions, parsedEnvironmentArgs, env, additionalOptions?.envPrefix);
                 for (const [key, option] of Object.entries(subcommandOptions)) {
                     combinedOptions[key] = option;
                 }
@@ -170,6 +99,16 @@ export function parseCliArguments(command, subcommands, cliOptions, additionalAr
                 matchingOption = exactMatch;
             }
             else {
+                if ('--help'.startsWith(first)) {
+                    printHelpContents(command, subcommands, cliArgs, additionalOptions, subcommand);
+                    exit(0, undefined);
+                    return {};
+                }
+                else if ('--version'.startsWith(first) && additionalOptions?.version) {
+                    await printVersion(additionalOptions.version, logger);
+                    exit(0, undefined);
+                    return {};
+                }
                 exit(2, `Unknown argument: ${first}`);
             }
             if (!matchingOption) {
@@ -177,93 +116,41 @@ export function parseCliArguments(command, subcommands, cliOptions, additionalAr
                 return {};
             }
             const optionConfig = combinedOptions[matchingOption];
-            if (isEnumOption(optionConfig)) {
-                if (rest.length === 0) {
-                    if (optionConfig.values === 'single') {
-                        exit(2, `Option ${first} expects a value, but received none`);
-                    }
-                    else {
-                        exit(2, `Option ${first} expects at least one value, but received none`);
-                    }
+            if (optionConfig.present) {
+                parsedArgs[matchingOption] = await optionConfig.present(parsedArgs[matchingOption]);
+            }
+            if (rest.length > 0 && optionConfig.character) {
+                if (!isLast) {
+                    exit(2, `Validation error for ${first}: does not accept values but received ${rest.join(', ')}`);
                     return {};
                 }
-                if (optionConfig.values === 'single') {
-                    if (rest.length > 1 && !isLast) {
-                        exit(2, `Option ${first} expects a single value, but received multiple: ${rest.join(', ')}`);
-                    }
-                    const value = rest[0];
-                    const matchingValue = optionConfig.validValues.find((v) => v.toLowerCase() === value.toLowerCase());
-                    if (!matchingValue) {
-                        exit(2, `Option ${first} allows only the following values: ${optionConfig.validValues.join(', ')}`);
-                    }
-                    parsedArgs[matchingOption] = matchingValue;
-                    operands.push(...rest.slice(1));
-                }
-                else if (optionConfig.values === 'multiple') {
-                    const invalidValues = [];
-                    const validValues = [];
-                    for (const value of rest) {
-                        const matchingValue = optionConfig.validValues.find((v) => v.toLowerCase() === value.toLowerCase());
-                        if (matchingValue) {
-                            validValues.push(matchingValue);
-                        }
-                        else {
-                            invalidValues.push(value);
-                        }
-                    }
-                    if (invalidValues.length > 0) {
-                        exit(2, `Option ${first} allows only the following values: ${optionConfig.validValues.join(', ')}`);
-                    }
-                    parsedArgs[matchingOption] = validValues;
-                }
-            }
-            else if (optionConfig.type === 'boolean') {
-                //set boolean value
-                parsedArgs[matchingOption] = true;
-                //Handle extra values
-                if (rest.length > 0) {
-                    if (!isLast) {
-                        exit(2, `Boolean option ${first} does not accept values`);
-                    }
-                    else {
-                        operands.push(...rest);
-                    }
+                else {
+                    operands.push(...rest);
                 }
             }
-            else if (optionConfig.values === 'single') {
-                if (rest.length === 0) {
-                    exit(2, `Option ${first} expects a value, but received none`);
-                }
-                //Validate the value
-                const { parsed, invalid } = validateTypes(optionConfig.type, rest[0]);
-                if (invalid.length > 0) {
-                    exit(2, `Option ${first} expects a valid ${optionConfig.type}, but received: ${invalid.join(', ')}`);
-                }
-                //Set the value
-                parsedArgs[matchingOption] = parsed;
-                if (rest.length > 1) {
-                    if (!isLast) {
-                        exit(2, `Option ${first} expects a single value, but received multiple: ${rest.join(', ')}`);
+            else {
+                const acceptsMultiple = optionConfig.acceptMultipleValues
+                    ? optionConfig.acceptMultipleValues()
+                    : false;
+                let theRest = rest;
+                if (!acceptsMultiple && rest.length > 1) {
+                    if (isLast) {
+                        theRest = [rest[0]];
+                        operands.push(...rest.slice(1));
                     }
                     else {
-                        operands.push(...rest.slice(1));
+                        exit(2, `Validation error for ${first}: expects a single value but received ${rest.join(', ')}`);
                     }
                 }
-            }
-            else if (optionConfig.values === 'multiple') {
-                if (rest.length === 0) {
-                    exit(2, `Option ${first} expects at least one value, but received none`);
+                const currentValue = parsedArgs[matchingOption];
+                const validation = await optionConfig.validateValues(currentValue, theRest);
+                if (!validation.valid) {
+                    exit(2, `Validation error for ${first}: ${validation.message}`);
+                    return {};
                 }
-                //Set the Value
-                //Validate the value
-                const { parsed, invalid } = validateTypes(optionConfig.type, rest);
-                if (invalid.length > 0) {
-                    exit(2, `Option ${first} expects a valid ${optionConfig.type}, but received: ${invalid.join(', ')}`);
+                else {
+                    parsedArgs[matchingOption] = await optionConfig.reduceValues(currentValue, validation.value);
                 }
-                parsedArgs[matchingOption] = parsed;
-            }
-            else {
-                throw new Error(`Unrecognized option values ${optionConfig.values}`);
             }
         }
         else if (first.startsWith('-')) {
@@ -284,56 +171,52 @@ export function parseCliArguments(command, subcommands, cliOptions, additionalAr
             }
         }
     }
-    if (numberOfSubcommands > 0 && additionalArgs?.requireSubcommand && !subcommand) {
+    if (numberOfSubcommands > 0 && additionalOptions?.requireSubcommand && !subcommand) {
         exit(2, `A subcommand is required`);
     }
     // Step 4: Return results
     return {
-        args: parsedArgs,
+        args: { ...parsedEnvironmentArgs, ...parsedArgs },
         operands,
         subcommand: subcommand,
         anyValues: args.length > 0,
         printHelp: () => {
-            printHelpContents(command, subcommands, cliOptions, additionalArgs, subcommand);
+            printHelpContents(command, subcommands, cliArgs, additionalOptions, subcommand);
         }
     };
 }
 /**
- * Initialize the default values for arguments
+ * Initialize the default values for arguments.
+ *
+ * Will populate the parsedArgs object with default values from the cliArguments.
+ * Will also populate the booleanOptions map with single character boolean options.
  *
  * @param parsedArgs the parsed arguments to default the values in
- * @param cliOptions the configuration options for the CLI commands
+ * @param booleanOptions a map of single character boolean options to their full names
+ * @param cliArguments the configuration options for the CLI commands
  */
-function initializeOptionDefaults(parsedArgs, booleanOptions, cliOptions) {
-    for (const [key, option] of Object.entries(cliOptions)) {
-        if (option.type === 'boolean') {
-            parsedArgs[key] = false; //(option as BooleanOption).default
-            if (option.character) {
-                booleanOptions[option.character.toLowerCase()] = key;
-            }
-        }
-        else if (option.values === 'single') {
-            parsedArgs[key] = undefined;
-        }
-        else if (option.values === 'multiple') {
-            parsedArgs[key] = [];
+function initializeOptionDefaults(parsedArgs, booleanOptions, cliArguments) {
+    for (const [key, option] of Object.entries(cliArguments)) {
+        parsedArgs[key] = option.defaultValue;
+        if (option.character) {
+            booleanOptions[option.character.toLowerCase()] = key;
         }
     }
 }
 /**
  * Parse environment variables and set the values in the parsed arguments.
  *
- * @param options the configuration options for the CLI commands
+ * @param cliArguments the configuration options for the CLI commands
  * @param parsedArgs the parsed arguments to set the values in
  * @param env the environment variables to get values from
  * @param envPrefix the prefix to use for environment variables, if any
  */
-function parseEnvironmentVariables(options, parsedArgs, env, envPrefix) {
+async function parseEnvironmentVariables(cliArguments, parsedArgs, env, envPrefix) {
     if (!envPrefix) {
         return;
     }
     const prefix = envPrefix + '_';
-    const envToKeys = Object.keys(options).reduce((acc, key) => {
+    const envToKeys = Object.keys(cliArguments).reduce((acc, key) => {
         acc[camelToCapitalSnakeCase(key)] = key;
         return acc;
     }, {});
@@ -342,51 +225,19 @@ function parseEnvironmentVariables(options, parsedArgs, env, envPrefix) {
             const optionKey = key.slice(prefix.length);
             const option = envToKeys[optionKey];
             if (option) {
-                const config = options[option];
-                if (isEnumOption(config)) {
-                    if (config.values === 'single') {
-                        const matchingValue = config.validValues.find((v) => v.toLowerCase() === value.toLowerCase());
-                        if (!matchingValue) {
-                            exit(2, `Environment ${key} allows only the following values: ${config.validValues.join(', ')}`);
-                        }
-                        parsedArgs[option] = matchingValue;
-                    }
-                    else if (config.values === 'multiple') {
-                        const invalidValues = [];
-                        const validValues = [];
-                        const values = value.split(' ');
-                        for (const v of values) {
-                            const matchingValue = config.validValues.find((valid) => valid.toLowerCase() === v.toLowerCase());
-                            if (matchingValue) {
-                                validValues.push(matchingValue);
-                            }
-                            else {
-                                invalidValues.push(value);
-                            }
-                        }
-                        if (invalidValues.length > 0) {
-                            exit(2, `Environment ${key} allows only the following values: ${config.validValues.join(', ')}`);
-                        }
-                        parsedArgs[option] = validValues;
-                    }
-                }
-                else if (config.type === 'boolean') {
-                    parsedArgs[option] = true;
-                }
-                else if (config.values === 'single') {
-                    const { parsed, invalid } = validateTypes(config.type, value);
-                    if (invalid.length > 0) {
-                        exit(2, `Environment ${key} expects a valid ${config.type}, but received: ${invalid.join(', ')}`);
-                    }
-                    parsedArgs[option] = parsed;
+                const config = cliArguments[option];
+                if (config.present) {
+                    parsedArgs[option] = await config.present(parsedArgs[option]);
                 }
-                else if (config.values === 'multiple') {
+                if (!config.character) {
                     const values = value.split(' ');
-                    const { parsed, invalid } = validateTypes(config.type, values);
-                    if (invalid.length > 0) {
-                        exit(2, `Environment ${key} expects a valid ${config.type}, but received: ${invalid.join(', ')}`);
+                    const validation = await config.validateValues(parsedArgs[option], values);
+                    if (!validation.valid) {
+                        const s = values.length > 1 ? 's' : '';
+                        exit(2, `Invalid value${s} for environment ${key}: ${validation.message}`);
+                        return;
                     }
-                    parsedArgs[option] = parsed;
+                    parsedArgs[option] = await config.reduceValues(parsedArgs[option], validation.value);
                 }
             }
         }
@@ -433,30 +284,6 @@ function groupArguments(args) {
     }
     return grouped;
 }
-/**
- * Validate the types of a standard argument
- *
- * @param type the type the argument accepts
- * @param values the values to validate
- * @returns an object with the invalid values and the parsed values
- */
-function validateTypes(type, values) {
-    if (type === 'string') {
-        return { invalid: [], parsed: values };
-    }
-    if (!Array.isArray(values)) {
-        const isValid = !isNaN(Number(values));
-        if (isValid) {
-            return { invalid: [], parsed: Number(values) };
-        }
-        return { invalid: [values], parsed: 0 };
-    }
-    const invalid = values.filter((v) => isNaN(Number(v)));
-    if (invalid.length > 0) {
-        return { invalid, parsed: [] };
-    }
-    return { invalid: [], parsed: values.map(Number) };
-}
 function camelToCapitalSnakeCase(input) {
     return input
         .replace(/([a-z])([A-Z])/g, '$1_$2') // Insert underscore before capital letters
@@ -468,25 +295,27 @@ function camelToKebabCase(input) {
         .toLowerCase(); // Convert to uppercase
 }
 export function printHelpContents(command, subcommands, cliOptions, additionalArgs, selectedSubcommand) {
+    const logger = additionalArgs?.consoleLogger ?? console;
     const operandsExpected = additionalArgs?.expectOperands != undefined ? additionalArgs?.expectOperands : true;
     const operandsName = additionalArgs?.operandsName ?? 'operand';
     const operandsString = operandsExpected ? ` [--] [${operandsName}1] [${operandsName}2]` : '';
-    const anyGlobalFlags = Object.values(cliOptions).some((option) => isBooleanOption(option));
+    const anyGlobalFlags = Object.values(cliOptions).some((option) => option.character);
     if (selectedSubcommand) {
-        const anyCommandFlags = Object.values(subcommands[selectedSubcommand].options).some((option) => isBooleanOption(option));
+        const anyCommandFlags = Object.values(subcommands[selectedSubcommand].arguments).some((option) => option.character);
         const flags = anyGlobalFlags || anyCommandFlags ? ' [flags]' : '';
         let usageString = `Usage: ${command} ${selectedSubcommand} [options]${flags}${operandsString}`;
         if (additionalArgs?.allowOperandsFromStdin) {
             usageString += `\n       <${operandsName}s to stdout> | ${command} ${selectedSubcommand} [options]${flags}`;
         }
-        console.log(usageString);
-        console.log(`\n${subcommands[selectedSubcommand].description}`);
-        console.log(`${selectedSubcommand} Options:`);
-        printOptions(subcommands[selectedSubcommand].options);
-        console.log('');
+        logger.log(usageString);
+        logger.log('');
+        logger.log(`${subcommands[selectedSubcommand].description}`);
+        logger.log(`${selectedSubcommand} Options:`);
+        printOptions(subcommands[selectedSubcommand].arguments, logger);
+        logger.log('');
     }
     else {
-        const anyCommandFlags = Object.values(subcommands).some((subcommand) => Object.values(subcommand.options).some((option) => isBooleanOption(option)));
+        const anyCommandFlags = Object.values(subcommands).some((subcommand) => Object.values(subcommand.arguments).some((option) => option.character));
         const flags = anyGlobalFlags || anyCommandFlags ? ' [flags]' : '';
         let singleUseString = `${command}`;
         const subcommandKeys = Object.keys(subcommands);
@@ -501,18 +330,19 @@ export function printHelpContents(command, subcommands, cliOptions, additionalAr
         if (additionalArgs?.allowOperandsFromStdin) {
             usageString += `\n       <${operandsName}s to stdout> | ${singleUseString}`;
         }
-        console.log(usageString);
+        logger.log(usageString);
         const longestCommand = subcommandKeys.reduce((acc, cmd) => Math.max(acc, cmd.length), 0);
         if (subcommandKeys.length > 0) {
-            console.log('Subcommands:');
+            logger.log('Subcommands:');
             for (const cmd of subcommandKeys) {
                 const description = subcommands[cmd].description;
-                console.log(`  ${(cmd + ':').padEnd(longestCommand + 1)} ${description}`);
+                logger.log(`  ${(cmd + ':').padEnd(longestCommand + 1)} ${description}`);
             }
-            console.log(`\n Use ${command} <subcommand> --help for more information about a subcommand`);
+            logger.log('');
+            logger.log(` Use ${command} <subcommand> --help for more information about a subcommand`);
         }
     }
-    console.log('Global Options:');
+    logger.log('Global Options:');
     const globalOptions = {
         ...cliOptions,
         ...{
@@ -526,46 +356,95 @@ export function printHelpContents(command, subcommands, cliOptions, additionalAr
             description: 'Print the version and exit'
         };
     }
-    printOptions(globalOptions);
+    printOptions(globalOptions, logger);
 }
-function printOptions(cliOptions) {
+function printOptions(cliOptions, logger) {
     const longestOption = Object.keys(cliOptions).reduce((acc, key) => Math.max(acc, camelToKebabCase(key).length + 2), 0) + 1;
     const terminalWidth = process.stdout.columns ?? 80;
     const nonBooleanBuffer = '     ';
     for (const [key, option] of Object.entries(cliOptions)) {
         let optionString = `  --${camelToKebabCase(key)}:`.padEnd(longestOption + 3);
-        if (isBooleanOption(option)) {
+        if (option.character) {
             optionString += `(-${option.character}) `;
         }
         else {
             optionString += nonBooleanBuffer;
         }
         const leftBar = optionString.length;
-        optionString += option.description + '. ';
-        if (isEnumOption(option)) {
-            if (option.values === 'single') {
-                optionString += `Must be one of: ${option.validValues.join(', ')}.`;
-            }
-            else {
-                optionString += `Valid values: ${option.validValues.join(', ')}.`;
-            }
-        }
-        else if (option.type === 'boolean') {
-            // Do nothing
-        }
-        else if (option.values === 'single') {
-            optionString += `One ${option.type} required`;
-        }
-        else if (option.values === 'multiple') {
-            optionString += `Multiple ${option.type}s allowed`;
-        }
-        console.log(optionString.slice(0, terminalWidth));
+        optionString += option.description;
+        logger.log(optionString.slice(0, terminalWidth));
         let stringToPrint = optionString.slice(terminalWidth);
         const secondLineLength = terminalWidth - leftBar;
         while (stringToPrint.length > 0) {
-            console.log(' '.repeat(leftBar) + stringToPrint.slice(0, secondLineLength));
+            logger.log(' '.repeat(leftBar) + stringToPrint.slice(0, secondLineLength).trimStart());
             stringToPrint = stringToPrint.slice(secondLineLength);
         }
     }
 }
+async function printVersion(versionInfo, logger) {
+    if (!versionInfo) {
+        logger.log('Version information not available. This is a bug.');
+        return;
+    }
+    if (typeof versionInfo === 'string') {
+        logger.log(versionInfo);
+        return;
+    }
+    let currentVersion = null;
+    if (typeof versionInfo.currentVersion === 'string') {
+        currentVersion = versionInfo.currentVersion;
+    }
+    else if (typeof versionInfo.currentVersion === 'function') {
+        currentVersion = await versionInfo.currentVersion();
+    }
+    if (!currentVersion) {
+        logger.log('Current version not available');
+        return;
+    }
+    let latestVersion = null;
+    if (typeof versionInfo.checkForUpdates == 'string') {
+        latestVersion = await getLatestVersionFromNpm(versionInfo.checkForUpdates);
+    }
+    else if (typeof versionInfo.checkForUpdates === 'function') {
+        latestVersion = await versionInfo.checkForUpdates();
+    }
+    let updateMessage = undefined;
+    if (currentVersion && latestVersion && currentVersion !== latestVersion) {
+        if (versionInfo.updateMessage) {
+            updateMessage = versionInfo.updateMessage(currentVersion, latestVersion);
+        }
+        else if (typeof versionInfo.checkForUpdates === 'string') {
+            updateMessage = `Latest: ${latestVersion}. To update run: npm update -g ${versionInfo.checkForUpdates}`;
+        }
+        else {
+            updateMessage = `Latest: ${latestVersion}.`;
+        }
+    }
+    else if (currentVersion && latestVersion && currentVersion === latestVersion) {
+        // updateMessage = 'You are using the latest version.'
+    }
+    logger.log(currentVersion);
+    if (updateMessage) {
+        logger.log(updateMessage);
+    }
+}
+/**
+ * Fetch the latest version of a package from the npm registry.
+ *
+ * @param packageName the name of the npm package to check, e.g. "my-cli-tool" or "@my-org/my-cli-tool"
+ * @returns the latest version of the package published on npm or null if any error occurs
+ */
+async function getLatestVersionFromNpm(packageName) {
+    try {
+        const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+        if (res.ok) {
+            const data = await res.json();
+            return data.version || null;
+        }
+    }
+    catch (e) {
+        // Ignore errors fetching latest version
+    }
+    return null;
+}
 //# sourceMappingURL=cli.js.map